From 595ba18b4a797a9bad9fc995efa15140b5872402 Mon Sep 17 00:00:00 2001 From: "leonteva.v" Date: Tue, 2 Apr 2024 14:29:03 +0400 Subject: [PATCH] =?UTF-8?q?2=20=D0=BB=D0=B0=D0=B1=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ProjectBattleship/AbstractStrategy.cs | 59 ++ .../ProjectBattleship/DirectionType.cs | 1 + .../ProjectBattleship/DrawingBattleship.cs | 174 +--- .../ProjectBattleship/DrawingShip.cs | 144 +++ .../ProjectBattleship/EntityBattleship.cs | 28 +- .../ProjectBattleship/EntityShip.cs | 14 + .../FormBattleship.Designer.cs | 43 +- .../ProjectBattleship/FormBattleship.cs | 89 +- .../ProjectBattleship/FormBattleship.resx | 882 +++++++++--------- .../ProjectBattleship/IMoveableObject.cs | 7 + .../ProjectBattleship/MoveToBorder.cs | 25 + .../ProjectBattleship/MoveToCenter.cs | 46 + .../ProjectBattleship/MoveableShip.cs | 42 + .../ProjectBattleship/MovementDirection.cs | 8 + .../ProjectBattleship/ObjectParameters.cs | 21 + .../ProjectBattleship/StrategyStatus.cs | 9 + 16 files changed, 972 insertions(+), 620 deletions(-) create mode 100644 ProjectBattleship/ProjectBattleship/AbstractStrategy.cs create mode 100644 ProjectBattleship/ProjectBattleship/DrawingShip.cs create mode 100644 ProjectBattleship/ProjectBattleship/EntityShip.cs create mode 100644 ProjectBattleship/ProjectBattleship/IMoveableObject.cs create mode 100644 ProjectBattleship/ProjectBattleship/MoveToBorder.cs create mode 100644 ProjectBattleship/ProjectBattleship/MoveToCenter.cs create mode 100644 ProjectBattleship/ProjectBattleship/MoveableShip.cs create mode 100644 ProjectBattleship/ProjectBattleship/MovementDirection.cs create mode 100644 ProjectBattleship/ProjectBattleship/ObjectParameters.cs create mode 100644 ProjectBattleship/ProjectBattleship/StrategyStatus.cs diff --git a/ProjectBattleship/ProjectBattleship/AbstractStrategy.cs b/ProjectBattleship/ProjectBattleship/AbstractStrategy.cs new file mode 100644 index 0000000..b9f7f86 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/AbstractStrategy.cs @@ -0,0 +1,59 @@ +using ProjectBattleship.MovementStrateg; + +namespace ProjectBattleship.MovementStrategy; +public abstract class AbstractStrategy +{ + private IMoveableObject? _moveableObject; + private StrategyStatus _state = StrategyStatus.NotInit; + protected int FieldWidth { get; private set; } + protected int FieldHeight { get; private set; } + public StrategyStatus GetStatus() { return _state; } + public void SetData(IMoveableObject moveableObject, int width, int height) + { + if (moveableObject == null) + { + _state = StrategyStatus.NotInit; + return; + } + _state = StrategyStatus.InProgress; + _moveableObject = moveableObject; + FieldWidth = width; + FieldHeight = height; + } + public void MakeStep() + { + if (_state != StrategyStatus.InProgress) + { + return; + } + if (IsTargetDestinaion()) + { + _state = StrategyStatus.Finish; + return; + } + MoveToTarget(); + } + protected bool MoveLeft() => MoveTo(MovementDirection.Left); + protected bool MoveRight() => MoveTo(MovementDirection.Right); + protected bool MoveUp() => MoveTo(MovementDirection.Up); + protected bool MoveDown() => MoveTo(MovementDirection.Down); + protected ObjectParameters? GetObjectParameters => _moveableObject?.GetObjectPosition; + protected int? GetStep() + { + if (_state != StrategyStatus.InProgress) + { + return null; + } + return _moveableObject?.GetStep; + } + protected abstract void MoveToTarget(); + protected abstract bool IsTargetDestinaion(); + private bool MoveTo(MovementDirection movementDirection) + { + if (_state != StrategyStatus.InProgress) + { + return false; + } + return _moveableObject?.TryMoveObject(movementDirection) ?? false; + } +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/DirectionType.cs b/ProjectBattleship/ProjectBattleship/DirectionType.cs index 32380cc..e6fad8c 100644 --- a/ProjectBattleship/ProjectBattleship/DirectionType.cs +++ b/ProjectBattleship/ProjectBattleship/DirectionType.cs @@ -2,6 +2,7 @@ { public enum DirectionType { + Unknow = -1, Up = 1, Down = 2, Left = 3, diff --git a/ProjectBattleship/ProjectBattleship/DrawingBattleship.cs b/ProjectBattleship/ProjectBattleship/DrawingBattleship.cs index 79ca5e4..dae9010 100644 --- a/ProjectBattleship/ProjectBattleship/DrawingBattleship.cs +++ b/ProjectBattleship/ProjectBattleship/DrawingBattleship.cs @@ -1,152 +1,42 @@ -namespace ProjectBattleship +using ProjectBattleship.Entities; + +namespace ProjectBattleship.Drawning; +public class DrawingBattleship : DrawingShip { - public class DrawingBattleship + public DrawingBattleship(int speed, double weight, Color bodyColor, Color additionalColor, bool turret, bool rocketLauncher) : base(150, 50) { - public EntityBattleship? EntityBattleship { get; private set; } - private int? _pictureWidth; - private int? _pictureHeight; - private int? _startPosX; - private int? _startPosY; - private readonly int _shipWidth = 150; - private readonly int _shipHeight = 50; - public void Init(int speed, double weight, Color bodyColor, Color additionalColor, bool turret, bool rocketLauncher) + EntityShip = new EntityBattleship(speed, weight, bodyColor, additionalColor, turret, rocketLauncher); + } + public override void DrawTransport(Graphics g) + { + if (EntityShip == null || EntityShip is not EntityBattleship battleship || !_startPosX.HasValue || !_startPosY.HasValue) { - EntityBattleship = new EntityBattleship(); - EntityBattleship.Init(speed, weight, bodyColor, additionalColor, turret, rocketLauncher); - _pictureWidth = null; - _pictureHeight = null; - _startPosX = null; - _startPosY = null; + return; } - public bool SetPictureSize(int width, int height) + Pen pen = new(Color.Black); + Brush additionalBrush = new SolidBrush(battleship.AdditionalColor); + base.DrawTransport(g); + //орудийная башня + if (battleship.Turret) { - if (width >= _shipWidth || height >= _shipHeight) - { - _pictureWidth = width; - _pictureHeight = height; - if (_startPosX != null && _startPosY != null) - { - SetPosition(_startPosX.Value, _startPosY.Value); - } - return true; - } - return false; + Point[] shield = new Point[] {new Point(_startPosX.Value + 112, _startPosY.Value + 19), new Point(_startPosX.Value + 112, _startPosY.Value + 31), + new Point(_startPosX.Value + 119, _startPosY.Value + 28), new Point(_startPosX.Value + 119, _startPosY.Value + 22)}; + g.FillPolygon(additionalBrush, shield); + g.FillRectangle(additionalBrush, _startPosX.Value + 119, _startPosY.Value + 24, 12, 2); + g.DrawPolygon(pen, shield); + g.DrawRectangle(pen, _startPosX.Value + 119, _startPosY.Value + 24, 12, 2); } - public void SetPosition(int x, int y) + //ячейки для ракет + if (battleship.RocketLauncher) { - if (!_pictureHeight.HasValue || !_pictureWidth.HasValue) - { - return; - } - if (x < 0) - { - x = 0; - } - else if (x > _pictureWidth - _shipWidth) - { - x = _pictureWidth.Value - _shipWidth; - } - if (y < 0) - { - y = 0; - } - else if (y > _pictureHeight - _shipHeight) - { - y = _pictureHeight.Value - _shipHeight; - } - _startPosX = x; - _startPosY = y; - } - public bool MoveTransport(DirectionType direction) - { - if (EntityBattleship == null || !_startPosX.HasValue || !_startPosY.HasValue) - { - return false; - } - switch (direction) - { - // Влево - case DirectionType.Left: - if (_startPosX.Value - EntityBattleship.Step > 0) - { - _startPosX -= (int)EntityBattleship.Step; - } - return true; - //Вверх - case DirectionType.Up: - if (_startPosY.Value - EntityBattleship.Step > 0) - { - _startPosY -= (int)EntityBattleship.Step; - } - return true; - //Вправо - case DirectionType.Right: - { - if (_startPosX.Value + _shipWidth + EntityBattleship.Step < _pictureWidth) - { - _startPosX += (int)EntityBattleship.Step; - } - } - return true; - //Вниз - case DirectionType.Down: - { - if (_startPosY.Value + _shipHeight + EntityBattleship.Step < _pictureHeight) - { - _startPosY += (int)EntityBattleship.Step; - } - } - return true; - default: - return false; - } - } - public void DrawTransport(Graphics g) - { - if (EntityBattleship == null || !_startPosX.HasValue || !_startPosY.HasValue) - { - return; - } - Pen pen = new(Color.Black); - Brush additionalBrush = new SolidBrush(EntityBattleship.AdditionalColor); - Brush bodyBrush = new SolidBrush(EntityBattleship.BodyColor); - //корпус - Point[] hull = new Point[] {new Point(_startPosX.Value + 5, _startPosY.Value), new Point(_startPosX.Value + 100, _startPosY.Value), - new Point(_startPosX.Value + 150, _startPosY.Value + 25), new Point(_startPosX.Value + 100, _startPosY.Value + 50), new Point(_startPosX.Value + 5, _startPosY.Value + 50)}; - g.FillPolygon(bodyBrush, hull); - g.DrawPolygon(pen, hull); - Brush brBlack = new SolidBrush(Color.Black); - g.FillRectangle(brBlack, _startPosX.Value, _startPosY.Value + 6, 5, 13); - g.FillRectangle(brBlack, _startPosX.Value, _startPosY.Value + 31, 5, 13); - //надстройки - Brush brDark = new SolidBrush(Color.DarkGray); - g.FillRectangle(brDark, _startPosX.Value + 39, _startPosY.Value + 20, 40, 10); - g.DrawRectangle(pen, _startPosX.Value + 39, _startPosY.Value + 20, 40, 10); - g.FillRectangle(brDark, _startPosX.Value + 70, _startPosY.Value + 12, 18, 26); - g.DrawRectangle(pen, _startPosX.Value + 70, _startPosY.Value + 12, 18, 26); - g.FillEllipse(brBlack, _startPosX.Value + 94, _startPosY.Value + 19, 12, 12); - //орудийная башня - if (EntityBattleship.Turret) - { - Point[] shield = new Point[] {new Point(_startPosX.Value + 112, _startPosY.Value + 19), new Point(_startPosX.Value + 112, _startPosY.Value + 31), - new Point(_startPosX.Value + 119, _startPosY.Value + 28), new Point(_startPosX.Value + 119, _startPosY.Value + 22)}; - g.FillPolygon(additionalBrush, shield); - g.FillRectangle(additionalBrush, _startPosX.Value + 119, _startPosY.Value + 24, 12, 2); - g.DrawPolygon(pen, shield); - g.DrawRectangle(pen, _startPosX.Value + 119, _startPosY.Value + 24, 12, 2); - } - //ячейки для ракет - if (EntityBattleship.RocketLauncher) - { - g.FillRectangle(additionalBrush, _startPosX.Value + 14, _startPosY.Value + 14, 10, 10); - g.FillRectangle(additionalBrush, _startPosX.Value + 26, _startPosY.Value + 14, 10, 10); - g.FillRectangle(additionalBrush, _startPosX.Value + 14, _startPosY.Value + 26, 10, 10); - g.FillRectangle(additionalBrush, _startPosX.Value + 26, _startPosY.Value + 26, 10, 10); - g.DrawRectangle(pen, _startPosX.Value + 14, _startPosY.Value + 14, 10, 10); - g.DrawRectangle(pen, _startPosX.Value + 26, _startPosY.Value + 14, 10, 10); - g.DrawRectangle(pen, _startPosX.Value + 14, _startPosY.Value + 26, 10, 10); - g.DrawRectangle(pen, _startPosX.Value + 26, _startPosY.Value + 26, 10, 10); - } + g.FillRectangle(additionalBrush, _startPosX.Value + 14, _startPosY.Value + 14, 10, 10); + g.FillRectangle(additionalBrush, _startPosX.Value + 26, _startPosY.Value + 14, 10, 10); + g.FillRectangle(additionalBrush, _startPosX.Value + 14, _startPosY.Value + 26, 10, 10); + g.FillRectangle(additionalBrush, _startPosX.Value + 26, _startPosY.Value + 26, 10, 10); + g.DrawRectangle(pen, _startPosX.Value + 14, _startPosY.Value + 14, 10, 10); + g.DrawRectangle(pen, _startPosX.Value + 26, _startPosY.Value + 14, 10, 10); + g.DrawRectangle(pen, _startPosX.Value + 14, _startPosY.Value + 26, 10, 10); + g.DrawRectangle(pen, _startPosX.Value + 26, _startPosY.Value + 26, 10, 10); } } } \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/DrawingShip.cs b/ProjectBattleship/ProjectBattleship/DrawingShip.cs new file mode 100644 index 0000000..22f85e4 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/DrawingShip.cs @@ -0,0 +1,144 @@ +using ProjectBattleship.Entities; + +namespace ProjectBattleship.Drawning; +public class DrawingShip +{ + public EntityShip? EntityShip { get; protected set; } + private int? _pictureWidth; + private int? _pictureHeight; + protected int? _startPosX; + protected int? _startPosY; + private readonly int _shipWidth = 150; + private readonly int _shipHeight = 50; + public int? GetPosX => _startPosX; + public int? GetPosY => _startPosY; + public int GetWidth => _shipWidth; + public int GetHeight => _shipHeight; + private DrawingShip() + { + _pictureWidth = null; + _pictureHeight = null; + _startPosX = null; + _startPosY = null; + } + public DrawingShip(int speed, double weight, Color bodycolor) : this() + { + EntityShip = new EntityShip(speed, weight, bodycolor); + _pictureWidth = null; + _pictureHeight = null; + _startPosX = null; + _startPosY = null; + } + protected DrawingShip(int shipWidth, int shipHeight) : this() + { + _shipWidth = shipWidth; + _shipHeight = shipHeight; + } + public bool SetPictureSize(int width, int height) + { + if (width >= _shipWidth || height >= _shipHeight) + { + _pictureWidth = width; + _pictureHeight = height; + if (_startPosX != null && _startPosY != null) + { + SetPosition(_startPosX.Value, _startPosY.Value); + } + return true; + } + return false; + } + public void SetPosition(int x, int y) + { + if (!_pictureHeight.HasValue || !_pictureWidth.HasValue) + { + return; + } + if (x < 0) + { + x = 0; + } + else if (x > _pictureWidth - _shipWidth) + { + x = _pictureWidth.Value - _shipWidth; + } + if (y < 0) + { + y = 0; + } + else if (y > _pictureHeight - _shipHeight) + { + y = _pictureHeight.Value - _shipHeight; + } + _startPosX = x; + _startPosY = y; + } + public bool MoveTransport(DirectionType direction) + { + if (EntityShip == null || !_startPosX.HasValue || !_startPosY.HasValue) + { + return false; + } + switch (direction) + { + // Влево + case DirectionType.Left: + if (_startPosX.Value - EntityShip.Step > 0) + { + _startPosX -= (int)EntityShip.Step; + } + return true; + //Вверх + case DirectionType.Up: + if (_startPosY.Value - EntityShip.Step > 0) + { + _startPosY -= (int)EntityShip.Step; + } + return true; + //Вправо + case DirectionType.Right: + { + if (_startPosX.Value + _shipWidth + EntityShip.Step < _pictureWidth) + { + _startPosX += (int)EntityShip.Step; + } + } + return true; + //Вниз + case DirectionType.Down: + { + if (_startPosY.Value + _shipHeight + EntityShip.Step < _pictureHeight) + { + _startPosY += (int)EntityShip.Step; + } + } + return true; + default: + return false; + } + } + public virtual void DrawTransport(Graphics g) + { + if (EntityShip == null || !_startPosX.HasValue || !_startPosY.HasValue) + { + return; + } + Pen pen = new(Color.Black); + Brush bodyBrush = new SolidBrush(EntityShip.BodyColor); + //корпус + Point[] hull = new Point[] {new Point(_startPosX.Value + 5, _startPosY.Value), new Point(_startPosX.Value + 100, _startPosY.Value), + new Point(_startPosX.Value + 150, _startPosY.Value + 25), new Point(_startPosX.Value + 100, _startPosY.Value + 50), new Point(_startPosX.Value + 5, _startPosY.Value + 50)}; + g.FillPolygon(bodyBrush, hull); + g.DrawPolygon(pen, hull); + Brush brBlack = new SolidBrush(Color.Black); + g.FillRectangle(brBlack, _startPosX.Value, _startPosY.Value + 6, 5, 13); + g.FillRectangle(brBlack, _startPosX.Value, _startPosY.Value + 31, 5, 13); + //надстройки + Brush brDark = new SolidBrush(Color.DarkGray); + g.FillRectangle(brDark, _startPosX.Value + 39, _startPosY.Value + 20, 40, 10); + g.DrawRectangle(pen, _startPosX.Value + 39, _startPosY.Value + 20, 40, 10); + g.FillRectangle(brDark, _startPosX.Value + 70, _startPosY.Value + 12, 18, 26); + g.DrawRectangle(pen, _startPosX.Value + 70, _startPosY.Value + 12, 18, 26); + g.FillEllipse(brBlack, _startPosX.Value + 94, _startPosY.Value + 19, 12, 12); + } +} diff --git a/ProjectBattleship/ProjectBattleship/EntityBattleship.cs b/ProjectBattleship/ProjectBattleship/EntityBattleship.cs index 70aca75..08f515b 100644 --- a/ProjectBattleship/ProjectBattleship/EntityBattleship.cs +++ b/ProjectBattleship/ProjectBattleship/EntityBattleship.cs @@ -1,22 +1,14 @@ -namespace ProjectBattleship +namespace ProjectBattleship.Entities; +public class EntityBattleship : EntityShip { - public class EntityBattleship + public Color AdditionalColor { get; private set; } + public bool Turret { get; private set; } + public bool RocketLauncher { get; private set; } + public double Step => (double)Speed * 100 / Weight; + public EntityBattleship(int speed, double weight, Color bodyColor, Color additionalColor, bool turret, bool rocketLauncher) : base(speed, weight, bodyColor) { - 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 Turret { get; private set; } - public bool RocketLauncher { get; private set; } - public double Step => (double)Speed * 100 / Weight; - public void Init(int speed, double weight, Color bodyColor, Color additionalColor, bool turret, bool rocketLauncher) - { - Speed = speed; - Weight = weight; - BodyColor = bodyColor; - AdditionalColor = additionalColor; - Turret = turret; - RocketLauncher = rocketLauncher; - } + AdditionalColor = additionalColor; + Turret = turret; + RocketLauncher = rocketLauncher; } } \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/EntityShip.cs b/ProjectBattleship/ProjectBattleship/EntityShip.cs new file mode 100644 index 0000000..8bbd131 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/EntityShip.cs @@ -0,0 +1,14 @@ +namespace ProjectBattleship.Entities; +public class EntityShip +{ + public int Speed { get; private set; } + public double Weight { get; private set; } + public Color BodyColor { get; private set; } + public double Step => Speed * 100 / Weight; + public EntityShip(int speed, double weight, Color bodyColor) + { + Speed = speed; + Weight = weight; + BodyColor = bodyColor; + } +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/FormBattleship.Designer.cs b/ProjectBattleship/ProjectBattleship/FormBattleship.Designer.cs index 6011277..a94a03e 100644 --- a/ProjectBattleship/ProjectBattleship/FormBattleship.Designer.cs +++ b/ProjectBattleship/ProjectBattleship/FormBattleship.Designer.cs @@ -35,6 +35,9 @@ buttonUp = new Button(); buttonDown = new Button(); buttonRight = new Button(); + buttonCreateShip = new Button(); + comboBoxStrategy = new ComboBox(); + buttonStrategyStep = new Button(); ((System.ComponentModel.ISupportInitialize)pictureBoxBattleship).BeginInit(); SuspendLayout(); // @@ -51,11 +54,12 @@ // // buttonCreate // + buttonCreate.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; buttonCreate.Location = new Point(38, 500); buttonCreate.Name = "buttonCreate"; buttonCreate.Size = new Size(121, 62); buttonCreate.TabIndex = 1; - buttonCreate.Text = "Создать"; + buttonCreate.Text = "Создать линкор"; buttonCreate.UseVisualStyleBackColor = true; buttonCreate.Click += buttonCreate_Click; // @@ -107,11 +111,45 @@ buttonRight.UseVisualStyleBackColor = true; buttonRight.Click += ButtonMove_Click; // + // buttonCreateShip + // + buttonCreateShip.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonCreateShip.Location = new Point(212, 500); + buttonCreateShip.Name = "buttonCreateShip"; + buttonCreateShip.Size = new Size(121, 62); + buttonCreateShip.TabIndex = 6; + buttonCreateShip.Text = "Создать корабль"; + buttonCreateShip.UseVisualStyleBackColor = true; + buttonCreateShip.Click += buttonCreateShip_Click; + // + // comboBoxStrategy + // + comboBoxStrategy.DropDownStyle = ComboBoxStyle.DropDownList; + comboBoxStrategy.FormattingEnabled = true; + comboBoxStrategy.Items.AddRange(new object[] { "К центру", "К краю" }); + comboBoxStrategy.Location = new Point(742, 24); + comboBoxStrategy.Name = "comboBoxStrategy"; + comboBoxStrategy.Size = new Size(151, 28); + comboBoxStrategy.TabIndex = 8; + // + // buttonStrategyStep + // + buttonStrategyStep.Location = new Point(799, 74); + buttonStrategyStep.Name = "buttonStrategyStep"; + buttonStrategyStep.Size = new Size(94, 29); + buttonStrategyStep.TabIndex = 10; + buttonStrategyStep.Text = "Шаг"; + buttonStrategyStep.UseVisualStyleBackColor = true; + buttonStrategyStep.Click += buttonStrategyStep_Click; + // // FormBattleship // AutoScaleDimensions = new SizeF(8F, 20F); AutoScaleMode = AutoScaleMode.Font; ClientSize = new Size(922, 598); + Controls.Add(buttonStrategyStep); + Controls.Add(comboBoxStrategy); + Controls.Add(buttonCreateShip); Controls.Add(buttonRight); Controls.Add(buttonDown); Controls.Add(buttonUp); @@ -133,5 +171,8 @@ private Button buttonUp; private Button buttonDown; private Button buttonRight; + private Button buttonCreateShip; + private ComboBox comboBoxStrategy; + private Button buttonStrategyStep; } } \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/FormBattleship.cs b/ProjectBattleship/ProjectBattleship/FormBattleship.cs index 4e1edd6..21b7422 100644 --- a/ProjectBattleship/ProjectBattleship/FormBattleship.cs +++ b/ProjectBattleship/ProjectBattleship/FormBattleship.cs @@ -1,38 +1,57 @@ -namespace ProjectBattleship +using ProjectBattleship.Drawning; +using ProjectBattleship.MovementStrategy; +using ProjectBattleship.MovementStrateg; + +namespace ProjectBattleship { public partial class FormBattleship : Form { - private DrawingBattleship? _drawingBattleship; + private DrawingShip? _drawingShip; + private AbstractStrategy? _strategy; public FormBattleship() { InitializeComponent(); + _strategy = null; } private void Draw() { - if (_drawingBattleship == null) + if (_drawingShip == null) { return; } Bitmap bmp = new Bitmap(pictureBoxBattleship.Width, pictureBoxBattleship.Height); Graphics gr = Graphics.FromImage(bmp); - _drawingBattleship.DrawTransport(gr); + _drawingShip.DrawTransport(gr); pictureBoxBattleship.Image = bmp; } - private void buttonCreate_Click(object sender, EventArgs e) + private void CreateObject(string type) { - Random random = new Random(); - _drawingBattleship = new DrawingBattleship(); - _drawingBattleship.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))); - _drawingBattleship.SetPictureSize(pictureBoxBattleship.Width, pictureBoxBattleship.Height); - _drawingBattleship.SetPosition(random.Next(10, 100), random.Next(10, 100)); + Random random = new(); + switch (type) + { + case nameof(DrawingShip): + _drawingShip = new DrawingShip(random.Next(100, 300), random.Next(1000, 3000), + Color.FromArgb(random.Next(0, 256), random.Next(0, 256), random.Next(0, 256))); + break; + case nameof(DrawingBattleship): + _drawingShip = new DrawingBattleship(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))); + break; + default: + return; + } + _drawingShip.SetPictureSize(pictureBoxBattleship.Width, pictureBoxBattleship.Height); + _drawingShip.SetPosition(random.Next(10, 100), random.Next(10, 100)); + _strategy = null; + comboBoxStrategy.Enabled = true; Draw(); } + private void buttonCreate_Click(object sender, EventArgs e) => CreateObject(nameof(DrawingBattleship)); private void ButtonMove_Click(object sender, EventArgs e) { - if (_drawingBattleship == null) + if (_drawingShip == null) { return; } @@ -42,19 +61,19 @@ { case "buttonUp": result = - _drawingBattleship.MoveTransport(DirectionType.Up); + _drawingShip.MoveTransport(DirectionType.Up); break; case "buttonDown": result = - _drawingBattleship.MoveTransport(DirectionType.Down); + _drawingShip.MoveTransport(DirectionType.Down); break; case "buttonLeft": result = - _drawingBattleship.MoveTransport(DirectionType.Left); + _drawingShip.MoveTransport(DirectionType.Left); break; case "buttonRight": result = - _drawingBattleship.MoveTransport(DirectionType.Right); + _drawingShip.MoveTransport(DirectionType.Right); break; } if (result) @@ -62,5 +81,39 @@ Draw(); } } + private void buttonCreateShip_Click(object sender, EventArgs e) => CreateObject(nameof(DrawingShip)); + private void buttonStrategyStep_Click(object sender, EventArgs e) + { + if (_drawingShip == null) + { + return; + } + if (comboBoxStrategy.Enabled) + { + _strategy = comboBoxStrategy.SelectedIndex switch + { + 0 => new MoveToCenter(), + 1 => new MoveToBorder(), + _ => null, + }; + if (_strategy == null) + { + return; + } + _strategy.SetData(new MoveableShip(_drawingShip), pictureBoxBattleship.Width, pictureBoxBattleship.Height); + } + if (_strategy == null) + { + return; + } + comboBoxStrategy.Enabled = false; + _strategy.MakeStep(); + Draw(); + if (_strategy.GetStatus() == StrategyStatus.Finish) + { + comboBoxStrategy.Enabled = true; + _strategy = null; + } + } } } diff --git a/ProjectBattleship/ProjectBattleship/FormBattleship.resx b/ProjectBattleship/ProjectBattleship/FormBattleship.resx index ff5cab1..1bd4ba6 100644 --- a/ProjectBattleship/ProjectBattleship/FormBattleship.resx +++ b/ProjectBattleship/ProjectBattleship/FormBattleship.resx @@ -121,7 +121,7 @@ iVBORw0KGgoAAAANSUhEUgAAB44AAAOdCAYAAAB6bE8jAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO - wwAADsMBx2+oZAAAahtJREFUeF7s3V+MnXW99/0JIcYQY2rtXH/X/Ok4ljKdmc4MxhBjjDHGGLNjdnY8 + wAAADsABataJCQAAahtJREFUeF7s3V+MnXW99/0JIcYQY2rtXH/X/Ok4ljKdmc4MxhBjjDHGGLNjdnY8 eA7u7EMOnoN9SO4z4iGHHvbANO261hQGEbACKmI3GCKGiOE2hJjG26cCIgICYsFSy/VcA617XOsH9M/M rN+11uudvA7uvRWms9a6muxPvveakCRJktrQ8TSdvX1i4rqL/09JkiRJkiRJkiRJ0jjVy8pvVWnx6sbC wscu/o8kSZIkSZIkSZIkSePQepIkvbS4t0qLepPhWJIkSZIkSZIkSZLGqItXxi9fGo0Nx5IkSZIkSZIk @@ -580,7 +580,7 @@ iVBORw0KGgoAAAANSUhEUgAAA50AAAeOCAYAAAB3IVJsAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO - wwAADsMBx2+oZAAAg6NJREFUeF7s/V2MZXWd939XiCGGGINM135Ye9cDbdk0/VBdVZiJMcaYiTHGTIwx + wAAADsABataJCQAAg6NJREFUeF7s/V2MZXWd939XiCGGGINM135Ye9cDbdk0/VBdVZiJMcaYiTHGTIwx HvwPJnPIwX0wh+Q6I3PI4Rz2gSHdu3Y1FCIiAiJiD0yIGCOGvyHEEC//LSIiICA22LTNvtfuXjOjmx9N P6z1++29f6938sqd+3/NKHRX7bU+yffa14IkSbq8RtX/ryRJkiRJtTZoF//Pdqf4/1X/fyVJkiRJqqdj 3e7ydrt4rfTWYM9Kp/r/LEmSJEnS1XX7wsI15dh8tDSq3F/9H0mSJEmSdHUNO8VtfzM4zxt2et+o/o8l @@ -1148,7 +1148,7 @@ iVBORw0KGgoAAAANSUhEUgAAA50AAAeOCAYAAAB3IVJsAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO - wwAADsMBx2+oZAAAgjRJREFUeF7s3F+MZQWZ7/0KIYYYQ5Dp3n/W3lVdtG3T9J/qqsJMjDHGTIwxZmIm + wAAADsABataJCQAAgjRJREFUeF7s3F+MZQWZ7/0KIYYYQ5Dp3n/W3lVdtG3T9J/qqsJMjDHGTIwxZmIm Ey8n55LLuSTnzswll3PZF4bQu3Y1FiIiAiI6DEyIGiMTX0OMIRyDioiIDSK00Db73dWsmXF2LxvoXms9 u/bz+Safq/e8R4WqtdYv50ktSZIkSZIkaY7b6g7+bqs3+CIAsCh6nytf85IkxbfVKX601S0mAMCiGDxb vuYlSYrP6ASARWN0SpLmKKMTABaN0SlJmqOMTgBYNEanJGmOMjoBYNEYnZKkOcroBIBFY3RKkuYooxMA @@ -1709,444 +1709,444 @@ - iVBORw0KGgoAAAANSUhEUgAAB44AAAOdCAYAAAB6bE8jAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 - YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAGYuSURBVHhe7N1djJ11vff/CSHEEGOwzqx1Pax56DC2ZR7X - rJodYwwxxhhjjDHGg//Bzj7k4H/gIdlnxEMOPeyBado1awpTCkKFCogVDBFDxHCThpiG238FrJWHgqXU - trbXf9b0V0G9Cp12ZtbvWuv1Tl4H973d0M6sa+1kf/Ld15AkSZIkSZIkSZIkSZIkSZIkSZI2uPuGhm7Z - X69PhP+nJEmSJEmSJEmSJGnQWpmevm2pnp3rJNm9K0NDt4T/b0mSJEmSJEmSJEnSoBSG4yJ4ft9wviP8 - lyRJkiRJkiRJkiRJg9C/Dcdda9fH3f8T1uE/IkmSJEmSJEmSJEnq50qG4zXtJPt1e6QxFf5jkiRJkiRJ - kiRJkqR+7VrDcXC2XU9/WIT/rCRJkiRJkiRJkiSpD/uU4fiqJw9kWSP8t0iSJEmSJEmSJEmS+qnrHI67 - 3u/U0nvCf5skSZIkSZIkSZIkqV9ax3B8RZIdWcpz18eSJEmSJEmSJEmS1C+tezi+4rTrY0mSJEmSJEmS - JEnqk25wOF7TrqePHxgezcI/SpIkSZIkSZIkSZJUxW5mOA6618f/Hf5xkiRJkiRJkiRJkqSqtQHD8RW1 - bN/eOybuCP9YSZIkSZIkSZIkSVJV2rDh+IpTnVr6/fCPliRJkiRJkiRJkiRVoQ0ejq86uC/Pt4V/hSRJ - kiRJkiRJkiQp5jZpOO461a5l3wv/GkmSJEmSJEmSJElSrG3icHzVwZVGw/WxJEmSJEmSJEmSJMXaFgzH - XSfb9ey74V8pSZIkSZIkSZIkSYqpLRqOrzrYGRu7I/yrJUmSJEmSJEmSJEkxtMXDcdeJTi37RvjXS5Ik - SZIkSZIkSZJ6XQ+G4zXter7nJ8PDnw1/DEmSJEmSJEmSJElSr+rVcLymlv1huZZ/OfxRJEmSJEmSJEmS - JEm9qKfDcdC9Pl4ZGXF9LEmSJEmSJEmSJEm9KIbhOPhjO2l8LfyxJEmSJEmSJEmSJElbVUTD8Zru9fH+ - ev328MeTJEmSJEmSJEmSJG12sQ3HV+SvddL07vBHlCRJkiRJkiRJkiRtZnEOx2suda+P92SZ62NJkiRJ - kiRJkiRJ2swiHo6vOraUJF8Kf1xJkiRJkiRJkiRJ0kZXgeG462K7lt3/xNTUbeGPLUmSJEmSJEmSJEna - qCoyHF91bH+auj6WJEmSJEmSJEmSpI2sYsNx0a5n55fq6f+uDA3dEv4KkiRJkiRJkiRJkqSbqWrD8UfS - V9pp2gp/DUmSJEmSJEmSJEnSjVbd4XjN2ruPu3+H8NeRJEmSJEmSJEmSJK23ig/Ha9r17OXOSN4MfyVJ - kiRJkiRJkiRJ0nrqh+E4uNhOsh9597EkSZIkSZIkSZIkrbM+Go6D9Lf703RX+OtJkiRJkiRJkiRJkj6t - /huO15zrJNm9ro8lSZIkSZIkSZIk6Trq0+H4qt+0s2xH+KtKkiRJkiRJkiRJksrq8+G4a+36+D7Xx5Ik - SZIkSZIkSZJU3gAMx1c93xlpTIW/tiRJkiRJkiRJkiTpagM0HHe5PpYkSZIkSZIkSZKkf2/AhuM17ST7 - ddv1sSRJkiRJkiRJkiRdaTOH41d37ipWkrz0vxaB051a+t/hxyBJkiRJkiRJkiRJg9tmDsd/X1wszq16 - bvudpf/1SDx5IMsa4cchSZIkSZIkSZIkSYPXZg/Hxe7da05MzxQH00bpfy4C73dq6T1F+JlIkiRJkiRJ - kiRJ0kC1VcNx17lms3h2YrL0PxuFJHtyKc9dH0uSJEmSJEmSJEkarLZyOL4q7uvjdO36OPx4JEmSJEmS - JEmSJKn/68Vw3PVhs1n8KuLr43Y9fXzfFxpZ+DFJkiRJkiRJkiRJUv/Wq+H4qu718Uq87z4+7fpYkiRJ - kiRJkiRJUt/X6+G468PmYnF0fHvpPyMShw8Mj7o+liRJkiRJkiRJktSfxTAcX/XaruniwUivj9v17K2l - JP9B+LFJkiRJkiRJkiRJUv8U03Dc9UGzWfxibKL0nxeJg8tZNhx+fJIkSZIkSZIkSZJU/WIbjq86vuuu - 4oEkL/3nRuBUp5Z+P/wIJUmSJEmSJEmSJKnaxTocd3Wvj5+O/Pp4X55vCz9KSZIkSZIkSZIkSapmMQ/H - V0V+fXyyU8++G36ckiRJkiRJkiRJklS9qjAcd51ZWCieGtte+u+JxMGVRsP1sSRJkiRJkiRJkqTqVZXh - +KrYr4+X69l3wo9WkiRJkiRJkiRJkqpR1YbjrjMLzeKp0YjffZzk7Z8MD382/IglSZIkSZIkSZIkKe6q - OBx3XW61imM7dhbLJf/eSJzo1LJvhB+zJEmSJEmSJEmSJMVbVYfjq96bny+ORHx93K7ne1ZGRlwfS5Ik - SZIkSZIkSYq3qg/HXRW4Pv5jJ8m/Fn7kkiRJkiRJkiRJkhRX/TAcX3V6fr54ojFe+meJgetjSZIkSZIk - SZIkSVHWT8NxVxWuj5eT5O7w45ckSZIkSZIkSZKk3tdvw/FVp+cXisdH474+3l+v3x5+DZIkSZIkSZIk - SZLUu/p1OO661Np95fo4Kf/z9Vq7nr3WSVPXx5IkSZIkSZIkSZJ6Wz8Px1e9270+boyV/hkjcGnVj5+Y - mrot/EokSZIkSZIkSZIkaWsbhOG46x+tVvHS1I6ik+Slf9YIHFtKki+FX4skSZIkSZIkSZIkbV2DMhxf - 9dbcfPFYHu318cV2Lbvf9bEkSZIkSZIkSZKkLW3QhuOu+K+P81c6adoKvyJJkiRJkiRJkiRJ2twGcTi+ - au36ON53H69dH3d/P+FXJUmSJEmSJEmSJEmb0yAPx13/vD4u+fPHIX3lwEjWDL8uSZIkSZIkSZIkSdr4 - Bn04vuqvs3PFo/lo6d8jAmvXx3uGdt8afm2SJEmSJEmSJEmStHEZjj9yMfrr4+zlzkju+liSJEmSJEmS - JEnSxmY4/k9/npktHsmivT4+10mye1eGhm4Jv0JJkiRJkiRJkiRJurkMx+UurP7ZX5icKv17xSH97XKW - 7Qq/RkmSJEmSJEmSJEm68QzHn6x7ffyw62NJkiRJkiRJkiRJ/Zzh+NNdWGxFfn2c/aadZTvCr1SSJEmS - JEmSJEmS1pfh+Pq9OTNTPJw1Sv+uEVi7Pr7P9bEkSZIkSZIkSZKk9WY4Xp/z8V8fP98ZaUyFX68kSZIk - SZIkSZIkfXqG4xvzxsxscSje6+Ozro8lSZIkSZIkSZIkXXeG4xt3vtUqno/7+vjpfWk6Fn7VkiRJkiRJ - kiRJklSe4fjmnZieKQ6m0V4fv9+ppfcU4fctSZIkSZIkSZIkSf+R4XhjnFv9uz63/c7Sn0MknjyQZY3w - a5ckSZIkSZIkSZKkjzIcb6y4r4/Ttevj8KuXJEmSJEmSJEmSpCsZjjfeuWazeHZisvRnEoUkO7KU566P - JUmSJEmSJEmSJF3JcLx5utfHK/G++/i062NJkiRJkiRJkiRJaxmON9eHzWbxq4ivj9v19PEDw6NZ+DhI - kiRJkiRJkiRJGsQMx1tj7fo4yUt/ThFwfSxJkiRJkiRJkiQNcobjrfNhc7E4Or699GcViYMrSTIcPhqS - JEmSJEmSJEmSBiXD8dY7vuuu4sF43318ql1Lvx8+HpIkSZIkSZIkSZIGIcNxb3zQbBa/GJso/blF4uBy - lrk+liRJkiRJkiRJkgYhw3Fvda+PH4j33cenlmrp98JHRZIkSZIkSZIkSVK/ZjjuvTMLC8XTkV8f78vz - beEjI0mSJEmSJEmSJKnfMhzHI/Lr45Odevbd8LGRJEmSJEmSJEmS1E8ZjuPSvT5+ajTu6+PO2Ngd4eMj - SZIkSZIkSZIkqR8yHMfn8qrYr4+X6vl3wkdIkiRJkiRJkiRJUtUzHMfrvYWF4sjoeOnPNgbter7nJ8PD - nw0fJUmSJEmSJEmSJElVzXAct8utVnFsx85iueTnG4kTS/X86+HjJEmSJEmSJEmSJKmKGY6r4b35+eJI - I+7r45WREdfHkiRJkiRJkiRJUhUzHFdHBa6P/9hJ8q+Fj5YkSZIkSZIkSZKkqmQ4rp7T8wvFE5FfH++v - 128PHzFJkiRJkiRJkiRJsWc4rqb4r4/z15aT5O7wMZMkSZIkSZIkSZIUc4bjauteHz8+Gu318aXu9fGe - LHN9LEmSJEmSJEmSJMWc4bj6LrV2X7k+Tsp/D73WrmevtdP0q+EjJ0mSJEmSJEmSJCm2DMf94+25+eJw - Plb6u4jAxXYtu/+JqanbwkdPkiRJkiRJkiRJUiwZjvvLP1qt4qWpHUUnyUt/JxE4tj9NvxQ+fpIkSZIk - SZIkSZJiyHDcn96amy8ei/z6uPvZCx9DSZIkSZIkSZIkSb3McNy//nl9XPK7iUP+SjtNW+GjKEmSJEmS - JEmSJKlXGY77319n54rHGq6PJUmSJEmSJEmSJF0jw/FgiP36uF3PXj4wkjXDx1KSJEmSJEmSJEnSVmY4 - Hizd6+NH89HS31cE1q6P9wztvjV8PCVJkiRJkiRJkiRtRYbjwXOx1SpevPOLpb+zOKS/3Z+mu8JHVJIk - SZIkSZIkSdJmZzgeXH+emS0eyaK9Pj7XSbJ7V4aGbgkfVUmSJEmSJEmSJEmbleF4sF1Y/R29MDlV+vuL - xG+Ws8z1sSRJkiRJkiRJkrSZGY7p6l4fP+z6WJIkSZIkSZIkSRrMDMdcdWGxFfv18fP7hvMd4aMrSZIk - SZIkSZIkaaMyHPPv3pyZKR7OGqW/0wisXR/f5/pYkiRJkiRJkiRJ2rgMx5Q5X4Hr4/ZIYyp8jCVJkiRJ - kiRJkiTdTIZjPskbM7PFoXivj8+26+kPi/BZliRJkiRJkiRJknSDGY75NN3f43MTk6W/4xh06tnT+9J0 - LHykJUmSJEmSJEmSJK03wzHX68T0THEwjfb6+P1OLb3H9bEkSZIkSZIkSZJ0AxmOWY9zq7/TZyO+Pl5K - sieX8rwRPt6SJEmSJEmSJEmSrifDMTci7uvjdO36OHzEJUmSJEmSJEmSJH1ahmNu1LlmM+7r41p+ZN8X - Gln4qEuSJEmSJEmSJEm6VoZjblb3+ngl3ncfn3Z9LEmSJEmSJEmSJH1KhmM2wofNZnF0fHvp5yASjx8Y - HnV9LEmSJEmSJEmSJJVlOGYjrV0fJ3np5yEC3evj/w4ffUmSJEmSJEmSJElXMxyz0T5oNotfxH19fHA5 - y4bDIyBJkiRJkiRJkiTJcMxmOb7rruLBeN99fKpTS78fHgNJkiRJkiRJkiRpsDMcs5nWro/HJko/H5E4 - uC/Pt4XHQZIkSZIkSZIkSRrMDMdshe718QPxvvv4VLuWfS88EpIkSZIkSZIkSdLgZThmq5xZWCiejvz6 - eKXRcH0sSZIkSZIkSZKkwctwzFaL/Pr4ZLuefTc8HpIkSZIkSZIkSdJgZDimF84sNIunRuO+Pu6Mjd0R - HhNJkiRJkiRJkiSpvzMc0yuXV726c1exXPLZicSJTi37RnhUJEmSJEmSJEmSpP7NcEyvvbewUByJ+Pq4 - Xc/3/GR4+LPhkZEkSZIkSZIkSZL6L8MxMbjcahXHduyM+fr4j/vr+dfDYyNJkiRJkiRJkiT1V4ZjYnJ6 - fr54ojFe+nmKQff6eGVkxPWxJEmSJEmSJEmS+ivDMbGpwvVxO2l8LTxCkiRJkiRJkiRJUvUzHBOr0/ML - xeOjcV8f76/Xbw+PkiRJkiRJkiRJklTdDMfE7FJr95Xr46T8M9Z7+WudNL07PE6SJEmSJEmSJElSNTMc - UwXvxn19fGnVj/dOTHwmPFaSJEmSJEmSJElStTIcUxX/aLWKl6Z2FJ0kL/28ReDYUpJ8KTxakiRJkiRJ - kiRJUnUyHFM1b83NF4/lY6WfuQhcbNey+5+YmrotPGKSJEmSJEmSJElS/BmOqaIqXB/vT1PXx5IkSZIk - SZIkSapGhmOqrArXx91nLDxukiRJkiRJkiRJUpwZjqm6f14fl3wG45C+0k7TVnjkJEmSJEmSJEmSpPgy - HNMv/jo7Vzyaj5Z+FiPg+liSJEmSJEmSJEnxZjimn1yM/Pq4Xc9e7ozkzfD4SZIkSZIkSZIkSXFkOKYf - nZqL/Po4yX60MjR0S3gMJUmSJEmSJEmSpN5mOKZfXVj9/L0wOVX62YxD+tvlLNsVHkVJkiRJkiRJkiSp - dxmO6Xd/npktHs6ivT4+10mye10fS5IkSZIkSZIkqacZjhkEFxZbkV8fZ79pZ9mO8FhKkiRJkiRJkiRJ - W5vhmEHyZgWuj+9zfSxJkiRJkiRJkqStznDMoKnA9fHznZHGVHhEJUmSJEmSJEmSpM3PcMyg6l4fH8oa - pZ/dCLg+liRJkiRJkiRJ0tZlOGaQnY/8+ridZL9uuz6WJEmSJEmSJEnSZmc4ht3FiemZ4mAa7fXx+51a - ek8RnllJkiRJkiRJkiRpwzMcwxXnVj+vz22/s/SzHIknD2RZIzy6kiRJkiRJkiRJ0sZlOIZ/5fpYkiRJ - kiRJkiRJA5fhGP7TuWazeHZisvRzHYUkO7KU566PJUmSJEmSJEmStDEZjuHa4r4+Tteuj8OjLEmSJEmS - JEmSJN14hmP4ZB82m8WvIr4+btfTx/d9oZGFR1qSJEmSJEmSJElaf4ZjuD7d6+OVeN99fNr1sSRJkiRJ - kiRJkm44wzFcvw+bi8XR8e2ln/dIHD4wPOr6WJIkSZIkSZIkSevLcAzr99qu6eLBSK+P2/XsraUk/0F4 - xCVJkiRJkiRJkqRPz3AMN+aDZrP4xdhE6Wc/EgeXs2w4POqSJEmSJEmSJEnStTMcw805vuuu4oEkL30G - InCqU0u/Hx53SZIkSZIkSZIkqTzDMdy87vXx05FfH+/L823hsZckSZIkSZIkSZL+NcMxbJzIr49PdurZ - d8OjL0mSJEmSJEmSJH2U4Rg21pmFheKpse2lz0QkDq40Gq6PJUmSJEmSJEmS9FGGY9gcsV8fL9ez74Sv - AUmSJEmSJEmSJA16hmPYPGcWmsVToxG/+zjJ2z8ZHv5s+DqQJEmSJEmSJEnSoGY4hs11udUqju3YWSyX - PCORONGpZd8IXwmSJEmSJEmSJEkaxAzHsDXem58vjkR8fdyu53tWRkZcH0uSJEmSJEmSJA1ihmPYOhW4 - Pv5jJ8m/Fr4eJEmSJEmSJEmSNCgZjmHrnZ6fL55ojJc+NzFwfSxJkiRJkiRJkjRgGY6hN6pwfbycJHeH - rwpJkiRJkiRJkiT1c4Zj6K3T8wvF46NxXx/vr9dvD18ZkiRJkiRJkiRJ6scMx9B7l1q7r1wfJ+XPUq+1 - 69lrnTR1fSxJkiRJkiRJktSvGY4hHm/PzReH87HS5ykCl1b9+ImpqdvC14ckSZIkSZIkSZL6JcMxxOUf - rVbx0tSOopPkpc9VBI4tJcmXwleIJEmSJEmSJEmS+iHDMcTprbn54rF4r48vtmvZ/a6PJUmSJEmSJEmS - +iTDMcQr/uvj/JVOmrbC14kkSZIkSZIkSZKqmuEY4vfX2bnisUbc18fd75LwtSJJkiRJkiRJkqSqZTiG - avjn9XHJsxaH9JUDI1kzfLVIkiRJkiRJkiSpShmOoVq618eP5qOlz1wE1q6P9wztvjV8xUiSJEmSJEmS - JKkKGY6hei5Gf32cvdwZyV0fS5IkSZIkSZIkVSXDMVTXn2dmi0eyaK+Pz3WS7N6VoaFbwteNJEmSJEmS - JEmSYs1wDNV2YfU5e2FyqvQZjMRvlrNsV/jKkSRJkiRJkiRJUowZjqE/dK+PH3Z9LEmSJEmSJEmSpBvJ - cAz948JiK/rr433D+Y7w9SNJkiRJkiRJkqRYMhxD/3lzZqZ4OGuUPpcRWLs+vs/1sSRJkiRJkiRJUjwZ - jqE/nY//+vj5zkhjKnwVSZIkSZIkSZIkqZcZjqG/vTEzWxyK9/r4rOtjSZIkSZIkSZKkCDIcQ/8732oV - z8d9ffz0vjQdC19LkiRJkiRJkiRJ2uoMxzA4TkzPFAfTaK+P3+/U0nuK8N0kSZIkSZIkSZKkLcxwDIPl - 3Opz+dz2O0uf2Ug8eSDLGuErSpIkSZIkSZIkSVuR4RgGU9zXx+na9XH4mpIkSZIkSZIkSdJmZziGwXWu - 2SyenZgsfX6jkGRHlvLc9bEkSZIkSZIkSdJmZzgGutfHK/G++/i062NJkiRJkiRJkqRNznAMdH3YbBa/ - ivj6uF1PHz8wPJqFry5JkiRJkiRJkiRtZIZj4OPWro+TvPSZjoDrY0mSJEmSJEmSpM3IcAz8uw+bi8XR - 8e2lz3UkDq4kyXD4GpMkSZIkSZIkSdLNZjgGruX4rruKB+N99/Gpdi39fvgqkyRJkiRJkiRJ0s1kOAY+ - yQfNZvGLsYnSZzwSB5ezzPWxJEmSJEmSJEnSzWQ4Bq5H9/r4gXjffXxqqZZ+L3ytSZIkSZIkSZIkab0Z - joHrdWZhoXg68uvjfXm+LXy9SZIkSZIkSZIk6XozHAPrFfn18clOPftu+IqTJEmSJEmSJEnS9WQ4Bm5E - 9/r4qdG4r487Y2N3hK86SVK/tZQk31qq568BAAAAABsl++O/jS0bxnAM/e1Sa3fxf764s1hOyr8Deq1d - z17rpOndYWKQJPVTS0n+g7IvfwAAAAAgPoZjGAzvLSwUR0bHS78HYtCu53t+Mjz82TA1SJL6IcMxAAAA - AFSH4RgGx+VWqzi2Y2exXPJdEIkTS/X862FukCRVPcMxAAAAAFSH4RgGz3vz88WRRtzXxysjI66PJanq - GY4BAAAAoDoMxzCYKnB9/MdOkn8tTA+SpCpmOAYAAACA6jAcw2A7Pb9QPBH59fH+ev32MEFIkqqU4RgA - AAAAqsNwDMR/fZy/tpwkd4cZQpJUlQzHAAAAAFAdhmPgqu718eOj0V4fX+peH+/JMtfHklSVDMcAAAAA - UB2GY+DjLrV2X7k+Tsq/M3qtXc9ea6fpV8MkIUmKOcMxAAAAAFSH4Rgo8/bcfHE4Hyv93ojAxXYtu/+J - qanbwjQhSYoxwzEAAAAAVIfhGLiWf7RaxUtTO4pOkpd+f0Tg2P40/VKYJyRJsWU4BgAAAIDqMBwDn+bk - 7FzxSDZa+h3Sa+16dn6pnv7v0aGhW8NMIUmKJcMxAAAAAFSH4Ri4Hv+8Pi75HolD/ko7TVthqpAkxZDh - GAAAAACqw3AMrMdfZ+eKxxpxv/t4ZXrau48lKYYMxwAAAABQHYZjYL1ivz5u17OXD4xkzTBbSJJ6leEY - AAAAAKrDcAzcqO718aN5nO8+XrV2fbxnaLd3H0tSrzIcAwAAAEB1GI6Bm3Gx1SpevPOLpd8vcUh/uz9N - d4UJQ5K0lRmOAQAAAKA6DMfARvjzzGzxcBbt9fG5TpLduzI0dEuYMiRJW5HhGAAAAACqw3AMbJQLq98n - L0xOlX7XROI3y1nm+liStirDMQAAAABUh+EY2GiujyVJaxmOAQAAAKA6DMfAZriw2Ir9+vj5fcP5jjBt - SJI2I8MxAAAAAFSH4RjYTG+uXR83Sr9/IrB2fXyf62NJ2pw2azg+nI8VJ1f/BwwAAAAAsHEutcrHHoCN - cq7ZLJ6dmCz93/1HoZYf2feFRhZmDknSRrVZw/GTYxOl/wMHAAAAAACI3xszs8WheK+Pz7br6Q+LsHVI - kjYgwzEAAAAAAFCm+38e/7mIr4879ezpfWk6FiYPSdLNZDgGAAAAAAA+yYnpmeJgGu318fudWnqP62NJ - uskMxwAAAAAAwKc5t7gY97uPk+zJpTxvhPlDkrTeDMcAAAAAAMD1ivv6OF27Pg4TiCRpPRmOAQAAAACA - 9TjXbMZ9fVzLj+z7QiMLU4gk6XoyHAMAAAAAADeie328Eu+7j0+7PpakdWQ4BgAAAAAAbtSHzcXi6Pj2 - 0q0gEo8fGB51fSxJn5bhGAAAAAAAuFlr18dJXroZRKB7ffzfYRqRJJVlOAYAAAAAADbCB81m8Yu4r48P - LmfZcJhIJEkfz3AMAAAAAABspOO77ioejPfdx6c6tfT7YSaRJF3NcAwAAAAAAGy0tevjsYnSDSESB/fl - +bYwl0iSDMcAAAAAAMBm6V4fPxDvu49PtWvZ98JkIkmDneEYAAAAAADYTGcWFoqnI78+Xmk0XB9LGuwM - xwAAAAAAwFaI/Pr4ZLuefTfMJ5I0eBmOAQAAAACArXJmoVk8NRr39XFnbOyOMKNI0uBkOAYAAAAAALbS - 5VWv7txVLJfsC5E40all3whTiiQNRoZjAAAAAACgF95bWCiORHx93K7ne34yPPzZMKlIUn9nOAYAAAAA - AHrlcqtVHNuxM+br4z/ur+dfD7OKJPVvhmMAAAAAAKDXTs/PF080xks3hxh0r49XRkZcH0vq3wzHAAAA - AABADKpwfdxOGl8LE4sk9VeGYwAAAAAAICan5xeKx0fjvj7eX6/fHqYWSeqPDMcAAAAAAEBsLrV2X7k+ - Tsp3iN7LX+uk6d1hbpGk6mc4BgAAAAAAYvVu3NfHl1b9eO/ExGfC7CJJ1c1wDAAAAAAAxOwfrVbx0tSO - opPkpZtEBI4tJcmXwvQiSdXMcAwAAAAAAFTBW3PzxWP5WOkuEYGL7Vp2/xNTU7eFCUaSqpXhGAAAAAAA - qIoqXB/vT1PXx5Kql+EYAAAAAAComipcH69MT7s+llSdDMcAAAAAAEAV/fP6uGSniEP6SjtNW2GSkaS4 - MxwDAAAAAABV9tfZueLRfLR0r4iA62NJ1chwDAAAAAAAVN3FyK+P2/Xs5c5I3gzzjCTFl+EYAAAAAADo - F6fmIr8+TrIfrQwN3RJmGkmKJ8MxAAAAAADQTy4sLhYvTE6V7hdxSH+7nGW7wlQjSXFkOAYAAAAAAPrR - n2dmi4ezaK+Pz3WS7F7Xx5KiyXAMAAAAAAD0qwuLrcivj7PftLNsR5htJKl3GY4BAAAAAIB+92YFro/v - c30sqZcZjgEAAAAAgEFQgevj5zsjjakw4UjS1mY4BgAAAAAABkn3+vhQ1ijdNyLg+lhSbzIcAwAAAAAA - g+Z85NfH7ST7ddv1saStzHAMAAAAAAAMqhPTM8XBNNrr4/c7tfSeImw6krSpGY4BAAAAAIBBdm5xsXhu - +52le0cknjyQZY0w7UjS5mQ4BgAAAAAAcH0sacAzHAMAAAAAAFxxrtksnp2YLN0+opBkR5by3PWxpI3P - cAwAAAAAAPCv4r4+Tteuj8PUI0kbk+EYAAAAAADgP33YbBa/ivj6uF1PH9/3hUYWJh9JurkMxwAAAAAA - ANfWvT5eiffdx6ddH0vakAzHAAAAAAAAn+zD5mJxdHx76SYSicMHhkddH0u68QzHAAAAAAAA1+e1XdPF - g5FeH7fr2Vvd3SdMQJK0vgzHAAAAAAAA1++DZrP4xdhE6T4SiYPLWTYcpiBJur4MxwAAAAAAAOt3fNdd - xQNJXrqTRODUUi39XpiDJOnTMxwDAAAAAADcmO718dORXx/vy/NtYRaSpGtnOAYAAAAAALg5kV8fn+zU - s++GaUiSyjMcAwAAAAAA3LwzCwvFU2PbS3eTSBxcaTRcH0sqz3AMAAAAAACwcWK/Pl6uZ98JM5EkfZTh - GAAAAAAAYGOdWWgWT41G/O7jJG//ZHj4s2EukiTDMQAAAAAAwGa43GoVx3bsLJZLdpRInFiq518Pk5Gk - Qc9wDAAAAAAAsHnem58vjjTGS/eUGLTr+Z6VkRHXx9KgZzgGAAAAAADYXBW4Pv5jJ8m/FuYjSYOY4RgA - AAAAAGBrnJ6fL55wfSwpxgzHAAAAAAAAWyf+6+P8teUkuTtMSZIGJcMxAAAAAADA1js9v1A8Phr39fH+ - ev32MClJ6vcMxwAAAAAAAL1xqbX7yvVxUr639Fq7nr3WTtOvhllJUj9nOAYAAAAAAOitt+fmi8P5WOnm - EoFL7Vp2/xNTU7eFeUlSP2Y4BgAAAAAA6L1/tFrFS1M7ik6Sl24vETi2lCRfChOTpH7LcAwAAAAAABCP - t+bmi8fivT6+6PpY6tMMxwAAAAAAAHGJ//o4f6WTpq0wN0nqhwzHAAAAAAAAcfrr7FzxWCPu6+OV6WnX - x1I/ZDgGAAAAAACI1z+vj0v2mDikrxwYyZphepJU1QzHAAAAAAAA8eteHz+aj5buMhFYuz7eM7T71jBB - SapahmMAAAAAAIBquBj99XH2cmckd30sVTHDMQAAAAAAQLX8eWa2eCSL9vr4XCfJ7l0ZGrolzFGSqpDh - GAAAAAAAoHouLC4WL0xOle40kfjNcpbtCpOUpNgzHAMAAAAAAFRX9/r4YdfHkm42wzEAAAAAAEC1XVhs - RX99vG843xHmKUkxZjgGAAAAAADoD2/OzBQPZ43S7SYCa9fH97k+luLMcAwAAAAAANA/zsd/ffx8Z6Qx - FaYqSbFkOAYAAAAAAOg/b8zMFofivT4+6/pYiizDMQAAAAAAQH8632oVz8d9ffz0vjQdC7OVpF5mOAYA - AAAAAOhvJ6ZnioNptNfH73dq6T1F2K4k9SjDMQAAAAAAQP87t7hYPLf9ztJdJxJPHsiyRpiwJG11hmMA - AAAAAIDBEff1cbp2fRxmLElbmeEYAAAAAABgsJxrNotnJyZLN54oJNmRpTx3fSxtZYZjAAAAAACAwdS9 - Pl6J993Hp10fS1uY4RgAAAAAAGBwfdhsFr+K+Pq4XU8fPzA8moVpS9JmZTgGAAAAAABg7fo4yUt3nwi4 - PpY2O8MxAAAAAAAAXR80m8UvxreXbj+ROLiSJMNh5pK0kRmOAQAAAAAA+Ljju+4qHoz33cen2rX0+2Hq - krRRGY4BAAAAAAD4d2vXx2MTpTtQJA4uZ5nrY2mjMhwDAAAAAABwLd3r4wfifffxqaVa+r0we0m6mQzH - AAAAAAAAfJIzCwvF05FfH+/L821h/pJ0IxmOAQAAAAAAuB6RXx+f7NSz74YJTNJ6MxwDAAAAAABwvbrX - x0+Nxn193BkbuyNMYZKuN8MxAAAAAAAA63F5VezXx0v1/DthDpN0PRmOAQAAAAAAuBHvLSwUR0bHS7ei - GLTr+Z6fDA9/Nsxikj4pwzEAAAAAAAA36nKrVRzbsbNYLtmLInFiqZ5/PUxjkq6V4RgAAAAAAICb9d78 - fHGkEff18crIiOtj6VoZjgEAAAAAANgIFbg+/mMnyb8WZjJJH89wDAAAAAAAwEY6Pb9QPBH59fH+ev32 - MJdJ6mY4BgAAAAAAYKNdau2O/Po4f205Se4Ok5kkwzEAAAAAAACbpXt9/PhotNfHl7rXx3uyzPWxZDgG - AAAAAABgM3Wvj1/+4o6ik+Slu1IEXu0kjf8K85k0mBmOAQAAAAAA2Apvzc0Xh/Ox0m0pAhfbtez+J6am - bgszmjRYGY4BAAAAAADYKv9otYqXpqK+Pj62P02/FKY0aXAyHAMAAAAAALDVutfHj0V+fbwyPe36WIOT - 4RgAAAAAAIBe+Of1ccnWFIf8lXaatsKsJvV3hmMAAAAAAAB66a+zc8VjDdfHUk8zHAMAAAAAANBrsV8f - t+vZywdGsmaY2KT+y3AMAAAAAABALLrXx4/mo6X7UwTWro/3DO2+NUxtUv9kOAYAAAAAACAmF1ut4sU7 - v1i6QcUh/e3+NN0V5japPzIcAwAAAAAAEKM/z8wWD2fRXh+f6yTZvStDQ7eE2U2qdoZjAAAAAAAAYnVh - cbF4YXKqdI+KxG+Ws8z1saqf4RgAAAAAAIDYuT6WNjnDMQAAAAAAAFVwYbEV+/Xx8/uG8x1hhpOqleEY - AAAAAACAKnlz7fq4UbpRRWDt+vg+18eqWoZjAAAAAAAAquZ8Ba6P2yONqTDJSfFnOAYAAAAAAKCq3piZ - LQ7Fe318tl1Pf1iEXU6KOsMxAAAAAAAAVfb3xcXiuYnJ0s0qBp169vS+NB0L85wUZ4ZjAAAAAAAA+sGJ - 6ZniYBrt9fH7nVp6j+tjRZvhGAAAAAAAgH5xbnGxeDbi6+OlJHtyKc8bYaqT4slwDAAAAAAAQL+J+/o4 - Xbs+DnOdFEeGYwAAAAAAAPrRuWYz7uvjWn5k3xcaWZjtpN5mOAYAAAAAAKCfda+PV+J99/Fp18eKIsMx - AAAAAAAA/e7D5mJxdHx76a4ViccPDI+6PlbvMhwDAAAAAAAwKNauj5O8dN+KQPf6+L/DjCdtbYZjAAAA - AAAABskHzWbxi7ivjw8uZ9lwmPOkrclwDAAAAAAAwCA6vuuu4sF43318qlNLvx8mPWnzMxwDAAAAAAAw - qNauj8cmSveuSBzcl+fbwrQnbV6GYwAAAAAAAAZd9/r4gXjffXyqXcu+F+Y9aXMyHAMAAAAAAMDu4szC - QvF05NfHK42G62NtToZjAAAAAAAA+Ejk18cn2/Xsu2HqkzYuwzEAAAAAAAD8qzMLzeKp0bivjztjY3eE - yU+6+QzHAAAAAAAA8J8ur3p1565iuWQLi8SJTi37Rpj9pJvLcAwAAAAAAADX9t7CQnEk4uvjdj3f85Ph - 4c+G+U+6sQzHAAAAAAAA8Mkut1rFsR07Y74+/uP+ev71MAFK689wDAAAAAAAANfn9Px88URjvHQfi0H3 - +nhlZMT1sdaf4RgAAAAAAACuXxWuj9tJ42thDpSuL8MxAAAAAAAArN/p+YXi8dG4r4/31+u3h1lQ+uQM - xwAAAAAAAHBjLrV2X7k+Tso3s97LX+uk6d1hGpSuneEYAAAAAAAAbs67cV8fX1r1470TE58JE6H0nxmO - AQAAAAAA4Ob9o9UqXpraUXSSvHQ/i8CxpST5UpgJpX/NcAwAAAAAAAAb5625+eKxfKx0Q4vAxXYtu/+J - qanbwlwoXclwDAAAAAAAABurCtfH+9PU9bE+ynAMAAAAAAAAm6MK18cr09Ouj2U4BgAAAAAAgM30z+vj - kk0tDukr7TRthflQg5rhGAAAAAAAADbfX2fnikfz0dJtLQKujwc9wzEAAAAAAABsjYuRXx+369nLnZG8 - GaZEDVKGYwAAAAAAANhap+Yivz5Osh+tDA3dEiZFDUKGYwAAAAAAANh6FxYXixcmp0q3tjikv13Osl1h - VlS/ZzgGAAAAAACA3vnzzGzxcBbt9fG5TpLd6/p4ADIcAwAAAAAAQG9dWGxFfn2c/aadZTvCxKh+zHAM - AAAAAAAAcXizAtfH97k+7s8MxwAAAAAAABCP8/FfHz/fGWlMhblR/ZLhGAAAAAAAAOLTvT4+lDVKt7gI - uD7utwzHAAAAAAAAEKfYr4/bSfbrtuvj/shwDAAAAAAAAHE7MT1THEyjvT5+v1NL7ynC/qiKZjgGAAAA - AACA+J1bXCye235n6TYXiScPZFkjzJCqWoZjAAAAAAAAqA7Xx9qUDMcAAAAAAABQLeeazeLZicnSnS4K - SXZkKc9dH1cpwzEAAAAAAABUU9zXx+na9XGYJRV7hmMAAAAAAACorg+bzeJXEV8ft+vp4/u+0MjCPKlY - MxwDAAAAAABA9XWvj1fifffxadfHkWc4BgAAAAAAgP7wYXOxODq+vXS/i8Th9vB4EqZKxZThGAAAAAAA - APrLa7umiwcjvT5u17O3uhtlmCsVS4ZjAAAAAAAA6D8fNJvFL8YmSre8SBxczrLhMFuq1xmOAQAAAAAA - oH8d33VX8UCSl256ETi1VEu/F6ZL9TLDMQAAAAAAAPS37vXx05FfH+/L821hwlQvMhwDAAAAAADAYIj8 - +vhkp559N8yY2uoMxwAAAAAAADA4ziwsFE+NbS/d+CJxcKXRcH281RmOAQAAAAAAYPDEfn28XM++EyZN - bUWGYwAAAAAAABhMZxaaxVOjEb/7OMnbPxke/myYNrWZGY4BAAAAAABgcF1utYpjO3YWyyWbXyROLNXz - r4d5U5uV4RgAAAAAAAB4b36+ONIYL93+YtCu53tWRkZcH29WhmMAAAAAAACgqwLXx3/sJPnXwtSpjcxw - DAAAAAAAAHzc6fn54gnXx4OV4RgAAAAAAAD4d/FfH+evLSfJ3WH21M1mOAYAAAAAAACu5fT8QvH4aNzX - x/vr9dvD/KkbzXAMAAAAAAAAfJJLrd1Xro+T8m2w19r17LV2mn41TKC6kQzHAAAAAAAAwPV4e26+OJyP - le6DEbjUrmX3PzE1dVuYQrWeDMcAAAAAAADA9fpHq1W8NLWj6CR56U4YgWNLSfKlMIfqejMcAwAAAAAA - AOv11tx88Vi818cXXR+vM8MxAAAAAAAAcCPivz7OX+mkaStMo/qkDMcAAAAAAADAzfjr7FzxWCPu6+OV - 6WnXx5+U4RgAAAAAAAC4Wf+8Pi7ZDuOQvnJgJGuGmVT/nuEYAAAAAAAA2Cjd6+NH89HSDTECa9fHe4Z2 - 3xrmUl3NcAwAAAAAAABspIvRXx9nL3dGctfHH89wDAAAAAAAAGyGP8/MFo9k0V4fn+sk2b0rQ0O3hOl0 - sDMcAwAAAAAAAJvlwuJi8cLkVOmmGInfLGfZrjCfDm6GYwAAAAAAAGCzda+PH3Z9HG+GYwAAAAAAAGAr - XFhsRX99vG843xGm1MHKcAwAAAAAAABspTdnZoqHs0bpzhiBtevj+wbt+thwDAAAAAAAAGy18/FfHz/f - GWlMhVm1/zMcAwAAAAAAAL3yxsxscSje6+OzA3N9bDgGAAAAAAAAeul8q1U8H/f18dP70nQsTKz9meEY - AAAAAAAAiMGJ6ZniYBrt9fH7nVp6TxF21r7LcAwAAAAAAADE4tziYvHsxGTpBhmFJHvyQJY1wtzaPxmO - AQAAAAAAgNjEfX2crl0fh8m1PzIcAwAAAAAAADE612zGfn18ZN8XGlmYXqud4RgAAAAAAACIWff6eCXe - dx+f7ovrY8MxAAAAAAAAELsPm83iVxFfH7fr6eMHhkere31sOAYAAAAAAACqYu36OMlLN8oInG7X8v8J - U2y1MhwDAAAAAAAAVfJBs1n8Ynx76U4ZiYMrSTIcJtlqZDgGAAAAAAAAquj4rruKB+N99/Gpdi39fphl - 489wDAAAAAAAAFTV2vXx2ETpZhmJg8tZFv/1seEYAAAAAAAAqLru9fED8b77+NRSLf1emGjjzHAMAAAA - AAAA9IMzCwvF05FfH+/L821hqo0rwzEAAAAAAADQTyK/Pj7ZrmffDXNtPBmOAQAAAAAAgH7TvT5+ajTu - 6+PO2NgdYbbtfYZjAAAAAAAAoB9dXhX79fFSPf9OmG57m+EYAAAAAAAA6GfvLSwUR0bHS3fNGLTr+Z6f - DA9/Nky4vclwDAAAAAAAAPS7y61WcWzHzmK5ZNuMxImlev71MONufYZjAAAAAAAAYFC8Nz9fHGnEfX28 - MjKy9dfHhmMAAAAAAABgkFTg+viPnST/Wph0tybDMQAAAAAAADCITs8vFE9Efn28v16/PUy7m5vhGAAA - AAAAABhUl1q7I78+zl9bTpK7w7y7eRmOAQAAAAAAgEHXvT5+fDTa6+NL3evjPVm2edfHhmMAAAAAAACA - K9fHL39xR9FJ8tINNAKvdpLGf4Wpd2MzHAMAAAAAAAB85K25+eJwPla6g0bgYruW3f/E1NRtYfLdmAzH - AAAAAAAAAP/qH61W8dJU1NfHx/an6ZfC7HvzGY4BAAAAAAAAynWvjx+L/Pp4ZXr65q+PDccAAAAAAAAA - 13ZhcbF4YXKqdBeNQ/rb/Wm6K0zAN5bhGAAAAAAAAODT/XV2rnis0afXx4ZjAAAAAAAAgOvzz3cfl2yk - MWjXs5c7I3kzzMHXn+EYAAAAAAAAYH2618eP5qOlW2kEznWS7N6VoaFbwiz86RmOAQAAAAAAANbvYqtV - vHjnF0v30kj8ZjnLru/dx4ZjAAAAAAAAgBv355nZ4uEs7uvj+z7t+thwDAAAAAAAAHBzLiwuFi9MTpVu - p5F4vjPSmAoz8X9mOAYAAAAAAADYGJFfH5+95vWx4RgAAAAAAABg41xYbMV+ffz0vjQdC5PxlQzHAAAA - AAAAABvv/5ueKQ6mjdI9NQLvtOvZ/xNmY8MxAAAAAAAAwGaIfDg+s5Rk/28RdmPDMQAAAAAAAMAGOtts - Fr8c3166o0bi0fbweBIm4ysZjgEAAAAAAAA2xvFddxUPpnnphhqB050k/0GYiv81wzEAAAAAAADAzfmw - uRj7lfHh/7gy/niGYwAAAAAAAIAb170yXon3yvhMp5be8893GV8rwzEAAAAAAADA+v19cbF4bmKydC+N - xNOdNB0L0/AnZzgGAAAAAAAAWJ8Td00XB9NG6VYageu7Mv54hmMAAAAAAACA6xP7lXGnnj1zIEkmwhx8 - /RmOAQAAAAAAAD7dn6Znioey0dJ9NALrvzL+eIZjAAAAAAAAgGu7sLhYvDA5VbqLxiH97f403RUm4BvL - cAwAAAAAAABQ7vXpmeJQvFfGZ2/qyvjjGY4BAAAAAAAA/tX5yN9l3K7nz3Zqtckw+958hmMAAAAAAACA - j7wxM1scyhqlO2gE1q6M7xsauiVMvhuT4RgAAAAAAADgyruMn+/3dxlfK8MxAAAAAAAAMOhOzs4Vj0T6 - LuN2PTvfSbJ7jw4N3Rpm3o3PcAwAAAAAAAAMqoutVvFCxFfGnXr24nKSTId5d/MyHAMAAAAAAACD6C8R - Xxmv2vwr449nOAYAAAAAAAAGSexXxku17Hf76/XZMOluTYZjAAAAAAAAYFCcmp0tfpqPlW6cEdjaK+OP - ZzgGAAAAAAAA+l3sV8btJPv9cq0xH2bcrc9wDAAAAAAAAPSzU3NzxU/zaN9lfLF7ZbxnaPfWXxl/PMMx - AAAAAAAA0I8urXppakfRSfLSTTMCr3aSxn+F6ba3GY4BAAAAAACAfvP23FxxuDFeumVG4FK7lt2/d2Li - M2G27X2GYwAAAAAAAKBfVOHKeKmefznMtfFkOAYAAAAAAAD6wTvz88XPIr8yXmk04rky/niGYwAAAAAA - AKDKYr8y7iTZH9q17Cthoo0zwzEAAAAAAABQVe/Oda+Mx0o3ywjEfWX88QzHAAAAAAAAQNVcal25Ml5O - yvfKCBxfHkm/GmbZ+DMcAwAAAAAAAFXy7vxC8Xi8V8ZdP96TZbeHSbYaGY4BAAAAAACAKrjcahXHduws - DkT6LuNVJ9q17Bthiq1WhmMAAAAAAAAgdu8vLBQ/Hx0v3SZj0K7ne5a2bftcmGGrl+EYAAAAAAAAiFX0 - V8a17PVOLf1mmF+rm+EYAAAAAAAAiNH78/FfGa98frK6V8Yfz3AMAAAAAAAAxOTyqsjfZfzmUpJ8K0yu - /ZHhGAAAAAAAAIjF3xaaa1tj2QYZg+6V8d47Ju4Ic2v/ZDgGAAAAAAAAeu3qlfEDEV8Zt5P822Fm7b8M - xwAAAAAAAEAvfdBsFs+Mby/dHaOQ5O3O2Fj/XRl/PMMxAAAAAAAA0CvHd91VPJg2SjfHCLzVSfIfhGm1 - vzMcAwAAAAAAAFvtbPxXxof21+u1MKv2f4ZjAAAAAAAAYCtduTKO9l3G7wzMlfHHMxwDAAAAAAAAW+Fs - c7H45fhk6b4Yg049e2S5VhucK+OPZzgGAAAAAAAANlv3ynjFlXG8GY4BAAAAAACAzfJhc7E4GvO7jOvZ - o3tHRpIwnw5uhmMAAAAAAABgM7y2a7pYSaK9Mj498FfGH89wDAAAAAAAAGykvy8uFs9NxPsu41VP70vT - sTCZqpvhGAAAAAAAANgoJ+6aLh5KG6UbYgTOdGrpPUXYSvWxDMcAAAAAAADAzYr9yrhTz545kCQTYSbV - v2c4BgAAAAAAAG7Gn6Znioey0dLdMAKujK8nwzEAAAAAAABwI85H/y7j9Oj+et2V8fVkOAYAAAAAAADW - 6/XpmeJQvFfGZ10ZrzPDMQAAAAAAAHC9zrdacV8Z17JnO7XaZJhDdb0ZjgEAAAAAAIDr8cbMbHEoa5Tu - gxE4166nP7xvaOiWMIVqPRmOAQAAAAAAgE9yYXGxeGFyqnQXjEP+4lKSTIcJVDeS4RgAAAAAAAC4lpOz - c8Ujkb7LuF3PzneS7N6jQ0O3hvlTN5rhGAAAAAAAAPh3F1utqK+MO/XsxWVXxhuX4RgAAAAAAAD4uL/M - zhU/zcdKd8AIuDLejAzHAAAAAAAAQFfsV8ZLtex3S/XGbJg6tZEZjgEAAAAAAIBTc/FfGe8Z2u3KeLMy - HAMAAAAAAMDgunpl3CnZ/CLx++VaYz7Mm9qsDMcAAAAAAAAwmN6emy8Ox3tlfKmdZD9yZbxFGY4BAAAA - AABgsFxa9dLUjqKT5KVbXwRe3V9v/FeYNLUVGY4BAAAAAABgcLw9P18cboyXbnwRuNSuZffvnZj4TJgz - tVUZjgEAAAAAAKD/RX9lXMv+sFzLvxxmTG11hmMAAAAAAADob+/Mzxc/a0T8LuNadv9Ko+HKuJcZjgEA - AAAAAKA/VeBdxsfbtewrYbpULzMcAwAAAAAAQP95d86VsdaR4RgAAAAAAAD6x6XWlSvj5aR8x4vA8eWR - 9KthrlQsGY4BAAAAAACgP7y3sFAcGR0v3e9i0K7ne5a2bftcmCoVU4ZjAAAAAAAAqLbLrVZxbMfO4kC8 - 7zJ+famWfTNMlIoxwzEAAAAAAABU1/sLC8XPXRnrZjMcAwAAAAAAQPVcXhX1lXEte709kn4rzJKKPcMx - AAAAAAAAVMv78wtre1zZTheD7pXxyucnXRlXKcMxAAAAAAAAVEP0V8b17M1O0vh2mCJVpQzHAAAAAAAA - EL+/LTSjvzLee8fEHWGGVNUyHAMAAAAAAEDcXt25q3gg3ivjk0v1/DthflRVMxwDAAAAAABAnD5oNotn - xreX7nFRqKUHV5JkOEyPqnKGYwAAAAAAAIjP8V13FQ+mjdItLgJvdZL8B2FyVD9kOAYAAAAAAIB4nI39 - yriePbK/Xq+FuVH9kuEYAAAAAAAA4nDlyjjadxm/48q4jzMcAwAAAAAAQG+dbS4WvxyfLN3dIvHo3pGR - JEyM6scMxwAAAAAAANA73SvjFVfG6nWGYwAAAAAAANh6HzYXi6MRv8u4Xc8Ot4fHXRkPSoZjAAAAAAAA - 2FonpmeKg2mjdGeLwJl2Lf+fMCdqUDIcAwAAAAAAwNb4++Ji8dxE1O8yfqaTpmNhStQgZTgGAAAAAACA - zfen6ZnioYivjDu19J4ibIgawAzHAAAAAAAAsHkqcGV89ECSTIT5UIOa4RgAAAAAAAA2x9qVcTZauqdF - wJWxPspwDAAAAAAAABvrfORXxu16/mynVpsMk6FkOAYAAAAAAICN9MbMbHEo3ivjs66MVZrhGAAAAAAA - AG7e+VYr7ncZ17JfP1AbdWWs8gzHAAAAAAAAcHNOzswWj0R6ZdyuZ+c7SXbvytDQLWEilP4zwzEAAAAA - AADcmAuLi8ULk1Ole1kc8heXkmQ6TIPStTMcAwAAAAAAwPqdnJ2L/sr46NDQrWEWlD45wzEAAAAAAABc - v4utVtxXxrXsd/vr9dkwB0rXl+EYAAAAAAAArs9fZueKn+ZjpftYBFwZ68YzHAMAAAAAAMAni/3KuJ1k - v1+uNebDBCitP8MxAAAAAAAAXNupue6VcZzvMl51sXtlvGdotytj3VyGYwAAAAAAAPhPl1a9eOcXi07J - FhaJl9u13JWxNibDMQAAAAAAAPyrt+fmisPxvsv4UruW3b93YuIzYfKTbj7DMQAAAAAAAFzRvTJ+aWpH - 0Uny0g0sAq8u1fMvh6lP2rgMxwAAAAAAALC7eGd+vjjcGC/dviLgylibm+EYAAAAAACAQRb7lXEnyf6w - XHNlrE3OcAwAAAAAAMCg6l4Z/6wR97uMVxoNV8ba/AzHAAAAAAAADJpLrStXxstJ+dYVgeNLtewrYdKT - Nj/DMQAAAAAAAIPk3bn54vHIr4z3ZNntYc6TtibDMQAAAAAAAIPgcqtVHNuxszgQ6buMV53o1LJvhBlP - 2toMxwAAAAAAAPS79xcWip+PjpfuWjFo1/M9S9u2fS5MeNLWZzgGAAAAAACgX1Xgyvj1Ti39ZpjupN5l - OAYAAAAAAKAfVeHKeOXzk66MFUeGYwAAAAAAAPrJ5VWRXxm/2R5JvxXmOimODMcAAAAAAAD0i78tNNd2 - qrL9KgbdK+O9d0zcEaY6KZ4MxwAAAAAAAFTd1SvjByK+Mu4kjW+HiU6KL8MxAAAAAAAAVda9Mn5qNN4r - 46Ukb7syVvQZjgEAAAAAAKiq47vuKh5MG6V7Va+169lbnST/QZjlpLgzHAMAAAAAAFA1Z5vN4pnx7aU7 - VQw6SX5of71eC5OcFH+GYwAAAAAAAKrkypVxtO8ydmWsamY4BgAAAAAAoAq6V8a/jPjKeNUjy7WaK2NV - M8MxAAAAAAAAsYv8yvgdV8aqfIZjAAAAAAAAYvVhczH2K+NH946MJGF6k6qb4RgAAAAAAIAYda+MV+K9 - Mj7tylh9leEYAAAAAACAmPx9cbF4bmKydIOKxOH28LgrY/VXhmMAAAAAAABiceKu6eKhtFG6P0XgTKeW - 3lOEnU3qqwzHAAAAAAAA9FoFroyf6aTpWJjYpP7LcAwAAAAAAEAv/Wl6pngoGy3dnCLgyliDkeEYAAAA - AACAXqjAlfHR/fX6RJjVpP7OcAwAAAAAAMBWe316pjgU75XxWVfGGrgMxwAAAAAAAGyV85FfGbfr+bOd - Wm0yTGnS4GQ4BgAAAAAAYCu8MTNbHMoapdtSBNaujO8bGrolzGjSYGU4BgAAAAAAYDNdWFwsnp+cKt2U - 4pD+dn+a7grzmTSYGY4BAAAAAADYLCdn54pHIn2Xcbuene8k2b1Hh4ZuDdOZNLgZjgEAAAAAANhoF1ut - 4oWIr4w79ezF5SSZDpOZJMMxAAAAAAAAG+kvEV8Zr3JlLJVlOAYAAAAAAGAjxH5lvFTLfre/Xp8NM5mk - j2c4BgAAAAAA4Gadmp0tfpqPle5GEXBlLH1ahmMAAAAAAABuVOxXxu0k+/1yrTEfpjFJ18pwDAAAAAAA - wI04NTdX/DSP9l3GF7tXxnuGdrsylq4nwzEAAAAAAADrcWnVS1M7ik6Sl+5EEXi1kzT+K8xhkq4nwzEA - AAAAAADX6+25ueJwY7x0H4rApXYtu3/vxMRnwhQm6XozHAMAAAAAAPBpor8yrmV/WKrnXw4TmKT1ZjgG - AAAAAADgk7wzP1/8LPIr45VGw5WxdDMZjgEAAAAAACgT+5VxJ8n+0K5lXwmzl6SbyXAMAAAAAADAv3t3 - rntlPFa6A0XAlbG00RmOAQAAAAAAuOpS68qV8XJSvgFF4PjySPrVMHVJ2qgMxwAAAAAAAHS9O79QPB7v - lXHXj/dk2e1h5pK0kRmOAQAAAAAABtvlVqs4tmNncSDSdxmvOtGuZd8I85akzchwDAAAAAAAMLjeX1go - fj46Xrr3xKBdz/csbdv2uTBtSdqsDMcAAAAAAACDJ/or41r2eqeWfjNMWpI2O8MxAAAAAADAYHl/Pv4r - 45XPT7oylrYywzEAAAAAAMBguLwq8ncZv7mUJN8KM5akrcxwDAAAAAAA0P/+ttBc22/Kdp0YdK+M994x - cUeYsCRtdYZjAAAAAACA/nX1yviBiK+M20n+7TBdSepVhmMAAAAAAID+9EGzWTwzvr10y4lCLT24kiTD - YbaS1MsMxwAAAAAAAP3n+K67igfTRumOE4G3Okn+gzBXSYohwzEAAAAAAED/OBv7lXGSH9pfr9fCVCUp - lgzHAAAAAAAA/eHKlXG07zJ+x5WxFHGGYwAAAAAAgGo721wsfjk+WbrZxKBTzx5ZrtVcGUsxZzgGAAAA - AACoru6V8YorY0k3m+EYAAAAAACgej5sLhZHY36XcT17dO/ISBImKUmxZzgGAAAAAAColv/bvTJOor0y - Pu3KWKpghmMAAAAAAIBq+PviYvHcRLzvMl719L40HQszlKQqZTgGAAAAAACI34m7pouH0kbpLhOBM51a - ek8R9idJFcxwDAAAAAAAEK/Yr4w79eyZA0kyEaYnSVXNcAwAAAAAABCnP03PFA9lo6VbTARcGUv9lOEY - AAAAAAAgLuejf5dxenR/ve7KWOqnDMcAAAAAAADxeH16pjgU75XxWVfGUp9mOAYAAAAAAOi9861W3FfG - tezZTq02GSYmSf2W4RgAAAAAAKC33piZLQ5ljdLNJQLn2vX0h/cNDd0S5iVJ/ZjhGAAAAAAAoDcuLC4W - L0xOlW4tcchfXEqS6TArSernDMcAAAAAAABb7+TsXPFIpO8ybtez850ku/fo0NCtYVKS1O8ZjgEAAAAA - ALbOxVYr6ivjTj17cdmVsTR4GY4BAAAAAAC2xl9m54qf5mOl20oEXBlLg5zhGAAAAAAAYHPFfmW8VMt+ - t1RvzIb5SNIgZjgGAAAAAADYPKfm4r8y3jO025WxNOgZjgEAAAAAADbe1SvjTsmOEonfL9ca82EykjTo - GY4BAAAAAAA21ttz88XheK+ML7WT7EeujCX9S4ZjAAAAAACAjXFp1UtTO4pOkpfuJxF4dX+98V9hJpKk - jzIcAwAAAAAA3Ly35+eLw43x0t0kApfatez+vRMTnwkTkST9a4ZjAAAAAACAGxf9lXEt+8NyLf9ymIYk - qTzDMQAAAAAAwI15Z36++Fkj4ncZ17L7VxoNV8aSPj3DMQAAAAAAwPpU4F3Gx9u17CthDpKkT89wDAAA - AAAAcP3enXNlLKkPMxwDAAAAAAB8ukutK1fGy0n5NhKB48sj6VfDBCRJ68twDAAAAAAA8MneW1gojoyO - l24iMWjX8z1L27Z9Lsw/krT+DMcAAAAAAADlLrdaxbEdO4sD8b7L+PWlWvbNMPtI0o1nOAYAAAAAAPhP - 7y8sFD93ZSxpUDIcAwAAAAAAfOTyqqivjGvZ6+2R9Fth6pGkjclwDAAAAAAAcMX78wtrG0fZ9hGD7pXx - yucnXRlL2vgMxwAAAAAAwKCL/sq4nr3ZSRrfDvOOJG18hmMAAAAAAGCQ/W2hGf2V8d47Ju4I044kbU6G - YwAAAAAAYFC9unNX8UCkV8btevZWd8cJk44kbW6GYwAAAAAAYNB80GwWz4xvL904olBLD64kyXCYcyRp - 8zMcAwAAAAAAg+T4rruKB9NG6b4Rgbc6rowl9SLDMQAAAAAAMAjOxn5lXM8eWa7VamHCkaStzXAMAAAA - AAD0uytXxnG+y3jVO66MJfU8wzEAAAAAANCvzjYXi1+OT5ZuGZF4dO/ISBJmG0nqXYZjAAAAAACgH3Wv - jFdcGUvS9WU4BgAAAAAA+smHzcXiaMTvMm7Xs8Pt4XFXxpLiynAMAAAAAAD0ixPTM8XBtFG6XUTgTLuW - /0+YaCQprgzHAAAAAABA1f19cbF4biLqdxk/00nTsTDPSFJ8GY4BAAAAAIAq+9P0TPFQxFfGnVp6TxF2 - GUmKNsMxAAAAAABQRRW4Mj56IEkmwiQjSXFnOAYAAAAAAKpm7co4Gy3dKCLgylhS9TIcAwAAAAAAVXE+ - 8ivjdj1/tlOrTYYZRpKqk+EYAAAAAACogjdmZotDWbTvMj7rylhSpTMcAwAAAAAAMTvfasX9LuNa9usH - aqOujCVVO8MxAAAAAAAQq5Mzs8Ujkb7LuF3PzneS7N6VoaFbwuwiSdXNcAwAAAAAAMTmwuJi8cLkVOkG - EYf8xaUkmQ5ziyRVP8MxAAAAAAAQk5Ozc9FfGR8dGro1TC2S1B8ZjgEAAAAAgBhcbLXivjKuZb/bX6/P - holFkvorwzEAAAAAANBrf5mdK36aj5VuDhFwZSyp/zMcAwAAAAAAvRL7lXE7yX6/XGvMh1lFkvo3wzEA - AAAAANALp+a6V8Zxvst41cXulfGeod2ujCUNRoZjAAAAAABgK11a9eKdXyw6JftCJF5u13JXxpIGK8Mx - AAAAAACwVd6emysOx/su40vtWnb/3omJz4QZRZIGJ8MxAAAAAACw2bpXxi9N7Sg6SV66K0Tg1aV6/uUw - n0jS4GU4BgAAAAAANtM78/PFzxrjpXtCBFwZS1I3wzEAAAAAALAZYr8y7iTZH5ZrrowlaS3DMQAAAAAA - sNHeneteGcf9LuOVRsOVsSRdzXAMAAAAAABslEutK1fGy0n5fhCB40u17CthJpEkXc1wDAAAAAAAbITu - lfHjkV8Z78my28NEIkn6eIZjAAAAAADgZlxutYpjO3YWByJ9l/GqE51a9o0wjUiSyjIcAwAAAAAAN+r9 - hYXi56PjpVtBDNr1fM/Stm2fC7OIJOlaGY4BAAAAAID1qsCV8eudWvrNMIdIkj4twzEAAAAAALAeVbgy - Xvn8pCtjSVpPhmMAAAAAAOB6XF4V+ZXxm+2R9FthApEkrSfDMQAAAAAA8Gn+ttBc+9/9l20CMeheGe+9 - Y+KOMH9Iktab4RgAAAAAALiWq1fGD0R8ZdxJGt8Os4ck6UYzHAMAAAAAAGW6V8ZPjcZ7ZbyU5G1XxpK0 - QRmOAQAAAACAf3d8113Fg2mjdAPotXY9e6uT5D8IU4ckaSParOH4sXysODE9AwAAAABsoEsl4w7ARjrX - bBbPTkyW/u/+o1DLj+z7QiMLM4ckaaParOEYAAAAANh4f19cLB16ADbClSvjaN9l7MpYkjYzwzEAAAAA - VIfhGNgMZ5vN4pfj20u/dyLxyHKtVgvThiRpMzIcAwAAAEB1GI6BjRb5lfE7rowlaYsyHAMAAABAdRiO - gY3yYXMx9ivjR/eOjCRhzpAkbXaGYwAAAACoDsMxsBG6V8Yr8V4Zn3ZlLEk9yHAMAAAAANVhOAZuRvc7 - 5LmJydLvl0gcbg+PuzKWpF5kOAYAAACA6jAcAzfqxF3TxUNpo/S7JQJnOrX0niJsF5KkHmQ4BgAAAIDq - MBwD61WBK+NnOmk6FmYLSVKvMhwDAAAAQHUYjoH1+NP0TPFQNlr6fRIBV8aSFFOGYwAAAACoDsMxcD0q - cGV8dH+9PhGmCklSDBmOAQAAAKA6DMfApzk5O1c8EumVcbuenV+qp/97dGjo1jBTSJJiyXAMAAAAANVh - OAau5XzsV8a17NlOrTYZ5glJUmwZjgEAAACgOgzHQJk3ZmaLQ1mj9HsjAme77zK+b2joljBNSJJizHAM - AAAAANVhOAY+7sLqd8Lzk1Ol3xdxSH+7P013hUlCkhRzhmMAAAAAqA7DMXDVycjfZdxJsnu9y1iSKpTh - GAAAAACqw3AMXGy1ihcivjLu1LMXl5NkOswQkqSqZDgGAAAAgOowHMNg+0vEV8arXBlLUpUzHAMAAABA - dRiOYTDFfmW8VMt+t79enw3TgySpihmOAQAAAKA6DMcweE7NzhY/zcdKvxMi4MpYkvolwzEAAAAAVIfh - GAZH7FfG7ST7/XKtMR/mBklS1TMcAwAAAEB1GI5hMJyamyt+mkf7LuOL3SvjPUO7XRlLUj+1VM+/3n33 - AAAAAACwgcrHlptmOIb+dqm1u/g/X9xZLCfl3wG91q5nr3XS9O4wMUiSJEmSJEmSJOlarUxP31Y2uGwE - wzH0r7fn54vDjfHSZz8Cl9q17P69ExOfCV91kiRJkiRJkiRJ+qQMx8B6XFr10tSOopPkpc99z9WyPyzV - 8y+HrzhJkiRJkiRJkiRdT4Zj4Hq9Mz9f/CzyK+OVRsOVsSRJkiRJkiRJ0nozHAOfJvYr406S/aFdy74S - vtYkSZIkSZIkSZK03gzHwCd5d657ZTxW+oxHwJWxJEmSJEmSJEnSRmQ4Bspcal25Ml5Oyp/vCBxfHkm/ - Gr7KJEmSJEmSJEmSdDMZjoF/997CQnFkNNp3GXf9eE+W3R6+xiRJkiRJkiRJknSzGY6Bqy63WsWxHTuL - A5G+y3jViXYt+0b4+pIkSZIkSZIkSdJGZTgGut5fWCh+HvGVcbue71natu1z4atLkiRJkiRJkiRJG5nh - GAZb9FfGtez1Ti39ZvjKkiRJkiRJkiRJ0mZkOIbB9f78QvHk2ETp8xuD7pXxyucnXRlLkiRJkiRJkiRt - doZjGDyXV0X+LuM3l5LkW+FrSpIkSZIkSZIkSZud4RgGy98WmtFfGe+9Y+KO8BUlSZIkSZIkSZKkrchw - DIPh6pXxAxFfGbeT/Nvhq0mSJEmSJEmSJElbmeEY+t8HzWbxzPj20uc0CrX04EqSDIevJUmSJEmSJEmS - JG11hmPob8d33VU8mDZKn9EIvNVJ8h+EryNJkiRJkiRJkiT1KsMx9KezsV8ZJ/mh/fV6LXwVSZIkSZIk - SZIkqZcZjqH/XLkyjvZdxu+4MpYkSZIkSZIkSYoswzH0j7PNxeKX45Olz2MMOvXskeVazZWxJEmSJEmS - JElSbBmOoT90r4xXXBlLkiRJkiRJkiTpRjIcQ7V92Fwsjsb8LuN69ujekZEkfOVIkiRJkiRJkiQpxgzH - UF3/t3tlnER7ZXzalbEkSZIkSZIkSVJFMhxD9XSfrecm4n2X8aqn96XpWPiakSRJkiRJkiRJUuwZjqFa - Ttw1XTyUNkqfuQic6dTSe4rw/SJJkiRJkiRJkqSKZDiGaoj9yrhTz545kCQT4atFkiRJkiRJkiRJVcpw - DPH70/RM8VA2WvqcRcCVsSRJkiRJkiRJUtUzHEO8zkd+ZbxUT4/ur9ddGUuSJEmSJEmSJFU9wzHE6fXp - meJQvFfGZ10ZS5IkSZIkSZIk9VGGY4jL+VYr7ivjWvbsA7XRyfAVIkmSJEmSJEmSpH7IcAzxeGNmtjiU - NUqfpwica9fTH943NHRL+PqQJEmSJEmSJElSv2Q4ht67sPqsvDA5VfocxSF/cSlJpsPXhiRJkiRJkiRJ - kvotwzH01snZueKRSN9l3K5n5ztJdu/RoaFbw1eGJEmSJEmSJEmS+jHDMfTGxVYr6ivjTj17cdmVsSRJ - kiRJkiRJ0mBkOIat95fZueKn+VjpcxMBV8aSJEmSJEmSJEmDluEYtk7sV8ZLtex3S/XGbPh6kCRJkiRJ - kiRJ0qBkOIatcWou/ivjPUO7XRlLkiRJkiRJkiQNYoZj2FxXr4w7Jc9IJH6/XGvMh68ESZIkSZIkSZIk - DWKGY9g8b8/NF4fjvTK+1E6yH7kyliRJkiRJkiRJkuEYNsGlVS9N7Sg6SV76bETg1f31xn+FrwFJkiRJ - kiRJkiQNeoZj2Fhvz88Xhxvjpc9EBC61a9n9eycmPhO+AiRJkiRJkiRJkiTDMWyU6K+Ma9kflmv5l8Oj - L0mSJEmSJEmSJH2U4Rhu3jvz88XPGhG/y7iW3b/SaLgyliRJkiRJkiRJUnmGY7hxV6+Ml5PyZyACx9u1 - 7CvhcZckSZIkSZIkSZLKMxzDjXl3Lv4r4z1Zdnt41CVJkiRJkiRJkqRrZziG9bncahUvfzHuK+PlkfSr - 4RGXJEmSJEmSJEmSPj3DMVy/9xYWip+Pjpd+3mPQrud7lrZt+1x4vCVJkiRJkiRJkqTry3AMn657ZXxs - x87iQJKXftYj8PpSLftmeKwlSZIkSZIkSZKk9WU4hk/2vitjSZIkSZIkSZIk9XuGYyh3eVXUV8a17PX2 - SPqt8ChLkiRJkiRJkiRJN57hGP7T+/MLxZNjE6Wf6xh0r4xXPj/pyliSJEmSJEmSJEkbk+EYPhL9lXE9 - e7OTNL4dHl9JkiRJkiRJkiRpYzIcwxV/W2hGf2W8946JO8KjK0mSJEmSJEmSJG1chmPYXby6c1fxQKRX - xu169tZSkv8gPLKSJEmSJEmSJEnSxmc4ZpCdbTaLZ8a3l35+o1BLD64kyXB4XCVJkiRJkiRJkqTNyXDM - oDq+667iwbRR+tmNwFsdV8aSJEmSJEmSJEnaqgzHDJror4zr2SPLtVotPKKSJEmSJEmSJEnS5mc4ZpBc - uTKO813Gq95xZSxJkiRJkiRJkqSeZDhmEJxtLha/jPvK+NG9IyNJeCwlSZIkSZIkSZKkrc1wTL/rXhmv - uDKWJEmSJEmSJEmSrp3hmH71YXOxOBrxlXG7nh1uD4+7MpYkSZIkSZIkSVLvMxzTj05MzxQH00bp5zIC - Z9q1/H/CIyhJkiRJkiRJkiT1PsMx/aT7mXtuYrL08xiJZzppOhYeP0mSJEmSJEmSJCmODMf0iz9NzxQP - RXxl3Kml9xThuZMkSZIkSZIkSZKiynBM1VXgyvjogSSZCI+cJEmSJEmSJEmSFF+GY6ps7co4Gy39/EXA - lbEkSZIkSZIkSZKqkeGYKjof+ZVxu54/26nVJsNjJkmSJEmSJEmSJMWd4ZiqeWNmtjiURfsu47OujCVJ - kiRJkiRJklS5DMdUxflWK+53GdeyXz9QG3VlLEmSJEmSJEmSpOplOKYKTs7MFo9E+i7jdj0730mye1eG - hm4Jj5UkSZIkSZIkSZJUrQzHxOzC6mfohcmp0s9XHPIXl5JkOjxOkiRJkiRJkiRJUjUzHBOrk7Nz0V8Z - Hx0aujU8SpIkSZIkSZIkSVJ1MxwTm4utVtxXxrXsd/vr9dnwCEmSJEmSJEmSJEnVz3BMTP4yO1f8NB8r - /TxFwJWxJEmSJEmSJEmS+jPDMTGI/cq4nWS/X6415sNjI0mSJEmSJEmSJPVXhmN67dRc98o4zncZr7rY - vTLeM7TblbEkSZIkSZIkSZL6N8MxvXJp1Yt3frHolHx2IvFyu5a7MpYkSZIkSZIkSVL/ZzimF96emysO - x/su40vtWnb/3omJz4THRJIkSZIkSZIkServDMdspe6V8UtTO4pOkv//7d1PiFz1AQfwQTyIB1mD+96b - N5Pd6WKjJvvPFYpIjyLi2WPp0WOP0pv06LHHPS3dmTfR1RAllmpLGmwptIhKDxJCoGBTsRKjjTYtqSSv - O+YXlPqaP5udmd+b9/nA9xDYnZ333i+nL19e5ZmJIKcHaefx8N8DAAAAAAAAmkFxLJPKhdXV8o3uYuVZ - iSBWxgAAAAAAADSX4ljGndhXxkWWnxkmVsYAAAAAAAA0mOJYxpnPVkYr47jfZbzT7VoZAwAAAAAA0GyK - YxlHrmxcWxkPs+qzEUHODpL8ifDfAAAAAAAAAJpNcSz7ndHK+JeRr4w38/ze8F8AAAAAAAAAUBzLfuXq - xkb5waGHyqORvst4Nx8WSf5kOPoAAAAAAADAdYpj2Y9cXFsr3zy4WHkOYkg/7WwODhy4Lxx7AAAAAAAA - 4NsUx3InqcHK+FyRtJ8Kxx0AAAAAAACoojiWvaYOK+Od+5esjAEAAAAAAOBmFMdyu7m6m8hXxh8Nsuzp - cMQBAAAAAACAm1Ecy+3ki7X18q2FXuXzjiGjlfHWXG8uHG8AAAAAAADgViiO5VZyfWX8UsQr4yLrPhOO - NQAAAAAAAHA7FMdys4xWxr8+GO/KeJB1+sXCgpUxAAAAAAAA7JXiWG6Usw8/Ur7c7lY+32mnn+bni6zz - bDjKAAAAAAAAwF4pjqUql9bXy5OL36t8rjGkyDrHttM0CccYAAAAAAAAuBOKY/nfXFsZR/suYytjAAAA - AAAA2G+KY7me0cr4txGvjHdzfJgkVsYAAAAAAACw3xTHMspoZbwT78r4gpUxAAAAAAAAjJHiuNn51/qj - sa+MX9+an8/CcQUAAAAAAADGQXHc3ES+Mv7cyhgAAAAAAAAmRHHcvIyey+96S5XPLJKc6D+waGUMAAAA - AAAAk6I4blY+fORw+Wq7W/m8IsiXRdJ+rgxnEwAAAAAAAJgQxXEzUoOV8cmi3V4IxxIAAAAAAACYJMXx - 7Oevh4+Ur+YHK59RBLEyBgAAAAAAgGlTHM9uarAyPrWdpr1wFAEAAAAAAIBpURzPZs4dPlIei3dlfMnK - GAAAAAAAACKiOJ6tXI59ZZzkbxdJshSOHwAAAAAAABADxfHs5G9HlstjebfyWUSQr1fGL7Rad4WjBwAA - AAAAAMRCcVz//Gf3Pv9h6cHKZxBH2n/abrcfDkcOAAAAAAAAiI3iuN75eHmlPB7pu4z7aX65yPLnT7Va - d4fjBgAAAAAAAMRIcVzPfLWxUf4x4pVxkebvDLPscDhmAAAAAAAAQMwUx/XL3yNeGe/GyhgAAAAAAADq - RnFcn8S+Mh4k+bvbabocjhYAAAAAAABQF4rjeuST5eXytc5C5X2OIFbGAAAAAAAAUGeK47gT+8q4n+Xv - D5PuajhOAAAAAAAAQB0pjuPNJysr5WudaN9l/NVoZbzZeszKGAAAAAAAAOpOcRxfruzmvQcPlUXWqbyv - EeR0kXV/EI4QAAAAAAAAUHeK47jy6epqeaK7WHk/I8iVfpK/uNXr3ROODwAAAAAAADALFMdxJPqVcZKf - GaSdx8OxAQAAAAAAAGaJ4nj6ubC6Wr4R+cp4p9u1MgYAAAAAAIBZpTieXmJfGRdZfqaf5E+EowIAAAAA - AADMKsXxdPLZymhlvFB53yKIlTEAAAAAAAA0ieJ4srmycW1lPMyq71kEOTucb/8wHA8AAAAAAACgCRTH - k8s/1tbKXx2M9l3Go/x8M8/vDUcDAAAAAAAAaArF8fhzdWOj/ODQQ+XRSN9lvJsP+0n+ZDgSAAAAAAAA - QNMojsebi2tr5ZsRr4z7aWdzcODAfeE4AAAAAAAAAE2kOB5Pol8ZJ/m5Imk/FY4BAAAAAAAA0GSK4/3P - xdW18q2FXuU9iSGjlfHO/UtWxgAAAAAAAMA1iuP9y9XdRP4u448GWfZ0ePQAAAAAAAAA1yiO9ydfrK1H - vzLemuvNhccOAAAAAAAA8A3F8Z3l+sr4pYhXxv2s80x43AAAAAAAAADfpTjee/65vl6eXPxe5bVHkaT9 - yk6WPRAeNQAAAAAAAEA1xfHecvbhR8qX293K644g54us82x4xAAAAAAAAAA3pji+vVyKfWWcdY5tp2kS - Hi8AAAAAAADAzSmObz3XVsbRvsv4gpUxAAAAAAAAsCeK45vn0vqj5W8XlyqvMYYUaX58mCRWxgAAAAAA - AMDeKI5vnNHKeMfKGAAAAAAAAJhliuPq/Gv90fJUzO8yTvPXt+bns/AYAQAAAAAAAPZOcfzd/GW0Ms6i - XRl/bmUMAAAAAAAA7CvF8TcZfd/f9eJ9l/FuflO02wvh0QEAAAAAAADsD8Xxtfz18JHy1Xa38joiyJdF - 0n6uDM8MAAAAAAAAYF81vTiOfWVcpPnJo1nWC48LAAAAAAAAYP81uTj+emWcH6z87hHEyhgAAAAAAACY - jCYWx5cjXxkP0vap7TS1MgYAAAAAAAAmo2nF8bnDR8pj8a6ML1kZAwAAAAAAABPXlOL48sZG3CvjJH/7 - peTgUngsAAAAAAAAAJPThOL44yPL5fF4V8b/7qftn7zQat0VHgkAAAAAAADAZM1ycfyf3b//x6UHK79b - HOm8M8iyw+FRAAAAAAAAAEzHrBbHHy+vRLsy7qf55SLLnz/Vat0dHgMAAAAAAADA9MxacfzVxkbUK+Mi - zd8ZWhkDAAAAAAAAMZml4vjvyyvla52Fyu8SQayMAQAAAAAAgDjNQnEc+8p4kOTvDtLucrjlAAAAAAAA - AHGpe3H8yUr8K+PN1mNWxgAAAAAAAEC86locX18ZFxV/N5K8P0y6q+E2AwAAAAAAAMSrjsXxpyur5Yl4 - V8ZX+ln+MytjAAAAAAAAoDbqVBxf2c17Dx4qi6xT+fciyOnttPuDcGsBAAAAAAAA6qEuxfGnq6vlie5i - 5d+JIFf6Sf7iVq93T7itAAAAAAAAAPURe3Ec/co4yc8Mk87j4XYCAAAAAAAA1E/MxfGF1dXyjW7E7zJO - 8hd3ul0rYwAAAAAAAKDeYiyOr6+Mh1n150aQs/0kfyLcQgAAAAAAAIB6i604/mwl/pXxZp7fG24fAAAA - AAAAQP3FUhxf3dgo//z9uFfGw/n2D8NtAwAAAAAAAJgdMRTH/1hbK988uFj5GTGkn3Y2BwcO3BduGQAA - AAAAAMBsmWZxPFoZf3DoofJo1qn8/QhybpDkT4VbBQAAAAAAADCbplUcX7QyBgAAAAAAAIjDpIvjq7uJ - emWc5Of68+2nw+0BAAAAAAAAmH2TLI4vrq6Vby30Kn82hoxWxjv3L1kZAwAAAAAAAM0yieI4+pVxmn9U - ZN1nwi0BAAAAAAAAaJZxF8dfrK1HvzLemuvNhdsBAAAAAAAA0DzjLI5PP/RwuRPvyvjzImn/KNwGAAAA - AAAAgOYaZ3EcbZL2KztZ9kC4BQAAAAAAAADN1rDi+HyRdZ4Nlw4AAAAAAADASIOK4+PDJEnCZQMAAAAA - AABwXQOK4wtWxgAAAAAAAAA3MOPF8etb8/NZuFQAAAAAAAAAqsxocWxlDAAAAAAAAHCrZq047qf5if4D - i1bGAAAAAAAAALdqhorjL/tJ58fhsgAAAAAAAAC4VTNSHJ8s2u2FcEkAAAAAAAAA3I6aF8dfFkn7uTJc - CwAAAAAAAAB7UOPi+NTRLOuFywAAAAAAAABgr+pWHPfT/PIgbf90p9W6K1wCAAAAAAAAAHeiTsVxP+28 - XSTJUvjqAAAAAAAAAOyHmhTHl7zLGAAAAAAAAGBMoi+Ok/z3LyUHrYwBAAAAAAAAxiXW4nj0LuMiy5/3 - LmMAAAAAAACAMYuzOO68M8yyw+ErAgAAAAAAADBOMRXH11fGp1qtu8PXAwAAAAAAAGDcoimOk/zd7TRd - Dl8LAAAAAAAAgEmJoDi2MgYAAAAAAACYpqkWx0l+Zph0Hg9fBQAAAAAAAIBpmFJx/NVoZbzZeszKGAAA - AAAAAGDaplAc/7mfdFbDnwcAAAAAAABg2iZYHF/pJ/mLW73ePeFPAwAAAAAAABCDCRXHpwepdxkDAAAA - AAAARGnMxbGVMQAAAAAAAEDsxlUcF1l+ZphYGQMAAAAAAABEbwzF8dcr451u18oYAAAAAAAAoA72uTg+ - O0jyJ8JHAwAAAAAAAFAH+1YcJ/kvtuZ6c+FjAQAAAAAAAKiLfSiOP+wn+ZPh4wAAAAAAAAComzspjvtp - Z3Nw4MB94aMAAAAAAAAAqKM9FcdJfq5I2k+FjwAAAAAAAACgzm63OB6tjHfuX7IyBgAAAAAAAJgVt1Ec - f1Rk3WfCrwEAAAAAAAAwK26lOB6tjLfmenPhVwAAAAAAAACYJTcqjvtpfn6QdZ4NPwoAAAAAAADALPp/ - xXGRdY5tp2kSfgwAAAAAAACAWVVRHJ8vrIwBAAAAAAAAmuPbxXGR5seHSWJlDAAAAAAAANAkoTi+YGUM - AAAAAAAA0FAvtFp3badpL/wTAAAi1mr9F19mbFwr1UcBAAAAAElFTkSuQmCC + iVBORw0KGgoAAAANSUhEUgAAB44AAAOdCAYAAAB6bE8jAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + wAAADsABataJCQAAZi5JREFUeF7s3V2MnXW99/8JIcQQY7DOrHU9rHnoMLZlHtesmh1jDDHGGGOMMcaD + /8HOPuTgf+Ah2WfEQw497IFp2jVrClMKQoUKiBUMEUPEcJOGmIbbfwWslYeCpdS2ttd/1vRXQb0KnXZm + 1u9a6/VOXgf3vd3Qzqxr7WR/8t3XkCRJkiRJkiRJkiRJkiRJkiRJkja4+4aGbtlfr0+E/6ckSZIkSZIk + SZIkadBamZ6+bamenesk2b0rQ0O3hP9vSZIkSZIkSZIkSdKgFIbjInh+33C+I/yXJEmSJEmSJEmSJEmD + 0L8Nx11r18fd/xPW4T8iSZIkSZIkSZIkSernSobjNe0k+3V7pDEV/mOSJEmSJEmSJEmSpH7tWsNxcLZd + T39YhP+sJEmSJEmSJEmSJKkP+5Th+KonD2RZI/y3SJIkSZIkSZIkSZL6qescjrve79TSe8J/myRJkiRJ + kiRJkiSpX1rHcHxFkh1ZynPXx5IkSZIkSZIkSZLUL617OL7itOtjSZIkSZIkSZIkSeqTbnA4XtOup48f + GB7Nwj9KkiRJkiRJkiRJklTFbmY4DrrXx/8d/nGSJEmSJEmSJEmSpKq1AcPxFbVs3947Ju4I/1hJkiRJ + kiRJkiRJUlXasOH4ilOdWvr98I+WJEmSJEmSJEmSJFWhDR6Orzq4L8+3hX+FJEmSJEmSJEmSJCnmNmk4 + 7jrVrmXfC/8aSZIkSZIkSZIkSVKsbeJwfNXBlUbD9bEkSZIkSZIkSZIkxdoWDMddJ9v17LvhXylJkiRJ + kiRJkiRJiqktGo6vOtgZG7sj/KslSZIkSZIkSZIkSTG0xcNx14lOLftG+NdLkiRJkiRJkiRJknpdD4bj + Ne16vucnw8OfDX8MSZIkSZIkSZIkSVKv6tVwvKaW/WG5ln85/FEkSZIkSZIkSZIkSb2op8Nx0L0+XhkZ + cX0sSZIkSZIkSZIkSb0ohuE4+GM7aXwt/LEkSZIkSZIkSZIkSVtVRMPxmu718f56/fbwx5MkSZIkSZIk + SZIkbXaxDcdX5K910vTu8EeUJEmSJEmSJEmSJG1mcQ7Hay51r4/3ZJnrY0mSJEmSJEmSJEnazCIejq86 + tpQkXwp/XEmSJEmSJEmSJEnSRleB4bjrYruW3f/E1NRt4Y8tSZIkSZIkSZIkSdqoKjIcX3Vsf5q6PpYk + SZIkSZIkSZKkjaxiw3HRrmfnl+rp/64MDd0S/gqSJEmSJEmSJEmSpJupasPxR9JX2mnaCn8NSZIkSZIk + SZIkSdKNVt3heM3au4+7f4fw15EkSZIkSZIkSZIkrbeKD8dr2vXs5c5I3gx/JUmSJEmSJEmSJEnSeuqH + 4Ti42E6yH3n3sSRJkiRJkiRJkiStsz4ajoP0t/vTdFf460mSJEmSJEmSJEmSPq3+G47XnOsk2b2ujyVJ + kiRJkiRJkiTpOurT4fiq37SzbEf4q0qSJEmSJEmSJEmSyurz4bhr7fr4PtfHkiRJkiRJkiRJklTeAAzH + Vz3fGWlMhb+2JEmSJEmSJEmSJOlqAzQcd7k+liRJkiRJkiRJkqR/b8CG4zXtJPt12/WxJEmSJEmSJEmS + JF1pM4fjV3fuKlaSvPS/FoHTnVr63+HHIEmSJEmSJEmSJEmD22YOx39fXCzOrXpu+52l//VIPHkgyxrh + xyFJkiRJkiRJkiRJg9dmD8fF7t1rTkzPFAfTRul/LgLvd2rpPUX4mUiSJEmSJEmSJEnSQLVVw3HXuWaz + eHZisvQ/G4Uke3Ipz10fS5IkSZIkSZIkSRqstnI4viru6+N07fo4/HgkSZIkSZIkSZIkqf/rxXDc9WGz + Wfwq4uvjdj19fN8XGln4MUmSJEmSJEmSJElS/9ar4fiq7vXxSrzvPj7t+liSJEmSJEmSJElS39fr4bjr + w+ZicXR8e+k/IxKHDwyPuj6WJEmSJEmSJEmS1J/FMBxf9dqu6eLBSK+P2/XsraUk/0H4sUmSJEmSJEmS + JElS/xTTcNz1QbNZ/GJsovSfF4mDy1k2HH58kiRJkiRJkiRJklT9YhuOrzq+667igSQv/edG4FSnln4/ + /AglSZIkSZIkSZIkqdrFOhx3da+Pn478+nhfnm8LP0pJkiRJkiRJkiRJqmYxD8dXRX59fLJTz74bfpyS + JEmSJEmSJEmSVL2qMBx3nVlYKJ4a217674nEwZVGw/WxJEmSJEmSJEmSpOpVleH4qtivj5fr2XfCj1aS + JEmSJEmSJEmSqlHVhuOuMwvN4qnRiN99nOTtnwwPfzb8iCVJkiRJkiRJkiQp7qo4HHddbrWKYzt2Fssl + /95InOjUsm+EH7MkSZIkSZIkSZIkxVtVh+Or3pufL45EfH3crud7VkZGXB9LkiRJkiRJkiRJireqD8dd + Fbg+/mMnyb8WfuSSJEmSJEmSJEmSFFf9MBxfdXp+vniiMV76Z4mB62NJkiRJkiRJkiRJUdZPw3FXFa6P + l5Pk7vDjlyRJkiRJkiRJkqTe12/D8VWn5xeKx0fjvj7eX6/fHn4NkiRJkiRJkiRJktS7+nU47rrU2n3l + +jgp//P1WruevdZJU9fHkiRJkiRJkiRJknpbPw/HV73bvT5ujJX+GSNwadWPn5iaui38SiRJkiRJkiRJ + kiRpaxuE4bjrH61W8dLUjqKT5KV/1ggcW0qSL4VfiyRJkiRJkiRJkiRtXYMyHF/11tx88Vge7fXxxXYt + u9/1sSRJkiRJkiRJkqQtbdCG4674r4/zVzpp2gq/IkmSJEmSJEmSJEna3AZxOL5q7fo43ncfr10fd38/ + 4VclSZIkSZIkSZIkSZvTIA/HXf+8Pi7588chfeXASNYMvy5JkiRJkiRJkiRJ2vgGfTi+6q+zc8Wj+Wjp + 3yMCa9fHe4Z23xp+bZIkSZIkSZIkSZK0cRmOP3Ix+uvj7OXOSO76WJIkSZIkSZIkSdLGZjj+T3+emS0e + yaK9Pj7XSbJ7V4aGbgm/QkmSJEmSJEmSJEm6uQzH5S6s/tlfmJwq/XvFIf3tcpbtCr9GSZIkSZIkSZIk + SbrxDMefrHt9/LDrY0mSJEmSJEmSJEn9nOH4011YbEV+fZz9pp1lO8KvVJIkSZIkSZIkSZLWl+H4+r05 + M1M8nDVK/64RWLs+vs/1sSRJkiRJkiRJkqT1Zjhen/PxXx8/3xlpTIVfryRJkiRJkiRJkiR9eobjG/PG + zGxxKN7r47OujyVJkiRJkiRJkiRdd4bjG3e+1Sqej/v6+Ol9aToWftWSJEmSJEmSJEmSVJ7h+OadmJ4p + DqbRXh+/36ml9xTh9y1JkiRJkiRJkiRJ/5HheGOcW/27Prf9ztKfQySePJBljfBrlyRJkiRJkiRJkqSP + MhxvrLivj9O16+Pwq5ckSZIkSZIkSZKkKxmON965ZrN4dmKy9GcShSQ7spTnro8lSZIkSZIkSZIkXclw + vHm618cr8b77+LTrY0mSJEmSJEmSJElrGY4314fNZvGriK+P2/X08QPDo1n4OEiSJEmSJEmSJEkaxAzH + W2Pt+jjJS39OEXB9LEmSJEmSJEmSJA1yhuOt82FzsTg6vr30ZxWJgytJMhw+GpIkSZIkSZIkSZIGJcPx + 1ju+667iwXjffXyqXUu/Hz4ekiRJkiRJkiRJkgYhw3FvfNBsFr8Ymyj9uUXi4HKWuT6WJEmSJEmSJEmS + BiHDcW91r48fiPfdx6eWaun3wkdFkiRJkiRJkiRJUr9mOO69MwsLxdORXx/vy/Nt4SMjSZIkSZIkSZIk + qd8yHMcj8uvjk5169t3wsZEkSZIkSZIkSZLUTxmO49K9Pn5qNO7r487Y2B3h4yNJkiRJkiRJkiSpHzIc + x+fyqtivj5fq+XfCR0iSJEmSJEmSJElS1TMcx+u9hYXiyOh46c82Bu16vucnw8OfDR8lSZIkSZIkSZIk + SVXNcBy3y61WcWzHzmK55OcbiRNL9fzr4eMkSZIkSZIkSZIkqYoZjqvhvfn54kgj7uvjlZER18eSJEmS + JEmSJElSFTMcV0cFro//2Enyr4WPliRJkiRJkiRJkqSqZDiuntPzC8UTkV8f76/Xbw8fMUmSJEmSJEmS + JEmxZziupvivj/PXlpPk7vAxkyRJkiRJkiRJkhRzhuNq614fPz4a7fXxpe718Z4sc30sSZIkSZIkSZIk + xZzhuPoutXZfuT5Oyn8PvdauZ6+10/Sr4SMnSZIkSZIkSZIkKbYMx/3j7bn54nA+Vvq7iMDFdi27/4mp + qdvCR0+SJEmSJEmSJElSLBmO+8s/Wq3ipakdRSfJS38nETi2P02/FD5+kiRJkiRJkiRJkmLIcNyf3pqb + Lx6L/Pq4+9kLH0NJkiRJkiRJkiRJvcxw3L/+eX1c8ruJQ/5KO01b4aMoSZIkSZIkSZIkqVcZjvvfX2fn + iscaro8lSZIkSZIkSZIkXSPD8WCI/fq4Xc9ePjCSNcPHUpIkSZIkSZIkSdJWZjgeLN3r40fz0dLfVwTW + ro/3DO2+NXw8JUmSJEmSJEmSJG1FhuPBc7HVKl6884ulv7M4pL/dn6a7wkdUkiRJkiRJkiRJ0mZnOB5c + f56ZLR7Jor0+PtdJsntXhoZuCR9VSZIkSZIkSZIkSZuV4XiwXVj9Hb0wOVX6+4vEb5azzPWxJEmSJEmS + JEmStJkZjunqXh8/7PpYkiRJkiRJkiRJGswMx1x1YbEV+/Xx8/uG8x3hoytJkiRJkiRJkiRpozIc8+/e + nJkpHs4apb/TCKxdH9/n+liSJEmSJEmSJEnauAzHlDlfgevj9khjKnyMJUmSJEmSJEmSJN1MhmM+yRsz + s8WheK+Pz7br6Q+L8FmWJEmSJEmSJEmSdIMZjvk03d/jcxOTpb/jGHTq2dP70nQsfKQlSZIkSZIkSZIk + rTfDMdfrxPRMcTCN9vr4/U4tvcf1sSRJkiRJkiRJknQDGY5Zj3Orv9NnI74+XkqyJ5fyvBE+3pIkSZIk + SZIkSZKuJ8MxNyLu6+N07fo4fMQlSZIkSZIkSZIkfVqGY27UuWYz7uvjWn5k3xcaWfioS5IkSZIkSZIk + SbpWhmNuVvf6eCXedx+fdn0sSZIkSZIkSZIkfUqGYzbCh81mcXR8e+nnIBKPHxgedX0sSZIkSZIkSZIk + lWU4ZiOtXR8neennIQLd6+P/Dh99SZIkSZIkSZIkSVczHLPRPmg2i1/EfX18cDnLhsMjIEmSJEmSJEmS + JMlwzGY5vuuu4sF43318qlNLvx8eA0mSJEmSJEmSJGmwMxyzmdauj8cmSj8fkTi4L8+3hcdBkiRJkiRJ + kiRJGswMx2yF7vXxA/G++/hUu5Z9LzwSkiRJkiRJkiRJ0uBlOGarnFlYKJ6O/Pp4pdFwfSxJkiRJkiRJ + kqTBy3DMVov8+vhku559NzwekiRJkiRJkiRJ0mBkOKYXziw0i6dG474+7oyN3REeE0mSJEmSJEmSJKm/ + MxzTK5dXvbpzV7Fc8tmJxIlOLftGeFQkSZIkSZIkSZKk/s1wTK+9t7BQHIn4+rhdz/f8ZHj4s+GRkSRJ + kiRJkiRJkvovwzExuNxqFcd27Iz5+viP++v518NjI0mSJEmSJEmSJPVXhmNicnp+vniiMV76eYpB9/p4 + ZWTE9bEkSZIkSZIkSZL6K8MxsanC9XE7aXwtPEKSJEmSJEmSJElS9TMcE6vT8wvF46NxXx/vr9dvD4+S + JEmSJEmSJEmSVN0Mx8TsUmv3levjpPwz1nv5a500vTs8TpIkSZIkSZIkSVI1MxxTBe/GfX18adWP905M + fCY8VpIkSZIkSZIkSVK1MhxTFf9otYqXpnYUnSQv/bxF4NhSknwpPFqSJEmSJEmSJElSdTIcUzVvzc0X + j+VjpZ+5CFxs17L7n5iaui08YpIkSZIkSZIkSVL8GY6poipcH+9PU9fHkiRJkiRJkiRJqkaGY6qsCtfH + 3WcsPG6SJEmSJEmSJElSnBmOqbp/Xh+XfAbjkL7STtNWeOQkSZIkSZIkSZKk+DIc0y/+OjtXPJqPln4W + I+D6WJIkSZIkSZIkSfFmOKafXIz8+rhdz17ujOTN8PhJkiRJkiRJkiRJcWQ4ph+dmov8+jjJfrQyNHRL + eAwlSZIkSZIkSZKk3mY4pl9dWP38vTA5VfrZjEP62+Us2xUeRUmSJEmSJEmSJKl3GY7pd3+emS0ezqK9 + Pj7XSbJ7XR9LkiRJkiRJkiSppxmOGQQXFluRXx9nv2ln2Y7wWEqSJEmSJEmSJElbm+GYQfJmBa6P73N9 + LEmSJEmSJEmSpK3OcMygqcD18fOdkcZUeEQlSZIkSZIkSZKkzc9wzKDqXh8fyhqln90IuD6WJEmSJEmS + JEnS1mU4ZpCdj/z6uJ1kv267PpYkSZIkSZIkSdJmZziG3cWJ6ZniYBrt9fH7nVp6TxGeWUmSJEmSJEmS + JGnDMxzDFedWP6/Pbb+z9LMciScPZFkjPLqSJEmSJEmSJEnSxmU4hn/l+liSJEmSJEmSJEkDl+EY/tO5 + ZrN4dmKy9HMdhSQ7spTnro8lSZIkSZIkSZK0MRmO4drivj5O166Pw6MsSZIkSZIkSZIk3XiGY/hkHzab + xa8ivj5u19PH932hkYVHWpIkSZIkSZIkSVp/hmO4Pt3r45V433182vWxJEmSJEmSJEmSbjjDMVy/D5uL + xdHx7aWf90gcPjA86vpYkiRJkiRJkiRJ68twDOv32q7p4sFIr4/b9eytpST/QXjEJUmSJEmSJEmSpE/P + cAw35oNms/jF2ETpZz8SB5ezbDg86pIkSZIkSZIkSdK1MxzDzTm+667igSQvfQYicKpTS78fHndJkiRJ + kiRJkiSpPMMx3Lzu9fHTkV8f78vzbeGxlyRJkiRJkiRJkv41wzFsnMivj0926tl3w6MvSZIkSZIkSZIk + fZThGDbWmYWF4qmx7aXPRCQOrjQaro8lSZIkSZIkSZL0UYZj2ByxXx8v17PvhK8BSZIkSZIkSZIkDXqG + Y9g8ZxaaxVOjEb/7OMnbPxke/mz4OpAkSZIkSZIkSdKgZjiGzXW51SqO7dhZLJc8I5E40all3whfCZIk + SZIkSZIkSRrEDMewNd6bny+ORHx93K7ne1ZGRlwfS5IkSZIkSZIkDWKGY9g6Fbg+/mMnyb8Wvh4kSZIk + SZIkSZI0KBmOYeudnp8vnmiMlz43MXB9LEmSJEmSJEmSNGAZjqE3qnB9vJwkd4evCkmSJEmSJEmSJPVz + hmPordPzC8Xjo3FfH++v128PXxmSJEmSJEmSJEnqxwzH0HuXWruvXB8n5c9Sr7Xr2WudNHV9LEmSJEmS + JEmS1K8ZjiEeb8/NF4fzsdLnKQKXVv34iamp28LXhyRJkiRJkiRJkvolwzHE5R+tVvHS1I6ik+Slz1UE + ji0lyZfCV4gkSZIkSZIkSZL6IcMxxOmtufnisXivjy+2a9n9ro8lSZIkSZIkSZL6JMMxxCv+6+P8lU6a + tsLXiSRJkiRJkiRJkqqa4Rji99fZueKxRtzXx93vkvC1IkmSJEmSJEmSpKplOIZq+Of1ccmzFof0lQMj + WTN8tUiSJEmSJEmSJKlKGY6hWrrXx4/mo6XPXATWro/3DO2+NXzFSJIkSZIkSZIkqQoZjqF6LkZ/fZy9 + 3BnJXR9LkiRJkiRJkiRVJcMxVNefZ2aLR7Jor4/PdZLs3pWhoVvC140kSZIkSZIkSZJizXAM1XZh9Tl7 + YXKq9BmMxG+Ws2xX+MqRJEmSJEmSJElSjBmOoT90r48fdn0sSZIkSZIkSZKkG8lwDP3jwmIr+uvjfcP5 + jvD1I0mSJEmSJEmSpFgyHEP/eXNmpng4a5Q+lxFYuz6+z/WxJEmSJEmSJElSPBmOoT+dj//6+PnOSGMq + fBVJkiRJkiRJkiSplxmOob+9MTNbHIr3+vis62NJkiRJkiRJkqQIMhxD/zvfahXPx319/PS+NB0LX0uS + JEmSJEmSJEna6gzHMDhOTM8UB9Nor4/f79TSe4rw3SRJkiRJkiRJkqQtzHAMg+Xc6nP53PY7S5/ZSDx5 + IMsa4StKkiRJkiRJkiRJW5HhGAZT3NfH6dr1cfiakiRJkiRJkiRJ0mZnOIbBda7ZLJ6dmCx9fqOQZEeW + 8tz1sSRJkiRJkiRJ0mZnOAa618cr8b77+LTrY0mSJEmSJEmSpE3OcAx0fdhsFr+K+Pq4XU8fPzA8moWv + LkmSJEmSJEmSJG1khmPg49auj5O89JmOgOtjSZIkSZIkSZKkzchwDPy7D5uLxdHx7aXPdSQOriTJcPga + kyRJkiRJkiRJ0s1mOAau5fiuu4oH43338al2Lf1++CqTJEmSJEmSJEnSzWQ4Bj7JB81m8YuxidJnPBIH + l7PM9bEkSZIkSZIkSdLNZDgGrkf3+viBeN99fGqpln4vfK1JkiRJkiRJkiRpvRmOget1ZmGheDry6+N9 + eb4tfL1JkiRJkiRJkiTpejMcA+sV+fXxyU49+274ipMkSZIkSZIkSdL1ZDgGbkT3+vip0bivjztjY3eE + rzpJUr+1lCTfWqrnrwEAAAAAGyX747+NLRvGcAz97VJrd/F/vrizWE7KvwN6rV3PXuuk6d1hYpAk9VNL + Sf6Dsi9/AAAAACA+hmMYDO8tLBRHRsdLvwdi0K7ne34yPPzZMDVIkvohwzEAAAAAVIfhGAbH5VarOLZj + Z7Fc8l0QiRNL9fzrYW6QJFU9wzEAAAAAVIfhGAbPe/PzxZFG3NfHKyMjro8lqeoZjgEAAACgOgzHMJgq + cH38x06Sfy1MD5KkKmY4BgAAAIDqMBzDYDs9v1A8Efn18f56/fYwQUiSqpThGAAAAACqw3AMxH99nL+2 + nCR3hxlCklSVDMcAAAAAUB2GY+Cq7vXx46PRXh9f6l4f78ky18eSVJUMxwAAAABQHYZj4OMutXZfuT5O + yr8zeq1dz15rp+lXwyQhSYo5wzEAAAAAVIfhGCjz9tx8cTgfK/3eiMDFdi27/4mpqdvCNCFJijHDMQAA + AABUh+EYuJZ/tFrFS1M7ik6Sl35/RODY/jT9UpgnJEmxZTgGAAAAgOowHAOf5uTsXPFINlr6HdJr7Xp2 + fqme/u/RoaFbw0whSYolwzEAAAAAVIfhGLge/7w+LvkeiUP+SjtNW2GqkCTFkOEYAAAAAKrDcAysx19n + 54rHGnG/+3hletq7jyUphgzHAAAAAFAdhmNgvWK/Pm7Xs5cPjGTNMFtIknqV4RgAAAAAqsNwDNyo7vXx + o3mc7z5etXZ9vGdot3cfS1KvMhwDAAAAQHUYjoGbcbHVKl6884ul3y9xSH+7P013hQlDkrSVGY4BAAAA + oDoMx8BG+PPMbPFwFu318blOkt27MjR0S5gyJElbkeEYAAAAAKrDcAxslAur3ycvTE6VftdE4jfLWeb6 + WJK2KsMxAAAAAFSH4RjYaK6PJUlrGY4BAAAAoDoMx8BmuLDYiv36+Pl9w/mOMG1IkjYjwzEAAAAAVIfh + GNhMb65dHzdKv38isHZ9fJ/rY0nanDZrOD6cjxUnV/8HDAAAAACwcS61yscegI1yrtksnp2YLP3f/Ueh + lh/Z94VGFmYOSdJGtVnD8ZNjE6X/AwcAAAAAAIjfGzOzxaF4r4/PtuvpD4uwdUiSNiDDMQAAAAAAUKb7 + fx7/uYivjzv17Ol9aToWJg9J0s1kOAYAAAAAAD7JiemZ4mAa7fXx+51aeo/rY0m6yQzHAAAAAADApzm3 + uBj3u4+T7MmlPG+E+UOStN4MxwAAAAAAwPWK+/o4Xbs+DhOIJGk9GY4BAAAAAID1ONdsxn19XMuP7PtC + IwtTiCTpejIcAwAAAAAAN6J7fbwS77uPT7s+lqR1ZDgGAAAAAABu1IfNxeLo+PbSrSASjx8YHnV9LEmf + luEYAAAAAAC4WWvXx0leuhlEoHt9/N9hGpEklWU4BgAAAAAANsIHzWbxi7ivjw8uZ9lwmEgkSR/PcAwA + AAAAAGyk47vuKh6M993Hpzq19PthJpEkXc1wDAAAAAAAbLS16+OxidINIRIH9+X5tjCXSJIMxwAAAAAA + wGbpXh8/EO+7j0+1a9n3wmQiSYOd4RgAAAAAANhMZxYWiqcjvz5eaTRcH0sa7AzHAAAAAADAVoj8+vhk + u559N8wnkjR4GY4BAAAAAICtcmahWTw1Gvf1cWds7I4wo0jS4GQ4BgAAAAAAttLlVa/u3FUsl+wLkTjR + qWXfCFOKJA1GhmMAAAAAAKAX3ltYKI5EfH3crud7fjI8/NkwqUhSf2c4BgAAAAAAeuVyq1Uc27Ez5uvj + P+6v518Ps4ok9W+GYwAAAAAAoNdOz88XTzTGSzeHGHSvj1dGRlwfS+rfDMcAAAAAAEAMqnB93E4aXwsT + iyT1V4ZjAAAAAAAgJqfnF4rHR+O+Pt5fr98ephZJ6o8MxwAAAAAAQGwutXZfuT5OyneI3stf66Tp3WFu + kaTqZzgGAAAAAABi9W7c18eXVv1478TEZ8LsIknVzXAMAAAAAADE7B+tVvHS1I6ik+Slm0QEji0lyZfC + 9CJJ1cxwDAAAAAAAVMFbc/PFY/lY6S4RgYvtWnb/E1NTt4UJRpKqleEYAAAAAACoiipcH+9PU9fHkqqX + 4RgAAAAAAKiaKlwfr0xPuz6WVJ0MxwAAAAAAQBX98/q4ZKeIQ/pKO01bYZKRpLgzHAMAAAAAAFX219m5 + 4tF8tHSviIDrY0nVyHAMAAAAAABU3cXIr4/b9ezlzkjeDPOMJMWX4RgAAAAAAOgXp+Yivz5Osh+tDA3d + EmYaSYonwzEAAAAAANBPLiwuFi9MTpXuF3FIf7ucZbvCVCNJcWQ4BgAAAAAA+tGfZ2aLh7Nor4/PdZLs + XtfHkqLJcAwAAAAAAPSrC4utyK+Ps9+0s2xHmG0kqXcZjgEAAAAAgH73ZgWuj+9zfSyplxmOAQAAAACA + QVCB6+PnOyONqTDhSNLWZjgGAAAAAAAGSff6+FDWKN03IuD6WFJvMhwDAAAAAACD5nzk18ftJPt12/Wx + pK3McAwAAAAAAAyqE9MzxcE02uvj9zu19J4ibDqStKkZjgEAAAAAgEF2bnGxeG77naV7RySePJBljTDt + SNLmZDgGAAAAAABwfSxpwDMcAwAAAAAAXHGu2SyenZgs3T6ikGRHlvLc9bGkjc9wDAAAAAAA8K/ivj5O + 166Pw9QjSRuT4RgAAAAAAOA/fdhsFr+K+Pq4XU8f3/eFRhYmH0m6uQzHAAAAAAAA19a9Pl6J993Hp10f + S9qQDMcAAAAAAACf7MPmYnF0fHvpJhKJwweGR10fS7rxDMcAAAAAAADX57Vd08WDkV4ft+vZW93dJ0xA + krS+DMcAAAAAAADX74Nms/jF2ETpPhKJg8tZNhymIEm6vgzHAAAAAAAA63d8113FA0leupNE4NRSLf1e + mIMk6dMzHAMAAAAAANyY7vXx05FfH+/L821hFpKka2c4BgAAAAAAuDmRXx+f7NSz74ZpSJLKMxwDAAAA + AADcvDMLC8VTY9tLd5NIHFxpNFwfSyrPcAwAAAAAALBxYr8+Xq5n3wkzkSR9lOEYAAAAAABgY51ZaBZP + jUb87uMkb/9kePizYS6SJMMxAAAAAADAZrjcahXHduwslkt2lEicWKrnXw+TkaRBz3AMAAAAAACwed6b + ny+ONMZL95QYtOv5npWREdfH0qBnOAYAAAAAANhcFbg+/mMnyb8W5iNJg5jhGAAAAAAAYGucnp8vnnB9 + LCnGDMcAAAAAAABbJ/7r4/y15SS5O0xJkgYlwzEAAAAAAMDWOz2/UDw+Gvf18f56/fYwKUnq9wzHAAAA + AAAAvXGptfvK9XFSvrf0WruevdZO06+GWUlSP2c4BgAAAAAA6K235+aLw/lY6eYSgUvtWnb/E1NTt4V5 + SVI/ZjgGAAAAAADovX+0WsVLUzuKTpKXbi8ROLaUJF8KE5OkfstwDAAAAAAAEI+35uaLx+K9Pr7o+ljq + 0wzHAAAAAAAAcYn/+jh/pZOmrTA3SeqHDMcAAAAAAABx+uvsXPFYI+7r45XpadfHUj9kOAYAAAAAAIjX + P6+PS/aYOKSvHBjJmmF6klTVDMcAAAAAAADx614fP5qPlu4yEVi7Pt4ztPvWMEFJqlqGYwAAAAAAgGq4 + GP31cfZyZyR3fSxVMcMxAAAAAABAtfx5ZrZ4JIv2+vhcJ8nuXRkauiXMUZKqkOEYAAAAAACgei4sLhYv + TE6V7jSR+M1ylu0Kk5Sk2DMcAwAAAAAAVFf3+vhh18eSbjbDMQAAAAAAQLVdWGxFf328bzjfEeYpSTFm + OAYAAAAAAOgPb87MFA9njdLtJgJr18f3uT6W4sxwDAAAAAAA0D/Ox399/HxnpDEVpipJsWQ4BgAAAAAA + 6D9vzMwWh+K9Pj7r+liKLMMxAAAAAABAfzrfahXPx319/PS+NB0Ls5WkXmY4BgAAAAAA6G8npmeKg2m0 + 18fvd2rpPUXYriT1KMMxAAAAAABA/zu3uFg8t/3O0l0nEk8eyLJGmLAkbXWGYwAAAAAAgMER9/VxunZ9 + HGYsSVuZ4RgAAAAAAGCwnGs2i2cnJks3nigk2ZGlPHd9LG1lhmMAAAAAAIDB1L0+Xon33cenXR9LW5jh + GAAAAAAAYHB92GwWv4r4+rhdTx8/MDyahWlL0mZlOAYAAAAAAGDt+jjJS3efCLg+ljY7wzEAAAAAAABd + HzSbxS/Gt5duP5E4uJIkw2HmkrSRGY4BAAAAAAD4uOO77ioejPfdx6fatfT7YeqStFEZjgEAAAAAAPh3 + a9fHYxOlO1AkDi5nmetjaaMyHAMAAAAAAHAt3evjB+J99/GppVr6vTB7SbqZDMcAAAAAAAB8kjMLC8XT + kV8f78vzbWH+knQjGY4BAAAAAAC4HpFfH5/s1LPvhglM0nozHAMAAAAAAHC9utfHT43GfX3cGRu7I0xh + kq43wzEAAAAAAADrcXlV7NfHS/X8O2EOk3Q9GY4BAAAAAAC4Ee8tLBRHRsdLt6IYtOv5np8MD382zGKS + PinDMQAAAAAAADfqcqtVHNuxs1gu2YsicWKpnn89TGOSrpXhGAAAAAAAgJv13vx8caQR9/XxysiI62Pp + WhmOAQAAAAAA2AgVuD7+YyfJvxZmMkkfz3AMAAAAAADARjo9v1A8Efn18f56/fYwl0nqZjgGAAAAAABg + o11q7Y78+jh/bTlJ7g6TmSTDMQAAAAAAAJule338+Gi018eXutfHe7LM9bFkOAYAAAAAAGAzda+PX/7i + jqKT5KW7UgRe7SSN/wrzmTSYGY4BAAAAAADYCm/NzReH87HSbSkCF9u17P4npqZuCzOaNFgZjgEAAAAA + ANgq/2i1ipemor4+PrY/Tb8UpjRpcDIcAwAAAAAAsNW618ePRX59vDI97fpYg5PhGAAAAAAAgF745/Vx + ydYUh/yVdpq2wqwm9XeGYwAAAAAAAHrpr7NzxWMN18dSTzMcAwAAAAAA0GuxXx+369nLB0ayZpjYpP7L + cAwAAAAAAEAsutfHj+ajpftTBNauj/cM7b41TG1S/2Q4BgAAAAAAICYXW63ixTu/WLpBxSH97f403RXm + Nqk/MhwDAAAAAAAQoz/PzBYPZ9FeH5/rJNm9K0NDt4TZTap2hmMAAAAAAABidWFxsXhhcqp0j4rEb5az + zPWxqp/hGAAAAAAAgNi5PpY2OcMxAAAAAAAAVXBhsRX79fHz+4bzHWGGk6qV4RgAAAAAAIAqeXPt+rhR + ulFFYO36+D7Xx6pahmMAAAAAAACq5nwFro/bI42pMMlJ8Wc4BgAAAAAAoKremJktDsV7fXy2XU9/WIRd + Too6wzEAAAAAAABV9vfFxeK5icnSzSoGnXr29L40HQvznBRnhmMAAAAAAAD6wYnpmeJgGu318fudWnqP + 62NFm+EYAAAAAACAfnFucbF4NuLr46Uke3IpzxthqpPiyXAMAAAAAABAv4n7+jhduz4Oc50UR4ZjAAAA + AAAA+tG5ZjPu6+NafmTfFxpZmO2k3mY4BgAAAAAAoJ91r49X4n338WnXx4oiwzEAAAAAAAD97sPmYnF0 + fHvprhWJxw8Mj7o+Vu8yHAMAAAAAADAo1q6Pk7x034pA9/r4v8OMJ21thmMAAAAAAAAGyQfNZvGLuK+P + Dy5n2XCY86StyXAMAAAAAADAIDq+667iwXjffXyqU0u/HyY9afMzHAMAAAAAADCo1q6PxyZK965IHNyX + 59vCtCdtXoZjAAAAAAAABl33+viBeN99fKpdy74X5j1pczIcAwAAAAAAwO7izMJC8XTk18crjYbrY21O + hmMAAAAAAAD4SOTXxyfb9ey7YeqTNi7DMQAAAAAAAPyrMwvN4qnRuK+PO2Njd4TJT7r5DMcAAAAAAADw + ny6venXnrmK5ZAuLxIlOLftGmP2km8twDAAAAAAAANf23sJCcSTi6+N2Pd/zk+Hhz4b5T7qxDMcAAAAA + AADwyS63WsWxHTtjvj7+4/56/vUwAUrrz3AMAAAAAAAA1+f0/HzxRGO8dB+LQff6eGVkxPWx1p/hGAAA + AAAAAK5fFa6P20nja2EOlK4vwzEAAAAAAACs3+n5heLx0bivj/fX67eHWVD65AzHAAAAAAAAcGMutXZf + uT5Oyjez3stf66Tp3WEalK6d4RgAAAAAAABuzrtxXx9fWvXjvRMTnwkTofSfGY4BAAAAAADg5v2j1Spe + mtpRdJK8dD+LwLGlJPlSmAmlf81wDAAAAAAAABvnrbn54rF8rHRDi8DFdi27/4mpqdvCXChdyXAMAAAA + AAAAG6sK18f709T1sT7KcAwAAAAAAACbowrXxyvT066PZTgGAAAAAACAzfTP6+OSTS0O6SvtNG2F+VCD + muEYAAAAAAAANt9fZ+eKR/PR0m0tAq6PBz3DMQAAAAAAAGyNi5FfH7fr2cudkbwZpkQNUoZjAAAAAAAA + 2Fqn5iK/Pk6yH60MDd0SJkUNQoZjAAAAAAAA2HoXFheLFyanSre2OKS/Xc6yXWFWVL9nOAYAAAAAAIDe + +fPMbPFwFu318blOkt3r+ngAMhwDAAAAAABAb11YbEV+fZz9pp1lO8LEqH7McAwAAAAAAABxeLMC18f3 + uT7uzwzHAAAAAAAAEI/z8V8fP98ZaUyFuVH9kuEYAAAAAAAA4tO9Pj6UNUq3uAi4Pu63DMcAAAAAAAAQ + p9ivj9tJ9uu26+P+yHAMAAAAAAAAcTsxPVMcTKO9Pn6/U0vvKcL+qIpmOAYAAAAAAID4nVtcLJ7bfmfp + NheJJw9kWSPMkKpahmMAAAAAAACoDtfH2pQMxwAAAAAAAFAt55rN4tmJydKdLgpJdmQpz10fVynDMQAA + AAAAAFRT3NfH6dr1cZglFXuGYwAAAAAAAKiuD5vN4lcRXx+36+nj+77QyMI8qVgzHAMAAAAAAED1da+P + V+J99/Fp18eRZzgGAAAAAACA/vBhc7E4Or69dL+LxOH28HgSpkrFlOEYAAAAAAAA+stru6aLByO9Pm7X + s7e6G2WYKxVLhmMAAAAAAADoPx80m8UvxiZKt7xIHFzOsuEwW6rXGY4BAAAAAACgfx3fdVfxQJKXbnoR + OLVUS78Xpkv1MsMxAAAAAAAA9Lfu9fHTkV8f78vzbWHCVC8yHAMAAAAAAMBgiPz6+GSnnn03zJja6gzH + AAAAAAAAMDjOLCwUT41tL934InFwpdFwfbzVGY4BAAAAAABg8MR+fbxcz74TJk1tRYZjAAAAAAAAGExn + FprFU6MRv/s4yds/GR7+bJg2tZkZjgEAAAAAAGBwXW61imM7dhbLJZtfJE4s1fOvh3lTm5XhGAAAAAAA + AHhvfr440hgv3f5i0K7ne1ZGRlwfb1aGYwAAAAAAAKCrAtfHf+wk+dfC1KmNzHAMAAAAAAAAfNzp+fni + CdfHg5XhGAAAAAAAAPh38V8f568tJ8ndYfbUzWY4BgAAAAAAAK7l9PxC8fho3NfH++v128P8qRvNcAwA + AAAAAAB8kkut3Veuj5PybbDX2vXstXaafjVMoLqRDMcAAAAAAADA9Xh7br44nI+V7oMRuNSuZfc/MTV1 + W5hCtZ4MxwAAAAAAAMD1+kerVbw0taPoJHnpThiBY0tJ8qUwh+p6MxwDAAAAAAAA6/XW3HzxWLzXxxdd + H68zwzEAAAAAAABwI+K/Ps5f6aRpK0yj+qQMxwAAAAAAAMDN+OvsXPFYI+7r45XpadfHn5ThGAAAAAAA + ALhZ/7w+LtkO45C+cmAka4aZVP+e4RgAAAAAAADYKN3r40fz0dINMQJr18d7hnbfGuZSXc1wDAAAAAAA + AGyki9FfH2cvd0Zy18cfz3AMAAAAAAAAbIY/z8wWj2TRXh+f6yTZvStDQ7eE6XSwMxwDAAAAAAAAm+XC + 4mLxwuRU6aYYid8sZ9muMJ8OboZjAAAAAAAAYLN1r48fdn0cb4ZjAAAAAAAAYCtcWGxFf328bzjfEabU + wcpwDAAAAAAAAGylN2dmioezRunOGIG16+P7Bu362HAMAAAAAAAAbLXz8V8fP98ZaUyFWbX/MxwDAAAA + AAAAvfLGzGxxKN7r47MDc31sOAYAAAAAAAB66XyrVTwf9/Xx0/vSdCxMrP2Z4RgAAAAAAACIwYnpmeJg + Gu318fudWnpPEXbWvstwDAAAAAAAAMTi3OJi8ezEZOkGGYUke/JAljXC3No/GY4BAAAAAACA2MR9fZyu + XR+HybU/MhwDAAAAAAAAMTrXbMZ+fXxk3xcaWZheq53hGAAAAAAAAIhZ9/p4Jd53H5/ui+tjwzEAAAAA + AAAQuw+bzeJXEV8ft+vp4weGR6t7fWw4BgAAAAAAAKpi7fo4yUs3ygicbtfy/wlTbLUyHAMAAAAAAABV + 8kGzWfxifHvpThmJgytJMhwm2WpkOAYAAAAAAACq6Piuu4oH43338al2Lf1+mGXjz3AMAAAAAAAAVNXa + 9fHYROlmGYmDy1kW//Wx4RgAAAAAAACouu718QPxvvv41FIt/V6YaOPMcAwAAAAAAAD0gzMLC8XTkV8f + 78vzbWGqjSvDMQAAAAAAANBPIr8+PtmuZ98Nc208GY4BAAAAAACAftO9Pn5qNO7r487Y2B1htu19hmMA + AAAAAACgH11eFfv18VI9/06Ybnub4RgAAAAAAADoZ+8tLBRHRsdLd80YtOv5np8MD382TLi9yXAMAAAA + AAAA9LvLrVZxbMfOYrlk24zEiaV6/vUw4259hmMAAAAAAABgULw3P18cacR9fbwyMrL118eGYwAAAAAA + AGCQVOD6+I+dJP9amHS3JsMxAAAAAAAAMIhOzy8UT0R+fby/Xr89TLubm+EYAAAAAAAAGFSXWrsjvz7O + X1tOkrvDvLt5GY4BAAAAAACAQde9Pn58NNrr40vd6+M9WbZ518eGYwAAAAAAAIAr18cvf3FH0Uny0g00 + Aq92ksZ/hal3YzMcAwAAAAAAAHzkrbn54nA+VrqDRuBiu5bd/8TU1G1h8t2YDMcAAAAAAAAA/+ofrVbx + 0lTU18fH9qfpl8Lse/MZjgEAAAAAAADKda+PH4v8+nhlevrmr48NxwAAAAAAAADXdmFxsXhhcqp0F41D + +tv9aborTMA3luEYAAAAAAAA4NP9dXaueKzRp9fHhmMAAAAAAACA6/PPdx+XbKQxaNezlzsjeTPMwdef + 4RgAAAAAAABgfbrXx4/mo6VbaQTOdZLs3pWhoVvCLPzpGY4BAAAAAAAA1u9iq1W8eOcXS/fSSPxmOcuu + 793HhmMAAAAAAACAG/fnmdni4Szu6+P7Pu362HAMAAAAAAAAcHMuLC4WL0xOlW6nkXi+M9KYCjPxf2Y4 + BgAAAAAAANgYkV8fn73m9bHhGAAAAAAAAGDjXFhsxX59/PS+NB0Lk/GVDMcAAAAAAAAAG+//m54pDqaN + 0j01Au+069n/E2ZjwzEAAAAAAADAZoh8OD6zlGT/bxF2Y8MxAAAAAAAAwAY622wWvxzfXrqjRuLR9vB4 + EibjKxmOAQAAAAAAADbG8V13FQ+meemGGoHTnST/QZiK/zXDMQAAAAAAAMDN+bC5GPuV8eH/uDL+eIZj + AAAAAAAAgBvXvTJeiffK+Eynlt7zz3cZXyvDMQAAAAAAAMD6/X1xsXhuYrJ0L43E0500HQvT8CdnOAYA + AAAAAABYnxN3TRcH00bpVhqB67sy/niGYwAAAAAAAIDrE/uVcaeePXMgSSbCHHz9GY4BAAAAAAAAPt2f + pmeKh7LR0n00Auu/Mv54hmMAAAAAAACAa7uwuFi8MDlVuovGIf3t/jTdFSbgG8twDAAAAAAAAFDu9emZ + 4lC8V8Znb+rK+OMZjgEAAAAAAAD+1fnI32XcrufPdmq1yTD73nyGYwAAAAAAAICPvDEzWxzKGqU7aATW + rozvGxq6JUy+G5PhGAAAAAAAAODKu4yf7/d3GV8rwzEAAAAAAAAw6E7OzhWPRPou43Y9O99JsnuPDg3d + Gmbejc9wDAAAAAAAAAyqi61W8ULEV8adevbicpJMh3l38zIcAwAAAAAAAIPoLxFfGa/a/Cvjj2c4BgAA + AAAAAAZJ7FfGS7Xsd/vr9dkw6W5NhmMAAAAAAABgUJyanS1+mo+VbpwR2Nor449nOAYAAAAAAAD6XexX + xu0k+/1yrTEfZtytz3AMAAAAAAAA9LNTc3PFT/No32V8sXtlvGdo99ZfGX88wzEAAAAAAADQjy6temlq + R9FJ8tJNMwKvdpLGf4XptrcZjgEAAAAAAIB+8/bcXHG4MV66ZUbgUruW3b93YuIzYbbtfYZjAAAAAAAA + oF9U4cp4qZ5/Ocy18WQ4BgAAAAAAAPrBO/Pzxc8ivzJeaTTiuTL+eIZjAAAAAAAAoMpivzLuJNkf2rXs + K2GijTPDMQAAAAAAAFBV7851r4zHSjfLCMR9ZfzxDMcAAAAAAABA1VxqXbkyXk7K98oIHF8eSb8aZtn4 + MxwDAAAAAAAAVfLu/ELxeLxXxl0/3pNlt4dJthoZjgEAAAAAAIAquNxqFcd27CwORPou41Un2rXsG2GK + rVaGYwAAAAAAACB27y8sFD8fHS/dJmPQrud7lrZt+1yYYauX4RgAAAAAAACIVfRXxrXs9U4t/WaYX6ub + 4RgAAAAAAACI0fvz8V8Zr3x+srpXxh/PcAwAAAAAAADE5PKqyN9l/OZSknwrTK79keEYAAAAAAAAiMXf + FpprW2PZBhmD7pXx3jsm7ghza/9kOAYAAAAAAAB67eqV8QMRXxm3k/zbYWbtvwzHAAAAAAAAQC990GwW + z4xvL90do5Dk7c7YWP9dGX88wzEAAAAAAADQK8d33VU8mDZKN8cIvNVJ8h+EabW/MxwDAAAAAAAAW+1s + /FfGh/bX67Uwq/Z/hmMAAAAAAABgK125Mo72XcbvDMyV8cczHAMAAAAAAABb4Wxzsfjl+GTpvhiDTj17 + ZLlWG5wr449nOAYAAAAAAAA2W/fKeMWVcbwZjgEAAAAAAIDN8mFzsTga87uM69mje0dGkjCfDm6GYwAA + AAAAAGAzvLZrulhJor0yPj3wV8Yfz3AMAAAAAAAAbKS/Ly4Wz03E+y7jVU/vS9OxMJmqm+EYAAAAAAAA + 2Cgn7pouHkobpRtiBM50auk9RdhK9bEMxwAAAAAAAMDNiv3KuFPPnjmQJBNhJtW/ZzgGAAAAAAAAbsaf + pmeKh7LR0t0wAq6MryfDMQAAAAAAAHAjzkf/LuP06P563ZXx9WQ4BgAAAAAAANbr9emZ4lC8V8ZnXRmv + M8MxAAAAAAAAcL3Ot1pxXxnXsmc7tdpkmEN1vRmOAQAAAAAAgOvxxsxscShrlO6DETjXrqc/vG9o6JYw + hWo9GY4BAAAAAACAT3JhcbF4YXKqdBeMQ/7iUpJMhwlUN5LhGAAAAAAAALiWk7NzxSORvsu4Xc/Od5Ls + 3qNDQ7eG+VM3muEYAAAAAAAA+HcXW62or4w79ezFZVfGG5fhGAAAAAAAAPi4v8zOFT/Nx0p3wAi4Mt6M + DMcAAAAAAABAV+xXxku17HdL9cZsmDq1kRmOAQAAAAAAgFNz8V8Z7xna7cp4szIcAwAAAAAAwOC6emXc + Kdn8IvH75VpjPsyb2qwMxwAAAAAAADCY3p6bLw7He2V8qZ1kP3JlvEUZjgEAAAAAAGCwXFr10tSOopPk + pVtfBF7dX2/8V5g0tRUZjgEAAAAAAGBwvD0/XxxujJdufBG41K5l9++dmPhMmDO1VRmOAQAAAAAAoP9F + f2Vcy/6wXMu/HGZMbXWGYwAAAAAAAOhv78zPFz9rRPwu41p2/0qj4cq4lxmOAQAAAAAAoD9V4F3Gx9u1 + 7CthulQvMxwDAAAAAABA/3l3zpWx1pHhGAAAAAAAAPrHpdaVK+PlpHzHi8Dx5ZH0q2GuVCwZjgEAAAAA + AKA/vLewUBwZHS/d72LQrud7lrZt+1yYKhVThmMAAAAAAACotsutVnFsx87iQLzvMn59qZZ9M0yUijHD + MQAAAAAAAFTX+wsLxc9dGetmMxwDAAAAAABA9VxeFfWVcS17vT2SfivMkoo9wzEAAAAAAABUy/vzC2t7 + XNlOF4PulfHK5yddGVcpwzEAAAAAAABUQ/RXxvXszU7S+HaYIlWlDMcAAAAAAAAQv78tNKO/Mt57x8Qd + YYZU1TIcAwAAAAAAQNxe3bmreCDeK+OTS/X8O2F+VFUzHAMAAAAAAECcPmg2i2fGt5fucVGopQdXkmQ4 + TI+qcoZjAAAAAAAAiM/xXXcVD6aN0i0uAm91kvwHYXJUP2Q4BgAAAAAAgHicjf3KuJ49sr9er4W5Uf2S + 4RgAAAAAAADicOXKONp3Gb/jyriPMxwDAAAAAABAb51tLha/HJ8s3d0i8ejekZEkTIzqxwzHAAAAAAAA + 0DvdK+MVV8bqdYZjAAAAAAAA2HofNheLoxG/y7hdzw63h8ddGQ9KhmMAAAAAAADYWiemZ4qDaaN0Z4vA + mXYt/58wJ2pQMhwDAAAAAADA1vj74mLx3ETU7zJ+ppOmY2FK1CBlOAYAAAAAAIDN96fpmeKhiK+MO7X0 + niJsiBrADMcAAAAAAACweSpwZXz0QJJMhPlQg5rhGAAAAAAAADbH2pVxNlq6p0XAlbE+ynAMAAAAAAAA + G+t85FfG7Xr+bKdWmwyToWQ4BgAAAAAAgI30xsxscSjeK+OzroxVmuEYAAAAAAAAbt75VivudxnXsl8/ + UBt1ZazyDMcAAAAAAABwc07OzBaPRHpl3K5n5ztJdu/K0NAtYSKU/jPDMQAAAAAAANyYC4uLxQuTU6V7 + WRzyF5eSZDpMg9K1MxwDAAAAAADA+p2cnYv+yvjo0NCtYRaUPjnDMQAAAAAAAFy/i61W3FfGtex3++v1 + 2TAHSteX4RgAAAAAAACuz19m54qf5mOl+1gEXBnrxjMcAwAAAAAAwCeL/cq4nWS/X6415sMEKK0/wzEA + AAAAAABc26m57pVxnO8yXnWxe2W8Z2i3K2PdXIZjAAAAAAAA+E+XVr145xeLTskWFomX27XclbE2JsMx + AAAAAAAA/Ku35+aKw/G+y/hSu5bdv3di4jNh8pNuPsMxAAAAAAAAXNG9Mn5pakfRSfLSDSwCry7V8y+H + qU/auAzHAAAAAAAAsLt4Z36+ONwYL92+IuDKWJub4RgAAAAAAIBBFvuVcSfJ/rBcc2WsTc5wDAAAAAAA + wKDqXhn/rBH3u4xXGg1Xxtr8DMcAAAAAAAAMmkutK1fGy0n51hWB40u17Cth0pM2P8MxAAAAAAAAg+Td + ufni8civjPdk2e1hzpO2JsMxAAAAAAAAg+Byq1Uc27GzOBDpu4xXnejUsm+EGU/a2gzHAAAAAAAA9Lv3 + FxaKn4+Ol+5aMWjX8z1L27Z9Lkx40tZnOAYAAAAAAKBfVeDK+PVOLf1mmO6k3mU4BgAAAAAAoB9V4cp4 + 5fOTrowVR4ZjAAAAAAAA+snlVZFfGb/ZHkm/FeY6KY4MxwAAAAAAAPSLvy0013aqsv0qBt0r4713TNwR + pjopngzHAAAAAAAAVN3VK+MHIr4y7iSNb4eJToovwzEAAAAAAABV1r0yfmo03ivjpSRvuzJW9BmOAQAA + AAAAqKrju+4qHkwbpXtVr7Xr2VudJP9BmOWkuDMcAwAAAAAAUDVnm83imfHtpTtVDDpJfmh/vV4Lk5wU + f4ZjAAAAAAAAquTKlXG07zJ2ZaxqZjgGAAAAAACgCrpXxr+M+Mp41SPLtZorY1UzwzEAAAAAAACxi/zK + +B1Xxqp8hmMAAAAAAABi9WFzMfYr40f3jowkYXqTqpvhGAAAAAAAgBh1r4xX4r0yPu3KWH2V4RgAAAAA + AICY/H1xsXhuYrJ0g4rE4fbwuCtj9VeGYwAAAAAAAGJx4q7p4qG0Ubo/ReBMp5beU4SdTeqrDMcAAAAA + AAD0WgWujJ/ppOlYmNik/stwDAAAAAAAQC/9aXqmeCgbLd2cIuDKWIOR4RgAAAAAAIBeqMCV8dH99fpE + mNWk/s5wDAAAAAAAwFZ7fXqmOBTvlfFZV8YauAzHAAAAAAAAbJXzkV8Zt+v5s51abTJMadLgZDgGAAAA + AABgK7wxM1scyhql21IE1q6M7xsauiXMaNJgZTgGAAAAAABgM11YXCyen5wq3ZTikP52f5ruCvOZNJgZ + jgEAAAAAANgsJ2fnikcifZdxu56d7yTZvUeHhm4N05k0uBmOAQAAAAAA2GgXW63ihYivjDv17MXlJJkO + k5kkwzEAAAAAAAAb6S8RXxmvcmUslWU4BgAAAAAAYCPEfmW8VMt+t79enw0zmaSPZzgGAAAAAADgZp2a + nS1+mo+V7kYRcGUsfVqGYwAAAAAAAG5U7FfG7ST7/XKtMR+mMUnXynAMAAAAAADAjTg1N1f8NI/2XcYX + u1fGe4Z2uzKWrifDMQAAAAAAAOtxadVLUzuKTpKX7kQReLWTNP4rzGGSrifDMQAAAAAAANfr7bm54nBj + vHQfisCldi27f+/ExGfCFCbpejMcAwAAAAAA8GmivzKuZX9YqudfDhOYpPVmOAYAAAAAAOCTvDM/X/ws + 8ivjlUbDlbF0MxmOAQAAAAAAKBP7lXEnyf7QrmVfCbOXpJvJcAwAAAAAAMC/e3eue2U8VroDRcCVsbTR + GY4BAAAAAAC46lLrypXxclK+AUXg+PJI+tUwdUnaqAzHAAAAAAAAdL07v1A8Hu+VcdeP92TZ7WHmkrSR + GY4BAAAAAAAG2+VWqzi2Y2dxINJ3Ga860a5l3wjzlqTNyHAMAAAAAAAwuN5fWCh+PjpeuvfEoF3P9yxt + 2/a5MG1J2qwMxwAAAAAAAIMn+ivjWvZ6p5Z+M0xakjY7wzEAAAAAAMBgeX8+/ivjlc9PujKWtjLDMQAA + AAAAwGC4vCrydxm/uZQk3wozlqStzHAMAAAAAADQ//620Fzbb8p2nRh0r4z33jFxR5iwJG11hmMAAAAA + AID+dfXK+IGIr4zbSf7tMF1J6lWGYwAAAAAAgP70QbNZPDO+vXTLiUItPbiSJMNhtpLUywzHAAAAAAAA + /ef4rruKB9NG6Y4Tgbc6Sf6DMFdJiiHDMQAAAAAAQP84G/uVcZIf2l+v18JUJSmWDMcAAAAAAAD94cqV + cbTvMn7HlbEUcYZjAAAAAACAajvbXCx+OT5ZutnEoFPPHlmu1VwZSzFnOAYAAAAAAKiu7pXxiitjSTeb + 4RgAAAAAAKB6PmwuFkdjfpdxPXt078hIEiYpSbFnOAYAAAAAAKiW/9u9Mk6ivTI+7cpYqmCGYwAAAAAA + gGr4++Ji8dxEvO8yXvX0vjQdCzOUpCplOAYAAAAAAIjfibumi4fSRukuE4EznVp6TxH2J0kVzHAMAAAA + AAAQr9ivjDv17JkDSTIRpidJVc1wDAAAAAAAEKc/Tc8UD2WjpVtMBFwZS/2U4RgAAAAAACAu56N/l3F6 + dH+97spY6qcMxwAAAAAAAPF4fXqmOBTvlfFZV8ZSn2Y4BgAAAAAA6L3zrVbcV8a17NlOrTYZJiZJ/Zbh + GAAAAAAAoLfemJktDmWN0s0lAufa9fSH9w0N3RLmJUn9mOEYAAAAAACgNy4sLhYvTE6Vbi1xyF9cSpLp + MCtJ6ucMxwAAAAAAAFvv5Oxc8Uik7zJu17PznSS79+jQ0K1hUpLU7xmOAQAAAAAAts7FVivqK+NOPXtx + 2ZWxNHgZjgEAAAAAALbGX2bnip/mY6XbSgRcGUuDnOEYAAAAAABgc8V+ZbxUy363VG/MhvlI0iBmOAYA + AAAAANg8p+bivzLeM7TblbE06BmOAQAAAAAANt7VK+NOyY4Sid8v1xrzYTKSNOgZjgEAAAAAADbW23Pz + xeF4r4wvtZPsR66MJf1LhmMAAAAAAICNcWnVS1M7ik6Sl+4nEXh1f73xX2EmkqSPMhwDAAAAAADcvLfn + 54vDjfHS3SQCl9q17P69ExOfCRORJP1rhmMAAAAAAIAbF/2VcS37w3It/3KYhiSpPMMxAAAAAADAjXln + fr74WSPidxnXsvtXGg1XxpI+PcMxAAAAAADA+lTgXcbH27XsK2EOkqRPz3AMAAAAAABw/d6dc2UsqQ8z + HAMAAAAAAHy6S60rV8bLSfk2EoHjyyPpV8MEJEnry3AMAAAAAADwyd5bWCiOjI6XbiIxaNfzPUvbtn0u + zD+StP4MxwAAAAAAAOUut1rFsR07iwPxvsv49aVa9s0w+0jSjWc4BgAAAAAA+E/vLywUP3dlLGlQMhwD + AAAAAAB85PKqqK+Ma9nr7ZH0W2HqkaSNyXAMAAAAAABwxfvzC2sbR9n2EYPulfHK5yddGUva+AzHAAAA + AADAoIv+yrievdlJGt8O844kbXyGYwAAAAAAYJD9baEZ/ZXx3jsm7gjTjiRtToZjAAAAAABgUL26c1fx + QKRXxu169lZ3xwmTjiRtboZjAAAAAABg0HzQbBbPjG8v3TiiUEsPriTJcJhzJGnzMxwDAAAAAACD5Piu + u4oH00bpvhGBtzqujCX1IsMxAAAAAAAwCM7GfmVczx5ZrtVqYcKRpK3NcAwAAAAAAPS7K1fGcb7LeNU7 + rowl9TzDMQAAAAAA0K/ONheLX45Plm4ZkXh078hIEmYbSepdhmMAAAAAAKAfda+MV1wZS9L1ZTgGAAAA + AAD6yYfNxeJoxO8ybtezw+3hcVfGkuLKcAwAAAAAAPSLE9MzxcG0UbpdROBMu5b/T5hoJCmuDMcAAAAA + AEDV/X1xsXhuIup3GT/TSdOxMM9IUnwZjgEAAAAAgCr70/RM8VDEV8adWnpPEXYZSYo2wzEAAAAAAFBF + FbgyPnogSSbCJCNJcWc4BgAAAAAAqmbtyjgbLd0oIuDKWFL1MhwDAAAAAABVcT7yK+N2PX+2U6tNhhlG + kqqT4RgAAAAAAKiCN2Zmi0NZtO8yPuvKWFKlMxwDAAAAAAAxO99qxf0u41r26wdqo66MJVU7wzEAAAAA + ABCrkzOzxSORvsu4Xc/Od5Ls3pWhoVvC7CJJ1c1wDAAAAAAAxObC4mLxwuRU6QYRh/zFpSSZDnOLJFU/ + wzEAAAAAABCTk7Nz0V8ZHx0aujVMLZLUHxmOAQAAAACAGFxsteK+Mq5lv9tfr8+GiUWS+ivDMQAAAAAA + 0Gt/mZ0rfpqPlW4OEXBlLKn/MxwDAAAAAAC9EvuVcTvJfr9ca8yHWUWS+jfDMQAAAAAA0Aun5rpXxnG+ + y3jVxe6V8Z6h3a6MJQ1GhmMAAAAAAGArXVr14p1fLDol+0IkXm7XclfGkgYrwzEAAAAAALBV3p6bKw7H + +y7jS+1adv/eiYnPhBlFkgYnwzEAAAAAALDZulfGL03tKDpJXrorRODVpXr+5TCfSNLgZTgGAAAAAAA2 + 0zvz88XPGuOle0IEXBlLUjfDMQAAAAAAsBlivzLuJNkflmuujCVpLcMxAAAAAACw0d6d614Zx/0u45VG + w5WxJF3NcAwAAAAAAGyUS60rV8bLSfl+EIHjS7XsK2EmkSRdzXAMAAAAAABshO6V8eORXxnvybLbw0Qi + Sfp4hmMAAAAAAOBmXG61imM7dhYHIn2X8aoTnVr2jTCNSJLKMhwDAAAAAAA36v2FheLno+OlW0EM2vV8 + z9K2bZ8Ls4gk6VoZjgEAAAAAgPWqwJXx651a+s0wh0iSPi3DMQAAAAAAsB5VuDJe+fykK2NJWk+GYwAA + AAAA4HpcXhX5lfGb7ZH0W2ECkSStJ8MxAAAAAADwaf620Fz73/2XbQIx6F4Z771j4o4wf0iS1pvhGAAA + AAAAuJarV8YPRHxl3Eka3w6zhyTpRjMcAwAAAAAAZbpXxk+NxntlvJTkbVfGkrRBGY4BAAAAAIB/d3zX + XcWDaaN0A+i1dj17q5PkPwhThyRpI9qs4fixfKw4MT0DAAAAAGygSyXjDsBGOtdsFs9OTJb+7/6jUMuP + 7PtCIwszhyRpo9qs4RgAAAAA2Hh/X1wsHXoANsKVK+No32XsyliSNjPDMQAAAABUh+EY2Axnm83il+Pb + S793IvHIcq1WC9OGJGkzMhwDAAAAQHUYjoGNFvmV8TuujCVpizIcAwAAAEB1GI6BjfJhczH2K+NH946M + JGHOkCRtdoZjAAAAAKgOwzGwEbpXxivxXhmfdmUsST3IcAwAAAAA1WE4Bm5G9zvkuYnJ0u+XSBxuD4+7 + MpakXmQ4BgAAAIDqMBwDN+rEXdPFQ2mj9LslAmc6tfSeImwXkqQeZDgGAAAAgOowHAPrVYEr42c6aToW + ZgtJUq8yHAMAAABAdRiOgfX40/RM8VA2Wvp9EgFXxpIUU4ZjAAAAAKgOwzFwPSpwZXx0f70+EaYKSVIM + GY4BAAAAoDoMx8CnOTk7VzwS6ZVxu56dX6qn/3t0aOjWMFNIkmLJcAwAAAAA1WE4Bq7lfOxXxrXs2U6t + NhnmCUlSbBmOAQAAAKA6DMdAmTdmZotDWaP0eyMCZ7vvMr5vaOiWME1IkmLMcAwAAAAA1WE4Bj7uwup3 + wvOTU6XfF3FIf7s/TXeFSUKSFHOGYwAAAACoDsMxcNXJyN9l3Emye73LWJIqlOEYAAAAAKrDcAxcbLWK + FyK+Mu7UsxeXk2Q6zBCSpKpkOAYAAACA6jAcw2D7S8RXxqtcGUtSlTMcAwAAAEB1GI5hMMV+ZbxUy363 + v16fDdODJKmKGY4BAAAAoDoMxzB4Ts3OFj/Nx0q/EyLgyliS+iXDMQAAAABUh+EYBkfsV8btJPv9cq0x + H+YGSVLVMxwDAAAAQHUYjmEwnJqbK36aR/su44vdK+M9Q7tdGUtSP7VUz7/effcAAAAAALCByseWm2Y4 + hv52qbW7+D9f3FksJ+XfAb3WrmevddL07jAxSJIkSZIkSZIk6VqtTE/fVja4bATDMfSvt+fni8ON8dJn + PwKX2rXs/r0TE58JX3WSJEmSJEmSJEn6pAzHwHpcWvXS1I6ik+Slz33P1bI/LNXzL4evOEmSJEmSJEmS + JF1PhmPger0zP1/8LPIr45VGw5WxJEmSJEmSJEnSejMcA58m9ivjTpL9oV3LvhK+1iRJkiRJkiRJkrTe + DMfAJ3l3rntlPFb6jEfAlbEkSZIkSZIkSdJGZDgGylxqXbkyXk7Kn+8IHF8eSb8avsokSZIkSZIkSZJ0 + MxmOgX/33sJCcWQ02ncZd/14T5bdHr7GJEmSJEmSJEmSdLMZjoGrLrdaxbEdO4sDkb7LeNWJdi37Rvj6 + kiRJkiRJkiRJ0kZlOAa63l9YKH4e8ZVxu57vWdq27XPhq0uSJEmSJEmSJEkbmeEYBlv0V8a17PVOLf1m + +MqSJEmSJEmSJEnSZmQ4hsH1/vxC8eTYROnzG4PulfHK5yddGUuSJEmSJEmSJG12hmMYPJdXRf4u4zeX + kuRb4WtKkiRJkiRJkiRJm53hGAbL3xaa0V8Z771j4o7wFSVJkiRJkiRJkqStyHAMg+HqlfEDEV8Zt5P8 + 2+GrSZIkSZIkSZIkSVuZ4Rj63wfNZvHM+PbS5zQKtfTgSpIMh68lSZIkSZIkSZIkbXWGY+hvx3fdVTyY + Nkqf0Qi81UnyH4SvI0mSJEmSJEmSJPUqwzH0p7OxXxkn+aH99XotfBVJkiRJkiRJkiSplxmOof9cuTKO + 9l3G77gyliRJkiRJkiRJiizDMfSPs83F4pfjk6XPYww69eyR5VrNlbEkSZIkSZIkSVJsGY6hP3SvjFdc + GUuSJEmSJEmSJOlGMhxDtX3YXCyOxvwu43r26N6RkSR85UiSJEmSJEmSJCnGDMdQXf+3e2WcRHtlfNqV + sSRJkiRJkiRJUkUyHEP1dJ+t5ybifZfxqqf3pelY+JqRJEmSJEmSJElS7BmOoVpO3DVdPJQ2Sp+5CJzp + 1NJ7ivD9IkmSJEmSJEmSpIpkOIZqiP3KuFPPnjmQJBPhq0WSJEmSJEmSJElVynAM8fvT9EzxUDZa+pxF + wJWxJEmSJEmSJElS1TMcQ7zOR35lvFRPj+6v110ZS5IkSZIkSZIkVT3DMcTp9emZ4lC8V8ZnXRlLkiRJ + kiRJkiT1UYZjiMv5VivuK+Na9uwDtdHJ8BUiSZIkSZIkSZKkfshwDPF4Y2a2OJQ1Sp+nCJxr19Mf3jc0 + dEv4+pAkSZIkSZIkSVK/ZDiG3ruw+qy8MDlV+hzFIX9xKUmmw9eGJEmSJEmSJEmS+i3DMfTWydm54pFI + 32XcrmfnO0l279GhoVvDV4YkSZIkSZIkSZL6McMx9MbFVivqK+NOPXtx2ZWxJEmSJEmSJEnSYGQ4hq33 + l9m54qf5WOlzEwFXxpIkSZIkSZIkSYOW4Ri2TuxXxku17HdL9cZs+HqQJEmSJEmSJEnSoGQ4hq1xai7+ + K+M9Q7tdGUuSJEmSJEmSJA1ihmPYXFevjDslz0gkfr9ca8yHrwRJkiRJkiRJkiQNYoZj2Dxvz80Xh+O9 + Mr7UTrIfuTKWJEmSJEmSJEmS4Rg2waVVL03tKDpJXvpsRODV/fXGf4WvAUmSJEmSJEmSJA16hmPYWG/P + zxeHG+Olz0QELrVr2f17JyY+E74CJEmSJEmSJEmSJMMxbJTor4xr2R+Wa/mXw6MvSZIkSZIkSZIkfZTh + GG7eO/Pzxc8aEb/LuJbdv9JouDKWJEmSJEmSJElSeYZjuHFXr4yXk/JnIALH27XsK+FxlyRJkiRJkiRJ + ksozHMONeXcu/ivjPVl2e3jUJUmSJEmSJEmSpGtnOIb1udxqFS9/Me4r4+WR9KvhEZckSZIkSZIkSZI+ + PcMxXL/3FhaKn4+Ol37eY9Cu53uWtm37XHi8JUmSJEmSJEmSpOvLcAyfrntlfGzHzuJAkpd+1iPw+lIt + +2Z4rCVJkiRJkiRJkqT1ZTiGT/a+K2NJkiRJkiRJkiT1e4ZjKHd5VdRXxrXs9fZI+q3wKEuSJEmSJEmS + JEk3nuEY/tP78wvFk2MTpZ/rGHSvjFc+P+nKWJIkSZIkSZIkSRuT4Rg+Ev2VcT17s5M0vh0eX0mSJEmS + JEmSJGljMhzDFX9baEZ/Zbz3jok7wqMrSZIkSZIkSZIkbVyGY9hdvLpzV/FApFfG7Xr21lKS/yA8spIk + SZIkSZIkSdLGZzhmkJ1tNotnxreXfn6jUEsPriTJcHhcJUmSJEmSJEmSpM3JcMygOr7rruLBtFH62Y3A + Wx1XxpIkSZIkSZIkSdqqDMcMmuivjOvZI8u1Wi08opIkSZIkSZIkSdLmZzhmkFy5Mo7zXcar3nFlLEmS + JEmSJEmSpJ5kOGYQnG0uFr+M+8r40b0jI0l4LCVJkiRJkiRJkqStzXBMv+teGa+4MpYkSZIkSZIkSZKu + neGYfvVhc7E4GvGVcbueHW4Pj7syliRJkiRJkiRJUu8zHNOPTkzPFAfTRunnMgJn2rX8f8IjKEmSJEmS + JEmSJPU+wzH9pPuZe25isvTzGIlnOmk6Fh4/SZIkSZIkSZIkKY4Mx/SLP03PFA9FfGXcqaX3FOG5kyRJ + kiRJkiRJkqLKcEzVVeDK+OiBJJkIj5wkSZIkSZIkSZIUX4ZjqmztyjgbLf38RcCVsSRJkiRJkiRJkqqR + 4ZgqOh/5lXG7nj/bqdUmw2MmSZIkSZIkSZIkxZ3hmKp5Y2a2OJRF+y7js66MJUmSJEmSJEmSVLkMx1TF + +VYr7ncZ17JfP1AbdWUsSZIkSZIkSZKk6mU4pgpOzswWj0T6LuN2PTvfSbJ7V4aGbgmPlSRJkiRJkiRJ + klStDMfE7MLqZ+iFyanSz1cc8heXkmQ6PE6SJEmSJEmSJElSNTMcE6uTs3PRXxkfHRq6NTxKkiRJkiRJ + kiRJUnUzHBObi61W3FfGtex3++v12fAISZIkSZIkSZIkSdXPcExM/jI7V/w0Hyv9PEXAlbEkSZIkSZIk + SZL6M8MxMYj9yridZL9frjXmw2MjSZIkSZIkSZIk9VeGY3rt1Fz3yjjOdxmvuti9Mt4ztNuVsSRJkiRJ + kiRJkvo3wzG9cmnVi3d+seiUfHYi8XK7lrsyliRJkiRJkiRJUv9nOKYX3p6bKw7H+y7jS+1adv/eiYnP + hMdEkiRJkiRJkiRJ6u8Mx2yl7pXxS1M7ik6S///t3U+IXPUBB/BBPIgHWYP73ps3k93pYqMm+88VikiP + IuLZY+nRY4/Sm/Toscc9Ld2ZN9HVECWWaksabCm0iEoPEkKgYFOxEqONNi2pJK875heU+po/m52Z35v3 + +cD3ENidnffeL6cvX17lmYkgpwdp5/Hw3wMAAAAAAACaQXEsk8qF1dXyje5i5VmJIFbGAAAAAAAANJfi + WMad2FfGRZafGSZWxgAAAAAAADSY4ljGmc9WRivjuN9lvNPtWhkDAAAAAADQbIpjGUeubFxbGQ+z6rMR + Qc4OkvyJ8N8AAAAAAAAAmk1xLPud0cr4l5GvjDfz/N7wXwAAAAAAAABQHMt+5erGRvnBoYfKo5G+y3g3 + HxZJ/mQ4+gAAAAAAAMB1imPZj1xcWyvfPLhYeQ5iSD/tbA4OHLgvHHsAAAAAAADg2xTHciepwcr4XJG0 + nwrHHQAAAAAAAKiiOJa9pg4r4537l6yMAQAAAAAA4GYUx3K7ubqbyFfGHw2y7OlwxAEAAAAAAICbURzL + 7eSLtfXyrYVe5fOOIaOV8dZcby4cbwAAAAAAAOBWKI7lVnJ9ZfxSxCvjIus+E441AAAAAAAAcDsUx3Kz + jFbGvz4Y78p4kHX6xcKClTEAAAAAAADsleJYbpSzDz9SvtzuVj7faaef5ueLrPNsOMoAAAAAAADAXimO + pSqX1tfLk4vfq3yuMaTIOse20zQJxxgAAAAAAAC4E4pj+d9cWxlH+y5jK2MAAAAAAADYb4pjuZ7Ryvi3 + Ea+Md3N8mCRWxgAAAAAAALDfFMcyymhlvBPvyviClTEAAAAAAACMkeK42fnX+qOxr4xf35qfz8JxBQAA + AAAAAMZBcdzcRL4y/tzKGAAAAAAAACZEcdy8jJ7L73pLlc8skpzoP7BoZQwAAAAAAACTojhuVj585HD5 + artb+bwiyJdF0n6uDGcTAAAAAAAAmBDFcTNSg5XxyaLdXgjHEgAAAAAAAJgkxfHs56+Hj5Sv5gcrn1EE + sTIGAAAAAACAaVMcz25qsDI+tZ2mvXAUAQAAAAAAgGlRHM9mzh0+Uh6Ld2V8ycoYAAAAAAAAIqI4nq1c + jn1lnORvF0myFI4fAAAAAAAAEAPF8ezkb0eWy2N5t/JZRJCvV8YvtFp3haMHAAAAAAAAxEJxXP/8Z/c+ + /2HpwcpnEEfaf9putx8ORw4AAAAAAACIjeK43vl4eaU8Hum7jPtpfrnI8udPtVp3h+MGAAAAAAAAxEhx + XM98tbFR/jHilXGR5u8Ms+xwOGYAAAAAAABAzBTH9cvfI14Z78bKGAAAAAAAAOpGcVyfxL4yHiT5u9tp + uhyOFgAAAAAAAFAXiuN65JPl5fK1zkLlfY4gVsYAAAAAAABQZ4rjuBP7yrif5e8Pk+5qOE4AAAAAAABA + HSmO480nKyvla51o32X81WhlvNl6zMoYAAAAAAAA6k5xHF+u7Oa9Bw+VRdapvK8R5HSRdX8QjhAAAAAA + AABQd4rjuPLp6mp5ortYeT8jyJV+kr+41evdE44PAAAAAAAAMAsUx3Ek+pVxkp8ZpJ3Hw7EBAAAAAAAA + ZoniePq5sLpavhH5ynin27UyBgAAAAAAgFmlOJ5eYl8ZF1l+pp/kT4SjAgAAAAAAAMwqxfF08tnKaGW8 + UHnfIoiVMQAAAAAAADSJ4niyubJxbWU8zKrvWQQ5O5xv/zAcDwAAAAAAAKAJFMeTyz/W1spfHYz2Xcaj + /Hwzz+8NRwMAAAAAAABoCsXx+HN1Y6P84NBD5dFI32W8mw/7Sf5kOBIAAAAAAABA0yiOx5uLa2vlmxGv + jPtpZ3Nw4MB94TgAAAAAAAAATaQ4Hk+iXxkn+bkiaT8VjgEAAAAAAADQZIrj/c/F1bXyrYVe5T2JIaOV + 8c79S1bGAAAAAAAAwDWK4/3L1d1E/i7jjwZZ9nR49AAAAAAAAADXKI73J1+srUe/Mt6a682Fxw4AAAAA + AADwDcXxneX6yviliFfG/azzTHjcAAAAAAAAAN+lON57/rm+Xp5c/F7ltUeRpP3KTpY9EB41AAAAAAAA + QDXF8d5y9uFHypfb3crrjiDni6zzbHjEAAAAAAAAADemOL69XIp9ZZx1jm2naRIeLwAAAAAAAMDNKY5v + PddWxtG+y/iClTEAAAAAAACwJ4rjm+fS+qPlbxeXKq8xhhRpfnyYJFbGAAAAAAAAwN4ojm+c0cp4x8oY + AAAAAAAAmGWK4+r8a/3R8lTM7zJO89e35uez8BgBAAAAAAAA9k5x/N38ZbQyzqJdGX9uZQwAAAAAAADs + K8XxNxl939/14n2X8W5+U7TbC+HRAQAAAAAAAOwPxfG1/PXwkfLVdrfyOiLIl0XSfq4MzwwAAAAAAABg + XzW9OI59ZVyk+cmjWdYLjwsAAAAAAABg/zW5OP56ZZwfrPzuEcTKGAAAAAAAAJiMJhbHlyNfGQ/S9qnt + NLUyBgAAAAAAACajacXxucNHymPxrowvWRkDAAAAAAAAE9eU4vjyxkbcK+Mkf/ul5OBSeCwAAAAAAAAA + k9OE4vjjI8vl8XhXxv/up+2fvNBq3RUeCQAAAAAAAMBkzXJx/J/dv//HpQcrv1sc6bwzyLLD4VEAAAAA + AAAATMesFscfL69EuzLup/nlIsufP9Vq3R0eAwAAAAAAAMD0zFpx/NXGRtQr4yLN3xlaGQMAAAAAAAAx + maXi+O/LK+VrnYXK7xJBrIwBAAAAAACAOM1CcRz7yniQ5O8O0u5yuOUAAAAAAAAAcal7cfzJSvwr483W + Y1bGAAAAAAAAQLzqWhxfXxkXFX83krw/TLqr4TYDAAAAAAAAxKuOxfGnK6vliXhXxlf6Wf4zK2MAAAAA + AACgNupUHF/ZzXsPHiqLrFP59yLI6e20+4NwawEAAAAAAADqoS7F8aerq+WJ7mLl34kgV/pJ/uJWr3dP + uK0AAAAAAAAA9RF7cRz9yjjJzwyTzuPhdgIAAAAAAADUT8zF8YXV1fKNbsTvMk7yF3e6XStjAAAAAAAA + oN5iLI6vr4yHWfXnRpCz/SR/ItxCAAAAAAAAgHqLrTj+bCX+lfFmnt8bbh8AAAAAAABA/cVSHF/d2Cj/ + /P24V8bD+fYPw20DAAAAAAAAmB0xFMf/WFsr3zy4WPkZMaSfdjYHBw7cF24ZAAAAAAAAwGyZZnE8Whl/ + cOih8mjWqfz9CHJukORPhVsFAAAAAAAAMJumVRxftDIGAAAAAAAAiMOki+Oru4l6ZZzk5/rz7afD7QEA + AAAAAACYfZMsji+urpVvLfQqfzaGjFbGO/cvWRkDAAAAAAAAzTKJ4jj6lXGaf1Rk3WfCLQEAAAAAAABo + lnEXx1+srUe/Mt6a682F2wEAAAAAAADQPOMsjk8/9HC5E+/K+PMiaf8o3AYAAAAAAACA5hpncRxtkvYr + O1n2QLgFAAAAAAAAAM3WsOL4fJF1ng2XDgAAAAAAAMBIg4rj48MkScJlAwAAAAAAAHBdA4rjC1bGAAAA + AAAAADcw48Xx61vz81m4VAAAAAAAAACqzGhxbGUMAAAAAAAAcKtmrTjup/mJ/gOLVsYAAAAAAAAAt2qG + iuMv+0nnx+GyAAAAAAAAALhVM1Icnyza7YVwSQAAAAAAAADcjpoXx18WSfu5MlwLAAAAAAAAAHtQ4+L4 + 1NEs64XLAAAAAAAAAGCv6lYc99P88iBt/3Sn1borXAIAAAAAAAAAd6JOxXE/7bxdJMlS+OoAAAAAAAAA + 7IeaFMeXvMsYAAAAAAAAYEyiL46T/PcvJQetjAEAAAAAAADGJdbiePQu4yLLn/cuYwAAAAAAAIAxi7M4 + 7rwzzLLD4SsCAAAAAAAAME4xFcfXV8anWq27w9cDAAAAAAAAYNyiKY6T/N3tNF0OXwsAAAAAAACASYmg + OLYyBgAAAAAAAJimqRbHSX5mmHQeD18FAAAAAAAAgGmYUnH81WhlvNl6zMoYAAAAAAAAYNqmUBz/uZ90 + VsOfBwAAAAAAAGDaJlgcX+kn+Ytbvd494U8DAAAAAAAAEIMJFcenB6l3GQMAAAAAAABEaczFsZUxAAAA + AAAAQOzGVRwXWX5mmFgZAwAAAAAAAERvDMXx1yvjnW7XyhgAAAAAAACgDva5OD47SPInwkcDAAAAAAAA + UAf7Vhwn+S+25npz4WMBAAAAAAAAqIt9KI4/7Cf5k+HjAAAAAAAAAKibOymO+2lnc3DgwH3howAAAAAA + AACooz0Vx0l+rkjaT4WPAAAAAAAAAKDObrc4Hq2Md+5fsjIGAAAAAAAAmBW3URx/VGTdZ8KvAQAAAAAA + ADArbqU4Hq2Mt+Z6c+FXAAAAAAAAAJglNyqO+2l+fpB1ng0/CgAAAAAAAMAs+n/FcZF1jm2naRJ+DAAA + AAAAAIBZVVEcny+sjAEAAAAAAACa49vFcZHmx4dJYmUMAAAAAAAA0CShOL5gZQwAAAAAAADQUC+0Wndt + p2kv/BMAACLWav0XX2ZsXCvVRwEAAAAASUVORK5CYII= \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/IMoveableObject.cs b/ProjectBattleship/ProjectBattleship/IMoveableObject.cs new file mode 100644 index 0000000..ae33266 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/IMoveableObject.cs @@ -0,0 +1,7 @@ +namespace ProjectBattleship.MovementStrategy; +public interface IMoveableObject +{ + ObjectParameters? GetObjectPosition { get; } + int GetStep { get; } + bool TryMoveObject(MovementDirection direction); +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/MoveToBorder.cs b/ProjectBattleship/ProjectBattleship/MoveToBorder.cs new file mode 100644 index 0000000..3d63bbd --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/MoveToBorder.cs @@ -0,0 +1,25 @@ +namespace ProjectBattleship.MovementStrategy; +public class MoveToBorder : AbstractStrategy +{ + protected override bool IsTargetDestinaion() + { + ObjectParameters? objParams = GetObjectParameters; + if (objParams == null) + { + return false; + } + return objParams.LeftBorder - GetStep() <= 0 || objParams.RightBorder + GetStep() >= FieldWidth || objParams.TopBorder - GetStep() <= 0 || objParams.ObjectMiddleVertical + GetStep() >= FieldHeight; + } + protected override void MoveToTarget() + { + ObjectParameters? objParams = GetObjectParameters; + if (objParams == null) + { + return; + } + int x = objParams.RightBorder; + if (x + GetStep() < FieldWidth) MoveRight(); + int y = objParams.DownBorder; + if (y + GetStep() < FieldHeight) MoveDown(); + } +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/MoveToCenter.cs b/ProjectBattleship/ProjectBattleship/MoveToCenter.cs new file mode 100644 index 0000000..fbc9e53 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/MoveToCenter.cs @@ -0,0 +1,46 @@ +namespace ProjectBattleship.MovementStrategy; +public class MoveToCenter : AbstractStrategy +{ + protected override bool IsTargetDestinaion() + { + ObjectParameters? objParams = GetObjectParameters; + if (objParams == null) + { + return false; + } + return objParams.ObjectMiddleHorizontal - GetStep() <= FieldWidth / 2 && objParams.ObjectMiddleHorizontal + GetStep() >= FieldWidth / 2 && + objParams.ObjectMiddleVertical - GetStep() <= FieldHeight / 2 && objParams.ObjectMiddleVertical + GetStep() >= FieldHeight / 2; + } + protected override void MoveToTarget() + { + ObjectParameters? objParams = GetObjectParameters; + if (objParams == null) + { + return; + } + int diffX = objParams.ObjectMiddleHorizontal - FieldWidth / 2; + if (Math.Abs(diffX) > GetStep()) + { + if (diffX > 0) + { + MoveLeft(); + } + else + { + MoveRight(); + } + } + int diffY = objParams.ObjectMiddleVertical - FieldHeight / 2; + if (Math.Abs(diffY) > GetStep()) + { + if (diffY > 0) + { + MoveUp(); + } + else + { + MoveDown(); + } + } + } +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/MoveableShip.cs b/ProjectBattleship/ProjectBattleship/MoveableShip.cs new file mode 100644 index 0000000..fa9a117 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/MoveableShip.cs @@ -0,0 +1,42 @@ +using ProjectBattleship.Drawning; + +namespace ProjectBattleship.MovementStrategy; +public class MoveableShip : IMoveableObject +{ + private readonly DrawingShip? _ship = null; + public MoveableShip(DrawingShip ship) + { + _ship = ship; + } + public ObjectParameters? GetObjectPosition + { + get + { + if (_ship == null || _ship.EntityShip == null || !_ship.GetPosX.HasValue || !_ship.GetPosY.HasValue) + { + return null; + } + return new ObjectParameters(_ship.GetPosX.Value, _ship.GetPosY.Value, _ship.GetWidth, _ship.GetHeight); + } + } + public int GetStep => (int)(_ship?.EntityShip?.Step ?? 0); + public bool TryMoveObject(MovementDirection direction) + { + if (_ship == null || _ship.EntityShip == null) + { + return false; + } + return _ship.MoveTransport(GetDirectionType(direction)); + } + private static DirectionType GetDirectionType(MovementDirection direction) + { + return direction switch + { + MovementDirection.Left => DirectionType.Left, + MovementDirection.Right => DirectionType.Right, + MovementDirection.Up => DirectionType.Up, + MovementDirection.Down => DirectionType.Down, + _ => DirectionType.Unknow, + }; + } +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/MovementDirection.cs b/ProjectBattleship/ProjectBattleship/MovementDirection.cs new file mode 100644 index 0000000..452d27b --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/MovementDirection.cs @@ -0,0 +1,8 @@ +namespace ProjectBattleship.MovementStrategy; +public enum MovementDirection +{ + Up = 1, + Down = 2, + Left = 3, + Right = 4 +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/ObjectParameters.cs b/ProjectBattleship/ProjectBattleship/ObjectParameters.cs new file mode 100644 index 0000000..f1aa202 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/ObjectParameters.cs @@ -0,0 +1,21 @@ +namespace ProjectBattleship.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; + public ObjectParameters(int x, int y, int width, int height) + { + _x = x; + _y = y; + _width = width; + _height = height; + } +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/StrategyStatus.cs b/ProjectBattleship/ProjectBattleship/StrategyStatus.cs new file mode 100644 index 0000000..705274d --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/StrategyStatus.cs @@ -0,0 +1,9 @@ +namespace ProjectBattleship.MovementStrateg +{ + public enum StrategyStatus + { + NotInit, + InProgress, + Finish + } +} \ No newline at end of file -- 2.25.1