diff --git a/Cruiser/Cruiser/AbstractStrategy.cs b/Cruiser/Cruiser/AbstractStrategy.cs new file mode 100644 index 0000000..9d40e09 --- /dev/null +++ b/Cruiser/Cruiser/AbstractStrategy.cs @@ -0,0 +1,88 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +using ProjectCruiser.Drawnings; +namespace ProjectCruiser.MovementStrategy +{ + public abstract class AbstractStrategy + { + private IMoveableObject? _moveableObject; + + private Status _state = Status.NotInit; + + protected int FieldWidth { get; private set; } + + protected int FieldHeight { get; private set; } + + public Status GetStatus() { return _state; } + + public void SetData(IMoveableObject moveableObject, int width, int + height) + { + if (moveableObject == null) + { + _state = Status.NotInit; + return; + } + _state = Status.InProgress; + _moveableObject = moveableObject; + FieldWidth = width; + FieldHeight = height; + } + + public void MakeStep() + { + if (_state != Status.InProgress) + { + return; + } + if (IsTargetDestinaion()) + { + _state = Status.Finish; + return; + } + MoveToTarget(); + } + + protected bool MoveLeft() => MoveTo(DirectionType.Left); + + protected bool MoveRight() => MoveTo(DirectionType.Right); + + protected bool MoveUp() => MoveTo(DirectionType.Up); + + protected bool MoveDown() => MoveTo(DirectionType.Down); + + protected ObjectParameters? GetObjectParameters => + _moveableObject?.GetObjectPosition; + + protected int? GetStep() + { + if (_state != Status.InProgress) + { + return null; + } + return _moveableObject?.GetStep; + } + + protected abstract void MoveToTarget(); + + protected abstract bool IsTargetDestinaion(); + + private bool MoveTo(DirectionType directionType) + { + if (_state != Status.InProgress) + { + return false; + } + if (_moveableObject?.CheckCanMove(directionType) ?? false) + { + _moveableObject.MoveObject(directionType); + return true; + } + return false; + } + } +} diff --git a/Cruiser/Cruiser/DirectionType.cs b/Cruiser/Cruiser/DirectionType.cs index 480399f..5c3b79f 100644 --- a/Cruiser/Cruiser/DirectionType.cs +++ b/Cruiser/Cruiser/DirectionType.cs @@ -4,16 +4,17 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace Cruiser +namespace ProjectCruiser.Drawnings { - internal enum DirectionType + + public enum DirectionType { Up = 1, - + Down = 2, - + Left = 3, - + Right = 4 } } diff --git a/Cruiser/Cruiser/DrawningCruiser.cs b/Cruiser/Cruiser/DrawningCruiser.cs index fb5d921..52ee43f 100644 --- a/Cruiser/Cruiser/DrawningCruiser.cs +++ b/Cruiser/Cruiser/DrawningCruiser.cs @@ -1,114 +1,131 @@ using System; using System.Collections.Generic; -using System.Drawing.Drawing2D; using System.Linq; using System.Text; using System.Threading.Tasks; -namespace Cruiser +using ProjectCruiser.Entities; +using ProjectCruiser.Drawnings; +using System.Drawing.Drawing2D; + +namespace ProjectCruiser.DrawningObjects { - internal class DrawningCruiser + public class DrawningCruiser { - public EntityCruiser? EntityCruiser { get; private set; } - + public EntityCruiser? EntityCruiser { get; protected set; } + private int _pictureWidth; - + private int _pictureHeight; - - private int _startPosX; - - private int _startPosY; - - private readonly int _cruiserWidth = 150; - - private readonly int _cruiserHeight = 50; - - public bool Init(int speed, double weight, Color bodyColor, Color -additionalColor, bool vert, bool rocket, int width, int height) + + protected int _startPosX; + + protected int _startPosY; + + protected readonly int _cruiserWidth = 145; + + protected readonly int _cruiserHeight = 45; + + public DrawningCruiser(int speed, double weight, Color bodyColor, int + width, int height) { - - if (width < _pictureWidth || height < _pictureHeight) + _pictureWidth = width; + _pictureHeight = height; + EntityCruiser = new EntityCruiser(speed, weight, bodyColor); + } + + protected DrawningCruiser(int speed, double weight, Color bodyColor, int + width, int height, int cruiserWidth, int cruiserHeight) + { + if (width <= _pictureWidth || height <= _pictureHeight) { - return false; + return; } _pictureWidth = width; _pictureHeight = height; - EntityCruiser = new EntityCruiser(); - EntityCruiser.Init(speed, weight, bodyColor, additionalColor, vert, rocket); - return true; + _cruiserWidth = cruiserWidth; + _cruiserHeight = cruiserHeight; + EntityCruiser = new EntityCruiser(speed, weight, bodyColor); } - + public void SetPosition(int x, int y) { - if (x <= _pictureWidth - _cruiserWidth && y <= _pictureHeight - _cruiserHeight) + if (x < 0 || y < 0 || x + _cruiserWidth > _pictureWidth || y + _cruiserHeight > _pictureHeight) { - _startPosX = x; - _startPosY = y; + x = 10; + y = 10; } + _startPosX = x; + _startPosY = y; + } + + protected int PictureWidth + { + get { return _pictureWidth; } + } + + protected int PictureHeight + { + get { return _pictureHeight; } } - public void MoveTransport(DirectionType direction) + public int GetPosX => _startPosX; + + public int GetPosY => _startPosY; + + public int GetWidth => _cruiserWidth; + + public int GetHeight => _cruiserHeight; + + public virtual bool CanMove(DirectionType direction) { if (EntityCruiser == null) + { + return false; + } + return direction switch + { + DirectionType.Left => _startPosX - EntityCruiser.Step > 0, + + DirectionType.Up => _startPosY - EntityCruiser.Step > 7, + + DirectionType.Right => _startPosX + EntityCruiser.Step + _cruiserWidth <= _pictureWidth, + + DirectionType.Down => _startPosY + EntityCruiser.Step + _cruiserHeight <= _pictureHeight, + _ => false, + }; + } + + public virtual void MoveTransport(DirectionType direction) + { + if (!CanMove(direction) || EntityCruiser == null) { return; } switch (direction) { case DirectionType.Left: - if (_startPosX - EntityCruiser.Step > 0) - { - _startPosX -= (int)EntityCruiser.Step; - } - else if (_startPosX - EntityCruiser.Step < 0) - { - _startPosX = _startPosX - _startPosX + 3; - } + _startPosX -= (int)EntityCruiser.Step; break; - case DirectionType.Up: - if (_startPosY - EntityCruiser.Step > 0) - { - _startPosY -= (int)EntityCruiser.Step; - } - else if (_startPosY - EntityCruiser.Step < 0) - { - _startPosY = _startPosY - _startPosY + 0; - } + _startPosY -= (int)EntityCruiser.Step; break; - case DirectionType.Right: - if (_startPosX + EntityCruiser.Step + _cruiserWidth < _pictureWidth) - { - _startPosX += (int)EntityCruiser.Step; - } - else if (_startPosX + EntityCruiser.Step + _cruiserWidth > _pictureWidth) - { - _startPosX += _pictureWidth - _startPosX - _cruiserWidth; - } + _startPosX += (int)EntityCruiser.Step; break; - case DirectionType.Down: - if (_startPosY + EntityCruiser.Step + _cruiserHeight < _pictureHeight) - { - _startPosY += (int)EntityCruiser.Step; - } - else if (_startPosY + EntityCruiser.Step + _cruiserHeight > _pictureHeight) - { - _startPosY += _pictureHeight - _startPosY - _cruiserHeight; - } + _startPosY += (int)EntityCruiser.Step; break; } } - - public void DrawTransport(Graphics g) + + public virtual void DrawTransport(Graphics g) { if (EntityCruiser == null) { return; } Pen pen = new(Color.Black); - Brush additionalBrush = new SolidBrush(EntityCruiser.AdditionalColor); Brush BodyColor = new SolidBrush(EntityCruiser.BodyColor); GraphicsPath path1 = new GraphicsPath(); @@ -118,7 +135,7 @@ additionalColor, bool vert, bool rocket, int width, int height) path1.AddLine(_startPosX + 100, _startPosY + 50, _startPosX + 150, _startPosY + 25); path1.AddLine(_startPosX + 100, _startPosY + 0, _startPosX + 150, _startPosY + 25); - g.FillPath(additionalBrush, path1); + g.FillPath(BodyColor, path1); g.DrawPath(pen, path1); Brush brBlack = new SolidBrush(Color.Black); @@ -127,30 +144,11 @@ additionalColor, bool vert, bool rocket, int width, int height) g.FillRectangle(brBlack, _startPosX - 3, _startPosY + 7, 3, 15); g.DrawRectangle(pen, _startPosX - 3, _startPosY + 25, 3, 15); g.FillRectangle(brBlack, _startPosX - 3, _startPosY + 25, 3, 15); - + g.DrawRectangle(pen, _startPosX + 60, _startPosY + 12, 20, 25); g.FillRectangle(brBlack, _startPosX + 60, _startPosY + 12, 20, 25); g.DrawRectangle(pen, _startPosX + 30, _startPosY + 19, 30, 13); g.FillRectangle(brBlack, _startPosX + 30, _startPosY + 19, 30, 13); - - if (EntityCruiser.Vert) - { - Brush brRed = new SolidBrush(Color.Red); - g.FillEllipse(brRed, _startPosX + 95, _startPosY + 15, 20, 20); - g.DrawEllipse(pen, _startPosX + 95, _startPosY + 15, 20, 20); - } - - if (EntityCruiser.Rocket) - { - g.DrawEllipse(pen, _startPosX + 8, _startPosY + 3, 15, 12); - g.FillEllipse(brBlack, _startPosX + 8, _startPosY + 3, 15, 12); - - g.DrawEllipse(pen, _startPosX + 8, _startPosY + 18, 15, 12); - g.FillEllipse(brBlack, _startPosX + 8, _startPosY + 18, 15, 12); - - g.DrawEllipse(pen, _startPosX + 8, _startPosY + 33, 15, 12); - g.FillEllipse(brBlack, _startPosX + 8, _startPosY + 33, 15, 12); - } } } } diff --git a/Cruiser/Cruiser/DrawningCruiserDou.cs b/Cruiser/Cruiser/DrawningCruiserDou.cs new file mode 100644 index 0000000..6632aa2 --- /dev/null +++ b/Cruiser/Cruiser/DrawningCruiserDou.cs @@ -0,0 +1,59 @@ +using System; +using System.Collections.Generic; +using System.Drawing.Drawing2D; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +using ProjectCruiser.Drawnings; +using ProjectCruiser.Entities; +namespace ProjectCruiser.DrawningObjects +{ + public class DrawningCruiserDou : DrawningCruiser + { + public DrawningCruiserDou(int speed, double weight, Color bodyColor, Color + additionalColor, bool vert, bool rocket, int width, int height) : + base(speed, weight, bodyColor, width, height, 145, 45) + { + if (EntityCruiser != null) + { + EntityCruiser = new EntityCruiserDou(speed, weight, bodyColor, + additionalColor, vert, rocket); + } + } + + public override void DrawTransport(Graphics g) + { + if (EntityCruiser is not EntityCruiserDou cruiserWith) + { + return; + } + Pen pen = new(Color.Black); + + Brush additionalBrush = new SolidBrush(cruiserWith.AdditionalColor); + Brush BodyColor = new SolidBrush(EntityCruiser.BodyColor); + Brush brBlack = new SolidBrush(Color.Black); + + base.DrawTransport(g); + + if (cruiserWith.Vert) + { + Brush brRed = new SolidBrush(Color.Red); + g.FillEllipse(brRed, _startPosX + 95, _startPosY + 15, 20, 20); + g.DrawEllipse(pen, _startPosX + 95, _startPosY + 15, 20, 20); + } + + if (cruiserWith.Rocket) + { + g.DrawEllipse(pen, _startPosX + 8, _startPosY + 3, 15, 12); + g.FillEllipse(brBlack, _startPosX + 8, _startPosY + 3, 15, 12); + g.DrawEllipse(pen, _startPosX + 8, _startPosY + 18, 15, 12); + g.FillEllipse(brBlack, _startPosX + 8, _startPosY + 18, 15, 12); + g.DrawEllipse(pen, _startPosX + 8, _startPosY + 33, 15, 12); + g.FillEllipse(brBlack, _startPosX + 8, _startPosY + 33, 15, 12); + + } + + } + } +} diff --git a/Cruiser/Cruiser/EntityCruiser.cs b/Cruiser/Cruiser/EntityCruiser.cs index 3971b80..1940d82 100644 --- a/Cruiser/Cruiser/EntityCruiser.cs +++ b/Cruiser/Cruiser/EntityCruiser.cs @@ -4,34 +4,24 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace Cruiser +namespace ProjectCruiser.Entities { - internal class EntityCruiser + public class EntityCruiser { public int Speed { get; private set; } public double Weight { get; private set; } - + public Color BodyColor { get; private set; } - public Color AdditionalColor { get; private set; } - - public bool Vert { get; private set; } - - public bool Rocket { get; private set; } - public double Step => (double)Speed * 100 / Weight; - - public void Init(int speed, double weight, Color bodyColor, Color - additionalColor, bool vert, bool rocket) + + public EntityCruiser(int speed, double weight, Color bodyColor) { Speed = speed; Weight = weight; BodyColor = bodyColor; - AdditionalColor = additionalColor; - - Vert = vert; - Rocket = rocket; } } } + diff --git a/Cruiser/Cruiser/EntityCruiserDou.cs b/Cruiser/Cruiser/EntityCruiserDou.cs new file mode 100644 index 0000000..fb514cf --- /dev/null +++ b/Cruiser/Cruiser/EntityCruiserDou.cs @@ -0,0 +1,21 @@ +using System; + +namespace ProjectCruiser.Entities +{ + public class EntityCruiserDou : EntityCruiser + { + public Color AdditionalColor { get; private set; } + + public bool Vert { get; private set; } + + public bool Rocket { get; private set; } + + public EntityCruiserDou(int speed, double weight, Color bodyColor, Color additionalColor, bool vert, bool rocket) + : base(speed, weight, bodyColor) + { + AdditionalColor = additionalColor; + Vert = vert; + Rocket = rocket; + } + } +} diff --git a/Cruiser/Cruiser/FormCruiser.Designer.cs b/Cruiser/Cruiser/FormCruiser.Designer.cs index 2958a8d..2cc1a0c 100644 --- a/Cruiser/Cruiser/FormCruiser.Designer.cs +++ b/Cruiser/Cruiser/FormCruiser.Designer.cs @@ -1,4 +1,4 @@ -namespace Cruiser +namespace ProjectCruiser { partial class FormCruiser { @@ -28,15 +28,106 @@ /// private void InitializeComponent() { - this.pictureBoxCruiser = new System.Windows.Forms.PictureBox(); - this.buttonCreate = new System.Windows.Forms.Button(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FormCruiser)); + this.comboBoxStrategy = new System.Windows.Forms.ComboBox(); + this.ButtonCreateCruiserBat = new System.Windows.Forms.Button(); + this.ButtonCreateCruiser = new System.Windows.Forms.Button(); + this.ButtonStep = new System.Windows.Forms.Button(); this.buttonUp = new System.Windows.Forms.Button(); - this.buttonLeft = new System.Windows.Forms.Button(); this.buttonDown = new System.Windows.Forms.Button(); + this.buttonLeft = new System.Windows.Forms.Button(); this.buttonRight = new System.Windows.Forms.Button(); + this.pictureBoxCruiser = new System.Windows.Forms.PictureBox(); ((System.ComponentModel.ISupportInitialize)(this.pictureBoxCruiser)).BeginInit(); this.SuspendLayout(); // + // comboBoxStrategy + // + this.comboBoxStrategy.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.comboBoxStrategy.FormattingEnabled = true; + this.comboBoxStrategy.Items.AddRange(new object[] { + "MoveToCenter", + "MoveToBorder", + "-"}); + this.comboBoxStrategy.Location = new System.Drawing.Point(667, 12); + this.comboBoxStrategy.Name = "comboBoxStrategy"; + this.comboBoxStrategy.Size = new System.Drawing.Size(121, 23); + this.comboBoxStrategy.TabIndex = 0; + // + // ButtonCreateCruiserBat + // + this.ButtonCreateCruiserBat.Location = new System.Drawing.Point(19, 386); + this.ButtonCreateCruiserBat.Name = "ButtonCreateCruiserBat"; + this.ButtonCreateCruiserBat.Size = new System.Drawing.Size(160, 57); + this.ButtonCreateCruiserBat.TabIndex = 1; + this.ButtonCreateCruiserBat.Text = "Создать крейсер с ракетными шахтами и площадкой под вертолет"; + this.ButtonCreateCruiserBat.UseVisualStyleBackColor = true; + this.ButtonCreateCruiserBat.Click += new System.EventHandler(this.ButtonCreateUstaBat_Click); + // + // ButtonCreateCruiser + // + this.ButtonCreateCruiser.Location = new System.Drawing.Point(185, 386); + this.ButtonCreateCruiser.Name = "ButtonCreateCruiser"; + this.ButtonCreateCruiser.Size = new System.Drawing.Size(157, 55); + this.ButtonCreateCruiser.TabIndex = 2; + this.ButtonCreateCruiser.Text = "Создать крейсер"; + this.ButtonCreateCruiser.UseVisualStyleBackColor = true; + this.ButtonCreateCruiser.Click += new System.EventHandler(this.ButtonCreateUsta_Click); + // + // ButtonStep + // + this.ButtonStep.Location = new System.Drawing.Point(713, 50); + this.ButtonStep.Name = "ButtonStep"; + this.ButtonStep.Size = new System.Drawing.Size(75, 23); + this.ButtonStep.TabIndex = 3; + this.ButtonStep.Text = "Шаг"; + this.ButtonStep.UseVisualStyleBackColor = true; + this.ButtonStep.Click += new System.EventHandler(this.ButtonStep_Click); + // + // buttonUp + // + this.buttonUp.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("buttonUp.BackgroundImage"))); + this.buttonUp.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom; + this.buttonUp.Location = new System.Drawing.Point(678, 352); + this.buttonUp.Name = "buttonUp"; + this.buttonUp.Size = new System.Drawing.Size(44, 38); + this.buttonUp.TabIndex = 4; + this.buttonUp.UseVisualStyleBackColor = true; + this.buttonUp.Click += new System.EventHandler(this.ButtonMove_Click); + // + // buttonDown + // + this.buttonDown.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("buttonDown.BackgroundImage"))); + this.buttonDown.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom; + this.buttonDown.Location = new System.Drawing.Point(678, 395); + this.buttonDown.Name = "buttonDown"; + this.buttonDown.Size = new System.Drawing.Size(44, 38); + this.buttonDown.TabIndex = 5; + this.buttonDown.UseVisualStyleBackColor = true; + this.buttonDown.Click += new System.EventHandler(this.ButtonMove_Click); + // + // buttonLeft + // + this.buttonLeft.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("buttonLeft.BackgroundImage"))); + this.buttonLeft.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom; + this.buttonLeft.Location = new System.Drawing.Point(629, 395); + this.buttonLeft.Name = "buttonLeft"; + this.buttonLeft.Size = new System.Drawing.Size(44, 38); + this.buttonLeft.TabIndex = 6; + this.buttonLeft.UseVisualStyleBackColor = true; + this.buttonLeft.Click += new System.EventHandler(this.ButtonMove_Click); + // + // buttonRight + // + this.buttonRight.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("buttonRight.BackgroundImage"))); + this.buttonRight.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom; + this.buttonRight.Location = new System.Drawing.Point(727, 395); + this.buttonRight.Name = "buttonRight"; + this.buttonRight.Size = new System.Drawing.Size(44, 38); + this.buttonRight.TabIndex = 7; + this.buttonRight.UseVisualStyleBackColor = true; + this.buttonRight.Click += new System.EventHandler(this.ButtonMove_Click); + // // pictureBoxCruiser // this.pictureBoxCruiser.Dock = System.Windows.Forms.DockStyle.Fill; @@ -44,78 +135,22 @@ this.pictureBoxCruiser.Name = "pictureBoxCruiser"; this.pictureBoxCruiser.Size = new System.Drawing.Size(800, 450); this.pictureBoxCruiser.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; - this.pictureBoxCruiser.TabIndex = 0; + this.pictureBoxCruiser.TabIndex = 8; this.pictureBoxCruiser.TabStop = false; // - // buttonCreate - // - this.buttonCreate.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left))); - this.buttonCreate.Location = new System.Drawing.Point(12, 408); - this.buttonCreate.Name = "buttonCreate"; - this.buttonCreate.Size = new System.Drawing.Size(83, 30); - this.buttonCreate.TabIndex = 1; - this.buttonCreate.Text = "Создать"; - this.buttonCreate.UseVisualStyleBackColor = true; - this.buttonCreate.Click += new System.EventHandler(this.buttonCreate_Click); - // - // buttonUp - // - this.buttonUp.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); - this.buttonUp.BackgroundImage = global::Cruiser.Properties.Resources.вверх; - this.buttonUp.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom; - this.buttonUp.Location = new System.Drawing.Point(720, 372); - this.buttonUp.Name = "buttonUp"; - this.buttonUp.Size = new System.Drawing.Size(30, 30); - this.buttonUp.TabIndex = 2; - this.buttonUp.UseVisualStyleBackColor = true; - this.buttonUp.Click += new System.EventHandler(this.buttonMove_Click); - // - // buttonLeft - // - this.buttonLeft.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); - this.buttonLeft.BackgroundImage = global::Cruiser.Properties.Resources.влево; - this.buttonLeft.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom; - this.buttonLeft.Location = new System.Drawing.Point(684, 408); - this.buttonLeft.Name = "buttonLeft"; - this.buttonLeft.Size = new System.Drawing.Size(30, 30); - this.buttonLeft.TabIndex = 3; - this.buttonLeft.UseVisualStyleBackColor = true; - this.buttonLeft.Click += new System.EventHandler(this.buttonMove_Click); - // - // buttonDown - // - this.buttonDown.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); - this.buttonDown.BackgroundImage = global::Cruiser.Properties.Resources.вниз; - this.buttonDown.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom; - this.buttonDown.Location = new System.Drawing.Point(720, 408); - this.buttonDown.Name = "buttonDown"; - this.buttonDown.Size = new System.Drawing.Size(30, 30); - this.buttonDown.TabIndex = 4; - this.buttonDown.UseVisualStyleBackColor = true; - this.buttonDown.Click += new System.EventHandler(this.buttonMove_Click); - // - // buttonRight - // - this.buttonRight.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); - this.buttonRight.BackgroundImage = global::Cruiser.Properties.Resources.вправо; - this.buttonRight.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom; - this.buttonRight.Location = new System.Drawing.Point(756, 408); - this.buttonRight.Name = "buttonRight"; - this.buttonRight.Size = new System.Drawing.Size(30, 30); - this.buttonRight.TabIndex = 5; - this.buttonRight.UseVisualStyleBackColor = true; - this.buttonRight.Click += new System.EventHandler(this.buttonMove_Click); - // // FormCruiser // this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(800, 450); this.Controls.Add(this.buttonRight); - this.Controls.Add(this.buttonDown); this.Controls.Add(this.buttonLeft); + this.Controls.Add(this.buttonDown); this.Controls.Add(this.buttonUp); - this.Controls.Add(this.buttonCreate); + this.Controls.Add(this.ButtonStep); + this.Controls.Add(this.ButtonCreateCruiser); + this.Controls.Add(this.ButtonCreateCruiserBat); + this.Controls.Add(this.comboBoxStrategy); this.Controls.Add(this.pictureBoxCruiser); this.Name = "FormCruiser"; this.Text = "FormCruiser"; @@ -126,12 +161,14 @@ } #endregion - - private PictureBox pictureBoxCruiser; - private Button buttonCreate; + private ComboBox comboBoxStrategy; + private Button ButtonCreateCruiserBat; + private Button ButtonCreateCruiser; + private Button ButtonStep; private Button buttonUp; - private Button buttonLeft; private Button buttonDown; + private Button buttonLeft; private Button buttonRight; + private PictureBox pictureBoxCruiser; } } \ No newline at end of file diff --git a/Cruiser/Cruiser/FormCruiser.cs b/Cruiser/Cruiser/FormCruiser.cs index 0cee200..155264c 100644 --- a/Cruiser/Cruiser/FormCruiser.cs +++ b/Cruiser/Cruiser/FormCruiser.cs @@ -1,11 +1,15 @@ -using System.Windows.Forms; +using ProjectCruiser.DrawningObjects; +using ProjectCruiser.Drawnings; +using ProjectCruiser.MovementStrategy; -namespace Cruiser +namespace ProjectCruiser { public partial class FormCruiser : Form { private DrawningCruiser? _drawningCruiser; - + + private AbstractStrategy? _abstractStrategy; + public FormCruiser() { InitializeComponent(); @@ -19,29 +23,41 @@ namespace Cruiser } Bitmap bmp = new(pictureBoxCruiser.Width, pictureBoxCruiser.Height); - Graphics gr = Graphics.FromImage(bmp); - _drawningCruiser.DrawTransport(gr); + Graphics gr = Graphics.FromImage(bmp); + _drawningCruiser.DrawTransport(gr); pictureBoxCruiser.Image = bmp; } - - private void buttonCreate_Click(object sender, EventArgs e) + + private void ButtonCreateUstaBat_Click(object sender, EventArgs e) { Random random = new(); - _drawningCruiser = new DrawningCruiser(); - _drawningCruiser.Init(random.Next(100, 300), + _drawningCruiser = new DrawningCruiserDou(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)), pictureBoxCruiser.Width, pictureBoxCruiser.Height); - _drawningCruiser.SetPosition(random.Next(10, 100), - random.Next(10, 100)); + Convert.ToBoolean(random.Next(0, 2)), Convert.ToBoolean(random.Next(0, 2)), + pictureBoxCruiser.Width, pictureBoxCruiser.Height); + _drawningCruiser.SetPosition(random.Next(10, 100), random.Next(10, + 100)); Draw(); } - - private void buttonMove_Click(object sender, EventArgs e) + + private void ButtonCreateUsta_Click(object sender, EventArgs e) + { + Random random = new(); + _drawningCruiser = new DrawningCruiser(random.Next(100, 300), + random.Next(1000, 3000), + Color.FromArgb(random.Next(0, 256), random.Next(0, 256), + random.Next(0, 256)), + pictureBoxCruiser.Width, pictureBoxCruiser.Height); + _drawningCruiser.SetPosition(random.Next(10, 100), random.Next(10, + 100)); + Draw(); + } + + private void ButtonMove_Click(object sender, EventArgs e) { if (_drawningCruiser == null) { @@ -65,5 +81,43 @@ namespace Cruiser } Draw(); } + + private void ButtonStep_Click(object sender, EventArgs e) + { + if (_drawningCruiser == null) + { + return; + } + if (comboBoxStrategy.Enabled) + { + _abstractStrategy = comboBoxStrategy.SelectedIndex + switch + { + 0 => new MoveToCenter(), + 1 => new MoveToBorder(), + _ => null, + }; + if (_abstractStrategy == null) + { + return; + } + _abstractStrategy.SetData(new + DrawningObjectCruiser(_drawningCruiser), pictureBoxCruiser.Width, + pictureBoxCruiser.Height); + comboBoxStrategy.Enabled = false; + } + if (_abstractStrategy != null) + { + _abstractStrategy.MakeStep(); + Draw(); + + if (_abstractStrategy.GetStatus() == Status.Finish) + { + comboBoxStrategy.Enabled = true; + _abstractStrategy = null; + } + } + } + } -} \ No newline at end of file +} diff --git a/Cruiser/Cruiser/FormCruiser.resx b/Cruiser/Cruiser/FormCruiser.resx index f298a7b..365b6e2 100644 --- a/Cruiser/Cruiser/FormCruiser.resx +++ b/Cruiser/Cruiser/FormCruiser.resx @@ -57,4 +57,1926 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + /9j/4AAQSkZJRgABAQEASABIAAD/4QAiRXhpZgAATU0AKgAAAAgAAQESAAMAAAABAAEAAAAAAAD/2wBD + AAIBAQIBAQICAgICAgICAwUDAwMDAwYEBAMFBwYHBwcGBwcICQsJCAgKCAcHCg0KCgsMDAwMBwkODw0M + DgsMDAz/2wBDAQICAgMDAwYDAwYMCAcIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM + DAwMDAwMDAwMDAwMDAz/wAARCAJUAlQDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQF + BgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAk + M2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWG + h4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx + 8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQA + AQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5 + OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmq + srO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD9 + 8oIMv1ZlY5+Y5qb7On91fyog/wBWKkJwKAI/s6f3V/Kj7On91fyoW5Dfln8Kd5q+q/nQA37On91fyo+z + p/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR + 5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91 + fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q + +q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA3 + 7On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX + 8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q + /nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+ + zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/n + R5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On9 + 1fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5 + q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA + 37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/d + X8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+ + q/nQA37On91fyo+zp/dX8qd5q+q/nR5q+q/nQA37On91fyo+zp/dX8qXz13feX86QXSt05/GgA+zp/dX + 8qa8CxrlEXjtTkuFc8VJQBVZfKYjLHnP3qKdMhL9f0ooAlg/1YpJRuiYelLB/qxSScI3+1QJ7HzX/wAF + Cf8AgoVpv/BPfwZoOva14b1TxBaa9qDWKLZTxR+UREz8lz/s4x75r5Z/4iZ/Av8A0TPxZ/4FwVN/wcsg + r+zf8Pef+ZlckdA3+iy9fyr8ZfM/2Vr8o4o4ozDBZjLD0JLlSi1dJ7pN7p9T+9/AHwE4P4p4Po5vnFCU + q0p1E2qkoq0ZNLRO2x+yn/ETP4F/6Jn4s/8AAuCj/iJn8C/9Ez8Wf+BcFfjX5n+ytHmf7K189/rzm38y + /wDAY/5H7T/xKj4d/wDQLP8A8HVP8z9lP+ImfwL/ANEz8Wf+BcFH/ETP4F/6Jn4s/wDAuCvxr8z/AGVo + 8z/ZWj/XnNv5l/4DH/IP+JUfDv8A6BZ/+Dqn+Z+yn/ETP4F/6Jn4s/8AAuCj/iJn8C/9Ez8Wf+BcFfjX + 5n+ytHmf7K0f685t/Mv/AAGP+Qf8So+Hf/QLP/wdU/zP2U/4iZ/Av/RM/Fn/AIFwUf8AETP4F/6Jn4s/ + 8C4K/GvzP9laPM/2Vo/15zb+Zf8AgMf8g/4lR8O/+gWf/g6p/mfsp/xEz+Bf+iZ+LP8AwLgo/wCImfwL + /wBEz8Wf+BcFfjX5n+ytHmf7K0f685t/Mv8AwGP+Qf8AEqPh3/0Cz/8AB1T/ADP2U/4iZ/Av/RM/Fn/g + XBR/xEz+Bf8Aomfiz/wLgr8a/M/2Vo8z/ZWj/XnNv5l/4DH/ACD/AIlR8O/+gWf/AIOqf5n7Kf8AETP4 + F/6Jn4s/8C4KP+ImfwL/ANEz8Wf+BcFfjX5n+ytHmf7K0f685t/Mv/AY/wCQf8So+Hf/AECz/wDB1T/M + /ZT/AIiZ/Av/AETPxZ/4FwUf8RM/gX/omfiz/wAC4K/GvzP9laPM/wBlaP8AXnNv5l/4DH/IP+JUfDv/ + AKBZ/wDg6p/mfsp/xEz+Bf8Aomfiz/wLgo/4iZ/Av/RM/Fn/AIFwV+Nfmf7K0eZ/srR/rzm38y/8Bj/k + H/EqPh3/ANAs/wDwdU/zP2U/4iZ/Av8A0TPxZ/4FwUf8RM/gX/omfiz/AMC4K/GvzP8AZWjzP9laP9ec + 2/mX/gMf8g/4lR8O/wDoFn/4Oqf5n7Kf8RM/gX/omfiz/wAC4KP+ImfwL/0TPxZ/4FwV+Nfmf7K0eZ/s + rR/rzm38y/8AAY/5B/xKj4d/9As//B1T/M/ZT/iJn8C/9Ez8Wf8AgXBR/wARM/gX/omfiz/wLgr8a/M/ + 2Vo8z/ZWj/XnNv5l/wCAx/yD/iVHw7/6BZ/+Dqn+Z+yn/ETP4F/6Jn4s/wDAuCj/AIiZ/Av/AETPxZ/4 + FwV+Nfmf7K0eZ/srR/rzm38y/wDAY/5B/wASo+Hf/QLP/wAHVP8AM/ZT/iJn8C/9Ez8Wf+BcFH/ETP4F + /wCiZ+LP/AuCvxr8z/ZWjzP9laP9ec2/mX/gMf8AIP8AiVHw7/6BZ/8Ag6p/mfsp/wARM/gX/omfiz/w + Lgo/4iZ/Av8A0TPxZ/4FwV+Nfmf7K0eZ/srR/rzm38y/8Bj/AJB/xKj4d/8AQLP/AMHVP8z9lP8AiJn8 + C/8ARM/Fn/gXBR/xEz+Bf+iZ+LP/AALgr8a/M/2Vo8z/AGVo/wBec2/mX/gMf8g/4lR8O/8AoFn/AODq + n+Z+yn/ETP4F/wCiZ+LP/AuCj/iJn8C/9Ez8Wf8AgXBX41+Z/srR5n+ytH+vObfzL/wGP+Qf8So+Hf8A + 0Cz/APB1T/M/ZT/iJn8C/wDRM/Fn/gXBR/xEz+Bf+iZ+LP8AwLgr8a/M/wBlaPM/2Vo/15zb+Zf+Ax/y + D/iVHw7/AOgWf/g6p/mfsp/xEz+Bf+iZ+LP/AALgo/4iZ/Av/RM/Fn/gXBX41+Z/srR5n+ytH+vObfzL + /wABj/kH/EqPh3/0Cz/8HVP8z9lP+ImfwL/0TPxZ/wCBcFH/ABEz+Bf+iZ+LP/AuCvxr8z/ZWjzP9laP + 9ec2/mX/AIDH/IP+JUfDv/oFn/4Oqf5n7Kf8RM/gX/omfiz/AMC4KP8AiJn8C/8ARM/Fn/gXBX41+Z/s + rR5n+ytH+vObfzL/AMBj/kH/ABKj4d/9As//AAdU/wAz9lP+ImfwL/0TPxZ/4FwUf8RM/gX/AKJn4s/8 + C4K/GvzP9laPM/2Vo/15zb+Zf+Ax/wAg/wCJUfDv/oFn/wCDqn+Z+yn/ABEz+Bf+iZ+LP/AuCj/iJn8C + /wDRM/Fn/gXBX41+Z/srR5n+ytH+vObfzL/wGP8AkH/EqPh3/wBAs/8AwdU/zP2U/wCImfwL/wBEz8Wf + +BcFH/ETP4F/6Jn4s/8AAuCvxr8z/ZWjzP8AZWj/AF5zb+Zf+Ax/yD/iVHw7/wCgWf8A4Oqf5n7Kf8RM + /gX/AKJn4s/8C4KP+ImfwL/0TPxZ/wCBcFfjX5n+ytHmf7K0f685t/Mv/AY/5B/xKj4d/wDQLP8A8HVP + 8z9lP+ImfwL/ANEz8Wf+BcFH/ETP4F/6Jn4s/wDAuCvxr8z/AGVo8z/ZWj/XnNv5l/4DH/IP+JUfDv8A + 6BZ/+Dqn+Z+yn/ETP4F/6Jn4s/8AAuCj/iJn8C/9Ez8Wf+BcFfjX5n+ytHmf7K0f685t/Mv/AAGP+Qf8 + So+Hf/QLP/wdU/zP2U/4iZ/Av/RM/Fn/AIFwUf8AETP4F/6Jn4s/8C4K/GvzP9laPM/2Vo/15zb+Zf8A + gMf8g/4lR8O/+gWf/g6p/mfsp/xEz+Bf+iZ+LP8AwLgo/wCImfwL/wBEz8Wf+BcFfjX5n+ytHmf7K0f6 + 85t/Mv8AwGP+Qf8AEqPh3/0Cz/8AB1T/ADP2U/4iZ/Av/RM/Fn/gXBR/xEz+Bf8Aomfiz/wLgr8a/M/2 + Vo8z/ZWj/XnNv5l/4DH/ACD/AIlR8O/+gWf/AIOqf5n7Kf8AETP4F/6Jn4s/8C4KP+ImfwL/ANEz8Wf+ + BcFfjX5n+ytHmf7K0f685t/Mv/AY/wCQf8So+Hf/AECz/wDB1T/M/ZT/AIiZ/Av/AETPxZ/4FwUf8RM/ + gX/omfiz/wAC4K/GvzP9laPM/wBlaP8AXnNv5l/4DH/IP+JUfDv/AKBZ/wDg6p/mfsp/xEz+Bf8Aomfi + z/wLgo/4iZ/Av/RM/Fn/AIFwV+Nfmf7K0eZ/srR/rzm38y/8Bj/kH/EqPh3/ANAs/wDwdU/zP2Sk/wCD + mTwO64/4Vn4sH/b3BXTfA3/g4H8IfHP4veHPCFl8PvEVhdeIr5LKK4muoDHEzHGTzn8K/EbK/wB0V7V/ + wTw/5Pj+Ff8A2MdpyAMn5u9dGF42zWdaEZTVm19ld/RHg8UfRf4BwWUYrGYfDTU6dKpKP72bV4wbV033 + Wx/S7DK0s6Z469quVRg/18fvmr1fuF21qf5eRIZfv0US/fooKHwf6sUkn3PypYP9WKST7n5UEy2PzM/4 + OXP+Tb/h7/2Mj/8ApLNX4xV+zv8Awcuf8m3/AA9/7GR//SWavxir8H46/wCRvP0j/wCko/1f+ib/AMm6 + w/8A18q/+lsKKKK+PP6TCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAK9r/4J4/8nyfCv/sY7T/0OvFK9r/4J4/8nyfCv/sY7T/0OurA + /wC8Q9V+Z8txx/yT2O/681f/AE3I/pbt/wDj4j/Gr1Ubf/j4j/Gr1f07HY/w2j/l+RDL9+iiX79FMofB + /qxSSfc/Klg/1YpJPuflQTLY/Mz/AIOXP+Tb/h7/ANjI/wD6SzV+MVfs7/wcuf8AJt/w9/7GR/8A0lmr + 8Yq/B+Ov+RvP0j/6Sj/V/wCib/ybrD/9fKv/AKWwooor48/pMKKKKACiiigAooooAKKKKACiiigAoooo + AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo + AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAr2v/AIJ4/wDJ8nwr/wCx + jtP/AEOvFK9r/wCCeP8AyfJ8K/8AsY7T/wBDrqwP+8Q9V+Z8txx/yT2O/wCvNX/03I/pbt/+PiP8avVR + t/8Aj4j/ABq9X9Ox2P8ADaP+X5EMv36KJfv0Uyh8H+rFJJ9z8qWD/Vikk+5+VBMtj8zP+Dlz/k2/4e/9 + jI//AKSzV+MVfs7/AMHLn/Jt/wAPf+xkf/0lmr8Yq/B+Ov8Akbz9I/8ApKP9X/om/wDJusP/ANfKv/pb + Ciiivjz+kwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACva/+CeP/J8nwr/7GO0/9DrxSva/+CeP/J8nwr/7GO0/9DrqwP8AvEPVfmfL + ccf8k9jv+vNX/wBNyP6W7f8A4+I/xq9VG3/4+I/xq9X9Ox2P8No/5fkQy/fool+/RTKHwf6sUkn3PypY + P9WKST7n5UEy2PzM/wCDlz/k2/4e/wDYyP8A+ks1fjFX7O/8HLn/ACbf8Pf+xkf/ANJZq/GKvwfjr/kb + z9I/+ko/1f8Aom/8m6w//Xyr/wClsKKKK+PP6TCiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo + AKKKKACiiigAooooAKKKKACiiigAooooAKKKkjgaaQKvzM3YdaNw2GiIs2Oc9cDripI7QyiTDL+76nIx + zjHOcHrnjPHNexfsPfsa+J/21fjpYeFNBtm+y/8AHzqmoSZW30226eY7AHqeFUcsfQAkeuf8FPf+CZWt + fsM+JVv9MN7rXgXWTi31S5KO9o5C4tplVQEYEYEgwjLxkN8tepTyjEzwssYoPkTtf+vuv30PzvMfEvIs + LxFR4XqYiKxVSPMo/NWi30k1rFPVrVJo+O6Ksf2c/lhx8y9zkcc4yRn7ue/pzVevMlFrc/Qo1Iy+EKKK + KRQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXt + f/BPH/k+T4V/9jHaf+h14pXtf/BPH/k+T4V/9jHaf+h11YH/AHiHqvzPluOP+Sex3/Xmr/6bkf0t2/8A + x8R/jV6qNv8A8fEf41er+nY7H+G0f8vyIZfv0US/foplD4P9WKST7n5UsH+rFJJ9z8qCZbH5mf8ABy5/ + ybf8Pf8AsZH/APSWavxir9nf+Dlz/k2/4e/9jI//AKSzV+MVfg/HX/I3n6R/9JR/q/8ARN/5N1h/+vlX + /wBLYUUUV8ef0mFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRUkUBlOB1xux7DrQJtLVjY4jK+1a779nL9nfxN+0v8AFfR/CPhXTV1LUtTJkXzTiGCIHDSSkHKK + vfv2AJIBw/hn8MtY+K/jrS/DuhWsuoatqkqw20EADNK7AlVHPU474AHJIHNfv1/wTR/4J1aT+w/8KF8y + G1u/G2uJG+uaiIxIwYDetumfuxp0JHL5ycHBH1XDPDdXMsRad4wj8T/Ref6XPwLxz8asJwRldqDU8XVT + VOD2Xecu0Y/+TP3Va7a7j9h79h/w3+xB8Ibbw3ocS3GoORPqmpuAJtSmPBdsdAo4VQcAepyT6J8Z/gf4 + f+OPw11rwr4m0231TRNcgaG5gK8kE5DA9mDfMCOh5612a2m1cDjg/r1p86FoSF/Tiv3ang6NOgsNGK5E + rW6W7H+UOMzzMMXmLzfEVpPESlzud/e5r3un0t0tZJJJWSP5xf8AgoX+wH4m/Yj+LEul3EcuoeG9SBud + I1V4wpuYAMCIkE/Mg4KffJ5245r5umtvJZfnVlZBICpDfKfoe3QjseK/p1/ar/ZS8N/tYfBzUvCPii1W + a1uk329yq/v7GcfdmjOcBl/LseOK/nk/bB/ZU8Vfsf8Axb1bwr4ks1iWOYPZXaQ7Yb+DqssZHQEcspwQ + 3Y1+KcVcMywFT2tFXpPbyfZ/o308z/TL6O3jguLMH/ZOaTUcdTWv/T2KXxr+8vtru01vp5BRTmi2ru6r + 0BHRj7U2vij+qrhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR + RRQAUUUUAFe1/wDBPH/k+T4V/wDYx2n/AKHXile1/wDBPH/k+T4V/wDYx2n/AKHXVgf94h6r8z5bjj/k + nsd/15q/+m5H9Ldv/wAfEf41eqjb/wDHxH+NXq/p2Ox/htH/AC/Ihl+/RRL9+imUPg/1YpJPuflSwf6s + Ukn3PyoJlsfmZ/wcuf8AJt/w9/7GR/8A0lmr8Yq/Z3/g5c/5Nv8Ah7/2Mj/+ks1fjFX4Px1/yN5+kf8A + 0lH+r/0Tf+TdYf8A6+Vf/S2FFFFfHn9JhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA + BRRRQAUUUUAFFFFABRRQFyRjvQAu3n+WO9aWgaLdaxrlra2dvNdXlxKqW0ES7pZJP4VVR94n071Bb2ki + 34UOituAL8sq56fiew71+wn/AARe/wCCV0Pwz0XS/ix8QtLX/hKruPzdG0+4XLWMTfdmdScea3VB2XnN + e5keS18xxCo09O77I/K/FbxRy3grJpZjjfenLSnTvrOetkuyW8n0XnZP1H/gkT/wS/s/2TfBdn4w8UWd + vJ8Q9ZtFMgMQYaTE6nMUX+2d2HJ5xwMDivuVdO2BcemOlEOn7Zum3a24Hr2x+tXsV+/Zdl9HBUI4egrJ + fj5vzZ/kLxZxVmPEma1c3zWbnVm9+iXSMV0jFaJfPfUKKKK7j50ZMrOhUdxivnL9vn9hHQ/21/gleaJq + DLp+uW6GTR9VC/PYTDkLnvEx6g8+9fSFV7m3Yx/IxU+qgZx2FY4jD08RSlQrK8ZbnpZPm+MyrHUsyy+o + 6dalJSjJbpp3/wCA1s02nofy3/Hn4H+JPgB8UNU8KeKNLk0nVtHYRToU/dMAflmQ/wBxxyDzx1weK4Vo + iEDdm6V/Ql/wVE/4Jraf+3F8KpbjS/J03x/o6l9MvEXat3Hu3NbzcjcrHkEng847V+Bfj3wLqnw78Wah + pOrWE+k6hYyG3ubObAkhdOuR7/8A6s1+CcScO1Mtr23hL4X38vVfjuf6zeB3jLg+N8qvUtDF0klVgvwn + G+8Zfg7p9Dn6KMYor5g/eAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA + CiiigAooooAK9r/4J4/8nyfCv/sY7T/0OvFK9r/4J4/8nyfCv/sY7T/0OurA/wC8Q9V+Z8txx/yT2O/6 + 81f/AE3I/pbt/wDj4j/Gr1Ubf/j4j/Gr1f07HY/w2j/l+RDL9+iiX79FMofB/qxSSfc/Klg/1YpJPufl + QTLY/Mz/AIOXP+Tb/h7/ANjI/wD6SzV+MVfs7/wcuf8AJt/w9/7GR/8A0lmr8Yq/B+Ov+RvP0j/6Sj/V + /wCib/ybrD/9fKv/AKWwooor48/pMKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK + KACiiigAoop6Rbzx7mgBmM1MbYRSAsN/y7sBgOPX6e5pYLVjKNu0sMttLAEgde9feP8AwR6/4JZzftY+ + KoPHHjKxnh+H+jT7ljkTa2u3A6LzjMK98DmvRy3La2Nrxw9Fe8/6u/I+M4644yzhbKamb5pPlpwW32pS + fwxiuspdPK7eiPR/+CLf/BKw+Obmy+LXxD0uRtHtiJNA0y6XK6g4XIuZFP8Ayy/uhwM1+wVpoawAbflV + d2F7DPp/L2HFQaP4Wj0azhtbWKG0tbVFiiiiTaiIowvHTI9uPatqv6ByXJ6GW4dUKO/V9W+/+S6H+QHi + T4jZnxrnM82zFtLVU4XuqcOkV5veT6tvpYMUUUV6x8CFFFFABSY+alooAq3VmZIuu7vjFfn5/wAFk/8A + glp/w1D4Vfx94HsYF+IWixEXMCqqtrkC9FHrKn8JPWv0NqjPpmY2287iCV9cV5+ZZZQx1CVDELR/en0a + 81/wOp9NwfxhmfDGbUs4ymfLUpvbpJPeMl1jJb9eq1SP5RdS0+TTryW2uo3tbqBmjlhlG1omVtrKR2IN + U6/Xn/gtZ/wSom8VRal8Xfh/p4k1K3hE3iLSrW3Akuo1IH2mFRwSo++o5I5HpX5HLp8jqWXLKpAyB2IG + D+o69Ny9yBX8/wCdZLXy7EuhVWnR9Gu6/wAj/X3wu8UMs40yWGaYOSU1ZVIX96E7ap+T3i9mrdbpV6KK + K8c/TQooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAr2v/gnj/yf + J8K/+xjtP/Q68Ur2v/gnj/yfJ8K/+xjtP/Q66sD/ALxD1X5ny3HH/JPY7/rzV/8ATcj+lu3/AOPiP8av + VRt/+PiP8avV/Tsdj/DaP+X5EMv36KJfv0Uyh8H+rFJJ9z8qWD/Vikk+5+VBMtj8zP8Ag5c/5Nv+Hv8A + 2Mj/APpLNX4xV+zv/By5/wAm3/D3/sZH/wDSWavxir8H46/5G8/SP/pKP9X/AKJv/JusP/18q/8ApbCi + iivjz+kwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACpoXFvJ8zKvB5P + T8Kalu0rBVVtzEKBjqT0Ar3T9g39h/xF+3H8b7Pw7o8dxb6TbsJ9Z1ZI/wB3p0AHUk8bnPyovVj6KCw6 + MLhauIqxo0k3KTskeLn2fYHKMDVzDMaip0qcXKUnskv1b0S3baSu2jvv+CXn/BOq8/bp+JEIu4bi18G6 + HMs2uag0eBcMD8tpC/8AfI+Y4zgdfSv32+Hvwz034aeD9L0HR7ODT9L0q3Fvb28S7ViUdMD37+tYH7Pn + 7O3h39mr4ZaX4P8ACenQ6VoekxlIY4x88j/xzSN/FJIfmLHv7cV6P1r994d4fp5ZQstakvif6Ly/Pr2X + +RPjJ4uY3jnNnV96GEptqlTb6dZytvOXXflT5U2tWm35cUtFFfRn4+FFFFABRRRQAUUUUAFJt/OlooAz + tR09prdsbZM84YcZPf8AzxjjFfjJ/wAFnP8AglpP8I9Rv/ir4E09X8K3k3navpccbNJokpJzJCAMeS7E + u+77rMx6HFftRLD5sZX1xWL4l8GWvibQbvT762hurG8gkt5oZRuWWNxhlPcg59a8fPMmo5lh3Rq6NbPs + /wCt/wDM/QvDPxIzPgvOIZpl/vRdlUg3pON72fZreMuj7q6P5UVsSULb4yAccMCT9OfXgntVevuT/grh + /wAE1rz9jrxk/ibwvZtcfDvxFcu8LRIxk0iYtzZudxxGTyucDPy5zXxC9i0RXzMLuGeobGc4zgn0r+f8 + wy2tg6zoVlZr+r+h/r7wTxrlvE+VU84y2opU6i07xfWMl0lF6Nfdpq4aKKK88+xCiiigAooooAKKKKAC + iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK9r/4J4/8AJ8nwr/7GO0/9DrxSva/+CeP/ACfJ + 8K/+xjtP/Q66sD/vEPVfmfLccf8AJPY7/rzV/wDTcj+lu3/4+I/xq9VG3/4+I/xq9X9Ox2P8No/5fkQy + /fool+/RTKHwf6sUkn3PypYP9WKST7n5UEy2PzM/4OXP+Tb/AIe/9jI//pLNX4xV+zv/AAcuf8m3/D3/ + ALGR/wD0lmr8Yq/B+Ov+RvP0j/6Sj/V/6Jv/ACbrD/8AXyr/AOlsKKKK+PP6TCiiigAooooAKKKKACii + igAooooAKKKKACiiigAooooAKKKKACiiigAqSC2+0PtVlU4J+Y46VHXWfB/4Ra38c/iRpfhTw3ai+1jW + JTFbQBhlivL984UfMSAcL82CK0o0pVJKMFdvQ4sdmGHwlGVfETUIxTbbdkktW23skb37Lf7N/iT9qX40 + 6P4M8M2CXt5qzHzZQf3Njb/xzu38AXIAbucAZJAP9Ef7Hf7G/hv9jT4Nad4P8OwB2hHnajqEqjz9SnK4 + aWQjqSOAM4UcDgnPD/8ABOj/AIJ56D+wz8I0s7Zbe48YazEj65qvlr5lxIM4ijOTtiTk7QTuJ3HJJJ+m + kg2LjnAOetfuPCXDMcvpfWK38WX/AJKu3q+v3ev+VX0gPHCrxpjv7Oy2TjgaL06e1kr++12X2E9l7zs3 + aL9nHB75p1FFfZn84hRRRQAUUUUAFFFFABRRRQAUUUUAFMmGUPuMU+igDj/iZ8JdF+Knw71bw34gsYdS + 0XWrdra6tpF+V1Ixx3BB5BHIPPXmvwB/4KV/8E8NX/YU+LtxbxxzXng/W2a40fUigDbd5PkO3TzFB6fx + dq/oqljaVCvTNea/tKfsyeG/2oPhFqnhHxVYx3unahEVV9oaS1k24WWMn7roeQR+tfM8ScPQzLD2jpUi + vdf6Pyf5/O/7J4L+L2N4GzZVHeeEqNe1h8/jir2547dOZXT6W/l9ktjE2D7g8dCACR9Rnmo69w/bn/Y5 + 8SfsZfG7UfCutQ/6EvlnS71EIh1O3CL+9U9NwI2upIcH+HHNeI7cJu7ZAr8FxWHqUKjpVVaS0aP9cshz + zCZtgKWY4Kop0qkVKMls09v+D2ejs0xtFFFc57QUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF + ABRRRQAUUUUAFe1/8E8f+T5PhX/2Mdp/6HXile1/8E8f+T5PhX/2Mdp/6HXVgf8AeIeq/M+W44/5J7Hf + 9eav/puR/S3b/wDHxH+NXqo2/wDx8R/jV6v6djsf4bR/y/Ihl+/RRL9+imUPg/1YpJPuflSwf6sUkn3P + yoJlsfmZ/wAHLn/Jt/w9/wCxkf8A9JZq/GKv2d/4OXP+Tb/h7/2Mj/8ApLNX4xV+D8df8jefpH/0lH+r + /wBE3/k3WH/6+Vf/AEthRRRXx5/SYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU6K + IzSqq9WOBmnQwNO21euCam07TpNRvI4oVaZ5H2+XGCzsewUAElj0A7nimk3sZVq0acXKT2Vy74S8Hah4 + y8RWem6ZaXF7fX062sEEcTM8srfdRfUnrx254r92/wDgk3/wTLtP2N/h/beIPEi2uofEfV7NVvJ4/mj0 + iIkEWtvnjB/jc/MT8v3eK8//AOCPv/BLmP4DaLYfFDx1pcbeMdQtgNF0+SFWOg27DPmFvu/aGHViRgcD + 1r9Fbew8tt3+0W6dM9fz6/Xmv2Hg3hf6vFY7FR95/Cn0XfXr+R/ml9JLx4ln9aXDORVP9lg7VZx/5eyT + +FPrTi939pp9LXWCzKlcKqLGMKAOg71coHSiv0Y/j+MbaBRRRQUFFFFABRRRQAUUUUAFFFFABRRRQAUU + UUAFR3Ee6Erz+FSUUAeA/txfsR+HP21fgzeeGdeiVbuP95pOoIg8zT5+gKnIJBHytngj35r+ev8AaE/Z + 88Sfs1/FLWPB/izT5bPWNMm27iP3VzHnCyxsCVZG7EN14PrX9RNzZl4m2t82MBh94A9a+WP+Cl//AATl + 0j9uf4SSLHDBZ+N9HjMujaiqKG65MDk9UfvnoefavieLuGI4+n9YoL97H/yby9fP8z+lvo9+OlXg7Hf2 + TmknLAVpa/8ATqTfxpfy/wA6Xa61vf8AnfaDEatuVtxIG055qOui+JPgHVPhf421PQda0240fVNLlMF3 + bTLtaKRf8e2Otc8yMnVa/EKlNwfKz/VDB4uliKUa9GSlGSTTTummrpp9mhKKKKg6gooooAKKKKACiiig + AooooAKKKKACiiigAooooAKKKKACiiigAr2v/gnj/wAnyfCv/sY7T/0OvFK9r/4J4/8AJ8nwr/7GO0/9 + DrqwP+8Q9V+Z8txx/wAk9jv+vNX/ANNyP6W7f/j4j/Gr1Ubf/j4j/Gr1f07HY/w2j/l+RDL9+iiX79FM + ofB/qxSSfc/Klg/1YpJPuflQTLY/Mz/g5c/5Nv8Ah7/2Mj/+ks1fjFX7O/8ABy5/ybf8Pf8AsZH/APSW + avxir8H46/5G8/SP/pKP9X/om/8AJusP/wBfKv8A6Wwooor48/pMKKKKACiiigAooooAKKKKACiiigAo + oooAKKKKACiiigAop2zLYHPWrFvp7NP5ZZAzEAKfvEnoMep7dvcVUYt7GdSpGKu2Na0aJ2B6hckhhjB6 + Ec8/QV+rH/BF7/glVcaheaV8YPiRpyp5P7zw5pcqbS/pczLx9VGOTzntXln/AAR3/wCCWUn7RPiKx+In + jexaPwTplwz2dlKmJNfuFGS7A/8ALBOhx1PAr9tNP0lLOGOGJVhhjUKqIoUKF+6BjoB2FfpnBvCqqNY7 + FL3d4rv5vy8up/Bf0mPHx01PhLh6r77vGvUi/hT3pRae7+21svdvfmJYbBkl/wBnr0685/n+nFXjzQea + K/Wj+B9gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAqvdWxkhbGGbHGR0PY1YooA+C + f+Cun/BMeH9rDwNN4v8ACdjHH8RtDhZoiY0261GvWJuRmb+6x4r8Mtb0S40LUJ7G+DWt5aO0M8EqFJYZ + Vba0bKeQQePr7c1/Vrd6bvhk24YnGV2j5gOgPsK/M3/gtF/wS0/4Wn4e1j4seA9FDeKtPQNrFhaqN2qQ + qeZ40H/LZRyw6unT5vlP5zxlwsqyePwq95ayXfzS79+/rv8A2V9Gnx6llFWnwpn9T/Z5tKlUk1am3pyS + b2pt7PaDeqs21+NdFWG0+RS3B+QqGwOmfY9/btVevx+UWtz/AEkjOMvhCiiipKCiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAK9r/wCCeP8AyfJ8K/8AsY7T/wBDrxSva/8Agnj/AMnyfCv/ALGO0/8A + Q66sD/vEPVfmfLccf8k9jv8ArzV/9NyP6W7f/j4j/Gr1Ubf/AI+I/wAavV/Tsdj/AA2j/l+RDL9+iiX7 + 9FMofB/qxSSfc/Klg/1YpJPuflQTLY/Mz/g5c/5Nv+Hv/YyP/wCks1fjFX7O/wDBy5/ybf8AD3/sZH/9 + JZq/GKvwfjr/AJG8/SP/AKSj/V/6Jv8AybrD/wDXyr/6Wwooor48/pMKKKKACiiigAooooAKKKKACiii + gAooooAKKKKAClRGkbApKlht/NmVSzfN0x/F7D3PQDueKaJk7K45E8s7iVXj+L1PGPrn9Oa+x/8Aglj/ + AMEx9Q/bS8errGuR3Gl+A/D8mzVbuOVc6odu42lu2epHLuMqB0bd8teff8E9v2BvEn7c3xnj0mwSWx8M + aa4fXtXwCtrGQR5anPzSvgqoXODljwrFf6Dvgt8DdE+A/wAO9J8K+GLCPSdD0WBbe2gj/uj+Jj3djyzH + qea+94R4VeMl9axStTT/APAmunp3+70/kH6R3jt/q5h3kORVU8bUXvSVn7KL6/45L4U9Yp8/8t9Pwb8O + rHwPoWn6Vpdpb2GmaXClvbW8KbUhjQYVR7DqfU810gTHejZ8uKdX7RGKirLY/wAz225Ocm227tvVtvVt + vqwoooqgCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAAxWXe6IZIZArM/cR/d + Vvm3fz/+tg81qVHcIzR7V9MDHagVrn44/wDBbH/gl8fBct98X/h3pG7R7mZp/EWnwAKNOJHzXUagj90x + /wBYAPlX5/uhiPzBe3KAHIOfTr7D6nt296/q21fw3HqVjcW9yI7q3uImilhmiWSKYMNp3KeoI6jofxOf + w/8A+Cvf/BLqb9lPxDN4y8D2Zb4f6w+ZoEXd/YcrPuEIOeImblCeg4NfkvGnC3spPMMLH3W/eXZvqvJ9 + e3of6B/Rp8fniYUuEOIKn71WVGrJ/GulOTf2l9l/aXuv3knL4FoqwunM8LMGj3Ku/YzBWYfKOOeSNwyB + 255HNV6/MbWP7qp1Yz+F3Ciiig0CiiigAooooAKKKKACiiigAooooAKKKKACiiigAr2v/gnj/wAnyfCv + /sY7T/0OvFK9r/4J4/8AJ8nwr/7GO0/9DrqwP+8Q9V+Z8txx/wAk9jv+vNX/ANNyP6W7f/j4j/Gr1Ubf + /j4j/Gr1f07HY/w2j/l+RDL9+iiX79FMofB/qxSSfc/Klg/1YpJPuflQTLY/Mz/g5c/5Nv8Ah7/2Mj/+ + ks1fjFX7O/8ABy5/ybf8Pf8AsZH/APSWavxir8H46/5G8/SP/pKP9X/om/8AJusP/wBfKv8A6Wwooor4 + 8/pMKKKKACiiigAooooAKKKKACiiigAooooAKKKeISx+Xngt+H+e1AD4LN7lmWPkgE5PAP4mvXP2NP2S + fE/7YXxu0vwr4ZhVvtEf2i7vpVb7Pp9v0MzkZ2kHp/teork/gX8DfEf7QnxQ0nwr4W0z+19W1Z/3KPny + ljJwZXI+7GO7HpX9CH/BPr9hLQv2Fvgtb+H7HbqGuXWJ9Z1R0CyXs+3lBjpEn3VXPTuTzX13C/Dc8xrc + 87qnHd9/Jevfofzn4+eN2G4Ly76tgpRnja0Wqcd+VO69pJdl9lfal5KTXXfsmfsf+G/2P/hJo/g/wvC6 + 2mmxs093IFE+ozuMSTS4H3mPIA+7gAHHFewEZoxzRX7rRowpU1Spq0Y6Jdl2P8pswx+Ix2JqYzFzc6lR + uUpN3bb3bCiiitTkCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA + Gy/cPvXK/EP4X6Z8TvBOqaBr9na6vo+rQG2urO4jzFKjDDfifXtXWVHNHmEhvmHtSkk4uMldMqnOdOpG + rTbjKLTTTs01qmnumu6P57f+CoX/AAT01b9h/wCItzJb28mq+A9ckDaPqHlDdbS7gPKlP95FBjUH7wJJ + +YsW+RZLdozjnOM4x06dfzr+or9oT9nrw/8AtIfCfWPCPiyxi1DR9Wj8qQMPmhPVZkbqrqeQQa/ny/b0 + /YU8UfsP/FO50XVo/M0e8cHR7tfmF/CoG1884IIwUJ35/hxzX4pxfwxLBz+s0F+7l/5K+3+X3H+m30cv + HanxJhFkecTUcdBaN6e2irLmX99byS/xa+9b5+oqY2bK0gyv7oZbLD1xxzzUNfBn9bRkpbBRRRQUFFFF + ABRRRQAUUUUAFFFFABRRRQAUUUUAFe1/8E8f+T5PhX/2Mdp/6HXile1/8E8f+T5PhX/2Mdp/6HXVgf8A + eIeq/M+W44/5J7Hf9eav/puR/S3b/wDHxH+NXqo2/wDx8R/jV6v6djsf4bR/y/Ihl+/RRL9+imUPg/1Y + pJPuflSwf6sUkn3PyoJlsfmZ/wAHLn/Jt/w9/wCxkf8A9JZq/GKv2d/4OXP+Tb/h7/2Mj/8ApLNX4xV+ + D8df8jefpH/0lH+r/wBE3/k3WH/6+Vf/AEthRRRXx5/SYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVYs + GImDKdrqC6kjODVepLdv3496un8RMo8ysf0Gf8Etv+CbOl/sUfDH+0tS+z6l498QxrcaneIi7bVT8wto + eD+79eRn2r64is9zBvulRgAdAM56fpVPQkP9lWvzMWMUf3ucfL2rYAwK/pjL8FRwuGhQoq0Ul+SP8K+J + eIMfnuaVs2zSbnVqu7b+5JLoorRLorBRRRXaeKFFFFABRRRQAUUUUAFFFRyz+UpJHTHegCSiq8eoCT+H + 3HXp+XX2qxQAUUUUAFFFFABRRRQAUUMcCqbar5bNuj2x9mz9Tk+gwBz70bgXKKhW8WRQVwwbGDnjnpU1 + ABRRRQAUUUUAFFFFABRRRQBDcxF4CvUNjj2rxj9sv9jLw3+2b8ENQ8JeIoR5kiGXTr1AFm065C4SRD+h + B4YccHmvbMHPWo5Iso4z1/nWOIw9OvSdGqrxlo0dmW5li8uxUMfgqjhVptSjJOzTWzX9fmfy4ftH/BnU + /wBnn4y+IvA+tzWsmoeFbt7NzDjacYZW6c7lOcdvevP6+lP+CtoaD/go38Wv9nVV7ekMQH6Gvmuv5rzG + jGliZ04bJtL0TP8AbvgjMa+YcP4LMMS71K1GlOVtFecIydl01d7dAooorhPqQooooAKKKKACiiigAooo + oAKKKKACiiigAr2v/gnj/wAnyfCv/sY7T/0OvFK9r/4J4/8AJ8nwr/7GO0/9DrqwP+8Q9V+Z8txx/wAk + 9jv+vNX/ANNyP6W7f/j4j/Gr1Ubf/j4j/Gr1f07HY/w2j/l+RDL9+iiX79FMofB/qxSSfc/Klg/1YpJP + uflQTLY/Mz/g5c/5Nv8Ah7/2Mj/+ks1fjFX7O/8ABy5/ybf8Pf8AsZH/APSWavxir8H46/5G8/SP/pKP + 9X/om/8AJusP/wBfKv8A6Wwooor48/pMKKKKACiiigAooooAKKKKACiiigAooooAKfb/AOuX60yn2/8A + rl+taU/iA/q70H/kF2n/AFzj/wDQa1qydB/5Bdp/1zj/APQa1q/qKn8C9F+R/ghLcKKKKoQUUUUAFFFF + ABRRTHnEUe5uKAFklEK7m4rz39oL9ojwx+zn8KNX8WeLdQg0vR9JTc8jsd0zfwxxqBlnbsoHv05p/wAe + /wBojwv+zv8ACrVvFnizUIdL0fS13SSOSzSsekcagZZz2UD6kDmvwC/4KEf8FFfEf7fHxMa81BptK8H6 + azDRdF8xjGBn5Jpc8tIy/MSfp04r5niTiOlllKys6j2X6vy/N/O37Z4MeC+Y8dZjd3p4Om/3lS2+3uQ7 + zd1d7RWru7J/u1+xh+0t/wANcfs/6P48i0uTR7fXDM8FpNJumjiWRkUtj+I4z7e/WvZK+S/+CLaY/wCC + dfw5PzfNBclunzHz39q+tK9bKa1StgqVWr8Uopv5o/O+Nssw+XcQ47AYRWp0q1SEV2jGcor8EFFFFegf + LhRRRQAUUUUANdvlr5n/AOCof7QniD9lb9kPWfHPhyaNdS0PUNP8tZE3I6SXMUbKw7gqxH419KXZxGfa + vjT/AILsP5X/AATV8bN/Et3pm0kdP9Mhry86qSp5fWqQdmoSa+SPtfDXL8Pj+L8rwWLip06mIpRlF7OM + qkU0/Jp2PTP2Ff29/CP7cXwvh1rQbjytSs/3GqaY/E1lMeuRwSp/hYDB6cHivfor9ZQv3fm4GDxkDJr+ + YD9l39qPxT+yb8W9M8XeFdRmtb61IW4i3fu79P4oZV7o3tgjqDnmv3+/YX/b38H/ALcfwzj1zQZ1g1Oy + KxarpchxPYzkYIK4+ZG6q44PQ4PFeDwvxRDMKfsaztVX/k3mj9V8d/AnGcFYp5jl6lPL6j0e7pN7Qm/y + l12bvv8ARFFQRX8cm3lfm6YOQeMnFT19kfzqFFFFABRRRQAUUUUAFNPKH3p1N/5Z0B0P5xP+Cuf/ACkc + +Ln/AGEh/wCioa+aK+l/+Cuf/KRz4uf9hNf/AEVBXzRX805t/vlX/FL82f7b+GX/ACSOV/8AYNh//TMA + ooorzT7kKKKKACiiigAooooAKKKKACiiigAooooAK9r/AOCeP/J8nwr/AOxjtP8A0OvFK9r/AOCeP/J8 + nwr/AOxjtP8A0OurA/7xD1X5ny3HH/JPY7/rzV/9NyP6W7f/AI+I/wAavVRt/wDj4j/Gr1f07HY/w2j/ + AJfkQy/fool+/RTKHwf6sUkn3PypYP8AVikk+5+VBMtj8zP+Dlz/AJNv+Hv/AGMj/wDpLNX4xV+zv/By + 5/ybf8Pf+xkf/wBJZq/GKvwfjr/kbz9I/wDpKP8AV/6Jv/JusP8A9fKv/pbCiiivjz+kwooooAKKKKAC + iiigAooooAKKKKACiiigAp9v/rl+tMp9v/rl+taU/iA/q70H/kF2n/XOP/0GtasnQf8AkF2n/XOP/wBB + rWr+oqfwL0X5H+CEtwoooqhBRRRQAUUUyadYI9zcUADzeXHubivPvj5+0Z4V/Zy+FOqeK/F2pQ6Vo2mq + rSSuSzOW+6iKBlpD2UD3OBzR8ff2ifC/7PHwj1Xxb4p1KPS9H0tQ0kj5ZpCfuxooG5pD2UD3OBzX4A/8 + FDv+Ch/iT9u/4kNcXckmn+DdOdl0bRw5Kquf9bLnlpGXkk9Og44r5riLiOjllK171Hsv1fZL8dl1t+2e + DHgvmXHWYXs6eCpv95U+73IXVnN316QTu76Jyf8ABRH/AIKMeJv29PiVJdXzS6R4P0t2TRdHVmKBSeJZ + SeWkZeSxHsMDivm83BlxlmDDnI9cY/lR9rJ9d2AM57AYA/KolGTX4RjcdWxVV168ryfU/wBZOGeGcuyL + LaWV5ZSVOjTSUYry6t9W3q29W2223c/oh/4Isjd/wTp+HP8A173B/wDJh6+sq+Tv+CLH/KOn4c/9e1z/ + AOlD19Y1/Q+Rf8i2h/gj+R/jP4mf8lfmn/YRW/8ATkgooor1T4cKKKKACiiigCG7/wBW1fGf/BeFM/8A + BNXxt/1+ab/6WQ19mXf+ravjX/gvB/yjU8bf9fmm/wDpZDXkZ9/yLMR/17n+R+heEX/JdZP/ANhND/05 + E/n/AI28qTcMbuvPrXpn7MH7U3ir9k34t6b4u8I6jJb3lr+7nhb/AFN9EfvQyr3U+2COoOea8vqWKTy5 + N38X9fWv50oYipRmqlJtNbNH+zWbZPhMzwlTBY6mqlKonGUWrpp76H9JP7Df7ePg/wDbh+GsOueHbhbf + VLNlh1XSpCPOsJmGNuOPkbs44PQgHivoBb5Gbb+APZj6Cv5g/wBlr9qvxR+yR8WtM8XeF76SG6s/kubc + n9zqER+/DKvdT+Y6g55r9/f2Gf28PCP7bvw0i1zw7cbdUtWWHVtLmbE1hOe2ODsP8L4wfav3DhXimnmM + Fh6ulWK+/wA0f5WeO3gRjOCcW8wwEXUy+o/dlu6Te0Jv/wBJls9m77/QtFQJfK7AfLycA54Jxnip6+yP + 52CiiigAooooAKb/AMs6dTf+WdAdD+cT/grn/wApHPi5/wBhNf8A0VBXzRX0v/wVz/5SOfFz/sJr/wCi + oK+aK/mnNv8AfKv+KX5s/wBt/DL/AJJHLP8AsGw//pmmFFFFeafchRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABXtf/BPH/k+T4V/9jHaf+h14pXtf/BPH/k+T4V/9jHaf+h11YH/eIeq/M+W44/5J7Hf9eav/AKbk + f0t2/wDx8R/jV6qNv/x8R/jV6v6djsf4bR/y/Ihl+/RRL9+imUPg/wBWKST7n5UsH+rFJJ9z8qCZbH5m + f8HLn/Jt/wAPf+xkf/0lmr8Yq/Z3/g5c/wCTb/h7/wBjI/8A6SzV+MVfg/HX/I3n6R/9JR/q/wDRN/5N + 1h/+vlX/ANLYUUUV8ef0mFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFPt/wDXL9aZT7f/AFy/WtKfxAf1 + d6D/AMgu0/65x/8AoNa1ZOg/8gu0/wCucf8A6DWtX9RU/gXovyP8EJbhRRRVCCiio5LgRLlh0xQA55BG + m5uK4D48/tF+F/2efhRqvizxZqEel6RpaBpZGyzOzfdjRR8zSHsoHucDmmfHn9o3wp8APhTrHizxZqcO + l6LpK/v5iSxLn7sSqBlpG7KB7nA5r8A/+Chv/BRHxL+3n8Rpri8kn0rwfpzMNG0RXbhCf9dL/ekZeST0 + 6DjivmuIuI6OW0Wk71Hsv1fZL73sutv2vwY8Gcx46zBSs6eCpv8AeVO+3uQurObutdVFO76Jr/wUN/4K + J+JP27viLJcXUk+m+DdLZho2jI7EbCf9dLnlpGXkkjjoOOK+cJrhptpYgsvAY/ewBgD8qJpzOcsxLZB3 + E/McDAyfpUNfhGOx1bF1nXryvJ7v+vy2P9YuGOF8uyHL6eV5ZSVOlTSUUvxbe7bd229W3dsKcnWm05Ot + cZ9Gf0Q/8EWP+UdPw5/69rn/ANKHr6xr5O/4Isf8o6fhz/17XP8A6UPX1jX9JZD/AMi2h/gX5H+I/iZ/ + yV2af9hFb/05IKKKK9Y+HCiiigAooooAhu/9W1fGv/BeD/lGp42/6/NN/wDSyGvsq7/1bV8a/wDBeD/l + Gp42/wCvzTf/AEshryM+/wCRZiP+vc/yP0Lwi/5LrJ/+wmh/6cifz90UUV/Nx/tciSJvKk3cFvevTv2V + v2pfFP7Jnxf0rxh4XvpIby1PlzRE/ur+I/ehlXoyn8x2NeW1Lay+VLuHVTlc9jW1DEVKM1UpNprqjzc2 + ynCZlhKmCx1NVKdROMoyV00/J/8ADn9I/wCw7+3V4P8A23/hrBrfh64EWqWZEeraZMf31hMRhuOPkb+F + u/QgHivoJb5XfbxnoOeCfQV/MD+yt+1d4o/ZD+LGm+LfCd9JHd274ubeQ/uL+I/ejlToc+vbqOea/oA/ + Ya/bv8I/tu/DKHXdBn26tbbU1TTJeJrCUjIJHXyzj5Xxz6Cv3LhfiinmFNUK2lVfj5o/yp8dvAnF8E4p + 5jgIueAqP3Zbum3tCb8/sy67N33+hKKhjvlm+7huccHjI6/lU1fYH87hRRRQAU3/AJZ06m/8s6A6H84n + /BXP/lI58XP+wmv/AKKgr5or6X/4K5/8pHPi5/2E1/8ARUFfNFfzTm3++Vf8UvzZ/tv4Zf8AJI5Z/wBg + 2H/9M0wooorzT7kKKKKACiiigAooooAKKKKACiiigAooooAK9r/4J4/8nyfCv/sY7T/0OvFK9r/4J4/8 + nyfCv/sY7T/0OurA/wC8Q9V+Z8txx/yT2O/681f/AE3I/pbt/wDj4j/Gr1Ubf/j4j/Gr1f07HY/w2j/l + +RDL9+iiX79FMofB/qxSSfc/Klg/1YpJPuflQTLY/Mz/AIOXP+Tb/h7/ANjI/wD6SzV+MVfs7/wcuf8A + Jt/w9/7GR/8A0lmr8Yq/B+Ov+RvP0j/6Sj/V/wCib/ybrD/9fKv/AKWwooor48/pMKKKKACiiigAoooo + AKKKKACiiigAooooAKfb/wCuX60yn2/+uX61pT+ID+rvQf8AkF2n/XOP/wBBrWrJ0H/kF2n/AFzj/wDQ + a1q/qKn8C9F+R/ghLcKKKjmuRbx7m4FUIc8qxpuY4FeffHr9ozwr+z38K9U8WeKdSj0zSdLVWkfBeSQn + 7saJ1aQ9lH1OBzTv2gP2hvC/7PHwp1bxZ4s1CPTdD0pT5svLMz9BGijlnJ4AFfgH/wAFC/8Agof4m/bw + +Ic091NJpfgzS3YaPojSMyhS2BLL3aR1+Yk9Og44r5riLiKjltFreq9l+r7Jfjsutv2rwX8Gcx47zHS9 + PB03+9qW9HyQvo5tPs1FPmktk1/4KOf8FFPEH7fPxLae987T/Buksw0PR0ctGmTzPJkAmR15yc46Djiv + ms3LMmMkcjofQYAP4U+W687724tnJOepxgfpUFfhGOxtXFVXXrO8nuz/AFk4Y4Xy7IsupZXllNU6NNJR + S/Ft7tt3bb1bd7hRRRXGfRBTk602nJ1oA/oh/wCCLH/KOn4c/wDXtc/+lD19Y18nf8EWP+UdPw5/69rn + /wBKHr6xr+ksh/5FtD/AvyP8R/Ez/krs0/7CK3/pyQUUUV6x8OFFFFABRRRQBDd/6tq+Nf8AgvB/yjU8 + bf8AX5pv/pZDX2Vd/wCravjX/gvB/wAo1PG3/X5pv/pZDXkZ9/yLMR/17n+R+heEX/JdZP8A9hND/wBO + RP5+6KKK/m4/2uQUZoooAckhRt3DN716h+yz+1P4o/ZP+MGm+MPC+pTW95aSf6RAx/dX8eMGOUfxL+HH + avLadGfnz71tQxFSjNVKTaa2aPNzbKMJmeEqYLHQU6c04yi1dNPfR9fM/pP/AGHv27/CH7bfwutdd8O3 + Cx6nCBHqmmtxJYTHrvHB2t/C2OfQV76l8jsoGG3ZwQeOOv5V/ML+yn+1X4o/ZL+Lmn+LvC99Nb3Nq5+0 + Qf8ALHUExkrKvRs/p2r+gP8AYf8A23/Cf7bPwttvEHh+4jh1K2bydW0xmDTafOeqsB/C38L4wenB4r9x + 4X4op5hBUKulVL5S81/Xn6f5U+OngTi+CsX9fwKdTAVH7r3dJu9oTfX+7Lrs9d/faKhS9VnCnaC3C8/e + OMnH0qavsT+dwpv/ACzp1N/5Z0B0P5xP+Cuf/KRz4uf9hNf/AEVBXzRX0v8A8Fc/+Ujnxc/7Ca/+ioK+ + aK/mnNv98q/4pfmz/bfwy/5JHLP+wbD/APpmmFFFFeafchRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXt + f/BPH/k+T4V/9jHaf+h14pXtf/BPH/k+T4V/9jHaf+h11YH/AHiHqvzPluOP+Sex3/Xmr/6bkf0t2/8A + x8R/jV6qNv8A8fEf41er+nY7H+G0f8vyIZfv0US/foplD4P9WKST7n5UsH+rFJJ9z8qCZbH5mf8ABy5/ + ybf8Pf8AsZH/APSWavxir9nf+Dlz/k2/4e/9jI//AKSzV+MVfg/HX/I3n6R/9JR/q/8ARN/5N1h/+vlX + /wBLYUUUV8ef0mFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFPt/8AXL9aZT7f/XL9a0p/EB/V3oP/ACC7 + T/rnH/6DWtWToP8AyC7T/rnH/wCg1qSSiJSzV/UVP4V6L8j/AAQluEkoiTc3Fef/AB+/aH8M/s7fCvVv + F3irUItM0bSlBllYFmdj0jjQDLyN/Co69cgc0749ftEeGP2e/hRq3i3xVqCabo+kqDNIRveRj0jjUffk + PZR9Tgc1+Af/AAUW/wCCi/iP9vLx+t1eK+l+E9N3ro+iiVzsy3yzS5PzyMvOTjHTpxXzvEXEVHLKVt6j + 2X4XfZL8dl3X7P4NeDOZcdZjpeng6b/eVLej5Id5vbtFPmaeibf+Ch//AAUW8Tft1/ECS5neXRvB9i5T + StDErN8meJZifvyt94McbOnPWvm43Oe21upYH5if/wBVK0+T8vyjHTPfGP5dqhr8Ix2OrYus69eV5Pc/ + 1l4Y4Wy7IMvp5XldJU6NNWUV+bfVt3bb1bbb3YUUUVxH0YUUUUAFOTrTacnWgD+iH/gix/yjp+HP/Xtc + /wDpQ9fWNfJ3/BFj/lHT8Of+va5/9KHr6xr+ksh/5FtD/AvyP8R/Ez/krs0/7CK3/pyQUUUV6x8OFFFF + ABRRRQBDd/6tq+Nf+C8H/KNTxt/1+ab/AOlkNfZV3/q2r41/4Lwf8o1PG3/X5pv/AKWQ15Gff8izEf8A + Xuf5H6F4Rf8AJdZP/wBhND/05E/n7ooor+bj/a5BRRRQAUHrRRQBZs+JOZVhOxuX9cYr079lf9qrxR+y + T8VbDxZ4V1Jre5gJgks9zfZ7yM/eSdQBujPr1HUc815Wkuzp8v0qW1BLnMywZRsliRn2NdGHxFSlNTpO + zXU8bOsnwuZ4SpgsfBTpTTUotXTT3Vv6s9Vqf0nfsP8A7bvhL9tn4a23iDQbpE1G12xappjtum024IwV + IH8LdVfoenB4r3hb6NmUbh8xwD2J9q/mH/ZX/ar8UfshfFqx8XeFdRkhuYMxz2W5vIv4sZaOZQPmjP5j + qDnmv6AP2HP24PCf7a/wvt9f0G4iTVLUiDVdLdt02nXG3JBA/h9H6H2PFfuHC/FFPMIKjWdqq/HzX9f8 + D/K/x08C8XwVjHjsAnUwFR+7Ld02/sTf/pMuq0dpb+/U3/lnUS38bbfmB3HaCDwT7VL/AMs6+wP546H8 + 4n/BXP8A5SOfFz/sJr/6Kgr5or6X/wCCuf8Aykc+Ln/YTX/0VBXzRX805t/vlX/FL82f7b+GX/JI5Z/2 + DYf/ANM0wooorzT7kKKKKACiiigAooooAKKKKACiiigAooooAK9r/wCCeP8AyfJ8K/8AsY7T/wBDrxSv + a/8Agnj/AMnyfCv/ALGO0/8AQ66sD/vEPVfmfLccf8k9jv8ArzV/9NyP6W7f/j4j/Gr1Ubf/AI+I/wAa + vV/Tsdj/AA2j/l+RDL9+iiX79FMofB/qxSSfc/Klg/1YpJPuflQTLY/Mz/g5c/5Nv+Hv/YyP/wCks1fj + FX7O/wDBy5/ybf8AD3/sZH/9JZq/GKvwfjr/AJG8/SP/AKSj/V/6Jv8AybrD/wDXyr/6Wwooor48/pMK + KKKACiiigAooooAKKKKACiiigAooooAKfb/65frTKnsoPPuY1U/MxwAxC8/UnH61pT+JBzJas/q10SQR + 6Talv+ecf/oNcv8AHn9ojwz+z78KdW8W+KNRj03RtIA82Q/O0jHpHGv8bnso+uQOazfiz+0J4X/Z8+C9 + 34s8U6lHpej6PbxNO5G+RnKjbEi9WkbOQo7cnA5r8F/+CjX/AAUY8Qft6/ECO5uY5NK8J6eHXSNEaRv3 + Y3fLNL2eR15JIGOg44r99z/iKjluHUd6jSsvlu+yX47Ly/x48G/BvMeOczsk6eEpv95Ut5/BC+8381FO + 7T0TT/gox/wUZ8R/t7/EBLm8STTPCOms66Ponmt+7XPyzyjo0jrySQMdBxxXzZ5+OjMvQ9e+MfypGud3 + 95enQ+2D+lRV+FY7HVsVVdetK8nuz/WPhfhbLsgy6nlWV01TpU0lFL831bbu22223d6hRRRXGfSBRRRQ + AUUUUAFOTrTacnWgD+iH/gix/wAo6fhz/wBe1z/6UPX1jXyd/wAEWP8AlHT8Of8Ar2uf/Sh6+sa/pLIf + +RbQ/wAC/I/xH8TP+SuzT/sIrf8ApyQUUUV6x8OFFFFABRRRQBDd/wCravjX/gvB/wAo1PG3/X5pv/pZ + DX2Vd/6tq+Nf+C8H/KNTxt/1+ab/AOlkNeRn3/IsxH/Xuf5H6F4Rf8l1k/8A2E0P/TkT+fuiiiv5uP8A + a5BRRRQAUUUUAFPSXZ0+X6UyigCzbtuZv3yxkq2X3EHOMY+ntXp/7LH7WXin9kH4qWPi7wnqHk3UH7qe + zy3k38X3jHMgHzRnoO469ea8pMpPqfrVi3cF2/fLEzI2X3HPTGPp7V0YfETozU6bs11PGzrJ8LmeDqYL + HQU6U1aUWrpp7prr+j1R/Sb+w7+3D4T/AG1fhZba/oM8MepW4EOraYz7ptNuMZKkAfd9H6GvdReqWVOS + zDqPu59M1/MX+yv+1d4p/ZB+Kun+LvCt+Y7mFvKuLLcwhv4M5KTqBzH6dx6mv39/Yk/bo8J/tn/DCPX9 + BuUjvbUeXq2nM4afT5u+4Af6v0fjPoK/cOFuKIZjBUKztVS/8C80f5XeOvgZi+C8W8dgE6mAm/dlu6be + 0J/+2y2a3s9/xB/4K5/8pHPi5/2E1/8ARUFfNFfS3/BW5xL/AMFGfi4wK7TqagZP3v3UPSvmmvxnONMZ + V/xS/Nn+mXhnpwjlf/YNQ/8ATNMKKKK80+4CiiigAooooAKKKKACiiigAooooAKKKKACva/+CeP/ACfJ + 8K/+xjtP/Q68Ur2v/gnj/wAnyfCv/sY7T/0OurA/7xD1X5ny3HH/ACT2O/681f8A03I/pbt/+PiP8avV + Rt/+PiP8avV/Tsdj/DaP+X5EMv36KJfv0Uyh8H+rFJJ9z8qWD/Vikk+5+VBMtj8zP+Dlz/k2/wCHv/Yy + P/6SzV+MVfs7/wAHLn/Jt/w9/wCxkf8A9JZq/GKvwfjr/kbz9I/+ko/1f+ib/wAm6w//AF8q/wDpbCii + ivjz+kwooooAKKKKACiiigAooooAKKKKACiiigAq1p9zHBexSSZ2qd24KH2n6EYqrTg2P/rU07O6JnFS + i4vqfS3/AAUN/wCCiXiL9ufxrbyXP+geENJJj0jRw7boPugzTn7skhx1XOAdo44r5se5L5+8Px74x/Km + eaSW3ZfcMcnpzmm11YvG1sTVdas7yZ8/wzwvl+Q5fTyvLaahSp6JL722+rbbbb1bbYUUUVyH0QUUUUAF + FFFABRRRQAU5OtNpydaAP6If+CLH/KOn4c/9e1z/AOlD19Y18nf8EWP+UdPw5/69rn/0oevrGv6SyH/k + W0P8C/I/xH8TP+SuzT/sIrf+nJBRRRXrHw4UUUUAFFFFAEN3/q2r41/4Lwf8o1PG3/X5pv8A6WQ19lXf + +ravjX/gvB/yjU8bf9fmm/8ApZDXkZ9/yLMR/wBe5/kfoXhF/wAl1k//AGE0P/TkT+fuiiiv5uP9rkFF + FFABRRRQAUUUUAFOMpPqfrTaKALEO1iw87yso2W3HJ9j7V6j+yf+1X4o/ZD+KNj4s8L6kLeS33Jc2TM3 + k6hFt3GOZQBuBPAPb3rygyk+p+tAlKnP8Xrk5rfD4idGaqU3ZrqeTnGS4TNMJUwOPgp0qicZRaTTT0a+ + f4dD1b9sz46WP7Tf7SHi3x1b2kmnr4juI72OCU5eM+TChj6DoQTn26V5PT2l3eqjg4B4Bzk/nwPwplTW + rSqzdSW7bb+epWS5XRy3A0svwyap0oxhFN3ajCKjFX3eiWr1Ciiisj1AooooAKKKKACiiigAooooAKKK + KACiiigAr2v/AIJ4/wDJ8nwr/wCxjtP/AEOvFK9r/wCCeP8AyfJ8K/8AsY7T/wBDrqwP+8Q9V+Z8txx/ + yT2O/wCvNX/03I/pbt/+PiP8avVRt/8Aj4j/ABq9X9Ox2P8ADaP+X5EMv36KJfv0Uyh8H+rFJJ9z8qWD + /Vikk+5+VBMtj8zP+Dlz/k2/4e/9jI//AKSzV+MVfs7/AMHLn/Jt/wAPf+xkf/0lmr8Yq/B+Ov8Akbz9 + I/8ApKP9X/om/wDJusP/ANfKv/pbCiiivjz+kwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA + CiiigAooooAKKKKACiiigApydabTk60Af0Q/8EWP+UdPw5/69rn/ANKHr6xr5O/4Isf8o6fhz/17XP8A + 6UPX1jX9JZD/AMi2h/gX5H+I/iZ/yV2af9hFb/05IKKKK9Y+HCiiigAooooAhu/9W1fGv/BeD/lGp42/ + 6/NN/wDSyGvsq7/1bV8a/wDBeD/lGp42/wCvzTf/AEshryM+/wCRZiP+vc/yP0Lwi/5LrJ/+wmh/6cif + z90UUV/Nx/tcgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo + oAK9r/4J4/8AJ8nwr/7GO0/9DrxSva/+CeP/ACfJ8K/+xjtP/Q66sD/vEPVfmfLccf8AJPY7/rzV/wDT + cj+lu3/4+I/xq9VG3/4+I/xq9X9Ox2P8No/5fkQy/fool+/RTKHwf6sUkn3PypYP9WKST7n5UEy2PzM/ + 4OXP+Tb/AIe/9jI//pLNX4xV+zv/AAcuf8m3/D3/ALGR/wD0lmr8Yq/B+Ov+RvP0j/6Sj/V/6Jv/ACbr + D/8AXyr/AOlsKKKK+PP6TCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA + KKKKACnJ1ptOTrQB/RD/AMEWP+UdPw5/69rn/wBKHr6xr5O/4Isf8o6fhz/17XP/AKUPX1jX9JZD/wAi + 2h/gX5H+I/iZ/wAldmn/AGEVv/Tkgooor1j4cKKKKACiiigCG7/1bV8a/wDBeD/lGp42/wCvzTf/AEsh + r7Ku/wDVtXxr/wAF4P8AlGp42/6/NN/9LIa8jPv+RZiP+vc/yP0Lwi/5LrJ/+wmh/wCnIn8/dFFFfzcf + 7XIKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACva/+CeP + /J8nwr/7GO0/9DrxSva/+CeP/J8nwr/7GO0/9DrqwP8AvEPVfmfLccf8k9jv+vNX/wBNyP6W7f8A4+I/ + xq9VG3/4+I/xq9X9Ox2P8No/5fkQy/fool+/RTKHwf6sUkn3PypYP9WKST7n5UEy2PzM/wCDlz/k2/4e + /wDYyP8A+ks1fjFX7O/8HLn/ACbf8Pf+xkf/ANJZq/GKvwfjr/kbz9I/+ko/1f8Aom/8m6w//Xyr/wCl + sKKKK+PP6TCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACnJ1pt + OTrQB/RD/wAEWP8AlHT8Of8Ar2uf/Sh6+sa+Tv8Agix/yjp+HP8A17XP/pQ9fWNf0lkP/Itof4F+R/iP + 4mf8ldmn/YRW/wDTkgooor1j4cKKKKACiiigCG7/ANW1fGv/AAXg/wCUanjb/r803/0shr7Ku/8AVtXx + r/wXg/5RqeNv+vzTf/SyGvIz7/kWYj/r3P8AI/QvCL/kusn/AOwmh/6cifz90UUV/Nx/tcgooooAKKKK + ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK9r/AOCeP/J8nwr/AOxj + tP8A0OvFK9r/AOCeP/J8nwr/AOxjtP8A0OurA/7xD1X5ny3HH/JPY7/rzV/9NyP6W7f/AI+I/wAavVRt + /wDj4j/Gr1f07HY/w2j/AJfkQy/fool+/RTKHwf6sUkn3PypYP8AVikk+5+VBMtj8zP+Dlz/AJNv+Hv/ + AGMj/wDpLNX4xV+zv/By5/ybf8Pf+xkf/wBJZq/GKvwfjr/kbz9I/wDpKP8AV/6Jv/JusP8A9fKv/pbC + iiivjz+kwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigApydabTk + 60Af0Q/8EWP+UdPw5/69rn/0oevrGvk7/gix/wAo6fhz/wBe1z/6UPX1jX9JZD/yLaH+Bfkf4j+Jn/JX + Zp/2EVv/AE5IKKKK9Y+HCiiigAooooAhu/8AVtXxr/wXg/5RqeNv+vzTf/SyGvsq7/1bV8a/8F4P+Uan + jb/r803/ANLIa8jPv+RZiP8Ar3P8j9C8Iv8Akusn/wCwmh/6cifz90UUV/Nx/tcgooooAKKKKACiiigA + ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK9r/wCCeP8AyfJ8K/8AsY7T/wBD + rxSva/8Agnj/AMnyfCv/ALGO0/8AQ66sD/vEPVfmfLccf8k9jv8ArzV/9NyP6W7f/j4j/Gr1Ubf/AI+I + /wAavV/Tsdj/AA2j/l+RDL9+iiX79FMofB/qxSSfc/Klg/1YpJPuflQTLY/Mz/g5c/5Nv+Hv/YyP/wCk + s1fjFX7O/wDBy5/ybf8AD3/sZH/9JZq/GKvwfjr/AJG8/SP/AKSj/V/6Jv8AybrD/wDXyr/6Wwooor48 + /pMKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKcnWm05OtAH9E + P/BFj/lHT8Of+va5/wDSh6+sa+Tv+CLH/KOn4c/9e1z/AOlD19Y1/SWQ/wDItof4F+R/iP4mf8ldmn/Y + RW/9OSCiiivWPhwooooAKKKKAIbv/VtXxr/wXg/5RqeNv+vzTf8A0shr7Ku/9W1fGv8AwXg/5RqeNv8A + r803/wBLIa8jPv8AkWYj/r3P8j9C8Iv+S6yf/sJof+nIn8/dFFFfzcf7XIKKKKACiiigAooooAKKKKAC + iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACva/+CeP/ACfJ8K/+xjtP/Q68Ur2v/gnj + /wAnyfCv/sY7T/0OurA/7xD1X5ny3HH/ACT2O/681f8A03I/pbt/+PiP8avVRt/+PiP8avV/Tsdj/DaP + +X5EMv36KJfv0Uyh8H+rFJJ9z8qWD/Vikk+5+VBMtj8zP+Dlz/k2/wCHv/YyP/6SzV+MVfs7/wAHLn/J + t/w9/wCxkf8A9JZq/GKvwfjr/kbz9I/+ko/1f+ib/wAm6w//AF8q/wDpbCiiivjz+kwooooAKKKKACii + igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigApydabTk60Af0Q/wDBFj/lHT8Of+va + 5/8ASh6+sa+Tv+CLH/KOn4c/9e1z/wClD19Y1/SWQ/8AItof4F+R/iP4mf8AJXZp/wBhFb/05IKKKK9Y + +HCiiigAooooAhu/9W1fGv8AwXg/5RqeNv8Ar803/wBLIa+yrv8A1bV8a/8ABeD/AJRqeNv+vzTf/SyG + vIz7/kWYj/r3P8j9C8Iv+S6yf/sJof8ApyJ/P3RRRX83H+1yCiiigAooooAKKKKACiiigAooooAKKKKA + CiiigAooooAKKKKACiiigAooooAKKKKACiiigAr2v/gnj/yfJ8K/+xjtP/Q68Ur2v/gnj/yfJ8K/+xjt + P/Q66sD/ALxD1X5ny3HH/JPY7/rzV/8ATcj+lu3/AOPiP8avVRt/+PiP8avV/Tsdj/DaP+X5EMv36KJf + v0Uyh8H+rFJJ9z8qWD/Vikk+5+VBMtj8zP8Ag5c/5Nv+Hv8A2Mj/APpLNX4xV+zv/By5/wAm3/D3/sZH + /wDSWavxir8H46/5G8/SP/pKP9X/AKJv/JusP/18q/8ApbCiiivjz+kwooooAKKKKACiiigAooooAKKK + KACiiigAooooAKKKKACiiigAooooAKKKKACiiigApydabTk60Af0Q/8ABFj/AJR0/Dn/AK9rn/0oevrG + vk7/AIIsf8o6fhz/ANe1z/6UPX1jX9JZD/yLaH+Bfkf4j+Jn/JXZp/2EVv8A05IKKKK9Y+HCiiigAooo + oAhu/wDVtXxr/wAF4P8AlGp42/6/NN/9LIa+yrv/AFbV8a/8F4P+Uanjb/r803/0shryM+/5FmI/69z/ + ACP0Lwi/5LrJ/wDsJof+nIn8/dFFFfzcf7XIKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo + oooAKKKKACiiigAooooAKKKKACva/wDgnj/yfJ8K/wDsY7T/ANDrxSva/wDgnj/yfJ8K/wDsY7T/ANDr + qwP+8Q9V+Z8txx/yT2O/681f/Tcj+lu3/wCPiP8AGr1Ubf8A4+I/xq9X9Ox2P8No/wCX5EMv36KJfv0U + yh8H+rFJJ9z8qWD/AFYpJPuflQTLY/Mz/g5c/wCTb/h7/wBjI/8A6SzV+MVfs7/wcuf8m3/D3/sZH/8A + SWavxir8H46/5G8/SP8A6Sj/AFf+ib/ybrD/APXyr/6Wwooor48/pMKKKKACiiigAooooAKKKKACiiig + AooooAKKKKACiiigAooooAKKKKACiiigAooooAKcnWm05OtAH9EP/BFj/lHT8Of+va5/9KHr6xr5O/4I + sf8AKOn4c/8AXtc/+lD19Y1/SWQ/8i2h/gX5H+I/iZ/yV2af9hFb/wBOSCiiivWPhwooooAKKKKAIbv/ + AFbV8a/8F4P+Uanjb/r803/0shr7Ku/9W1fGv/BeD/lGp42/6/NN/wDSyGvIz7/kWYj/AK9z/I/QvCL/ + AJLrJ/8AsJof+nIn8/dFFFfzcf7XIKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK + KACiiigAooooAKKKKACva/8Agnj/AMnyfCv/ALGO0/8AQ68Ur2v/AIJ4/wDJ8nwr/wCxjtP/AEOurA/7 + xD1X5ny3HH/JPY7/AK81f/Tcj+lu3/4+I/xq9VG3/wCPiP8AGr1f07HY/wANo/5fkQy/fool+/RTKHwf + 6sUkn3PypYP9WKST7n5UEy2PzM/4OXP+Tb/h7/2Mj/8ApLNX4xV+zv8Awcuf8m3/AA9/7GR//SWavxir + 8H46/wCRvP0j/wCko/1f+ib/AMm6w/8A18q/+lsKKKK+PP6TCiiigAooooAKKKKACiiigAooooAKKKKA + CiiigAooooAKKKKACiiigAooooAKKKKACnwxtJIFUFmY4GB1plOV9sgb5gVORtOMU42vqTK9tD+h7/gj + FP8AZf8Agnb8OFPLNbT4APUGZzn+VfWH2geq/nX8xXgP9uX4u/C7wbH4f8N/Efxhoej2qlLe1stVlhjh + BZW+XaRjp+taP/Dx349f9Fk+JX/hQ3X/AMXX6pgOP8LhsLTw7pSfLFLddD/P3ib6IPEWbZ1jM0WOoxVa + rOaVp3SnJy10318/U/pk+0D1X86PtA9V/Ov5m/8Ah478ev8AosnxK/8AChuv/i6P+Hjvx6/6LJ8Sv/Ch + uv8A4uuv/iJOF/58y+9Hh/8AElPEX/Qwo/dP/I/pk+0D1X86PtA9V/Ov5m/+Hjvx6/6LJ8Sv/Chuv/i6 + P+Hjvx6/6LJ8Sv8Awobr/wCLo/4iThf+fMvvQf8AElPEX/Qwo/dP/I/pk+0D1X86PtA9V/Ov5m/+Hjvx + 6/6LJ8Sv/Chuv/i6P+Hjvx6/6LJ8Sv8Awobr/wCLo/4iThf+fMvvQf8AElPEX/Qwo/dP/I/peuZ1aI/M + vPvXxl/wXYvluP8Agmv40HC7rvTSDuB/5fbcf1PTPSvxs/4eO/Hr/osXxM/8KO6/+LrF+If7ZvxU+Lnh + m40XxT8RPG3iDR7sq01jqGtXFxbSFSGXdG7FThlB5HauLMuP8NicJUw0aUk5xcbtrqj6Tgv6I+fZJxBg + c5q46lKOHrU6jSU7tQkpNK6td2sr6Hl9FFFflh/fgUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFe1/8ABPH/AJPk+Ff/AGMdp/6HXile1/8ABPH/AJPk+Ff/AGMd + p/6HXVgf94h6r8z5bjj/AJJ7Hf8AXmr/AOm5H9Ldv/x8R/jV6qNv/wAfEf41er+nY7H+G0f8vyIZfv0U + S/foplD4P9WKST7n5UsH+rFJJ9z8qCZbH5mf8HLn/Jt/w9/7GR//AElmr8Yq/Z3/AIOXP+Tb/h7/ANjI + /wD6SzV+MVfg/HX/ACN5+kf/AElH+r/0Tf8Ak3WH/wCvlX/0thRRRXx5/SYUUUUAFFFFABRRRQAUUUUA + FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAGT7flRRRQAUUUUAFFFFABRRRQAUu7+WK + SigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACv + a/8Agnj/AMnyfCv/ALGO0/8AQ68Ur2v/AIJ4/wDJ8nwr/wCxjtP/AEOurA/7xD1X5ny3HH/JPY7/AK81 + f/Tcj+lu3/4+I/xq9VG3/wCPiP8AGr1f07HY/wANo/5fkQy/fool+/RTKHwf6sUkn3PypYP9WKST7n5U + Ey2PzM/4OXP+Tb/h7/2Mj/8ApLNX4xV+zv8Awcuf8m3/AA9/7GR//SWavxir8H46/wCRvP0j/wCko/1f + +ib/AMm6w/8A18q/+lsKKKK+PP6TCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii + gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii + gAooooAKKKKACiiigAooooAKKKKACiiigAooooAK9r/4J4/8nyfCv/sY7T/0OvFK9r/4J4/8nyfCv/sY + 7T/0OurA/wC8Q9V+Z8txx/yT2O/681f/AE3I/pbt/wDj4j/Gr1Ubf/j4j/Gr1f07HY/w2j/l+RDL9+ii + X79FMofB/qxSSfc/Klg/1YpJPuflQTLY/Mz/AIOXP+Tb/h7/ANjI/wD6SzV+MVfs7/wcuf8AJt/w9/7G + R/8A0lmr8Yq/B+Ov+RvP0j/6Sj/V/wCib/ybrD/9fKv/AKWwooor48/pMKKKKACiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAr2v/AIJ4/wDJ + 8nwr/wCxjtP/AEOvFK9r/wCCeP8AyfJ8K/8AsY7T/wBDrqwP+8Q9V+Z8txx/yT2O/wCvNX/03I/pbt/+ + PiP8avVRt/8Aj4j/ABq9X9Ox2P8ADaP+X5EMv36KJfv0Uyh8H+rFJJ9z8qWD/VikmOyIk9qCZH5mf8HL + n/Jt/wAPf+xkf/0lmr8Yq/a7/g4t8Ga34/8AgB8P7PQ9F1jWbqPxA80kVhZS3LRJ9mkGWCKccmvyJ/4Z + k+JH/RP/ABt/4Irv/wCN1+F8cUaks2m4xb0j0/uo/wBT/oq5tgaHh9h6VetCMlUq6OST+N92cPRXcf8A + DMnxI/6J/wCNv/BFd/8Axuj/AIZk+JH/AET/AMbf+CK7/wDjdfJfVa38j+5n9G/2/ln/AEE0/wDwOP8A + mcPRXcf8MyfEj/on/jb/AMEV3/8AG6P+GZPiR/0T/wAbf+CK7/8AjdH1Wt/I/uYf2/ln/QTT/wDA4/5n + D0V3H/DMnxI/6J/42/8ABFd//G6P+GZPiR/0T/xt/wCCK7/+N0fVa38j+5h/b+Wf9BNP/wADj/mcPRXc + f8MyfEj/AKJ/42/8EV3/APG6P+GZPiR/0T/xt/4Irv8A+N0fVa38j+5h/b+Wf9BNP/wOP+Zw9Fdx/wAM + yfEj/on/AI2/8EV3/wDG6P8AhmT4kf8ARP8Axt/4Irv/AON0fVa38j+5h/b+Wf8AQTT/APA4/wCZw9Fd + x/wzJ8SP+if+Nv8AwRXf/wAbo/4Zk+JH/RP/ABt/4Irv/wCN0fVa38j+5h/b+Wf9BNP/AMDj/mcPRXcf + 8MyfEj/on/jb/wAEV3/8bo/4Zk+JH/RP/G3/AIIrv/43R9VrfyP7mH9v5Z/0E0//AAOP+Zw9Fdx/wzJ8 + SP8Aon/jb/wRXf8A8bo/4Zk+JH/RP/G3/giu/wD43R9VrfyP7mH9v5Z/0E0//A4/5nD0V3H/AAzJ8SP+ + if8Ajb/wRXf/AMbo/wCGZPiR/wBE/wDG3/giu/8A43R9VrfyP7mH9v5Z/wBBNP8A8Dj/AJnD0V3H/DMn + xI/6J/42/wDBFd//ABuj/hmT4kf9E/8AG3/giu//AI3R9VrfyP7mH9v5Z/0E0/8AwOP+Zw9Fdx/wzJ8S + P+if+Nv/AARXf/xuj/hmT4kf9E/8bf8Agiu//jdH1Wt/I/uYf2/ln/QTT/8AA4/5nD0V3H/DMnxI/wCi + f+Nv/BFd/wDxuj/hmT4kf9E/8bf+CK7/APjdH1Wt/I/uYf2/ln/QTT/8Dj/mcPRXcf8ADMnxI/6J/wCN + v/BFd/8Axuj/AIZk+JH/AET/AMbf+CK7/wDjdH1Wt/I/uYf2/ln/AEE0/wDwOP8AmcPRXcf8MyfEj/on + /jb/AMEV3/8AG6P+GZPiR/0T/wAbf+CK7/8AjdH1Wt/I/uYf2/ln/QTT/wDA4/5nD0V3H/DMnxI/6J/4 + 2/8ABFd//G6P+GZPiR/0T/xt/wCCK7/+N0fVa38j+5h/b+Wf9BNP/wADj/mcPRXcf8MyfEj/AKJ/42/8 + EV3/APG6P+GZPiR/0T/xt/4Irv8A+N0fVa38j+5h/b+Wf9BNP/wOP+Zw9Fdx/wAMyfEj/on/AI2/8EV3 + /wDG6P8AhmT4kf8ARP8Axt/4Irv/AON0fVa38j+5h/b+Wf8AQTT/APA4/wCZw9Fdx/wzJ8SP+if+Nv8A + wRXf/wAbo/4Zk+JH/RP/ABt/4Irv/wCN0fVa38j+5h/b+Wf9BNP/AMDj/mcPRXcf8MyfEj/on/jb/wAE + V3/8bo/4Zk+JH/RP/G3/AIIrv/43R9VrfyP7mH9v5Z/0E0//AAOP+Zw9Fdx/wzJ8SP8Aon/jb/wRXf8A + 8bo/4Zk+JH/RP/G3/giu/wD43R9VrfyP7mH9v5Z/0E0//A4/5nD0V3H/AAzJ8SP+if8Ajb/wRXf/AMbo + /wCGZPiR/wBE/wDG3/giu/8A43R9VrfyP7mH9v5Z/wBBNP8A8Dj/AJnD0V3H/DMnxI/6J/42/wDBFd// + ABuj/hmT4kf9E/8AG3/giu//AI3R9VrfyP7mH9v5Z/0E0/8AwOP+Zw9Fdx/wzJ8SP+if+Nv/AARXf/xu + j/hmT4kf9E/8bf8Agiu//jdH1Wt/I/uYf2/ln/QTT/8AA4/5nD0V3H/DMnxI/wCif+Nv/BFd/wDxuj/h + mT4kf9E/8bf+CK7/APjdH1Wt/I/uYf2/ln/QTT/8Dj/mcPRXcf8ADMnxI/6J/wCNv/BFd/8Axuj/AIZk + +JH/AET/AMbf+CK7/wDjdH1Wt/I/uYf2/ln/AEE0/wDwOP8AmcPRXcf8MyfEj/on/jb/AMEV3/8AG6P+ + GZPiR/0T/wAbf+CK7/8AjdH1Wt/I/uYf2/ln/QTT/wDA4/5nD0V3H/DMnxI/6J/42/8ABFd//G6P+GZP + iR/0T/xt/wCCK7/+N0fVa38j+5h/b+Wf9BNP/wADj/mcPRXcf8MyfEj/AKJ/42/8EV3/APG6P+GZPiR/ + 0T/xt/4Irv8A+N0fVa38j+5h/b+Wf9BNP/wOP+Zw9Fdx/wAMyfEj/on/AI2/8EV3/wDG6P8AhmT4kf8A + RP8Axt/4Irv/AON0fVa38j+5h/b+Wf8AQTT/APA4/wCZw9Fdx/wzJ8SP+if+Nv8AwRXf/wAbo/4Zk+JH + /RP/ABt/4Irv/wCN0fVa38j+5h/b+Wf9BNP/AMDj/mcPRXcf8MyfEj/on/jb/wAEV3/8bo/4Zk+JH/RP + /G3/AIIrv/43R9VrfyP7mH9v5Z/0E0//AAOP+Zw9Fdx/wzJ8SP8Aon/jb/wRXf8A8bo/4Zk+JH/RP/G3 + /giu/wD43R9VrfyP7mH9v5Z/0E0//A4/5nD0V3H/AAzJ8SP+if8Ajb/wRXf/AMbo/wCGZPiR/wBE/wDG + 3/giu/8A43R9VrfyP7mH9v5Z/wBBNP8A8Dj/AJnD17X/AME8f+T5PhX/ANjHaf8Aodcb/wAMw/En/on/ + AI2/8EV3/wDG69f/AGC/gH458N/tm/DO/wBQ8F+LLGztdftZJpp9HuI44gG5LEpwPeurA4at9Yh7r3XR + 9z5jjbPMulkGOjHEQbdGr9uP/PuXmf0XW/8Ax8R/jV6qMHEyH2JHvV6v6WWx/iVH/L8iGX79FEv36KZQ + +D/Vilkj81Cp70yGXair0PPBqXNAGedK+dW9Dnld2Tgjv9am+xn/ACKtZozU8qFyoq/Yz/kUfYz/AJFW + s0Zo5UOyKv2M/wCRR9jP+RVrNGaOVBZFX7Gf8ij7Gf8AIq1mjNHKgsir9jP+RR9jP+RVrNGaOVBZFX7G + f8ij7Gf8irWaM0cqCyKv2M/5FH2M/wCRVrNGaOVBZFX7Gf8AIo+xn/Iq1mjNHKgsir9jP+RR9jP+RVrN + GaOVBZFX7Gf8ij7Gf8irWaM0cqCyKv2M/wCRR9jP+RVrNGaOVBZFX7Gf8ij7Gf8AIq1mjNHKgsir9jP+ + RR9jP+RVrNGaOVBZFX7Gf8ij7Gf8irWaM0cqCyKv2M/5FH2M/wCRVrNGaOVBZFX7Gf8AIo+xn/Iq1mjN + HKgsir9jP+RR9jP+RVrNGaOVBZFX7Gf8ij7Gf8irWaM0cqCyKv2M/wCRR9jP+RVrNGaOVBZFX7Gf8ij7 + Gf8AIq1mjNHKgsir9jP+RR9jP+RVrNGaOVBZFX7Gf8ij7Gf8irWaM0cqCyKv2M/5FH2M/wCRVrNGaOVB + ZFX7Gf8AIo+xn/Iq1mjNHKgsir9jP+RR9jP+RVrNGaOVBZFX7Gf8ij7Gf8irWaM0cqCyKv2M/wCRR9jP + +RVrNGaOVBZFX7Gf8ij7Gf8AIq1mjNHKgsir9jP+RR9jP+RVrNGaOVBZFX7Gf8ij7Gf8irWaM0cqCyKv + 2M/5FH2M/wCRVrNGaOVBZFX7Gf8AIo+xn/Iq1mjNHKgsir9jP+RR9jP+RVrNGaOVBZFX7Gf8ij7Gf8ir + WaM0cqCyKn2Rvb/vkVFLpTTR7WYntnHPXI/H3rQzSY9hTSS2E1crQQkNluNpJFWqbtyaHlEabj0pijGy + sRy/fopruWP3WooKGTH7JCzLy289eaZ9vk/2fyoooAPt8n+z+VH2+T/Z/KiigA+3yf7P5Ufb5P8AZ/Ki + igA+3yf7P5Ufb5P9n8qKKAD7fJ/s/lR9vk/2fyoooAPt8n+z+VH2+T/Z/KiigA+3yf7P5Ufb5P8AZ/Ki + igA+3yf7P5Ufb5P9n8qKKAD7fJ/s/lR9vk/2fyoooAPt8n+z+VH2+T/Z/KiigA+3yf7P5Ufb5P8AZ/Ki + igA+3yf7P5Ufb5P9n8qKKAD7fJ/s/lR9vk/2fyoooAPt8n+z+VH2+T/Z/KiigA+3yf7P5Ufb5P8AZ/Ki + igA+3yf7P5Ufb5P9n8qKKAD7fJ/s/lR9vk/2fyoooAPt8n+z+VH2+T/Z/KiigA+3yf7P5Ufb5P8AZ/Ki + igA+3yf7P5Ufb5P9n8qKKAD7fJ/s/lR9vk/2fyoooAPt8n+z+VH2+T/Z/KiigA+3yf7P5Ufb5P8AZ/Ki + igA+3yf7P5Ufb5P9n8qKKAD7fJ/s/lR9vk/2fyoooAPt8n+z+VH2+T/Z/KiigA+3yf7P5Ufb5P8AZ/Ki + igA+3yf7P5Ufb5P9n8qKKAD7fJ/s/lR9vk/2fyoooAPt8n+z+VH2+T/Z/KiigA+3yf7P5Ufb5P8AZ/Ki + igA+3yf7P5Ufb5P9n8qKKAD7fJ/s/lR9vk/2fyoooAPt8n+z+VH2+T/Z/KiigA+3yf7P5Ufb5P8AZ/Ki + igA+3yf7P5Ufb5P9n8qKKAD7fJ/s/lSpeNJLtYLt+lFFAD4IctJ8zffPeiiigD//2Q== + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/4QAiRXhpZgAATU0AKgAAAAgAAQESAAMAAAABAAEAAAAAAAD/2wBD + AAIBAQIBAQICAgICAgICAwUDAwMDAwYEBAMFBwYHBwcGBwcICQsJCAgKCAcHCg0KCgsMDAwMBwkODw0M + DgsMDAz/2wBDAQICAgMDAwYDAwYMCAcIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM + DAwMDAwMDAwMDAwMDAz/wAARCAJUAlQDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQF + BgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAk + M2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWG + h4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx + 8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQA + AQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5 + OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmq + srO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD9 + 8449w+b5kYk/N2qX7NH/AHVpYOYxT80AR/Zo/wC6tH2aP+6tAnU//Wp3mii4Dfs0f91aPs0f91aXzP8A + ao8z/aouAn2aP+6tH2aP+6tL5n+1R5n+1RcBPs0f91aPs0f91aXzP9qjzP8AaouAn2aP+6tH2aP+6tL5 + n+1R5n+1RcBPs0f91aPs0f8AdWl8z/ao8z/aouAn2aP+6tH2aP8AurS+Z/tUeZ/tUXAT7NH/AHVo+zR/ + 3VpfM/2qPM/2qLgJ9mj/ALq0fZo/7q0vmf7VHmf7VFwE+zR/3Vo+zR/3VpfM/wBqjzP9qi4CfZo/7q0f + Zo/7q0vmf7VHmf7VFwE+zR/3Vo+zR/3VpfM/2qPM/wBqi4CfZo/7q0fZo/7q0vmf7VHmf7VFwE+zR/3V + o+zR/wB1aXzP9qjzP9qi4CfZo/7q0fZo/wC6tL5n+1R5n+1RcBPs0f8AdWj7NH/dWl8z/ao8z/aouAn2 + aP8AurR9mj/urS+Z/tUeZ/tUXAT7NH/dWj7NH/dWl8z/AGqPM/2qLgJ9mj/urR9mj/urS+Z/tUeZ/tUX + AT7NH/dWj7NH/dWl8z/ao8z/AGqLgJ9mj/urR9mj/urS+Z/tUeZ/tUXAT7NH/dWj7NH/AHVpfM/2qPM/ + 2qLgJ9mj/urR9mj/ALq0vmf7VHmf7VFwE+zR/wB1aPs0f91aXzP9qjzP9qi4CfZo/wC6tH2aP+6tL5n+ + 1R5n+1RcBPs0f91aPs0f91aXzP8Aao8z/aouAn2aP+6tH2aP+6tL5n+1R5n+1RcBPs0f91aPs0f91aXz + P9qjzP8AaouAn2aP+6tH2aP+6tL5n+1R5n+1RcBPs0f91aPs0f8AdWl8z/ao8z/aouAn2aP+6tH2aP8A + urS+Z/tUeZ/tUXAT7NH/AHVo+zR/3VpfM/2qPM/2qLgJ9mj/ALq0fZo/7q0vmf7VHmf7VFwE+zR/3Vo+ + zR/3VpfM/wBqjzP9qi4CfZo/7q0fZ4/7q07zlpvnigA+zR5+6tNkhCJuVF3fShJRKTt7ZqagSdymECs3 + zSfMSelFTSHDd6KBj4P9WKS5P7htvWlg/wBWKSQ4SgTPmn/goH/wUB0f/gn/AODfD+ua3oOreILfXb42 + UaWTxq0LCJ3+bcw9K+Wf+ImD4f4/5J34w/7/ANr/APHKk/4OW/8Ak3z4e+v/AAkLnH/btNX40Hk1+U8U + cUY/A4+VChJctl07pH94+AfgHwlxXwnTzfN6U5VXOaupyirJ2W2h+yn/ABEv/D//AKJ34x/7/wBr/wDH + KP8AiJf+H/8A0Tvxj/3/ALX/AOOV+NVFfP8A+vOa/wAy+5H7R/xKd4ff8+an/gyX+Z+yv/ES/wDD/wD6 + J34x/wC/9r/8co/4iX/h/wD9E78Y/wDf+1/+OV+NVFH+vOa/zL7kP/iU7w+/581P/Bkv8z9lf+Il/wCH + /wD0Tvxj/wB/7X/45R/xEv8Aw/8A+id+Mf8Av/a//HK/Gqij/XnNf5l9yD/iU7w+/wCfNT/wZL/M/ZX/ + AIiX/h//ANE78Y/9/wC1/wDjlH/ES/8AD/8A6J34x/7/ANr/APHK/Gqij/XnNf5l9yD/AIlO8Pv+fNT/ + AMGS/wAz9lf+Il/4f/8ARO/GP/f+1/8AjlH/ABEv/D//AKJ34x/7/wBr/wDHK/Gqij/XnNf5l9yD/iU7 + w+/581P/AAZL/M/ZX/iJf+H/AP0Tvxj/AN/7X/45R/xEv/D/AP6J34x/7/2v/wAcr8aqKP8AXnNf5l9y + D/iU7w+/581P/Bkv8z9lf+Il/wCH/wD0Tvxj/wB/7X/45R/xEv8Aw/8A+id+Mf8Av/a//HK/Gqij/XnN + f5l9yD/iU7w+/wCfNT/wZL/M/ZX/AIiX/h//ANE78Y/9/wC1/wDjlH/ES/8AD/8A6J34x/7/ANr/APHK + /Gqij/XnNf5l9yD/AIlO8Pv+fNT/AMGS/wAz9lf+Il/4f/8ARO/GP/f+1/8AjlH/ABEv/D//AKJ34x/7 + /wBr/wDHK/Gqij/XnNf5l9yD/iU7w+/581P/AAZL/M/ZX/iJf+H/AP0Tvxj/AN/7X/45R/xEv/D/AP6J + 34x/7/2v/wAcr8aqKP8AXnNf5l9yD/iU7w+/581P/Bkv8z9lf+Il/wCH/wD0Tvxj/wB/7X/45R/xEv8A + w/8A+id+Mf8Av/a//HK/Gqij/XnNf5l9yD/iU7w+/wCfNT/wZL/M/ZX/AIiX/h//ANE78Y/9/wC1/wDj + lH/ES/8AD/8A6J34x/7/ANr/APHK/Gqij/XnNf5l9yD/AIlO8Pv+fNT/AMGS/wAz9lf+Il/4f/8ARO/G + P/f+1/8AjlH/ABEv/D//AKJ34x/7/wBr/wDHK/Gqij/XnNf5l9yD/iU7w+/581P/AAZL/M/ZX/iJf+H/ + AP0Tvxj/AN/7X/45R/xEv/D/AP6J34x/7/2v/wAcr8aqKP8AXnNf5l9yD/iU7w+/581P/Bkv8z9lf+Il + /wCH/wD0Tvxj/wB/7X/45R/xEv8Aw/8A+id+Mf8Av/a//HK/Gqij/XnNf5l9yD/iU7w+/wCfNT/wZL/M + /ZX/AIiX/h//ANE78Y/9/wC1/wDjlH/ES/8AD/8A6J34x/7/ANr/APHK/Gqij/XnNf5l9yD/AIlO8Pv+ + fNT/AMGS/wAz9lf+Il/4f/8ARO/GP/f+1/8AjlH/ABEv/D//AKJ34x/7/wBr/wDHK/Gqij/XnNf5l9yD + /iU7w+/581P/AAZL/M/ZX/iJf+H/AP0Tvxj/AN/7X/45R/xEv/D/AP6J34x/7/2v/wAcr8aqKP8AXnNf + 5l9yD/iU7w+/581P/Bkv8z9lf+Il/wCH/wD0Tvxj/wB/7X/45R/xEv8Aw/8A+id+Mf8Av/a//HK/Gqij + /XnNf5l9yD/iU7w+/wCfNT/wZL/M/ZX/AIiX/h//ANE78Y/9/wC1/wDjlH/ES/8AD/8A6J34x/7/ANr/ + APHK/Gqij/XnNf5l9yD/AIlO8Pv+fNT/AMGS/wAz9lf+Il/4f/8ARO/GP/f+1/8AjlH/ABEv/D//AKJ3 + 4x/7/wBr/wDHK/Gqij/XnNf5l9yD/iU7w+/581P/AAZL/M/ZX/iJf+H/AP0Tvxj/AN/7X/45R/xEv/D/ + AP6J34x/7/2v/wAcr8aqKP8AXnNf5l9yD/iU7w+/581P/Bkv8z9lf+Il/wCH/wD0Tvxj/wB/7X/45R/x + Ev8Aw/8A+id+Mf8Av/a//HK/Gqij/XnNf5l9yD/iU7w+/wCfNT/wZL/M/ZX/AIiX/h//ANE78Y/9/wC1 + /wDjlH/ES/8AD/8A6J34x/7/ANr/APHK/Gqij/XnNf5l9yD/AIlO8Pv+fNT/AMGS/wAz9lf+Il/4f/8A + RO/GP/f+1/8AjlH/ABEv/D//AKJ34x/7/wBr/wDHK/Gqij/XnNf5l9yD/iU7w+/581P/AAZL/M/ZX/iJ + f+H/AP0Tvxj/AN/7X/45R/xEv/D/AP6J34x/7/2v/wAcr8aqKP8AXnNf5l9yD/iU7w+/581P/Bkv8z9l + f+Il/wCH/wD0Tvxj/wB/7X/45R/xEv8Aw/8A+id+Mf8Av/a//HK/Gqij/XnNf5l9yD/iU7w+/wCfNT/w + ZL/M/ZX/AIiX/h//ANE78Y/9/wC1/wDjlH/ES/8AD/8A6J34x/7/ANr/APHK/Gqij/XnNf5l9yD/AIlO + 8Pv+fNT/AMGS/wAz9lf+Il/4f/8ARO/GP/f+1/8AjlH/ABEv/D//AKJ34x/7/wBr/wDHK/Gqij/XnNf5 + l9yD/iU7w+/581P/AAZL/M/ZX/iJf+H/AP0Tvxj/AN/7X/45R/xEv/D/AP6J34x/7/2v/wAcr8aqKP8A + XnNf5l9yD/iU7w+/581P/Bkv8z9lf+Il/wCH/wD0Tvxj/wB/7X/45R/xEv8Aw/8A+id+Mf8Av/a//HK/ + Gqij/XnNf5l9yD/iU7w+/wCfNT/wZL/M/ZX/AIiX/h//ANE78Y/9/wC1/wDjlH/ES/8AD/8A6J34x/7/ + ANr/APHK/Gqij/XnNf5l9yD/AIlO8Pv+fNT/AMGS/wAz9lf+Il/4f/8ARO/GP/f+1/8AjlH/ABEv/D// + AKJ34x/7/wBr/wDHK/Gqij/XnNf5l9yD/iU7w+/581P/AAZL/M/ZX/iJd+H3/RO/F/8A3/tv/jldL8Fv + +C//AIJ+OHxX8O+D7HwL4qsrrxFex2UU808G2Jnb77YavxFzxXtH/BPo4/ba+F//AGMNrwP96ujBcbZn + OvGEpKza6LufPcWfRf4FwGTYrG4ejPnp05yX7yWjUW117n9L1u37xcdDljV3dxVCz/1sP0NXv4a/bY6q + 5/mNazsiOX79FEv36KYx8H+rFJL9z8qWD/Vikl+5+VBMtj8x/wDg5b/5N8+Hv/YwP/6TTV+M+cGv2Y/4 + OW/+TfPh7/2MD/8ApNNX4znrX4Tx3/yNZei/JH+rX0TP+Tf0f+vlT/0oKKKK+NP6YCiiigAooooAKKKK + ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK + ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAOpr2 + j/gn2cfttfC7/sYbX/0KvFx1r2f/AIJ+f8ntfC7/ALGG1/8AQq7Mv/3mHqvzPkeP/wDknMd/15qf+kM/ + pds/9bD9DV7+GqNn/rYfoavfw1/TUPhP8PX8TI5fv0US/foqgHwf6sUkv3PypYP9WKSX7n5UEy2PzH/4 + OW/+TfPh7/2MD/8ApNNX4znrX7Mf8HLf/Jvnw9/7GB//AEmmr8Zz1r8J47/5GsvRfkj/AFa+iZ/yb+j/ + ANfKn/pQUUUV8af0wFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU + AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU + AFFFFABRRRQAUUUUAFFFFABRRRQADrXs/wDwT8/5Pa+F3/Yw2v8A6FXjA617P/wT8/5Pa+F3/Yw2v/oV + dmX/AO8w9V+Z8jx//wAk5jv+vNT/ANIZ/S7Z/wCth+hq9/DVGz/1sP0NXv4a/pqHwn+Hr+Jkcv36KJfv + 0VQD4P8AVikl+5+VLB/qxSS/c/KgmWx+Y/8Awct/8m+fD3/sYH/9Jpq/Gc9a/Zj/AIOW/wDk3z4e/wDY + wP8A+k01fjOetfhPHf8AyNZei/JH+rX0TP8Ak39H/r5U/wDSgooor40/pgKKKKACiiigAooooAKKKKAC + iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC + iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAHWvZ/8Agn5/ + ye18Lv8AsYbX/wBCrxgda9n/AOCfn/J7Xwu/7GG1/wDQq7Mv/wB5h6r8z5Hj/wD5JzHf9ean/pDP6XbP + /Ww/Q1e/hqjZ/wCth+hq9/DX9NQ+E/w9fxMjl+/RRL9+iqAfB/qxSS/c/Klg/wBWKSX7n5UEy2PzH/4O + W/8Ak3z4e/8AYwP/AOk01fjOetfsx/wct/8AJvnw9/7GB/8A0mmr8Zz1r8J47/5GsvRfkj/Vr6Jn/Jv6 + P/Xyp/6UFFFFfGn9MBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF + ABRRUsJU3C7i6ru+YrVRjd2JnLlVxPLznG35etN8tvSv1g/4J+/8EYfhP+1L+yP4Y8ZeILzxZHq2vwyG + 4azv41SNhJ/CrRN/cr2X/iHA+COP+Q54/wA/9hO3/wDkevsMPwPmNelGrT5bNJ79z+Zc2+ldwdl2OrZf + iY1eelJwlaCteLs7e8fh15belHlt6V+4v/EOB8Ef+g54/wD/AAZ2/wD8j0f8Q4HwR/6Dnj//AMGdv/8A + I9bf8Q/zT+795wf8Tg8D/wAtb/wBf/JH4deW3pR5belfuL/xDgfBH/oOeP8A/wAGdv8A/I9H/EOB8Ef+ + g54//wDBnb//ACPR/wAQ/wA0/u/eH/E4PA/8tb/wBf8AyR+HXlt6UeW3pX7i/wDEOB8Ef+g54/8A/Bnb + /wDyPR/xDgfBH/oOeP8A/wAGdv8A/I9H/EP80/u/f/wA/wCJweB/5a3/AIAv/kj8OKk2/wAq/cF/+DcP + 4JohP9ufEL/wZ23/AMj18/f8FJ/+COnwz/ZD/ZK8QePPDOqeL7rVtLntI0hvr2F7ciW4iibcFgVvuyHq + wrDFcEZjh6Mq9Tl5Yq7s/wDgHq5F9Kjg/NsxoZZhY1eetOMI3ikrydlf3tr7n5d0UUV8cf0sFFFFABRR + RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAAOtez/8E/P+T2vhd/2M + Nr/6FXjA617P/wAE/P8Ak9r4Xf8AYw2v/oVdmX/7zD1X5nyPH/8AyTmO/wCvNT/0hn9Ltn/rYfoavfw1 + Rs/9bD9DV7+Gv6ah8J/h6/iZHL9+iiX79FUA+D/Vikl+5+VLB/qxSS/c/KgmWx+Y/wDwct/8m+fD3/sY + H/8ASaavxnPWv2Y/4OW/+TfPh7/2MD/+k01fjOetfhPHf/I1l6L8kf6tfRM/5N/R/wCvlT/0oKKKK+NP + 6YCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACnLyabTk60dRS2 + P6Hv+CKuG/4J3fDz/r3uP/Rz19ZbcV8mf8EU/wDlHd8Pf+ve5/8AR719aH7wr+ksj/5F1H/CvyP8RvEr + /kq8x/6/1f8A0uQuKMUUV6x8SGKMUUUAGKMUUUAV7lf3TV8Z/wDBeM/8a2vGI7fbNO/9K4a+zLn/AFLV + 8Z/8F5P+UbfjH/r807/0rhryc8/5F1f/AAS/I/QPCf8A5LXK/wDr/S/9Lifz/wBFFFfzaf7YBRRRQAUU + UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQADrXs//AAT8/wCT2vhd + /wBjDa/+hV4wOtez/wDBPz/k9r4Xf9jDa/8AoVdmX/7zD1X5nyPH/wDyTmO/681P/SGf0u2f+th+hq9/ + DVGz/wBbD9DV7+Gv6ah8J/h6/iZHL9+iiX79FUA+D/Vikl+5+VLB/qxSS/c/KgmWx+Y//By3/wAm+fD3 + /sYH/wDSaavxnPWv2Y/4OW/+TfPh7/2MD/8ApNNX4znrX4Tx3/yNZei/JH+rX0TP+Tf0f+vlT/0oKKKK + +NP6YCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACnJ1ptOTrQK + Wx/Q7/wRT/5R3fD3/r3uf/R719aH7wr5L/4Ip/8AKO74e/8AXvc/+j3r60P3hX9JZH/yL6P+Ffkf4jeJ + X/JV5j/1/q/+lyFooor1j4kKKKKACiiigCC5/wBU1fGX/BeT/lG34x/6/NO/9K4a+zLn/UtXxn/wXk/5 + Rt+Mf+vzTv8A0rhryc8/5F1b/BL8j9A8J/8Aktcr/wCv9L/0tH8/9FFFfzaf7YBRRRQAUUUUAFFFFABR + RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQADrXs/wDwT8/5Pa+F3/Yw2v8A6FXj + A617P/wT8/5Pa+F3/Yw2v/oVdmX/AO8w9V+Z8jx//wAk5jv+vNT/ANIZ/S7Z/wCth+hq9/DVGz/1sP0N + Xv4a/pqHwn+Hr+Jkcv36KJfv0VQD4P8AVikl+5+VLB/qxSS/c/KgmWx+Y/8Awct/8m+fD3/sYH/9Jpq/ + Gc9a/Zj/AIOW/wDk3z4e/wDYwP8A+k01fjOetfhPHf8AyNZei/JH+rX0TP8Ak39H/r5U/wDSgooor40/ + pgKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKcnWm05OtApbH9 + Dv8AwRT/AOUd3w9/697n/wBHvX1ofvCvkv8A4Ip/8o7vh7/173P/AKPevrQ/eFf0lkf/ACL6P+Ffkf4j + eJX/ACVeY/8AX+r/AOlyFooor1j4kKKKKACiiigCC5/1TV8Zf8F5P+UbfjH/AK/NO/8ASuGvsy5/1LV8 + Z/8ABeT/AJRt+Mf+vzTv/SuGvJzz/kXVv8EvyP0Dwn/5LXK/+v8AS/8AS0fz/wBFFFfzaf7YBRRRQAUU + UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQADrXs//AAT8/wCT2vhd + /wBjDa/+hV4wOtez/wDBPz/k9r4Xf9jDa/8AoVdmX/7zD1X5nyPH/wDyTmO/681P/SGf0u2f+th+hq9/ + DVGz/wBbD9DV7+Gv6ah8J/h6/iZHL9+iiX79FUA+D/Vikl+5+VLB/qxSS/c/KgmWx+Y//By3/wAm+fD3 + /sYH/wDSaavxnPWv2Y/4OW/+TfPh7/2MD/8ApNNX4znrX4Tx3/yNZei/JH+rX0TP+Tf0f+vlT/0oKKKK + +NP6YCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACnJ1ptOTrQK + Wx/Q7/wRT/5R3fD3/r3uf/R719aH7wr5L/4Ip/8AKO74e/8AXvc/+j3r60P3hX9JZH/yL6P+Ffkf4jeJ + X/JV5j/1/q/+lyFooor1j4kKKKKACiiigCC5/wBU1fGX/BeT/lG34x/6/NO/9K4a+zLn/UtXxn/wXk/5 + Rt+Mf+vzTv8A0rhryc8/5F1b/BL8j9A8J/8Aktcr/wCv9L/0tH8/9FFFfzaf7YBRRRQAUUUUAFFFFABR + RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQADrXs/wDwT8/5Pa+F3/Yw2v8A6FXj + A617P/wT8/5Pa+F3/Yw2v/oVdmX/AO8w9V+Z8jx//wAk5jv+vNT/ANIZ/S7Z/wCth+hq9/DVGz/1sP0N + Xv4a/pqHwn+Hr+Jkcv36KJfv0VQD4P8AVikl+5+VLB/qxSS/c/KgmWx+Y/8Awct/8m+fD3/sYH/9Jpq/ + Gc9a/Zj/AIOW/wDk3z4e/wDYwP8A+k01fjOetfhPHf8AyNZei/JH+rX0TP8Ak39H/r5U/wDSgooor40/ + pgKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKcnWm05OtApbH9 + Dv8AwRT/AOUd3w9/697n/wBHvX1ofvCvkv8A4Ip/8o7vh7/173P/AKPevrQ/eFf0lkf/ACL6P+Ffkf4j + eJX/ACVeY/8AX+r/AOlyFooor1j4kKKKKACiiigCC5/1TV8Zf8F5P+UbfjH/AK/NO/8ASuGvsy5/1LV8 + Z/8ABeT/AJRt+Mf+vzTv/SuGvJzz/kXVv8EvyP0Dwn/5LXK/+v8AS/8AS0fz/wBFFFfzaf7YBRRRQAUU + UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQADrXs//AAT8/wCT2vhd + /wBjDa/+hV4wOtez/wDBPz/k9r4Xf9jDa/8AoVdmX/7zD1X5nyPH/wDyTmO/681P/SGf0u2f+th+hq9/ + DVGz/wBbD9DV7+Gv6ah8J/h6/iZHL9+iiX79FUA+D/Vikl+5+VLB/qxSS/c/KgmWx+Y//By3/wAm+fD3 + /sYH/wDSaavxnPWv2Y/4OW/+TfPh7/2MD/8ApNNX4znrX4Tx3/yNZei/JH+rX0TP+Tf0f+vlT/0oKKKK + +NP6YCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACnJ1ptOTrQK + Wx/Q7/wRT/5R3fD3/r3uf/R719aH7wr5L/4Ip/8AKO74e/8AXvc/+j3r60P3hX9JZH/yL6P+Ffkf4jeJ + X/JV5j/1/q/+lyFooor1j4kKKKKACiiigCC5/wBU1fGX/BeT/lG34x/6/NO/9K4a+zLn/UtXxn/wXk/5 + Rt+Mf+vzTv8A0rhryc8/5F1b/BL8j9A8J/8Aktcr/wCv9L/0tH8/9FFFfzaf7YBRRRQAUUUUAFFFFABR + RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQADrXs/wDwT8/5Pa+F3/Yw2v8A6FXj + A617P/wT8/5Pa+F3/Yw2v/oVdmX/AO8w9V+Z8jx//wAk5jv+vNT/ANIZ/S7Z/wCth+hq9/DVGz/1sP0N + Xv4a/pqHwn+Hr+Jkcv36KJfv0VQD4P8AVikl+5+VLB/qxSS/c/KgmWx+Y/8Awct/8m+fD3/sYH/9Jpq/ + Gc9a/Zj/AIOW/wDk3z4e/wDYwP8A+k01fjOetfhPHf8AyNZei/JH+rX0TP8Ak39H/r5U/wDSgooor40/ + pgKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKcnWm05OtApbH9 + Dv8AwRT/AOUd3w9/697n/wBHvX1ofvCvkv8A4Ip/8o7vh7/173P/AKPevrQ/eFf0lkf/ACL6P+Ffkf4j + eJX/ACVeY/8AX+r/AOlyFooor1j4kKKKKACiiigCC5/1TV8Zf8F5P+UbfjH/AK/NO/8ASuGvsy5/1LV8 + Z/8ABeT/AJRt+Mf+vzTv/SuGvJzz/kXVv8EvyP0Dwn/5LXK/+v8AS/8AS0fz/wBFFFfzaf7YBRRRQAUU + UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQADrXs//AAT8/wCT2vhd + /wBjDa/+hV4wOtez/wDBPz/k9r4Xf9jDa/8AoVdmX/7zD1X5nyPH/wDyTmO/681P/SGf0u2f+th+hq9/ + DVGz/wBbD9DV7+Gv6ah8J/h6/iZHL9+iiX79FUA+D/Vikl+5+VLB/qxSS/c/KgmWx+Y//By3/wAm+fD3 + /sYH/wDSaavxnPWv2Y/4OW/+TfPh7/2MD/8ApNNX4znrX4Tx3/yNZei/JH+rX0TP+Tf0f+vlT/0oKKKK + +NP6YCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACnJ1ptOTrQK + Wx/Q7/wRT/5R3fD3/r3uf/R719aH7wr5L/4Ip/8AKO74e/8AXvc/+j3r60P3hX9JZH/yL6P+Ffkf4jeJ + X/JV5j/1/q/+lyFooor1j4kKKKKACiiigCC5/wBU1fGX/BeT/lG34x/6/NO/9K4a+zLn/UtXxn/wXk/5 + Rt+Mf+vzTv8A0rhryc8/5F1b/BL8j9A8J/8Aktcr/wCv9L/0tH8/9FFFfzaf7YBRRRQAUUUUAFFFFABR + RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQADrXs/wDwT8/5Pa+F3/Yw2v8A6FXj + A617P/wT8/5Pa+F3/Yw2v/oVdmX/AO8w9V+Z8jx//wAk5jv+vNT/ANIZ/S7Z/wCth+hq9/DVGz/1sP0N + Xv4a/pqHwn+Hr+Jkcv36KJfv0VQD4P8AVikl+5+VLB/qxSS/c/KgmWx+Y/8Awct/8m+fD3/sYH/9Jpq/ + Gc9a/Zj/AIOW/wDk3z4e/wDYwP8A+k01fjOetfhPHf8AyNZei/JH+rX0TP8Ak39H/r5U/wDSgooor40/ + pgKKKKACiiigAooooAKKKKACiiigAooooAKXHP8AhSEYqaGFppFjjQySN0VaPIUpJLmZCRhqAMmtDVtD + uvD93Jb3UMlpdRsYpIJvlliYHoyn5l9PmAqh1P8A9aqlFp2aMMPiIVo89J3T6/8ABEoooqToCiiigAoo + ooAKKKKACnJ1ptOTrQKWx/Q7/wAEU/8AlHd8Pf8Ar3uf/R719aH7wr5L/wCCKf8Ayju+Hv8A173P/o96 + +tD94V/SWR/8i+j/AIV+R/iN4lf8lXmP/X+r/wClyFooor1j4kKKKKACiiigCC5/1TV8Zf8ABeT/AJRt + +Mf+vzTv/SuGvsy5/wBS1fGf/BeT/lG34x/6/NO/9K4a8nPP+RdW/wAEvyP0Dwn/AOS1yv8A6/0v/S0f + z/0UUV/Np/tgFFFFABRRRQAUUUUAFFFHSgAxzRU8Vs07bV252luW7Cn29g06ZXy2U7vl3ru4Xcf0qoxb + MalaEF7zsV9menpmmkYrU1rw9faBqE1re2s1rdW6JJLFKNjxqdrLlf8Agf5Vm+1Eotbk0K8aseeDTXk7 + ryG0UUVJ0BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAAOtez/8E/P+T2vhd/2MNr/6FXjA617P/wAE/P8A + k9r4Xf8AYw2v/oVdmX/7zD1X5nyPH/8AyTmO/wCvNT/0hn9Ltn/rYfoavfw1Rs/9bD9DV7+Gv6ah8J/h + 6/iZHL9+iiX79FUA+D/Vikl+5+VLB/qxSS/c/KgmWx+Y/wDwct/8m+fD3/sYH/8ASaavxnPWv2Y/4OW/ + +TfPh7/2MD/+k01fjOetfhPHf/I1l6L8kf6tfRM/5N/R/wCvlT/0oKKKK+NP6YCiiigAooooAKKKKACi + iigAooooAKKKKACr2nSMl/CXwqbvm37un/AfmqjUlvzMK1o/GjmxkeahNeT/ACP2k/4Kkf8ABJxf2j/A + /wDwsD4e6bBaeOrS0R7y0hRf+Khi2pnd0xOuMDP3l9W6fjTrWj3WiXLw3lrcWc8TPHNDOPLlhZPldSvs + 1f1R6FH5/hyxGN37iL2/gr4C/wCCuf8AwSYT9o/Rb74heALOGz8d2UeLyyijXbr8fX2/fD/x7/er9c4n + 4T9vD67hV71ldd9Onn+Z/nF4B/SEqZNiVw7xDO+GbtTm96bvpGX9zs/s+m34kBSR3pK0NY0u40a7kt7y + 3ms7i3kaGeCYeXNDInyspX/Zb0qkIzjj61+RTg4uzP8AR3D4qnXh7WnK8dGmuqGUUUVmdIUUUUAFFFFA + BTk602nJ1oFLY/od/wCCKf8Ayju+Hv8A173P/o96+tD94V8l/wDBFP8A5R3fD3/r3uf/AEe9fWh+8K/p + LI/+RfR/wr8j/EbxK/5KvMf+v9X/ANLkLRRRXrHxIUUUUAFFFFAEFz/qmr4y/wCC8n/KNvxj/wBfmnf+ + lcNfZlz/AKlq+M/+C8n/ACjb8Y/9fmnf+lcNeTnn/Iurf4JfkfoHhP8A8lrlf/X+l/6Wj+f+iiiv5tP9 + sAooooAKKKKACiigDNAB0qxFbGd9q7ehPzP6UR25mfapjBwT8z+lSCJtmWUMrArtV13r8uf++auMbnPV + rqnFuTsNNuwj3N8ysTHhXXcrf7X+zX6d/wDBIr/gkTL4su7D4mfEzT91jD++0XR5v+X7+5cXCt/yz/u0 + /wD4JCf8EiJPGF5pvxO+Jljs0pcT6Jo8nH25eq3Fwrf8s/7seK/XixsV09Y4o4tsKL8u37iLX6jwlwle + 2Mxi0tou/mz+BfpDfSHcnU4a4aqaaxqVU/vjB/nL7j+dH/grDF5H/BQb4p20e2GG31VGEY6DFvCvFfNt + fS3/AAVt/wCUi/xa/wCwig+n7qCvmntX57nEUsZUS/mf5n9keGWvCeXf9eKX/pEQooorzT7oKKKKACii + igAooooAKKKKACiiigAooooAB1r2f/gn5/ye18Lv+xhtf/Qq8YHWvZ/+Cfn/ACe18Lv+xhtf/Qq7Mv8A + 95h6r8z5Hj//AJJzHf8AXmp/6Qz+l2z/ANbD9DV7+GqNn/rYfoavfw1/TUPhP8PX8TI5fv0US/foqgHw + f6sUkv3PypYP9WKSX7n5UEy2PzH/AODlv/k3z4e/9jA//pNNX4znrX7Mf8HLf/Jvnw9/7GB//SaavxnP + Wvwnjv8A5GsvRfkj/Vr6Jn/Jv6P/AF8qf+lBRRRXxp/TAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVJb + f60fWo6ktv8AWD61tR/iIwxX8Gfo/wAj+rbwxxoVj/1xi/8AQK0ry3823Zcb89qzfDH/ACArD/rjF/6D + W1X9PU/gXovyP8HK+lWVu7/M/OL/AIK6f8El4/2jNEvPiH8PbGOy8dWcebyyhjULr8fX/Z/fj3+97tX4 + s6tpFxol1Jb3lvPb3Nu5jmglGyWJl+VlK+zV/V3dw+dAy7d2exr86P8Agrr/AMEloP2iNEvfiB8PbGG0 + 8d2ceLywjjjVfEEecn+6PP8A7ucbvZq/P+LOE1iE8ZhF73Vd15ef5+p/X/0e/pCzyapDhziKpfDvSnN6 + +zfRS/udE/s+m34mGP3ppHFaWq6XdaTeTQ3lvJbXVq7QzQzfu5IWX5XUr/stWeF3H9a/H503F2loz/SP + D4qFaKnTd01dW2t6jaKKKzOgKKKKACnJ1ptOTrQKWx/Q7/wRT/5R3fD3/r3uf/R719aH7wr5L/4Ip/8A + KO74e/8AXvc/+j3r60P3hX9JZH/yL6P+Ffkf4jeJX/JV5j/1/q/+lyFooor1j4kKKKKACiiigCC5/wBU + 1fGX/BeT/lG34x/6/NO/9K4a+zLn/UtXxn/wXk/5Rt+Mf+vzTv8A0rhryc8/5F1b/BL8j9A8J/8Aktcr + /wCv9L/0tH8/9FFFfzaf7YBRRRQAUUUUAAGTVi2g+0vgbPulvmbbwKW1ga4k2jb0LfMdvSnQWRmCnasi + sSvyyLlP9pv9n3q4xuznrV4wTcnYVYW2/d3I25cK67l+X/0Gv08/4JDf8EhZPGt3p/xN+J2mlNGUiTRt + HkGPty/eW4nRufL/ALqdT/u8Un/BIT/gj/N4y1PT/id8TbCRNKXE2jaNLwL5e09wrf8ALL+7H/F/u1+v + On6X9gEMcMccccXyhAPlRf8AZFfqXCfCV7YzFrTov1Z/Av0iPpDObqcNcNVNtKlVP74wf5teiDTtP/s+ + GGKOKNI4/kVF+6i/7NaJX93+FOC4pD/qq/UtErI/hJtt3Z/OH/wVt/5SMfFr/sJJ/wCioK+aui/WvpX/ + AIK3f8pGPi1/2Ek/9FQV81H7or+bM4/3yp/il+Z/tn4X/wDJJZd/14pf+m4iUUUV5Z94FFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAA617P/wT8/5Pa+F3/Yw2v/oVeMDrXs//AAT8/wCT2vhd/wBjDa/+hV2Zf/vM + PVfmfI8f/wDJOY7/AK81P/SGf0u2f+th+hq9/DVGz/1sP0NXv4a/pqHwn+Hr+Jkcv36KJfv0VQD4P9WK + SX7n5UsH+rFJL9z8qCZbH5j/APBy3/yb58Pf+xgf/wBJpq/Gc9a/Zj/g5b/5N8+Hv/YwP/6TTV+M561+ + E8d/8jWXovyR/q19Ez/k39H/AK+VP/Sgooor40/pgKKKKACiiigAooooAKKKKACiiigAooooAKktv9YP + rUdSW3+sH1raj/ERz4r+BP0f5H9W3hj/AJAVh/1xi/8AQa2qxfDH/ICsP+uMX/oNbVf09R+Bei/I/wAH + cR/Fl6sTbxVa+i8y2Zdu/dwVNWqK0MT84f8Agrh/wSNt/wBorRdS+IXgKxWH4gWib7mzhCxrrqLwHbGF + 89U+6eK/F3U9FutJvrqzvLeS0udPkaKeCUeXNCyttdWz6NX9W95CZ7ZlHVuOlfnL/wAFav8AgkZD+0Ro + 198RPh/pq2/j60QPeWUYULrie68L5w/Df7tX53xZwosQpY3Cr3uq7+nn+f5/2R9Hn6QksmnDhziOpfDy + 0p1H/wAu9klJ/wAnZ/Z9NvxQCU3HNaet6VdaJqd1Y3VrPa3enyNFcwP9+3ZflZW/4FWcDX4/UpuDs0f6 + QYfE060FOm7p2aa631G0UUVmdAU5OtNpydaBS2P6Hf8Agin/AMo7vh7/ANe9z/6PevrQ/eFfJf8AwRT/ + AOUd3w9/697n/wBHvX1ofvCv6SyP/kX0f8K/I/xG8Sv+SrzH/r/V/wDS5C0UUV6x8SFFFFABRRRQBBc/ + 6pq+Mv8AgvJ/yjb8Y/8AX5p3/pXDX2Zc/wCpavjP/gvJ/wAo2/GP/X5p3/pXDXk55/yLq3+CX5H6B4T/ + APJa5X/1/pf+lo/n/ooor+bT/bAKKKKADHNOVMn9KD0yenrU0NpJNKu1Tyf8+3+FUlcznUjCLlN29e39 + dR1rA0su3y3kbDLtHX7tfp5/wSJ/4JAS+ObnT/id8TbCSPSc+ZpOjyjjUF/hnuFb/lmP4U/i7/LUP/BI + b/gkPceM77S/ib8TtLkt9HjcS6Po0v8Ay9r2luP9n+7/AHu9fr/Y6atiLeFY40jhyEVR8qD+HFfqfCXC + bdsZjFpb3V382fwF9Ij6Q3O58M8M1NdVVqJ/fGL/ADa9EFhpa2bwpCsccMOFKgfKi7cLtFaezml28Utf + qSikrI/hFybd2Bpp/wBVTqaf9VTEfzh/8Fbv+UjHxa/7CSf+ioK+aj90V9K/8Fbv+UjHxa/7CSf+ioK+ + aj90V/Necf75U/xS/M/208L/APkksu/68Uf/AE3ESiiivLPvAooooAKKKKACiiigAooooAKKKKACiiig + AHWvZ/8Agn5/ye18Lv8AsYbX/wBCrxgda9n/AOCfn/J7Xwu/7GG1/wDQq7Mv/wB5h6r8z5Hj/wD5JzHf + 9ean/pDP6XbP/Ww/Q1e/hqjZ/wCth+hq9/DX9NQ+E/w9fxMjl+/RRL9+iqAfB/qxSS/c/Klg/wBWKSX7 + n5UEy2PzH/4OW/8Ak3z4e/8AYwP/AOk01fjOetfsx/wct/8AJvnw9/7GB/8A0mmr8Zz1r8J47/5GsvRf + kj/Vr6Jn/Jv6P/Xyp/6UFFFFfGn9MBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABUlt/rB9ajqS2/1g+tb + Uf4iOfFfwJ+j/I/q28Mf8gKw/wCuMX/oNbVYvhj/AJAVh/1xi/8AQa2q/p6j/Dj6L8j/AAdxH8WXqwoo + orQxG7Kr3kPnQsu3cDjirVGOKLAfm5/wV2/4JMf8NJaTe/ET4d2MNn48s0zd2UbDytdhX8VVJ16j+97t + 0/F/U9GuNJvLqzu7We1urGTy7mCUbJYZF+VlZTz97r6V/V1eQNPaso/ir85P+Ct3/BI2D9onSL/4ifDv + T1tPHdvGHu7OEKkeuJ79FEy/X5v96vzrizhNV08Zhfi6rv6efl1/P+yPo9fSEqZPKnw3xHO+HbtTqN/A + +kZf3Oz+zftt+KPl/wCfSmgZNaOtaNc6Pf3VpdWtxZ3VhJ5dzBL/AK6GRflZW7fe6+lUAuD/AEr8glTc + XaR/o/h8TCtBVKbvF2aa1vfUbTk602nJ1rM6JbH9Dv8AwRT/AOUd3w9/697n/wBHvX1ofvCvkv8A4Ip/ + 8o7vh7/173P/AKPevrQ/eFf0lkf/ACL6P+Ffkf4jeJX/ACVeY/8AX+r/AOlyFooor1j4kKKKKACiiigC + C5/1TV8Zf8F5P+UbfjH/AK/NO/8ASuGvsy5/1LV8Z/8ABeT/AJRt+Mf+vzTv/SuGvJzz/kXVv8EvyP0D + wn/5LXK/+v8AS/8AS0fz/wBFFFfzaf7YB3pypuNKF5yans4W8+PKlmdvmX1FNa6IznUUY80iOOJo3XKf + eP3Tziv03/4JE/8ABIObxxqmm/FD4naZcW2h27rPo+kTj5r75T++n7eV/d/vd6P+CQH/AASIuPG2o6f8 + SfidpckOiW8gn0XRrkf8f392eZeuz+7/AHv92v2DsNNXTwkVvGkUMP3VA+VF9q/VOEuEb2xuMWnRP82f + wL9Ij6RMn7Thrhmp3jVqp/fCDX4vpsgsNOWzhjjWOOKKH5ERB8ir/DWls5p2KK/UoxSVkfwdJtu7Ciii + mIDTT/qqdTT/AKqgD+cP/grd/wApGPi1/wBhJP8A0VBXzUfuivpX/grd/wApGPi1/wBhJP8A0VBXzUfu + iv5rzj/fKn+KX5n+2nhf/wAkll3/AF4o/wDpuIlFFFeWfeBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAAO + tez/APBPz/k9r4Xf9jDa/wDoVeMDrXs//BPz/k9r4Xf9jDa/+hV2Zf8A7zD1X5nyPH//ACTmO/681P8A + 0hn9Ltn/AK2H6Gr38NUbP/Ww/Q1e/hr+mofCf4ev4mRy/fool+/RVAPg/wBWKSX7n5UsH+rFJL9z8qCZ + bH5j/wDBy3/yb58Pf+xgf/0mmr8Zz1r9mP8Ag5b/AOTfPh7/ANjA/wD6TTV+M561+E8d/wDI1l6L8kf6 + tfRM/wCTf0f+vlT/ANKCiiivjT+mAooooAKKKKACiiigAooooAKKKKACiiigAqS2/wBYPrUdSW3+sH1r + aj/ERz4r+BP0f5H9W3hj/kBWH/XGL/0GtqsXwx/yArD/AK4xf+g1tV/T1H+HH0X5H+DuI/iy9WFFFFaG + IUUUUAIRmoLuHfbMqru3fpViigD82/8Agrd/wSQg/aD0S8+Ivw+sY7Xx7Zx7ryzi2Rpri+/RRMPyb3av + xg1rSLjRtRmsbu1ks7qzcx3NvKMSwyL8rBv+BflX9XFzb+fbsv3s9q/OP/grj/wSMh/aE0m8+IXw5sIb + fx5aorXlmhWOPXF9+iiZfyb/AHq/O+LeE1iL4zC/F1XfzXn+Z/ZP0efpCSyicOHOI53w70p1G/4e1oy/ + udn9nrpt+KYXNKnWtDUtLudJvrqzubWa3urF/KuYZRsaB1+Vs/8AAqoKm7p9a/H5QcXaWh/o/QxEK1NV + Kbumrq2z7an9Dv8AwRT/AOUdvw9/697n/wBHtX1pjmvkv/gin/yjt+Hv/Xvcf+j2r60r+jsj/wCRfR/w + R/I/xN8Sv+SrzL/r/V/9LYUUUV6x8SFFFFABRRRQBBc/6pq+Mv8AgvH/AMo2/GP/AF+ad/6Vw19mXP8A + qWr4z/4Lxn/jW34y/wCvzTv/AErhryc8/wCRdW/wS/I/QPCf/ktcr/6/0v8A0tH4AKMtSiPNBXnr71PH + EyTLuU/Nxt9q/m+19j/ayVRRV2/+GEghZZBhd2f4a/TT/gkL/wAEhrjxrqem/Ez4naXJa6Dbssuj6NOP + m1H+7cTf9Mh/Cn8XcUv/AASC/wCCRNz471HTfiZ8TNLkt9FtGWbRdHnB3X47XEy/88l/hQ/fP+zX7BWO + mrYbIo4wscPCLj5Y1/2a/UuEOEW2sZjFpbRP82fwN9Ij6RTbqcM8MVO8atWL++EGvxfyQyy0hbRYYo1j + SKE4VMfKihfl2/T/ADitYJilA4/+tS1+pxSSsj+DNW7sKKKKYBRRRQAGmn/VU6mn/VUAfzh/8Fbv+UjH + xa/7CSf+ioK+aj90V9K/8Fbv+UjHxa/7CSf+ioK+aj90V/Necf75U/xS/M/208L/APkksu/68Uf/AE3E + SiiivLPvAooooAKKKKACiiigAooooAKKKKACiiigAHWvZ/8Agn5/ye18Lv8AsYbX/wBCrxgda9n/AOCf + n/J7Xwu/7GG1/wDQq7Mv/wB5h6r8z5Hj/wD5JzHf9ean/pDP6XbP/Ww/Q1e/hqjZ/wCth+hq9/DX9NQ+ + E/w9fxMjl+/RRL9+iqAfB/qxSS/c/Klg/wBWKSX7n5UEy2PzH/4OW/8Ak3z4e/8AYwP/AOk01fjOetfs + x/wct/8AJvnw9/7GB/8A0mmr8Zz1r8J47/5GsvRfkj/Vr6Jn/Jv6P/Xyp/6UFFFFfGn9MBRRRQAUUUUA + FFFFABRRRQAUUUUAFFFFABUlt/rB9ajqS2/1g+tbUf4iOfFfwJ+j/I/q28Mf8gKw/wCuMX/oNbVYvhj/ + AJAVh/1xi/8AQa2q/p6j/Dj6L8j/AAdxH8WXqwooorQxCiiigAooooAbtqC4h32jKvzbvWrNHagD83f+ + Cuf/AASStv2idMvviL8PLCG08dWaFr2zh2xprq9z2UTZ/wC+/dq/F3UNHuLC+uLO4tZrO6sXaK5gl+SS + Bl+V1b6PX9XlxEWhZR8xb1r85P8Agrp/wSTh/aB0y/8AiN8ObOK18dWMZN9YpsSLXUH3uBhfO9+M+zV+ + d8XcKrEf7ZhF73Vd/Tz/AK9f7J+j39IaeUyhw3xHUvh3ZU6j1cHpaMv7nRP7Oz029t/4Isnb/wAE7Ph7 + /wBcbg/+R2r61DcV8mf8EabW40r/AIJ+eBbW8t7qzubNLmKS3uVaKaFxO4ZGU9xX1ltyK+wyW6wFFSVv + dS+5H80eItSFTijMKlN3TrVGn3Tm7P7h1FA4FFeofGhRRRQAUUUE4oAguuImr4w/4Lw/vP8Agmz40Ppe + ab/6WQ19oSjzVr4x/wCC7H/KN3xioTzN17pile7f6ZDXk55/yLqy/uS/I++8KZJcZ5XL/p/S/CcT8B4I + Gadfl8zdztxztr9L/wDgkN/wSIm+Iup6f8SvifpMkOh25Euj6LcHD6j/AHbiZc/6ofwo2d/ptpf+CQ3/ + AASCufiHf6b8Sfidpdxb6DbSLLo+jS/ev9v3ZZu3l/3UbO7v8tfsPp9gtnFDHDHHDHH8qonCqoXC18Dw + lwndLGYxafZT6+bP60+kV9Ij+Jwxw1U11jVqJ7d4Qa/F/JCWOl+RHCiRxLHD91F+7H8vG0VqBMen5UBc + D/61Or9TjFJJLofwbq3dhRRRTAKKKKACiiigANNP+qp1NP8AqqAP5w/+Ct3/ACkY+LX/AGEk/wDRUFfN + OeK+lv8Agrcf+NjHxa/7CKn/AMhQV801/Necf75U/wAUvzP9tPC//kkst/68Uf8A03EKKKK8s+8Ciiig + AooooAKKKKACiiigAooooAKKKKAAda9n/wCCfn/J7Xwu/wCxhtf/AEKvGB1r2f8A4J+f8ntfC7/sYbX/ + ANCrsy//AHmHqvzPkeP/APknMd/15qf+kM/pds/9bD9DV7+GqNn/AK2H6Gr38Nf01D4T/D1/EyOX79FE + v36KoB8H+rFJL9z8qWD/AFYpJfuflQTLY/Mf/g5b/wCTfPh7/wBjA/8A6TTV+M561+zH/By3/wAm+fD3 + /sYH/wDSaavxnPWvwnjv/kay9F+SP9Wvomf8m/o/9fKn/pQUUUV8af0wFFFFABRRRQAUUUUAFFFFABRR + RQAUUUUAFSW3+sX61HU9om+bPopataPxo58V/Bn6P8j+rPwycaFYf9cIv/Qa2t3Ncd8K/GOl+O/h7o+r + aTfQ6hpuoWcUtvNE4dZV2/w11ccwcV/TtGUZUouO1l+SP8H8ZCdPETp1FZptNdb31uuhNRRRWxzhRRRQ + AUUUUAFFFFADdnNV7uPfbsu7PTnFWqMUAZOnWENjCY4YY4VJLEJtHzH/ANmrV25NLiiiySsgbbd2FFFF + ABRRRQAUUUUANZcCuF+LPwg8P/Gzws2g+ItPj1TTjcw3M1rL/q5XiYOhf/Z3oPyrvKbsqZQjKPLJXRpR + rTpVI1aTcZRd01o0+6M+w02PTraGOOFIViXYqr91Qf8ACtARYp2KKaSSsiJSbd2FFFFMQUUUUAFFFFAB + RRRQA3dzTWfcjUM6ovPFVb6/is7OSaaRY41UuzscBV7mpk7LUI3btE/nN/4K3Nn/AIKLfFr/ALCQX/yF + DXzWRivoD/gpn4t0zx9+3d8TtZ0e8ttQ0y81UiCeJ8rL5caI+P8AgQrwA9fav5tzdp4ypy/zP8z/AG38 + NKcqfCuXQmrSVCkmno01CKd10Eoooryz7kKKKKACiiigAooooAKKKKACiiigAooooAB1r2f/AIJ+f8nt + fC7/ALGG1/8AQq8YHWvZ/wDgn5/ye18Lv+xhtf8A0KuzL/8AeYeq/M+R4/8A+Scx3/Xmp/6Qz+l2z/1s + P0NXv4ao2f8ArYfoavfw1/TUPhP8PX8TI5fv0US/foqgHwf6sUkv3PypYP8AVikl+5+VBMtj8x/+Dlv/ + AJN8+Hv/AGMD/wDpNNX4znrX7Mf8HLf/ACb58Pf+xgf/ANJpq/Gc9a/CeO/+RrL0X5I/1a+iZ/yb+j/1 + 8qf+lBRRRXxp/TAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVYgKxSjzBuXksv97/AGar0u7mhOxMopqz + PvT/AIJD/wDBUl/2UPF6+B/GF5J/wgGtTBo5HkbboVwW7c48g/xV+4eka1ba3aQ3VrcJcW1xGJI2jOUl + U/MrD61/KlaNsmyzRx7Mt+9TzEPpX6b/APBFX/gqQvw+uNM+EHxA1DZpNwNuh6ldz/LYSH/l0kZv+Wf9 + 3+79zFfp3B3FCp2wOKfu7Rf6M/g/6S3gIq6nxTw/TftEr1YJfElvNJdV9pLda7rX9kS2KQsQagj1COb7 + rLn0zU/v0r9Yi7n8AjqKKKoAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK + KACiiigBu7FBlwucUjHC9KgnnWOBm3bf9rPFHoIjvLlRA3zLuyBnPRq/LH/gtF/wVKi0PQ9Q+Ffw51hf + tkrG08Q6lbSbZLZSvzW8ffLD70g+X+HdmvSv+Cxf/BUSH9mjwjefD/wTdrJ481SIR3FxEfM/sWF/4iBx + 5rL93PevxN1bVJNXvZrq6kkubq4w0k7n5nOF3bv96vzXjLihU4PA4Z6v4munkf2j9G3wHeZVIcU59T/d + RadKDXxtW95p/ZXRdXq9N23cyzlsbVcL8zZf/SPmqiTxR/nmivyOUm9z/RqjRjBWQUUUVJsFFFFABRRR + QAUUUUAFFFFABRRRQAUUUUAA617P/wAE/P8Ak9r4Xf8AYw2v/oVeMDrXs/8AwT8/5Pa+F3/Yw2v/AKFX + Zl/+8w9V+Z8jx/8A8k5jv+vNT/0hn9Ltn/rYfoavfw1Rs/8AWw/Q1e/hr+mofCf4ev4mRy/fool+/RVA + Pg/1YpJfuflSwf6sUkv3PyoJlsfmP/wct/8AJvnw9/7GB/8A0mmr8Zz1r9mP+Dlv/k3z4e/9jA//AKTT + V+M561+E8d/8jWXovyR/q19Ez/k39H/r5U/9KCiiivjT+mAooooAKKKKACiiigAooooAKKKKACiiigAo + oooAUHAq7pdwbS+jkX+D0HK8fw/7X93/AGvTrVGnR4L/AHiv49KuEmndGNalGcHGWzVj9iP+CL//AAVL + j+INppfwn+IOrSf8JHp6GDQ9Sndv+JtCqnbDIzf8tUT7u/7/APvbd36hJeRzj5Wr+UbSNXuNE1O3vrOa + S3vLN1nt5o38uSFhyrBv7yn5x/kV+5f/AASN/wCCm1n+1r4Hj8J+Kb+FfiDoUCgycxprsarnz4/l/wBZ + /fT738W3bX7BwfxQq8FgsU7SWkX38vU/zZ+kj4FrJ6s+Jcih+4m71IJfA39pJfZfVdH5bfehfApc4HNQ + Jcq44YH0qbHy8V+i+h/HVx1FA6UUDCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii + igApryeX1p1V7uRY7d2kO1VHzNQAs1xhW9q+OP8AgqV/wUY0z9iX4Wy2WjzWtx4+163I0u3b94tqo+X7 + RIvovb+/2rsv+Cg37eHhv9hT4NSa5qQW+8Qakr2miaSzMfts23+LHSNfvu5/h6fNsWvwA+OHxz8RftDf + EDU/FPi6+/tTWtXkMskzcCEhs7I1/gVV+VUHOK+H4u4mWCp/VsO/3kvwXn5vof019H7wOrcVYyGc5pBr + A05Lf/l5JfZX91dX8t72o+NfH+oePta1XWtVuvtOpas5ku7q4ZnmuCzIzJ/3383bYoKjA2qvK5yOaA2B + 90fWkr8Tq1ZVJc0nqf6jZdl9LCUlRoq0Voktkl0Ciiisz0AooooAKKKKACiiigAooooAKKKKACiiigAo + oooAB1r2f/gn5/ye18Lv+xhtf/Qq8YHWvZ/+Cfn/ACe18Lv+xhtf/Qq7Mv8A95h6r8z5Hj//AJJzHf8A + Xmp/6Qz+l2z/ANbD9DV7+GqNn/rYfoavfw1/TUPhP8PX8TI5fv0US/foqgHwf6sUkv3PypYP9WKSX7n5 + UEy2PzH/AODlv/k3z4e/9jA//pNNX4znrX7Mf8HLf/Jvnw9/7GB//SaavxnPWvwnjv8A5GsvRfkj/Vr6 + Jn/Jv6P/AF8qf+lBRRRXxp/TAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAEqvsfkA9etdL8 + OviBrHw18a6XrWiapcabqGiyrPZXEEnly2sg/iUfzT+P0rlt1Kr7T90VrSqOEuZbnBjsDRxVGVCslKMk + 009U091Y/oU/4Jm/8FDdH/bc+GNu1xNBY+NNFVYtY0/OJHbbxOi945O/91utfW6yiT1r+XX4AftA+Iv2 + ZfitpPi3wtfNa6po7/uyAwS6jP3oHx99T/tV/Qj+wv8AtteF/wBtz4P2niTQriOHUIQsOp2BfM2nzfxK + w/un+Gv23hPiaONp/V6z/eL/AMm815+R/lh4/eB9bhDG/wBqZZFvBVZPz9nJ/Zfk/sv5evv6HIpajW4U + tt7ipK+2P5tCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiimySiJdzcCgBss4hQs3 + 3V6mvF/2tv2rPCv7I3wa1jxl4lvnWHTz5cFrEP319MzfJDGp6s3r0C/M3ydOp+OPxs8P/Ab4bav4p8TX + q6fpOjwtcTSujY4/hUfxs3ZBzX8/3/BQr9vrxN+3L8Vp9QumOneFbLcmj6T5mRbQ7/8AWsOnmyfxf989 + a+Y4m4hp5dRtHWpLZdvNn7d4JeD+L42zRSqpxwdNr2k+/Xkj/ea67Javpfkf2v8A9rrxL+2V8X9Q8V+J + rjDTSBLKyT95FYQ/wwpn0/iP8XtXjwbBpd/9OKbX4NisVOvUdWo7ybu2f615JkeDynB08BgYKFKCSjFb + JIKKKK5z1wooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAAda9n/4J+f8AJ7Xwu/7GG1/9Crxg + da9n/wCCfn/J7Xwu/wCxhtf/AEKuzL/95h6r8z5Hj/8A5JzHf9ean/pDP6XbP/Ww/Q1e/hqjZ/62H6Gr + 38Nf01D4T/D1/EyOX79FEv36KoB8H+rFJL9z8qWD/Vikl+5+VBMtj8x/+Dlv/k3z4e/9jA//AKTTV+M5 + 61+zH/By3/yb58Pf+xgf/wBJpq/Gc9a/CeO/+RrL0X5I/wBWvomf8m/o/wDXyp/6UFFFFfGn9MBRRRQA + UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAE0KrKxDNsUqR0/SvZv2K/2yfEH7Gfxu03xToTb + bMHydS01ZPk1SHujbur/AN3/AGq8U3fLinwPmVfm8vn7392ujDYmdCoqlN2a2PC4h4fwecYGrgMbBTp1 + ItNNXvf9e3Y/p5/Zu/aU8M/tO/CXSfGXhe6+2WGpIC6AfvLSX+KKRfvBh93G3OK9T84Piv51P+CcX/BQ + /Wv2J/jDFdt5114T1plh13T+1wuMfao/m+WZfp8y1++/wl+KmifGTwRpfiXw/qNpqmj6zALy0uLeQSLN + GcdMf3e/+1X7zw3xDDMqFpaVI7r9T/JHxm8I8bwRmnJZywtRt05v/wBJl/eX4rX07gHNBOBUaXCyfdqQ + jNfTn40FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRTXbYtADTOFHNYfjTxnpfgnwvfatqt5DY6 + ZYwNNczyn5I0Ay2TVnVtShsbGaSeTy4I1LSOegX+9u6cV+KH/BYL/gqlN+0b4hvvhx4FupbfwPps+zUL + yLdGdamRv4ejeSp9vnavDz3OqWW4f2s93su7/rqfpPhb4Z5lxrnEcvwStTTvUn0hG+vq30XU81/4Klf8 + FMtR/bW+IDaPpImtfh7o0x+xWkpP/ExYf8vEg/vf3a+P3ZAu1f5VNcTNOfMkZGZvl+T+FR/nvVYcmvwP + Mcwq4uu69V3bP9eeC+Dsv4byunlWWQ5YQS9W7ayb7t9RKKKK88+uCiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKAAda9n/4J+f8AJ7Xwu/7GG1/9Crxgda9n/wCCfn/J7Xwu/wCxhtf/AEKuzL/9 + 5h6r8z5Hj/8A5JzHf9ean/pDP6XbP/Ww/Q1e/hqjZ/62H6Gr38Nf01D4T/D1/EyOX79FEv36KoB8H+rF + JL9z8qWD/Vikl+5+VBMtj8x/+Dlv/k3z4e/9jA//AKTTV+M561+zH/By3/yb58Pf+xgf/wBJpq/Gc9a/ + CeO/+RrL0X5I/wBWvomf8m/o/wDXyp/6UFFFFfGn9MBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA + UUUUAFFFFABRnmiigB6ylH3da+2f+CSX/BS28/Y/+Idr4W8QXO74c6wSbqN5GxpU3G24h+X5Fb+NNyqF + +b79fEgH6VPAvmycssZ+9ub1FejlmY1cFXVei9V+R8Xx1wPl3FGV1MrzOPNCS+afSUX0aZ/Vf4a8QWni + rSLPUrG5hu7O7iWZJ4/uzK33WH/162/NzX4k/wDBHT/gqzJ8F/Eem/Czx/fJN4O1JhBo9+zn/iRyt/yy + Zv8Ani/b+6391fuftVaXsdxFGyyb1kG5GH8Vfv2R51RzHDKtB6rddn/kz/IbxM8N8x4LzeWXY5Xg9ac+ + k49/VbNdH5WZeoozRXsn54FFFFABRRRQAUUUUAFFFFABRRRQAUUU132LQAeZVe5ul+zN83C9x2ptxMBA + zflX5zf8Fkv+Cpa/ATQ7r4a+A75X8X6jbFdRvkOf7JiYbCqbefOb+HP3e+K87NMzo4Gg8RWeiX3vsj6n + gvg/MuJ81p5TlkOaU3q+kVfWT8keVf8ABaL/AIKomW41T4R/DvUPLWNxB4i1aCT/AFjFd32eL8/ndflH + 3N3avyse4xbsqAIrEfLjirOtak+rXkk8zGSeYLvkP/LQhVwx9Wb+L+tUc4r8BzrNquYYj29T5Lsj/Xrw + v8Ocu4PyaGW4KPvNJznb3py6t/otktBpNGaKK8Y/TVpsFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF + ABRRRQAUUUUAFFFFAAOtez/8E/P+T2vhd/2MNr/6FXjA617P/wAE/P8Ak9r4Xf8AYw2v/oVdmX/7zD1X + 5nyPH/8AyTmO/wCvNT/0hn9Ltn/rYfoavfw1Rs/9bD9DV7+Gv6ah8J/h6/iZHL9+iiX79FUA+D/Vikl+ + 5+VLB/qxSS/c/KgmWx+Y/wDwct/8m+fD3/sYH/8ASaavxnPWv2Y/4OW/+TfPh7/2MD/+k01fjOetfhPH + f/I1l6L8kf6tfRM/5N/R/wCvlT/0oKKKK+NP6YCiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo + AKKKKACiiigABxRnI5oooCyLljeG1nWRW2n+9s5jz/GvP3lzxX60f8EYf+Cr39uR6V8H/iJfSfbox5Hh + 7Vrh/M+0BV+W3mY/x/3HP3/un59ufyNzke1WrDUbjTtRhntJZIJrdxJFJFIY3QjptYc17eSZzWy7EKtT + 2vqu6Py/xR8Mcu4zymeAxytJJuE7e9CXRry6NdUf1fR38c4+U7uSfpjrVjdxX52/8Ec/+CoTftM+G7fw + J48uEh8c6bbj7NqDfu1163T5Vb/run8Q43feFfodHcq5Uhh8w4GeuK/f8vzGjjKCr0XdP8PJn+QvGHCO + ZcNZrVyjNIcs4PRraS6ST6p/8PZk1FFFdx8yFFFFABRRRQAUUUUAFFFGaAGmTaKhmuV8tvmHTpmm3Uqx + wHcwXpz6V8v/APBRn/goNoP7D/wYm1CWaG/8U6rFJFo2mb1865k5Hmsuf9XH1YgGufF4qlhqTq1nZI9X + I8jx2b46ll2X03OpUaSS/rZbt9EcL/wVb/4Ka2f7Ffw6bw/oM0d58QvEED/ZYl5/sqL7n2h1P8X91OTu + /wBmvwr8U+K7/wAY+IL7VNSvZNS1DVZmuLi5lLec7szMxZmra+LPxc1r44+N9X8TeJLxdQ1rV7lrme42 + /Pk9FX5f9UqcbO3qa4vOFyP5V+C8Q8QVMxrX2gtl+vqf6y+Cvg7geC8rUWubEzs6k7at78q/urouu+4m + 7ikoor5m5+7BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAA617P/AME/ + P+T2vhd/2MNr/wChV4wOtez/APBPz/k9r4Xf9jDa/wDoVdmX/wC8w9V+Z8jx/wD8k5jv+vNT/wBIZ/S7 + Z/62H6Gr38NUbP8A1sP0NXv4a/pqHwn+Hr+Jkcv36KJfv0VQD4P9WKSX7n5UsH+rFJL9z8qCZbH5j/8A + By3/AMm+fD3/ALGB/wD0mmr8Zz1r9mP+Dlv/AJN8+Hv/AGMD/wDpNNX4znrX4Tx3/wAjWXovyR/q19Ez + /k39H/r5U/8ASgooor40/pgKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii + gAzxU1uwV/m9DxUNLuoCx0Pgjx5q3w917TdU0fUJNNv9HuBd2V0m7zbaRf7vsfSv3m/4JV/8FINL/be+ + GMen6lLHY+O9DiEWoWZx/pS9p48fwt3r+fuM+Wdw/hOa7P4K/HDxF+zv8StJ8V+F9SksdW0d/MhkXPzq + fvRSf34zX1HDfEFTLa/M/gluv1XmfgvjZ4N4PjTKnGCUcVTTdOduv8r/ALr/AAeqP6l0uUk+UN7dalzx + XzN/wT7/AG7PDv7cfwdi1yxZbTXtPCw6xpufmtZtvzP/ALat2dc19KJOrDsOv41+84bEU69JVqTunqf5 + OZzk2NynG1MvzCDhVptqSfdfo90+xNRRRW55gUUUUAFFFGaAGl8HpTXmVE3Z+WiRgiFq84/aG+P/AIa/ + Zo+FuqeLvFmpR6fpOmqGLN9+Vv4UjX+Nm7AVnUqxpwc6jslq2bYXC1sVXjhsNFynJpJJXbb6LzZzP7aP + 7YHhX9jP4O6h4p8RzGRo12WNghH2jU5zwsUa/wA3I+VevrX8937T/wC0x4h/av8Ai3qnjHxRc79Q1CZd + kP8ArI7ONeFhhzjYqr97b95vn/j+Xpv28/23PEH7cXxluPEOoL9h0W2Bh0fTt7bbGHd1/wB58bm/ya8J + zjt0r8P4q4mnmFX2NLSnHbz82f6lfR+8C6PCeAWZ5jG+NqpN/wBxPXlXn/M++nQA2O3403NFFfFn9P26 + hRRRQMKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAHWvZ/8Agn5/ye18 + Lv8AsYbX/wBCrxgda9n/AOCfn/J7Xwu/7GG1/wDQq7Mv/wB5h6r8z5Hj/wD5JzHf9ean/pDP6XbP/Ww/ + Q1e/hqjZ/wCth+hq9/DX9NQ+E/w9fxMjl+/RRL9+iqAfB/qxSS/c/Klg/wBWKSX7n5UEy2PzH/4OW/8A + k3z4e/8AYwP/AOk01fjOetfsx/wct/8AJvnw9/7GB/8A0mmr8Zz1r8J47/5GsvRfkj/Vr6Jn/Jv6P/Xy + p/6UFFFFfGn9MBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABmn + pKySAq236Uyii4rJnr37I37Vfij9j/4zWPijwtebpIisNzaSSf6PqMP8UUn/ALLiv6C/2Rv2qvDv7Xnw + e0zxl4auvNhu1K3Vsx/fWUw+9Ey9Qw/h/vJ6V/M0jKsmWXevda+iP+CfH7e/iP8AYa+LtrqNlJJfeFrw + iPVtJx/x8x/31H/PRf4favt+E+JngKipVn+7b+7zP5a+kJ4GU+K8H/amVwUcbSXSy9olf3X5/wArfof0 + iLcqzFV5xxT88e9cF8EvjJofx8+Hej+KvDd/HqGkaxClzDIhHO5fuf7w713XnAf41+206kZxU4O6e3mf + 5d4nDVsPWlQrx5ZRdmno01o015MkooorQxEyfSmPJs+b+VOYhax9d1y10nRpry6mjhtrdGlkld/LRFX7 + zFvSldLV7DjFyait2U/H3jfSfh54R1DXNYvoNO0vTIWnubiVvljUev8AnmvwF/4Ki/8ABRrUv25/iWkN + jJJZ+A9DkddLsG3Bp2/inkHHzHtx8vevRv8Agr3/AMFQz+1h4jvPAfhC4mh8A6TcfvJYjsXW7hH+/Jx/ + ql7f3j8w4r4NuLlrhzLI26Rwo9NuOlfj3GPEyxMvqmHfuLd/zPt6L8T/AEZ+jZ4EPKaUOJc9h/tElenG + X/LuL+0/7z/BepG05b/DtUeeaKK/OT+1gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig + AooooAKKKKACiiigAooooAB1r2f/AIJ+f8ntfC7/ALGG1/8AQq8YHWvZ/wDgn5/ye18Lv+xhtf8A0Kuz + L/8AeYeq/M+R4/8A+Scx3/Xmp/6Qz+l2z/1sP0NXv4ao2f8ArYfoavfw1/TUPhP8PX8TI5fv0US/foqg + Hwf6sUkv3PypYP8AVikl+5+VBMtj8x/+Dlv/AJN8+Hv/AGMD/wDpNNX4znrX7Mf8HLf/ACb58Pf+xgf/ + ANJpq/Gc9a/CeO/+RrL0X5I/1a+iZ/yb+j/18qf+lBRRRXxp/TAUUUUAFFFFABRRRQAUUUUAFFFFABRR + RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUALmrFpIFuAzfd6uP7+P4fxqtS7v6VSk0RKmpKx9k/ + 8Erv+ClOqfsZ/Eu30fWJTfeANWYLeWwDn7C21iZoRz8w43Iv319Wr94fBfjLTfHvhqx1bSb2HUNP1GFL + i2mgbessbruV8+hr+ViAL5q7vlx6d6/Qf/gj/wD8FTT+zx4jtfh34+vlk8D6k2bC7uN3/EgnL5ZWb/nl + J/FztX2Xdj9I4O4pVCSweKfuPZ9vL0P4i+kp4C/2jCXE2RQ/fxV6kIr40vtJfzLr/MvOx+44kzRJJ5a5 + PFZtnqkN9brJDMk0bqCrKcht33cVZurhVhbP8PXbX68rNXR/nfK6fLLRiXd2kNvIzdlySa/Hb/gsv/wV + Rj8cDVvhP4Avpm0mN/s2v6lBL5f2tx963jb/AJ5j7rbcrmvWf+CyP/BVCH4WaRe/C3wJqPk+IryDZrGo + xj5tPjbrBG3/AD1b+/nav97dX4739z58kjMkTTThXYoGO1v7vzf+Pf7Vfl/F/FNlLA4V/wCJ/oj+3/o0 + +BaxFSnxTn9P3U70oSW7WqnJdk9Yrrv2Iby7+0lSyxho1VNqjCqo/u1WLZFJmivydtvc/wBDoQUVaIUU + UUFhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQADrXs/8A + wT8/5Pa+F3/Yw2v/AKFXjA617P8A8E/P+T2vhd/2MNr/AOhV2Zf/ALzD1X5nyPH/APyTmO/681P/AEhn + 9Ltn/rYfoavfw1Rs/wDWw/Q1e/hr+mofCf4ev4mRy/fool+/RVAPg/1YpJfuflSwf6sUkv3PyoJlsfmP + /wAHLf8Ayb58Pf8AsYH/APSaavxnPWv2Y/4OW/8Ak3z4e/8AYwP/AOk01fjOetfhPHf/ACNZei/JH+rX + 0TP+Tf0f+vlT/wBKCiiivjT+mAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKADNWLSXyJo23JgHdlkEg/75PFV6M1UZWdyZ04yVmfqt/wRa/4KvLp17pnwg+J + GqFbWT914d1W7k+VGP8Ay6TO35xu3+7/AHQfoP8A4K3f8FR7L9k7wTdeD/COoW1x8Rtctt0ZRcjRoX58 + 6T/b2H5U+/n5tuyvwy03UZdJvo7i3lkhkjbcjocMprW8U+NtS8e6nfX2sahfapd3Mhmae9uJLhmdtu5t + zfNnj+L+GvtcPxlioZe8J12Uutv66n8p559GTI8XxjTz+OlB+9OlbSVS6+6L3kur8mV9a1iTX764u7yd + ri+vJTcSSy7nmkkb77Mx/hb79Y5YMelAO0U2vjKlRy1Z/UmFwcMNBU6aSitElsrdgooorM6gooooAKKK + KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAAda9n/AOCfn/J7 + Xwu/7GG1/wDQq8YHWvZ/+Cfn/J7Xwu/7GG1/9Crsy/8A3mHqvzPkeP8A/knMd/15qf8ApDP6XbP/AFsP + 0NXv4ao2f+th+hq9/DX9NQ+E/wAPX8TI5fv0US/foqgHwf6sUkv3PypYP9WKSX7n5UEy2PzH/wCDlv8A + 5N8+Hv8A2MD/APpNNX4znrX7Mf8ABy3/AMm+fD3/ALGB/wD0mmr8Zz1r8J47/wCRrL0X5I/1a+iZ/wAm + /o/9fKn/AKUFFFFfGn9MBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFAbChsUZ4/OkooFyhRRRQMKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii + igAooooAKKKKACiiigAooooAKKKKACiiigAooooAB1r2f/gn5/ye18Lv+xhtf/Qq8YHWvZ/+Cfn/ACe1 + 8Lv+xhtf/Qq7Mv8A95h6r8z5Hj//AJJzHf8AXmp/6Qz+l2z/ANbD9DV7+GqNn/rYfoavfw1/TUPhP8PX + 8TI5fv0US/foqgHwf6sUkv3PypYP9WKSX7n5UEy2PzH/AODlv/k3z4e/9jA//pNNX4znrX7Mf8HLf/Jv + nw9/7GB//SaavxnPWvwnjv8A5GsvRfkj/Vr6Jn/Jv6P/AF8qf+lBRRRXxp/TAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAAOtez/wDB + Pz/k9r4Xf9jDa/8AoVeMDrXs/wDwT8/5Pa+F3/Yw2v8A6FXZl/8AvMPVfmfI8f8A/JOY7/rzU/8ASGf0 + u2f+th+hq9/DVGz/ANbD9DV7+Gv6ah8J/h6/iZHL9+iiX79FUA+D/Vikl+5+VLB/qxSS/c/KgmWx+Y// + AAct/wDJvnw9/wCxgf8A9Jpq/Gc9a/Zj/g5b/wCTfPh7/wBjA/8A6TTV+M561+E8d/8AI1l6L8kf6tfR + M/5N/R/6+VP/AEoKKKK+NP6YCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo + ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo + ooAKKKKACiiigAooooAKKKKACiiigAooooAB1r2f/gn5/wAntfC7/sYbX/0KvGB1r2f/AIJ+f8ntfC7/ + ALGG1/8AQq7Mv/3mHqvzPkeP/wDknMd/15qf+kM/pds/9bD9DV7+GqNn/rYfoavfw1/TUPhP8PX8TI5f + v0US/foqgHwf6sUkv3KWD/Vikf7j0Cex+Y//AAct/wDJvvw9/wCxgf8A9Jpq/GcfNX7S/wDBxl4U1bxp + 8C/ANrouk6prFzD4geRo7KzluNi/ZpPvbFNfkd/wz948/wChJ8Wf+Cef/wCJr8P42w9SpmknCLatHX5I + /wBR/or5xgcNwHRp4irGMuepo5JP4vM4uiu0/wCGfvHn/Qk+LP8AwTz/APxNH/DP3jz/AKEnxZ/4J5// + AImvkfqdf+R/cz+kP9Y8r/6CIf8Agcf8zi6K7T/hn7x5/wBCT4s/8E8//wATR/wz948/6EnxZ/4J5/8A + 4mj6nX/kf3MP9Y8r/wCgiH/gcf8AM4uiu0/4Z+8ef9CT4s/8E8//AMTR/wAM/ePP+hJ8Wf8Agnn/APia + Pqdf+R/cw/1jyv8A6CIf+Bx/zOLortP+GfvHn/Qk+LP/AATz/wDxNH/DP3jz/oSfFn/gnn/+Jo+p1/5H + 9zD/AFjyv/oIh/4HH/M4uiu0/wCGfvHn/Qk+LP8AwTz/APxNH/DP3jz/AKEnxZ/4J5//AImj6nX/AJH9 + zD/WPK/+giH/AIHH/M4uiu0/4Z+8ef8AQk+LP/BPP/8AE0f8M/ePP+hJ8Wf+Cef/AOJo+p1/5H9zD/WP + K/8AoIh/4HH/ADOLortP+GfvHn/Qk+LP/BPP/wDE0f8ADP3jz/oSfFn/AIJ5/wD4mj6nX/kf3MP9Y8r/ + AOgiH/gcf8zi6K7T/hn7x5/0JPiz/wAE8/8A8TR/wz948/6EnxZ/4J5//iaPqdf+R/cw/wBY8r/6CIf+ + Bx/zOLortP8Ahn7x5/0JPiz/AME8/wD8TR/wz948/wChJ8Wf+Cef/wCJo+p1/wCR/cw/1jyv/oIh/wCB + x/zOLortP+GfvHn/AEJPiz/wTz//ABNH/DP3jz/oSfFn/gnn/wDiaPqdf+R/cw/1jyv/AKCIf+Bx/wAz + i6K7T/hn7x5/0JPiz/wTz/8AxNH/AAz948/6EnxZ/wCCef8A+Jo+p1/5H9zD/WPK/wDoIh/4HH/M4uiu + 0/4Z+8ef9CT4s/8ABPP/APE0f8M/ePP+hJ8Wf+Cef/4mj6nX/kf3MP8AWPK/+giH/gcf8zi6K7T/AIZ+ + 8ef9CT4s/wDBPP8A/E0f8M/ePP8AoSfFn/gnn/8AiaPqdf8Akf3MP9Y8r/6CIf8Agcf8zi6K7T/hn7x5 + /wBCT4s/8E8//wATR/wz948/6EnxZ/4J5/8A4mj6nX/kf3MP9Y8r/wCgiH/gcf8AM4uiu0/4Z+8ef9CT + 4s/8E8//AMTR/wAM/ePP+hJ8Wf8Agnn/APiaPqdf+R/cw/1jyv8A6CIf+Bx/zOLortP+GfvHn/Qk+LP/ + AATz/wDxNH/DP3jz/oSfFn/gnn/+Jo+p1/5H9zD/AFjyv/oIh/4HH/M4uiu0/wCGfvHn/Qk+LP8AwTz/ + APxNH/DP3jz/AKEnxZ/4J5//AImj6nX/AJH9zD/WPK/+giH/AIHH/M4uiu0/4Z+8ef8AQk+LP/BPP/8A + E0f8M/ePP+hJ8Wf+Cef/AOJo+p1/5H9zD/WPK/8AoIh/4HH/ADOLortP+GfvHn/Qk+LP/BPP/wDE0f8A + DP3jz/oSfFn/AIJ5/wD4mj6nX/kf3MP9Y8r/AOgiH/gcf8zi6K7T/hn7x5/0JPiz/wAE8/8A8TR/wz94 + 8/6EnxZ/4J5//iaPqdf+R/cw/wBY8r/6CIf+Bx/zOLortP8Ahn7x5/0JPiz/AME8/wD8TR/wz948/wCh + J8Wf+Cef/wCJo+p1/wCR/cw/1jyv/oIh/wCBx/zOLortP+GfvHn/AEJPiz/wTz//ABNH/DP3jz/oSfFn + /gnn/wDiaPqdf+R/cw/1jyv/AKCIf+Bx/wAzi6K7T/hn7x5/0JPiz/wTz/8AxNH/AAz948/6EnxZ/wCC + ef8A+Jo+p1/5H9zD/WPK/wDoIh/4HH/M4uiu0/4Z+8ef9CT4s/8ABPP/APE0f8M/ePP+hJ8Wf+Cef/4m + j6nX/kf3MP8AWPK/+giH/gcf8zi6K7T/AIZ+8ef9CT4s/wDBPP8A/E0f8M/ePP8AoSfFn/gnn/8AiaPq + df8Akf3MP9Y8r/6CIf8Agcf8zi6K7T/hn7x5/wBCT4s/8E8//wATR/wz948/6EnxZ/4J5/8A4mj6nX/k + f3MP9Y8r/wCgiH/gcf8AM4uiu0/4Z+8ef9CT4s/8E8//AMTR/wAM/ePP+hJ8Wf8Agnn/APiaPqdf+R/c + w/1jyv8A6CIf+Bx/zOLortP+GfvHn/Qk+LP/AATz/wDxNH/DP3jz/oSfFn/gnn/+Jo+p1/5H9zD/AFjy + v/oIh/4HH/M4uiu0/wCGfvHn/Qk+LP8AwTz/APxNH/DP3jz/AKEnxZ/4J5//AImj6nX/AJH9zD/WPK/+ + giH/AIHH/M4uiu0/4Z+8ef8AQk+LP/BPP/8AE0f8M/ePP+hJ8Wf+Cef/AOJo+p1/5H9zD/WPK/8AoIh/ + 4HH/ADOLortP+GfvHn/Qk+LP/BPP/wDE0f8ADP3jz/oSfFn/AIJ5/wD4mj6nX/kf3MP9Y8r/AOgiH/gc + f8zi6K7T/hn7x5/0JPiz/wAE8/8A8TR/wz948/6EnxZ/4J5//iaPqdf+R/cw/wBY8r/6CIf+Bx/zOLor + tP8Ahn7x5/0JPiz/AME8/wD8TR/wz948/wChJ8Wf+Cef/wCJo+p1/wCR/cw/1jyv/oIh/wCBx/zOMAwM + 17P/AME+xn9tr4X/APYw2vAHT5q4r/hQHjzP/Il+Lf8AwTT/APxNeu/sF/BTxlo37ZPw1u7vwj4ms7W1 + 163klmm0u4jjjVW/ibbiuzAYSssTT917ro+58jx3xDls+HsbCOIhd0qllzRu3yO1lc/o0s/9ZD9DV/bx + VCy5kj+hrQr+kI/Cf4r9WQy/fool+/RVAPg/1YpZI90e2mQSYAXvUtAFA6dHM2WjVv4hkZwaedJhI/1N + v/3yKuYoqeRXuVGTSsmU/wCyov8Anjb/APfIo/sqL/njb/8AfIq5RRyoOeXcp/2VF/zxt/8AvkUf2VF/ + zxt/++RVyijlQc8u5T/sqL/njb/98ij+yov+eNv/AN8irlFHKg55dyn/AGVF/wA8bf8A75FH9lRf88bf + /vkVcoo5UHPLuU/7Ki/542//AHyKP7Ki/wCeNv8A98irlFHKg55dyn/ZUX/PG3/75FH9lRf88bf/AL5F + XKKOVBzy7lP+yov+eNv/AN8ij+yov+eNv/3yKuUUcqDnl3Kf9lRf88bf/vkUf2VF/wA8bf8A75FXKKOV + Bzy7lP8AsqL/AJ42/wD3yKP7Ki/542//AHyKuUUcqDnl3Kf9lRf88bf/AL5FH9lRf88bf/vkVcoo5UHP + LuU/7Ki/542//fIo/sqL/njb/wDfIq5RRyoOeXcp/wBlRf8APG3/AO+RR/ZUX/PG3/75FXKKOVBzy7lP + +yov+eNv/wB8ij+yov8Anjb/APfIq5RRyoOeXcp/2VF/zxt/++RR/ZUX/PG3/wC+RVyijlQc8u5T/sqL + /njb/wDfIo/sqL/njb/98irlFHKg55dyn/ZUX/PG3/75FH9lRf8APG3/AO+RVyijlQc8u5T/ALKi/wCe + Nv8A98ij+yov+eNv/wB8irlFHKg55dyn/ZUX/PG3/wC+RR/ZUX/PG3/75FXKKOVBzy7lP+yov+eNv/3y + KP7Ki/542/8A3yKuUUcqDnl3Kf8AZUX/ADxt/wDvkUf2VF/zxt/++RVyijlQc8u5T/sqL/njb/8AfIo/ + sqL/AJ42/wD3yKuUUcqDnl3Kf9lRf88bf/vkUf2VF/zxt/8AvkVcoo5UHPLuU/7Ki/542/8A3yKP7Ki/ + 542//fIq5RRyoOeXcp/2VF/zxt/++RR/ZUX/ADxt/wDvkVcoo5UHPLuU/wCyov8Anjb/APfIo/sqL/nj + b/8AfIq5RRyoOeXcp/2VF/zxt/8AvkUf2VF/zxt/++RVyijlQc8u5T/sqL/njb/98ij+yov+eNv/AN8i + rlFHKg55dyn/AGVF/wA8bf8A75FH9lRf88bf/vkVcoo5UHPLuU/7Ki/542//AHyKP7Ki/wCeNv8A98ir + lFHKg55dyn/ZUX/PG3/75FH9lRf88bf/AL5FXKKOVBzy7lP+yov+eNv/AN8ij+yov+eNv/3yKuUUcqDn + l3Kf9lRf88bf/vkUf2VF/wA8bf8A75FXKKOVBzy7lP8AsqL/AJ42/wD3yKP7Ki/542//AHyKuUUcqDnl + 3KL6TEy/6m3/AO+RUQ0mMsrNDCNp4IjwRWnRRyoPaS7srJFmRW27dtWaKa8gjXLVW5JHJ96imy7Q/aig + CMr5G5tzMd38RzTftz+i/lRRQAfbn9F/Kj7c/ov5UUUAH25/Rfyo+3P6L+VFFAB9uf0X8qPtz+i/lRRQ + Afbn9F/Kj7c/ov5UUUAH25/Rfyo+3P6L+VFFAB9uf0X8qPtz+i/lRRQAfbn9F/Kj7c/ov5UUUAH25/Rf + yo+3P6L+VFFAB9uf0X8qPtz+i/lRRQAfbn9F/Kj7c/ov5UUUAH25/Rfyo+3P6L+VFFAB9uf0X8qPtz+i + /lRRQAfbn9F/Kj7c/ov5UUUAH25/Rfyo+3P6L+VFFAB9uf0X8qPtz+i/lRRQAfbn9F/Kj7c/ov5UUUAH + 25/Rfyo+3P6L+VFFAB9uf0X8qPtz+i/lRRQAfbn9F/Kj7c/ov5UUUAH25/Rfyo+3P6L+VFFAB9uf0X8q + Ptz+i/lRRQAfbn9F/Kj7c/ov5UUUAH25/Rfyo+3P6L+VFFAB9uf0X8qPtz+i/lRRQAfbn9F/Kj7c/ov5 + UUUAH25/Rfyo+3P6L+VFFAB9uf0X8qPtz+i/lRRQAfbn9F/Kj7c/ov5UUUAH25/Rfyo+3P6L+VFFAB9u + f0X8qPtz+i/lRRQAfbn9F/Kj7c/ov5UUUAH25/Rfyo+3P6L+VFFAB9uf0X8qPtz+i/lRRQAfbn9F/Kj7 + c/ov5UUUAH25/Rfyo+3P6L+VFFAB9uf0X8qWG7aUAtt/KiigCWOL73zN19aKKKAP/9k= + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/4QAiRXhpZgAATU0AKgAAAAgAAQESAAMAAAABAAEAAAAAAAD/2wBD + AAIBAQIBAQICAgICAgICAwUDAwMDAwYEBAMFBwYHBwcGBwcICQsJCAgKCAcHCg0KCgsMDAwMBwkODw0M + DgsMDAz/2wBDAQICAgMDAwYDAwYMCAcIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM + DAwMDAwMDAwMDAwMDAz/wAARCAJUAlQDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQF + BgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAk + M2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWG + h4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx + 8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQA + AQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5 + OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmq + srO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD9 + 8oIGJP3mVmLc1MIFz0ot/wDUr/uipCcCgBnkL6UeQvpSCVWPDYo8xf726gXMhfIX0o8hfSk8xf8AIo8x + f8igXMhfIX0o8hfSk8xf8ijzF/yKA5kL5C+lHkL6UnmL/kUeYv8AkUBzIXyF9KPIX0pPMX/Io8xf8igO + ZC+QvpR5C+lJ5i/5FHmL/kUBzIXyF9KPIX0pPMX/ACKPMX/IoDmQvkL6UeQvpSeYv+RR5i/5FAcyF8hf + SjyF9KTzF/yKPMX/ACKA5kL5C+lHkL6UnmL/AJFHmL/kUBzIXyF9KPIX0pPMX/Io8xf8igOZC+QvpR5C + +lJ5i/5FHmL/AJFAcyF8hfSjyF9KTzF/yKPMX/IoDmQvkL6UeQvpSeYv+RR5i/5FAcyF8hfSjyF9KTzF + /wAijzF/yKA5kL5C+lHkL6UnmL/kUeYv+RQHMhfIX0o8hfSk8xf8ijzF/wAigOZC+QvpR5C+lJ5i/wCR + R5i/5FAcyF8hfSjyF9KTzF/yKPMX/IoDmQvkL6UeQvpSeYv+RR5i/wCRQHMhfIX0o8hfSk8xf8ijzF/y + KA5kL5C+lHkL6UnmL/kUeYv+RQHMhfIX0o8hfSk8xf8AIo8xf8igOZC+QvpR5C+lJ5i/5FHmL/kUBzIX + yF9KPIX0pPMX/Io8xf8AIoDmQvkL6UeQvpSeYv8AkUeYv+RQHMhfIX0o8hfSk8xf8ijzF/yKA5kL5C+l + HkL6UnmL/kUeYv8AkUBzIXyF9KPIX0pPMX/Io8xf8igOZC+QvpR5C+lJ5i/5FHmL/kUBzIXyF9KPIX0p + PMX/ACKPMX/IoDmQvkL6UeQvpSeYv+RR5i/5FAcyF8hfSjyF9KTzF/yKPMX/ACKA5kL5C+lHkL6UnmL/ + AJFHmL/kUBzIXyF9KPIX0pPMX/IoM6oMk4oDmQvkL6U2WEKvyryOetPjkWUZU5p3egoqGZLT5WaTceet + FMv/APj4/CigC1b/AOpX/dFFyu5P4fx6UW/+pX/dFOm+4fpQB80/8FCv+ChOi/8ABPfw14b1rXtB1jXr + TxBfSWSpYvEpi2RFyfnI9unpXy+P+Dln4bqx/wCLe+N/YmS1+YdM/wCsFQ/8HNH/ACQv4Z/9h2f/ANEV + +NcnRfpX5RxRxRmOCzCVDDySjZO3LF7pPqr9T+9vAPwB4P4p4PoZxm9Gcq0pVE2qkoq0ZNLRO2x+zf8A + xEufDf8A6J742/7+Wv8A8do/4iXPhv8A9E98bf8Afy1/+O1+MVFfPf69Zv8Azr/wGP8AkftH/Ep3h3/0 + D1P/AAbP/M/Z3/iJc+G//RPfG3/fy1/+O0f8RLnw3/6J742/7+Wv/wAdr8YqKP8AXrN/51/4DH/IP+JT + vDv/AKB6n/g2f+Z+zv8AxEufDf8A6J742/7+Wv8A8do/4iXPhv8A9E98bf8Afy1/+O1+MVFH+vWb/wA6 + /wDAY/5B/wASneHf/QPU/wDBs/8AM/Z3/iJc+G//AET3xt/38tf/AI7R/wARLnw3/wCie+Nv+/lr/wDH + a/GKij/XrN/51/4DH/IP+JTvDv8A6B6n/g2f+Z+zv/ES58N/+ie+Nv8Av5a//HaP+Ilz4b/9E98bf9/L + X/47X4xUUf69Zv8Azr/wGP8AkH/Ep3h3/wBA9T/wbP8AzP2d/wCIlz4b/wDRPfG3/fy1/wDjtH/ES58N + /wDonvjb/v5a/wDx2vxioo/16zf+df8AgMf8g/4lO8O/+gep/wCDZ/5n7O/8RLnw3/6J742/7+Wv/wAd + o/4iXPhv/wBE98bf9/LX/wCO1+MVFH+vWb/zr/wGP+Qf8SneHf8A0D1P/Bs/8z9nf+Ilz4b/APRPfG3/ + AH8tf/jtH/ES58N/+ie+Nv8Av5a//Ha/GKij/XrN/wCdf+Ax/wAg/wCJTvDv/oHqf+DZ/wCZ+zv/ABEu + fDf/AKJ742/7+Wv/AMdo/wCIlz4b/wDRPfG3/fy1/wDjtfjFRR/r1m/86/8AAY/5B/xKd4d/9A9T/wAG + z/zP2d/4iXPhv/0T3xt/38tf/jtH/ES58N/+ie+Nv+/lr/8AHa/GKij/AF6zf+df+Ax/yD/iU7w7/wCg + ep/4Nn/mfs7/AMRLnw3/AOie+Nv+/lr/APHaP+Ilz4b/APRPfG3/AH8tf/jtfjFRR/r1m/8AOv8AwGP+ + Qf8AEp3h3/0D1P8AwbP/ADP2d/4iXPhv/wBE98bf9/LX/wCO0f8AES58N/8Aonvjb/v5a/8Ax2vxioo/ + 16zf+df+Ax/yD/iU7w7/AOgep/4Nn/mfs7/xEufDf/onvjb/AL+Wv/x2j/iJc+G//RPfG3/fy1/+O1+M + VFH+vWb/AM6/8Bj/AJB/xKd4d/8AQPU/8Gz/AMz9nf8AiJc+G/8A0T3xt/38tf8A47R/xEufDf8A6J74 + 2/7+Wv8A8dr8YqKP9es3/nX/AIDH/IP+JTvDv/oHqf8Ag2f+Z+zv/ES58N/+ie+Nv+/lr/8AHaP+Ilz4 + b/8ARPfG3/fy1/8AjtfjFRR/r1m/86/8Bj/kH/Ep3h3/ANA9T/wbP/M/Z3/iJc+G/wD0T3xt/wB/LX/4 + 7R/xEufDf/onvjb/AL+Wv/x2vxioo/16zf8AnX/gMf8AIP8AiU7w7/6B6n/g2f8Amfs7/wARLnw3/wCi + e+Nv+/lr/wDHaP8AiJc+G/8A0T3xt/38tf8A47X4xUUf69Zv/Ov/AAGP+Qf8SneHf/QPU/8ABs/8z9nf + +Ilz4b/9E98bf9/LX/47R/xEufDf/onvjb/v5a//AB2vxioo/wBes3/nX/gMf8g/4lO8O/8AoHqf+DZ/ + 5n7O/wDES58N/wDonvjb/v5a/wDx2j/iJc+G/wD0T3xt/wB/LX/47X4xUUf69Zv/ADr/AMBj/kH/ABKd + 4d/9A9T/AMGz/wAz9nf+Ilz4b/8ARPfG3/fy1/8AjtH/ABEufDf/AKJ742/7+Wv/AMdr8YqKP9es3/nX + /gMf8g/4lO8O/wDoHqf+DZ/5n7O/8RLnw3/6J742/wC/lr/8do/4iXPhv/0T3xt/38tf/jtfjFRR/r1m + /wDOv/AY/wCQf8SneHf/AED1P/Bs/wDM/Z3/AIiXPhv/ANE98bf9/LX/AOO0f8RLnw3/AOie+Nv+/lr/ + APHa/GKij/XrN/51/wCAx/yD/iU7w7/6B6n/AINn/mfs7/xEufDf/onvjb/v5a//AB2j/iJc+G//AET3 + xt/38tf/AI7X4xUUf69Zv/Ov/AY/5B/xKd4d/wDQPU/8Gz/zP2d/4iXPhv8A9E98bf8Afy1/+O0f8RLn + w3/6J742/wC/lr/8dr8YqKP9es3/AJ1/4DH/ACD/AIlO8O/+gep/4Nn/AJn7O/8AES58N/8Aonvjb/v5 + a/8Ax2j/AIiXPhv/ANE98bf9/LX/AOO1+MVFH+vWb/zr/wABj/kH/Ep3h3/0D1P/AAbP/M/Z3/iJc+G/ + /RPfG3/fy1/+O0f8RLnw3/6J742/7+Wv/wAdr8YqKP8AXrN/51/4DH/IP+JTvDv/AKB6n/g2f+Z+zv8A + xEufDf8A6J742/7+Wv8A8do/4iXPhv8A9E98bf8Afy1/+O1+MVFH+vWb/wA6/wDAY/5B/wASneHf/QPU + /wDBs/8AM/Z3/iJc+G//AET3xt/38tf/AI7R/wARLnw3/wCie+Nv+/lr/wDHa/GKij/XrN/51/4DH/IP + +JTvDv8A6B6n/g2f+Z+zv/ES58N/+ie+Nv8Av5a//HaP+Ilz4b/9E98bf9/LX/47X4xUUf69Zv8Azr/w + GP8AkH/Ep3h3/wBA9T/wbP8AzP2d/wCIlz4b/wDRPfG3/fy1/wDjtH/ES58N/wDonvjb/v5a/wDx2vxi + oo/16zf+df8AgMf8g/4lO8O/+gep/wCDZ/5n7O/8RLnw3/6J742/7+Wv/wAdo/4iXPhv/wBE98bf9/LX + /wCO1+MVFH+vWb/zr/wGP+Qf8SneHf8A0D1P/Bs/8z9nf+Ilz4b/APRPfG3/AH8tf/jtH/ES58N/+ie+ + Nv8Av5a//Ha/GKij/XrN/wCdf+Ax/wAg/wCJTvDv/oHqf+DZ/wCZ+zv/ABEufDf/AKJ742/7+Wv/AMdo + /wCIlz4b/wDRPfG3/fy1/wDjtfjFRR/r1m/86/8AAY/5B/xKd4d/9A9T/wAGz/zP2d/4iXPhv/0T3xt/ + 38tf/jtaPgz/AIOLfh/4/wDG2i6HZ/D/AMYR3Ws6hb2EUk0tt5cTSypGGOHJ43V+KNdx+zJ/ych8P/8A + sZNN/wDSuKtKHG+bSqRi5rVr7Mf8jzs2+it4fUMDWr0sPUUowk1+9nuk2up/UZpRbPzKw6HnGTnnsT61 + od6q2n3vyq13r9yjsf5YrYo3/wDx8fhRRf8A/Hx+FFUMtW/+pX/dFOm+4fpTbf8A1K/7op033D9KAPzD + /wCDmj/khfwz/wCw7P8A+iK/GuTov0r9lP8Ag5o/5IX8M/8AsOz/APoivxrk6L9K/B+OP+RrL0j/AOko + /wBX/oo/8m7wv+Ot/wCnGNooor48/pEKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAruP2ZP+TkPh/8A9jJpv/pXFXD13H7Mn/JyHw// + AOxk03/0rirfC/xoeq/M8nP/APkWYj/r3P8A9JZ/Ulafe/KrXeqtp978qtd6/p+Ox/hKtijf/wDHx+FF + F/8A8fH4UVQFq3/1K/7op033D9Kbb/6lf90U6b7h+lAH5h/8HNH/ACQv4Z/9h2f/ANEV+NcnRfpX7Kf8 + HNH/ACQv4Z/9h2f/ANEV+NcnRfpX4Pxx/wAjWXpH/wBJR/q/9FH/AJN3hf8AHW/9OMbRRRXx5/SIUUUU + AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU + AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU + AFFFFABXcfsyf8nIfD//ALGTTf8A0rirh67j9mT/AJOQ+H//AGMmm/8ApXFW+F/jQ9V+Z5Of/wDIsxH/ + AF7n/wCks/qStPvflVrvVW0+9+VWu9f0/HY/wlWxRv8A/j4/Cii//wCPj8KKoC1b/wCpX/dFOm+4fpTb + f/Ur/uinTfcP0oA/MP8A4OaP+SF/DP8A7Ds//oivxrk6L9K/ZT/g5o/5IX8M/wDsOz/+iK/GuTov0r8H + 44/5GsvSP/pKP9X/AKKP/Ju8L/jrf+nGNooor48/pEKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC + iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC + iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAruP2ZP+TkPh/wD9jJpv/pXFXD13 + H7Mn/JyHw/8A+xk03/0rirfC/wAaHqvzPJz/AP5FmI/69z/9JZ/Ulafe/KrXeqtp978qtd6/p+Ox/hKt + ijf/APHx+FFF/wD8fH4UVQFq3/1K/wC6KdN9w/Sm2/8AqV/3RTpvuH6UAfmH/wAHNH/JC/hn/wBh2f8A + 9EV+NcnRfpX7Kf8ABzR/yQv4Z/8AYdn/APRFfjXJ0X6V+D8cf8jWXpH/ANJR/q/9FH/k3eF/x1v/AE4x + tFFFfHn9IhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFdx+zJ/ych8P/wDsZNN/9K4q4eu4/Zk/5OQ+H/8A2Mmm/wDpXFW+F/jQ9V+Z + 5Of/APIsxH/Xuf8A6Sz+pK0+9+VWu9VbT735Va71/T8dj/CVbFG//wCPj8KKL/8A4+PwoqgLVv8A6lf9 + 0U6b7h+lNt/9Sv8AuinTfcP0oA/MP/g5o/5IX8M/+w7P/wCiK/GuTov0r9lP+Dmj/khfwz/7Ds//AKIr + 8a5Oi/Svwfjj/kay9I/+ko/1f+ij/wAm7wv+Ot/6cY2iiivjz+kQooooAKKKKACiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACu4/Zk/wCTkPh//wBj + Jpv/AKVxVw9dx+zJ/wAnIfD/AP7GTTf/AErirfC/xoeq/M8nP/8AkWYj/r3P/wBJZ/Ulafe/KrXeqtp9 + 78qtd6/p+Ox/hKtijf8A/Hx+FFF//wAfH4UVQFq3/wBSv+6KdN9w/Sm2/wDqV/3RTpvuH6UAfmH/AMHN + H/JC/hn/ANh2f/0RX41ydF+lfsp/wc0f8kL+Gf8A2HZ//RFfjXJ0X6V+D8cf8jWXpH/0lH+r/wBFH/k3 + eF/x1v8A04xtFFFfHn9IhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFdx+zJ/ych8P/APsZNN/9K4q4eu4/Zk/5OQ+H/wD2Mmm/+lcV + b4X+ND1X5nk5/wD8izEf9e5/+ks/qStPvflVrvVW0+9+VWu9f0/HY/wlWxRv/wDj4/Cii/8A+Pj8KKoC + 1b/6lf8AdFOm+4fpTbf/AFK/7op033D9KAPzD/4OaP8Akhfwz/7Ds/8A6Ir8a5Oi/Sv2U/4OaP8Akhfw + z/7Ds/8A6Ir8a5Oi/Svwfjj/AJGsvSP/AKSj/V/6KP8AybvC/wCOt/6cY2iiivjz+kQooooAKKKKACii + igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii + igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACu4 + /Zk/5OQ+H/8A2Mmm/wDpXFXD13H7Mn/JyHw//wCxk03/ANK4q3wv8aHqvzPJz/8A5FmI/wCvc/8A0ln9 + SVp978qtd6q2n3vyq13r+n47H+Eq2KN//wAfH4UUX/8Ax8fhRVAWrf8A1K/7op033D9Kbb/6lf8AdFOm + +4fpQB+Yf/BzR/yQv4Z/9h2f/wBEV+NcnRfpX7Kf8HNH/JC/hn/2HZ//AERX41ydF+lfg/HH/I1l6R/9 + JR/q/wDRR/5N3hf8db/04xtFFFfHn9IhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB + RRRQAUUUUAFFFPhG5sfLz/eOFoAZRVhrCQMVYKrLyVdvmFRtBJnpn8c1fs5ExkpbEdFP+zv/AHTR9nf+ + 6afs2XZjKKf9nf8Aumj7O/8AdNHs2FmMop/2d/7po+zv/dNHs2FmMop/2d/7po+zv/dNHs2FmMop/wBn + f+6aPs7/AN00ezYWYyin/Z3/ALpqSCyknyqxszfeAHXgEn9AaXs5dhS0V2QUVaudPmgg8ySJlXIDbuq7 + gCP0Iqu3H8qlprRkxnGSvF3G0UUUigooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo + ooAKKKKACu4/Zk/5OQ+H/wD2Mmm/+lcVcPXcfsyf8nIfD/8A7GTTf/SuKt8L/Gh6r8zyc/8A+RZiP+vc + /wD0ln9SVp978qtd6q2n3vyq13r+n47H+Eq2KN//AMfH4UUX/wDx8fhRVAWrf/Ur/uinTfcP0ptv/qV/ + 3RTpvuH6UAfmH/wc0f8AJC/hn/2HZ/8A0RX41ydF+lfsp/wc0f8AJC/hn/2HZ/8A0RX41ydF+lfg/HH/ + ACNZekf/AElH+r/0Uf8Ak3eF/wAdb/04xtFFFfHn9IhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA + UUUUAFFFFABRRRQAUUqIZHwKkt4XlDFV3c4x/e9h6n0A5PajcmUktxbOA3M3lqwBPJycZA5Ndh8DfgX4 + o/aE+I2meFvCuky6tq2r/OkOC0Sx5wXkI+7GOpPaus/ZJ/Y08b/thfE6Hwz4V0uG43KJb67uOLXT4NwB + eUjkEZ6fe7dDX7yfsJf8E+vBf7C/gT7D4ft/tWuagFfVNZnC/aL1wMYQ/wDLOIZO1F45J6k19dw3wvWz + GfPP3aaer7+S/Xsfzr43ePmXcF4aWCw3LWxs4+7TTuo32lUs9F2j8UvJXkuJ/wCCbP8AwS28MfsUeFv7 + S1LyfEPj3UolS81K4Tctqu0fuLcN/wAs+Tz3x7V9WJoVrub/AEW3LE7v9SvHt+lXLOIsfmAUrwAM4A7d + f5irgGDX7dgsvw+FoqjQglFeR/lrxBxLmme4+eaZrWdSrN3bfboklpFLolZLsZP9g2v/AD6Q/wDfhaP7 + Btf+fSH/AL8LWtRXV7OPZfceNzS7mT/YNr/z6Q/9+Fo/sG1/59If+/C1rUUezj2X3BzS7mT/AGDa/wDP + pD/34Wj+wbX/AJ9If+/C1rUUezj2X3BzS7mT/YNr/wA+kP8A34Wj+wbX/n0h/wC/C1rUUezj2X3BzS7m + T/YNr/z6Q/8AfhaP7Btf+fSH/vwta1NlkES7jxR7OPZfcHNLuZMmiWka5NrD/wB+Frhf2hPiz4L/AGfP + hhqXinxZd2ej6PpagvO1urO7twqRrg7pGPAU8dSeAa0v2iPjx4U/Z9+GWoeKPFurLpGjaamZJcZeRm4W + JB3dugH1J4Br8Bf+CjH/AAUa8Qft6+P47m5jXT/CelOzaJpCysRH83+ulX7ryMMEk9MYHGK+a4iz/D5b + R91J1HsrL732X57Ly/aPBvwczPjnMUlenhKbXtKmvryw7zfzUU03uk2/8FEv+Chutftz/EP7TJbtpPhC + w3DR9Ijb/UHdk3MpAG6SRMqR0G7C8Yr5pl5O7cG3nPGePzp9y+5uvQnsM/pxUVfhGNxdXE1nWrO8mf6y + 8L8M5fkOX08tyumqdKCsl+bbbbbe7bbbe7CiiiuU+iCiiigAooooAKKKKACiiigAooooAKKKKACiiigA + ooooAKKKKACiiigAooooAK7j9mT/AJOQ+H//AGMmm/8ApXFXD13H7Mn/ACch8P8A/sZNN/8ASuKt8L/G + h6r8zyc//wCRZiP+vc//AEln9SVp978qtd6q2n3vyq13r+n47H+Eq2KN/wD8fH4UUX//AB8fhRVAWrf/ + AFK/7op033D9Kbb/AOpX/dFOm+4fpQB+Yf8Awc0f8kL+Gf8A2HZ//RFfjXJ0X6V+yn/BzR/yQv4Z/wDY + dn/9EV+NcnRfpX4Pxx/yNZekf/SUf6v/AEUf+Td4X/HW/wDTjG0UUV8ef0iFFFFABRRRQAUUUUAFFFFA + BRRRQAUUUUAFFFFABRRRQAUUUUAFOTJ4Hf3xTatafbyM7GPLMFyoAyxPTgdz149M+lVFXdjOpNRi2xiJ + 5eS235Ru9T+GOc8/Svob9gb/AIJ7eNP25viQlhpMcum+F7Fx/a+vOoaK1Ug5VMf6yU/dCryM5O0ZZfQf + +CY//BLLXv20tfj1zWFm8P8AgPS5Xju9VQLu1Q7W3W1qW4J6BpDwFZx97bX7m/A34LeHfgP4J0/wx4V0 + m10XQ9JTy4La3Tanux7s56ljye9fecK8IyxjjisVdU18nL08vP7vL+RPHb6R2H4c9rkWQtVMa1aUt40r + rr0lPqo6qL+P+V8x+x/+yZ4R/Y/+G0Phfwfo8Om2isJLudnEtzqMwUDzpZByzdQAfu4IHGK9gFAOaK/Z + aNGFKCp0lyxWyWy9D/NnHZhisdiJ4vG1HUqTbcpSd22+rYUUUVqcgUUUUAFFFFABRRRQAUUVHczLbpub + oKAHSyCJdzcYrgf2iPj14T/Z7+GOoeKvFurR6To+mqDJMRlpGbhYox/FI3YexJ4Bpv7Q/wAfvCv7O3w0 + 1DxV4u1ZNK0bTEDSylcs7EgJGg/ikY8Be/JPANfgL/wUX/4KK+IP28/iMt5dL/ZvhPS2caLo6ysdnzk+ + dMv3Wkbrz0xxxivm+IuIqOWUdNaj2X6vsl+Oy8v2jwZ8Gsx46zK2tPB02vaVP/bIXWs381FWct0mv/BR + n/gox4g/b3+IyXlyjab4R0x3/sTR1kO2P5uJpl+68jAA7j0xgcYr5ruW3H6EjoP5jiln4LD0J6gZ9e3F + Q1+D47HVcVWlXru8n1P9ZOFuF8uyDLqWWZVTVOlTVlFL8X1bbu22223d6hRRRXGfSBVW60xrnVrW6+1X + Ua2qyKYEYCGfdjlxjJK44wR945zxi1RVRk07ozq0Y1I8s9rp9VqmmtvNLTZ7PQKKKKk0CiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAruP2ZP+TkPh/8A9jJpv/pXFXD13H7Mn/JyHw// + AOxk03/0rirfC/xoeq/M8nP/APkWYj/r3P8A9JZ/Ulafe/KrXeqtp978qtd6/p+Ox/hKtijf/wDHx+FF + F/8A8fH4UVQFq3/1K/7op033D9Kbb/6lf90U6b7h+lAH5h/8HNH/ACQv4Z/9h2f/ANEV+NcnRfpX7Kf8 + HNH/ACQv4Z/9h2f/ANEV+NcnRfpX4Pxx/wAjWXpH/wBJR/q/9FH/AJN3hf8AHW/9OMbRRRXx5/SIUUUU + AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABUkEJnfau3PucU2KJpm2qpY9cCrGnadNqM6wxRySPM + RHHt5LMSFCgfxMSeAOT2ppXdjKtWjTi5SaXqNtGaKTIZQeQSRuXGDwR79Pxr9Bf+CWX/AAR31H9omex8 + b/ESxvNM8ExlZbKzdwt1r7jkMxP+rg4xkcnGBXqf/BKr/gi9NqGoad8SPjBpXk7Asul+HJBjeRws9wPw + GEPJ5z2r9YdJ09LOFYoY0jhhUIiquxVAGMBf4QOwr9N4V4NdRLFY5e70i+vm/Lt3P4M8fPpMKm6nD3CU + 7z+GpXi7qPRxpPq+jnsteXX3jM+HXg2x8DaHaaXpWn2ul6XYQrDb2tvGIooUGflVR0HueT1NdImO1CDB + NOr9ZjFJWWx/A7cm3Kbbbd23q23u2wooopgFFFFABRRRQAUUUUAFFFR3EgiUMePwzQA6V1jQs3QVwH7Q + 37QHhT9nj4Xah4s8WatHpWh6an72XP7xmJAVIx1ZycAAU39oz49eFf2e/hZqXinxZqkel6TpqDfIybmk + djhI0X+KRjwB9SeAa/AX/gof/wAFC/EX7eHxLmup5pNL8GaW7Nomjh2ZQpb/AF0oHyvIxGSW6YAHGK+a + 4i4io5bRdneq9l+r7Jfjsu6/avBnwYzHjvMba08HTa9pV/HkhdNObVujUU1KXRNP+Ci3/BQ/xB+3X8TX + nuZJbHwfozuND0pGPl8sCZ5B/FK/UhvuY46mvm+dsjbxhenAz+nFJcnJH95eGJPJP8qir8Ix2OrYutKv + Xd5SP9Y+FuF8vyDLqWV5XTVOjTVopfi2923u2223q29wooorjPowooooAKKKKACiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK7j9mT/AJOQ+H//AGMmm/8ApXFXD13H7Mn/ACch + 8P8A/sZNN/8ASuKt8L/Gh6r8zyc//wCRZiP+vc//AEln9SVp978qtd6q2n3vyq13r+n47H+Eq2KN/wD8 + fH4UUX//AB8fhRVAWrf/AFK/7op033D9Kbb/AOpX/dFOm+4fpQB+Yf8Awc0f8kL+Gf8A2HZ//RFfjXJ0 + X6V+yn/BzR/yQv4Z/wDYdn/9EV+NcnRfpX4Pxx/yNZekf/SUf6v/AEUf+Td4X/HW/wDTjG0UUV8ef0iF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR3qS2ga4LKu3Kjdy23pXUfCP4P+JPjn42tfDfhTS7jW + NYvgRBbRHYzHB/j6KM4BZvlG4buDWlKlKpJQgrt6aHFj8dRwmHniK8lGME223ZJLVtt7JGV4O8Jaj4y8 + QWmmabZ3d9fXsqRwQWsfmTSsWA2ovcnkYPHc9K/Zv/glz/wR9svgNb6X46+KFhY6h4xZI5NP0UKJLXQS + V+Yvnh7jaSSegwAO9egf8Ey/+CTfh/8AY30lfEniC203V/iPqEHlz3ixlodIQ4P2a2B7Y5aTqWzt+XFf + athbmM/Nu7feOcfj3+p59a/X+F+DVhuXFY5Xluo9F118/wAj/Nnx4+klWz+VTIuGZOGF+GdVXUqvdR6x + pvq9HLvbRpYQtHJx93jrnn8+f6elXgcmgHJor9FP5CCiiigAooooAKKKKACiiigAoopk0ywJubtQAsjr + Gu5u1ee/tG/Hnwp8APhTqfizxZrC6Toulx5mn6yEkgKka/xSM2AB75PANP8A2i/jz4T/AGefhfqHizxZ + qsel6RpabpJWXezsSAsaL/FIzEAD6k8A1+AH/BRH/gob4j/bz+JUl5cTSad4P0qVl0TRhIWjHzZ82X+F + 5D1JPToOMV81xHxFRy2i0neo9l+r7Jfi9F3X7Z4M+C+YcdZiuZOngqb/AHlTvs+SGjvNrfdRTu+icn/B + RT/go54m/b5+IP22dm0nwbp8jJo+hiQnZGSD5sx+68hIySemcDjFfN11L53zc7ieScAnp2HFMuSrSHbn + g4+6F/EAcd6jr8IxuOrYurKvXd5Pdn+sXC/DOXZFl1PLMrpKnRpqyil97b3bb1bbbbvcKKKK4z6IKKKK + ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAruP2ZP+Tk + Ph//ANjJpv8A6VxVw9dx+zJ/ych8P/8AsZNN/wDSuKt8L/Gh6r8zyc//AORZiP8Ar3P/ANJZ/Ulafe/K + rXeqtp978qtd6/p+Ox/hKtijf/8AHx+FFF//AMfH4UVQFq3/ANSv+6KdN9w/Sm2/+pX/AHRTpvuH6UAf + mH/wc0f8kL+Gf/Ydn/8ARFfjXJ0X6V+yn/BzR/yQv4Z/9h2f/wBEV+NcnRfpX4Pxx/yNZekf/SUf6v8A + 0Uf+Td4X/HW/9OMbRRRXx5/SIUUUUAFFFFABRRRQAUUUUAFFFFABRRT4l3nH8zigBlSW6GV1VQzNuGAq + 7ievAH9Kc8LW6s3y/KMnnqPT+Ve5fsP/ALBvjj9uP4ix6P4ds2t9Jt5VTVtZnULbacnUk93bA4jXlj6K + rEdGFwtXEVVSoxcpN6JHi59n2ByjA1MxzGrGnSpq8pSdkl+bfZK7b0Sbdjkf2b/2W/Gn7UvxIsPDPgzR + 21a8vVxLLu/0Wxj53STP/AF7qOTwACWAP71/8E8/+CdHhH9hnwIttZpb6z4wuIk/tXXHi2yXD7TmOIfw + RLkgZ5bOTkkk9x+xv+x34N/Y0+G0Hh3wfpyws4EuoajMFa51KbGDJKw4JPOAOFHAyOT7FAgQ/LuAz3r9 + u4Z4TpZfH22I96r+EfTu/P7vP/Lfxw+kBjuM6ssty69HAxe20qttnPXRdVDZPWV5JcsFnBtZRtEaoAAo + OQPxq4OtFFfZH83xjbYKKKKCgooooAKKKKACiiigAoopk7rEu5u1ABM6xjc1efftE/H3wj+zx8L9S8U+ + LdWj0vR9LTfJIy7mkYkBY0X+KRmwAPqTwDR+0Z8fPCn7OXwq1Lxd4r1SPTdG0qPfLIyb2diQFjRf4pGY + gKPqTwDX4A/8FD/+Ch3iT9u/4kSXdw0mneDdPZho+jLIdiqTnzZf4XkYjJJ6cAcYr5riPiKlltF21qPZ + fq+yX47Luv2zwX8GMx46zJXvTwVN/vKn3Pkho7za62agrSe6Tf8A8FE/+ChviL9u74lSXU8kml+DNNlZ + NG0YOWjxuz50v8LyEgEk9OAOMV84TzeezMd24nLZULk9zgcUXE3nOWK7WIywAAXPsBxUNfhGOx1bF1pV + 67vJ7v8Ar8D/AFg4X4Yy/IcupZbldNU6VNWUUvvbe7berbbbd2wooorjPpAooooAKKKKACiiigAooooA + KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAruP2ZP+TkPh//ANjJpv8A + 6VxVw9dx+zJ/ych8P/8AsZNN/wDSuKt8L/Gh6r8zyc//AORZiP8Ar3P/ANJZ/Ulafe/KrXeqtp978qtd + 6/p+Ox/hKtijf/8AHx+FFF//AMfH4UVQFq3/ANSv+6KdN9w/Sm2/+pX/AHRTpvuH6UAfmH/wc0f8kL+G + f/Ydn/8ARFfjXJ0X6V+yn/BzR/yQv4Z/9h2f/wBEV+NcnRfpX4Pxx/yNZekf/SUf6v8A0Uf+Td4X/HW/ + 9OMbRRRXx5/SIUUUUAFFFFABRRRQAUUUUAFFFCjccYoABzU9rAxk24wxBK7jtBIB70lsWiUMQnz5A3HA + 4B6+3f8AKvvL/gln/wAEedV/axvbHxl44gu9G+H8MqyRqw23Wukc/KP4YTgDPevRy3La+NrKjh43l/Wr + 8j4zjjjrKeFssnmmb1FCnHbrKUukYx+1J9turdjz3/gnV/wS88Sft06xDdiG50Pwbayq+oa5MhV7gD78 + NsvQvxjLcDIPpX7r/s7fs+eGf2avh7p3hTwfpcOk6HpUYjjhQ/PI38Ukr9ZZG6lm5/DFb/wz+Huj/DTw + 5Z6PoOl2elaXp8Qit7e2XakSjIAx3+veuor904f4doZXTsveqPeX6Ly/Pftb/KLxc8ZM245xv71unhIS + bp0k9O3NN/am++qjdqOjd2pwSOfxp1FFfRn4+FFFFABRRRQAUUUUAFFFFABRRUc8oiAJOPwoAdLIIU3N + 2rgP2iPj34V/Z2+F2oeLPFmrR6Xo+lxl5JGGWlYkBY0H8TsxAA+p6A0z9oj9oLwp+zn8MdQ8W+LNXj0n + R9LiLyO335jkBY41/jdmIAH1PQGvwF/4KK/8FCPE37fPxHbULxn03wfpUjf2LoockCMtnzZU+60hOCWb + 6DjFfM8R8SUcspWWtRrRfq/L8X+K/bPBfwYzHjrMbu9PB02vaVO/9yGjvN9Xa0Vq9Wkz/gox/wAFEfEv + 7enxMa+upJdL8H6Q5XR9FRyyhS2TLKPutIxwST7AcAV833fLdt2TnChV/ADii4Pmsx24YHByQT+nFRBc + ivwnHY2tiqzr13eT3P8AWThnhnLciy6llmVUlTo01aMUrerfVtvVt3bd2227iUU7ZRsrjPoBtFO2UbKA + G0U7ZRsoAbRTtlGygBtFO2UbKAG0U7ZRsoAbRTtlGygBtFO2UbKAG0U7ZRsoAbRTtlGygBtFO2UbKAG0 + U7ZRsoAbRTtlGygBtFPjhaRwqgszHGB3pHVlHzAqQSuD2xT5Xa5PMr2G0UUUigooooAKKKKACu4/Zk/5 + OQ+H/wD2Mmm/+lcVcPXcfsyf8nIfD/8A7GTTf/SuKt8L/Gh6r8zyc/8A+RZiP+vc/wD0ln9SVp978qtd + 6q2n3vyq13r+n47H+Eq2KN//AMfH4UUX/wDx8fhRVAWrf/Ur/uinTfcP0ptv/qV/3RTpvuH6UAfmH/wc + 0f8AJC/hn/2HZ/8A0RX41ydF+lfsp/wc0f8AJC/hn/2HZ/8A0RX41ydF+lfg/HH/ACNZekf/AElH+r/0 + Uf8Ak3eF/wAdb/04xtFFFfHn9IhRRRQAUUUUAFFFFABRRUkEXmtgbc9txwPzoE3ZXYxev6Y9at2lvcLO + 4UNuVfnIGdoJHbufQd6n0XQL7WNVt7O1tZ7i8upBFBbIn76SQ8Kqr3J7evNfr7/wSu/4IvWXwzs9L+IX + xY0uG78U4Fxp+jSjfDYtyVeVf45cdEPyjBJr3MlyPEZjW9nRW276L5n5Z4o+K2TcFZb9dzGXNOV/Z018 + c32Svol1k9F62T8u/wCCVn/BFuTxy2l/EP4tWTW2jswutM0CQKsmoA8rLcA/8suA4Tvtr9e/C2kQ6NbQ + 2trDFa2tpGsUUUSBERR0+UfdOOMegFT6HaeRHtxtVfujduwPT/8AVwOgrT71+7ZRkuHy2h7Ggter6t+f + 6dj/ACh8RvEnOuNMzeY5tPRN8lNP3KafSK6vvJ3b7paCLjtS0UV6x8CFFFFABRRRQAUUUUAFFFFABRRR + QAVX1CPzVX+R6dR+vpViigDxv9pb9jD4f/tcHS4vHmjtrlvo7tNaQPdyLDHKfl3FVI3N9emPc15en/BF + v9nUDn4c2rc/eN/PluAP7/tX1pRXn1spwVap7WrSjKXdpM+oyzjbiHLsOsJgMdWpU1tGFScYr5RkkfJo + /wCCLP7OhH/JObP8b64/+Kpf+HLH7Ov/AETmx/8AA64/+Lr6xorL+wst/wCfEP8AwFHof8RM4v8A+hpi + P/B1T/5I+Tv+HLH7Ov8A0Tmx/wDA64/+Lo/4csfs6/8ARObH/wADrj/4uvrGil/YOW/8+If+AoP+ImcX + f9DTEf8Ag6p/8kfJ3/Dlj9nX/onNj/4HXH/xdH/Dlj9nX/onNj/4HXH/AMXX1jRR/YOW/wDPiH/gKD/i + JnF3/Q0xH/g6p/8AJHyd/wAOWP2df+ic2P8A4HXH/wAXR/w5Y/Z1/wCic2P/AIHXH/xdfWNFH9g5b/z4 + h/4Cg/4iZxd/0NMR/wCDqn/yR8nf8OWP2df+ic2P/gdcf/F0f8OWP2df+ic2P/gdcf8AxdfWNFH9g5b/ + AM+If+AoP+ImcXf9DTEf+Dqn/wAkfJ3/AA5Y/Z1/6JzY/wDgdcf/ABdH/Dlj9nX/AKJzY/8Agdcf/F19 + Y0Uf2Dlv/PiH/gKD/iJnF3/Q0xH/AIOqf/JHyd/w5Y/Z1/6JzY/+B1x/8XR/w5Y/Z1/6JzY/+B1x/wDF + 19Y0Uf2Dlv8Az4h/4Cg/4iZxd/0NMR/4Oqf/ACR8nf8ADlj9nX/onNj/AOB1x/8AF0f8OWP2df8AonNj + /wCB1x/8XX1jRR/YOW/8+If+AoP+ImcXf9DTEf8Ag6p/8kfJ3/Dlj9nX/onNj/4HXH/xdH/Dlj9nX/on + Nj/4HXH/AMXX1jRR/YOW/wDPiH/gKD/iJnF3/Q0xH/g6p/8AJHyd/wAOWP2df+ic2P8A4HXH/wAXR/w5 + Y/Z1/wCic2P/AIHXH/xdfWNFH9g5b/z4h/4Cg/4iZxd/0NMR/wCDqn/yR8nf8OWP2df+ic2P/gdcf/F0 + f8OWP2df+ic2P/gdcf8AxdfWNFH9g5b/AM+If+AoP+ImcXf9DTEf+Dqn/wAkfJ3/AA5Y/Z1/6JzY/wDg + dcf/ABdH/Dlj9nX/AKJzY/8Agdcf/F19Y0Uf2Dlv/PiH/gKD/iJnF3/Q0xH/AIOqf/JHyd/w5Y/Z1/6J + zY/+B1x/8XR/w5Y/Z1/6JzY/+B1x/wDF19Y0Uf2Dlv8Az4h/4Cg/4iZxd/0NMR/4Oqf/ACR8nf8ADlj9 + nX/onNj/AOB1x/8AF0f8OWP2df8AonNj/wCB1x/8XX1jRR/YOW/8+If+AoP+ImcXf9DTEf8Ag6p/8kfJ + c/8AwRi/Z2tRlfhxYsxyAPtkzA9ucv71+HX7cvgPRvhd+118R/Dfh+NLXR9D8QXtla26MzLCkcpXbyB0 + wfWv6dbj7n4Gv5m/+Cjv/J+vxk/7HLVP/SqSvg+PsBhcNhaTw9OMW5PZW6H9afRB4mzrN+Iscs0xlWso + 0VZTnKaT51r7zev+bPEz978KKKK/KT/QQKKKKACiiigAruP2ZP8Ak5D4f/8AYyab/wClcVcPXcfsyf8A + JyHw/wD+xk03/wBK4q3wv8aHqvzPJz//AJFmI/69z/8ASWf1JWn3vyq13qrafe/KrXev6fjsf4SrYo3/ + APx8fhRRf/8AHx+FFUBat/8AUr/uinTfcP0ptv8A6lf90U6b7h+lAH5h/wDBzR/yQv4Z/wDYdn/9EV+N + cnRfpX7Kf8HNH/JC/hn/ANh2f/0RX41ydF+lfg/HH/I1l6R/9JR/q/8ARR/5N3hf8db/ANOMbRRRXx5/ + SIUUUUAFFFFABRRUkEbTPtUZZuB9f85o3DYbFG0rbVrovhl8M9d+K/jC10Lw7pdxqmrag4ggt4UEjykg + jCqSMnv6AKSeAa3P2d/2cvFn7S/xN03wr4R0dtT1LUl83bISsMEXIMzsPuqp7+pUDJIB/d7/AIJ1f8E0 + fCf7D/hKGTbHrnja7gUajrjwBWDOMmOBW/1ca9Mj75yTgggfVcN8NYjMqnOvdhF6y/Ref4eZ+A+NXjnl + fBGEdBWq4uavCmnsv5pv7MV98to7Nrgv+CX/APwSK0X9k3SLPxR4ws9P1n4hyRIRIUWWHSQR/qYzk7n5 + BMg4zwOAK+5dPhdSPvLt6hiD/wDr+tGnLsGNq/gc1eFfuGX5dQwVFUMPGyX4+b7s/wAr+KuLM14kzGea + 5vVc6s38kukYraMV0S+etwHWiiiu4+dCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC + iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigCO4+5+Br+Zv/ + AIKO/wDJ+vxk/wCxy1T/ANKpK/pkuPufga/mb/4KO/8AJ+vxk/7HLVP/AEqkr838Sf8AdKP+J/kf2h9C + n/kosw/68r/0tHidFFFfj5/pAFFFFABRRRQAV3H7Mn/JyHw//wCxk03/ANK4q4eu4/Zk/wCTkPh//wBj + Jpv/AKVxVvhf40PVfmeTn/8AyLMR/wBe5/8ApLP6krT735Va71VtPvflVrvX9Px2P8JVsUb/AP4+Pwoo + v/8Aj4/CiqAtW/8AqV/3RTpvuH6U23/1K/7op033D9KAPzD/AODmj/khfwz/AOw7P/6Ir8a5Oi/Sv2U/ + 4OaP+SF/DP8A7Ds//oivxrk6L9K/B+OP+RrL0j/6Sj/V/wCij/ybvC/463/pxjaKKK+PP6RCiiigAooo + oAdECzcdc4Gema9m/Y1/Ye8dftq/E620HwpYf6LnzNQ1S5/489NhBAaR+564CjliewBI8dtI/NZh5nl8 + HJxnjBzxg9RxzxzzX19/wTK/4Ke6l+wz40Ol36nWPAutXJudUtxhntHZFRZrcYBVlUAOB8rIpx8wWvUy + inhZ4mCxknGF9bf1+K17H554l5lxFhcixFThejGpilH3VK/zcVazkt1F6N2T0Z+yX7D/AOw94Q/Yg+HE + Wh+G7Zn1C4AfU9UnXNxqUoGN7kcKB8wCjgD3JJ93tF2DAxx75/WuM+B/xn8NfHHwBpnibwrrVrrmiapC + DBcwuWBPcEH5lYZAIbkd+a7ZJ0J2g+1f0Xg6dCnRjHDJKFtLbW8j/GbPMZmOLzCtiM3cpYhyfO5/FzdU + 77W2tolaySSJKKKK6TywooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAI7j7n4Gv5m/wDgo7/y + fr8ZP+xy1T/0qkr+mS4+5+Br+Zv/AIKO/wDJ+vxk/wCxy1T/ANKpK/N/En/dKP8Aif5H9ofQp/5KLMP+ + vK/9LR4nRRRX4+f6QBRRRQAUUUUAFdx+zJ/ych8P/wDsZNN/9K4q4eu4/Zk/5OQ+H/8A2Mmm/wDpXFW+ + F/jQ9V+Z5Of/APIsxH/Xuf8A6Sz+pK0+9+VWu9VbT735Va71/T8dj/CVbFG//wCPj8KKL/8A4+PwoqgL + Vv8A6lf90U6b7h+lNt/9Sv8AuinTfcP0oA/MP/g5o/5IX8M/+w7P/wCiK/GuTov0r9lP+Dmj/khfwz/7 + Ds//AKIr8a5Oi/Svwfjj/kay9I/+ko/1f+ij/wAm7wv+Ot/6cY2iiivjz+kQooooAKKKKACrGnbfOw4+ + Vup544OCcc7fXtVeinGVncmpHmjyn0t+wH/wUL8WfsR/EuO40uVdS8N6g6PqukXLBba5IBBMYHEbc/KR + yX2A8Zr95P2Uv2q/Bv7WHw2tfFHhHUo7q1mAW5t3+W4sZucxSr/CwGOPTnpiv5iraYwh/ljZWUqRIu5e + QR+HXqOR2r1r9lT9sHxd+x/8VbPxJ4V1a6jWJUS7snH+jX8Q4McinhgOqufmBA9a+14Z4qqZfJUautJv + bqvNfm1s/U/ljxw+jtg+LFLNMqtTx0Vvoo1fKfaXRT1fRp9P6clmVnwpB+lPr5v/AGEf2+fBP7a/gZtQ + 0S8jt9c08Aaro8jYnsH77QeWiPUH1zX0Rb3KmRk7qQp7DOM8D8a/bMPiaWIpKtQlzRa3P8ys4yfHZVja + mX5lSlSrU3aUZJpp/P8ABq6a1TsWKKQZzS1seaFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ + AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAEdx9z + 8DX8zf8AwUd/5P1+Mn/Y5ap/6VSV/TJcfc/A1/M3/wAFHf8Ak/X4yf8AY5ap/wClUlfm/iT/ALpR/wAT + /I/tD6FP/JRZh/15X/paPE6KKK/Hz/SAKKKKACiiigAruP2ZP+TkPh//ANjJpv8A6VxVw9dx+zJ/ych8 + P/8AsZNN/wDSuKt8L/Gh6r8zyc//AORZiP8Ar3P/ANJZ/Ulafe/KrXeqtp978qtd6/p+Ox/hKtijf/8A + Hx+FFF//AMfH4UVQFq3/ANSv+6KdN9w/Sm2/+pX/AHRTpvuH6UAfmH/wc0f8kL+Gf/Ydn/8ARFfjXJ0X + 6V+yn/BzR/yQv4Z/9h2f/wBEV+NcnRfpX4Pxx/yNZekf/SUf6v8A0Uf+Td4X/HW/9OMbRRRXx5/SIUUU + UAFFFFABRRRQAU6Jgp+b7p4IB5YelNooA7z4H/HnxR8APiTpfijwpqjaPq2kupSeJSFaPuky9JE/2Txz + nqBX7sf8E1v+ConhX9uLQP7LuJV0fx/psYS80x2by7sDP76Bm5ZWwSQeRwPSv57YmUN8wyPSt7wL491b + 4d+KLDVtJ1Cax1DSZfPs7m3bypIXxkHPfp0/DvX0/D3ElfLamnvQe8e/p2f59T8H8ZfA7KuN8H7R2pYu + CtCql8+Wa+1F/et0+h/VVZ3SyMfVumRVqvzy/wCCWn/BZPSv2ofsPgfx89vovxCWILBchtltrjBegH/L + OU4BKd6+/wDTJ1PG4tn7pK4zX7jlmZUMdQWIoSuvxT7NdH/Suf5W8YcH5twxmc8pzik6dSO3VSXSUXtK + L799HZ6F6ikU8+9LXoHzIUUUUAFFFFABRRRQAUUUUAFFFFABQWxRVPVWaPy23fu1zuH5cnkDA/HrRuBa + Zxj/AOtUZu1B64/Cvmv9oT/gqH8If2VvH83hzxzrOsaHqSosix/2LczI6noyskZUg+xriH/4Lsfs1RHD + eNtRVupX/hH7wY/8hV5dTOsvpzcKlaCa6OSR9rl/hrxfj8PDF4LK8RUpzV4yjSqSi13TUWmvRn2X9rX+ + 9R9rX+9Xxmn/AAXh/ZqP/M7al/4ILz/41Tv+H8H7NP8A0O2pf+CC8/8AjVR/b2Wf9BFP/wADR2/8Qi46 + /wChPif/AARU/wDkT7K+1r/eo+1r/er41/4fwfs0/wDQ7al/4ILz/wCNUf8AD+D9mn/odtS/8EF5/wDG + qf8Ab2Wf9BFP/wADQf8AEIuOv+hPif8AwRU/+RPsr7Wv96j7Wv8Aer41/wCH8H7NP/Q7al/4ILz/AONU + f8P4P2af+h21L/wQXn/xqj+3ss/6CKf/AIGg/wCIRcdf9CfE/wDgip/8ifZX2tf71H2tf71fGv8Aw/g/ + Zp/6HbUv/BBef/GqP+H8H7NP/Q7al/4ILz/41R/b2Wf9BFP/AMDQf8Qi46/6E+J/8EVP/kT7K+1r/eo+ + 1r/er41/4fwfs0/9DtqX/ggvP/jVH/D+D9mn/odtS/8ABBef/GqP7eyz/oIp/wDgaD/iEXHX/QnxP/gi + p/8AIn2V9rX+9R9rX+9Xxr/w/g/Zp/6HbUv/AAQXn/xqj/h/B+zT/wBDtqX/AIILz/41R/b2Wf8AQRT/ + APA0H/EIuOv+hPif/BFT/wCRPsr7Wv8Aeo+1r/er41/4fwfs0/8AQ7al/wCCC8/+NUf8P4P2af8AodtS + /wDBBef/ABqj+3ss/wCgin/4Gg/4hFx1/wBCfE/+CKn/AMifZX2tf71H2tf71fGv/D+D9mn/AKHbUv8A + wQXn/wAao/4fwfs0/wDQ7al/4ILz/wCNUf29ln/QRT/8DQf8Qi46/wChPif/AARU/wDkT7K+1r/eo+1r + /er41/4fwfs0/wDQ7al/4ILz/wCNUf8AD+D9mn/odtS/8EF5/wDGqP7eyz/oIp/+BoP+IRcdf9CfE/8A + gip/8ifZX2tf71H2tf71fGv/AA/g/Zp/6HbUv/BBef8Axqj/AIfwfs0/9DtqX/ggvP8A41R/b2Wf9BFP + /wADQf8AEIuOv+hPif8AwRU/+RPsr7Wv96j7Wv8Aer41/wCH8H7NP/Q7al/4ILz/AONUf8P4P2af+h21 + L/wQXn/xqj+3ss/6CKf/AIGg/wCIRcdf9CfE/wDgip/8ifZX2tf71H2tf71fGv8Aw/g/Zp/6HbUv/BBe + f/GqP+H8H7NP/Q7al/4ILz/41R/b2Wf9BFP/AMDQf8Qi46/6E+J/8EVP/kT7K+1r/eo+1r/er41/4fwf + s0/9DtqX/ggvP/jVH/D+D9mn/odtS/8ABBef/GqP7eyz/oIp/wDgaD/iEXHX/QnxP/gip/8AIn2V9rX+ + 9R9rX+9Xxr/w/g/Zp/6HbUv/AAQXn/xqj/h/B+zT/wBDtqX/AIILz/41R/b2Wf8AQRT/APA0H/EIuOv+ + hPif/BFT/wCRPsae5Vo25zwa/mf/AOCjv/J+vxi/7HLVf/SqSv2Tvv8Aguv+zXcRceNNRbaDkHQb0dsd + oT7jt1r8Uv2zfiHpnxc/ap+IninRbg3ej+IPEl/qFjM0ZjMkEtw7xttYBhlWB5HevgOP8ywmJw1KOGqR + m1Jt8rT6H9Z/RH4L4gyTPsdVznA1sPGVJJOpTnBN86dk5JXdtbLoeX0Urfh+FJX5Yf32FFFFABRRRQAV + 3H7Mn/JyHw//AOxk03/0rirh67j9mT/k5D4f/wDYyab/AOlcVb4X+ND1X5nk5/8A8izEf9e5/wDpLP6k + rT735Va71VtPvflVrvX9Px2P8JVsUb//AI+Pwoov/wDj4/CiqAtW/wDqV/3RTpvuH6U23/1K/wC6KdN9 + w/SgD8w/+Dmj/khfwz/7Ds//AKIr8a5Oi/Sv2U/4OaP+SF/DP/sOz/8Aoivxrk6L9K/B+OP+RrL0j/6S + j/V/6KP/ACbvC/463/pxjaKKK+PP6RCiiigAooooAKKKKACiiigAoBwaKKALmn6lNp1zHdW0skF1asJY + ZY3aN4mHIZWXkEV+tv8AwSo/4LWL4qvNP+H/AMXdSt7fUpBFa6V4imBjjunAwsFxgYQkcCToTwe1fkNV + jT1Dz7WLKrEA4UMPxHP16HGM4JwK9jJc6xOXV1VoPTqujXZ/ofmXih4XZLxplksHmkLTSfJUSXPCT6p9 + V3i9Gul7Nf1d6fqMcz43f6wBhnk49/8A63GMYq7DKsp+U5/DFfiv/wAEtP8Ags5cfCO+0/wJ8Vb+5vPC + rqsel6vMS82iOWCiFzkmSHHzeY5LLnkkYr9jvBniWw8TaXbX2nXlreWN1GJYZreYTRSqedysOoJzX7xk + 2eYfMqPtaLs1unuv67/qf5PeJHhnnHBeZ/2fmkLxldwqJPlml1V9mvtResdOjTN6imCZT3B+lPr2D89C + iiigAooooAKKKKACiiigAqG8USJtI3BhyMZ4+lTUUAfPX7e/7Cvhf9uL4RXGg61D9j1KL59M1SD5p7KX + jDZ/iUkAMncHI5Ar+f79qP8AZd8Xfsm/FLUfCvi7TGtb61kPlXCr+7v4/wCGaJv4kPT2IIPOa/p/v4vN + i+7u4I4IBx9TXz9+3v8AsL+Gf24/hBPoOuRtZanAPM0vVYkDXNjMMbSCPvIcYZT1BBHIFfG8UcL08wg6 + 1Cyqr/ybyZ/RXgT474rgrGLL8xbqZfOWq3dJvecF/wClR6q7Wu/827RtEMN97GeetR16h+1N+zB4u/ZN + +Kmo+EfF2m/Zby3fdDPGMw30X8M0TfxKensQQec15pJG0Q+b736/jX4fiKE6NR0qitJOzR/qlk+bYTM8 + JTx2BqKpTqJOMou6aeq17kVFFFYnqBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR + RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV3H7Mn/JyHw//AOxk03/0rirh67j9mT/k5D4f/wDYyab/ + AOlcVb4X+ND1X5nk5/8A8izEf9e5/wDpLP6krT735Va71VtPvflVrvX9Px2P8JVsUb//AI+Pwoov/wDj + 4/CiqAtW/wDqV/3RTpvuH6U23/1K/wC6KdN9w/SgD8w/+Dmj/khfwz/7Ds//AKIr8a5Oi/Sv2U/4OaP+ + SF/DP/sOz/8Aoivxrk6L9K/B+OP+RrL0j/6Sj/V/6KP/ACbvC/463/pxjaKKK+PP6RCiiigAooooAKKK + KACiiigAooooAKKKKALFiFLPuJAKkcDOTg8ev4jpX25/wTW/4K4az+x1rNn4X8TPe+Ivh3cMsTQvMzXG + kPubMlqepjGc7TzgHbzXw3U1i/lSeZtVtoPXnGQRnGR616GW5hXwdZVqErNf1Z+R8dxrwTlXE+W1Mszi + mqlOS26xfSUXvGS6Nem17/1PfCX4meHfip4KsfEHhvVrPWtF1KMSW11bOGV16445BBOCDyDnPOa6yOZZ + X+U5xX86v/BPD/gpX4u/YU8XRx29xJrfg+8kU6lo9w7hMgfM8OSQkmBwP4sYr94P2ZP2lPCP7UHw2sfF + XhHVINQ069Qb1Vl821kIyY5VHKOM4Kn2Pev3Lh7iTD5lDlVo1FvH9V3X9dm/8pPF7wXzbgbG3qJ1MJN+ + 5Vt90Z/yzt2upWun0Xp1FRx3CMTtPfFSV9MfjYUUUUAFFFFABRRRQAUUUUAFQX8XmwH5d3GMcDI9Mmp6 + KAPnn9vH9hvw1+3D8H7jw7rkLWeqW4MmlarDGHuLCXHGMfeTgBl7jBHIFfgH+1X+y14t/ZI+KN94X8Xa + Z9juoWJt7lPmg1CL+GaJ/wCJTn8DkHnNf0+Xyl4fl/EDqw9BXgH7eH7DPhn9t34R3Hh3XImtdUXM2l6t + Cm65sJeMY9UyBuXuMelfG8UcKwzGn7XD2jVX4rsz+ifAfx2xfBOMjl+Yt1MvqP3o7uk3vOC/9Kj1V2td + /wCbRomhHzD5iM1HXqX7Uv7K3jD9kz4pX3hfxhpTWt5C5MU0fMN/H/DNE3dSMfQ5FeZS2rRHDZVuu09R + X4fiKE6NR0qis4uzP9VcpzbCZlhKeOwVRVKdRKUZRd001dbEVFFFYnpBRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXcfsyf8AJyHw/wD+xk03/wBK + 4q4eu4/Zk/5OQ+H/AP2Mmm/+lcVb4X+ND1X5nk5//wAizEf9e5/+ks/qStPvflVrvVW0+9+VWu9f0/HY + /wAJVsUb/wD4+Pwoov8A/j4/CiqAtW/+pX/dFOm+4fpTbf8A1K/7op033D9KAPzD/wCDmj/khfwz/wCw + 7P8A+iK/GuTov0r9lP8Ag5o/5IX8M/8AsOz/APoivxrk6L9K/B+OP+RrL0j/AOko/wBX/oo/8m7wv+Ot + /wCnGNooor48/pEKKKKACiiigAooooAKKKKACiiigAooooAKKKKAJLaQxtkfmCFYfQkHB969s/Y5/bn8 + b/sZfEmHWvCuo7bL5UvdLMKC11OIHlJOAQ2CSsi8hwnbNeH05doPzZx7DNdGHxVWhUVWk7SWzR4ueZDg + M2wlTBZjSjUpVFaUZK6a9P13W6s1c/pU/Yj/AG4vBn7avw5h17wzeeXdqFTUNJkH+kafJg5QgcMCQTvX + gg+ua91s7lXZl3Dd0YA5AP1/Kv5dv2fP2hPFP7NfxJ0/xZ4P1i50zWLNwW2k+Vcx8ho5FH3kZSwI69x3 + r94v+Ccv/BS/wj+3P4RhjWSHR/G9nEq6jo0rH7wXJeEn/WIeTnqOM9q/auGOLqeYRVDEe7V/9K9PPv8A + 8E/y/wDHT6PeO4NqyzTKeatgJPfVypdlPvHtPTs9dX9YUVXtrlJGxuXcwzjuPqKsV9sfzSFFFFABRRRQ + AUUUUAFFFFABUF8hePgE8HIAGSPTmp6KAPnf9uv9h3w1+2/8H7jw9rcDWeqRAzaZq0ahriwl7fN/EnHz + J34I5Ar8A/2rv2VvFn7IfxQvvCfi3TZLe7jfzLe5HMN/D0SVG75HX06HnNf0/Xys8Xy9cdB1I9BXgP7d + /wCw14Z/bd+EdxoOuw/ZtWX97pmqIgaawl7Eg/ejyBuXvx6V8dxRwvDMKftaCtVX4+TP6I8CfHbFcE4u + OAzFupgJv3o7um3vOC6/3o9dWtd/5sZEKN833mGabXqX7U/7LPjD9k/4oal4X8YabNaXlvIWguOPLv4+ + 0qEfwnj6dK8vMbY5Br8OxFCdGo6VRWadmj/VbKM2wmZ4SGOwVRTpzScZRd009Vr37jaKM0ViekFFFFAB + RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV3H7Mn/ACch + 8P8A/sZNN/8ASuKuHruP2ZP+TkPh/wD9jJpv/pXFW+F/jQ9V+Z5Of/8AIsxH/Xuf/pLP6krT735Va71V + tPvflVrvX9Px2P8ACVbFG/8A+Pj8KKL/AP4+PwoqgLVv/qV/3RTpvuH6U23/ANSv+6KdN9w/SgD8w/8A + g5o/5IX8M/8AsOz/APoivxrk6L9K/ZT/AIOaP+SF/DP/ALDs/wD6Ir8a5Oi/Svwfjj/kay9I/wDpKP8A + V/6KP/Ju8L/jrf8ApxjaKKK+PP6RCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAkgZQW3Kzb + htwDg1veAfiTrfwv8U6brWgancaXqmjyia2u4DsliYZP/AvTHeudpY22yKaunUcHeJy4zB0sRSlRrxUo + yTTTSaae6aejTP3d/wCCY/8AwV00P9rC0sfCfi+a20P4jRohMTPsh1pdh+aI/wDPY4yU9K+6NNu0cbfM + yWA2nGA3HUDsPb61/KVomt3GhX4vrGeW0vLVllgnhkaOeGRTlWRhyCD6c/hmv2D/AOCWn/BaLT/in/Yv + gP4saxHp/ipgLWw1hlKQao2CEimPRZumGPyOTj723P6/wtxkq9sLj3aXST69En5+fX13/wA4/Hr6NNXK + JVM/4VpueH1lUpJNumrXcoW1dNdVq4Kz1V3H9QAMUVl6JepIzKJPvn92GDDcB/vc9/6dQa0EuFZ9q49M + DtX6MfxotSSiiigYUUUUAFFFFABRRRQAVDfR+dFt+b5gRxwcfXtU1FAHz5+3f+w94X/bb+ENx4d121WH + U4xv03VIxuuLCQYw+f41yF3L349K/AL9qv8AZT8Xfsl/FC+8L+LtPltbm3k/cXG4eXqEX8Myk9cj8ulf + 09XyF4cBd2RgjO3j69q8I/bf/Yf8Lfts/Ci48P8AiC2a21KFC2matD81xp8pGAyn+Jem5e4AxyBXx3FH + C8Mwp+1oJKqv/JvJ/wBevl/RHgV464vgrFrA49upgKj1ju6Te84K/X7Ueu613/mx+xsPNP7vMK7z84z2 + Hb61DKmw4/u8V6p+1V+yv4q/ZJ+KGpeFfFlg0FzbsfsckDZjvIdyhbhG7xtjn0OQec15gLVi0xzGfIBY + nf15xkfnX4hiMPOlUdKas1uf6oZPnWEzPCwx2CqKdKaTjJO6aezT/prZ6leinypsOP7vFMrnPYCiiigA + ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAruP2ZP8Ak5D4f/8A + Yyab/wClcVcPXcfsyf8AJyHw/wD+xk03/wBK4q3wv8aHqvzPJz//AJFmI/69z/8ASWf1JWn3vyq13qra + fe/KrXev6fjsf4SrYo3/APx8fhRRf/8AHx+FFUBat/8AUr/uinTfcP0ptv8A6lf90U6b7h+lAH5h/wDB + zR/yQv4Z/wDYdn/9EV+NcnRfpX7Kf8HNH/JC/hn/ANh2f/0RX41ydF+lfg/HH/I1l6R/9JR/q/8ARR/5 + N3hf8db/ANOMbRRRXx5/SIUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVY09ttwPmZ + Ocbgm7Hcfjx+GKr0VUZWdyZx5o8p+oX/AAS+/wCC2LeC20j4d/F++ubnR2xBp3iKdwx04AELFct1aLgD + zfur/FhcsP148N6vBqVuLm3uILi3ukSaGWJw4mjZQVfI4YHPB7gd+p/lJt32McjORjpnn2Hc9ePQmvvb + /gl1/wAFe9Q/ZTvLPwP4ymk1j4fsQkExDyTaHnORED8zRDqUPA6iv0zhbjSVJRwuYNuPSXVeT7rz6eh/ + Cfj99GmGKdTiDhClarrKrRS0n1cqa6S7x2lvG0k1L92PNXPXNOrk/hf8Q9E+J3hmz1/QNUtdW0jV4EuL + O6tmDxyxn/aHU+o7dK6iOZCNwPDcV+sqUWk4u6Z/n/OnUpzdOrFxlFtNNWaa3TT2aejJKKKKZIUUUUAF + FFFABRRRQAVDeozR5UbiAflGMt7ZPSpqKAPAf23f2H/DX7bPwlutB8QW32XUY1L6ZqkSBrrTZTwCpH3l + 4G5T1GMcgV/P/wDtV/sr+Lf2QvifqPhXxdY+RcwsfsU8ZHk38W5Qs6MesbY/A5B5zX9PF8paBsKzccgd + SPSvB/24P2HPC/7a/wAKLjQdft2tdURC+l6rAq/atOlOACCf4em4dx7gV8fxPwvTzCm61FWqr8fJn9D+ + BfjpjOCsWsBjm54Co/eju6be84L/ANKjs917y1/mya3LCb5oyYwd53gHOe2O1QSnLfU5r1b9rL9lfxV+ + yD8UtQ8J+LrHyLqHP2OeLiG/i3AJOhbrG2Og6HOec15i9uxE3zRs0QO87wOc9sdq/D8Rh50ZunNWa3P9 + UcnzrB5nhYY7BVFOlNJxkndNPZp/01syrRTpTlvqc02uc9gKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAK7j9mT/k5D4f/APYyab/6VxVw9dx+zJ/ych8P/wDsZNN/9K4q + 3wv8aHqvzPJz/wD5FmI/69z/APSWf1JWn3vyq13qrafe/KrXev6fjsf4SrYo3/8Ax8fhRRf/APHx+FFU + Bat/9Sv+6KdN9w/Sm2/+pX/dFOm+4fpQB+Yf/BzR/wAkL+Gf/Ydn/wDRFfjXJ0X6V+yn/BzR/wAkL+Gf + /Ydn/wDRFfjXJ0X6V+D8cf8AI1l6R/8ASUf6v/RR/wCTd4X/AB1v/TjG0UUV8ef0iFFFFABRRRQAUUUU + AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABVjTlR5GDMittLJv6MQCccA4J6A9OeeCar0UIzq0+e + Dj3Pr7/gnp/wVC8RfsP+Lbe2kuZtc8B6q6f2ho7K3nWzY5mj4Cxt0OyMkN1OWyzfuh+z1+0J4T/aQ+H1 + j4s8I6xDq2j6ggYSRfehb+KOVequrZBBr+XW3k8t+Nuc8Z7e/Q177+wp+3p4q/Yf+KEeraLcy3mjyfLd + 6OVCW9+D13LgFSMkqRzvC9s195wxxfUwclQxPvU/xj5r/L7j+S/Hb6OWE4kpzzjIkoY6Ku1tGtbpKy0n + 2k/+3t+Zf0mxXEbt8p3A9OOKlGcmvE/2Mv2y/A/7Zvw4h8ReEtQjklwEvdOlKrd6dKByjoPxIYcMM9wa + 9oikUg4fP45Nfs2HxFKvTVWi+aL2aP8ANPMstxWXYqpgsdB06sG1KMlZpruv68rktFN3A980fLWxx3Q6 + im/LR8tAaDqKb8tHy0BoOopvy0fLQGg6oNQXdAflZsjBC9SPSpflo+WgNDwT9uH9h3wr+2r8J59B1+2F + vqUcbNpmrQqPtWmynABUn+HpuHcYr8AP2rv2V/FX7IPxSv8Awr4u094bmMn7FcRZ+z38W5QtwpP/ACzO + OnY59a/p0vQTF8ihmJwfXHfFeEft0fsSeF/2z/hNc6Dr8Ytb2NWbTtWj4n0+YgANn/nn/eHfA9K+P4n4 + WhmMPa0UlVX/AJN5M/obwL8dcXwXi1gMc3PAVH70d3Tb+3Bdv5o7Na7rX+bLydyTYaM+Vncd/U56j2qG + U5b6nNer/tV/sn+KP2Q/ifqXhfxZY/Z5LcFrK5R18nUItwCzITyQ2Og6fjXlEo2tz97nP1zX4fiKE6M3 + TqKzW5/qpkucYTNMJDHYGoqlKaTjKLummujW/wCmzG0UUVznrBRRRQAUUUUAFFFFABRRRQAUUUUAFFFF + ABRRRQAUUUUAFFFFABRRRQAUUUUAFdx+zJ/ych8P/wDsZNN/9K4q4eu4/Zk/5OQ+H/8A2Mmm/wDpXFW+ + F/jQ9V+Z5Of/APIsxH/Xuf8A6Sz+pK0+9+VWu9VbT735Va71/T8dj/CVbFG//wCPj8KKL/8A4+PwoqgL + Vv8A6lf90U6b7h+lNt/9Sv8AuinTfcP0oA/MP/g5o/5IX8M/+w7P/wCiK/GuTov0r9lP+Dmj/khfwz/7 + Ds//AKIr8a5Oi/Svwfjj/kay9I/+ko/1f+ij/wAm7wv+Ot/6cY2iiivjz+kQooooAKKKKACiiigAoooo + AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACprMlZDiQRcE7jn0PHHrUNFBMo8ysegfBn9o/xl+zz + 4mm1vwP4i1HwrqEkHkl7OXGVwPvKwKtnPGenPrXqg/4K2/tHQSf8la8QL/wCEfoIyK+a6K7qOY4mlHkp + zcV2TaX4HzGY8EcP5hXeJx+Co1qj05p0oTdlsryTenS59L/8Pc/2jv8Aormuf98Rf/GqP+Huf7R3/RXN + c/74i/8AjVfNFFaf2vjP+fsv/An/AJnnf8Qx4S/6FmG/8J6P/wAgfS//AA9z/aO/6K5rn/fEX/xqj/h7 + n+0d/wBFc1z/AL4i/wDjVfNFFH9r4z/n7L/wJ/5h/wAQx4R/6FmG/wDCej/8rPpf/h7n+0d/0VzXP++I + v/jVH/D3P9o7/ormuf8AfEX/AMar5ooo/tfGf8/Zf+BP/MP+IY8I/wDQsw3/AIT0f/lZ9L/8Pc/2jv8A + ormuf98Rf/GqP+Huf7R3/RXNc/74i/8AjVfNFFH9r4z/AJ+y/wDAn/mH/EMeEf8AoWYb/wAJ6P8A8rPp + f/h7n+0d/wBFc1z/AL4i/wDjVH/D3P8AaO/6K5rn/fEX/wAar5ooo/tfGf8AP2X/AIE/8w/4hjwj/wBC + zDf+E9H/AOVn0v8A8Pc/2jv+iua5/wB8Rf8Axqkf/grd+0ZKpDfFzXSuCcCOI7vb/VV800Uf2xjP+fsv + /An/AJjXhlwktf7Mw3/gij/8gesfHT9sz4kftNaJaW/jrxbeeI109jLBHeww7o2OB8hWLI6c5I6CvKpW + 3H2U4GQcgfXv+AFMorjrVp1Zc1Rtvu3f8z6XK8lwWW0Vh8vpRpU021GEYwim97RiktXq9AooorE9QKKK + KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAruP2ZP8Ak5D4f/8AYyab/wCl + cVcPXcfsyf8AJyHw/wD+xk03/wBK4q3wv8aHqvzPJz//AJFmI/69z/8ASWf1JWn3vyq13qrafe/KrXev + 6fjsf4SrYo3/APx8fhRRf/8AHx+FFUBat/8AUr/uinTfcP0ptv8A6lf90U6b7h+lAH5h/wDBzR/yQv4Z + /wDYdn/9EV+NcnRfpX7Kf8HNH/JC/hn/ANh2f/0RX41ydF+lfg/HH/I1l6R/9JR/q/8ARR/5N3hf8db/ + ANOMbRRRXx5/SIUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU + UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU + UUAFFFFABRRRQAUUUUAFFFFABXcfsyf8nIfD/wD7GTTf/SuKuHruP2ZP+TkPh/8A9jJpv/pXFW+F/jQ9 + V+Z5Of8A/IsxH/Xuf/pLP6krT735Va71VtPvflVrvX9Px2P8JVsUb/8A4+Pwoov/APj4/CiqAtW/+pX/ + AHRTpvuH6U23/wBSv+6KdN9w/SgD8w/+Dmj/AJIX8M/+w7P/AOiK/GuTov0r9lP+Dmj/AJIX8M/+w7P/ + AOiK/GuTov0r8H44/wCRrL0j/wCko/1f+ij/AMm7wv8Ajrf+nGNooor48/pEKKKKACiiigAooooAKKKK + ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK + ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAruP2ZP+Tk + Ph//ANjJpv8A6VxVw9dx+zJ/ych8P/8AsZNN/wDSuKt8L/Gh6r8zyc//AORZiP8Ar3P/ANJZ/Ulafe/K + rXeqtp978qtd6/p+Ox/hKtijf/8AHx+FFF//AMfH4UVQFq3/ANSv+6KdN9w/Sm2/+pX/AHRTpvuH6UAf + mH/wc0f8kL+Gf/Ydn/8ARFfjXJ0X6V+yn/BzR/yQv4Z/9h2f/wBEV+NcnRfpX4Pxx/yNZekf/SUf6v8A + 0Uf+Td4X/HW/9OMbRRRXx5/SIUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXcfsyf8AJyHw/wD+xk03/wBK4q4eu4/Zk/5OQ+H/AP2M + mm/+lcVb4X+ND1X5nk5//wAizEf9e5/+ks/qStPvflVrvVW0+9+VWu9f0/HY/wAJVsUb/wD4+Pwoov8A + /j4/CiqAtW/+pX/dFOm+4fpTbf8A1K/7op033D9KAPzD/wCDmj/khfwz/wCw7P8A+iK/GuTov0r9lP8A + g5o/5IX8M/8AsOz/APoivxrk6L9K/B+OP+RrL0j/AOko/wBX/oo/8m7wv+Ot/wCnGNooor48/pEKKKKA + CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA + CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA + CiiigAruP2ZP+TkPh/8A9jJpv/pXFXD13H7Mn/JyHw//AOxk03/0rirfC/xoeq/M8nP/APkWYj/r3P8A + 9JZ/Ulafe/KrXeqtp978qtd6/p+Ox/hKtijf/wDHx+FFF/8A8fH4UVQFq3/1K/7op033D9Kbb/6lf90U + 6b7h+lAH5h/8HNH/ACQv4Z/9h2f/ANEV+NcnRfpX7Kf8HNH/ACQv4Z/9h2f/ANEV+NcnRfpX4Pxx/wAj + WXpH/wBJR/q/9FH/AJN3hf8AHW/9OMbRRRXx5/SIUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF + FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF + FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXcfsyf8nIfD//ALGTTf8A0rirh67j + 9mT/AJOQ+H//AGMmm/8ApXFW+F/jQ9V+Z5Of/wDIsxH/AF7n/wCks/qStPvflVrvVW0+9+VWu9f0/HY/ + wlWxRv8A/j4/Cii//wCPj8KKoC1b/wCpX/dFOm+4fpTbf/Ur/uinTfcP0oA/MP8A4OaP+SF/DP8A7Ds/ + /oivxrk6L9K/ZT/g5o/5IX8M/wDsOz/+iK/GuTov0r8H44/5GsvSP/pKP9X/AKKP/Ju8L/jrf+nGNooo + r48/pEKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig + AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig + AooooAKKKKACiiigAruP2ZP+TkPh/wD9jJpv/pXFXD13H7Mn/JyHw/8A+xk03/0rirfC/wAaHqvzPJz/ + AP5FmI/69z/9JZ/Ulafe/KrXeqtp978qtd6/p+Ox/hKtijf/APHx+FFF/wD8fH4UVQFq3/1K/wC6KdN9 + w/Sm2/8AqV/3RTpvuH6UAfmH/wAHNH/JC/hn/wBh2f8A9EV+NcnRfpX7Kf8ABzR/yQv4Z/8AYdn/APRF + fjXJ0X6V+D8cf8jWXpH/ANJR/q/9FH/k3eF/x1v/AE4xtFFFfHn9IhRRRQAUUUUAFFFFABRRRQAUUUUA + FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA + FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFdx+zJ/ych8P/wDs + ZNN/9K4q4eu4/Zk/5OQ+H/8A2Mmm/wDpXFW+F/jQ9V+Z5Of/APIsxH/Xuf8A6Sz+pK0+9+VWu9VbT735 + Va71/T8dj/CVbFG//wCPj8KKL/8A4+PwoqgLVv8A6lf90Us+fLb6Ulv/AKlf90UXQ3Jj1zQB+Yf/AAcy + yB/gd8M8dtdn/wDRFfjZ/wAs1+lftz/wcD/A3xf8c/hF8PrLwh4c1TxFdWGrTTXEVlCZGiTyCMnHuP0N + flh/w7w+OX/RKvGnof8AiWtycdf1Ffh/G2FrTzWcowbVo7J9l/kf6g/Rf4oyjBcA4bD4zFUqc1Or7sqk + Iuzm2nZtP07nilFe1/8ADvH45f8ARK/Gn/gsej/h3j8cv+iV+NP/AAWPXyP1HEfyS+5n9Df68cPf9B9H + /wAG0/8A5I8Uor2v/h3j8cv+iV+NP/BY9H/DvH45f9Er8af+Cx6PqOI/kl9zD/Xjh7/oPo/+Daf/AMke + KUV7X/w7x+OX/RK/Gn/gsej/AId4/HL/AKJX40/8Fj0fUcR/JL7mH+vHD3/QfR/8G0//AJI8Uor2v/h3 + j8cv+iV+NP8AwWPR/wAO8fjl/wBEr8af+Cx6PqOI/kl9zD/Xjh7/AKD6P/g2n/8AJHilFe1/8O8fjl/0 + Svxp/wCCx6P+HePxy/6JX40/8Fj0fUcR/JL7mH+vHD3/AEH0f/BtP/5I8Uor2v8A4d4/HL/olfjT/wAF + j0f8O8fjl/0Svxp/4LHo+o4j+SX3MP8AXjh7/oPo/wDg2n/8keKUV7X/AMO8fjl/0Svxp/4LHo/4d4/H + L/olfjT/AMFj0fUcR/JL7mH+vHD3/QfR/wDBtP8A+SPFKK9r/wCHePxy/wCiV+NP/BY9H/DvH45f9Er8 + af8Agsej6jiP5Jfcw/144e/6D6P/AINp/wDyR4pRXtf/AA7x+OX/AESvxp/4LHo/4d4/HL/olfjT/wAF + j0fUcR/JL7mH+vHD3/QfR/8ABtP/AOSPFKK9r/4d4/HL/olfjT/wWPR/w7x+OX/RK/Gn/gsej6jiP5Jf + cw/144e/6D6P/g2n/wDJHilFe1/8O8fjl/0Svxp/4LHo/wCHePxy/wCiV+NP/BY9H1HEfyS+5h/rxw9/ + 0H0f/BtP/wCSPFKK9r/4d4/HL/olfjT/AMFj0f8ADvH45f8ARK/Gn/gsej6jiP5Jfcw/144e/wCg+j/4 + Np//ACR4pRXtf/DvH45f9Er8af8Agsej/h3j8cv+iV+NP/BY9H1HEfyS+5h/rxw9/wBB9H/wbT/+SPFK + K9r/AOHePxy/6JX40/8ABY9H/DvH45f9Er8af+Cx6PqOI/kl9zD/AF44e/6D6P8A4Np//JHilFe1/wDD + vH45f9Er8af+Cx6P+HePxy/6JX40/wDBY9H1HEfyS+5h/rxw9/0H0f8AwbT/APkjxSiva/8Ah3j8cv8A + olfjT/wWPR/w7x+OX/RK/Gn/AILHo+o4j+SX3MP9eOHv+g+j/wCDaf8A8keKUV7X/wAO8fjl/wBEr8af + +Cx6P+HePxy/6JX40/8ABY9H1HEfyS+5h/rxw9/0H0f/AAbT/wDkjxSiva/+HePxy/6JX40/8Fj0f8O8 + fjl/0Svxp/4LHo+o4j+SX3MP9eOHv+g+j/4Np/8AyR4pRXtf/DvH45f9Er8af+Cx6P8Ah3j8cv8Aolfj + T/wWPR9RxH8kvuYf68cPf9B9H/wbT/8AkjxSiva/+HePxy/6JX40/wDBY9H/AA7x+OX/AESvxp/4LHo+ + o4j+SX3MP9eOHv8AoPo/+Daf/wAkeKUV7X/w7x+OX/RK/Gn/AILHo/4d4/HL/olfjT/wWPR9RxH8kvuY + f68cPf8AQfR/8G0//kjxSiva/wDh3j8cv+iV+NP/AAWPR/w7x+OX/RK/Gn/gsej6jiP5Jfcw/wBeOHv+ + g+j/AODaf/yR4pRXtf8Aw7x+OX/RK/Gn/gsej/h3j8cv+iV+NP8AwWPR9RxH8kvuYf68cPf9B9H/AMG0 + /wD5I8Uor2v/AId4/HL/AKJX40/8Fj0f8O8fjl/0Svxp/wCCx6PqOI/kl9zD/Xjh7/oPo/8Ag2n/APJH + ilFe1/8ADvH45f8ARK/Gn/gsej/h3j8cv+iV+NP/AAWPR9RxH8kvuYf68cPf9B9H/wAG0/8A5I8Uor2v + /h3j8cv+iV+NP/BY9H/DvH45f9Er8af+Cx6PqOI/kl9zD/Xjh7/oPo/+Daf/AMkeKUV7X/w7x+OX/RK/ + Gn/gsej/AId4/HL/AKJX40/8Fj0fUcR/JL7mH+vHD3/QfR/8G0//AJI8Uor2v/h3j8cv+iV+NP8AwWPR + /wAO8fjl/wBEr8af+Cx6PqOI/kl9zD/Xjh7/AKD6P/g2n/8AJHilFe1/8O8fjl/0Svxp/wCCx6P+HePx + y/6JX40/8Fj0fUcR/JL7mH+vHD3/AEH0f/BtP/5I8Uor2v8A4d4/HL/olfjT/wAFj0f8O8fjl/0Svxp/ + 4LHo+o4j+SX3MP8AXjh7/oPo/wDg2n/8keKUV7X/AMO8fjl/0Svxp/4LHo/4d4/HL/olfjT/AMFj0fUc + R/JL7mH+vHD3/QfR/wDBtP8A+SPFKK9r/wCHePxy/wCiV+NP/BY9H/DvH45f9Er8af8Agsej6jiP5Jfc + w/144e/6D6P/AINp/wDyR4pRXtf/AA7x+OX/AESvxp/4LHo/4d4/HL/olfjT/wAFj0fUcR/JL7mH+vHD + 3/QfR/8ABtP/AOSPFK7n9mL/AJOS+H//AGMmm/8ApXFXZf8ADvH45f8ARK/Gn/gseut+Af7Bfxm8N/HL + wXqF/wDDPxda2djr1jPNNJp7KsSLcIxYn0GK6MLgcR7aHuS3XR9zy88424fll2IjHHUW3Centaf8r/vH + 9GNp/rfwH8qt96z9KlWaRmXuRnGRz16HvzV8dvpX9Kx0Vj/EtMpX/wDx8fhRRf8A/Hx+FFMZat/9Sv8A + uii4TemKbA4jREPHHFTUAU5YZJZM7OnvTfIkP/LPP/AqvUUNJ6k8pR+zyf8APP8A8eo+zyf88/8Ax6r1 + FLlQcv8AVkUfs8n/ADz/APHqPs8n/PP/AMeq9RRyoOX+rIo/Z5P+ef8A49R9nk/55/8Aj1XqKOVBy/1Z + FH7PJ/zz/wDHqPs8n/PP/wAeq9RRyoOX+rIo/Z5P+ef/AI9R9nk/55/+PVeoo5UHL/VkUfs8n/PP/wAe + o+zyf88//HqvUUcqDl/qyKP2eT/nn/49R9nk/wCef/j1XqKOVBy/1ZFH7PJ/zz/8eo+zyf8APP8A8eq9 + RRyoOX+rIo/Z5P8Ann/49R9nk/55/wDj1XqKOVBy/wBWRR+zyf8APP8A8eo+zyf88/8Ax6r1FHKg5f6s + ij9nk/55/wDj1H2eT/nn/wCPVeoo5UHL/VkUfs8n/PP/AMeo+zyf88//AB6r1FHKg5f6sij9nk/55/8A + j1H2eT/nn/49V6ijlQcv9WRR+zyf88//AB6j7PJ/zz/8eq9RRyoOX+rIo/Z5P+ef/j1H2eT/AJ5/+PVe + oo5UHL/VkUfs8n/PP/x6j7PJ/wA8/wDx6r1FHKg5f6sij9nk/wCef/j1H2eT/nn/AOPVeoo5UHL/AFZF + H7PJ/wA8/wDx6j7PJ/zz/wDHqvUUcqDl/qyKP2eT/nn/AOPUfZ5P+ef/AI9V6ijlQcv9WRR+zyf88/8A + x6j7PJ/zz/8AHqvUUcqDl/qyKP2eT/nn/wCPUfZ5P+ef/j1XqKOVBy/1ZFH7PJ/zz/8AHqPs8n/PP/x6 + r1FHKg5f6sij9nk/55/+PUfZ5P8Ann/49V6ijlQcv9WRR+zyf88//HqPs8n/ADz/APHqvUUcqDl/qyKP + 2eT/AJ5/+PUfZ5P+ef8A49V6ijlQcv8AVkUfs8n/ADz/APHqPs8n/PP/AMeq9RRyoOX+rIo/Z5P+ef8A + 49R9nk/55/8Aj1XqKOVBy/1ZFH7PJ/zz/wDHqPs8n/PP/wAeq9RRyoOX+rIo/Z5P+ef/AI9R9nk/55/+ + PVeoo5UHL/VkUfs8n/PP/wAeo+zyf88//HqvUUcqDl/qyKP2eT/nn/49R9nk/wCef/j1XqKOVBy/1ZFH + 7PJ/zz/8eo+zyf8APP8A8eq9RRyoOX+rIo/Z5P8Ann/49R9nk/55/wDj1XqKOVBy/wBWRR+zyf8APP8A + 8eo8h+6D6FutXqKLIOX+rIqwwENuO5cdic1YXk06myusa5amEY2Kd/8A8fH4UUt5G0koZfu4FFBQ9SYi + cE8k9ackzEmiigB3mtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5 + rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5 + rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5 + rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5 + rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtR5rUUUAHmtTXfcy/WiigBsUBIb95J1P8VFFFAH/9k= + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAUDBAQEAwUEBAQFBQUGBwwIBwcHBw8LCwkMEQ8SEhEPERET + FhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/2wBDAQUFBQcGBw4ICA4eFBEUHh4eHh4eHh4eHh4e + Hh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh7/wgARCAJUAlQDAREAAhEBAxEB/8QA + HAABAAIDAQEBAAAAAAAAAAAAAAIHAQQGCAUD/8QAGwEBAAIDAQEAAAAAAAAAAAAAAAUGAQIEBwP/2gAM + AwEAAhADEAAAAbkMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwYJABgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAyIkgfC+Ehz3PMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACedO57azLOYkgcDwWirYy9 + gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADa35/Qs95JnKJIHA8Foq2MvYAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAA2t+f0LPeSZyiSBwPBaKtjL2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANrfn9Cz3kmcokg + cDwWirYy9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADa35/Qs95JnKJIHA8Foq2MvYAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAA2t+f0LPeSZyiSBwPBaKtjL2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANrfn9 + Cz3kmcokgcDwWirYy9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADa35/Qs95JnKJIHA8Foq2MvYAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA2t+f0LPeSZyiSBwPBaKtjL2AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAANrfn9Cz3kmcokgcDwWirYy9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADa35/Qs95JnKJIHA8Foq + 2MvYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2t+f0LPeSZyiSBwPBaKtjL2AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAANrfn9Cz3kmcokgcDwWirYy9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADa35/Qs95Jn + KJIHA8Foq2MvYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2t+f0LPeSZyiSBwPBaKtjL2AAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAANrfn9Cz3kmcokgcDwWirYy9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADa + 35/Qs95JnKJIHA8Foq2MvYAAAAAAAAAAAAMSziLYAAAAAZYGMZAAAAAAAAAAAAG1vz+hZ7yTOUSQOB4L + RVsZewAAAAAAAAAAABLPztSUoPa9leyAAAAAfnjaqIu9cfyWXGNgAAAAAAAAAAANrfn9Cz3kmcokgcDw + WirYy9gAAAAAAAAAAAAT2+drSlA7bsr+QAAAAGPzxmtI65cBwW+OMmQAAAAAAAAAANrfn9Cz3kmcokgc + DwWirYy9gAAAAAAAAAAAACe3ztaUoHbdlfyAAAAAYw4Dis9ZRl4hjcyAAAAAAAAAANrfn9Cz3kmcokgc + DwWirYy9gAAAAAAAAAAAAAT2+dqylA7fsr+QAAAADByPJN1NFega+vQAAAAAAAAAANrfn9Cz3kmcokgc + DwWirYy9gAAAAAAAAAAAAACe3ztWUoHb9lfyAAAAAYY5znk6gifRdL59ZkAAAAAAAAAbW/P6FnvJM5RJ + A4HgtFWxl7AAAAAAAAAAAAAAAnnS1JWgdx2V7IAAAABjGPkfLtpyI9E+V8pIyAAAAAAAABtb8/oWe8kz + lEkDgeC0VbGXsAAAAAAAAAAAAAAAT2+dqylC7fsruQAAAAAfP0+1QRHoXPc80ZAAAAAAAAG1vz+hZ7yT + OUSQOB4LRVsZewAAAAAAAAAAAAAAAJ5+dqStC7jsruQAAAAAauu1Sxd95TkseMZAAAAAAAA2t+f0LPeS + ZyiSBwPBaKtjL2AAAAAAAAAAAAAAAAJ5+dqStC7jsruQAAAAAx+WM1dGXfhuK1YxsAAAAAAANrfn9Cz3 + kmcokgcDwWirYy9gAAAAAAAAAAAAAAAATzpakrQe47K7kAAAAAESvI+2VtHXXGM4ZAAAAAAG1vz+hZ7y + TOUSQOB4LRVsZewAAAAAAAAAAAAAAAABPOlqytC7fsreWQAAAABhjiuOw1XF3z8dfuAAAAAANrfn9Cz3 + kmcokgcDwWirYy9gAABnDGQAAAAAAAAAAAABPPztWUoXb9tcyyAAAAAGMcxzzFQRPoWrp0mQAAAABtb8 + /oWe8kzlEkDgeC0VbGXsAABnFkSFK6XoiAAAAAAAAAAAAAAyY16Doi55AAAAAAYxj4fykKeiPRfm/LuM + gAAAAbW/P6FnvJM5RJA4HgtFWxl7AAAFuy3nvZ9leAAAAAAAAAAAAAAAAAAAAAAMfL+fVT8R6J8T4ymM + bAAAADa35/Qs95JnKJIHA8Foq2MvYAAAt2W897PsrwAAAAAAAAAAAAAAAAAAAAAAGpp9Kii79y/JYDIA + AAG1vz+hZ7yTOUSQOB4LRVsZewAABbst572fZXgAAAAAAAAAAAAAAAAAAAAAAB+GFWRl54ritOMZAAAG + 1vz+hZ7yTOUSQOB4LRVsZewAABbst572fZXgAAAAAAAAAAAAAAAAAAAAAAAIMVvHW+u4+54xsAABtb8/ + oWe8kzlEkDgeC0VbGXsAAAW7Lee9n2V4AAAAAAAAAAAAAAAAAAAAAAADDHIck5UsV6B+OvQAABtb8/oW + e8kzlEkDgeC0VbGXsAAAW7Lee9n2V4AAAAAAAAAAAAAAAAAAAAAAAYOC4LJWMdefz1+wAAA2t+f0LPeS + ZyiSBwPBaKtjL2AAALdlvPez7K8AAAAAAAAAAAAAAAAAAAAAAB+ZWcbcuB4bbHX6AAAAbW/P6FnvJM5R + JA4HgtFWxl7AAAFuS3nvZ9leAAAAAAAAAAAAAAyAAAAAAAAfjrtU8XeuO5LLjGwAAAA2t+f0LPeSZyiS + BwPBaKtjL2AAALCkKf0vTDAAAAAAAAAAAAADGGWPvdETt7aAAAAAADS0+tQRPoPOc85jGQAAAANrfn9C + z3kmcokgcDwWirYy9gAAAAAAAAAAAAAAAAAxnOO+76hZ0jTZ5AAAAADB8v59VOQ/ovx/jKAAAAAAbW/P + 6FnvJM5RJA4HgtFWxl7AAAAAAAAAAAAAAAAAGWvfSFQs6Rpk85AAAAAGD4HwkKfifRfn/LuAAAAAAG1v + z+hZ7yTOUSQOB4LRVsZewAAAAAAAAAAAAAAAAMsd/IU6zZGmzzkAAAAAYxjlOaaqWK9B1dOkAAAAAADa + 35/Qs95JnKJIHA8Foq2MvYAAAAAAAAAAAAAAAAy17+QqFmyNMnnIAAAAAwxw/DY6tjb3+Wv2AAAAAAAG + 1vz+hZ7yTOUSQOB4LRVsZewAAAAAAAAAAAAAAAGcWB306zJGm/pnIAAAAAgxXEdb67j7jHH0AAAAAAAA + 2t+f0LPeSZyiSBwPBaKtjL2AAAAAAAAAAAAAAAMte/kKfZsjTZ5yAAAAAPyxmqou88VxWjDIAAAAAAAA + 2t+f0LPeSZyiSBwPBaKtjL2AAAAAAAAAAAAAAM5wY7/vp9myNOnkAAAAANPT6VFFX/meaexjYAAAAAAA + ADa35/Qs95JnKJIHA8Foq2MvYAAAAAAAAAAAAAGc4NbB76fZcjT55AAAAAYPm/Ppp6J9D+HzyxkAAAAA + AAAAbW/P6FnvJM5RJA4HgtFWxl7AAAAAAAAAAAAAGc4MWD306y5GnzyAAAAAwx8P4yNPxHofzPlIAAAA + AAAAAADa35/Qs95JnKJIHA8Foq2MvYAAAAAAAAAAAAGc4NbB76fZclT5gAAAAGGOY5paoon0PU06wAAA + AAAAAAANrfn9Cz3kmcokgcDwWirYy9gAAAAAAAAAAADOcGtg99QsuSp0wAAAAGInGcdhqyMvWvp0gAAA + AAAAAAADa35/Qs95JnKJIHA8Foq2MvYAAAAAAAAAAAAznWwJCnWZI06bIAAAAMRZr2PtNax12jj6AAAA + AAAAAAAAbW/P6FnvJM5RJA4HgtFWxl7AAAAAAAAAAAAE8/P7X2jcsAAAAAYZ/PG3yPlIxxuAAAAAAAAA + AAANrfn9Cz3kmcokgcDwWirYy9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADa35/Qs95JnKJIHA8Foq2 + MvYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2t+f0LPeSZyiSBwPBaKtjL2AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAANrfn9Cz3kmcokgcDwWirYy9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADa35/Qs95JnK + JIHA8Foq2MvYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2t+f0LPeSZyiSBwPBaKtjL2AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAANrfn9Cz3kmcokgcDwWirYy9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADa3 + 5/Qs95JnKJIHA8Foq2MvYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2t+f0LPeSZyiSBwPBaKtjL2AAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAANrfn9Cz3kmcokgcDwWirYy9gAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAADa35/Qs95JnKJIHA8Foq2MvYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2t+f0LPeSZyiSBwPB + aKtjL2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANrfn9Cz3kmcokgcDwWirYy9gAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAADa35/Qs95JnKJIHA8Foq2MvYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2t+f0LPe + SZyiSBwPBaKtjL2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANrfn9Cz3kmcokgcDwWmrYy9AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAADZ35/Qs95JLKJIMcRxWOu464gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AD99ue8ZvzSeUSRhjAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzllmJkyAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAARBkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGDJ//EACoQAAAEBgICAwEAAgMA + AAAAAAABBAUCAwYQFTQWMEBgERJQNSExEyBw/9oACAEBAAEFAv8AxU7urhA3y+TJhyZMOTJhyZMOTJhy + ZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMO + TJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJh + yZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMOTJhyZMIKjTxxlY71np+iJdqx3rP + T9ES7VjvWen6Il2rHes9P0RLtWO9Z6foiXasd6z0/REu1Y71np+iJdqx3rPT9ES7VjvWen6Il2rHes9P + 0RLtWO9Z6foiXasd6z0/REu1Y71np+iJdqx3rPT9ES7VjvWen6Il2rHes9P0RLtWO9Z6fl/B/kpdqx3r + PT8qE/qbE6wKR8EPqQ+pD6kPqQ+pD6kPqQ+pD6kPqQ+pCZLgjgfGeNJ5aXasd6z0/LhP4NhdyU9sRfJP + jJ9B8H5KXasd6z0/MI/g2F3JT2mHxl/5BERkfjpdqx3rPT82E/g2F3JSPnsMPTRArKbLjlzPGS7VjvWe + n5xH8GwO5KS7XZslLpatPNTTvFS7VjvWen58JmRsDuSnuckMlbIcUU9FN8RLtWO9Z6f4EJmRsLuSnuWJ + pSmS7ts5FM8NLtWO9Z6f4MJ/BsDuSku2fKgnS3lomIz8JLtWO9Z6f4UJmRsDuSgu2KEoifWaKSPjwUu1 + Y71np/hwmZGwO5KO99ZfsDIyPvS7VjvWen+IRmRsDuSku0w9s0KoTYIpcfcl2rHes9P8WEzI2F3JQXc8 + NUpdApkTE87tS7VjvWen0U63pFSDCtwwrcMK3DCtwwrcMK3DCtwwrcMK3DCtwwrcMK3DCtwwrcMK3DCt + wwrcMK3DCtwwrcMK3DCtwwrcMK3DCtwwrcMK3DCtwwrcCZm8jIv8dzo3yV0lcknI53Yl2rHes9PopD+X + +cuSSVcl1b5yGb1pdqx3rPT6KQ/l/nqJMufKeWqYij6ku1Y71np9FIfy/wBCZBDHA+M8SfqS7VjvWen0 + Uh/L/RP/AE+soMjLoS7VjvWen0Uh/L/Se3eBJDNiOZH/AN0u1Y71np9FIfy/0DD48lKKI/t0pdqx3rPT + 6KQ/l/nxGRE+PX3Hz1Jdqx3rPT6KQ/l/nTI4JcD28RK+xLtWO9Z6fRTzmkSIc82jPNozzaM82jPNozza + M82jPNozzaM82jPNozzaM82jPNozzaM82jPNozzaM82jPNozzaM82jPNozzaM82jPNozzaM82jPNozra + E82GdK7lSiUmku7pMXRdiXasd6z0/wAan2c5hkXx3OC2SjkOS+cum9qXasd6z0/xWBnOYZF3OrjJQylq + qarm9yXasd6z0/xGBnOMyLuenaWihUTY58zvS7VjvWen+HT7OcZkXx3PbyScRxRRxeAl2rHes9P8JgZz + jMu0z/w+PQM/nwku1Y71np/gEKfaDjMi+O2ZHDBA+PESg/DS7VjvWen+BT7P9zIu1TPlyJT06zFsXiJd + qx3rPT84hT7R9wRdq5XJSSHVxmrp3ipdqx3rPT86n2c4zIu10cJKCS4LJy2d4yXasd6z0/Np9n+4Ivjt + d3SUhgVT5iib46Xasd6z0/MYGf7Ai+O17eYEpTYzmReQl2rHes9PyiDA0fYyL47D/wBPj1DCDMz8pLtW + O9Z6flQGcMWWcBl3EZdxGXcRl3EZdxGXcRl3EZdxGXcRl3EZdxGXcRG5r5kHlpdqx3rPT9ES7VjvWen6 + Il2rHes9P0RLtWO9Z6foiXasd6z0/REu1Y71np+iJdqx3rPT9ES7VjvWen6Il2rHes9P0RLtWO9Z6foi + Xasd6z0/REu1Y71np+iJdqx3rPT9ES7VjvWen6Il2rHes9P0RLtWO9ZafoiXaKx3qqTNnpscuGOXDHLh + jlwxy4Y5cMcuGOXDHLhjlwxy4Y5cMcuGOXDHLhjlwxy4Y5cMcuGOXDHLhjlwxy4Y5cMcuGOXDHLhjlwx + y4Y5cMcuGOXDHLhjlwxy4Y5cMcuGOXDHLhjlwxy4Y5cMcuGOXDHLhjlwxy4Y5cMcuGOXDHLhjlwxy4Y5 + cMcuGOXDHLhjlwxy4Y5cMcuGOXDHLhjlwxy4Y5cMcuGOXBOgWkoKx+ln6Wfpn//EADkRAAAEAAwEBQQC + AQUBAAAAAAABAgQDBQYRFRY0UlNxobESIDAzIUBQYNEjMTJRE4FBIkJwkeFh/9oACAEDAQE/Af8AhiLo + uW+WaUnNMKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woq + q4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vl + qKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKqu + L5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5ai + qri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+ + Woqq4vlqKquL5aiqri+Woqq4vlqKquL5aiqri+WohJMw6EGo1l4c0lbQvL2K77C8j25pK2heXsV32F5H + tzSVtC8vYrvsLyPbmkraF5exXfYXke3NJW0Ly9iu+wvI9uaStoXl7Fd9heR7c0lbQvL2K77C8j25pK2h + eXsV32F5HtzSVtC8vYrvsLyPbmkraF5exXfYXke3NJW0Ly9iu+wvI9uaStoXl7Fd9heR7c0lbQvL2K77 + C8j25pK2heXsV32F5HtzSVtC8vYrvsLyPbmkraF5exXfYXke3NJW0Ly82ZzCcj60/m3fYXke3NJW0Ly8 + 3CJJSeExHMULbH/JB/jsJzE5icxOYnMTmJzE5icxOYnMTmEQi0K4kn4iJ48S5mg4XwVv/wCjiLzTvsLy + PbmkraF5ecWnjKYxHETG1P8Akgvx26s5kIoj7imgnJ/2CUR+Zd9heR7c0lbQvLzq0kspjEcRMbU/5YL8 + dutE8enBGUE4+37/AF/4CWSinLzDvsLyPbmkraF5eeWniKYxHESm1P8AkgvFO3WiuOVtD4V+KdhBQyYR + JKSc5eXd9heR7c0lbQvLz6kkopjEcxMbYzhYL8dutFkaQrFX7SGjmDcoJcGYn8q77C8j25pK2heXoC0k + opjEcxMbU/5YL8NusxfQrNfFBhhGMC7RxI/6E/lHfYXke3NJW0Ly9BWklFMZCOYlNr9WB/HbrN3EI2Xx + oPxEVxrBvU/pX6E/k3fYXke3NJW0Ly9CUklFMZCOYlNsZwsD+G3Wg4RUErjQcxiKI6Q6mRCeChP5J32F + 5HtzSVtC8vQ1JJRTGQjmJTbGcLA/ht1iOY5yETR4ULNBQ5/6v3+//QSiPyLvsLyPbmkraF5eiKSSimMh + HMSm2M4WB/HbrxNHvD9Fyfh/gwSiPxLyDvsLyPbmkraF5eirSSimMRzEptj/AJYH8f1+uvFMdqa/ThPF + OwgoRK0zp8S67vsLyPbmkraF5dGfzqyJRTGQjmJTbH/LA/j+v114rjeEZHw/dP6DZzBuEfyQZ+HWd9he + R7c0lbQvLox7GLps74YNUxTCnH2IKcfYgpx9iCnH2IKcfYgpx9iCnH2IKcfYgpx9iCnH2IKcfYgpx9iC + nH2IKcfYgpx9iCnH2IKcfYgpx9iCnH2IKcfYgpx9iCnH2IKcfYgpx9iCnH2IKcfYgpx9iCnH2IKcfYgV + HTxRTGvyEXxjCsVzp8S/QZPoJ3BEtBifqO+wvI9uaStoXl0ZT2z+vn09o7hWkJxwRiLI0g3yPD7/AKE/ + Td9heR7c0lbQvLoyntn9fPqEDDLglcaDmMRVHCHZcKvBYn6TvsLyPbmkraF5dGU9s/r59RSo0HxJ8DET + x4UPNBQ3grcT9F32F5HtzSVtC8ujKe2f18+pxNHs00C4/wCwlRKKcug77C8j25pK2heXRlPbP6+fU4ri + Vbs+Nf4CCgyg0kkvsXQd9heR7c0lbQvLoyntn9fPqUURGqGMoWGLwCE8BTEXh0XfYXke3NJW0Ly6Mp7Z + /Xz6hNP4CJ4hm+s4LIgSek77C8j25pK2heXRlPbP6+fT0oNZ8KRFERk3+pDfkCKbpu+wvI9uaStoXl0Y + 8ip07c8cEmcpv/gq6/ual8irr+5qXyKuv7mpfIq6/ual8irr+5qXyKuv7mpfIq6/ual8irr+5qXyKuv7 + mpfIq6/ual8irr+5qXyKuv7mpfIq6/ual8irr+5qXyKuv7mpfIq6/ual8irr+5qXyKuv7mpfIq6/ual8 + irr+5qXyKuv7mpfIq6/ual8irr+5qXyKuv7mpfIq6/ual8irr+5qXyKuv7mpfIq6/ual8irr+5qXyKvP + 7mpfIhYJUErgV127dbiEKDgy8RFUTwbMuI/FQIuo77C8j25pK2heXo04jqO+D6EB12bOFdwnBBkIuiyD + ZJmT9/31nfYXke3NJW0Ly9FMxHcd8M8BAdeLothXy5k/b/Jhmzg2iOCDLru+wvI9uaStoXl6IZiO474Z + 4CA68VROt6riV+AgIBEAngQUxeQd9heR7c0lbQvL0MzIR3HfDPAQHXiiJFOTKFhvxEHBlBlwpKYvIu+w + vI9uaStoXl6EYjuO+GeAgOt9xE8Qz/WcFkQJM328k77C8j25pK2heXoJn4CO474foQHWSk1nMQiaIygC + /lhi/wBXlHfYXke3NJW0Ly9AMyIR3HXD9CAPrQMCuHVwIKcxFMToaFxr8V+Vd9heR7c0lbQvLz6jmEdR + 3N9CAPM+s0aQrqE/jgi8RFkVoZIm/wB3+T8s77C8j25pK2heXnfsDOYR3Hc30IA8z60XRbCPl8KPt/kw + xYwbOD4EF5d32F5HtzSVtC8vOfYKOYR1Hc30IA8z60WRTCvVcX2SGzZDZBQcGUxeYd9heR7c0lbQvLzf + 2CjmEdR3N9CAPM+tFMSLdH/JC/iIKDKDLhIpi8y77C8j25pK2heXm1HMU4jqO5vowB5n1oniI1zQsOXh + +glJJ+3mnfYXke3NJW0Ly82tPEmYxQjHD3FCMcLUxQjHC1MUIxwtTFCMcLUxQjHC1MUIxwtTFCMcLUxQ + jHC1MUIxwtTFCMcLUxQjHC1MUIxw9wmJ2aD4koE3m3fYXke3NJW0Ly9iu+wvI9uaStoXl7Fd9heR7c0l + bQvL2K77C8j25pK2heXsV32F5HtzSVtC8vYrvsLyPbmkraF5exXfYXke3NJW0Ly9iu+wvI9uaStoXl7F + d9heR7c0lbQvL2K77C8j25pK2heXsV32F5HtzSVtC8vYrvsLyPbmkraF5exXfYXke3NJW0Ly9iu+wvI9 + uaStoXl7Fd9heR7c0lbQvL2K77C8j25pK2heXsV32F5HtzSccQUBDrOEObwFKM8QhSjPEIUozxCFKM8Q + hSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8Q + hSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8Q + hSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8Q + hSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8QhSjPEIUozxCFKM8Q + hSjPEIUozxCFKM8QhSjPEIOYyaKgVkSy+x/8y//EACsRAAAEBAQHAQADAQAAAAAAAAABAgMEFDJRERMg + MBIhIjFAUGAzQUJxcP/aAAgBAgEBPwH/AIw66TRCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTy + bCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCe + TYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybCeTYT + ybCeTYTybCeTYTybCeTYTybCeTYTybCeTYTybAo1J/xqjqS+FRUWqOpL4VFRao6kvhUVFqjqS+FRUWqO + pL4VFRao6kvhUVFqjqS+FRUWqOpL4VFRao6kvhUVFqjqS+FRUWqOpL4VFRao6kvhUVFqjqS+FRUWqOpL + 4VFRao6kvhUVFqjqS+FRUWqOpLzMDGAwGAwGAwGAwGAwGAwGHmIqLVHUl5ZCHfSrpV3GBWGBDAhgQwIY + EMCGBDAhgQwIYEDQk+WAfhjRzLy0VFqjqS8whDxPH0q770RDYc0DDyUVFqjqS80hDxPH0q77z8LjzQMP + IRUWqOpLziEPE8fSrvvPw5L5l3Bpw5eOiotUdSXnkeAYiePpV33nodLv+haTSeB+MiotUdSXoCDETx9K + u+86yThcw42aD5+KiotUdSXoSEPE8fSrecbJwsDDzJtn4iKi1R1JeiIMRPHyV33lJ4iwMPw5o5l28NFR + ao6kvRkGInj6Vd94yxERDcHNPYYeCiotUdSXpCDETx8ld9+Ihf5R4KKi1R1JelIQ8TxdKu+/EQ3H1J7g + yw30VFqjqS2cPNLkIeJ4ulW+/Dk727haTSeB7yKi1R1JbMKyhaMTEo0JRoSjQlGhKNCUaEo0JRoSjQlG + hKNCUaEo0JRoSjQlGhKNCUaEo0JRoSjQlGhKNCUaEo0JRoSjQlGhKtWBQrfgOsk4XMONqbPA91FRao6k + tmC/P17jaXCwMPNG2e4iotUdSWzBfn7BSSUWBh5g2+22iotUdSWzBfn7EyI+4iIY0c09tpFRao6ktmC/ + P2cRC4c0bKKi1R1JbMF+fs34kkck9wZ47CKi1R1JbMF+fsn4r+EbSKi1R1JbMF+fsOwiInHpTtoqLVHU + lswP5+vNRF3D8Sa+Se24iotUdSWzDPobTgoTbQm2hNtCbaE20JtoTbQm2hNtCbaE20JtoTbQm2hNtCba + E20JtoTbQm2hNtCbaE20JtoTbQm2hNtCbaE20JtoJUSixLfWskFiYefU5/m6iotUdSXp4eG4upW+66TZ + YmHXlOd95FRao6kvTQ8Nj1K33nyaC3FL5nvoqLVHUl6WGhsepQ7bz75NlgQUo1HifgIqLVHUl6SGhsep + Q7bz8SSeSe4M8fBRUWqOpL0cNDY9Sh23oiK/qkY+EiotUdSXooaGx6lbxngWIiIni5J8RFRao6kvQw0N + xdSt5aiSWJh+IN3/ADxUVFqjqS9BDw+PUreccJssTDrxuH4yKi1R1JefDw2PUredeJouYW6pyrx0VFqj + qS86Hh8epW8/EE32ClGo8T8hFRao6kvNh4fHqVvPxJI5JCjx8lFRao6kvMhobHqVvPxX9UjHykVFqjqS + 8sgT7lxnuXGe5cZ7lxnuXGe5cZ7lxnuXGe5cZ7lxnuXGe5cZ7lwbyz5GfmIqLVHUl8KiotUdSXwqKi1R + 1JfCoqLVHUl8KiotUdSXwqKi1R1JfCoqLVHUl8KiotUdSXwqKi1R1JfCoqLVHUl8KiotUdSXwqKi1R1J + fCoqLVHUl8KiotUdSXwqKi1R1JfCoqLVHUl8KiotUYk1JLAZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DK + XYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZ + S7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7D + KXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYZS7DKXYIaXxFy/7L//xAA2EAABAgMFBAgGAwADAAAA + AAABAAMCNHIEIJKhwREwMVESM0BBUFJgkSEiQmFzsRMycXCy0f/aAAgBAQAGPwL/AIYgjjbijER2fBS7 + uSl3clLu5KXdyUu7kpd3JS7uSl3clLu5KXdyUu7kpd3JS7uSl3clLu5KXdyUu7kpd3JS7uSl3clLu5KX + dyUu7kpd3JS7uSl3clLu5KXdyUu7kpd3JS7uSl3clLu5KXdyUu7kpd3JS7uSl3clLu5KXdyUu7kpd3JS + 7uSl3clLu5KXdyUu7kpd3JS7uSl3clLu5KXdyUu7kpd3JS7uSl3clLu5KXdyUu7kpd3JS7uSl3clLu5K + XdyUu7kpd3JS7uSl3clDALO7tiOzuvMV6ehWqxeYr09CtVi8xXp6FarF5ivT0K1WLzFenoVqsXmK9PQr + VYvMV6ehWqxeYr09CtVi8xXp6FarF5ivT0K1WLzFenoVqsXmK9PQrVYvMV6ehWqxeYr09CtVi8xXp6Fa + rF5ivT0K1WLzFenoVqsXmK9O17RxCFntGwPDgfOuC4LguC4LguC4LguC4LgjBHCDCe5F5jbEznD2tqsX + mK9O2AjuQs9oOx4cD5t7sKNoscPy8YoOX+dqarF5ivTtu0cQhZ7Qdjw4Hzb6K0WSHZH9UHmWwjYeXaGq + xeYr07dtHFCz2g7HhwPm3xda2QPf9lFBHD0SOIPZ2qxeYr07ft4FBi0RbHu4+bfcOi6OESLTsPRi7M1W + LzFengG0HYQhZ7Qdj3cfNvug4Pj3Rcl0HYfh9MXPsrVYvMV6eAgg7CO9Cz2g7HhwPm3xaeh6QOS+PzNn + hH/72RqsXmK9PAgQdhHehZ7RFseHA+bfFtyERQnuK/kaHSY58uxtVi8xXp4GCDsI70LPaDseHA+bfERD + aCjaLLDta74fL2JqsXmK9PBAR8CO9Cz2g7Hu4+bfm0WOH4/VAth7A1WLzFengoIOw80LPaDseHA+bf8A + 87AAe7x3RIwRQmEjiDv2qxeYr08GBB2Ed6FntMWx4cD5t/0h8jw4Rc0WnYejEN81WLzFem5LjzQji6ZG + 1S491Lj3UuPdS491Lj3UuPdS491Lj3UuPdS491Lj3UuPdS491Lj3UuPdS491Lj3UuPdS491Lj3UuPdS4 + 91Lj3UuPdS491Lj3UuPdS491Lj3W0MbCPv2Dox/CMf1i5ItOw/4ee9arF5ivTcxflP6Hh5beh28jyWyI + bWz/AFi3jVYvMV6bmL8p/Q8QLbsAihPNdOAdJk8Dy3bVYvMV6bmL8p/Q8RMMQBB7kX7OOk13jy7pqsXm + K9NzF+U/oeJxWmxw/eKD/wAWw7hqsXmK9NzF+U/oeJlpoiN//qjGYtpJ27hqsXmK9NzF+U/oeJFiykGP + vi5LaTtO5arF5ivTcxflP6HiG0o2eyRfL9UY7921WLzFem5i/Kf0PDzHHF0YRxKLLBMLOcW8arF5ivTc + lp9wwxdMn+v+LrjgK644CuuOArrjgK644CuuOArrjgK644CuuOArrjgK644CuuOArrjgK644CuuOArrj + gK644CuuOArrjgK644CuuOArrjgK644CuuOArrjgK644CuuOArrjgK644CuuiwFByDbsPDaN/E69F0YQ + tg+RkcId61WLzFeng8NqtMOyD6Yee/8A5HYv8HNdJw7IR/WHlvmqxeYr08GhtVph+X6Iee/+b5nD/WBf + yvRbT+t+1WLzFengsNptMOyH6YOe/wChBsjePd5UXHIzFEefYGqxeYr08EhtVph+T6Yee/LFmILvfF5U + Yoj0ieJPYWqxeYr08DhtVph+XjDBz35s9kiqjXx7E1WLzFengUNptUPy/TDz3xiiIEI70WLMTC13nzdk + arF5ivTwGG1WmH5fph5/ffFx2MQwhdCDbCyOA59larF5ivTwAWq1Q/L9MPP774uPR7OX3W2L4Nj+sPZm + qxeYr07eLVaofl+mHn9990o/jGf6wDvX8jsX+Dl2dqsXmK9O3C1WqH5fph5/ffdEbI3u6Hki67F0oj2h + qsXmK9O2i02qH5fpg5/ffFmznpPc/KjFHF0ou89parF5ivTtgtNph+H0wc/vvorNZYvjwijC2nj2pqsX + mK9O1gjiF8LVGpuJTcSm4lNxKbiU3EpuJTcSm4lNxKbiU3GjBHaozCe2NVi8xXp6FarF5ivT0K1WLzFe + noVqsXmK9PQrVYvMV6ehWqxeYr09CtVi8xXp6FarF5ivT0K1WLzFenoVqsXmK9PQrVYvMV6ehWqxeYr0 + 9CtVi8xXp6FarF5ivT0K1WLzFenoVqsXmK9PQrVYvMwstxRkR9ylXcKlXcKlXcKlXcKlXcKlXcKlXcKl + XcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKl + XcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKl + XcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKlXcKl + XcKbJszgAiHd/wAy/wD/xAAqEAACAQIEBQUBAQEBAAAAAAAAARExUaHR8PEQITBhsUBBUGDBkeFxgf/a + AAgBAQABPyEggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg + ggggpcVOEr6RUKgzkBho8uRuOY3HMbjmNxzG45jccxuOY3HMbjmNxzG45jccxuOY3HMbjmNxzG45jccx + uOY3HMbjmNxzG45jccxuOY3HMbjmNxzG45jccxuOY3HMbjmNxzG45jccxuOY3HMbjmNxzG45jccxuOY3 + HMbjmNxzG45jccxuOY3HMbjmNxzG45jccxuOY3HMbjmNxzG45jccxuOY3HMbjmNxzG45jccxuOY3HMLJ + EUl+58VQqDMR8vouq3FwqFQZiPl9F1W4uFQqDMR8vouq3FwqFQZiPl9F1W4uFQqDMR8vouq3FwqFQZiP + l9F1W4uFQqDMR8vouq3FwqFQZiPl9F1W4uFQqDMR8vouq3FwqFQZiPl9F1W4uFQqDMR8vouq3FwqFQZi + Pl9F1W4uFQqDMR8vouq3FwqFQZiPl9F1W4uFQqDMR8vouq3FwqFQZiPl9F1W4uFQqDMR8vVpS4R2CGQy + GQyGQyGQyGQyGQyGRyn1eq3FwqFQZiPl6t6XOomvZi1xBEHL/Qm+z+HYfw7D+HYfw7D+HYfw7D+HYfw7 + D+HYfw7D+HYfwT52GyqMOwenkQ/31Wq3FwqFQZiPl6xr1DaU1yhkOaEe1/sTT6bEOQmnyh+4xZnm9x3d + g0VXqdVuLhUKgzEfL1r1uaZKa5NMXL+Q9r/Ymn1KBKoa6KdysxqeRVvZ+o1W4uFQqDMR8vXNW5pHKa5Q + xclQj2uXyQ6nMhHkHnbtffuPzvxVJ+n1W4uFQqDMR8vXvWraOaa5QxE5PLRqJp9R0Jg0U5fh3QzWr29n + 3RHpdVuLhUKgzEfL4BDf5xNezEStPLRqSn1GNUdaVXP+JgoYfpNVuLhUKgzEfL4FrJzknsR/pR7S5iaf + UdBHP+ruRyE9tKvbu9JqtxcKhUGYj5fBMeTkpKpiJ3IaNSV1GJtvDoMcbK93a8yPRarcXCoVBmI+XwbW + TkpKpiNfJaNRNPqOgjqhDT9xjJVOv/N0NlX0Oq3FwqFQZiPl8I1l8wkqmI16Fq3JXVa5MpvrX791kMCG + muTTI6+q3FwqFQZiPl8K5kpykqhI9CNepK6vMiQUXa/1O6adJ9fVbi4VCoMxHy6MP1rCTkpPYWkU7a5k + rquhAVUBgY7XWJ+V262q3FwqFQZiPl0EV6Ah2Rv036b9N+m/Tfpv036b9N+m/Tfpv036b9N+m/Tfpv03 + 6b9N+m/Tfpv036b9N+m7RIVYlNPyZAit1nQgT7RqI6Dqii3XV1W4uFQqDMR8vl4joQpz/wCjdhr9oOj/ + ANIfT1W4uFQqDMR8vmIjoVVzoNmwwZHS1W4uFQqDMR8vmYjEL3hspTL7z7udDTXt0dVuLhUKgzEfL5uI + ssrj0uQ0fnIMGiGuhqtxcKhUGYj5fNxG1A7dFSq7mNFMmmvN9DVbi4VCoMxHy+aiMoKe8+32LuNZvM5t + us9HVbi4VCoMxHy+ZiNrEkqtkVyqKrsXYcveXHuulqtxcKhUGYj5dKJJJJJJJJJJJJJJJJJJJJJJJJJJ + JJJJPoVmkZZ7EQYcN07n/Bubf+dPVbi4VCoMxHy6LNRVSZ8osXY05+GnPw05+GnPw05+GnPw05+GnPw0 + 5+GnPw05+GnPw05+GnPw05+GnPw05+GnPw05+GnPw05+GnPw05+GnPw05+GnPw05+GnPw05+Guvw93Vt + BPXUVxPYj8/cVe7G55uvU1W4uFQqDMR8vhknIwEhy/E+wpEkko6soZo1ur2RbYTTMPq6rcXCoVBmI+Xw + qTkiBLzbjfYihRCXVb5D42SHIfNvvZDOz7duxdfVbi4VCoMxHy+ES5kSd5uxPsRRyhdVtDF7ZS5dzKsb + 3pT0Gq3FwqFQZiPl8Gk7EANOb8b7HKJKF1W1B/73qX+h5vm7j0Oq3FwqFQZiPl8EqocCS81iYsckoXVQ + mbcK5X9ey/CzHvLS3X0Wq3FwqFQZiPl8CnMalSuX4n2OUSUJdVEdJbPkhaU8qb/wOPR6rcXCoVBmI+Xr + 0pEqDIDXm/EIohQl1HyKnx2zmMafLY3PN+k1W4uFQqDMR8vXJSINa8H43YiiFC6kqJkhzaJ7tZEmP/Hr + /t2e3pdVuLhUKgzEfL1q5iLgg/E7EXKIXUbJZ+8nP/HcYHn/ADSy9PqtxcKhUGYj5esXMQxrwfidjlEl + C6jaHh7CzDGPKtv27eo1W4uFQqDMR8vVrmLUDnvp2J2OQSXLqNqBAWg05r/ZNVObPd+p1W4uFQqDMR8v + VpLHxdW7E7HIJLl1GSZt8hJNf8F2Q9bJar9VqtxcKhUGYj5eraEkyU2iPkklTksjTrI06yNOsjTrI06y + NOsjTrI06yNOsjTrI06yNMshYCYa5KRuVrn6vVbi4VCoMxHy+i6rcXCoVBmI+X0XVbi4VCoMxHy+i6rc + XCoVBmI+X0XVbi4VCoMxHy+i6rcXCoVBmI+X0XVbi4VCoMxHy+i6rcXCoVBmI+X0XVbi4VCoMxHy+i6r + cXCoVBmI+X0XVbi4VCoMxHy+i6rcXCoVBmI+X0XVbi4VCoMxHy+i6rcXCoVBmI+X0XVbi4VCoMxHy+i6 + rcXCoVBmM+X0XUb8VQqDH0ENpZjl9FIQhCEIQhCEIQhCEIQhCEIQhCEIQhCEIQhCEIQhCEIQhCEIQhCE + IQhCEIR6+Jt9/HUKgyCHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2I + diHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiHYh2IdiH + Yh2IdiHYh2IdiHYh2IYuFQvpSS+Ekkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk + kkkkkkkkkkkkkkkkkkkkiR//2gAMAwEAAgADAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABII + CSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSIAB//AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/ + AP8A/wD/AP8A/wD/AP8A/wD+HAAUkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkgoACkkkkkkkkkkkkkkk + kkkkkkkkkkkkkkkkkkkFAAUkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkgoACkkkkkkkkkkkkkkkkkkkk + kkkkkkkkkkkkkkFAAUkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkgoACkkkkkkkkkkkkkkkkkkkkkkkkk + kkkkkkkkkFAAUkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkgoACkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk + kkkkFAAUkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkgoACkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkF + AAUkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkgoACkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkFAAUkk + kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkgoACkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkFAAUkkkkkkk + kkkkkkkkkkkkkkkkkkkkkkkkkkgoACkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkFAAUkkkkkkkkkkkk + u/8A/wD/AP8A9hJJJJJJJJJJJJIKAApJJJJJJJJJJJJa2222223VJJJJJJJJJJJJBQAFJJJJJJJJJJJJ + JBySSSSQoJpJJJJJJJJJJIKAApJJJJJJJJJJJJJBySSSSSZPpJJJJJJJJJJBQAFJJJJJJJJJJJJJJHiS + SSSSQtJJJJJJJJJJIKAApJJJJJJJJJJJJJJHySSSSSUnpJJJJJJJJJBQAFJJJJJJJJJJJJJJJbiSSSSS + dfpJJJJJJJJIKAApJJJJJJJJJJJJJJJUSSSSSSClJJJJJJJJJBQAFJJJJJJJJJJJJJJJJPSSSSSSCgJJ + JJJJJJIKAApJJJJJJJJJJJJJJJJLCSSSSSGKJJJJJJJJBQAFJJJJJJJJJJJJJJJJJJCSSSSSSYNJJJJJ + JIKAApJJJJJJJJJJJJJJJJJIWSSSSSQ7pJJJJJJBQAFJJJKJJJJJJJJJJJJJJNmSSSSSRrtJJJJJIKAA + pJJIjbbbbbbbbbbbbbYVySSSSSTrZJJJJJBQAFJJJIySSSSSSSSSSSSSSSSSSSSSQ5FJJJJIKAApJJJG + SSSSSSSSSSSSSSSSSSSSSSQP9JJJJBQAFJJJIySSSSSSSSSSSSSSSSSSSSSSQUBJJJIKAApJJJGSSSSS + SSSSSSSSSSSSSSSSSSSFxJJJBQAFJJJIySSSSSSSSSSSSSSSSSSSSSSSQnpJJIKAApJJJGSSSSSSSSSS + SSSSSSSSSSSSSQWpJJJBQAFJJJIySSSSSSSSSSSSSSSSSSSSSSCapJJJIKAApJJJWSSSSSSSSSSSSSSC + SSSSSSSRKpJJJJBQAFJJJIEkkkkkkkkkkkkk9+SSSSSSBkJJJJJIKAApJJJJJJJJJJJJJJJJJMjSSSSS + SCnJJJJJJBQAFJJJJJJJJJJJJJJJJJLpySSSSSRhJJJJJJIKAApJJJJJJJJJJJJJJJJJNySSSSSPBJJJ + JJJJBQAFJJJJJJJJJJJJJJJJLtySSSSSFpJJJJJJJIKAApJJJJJJJJJJJJJJJKPySSSSSF9JJJJJJJJB + QAFJJJJJJJJJJJJJJJJtySSSSSBJJJJJJJJJIKAApJJJJJJJJJJJJJJCZSSSSSQb1JJJJJJJJJBQAFJJ + JJJJJJJJJJJJCtSSSSSSKdJJJJJJJJJIKAApJJJJJJJJJJJJJCNSSSSSSppJJJJJJJJJJBQAFJJJJJJJ + JJJJJJCsSSSSSQ9JJJJJJJJJJJIKAApJJJJJJJJJJJJCoSSSSSHgpJJJJJJJJJJJBQAFJJJJJJJJJJJJ + KUgAAAAGPpJJJJJJJJJJJIKAApJJJJJJJJJJJJINttttvepJJJJJJJJJJJJBQAFJJJJJJJJJJJJJJJJJ + JJJJJJJJJJJJJJJJIKAApJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJBQAFJJJJJJJJJJJJJJJJJJJJJJ + JJJJJJJJJJJIKAApJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJBQAFJJJJJJJJJJJJJJJJJJJJJJJJJJJ + JJJJJJIKAApJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJBQAFJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ + JIKAApJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJBQAFJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJIKAA + pJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJBQAFJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJIKAApJJJJ + JJJJJJJJJJJJJJJJJJJJJJJJJJJJJBQAFJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJIKAApJJJJJJJJJ + JJJJJJJJJJJJJJJJJJJJJJJJBQAFJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJIKAAJJJJJJJJJJJJJJJ + JJJJJJJJJJJJJJJJJJJTQA5JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJL6AUNttttttttttttttttttt + tttttttttttttttQSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSCAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAASf/8QALBEAAQIEBAYDAQEBAQEAAAAAAQARIVFh8CAxQdEwQGBxkbFQocGB4fEQcP/aAAgB + AwEBPxDo5wnCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcJw + nCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcJwnCcYgfyB45Mr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3 + Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr + 3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Yr3Y + r3Yr3Yr3Yr3Yr3YirgAmDvDuAmbMvhu6joW3TYruo6Ft02K7qOhbdNiu6joW3TYruo6Ft02K7qOhbdNi + u6joW3TYruo6Ft02K7qOhbdNiu6joW3TYruo6Ft02K7qOhbdNiu6joW3TYruo6Ft02K7qOhbdNiu6joW + 3TYruo5sAOUDGCZMmTJkyZMmTJkyJYOUAOXN26bFd1HNlQXBzFEdnJPMd32PWsFU9qp7VT2qntVPaqe1 + U9qp7VT2qntVPaqe0NMgyIRNnkg6bC8HSMECFn5q3TYruo5soZQuEeCc4kVfnbLWHEMUCHGiEcU0PWh3 + 11dZAn5i3TYruo5wo5C4RwAk4kVex61hxiJPlBRPd9HzGsEKEcHx/Cni3L26bFd1HPAOFwUaCJYkWiO2 + SBcOOKGvSz9hSic7AcEJ+Wt02K7qOfMQuCgUEnEi+XltdTxTkgEAzBt2zTrYH6/iZytumxXdRz5DonC4 + kjkblmKj6fxrqVq3EL6IDNDUIDMx11BADylumxXdR8AQ6K3wKKED6xq789duMMtg+6IMBLOeyiY7cnbp + sV3UfAkOjNwDNAScsxV+etdTxhQgEkBgmFD2vPKjIclbpsV3UfBmLgGaA05Zio+n8a6lPxCHRsqKBsQQ + BaJGXdn3zyA8jbpsV3UfCEzoGaA05xItEP411KfjEbKNUUO/mCEgjgoEEtx7dNiu6j4Qh0WgcFGIo87M + vWsE/FIdDo5cp/49eUNGcyI49umxXdRwQB50rdBGAo87Mu2SeD8UoXIzZOyEXBJ+LbpsV3UcDRZZgI/s + N1XeAq7wFXeAq7wFXeAq7wFXeAq7wFXeAq7wFXeAq7wFXeAq7wFXeAq7wFXeAq7wFXeAq7wFXeAq7wFX + eAq7wFXeAq7wFXeAq7wE7q8BRZhUBEuSZ8Yu0FmzcyvPVd9INQUAOR4lumxXdRwcvt9/HCnBAdRoU9CY + c5LogJLcO3TYruo4OX2+/kAOUBD8EzGh7X+MAOXCt02K7qODl9vv5EKkMxGiwDI/qR9mGZiAOXBt02K7 + qODl9vv5IA0U8JoD+gfT6dsgwrg8C3TYruo4OX2+/khgh4ZHg/bdmQU2A380v3wLdNiu6jg5fb7+RBEB + DSDr+t7QQNAyAyAkL/zgW6bFd1HBy+338gBEwOjGIzMjFqnPx5RAQeFbpsV3UcArL7ffx4VA5OTI2BOW + mg7cQW6bFd1HAL6IahgMwiCZkHVUyFMhTIUyFMhTIUyFMhTIUyFMhTIUyFMhTIUyFMhTIUyFMhTIUyFM + hTIUyFMhTIUyFEgQB2IEZIjOIP2HHHcwFcTkgOOZnT+JgR4lumxXdRwoqKioqKioqKioqKioqKioqKio + qKioqKioqKj/AOEGc5KMK7wJGl/vHG3kzITTPnLMszxrdNiu6j4UADnJRScmBI0v94+UYT2BvITlmghi + J6mpr9duPbpsV3UfCAAc5KKbvAkaIcXNCz4A5zoN0JBgl+6k15C3TYruo+DADlR6cmBI0Q4pqhgEPgMn + b7ZDoAMgNORt02K7qPgiADnJRAd4EjSdhaniiJgoF9r+hZQ4yDvyVumxXdR8CIOOSE4rvAkaXlBDLijg + 3JyQI+0AsW/1AMwbk7dNiu6jnyQA5QyKjnTwJGl5Qmoz4oSUSV5IfC5nIdkA0eUt02K7qOeJADlMoKNj + LAFGfFHnH0AmSdP+CKY4OX9KCQvtytumxXdRzpIBym0EQDGWAKfEdZHA7A3Jl5g5Qt3R1JrcOXt02K7q + OcJAOUygjOiLAOKRBDxAu57PmU3yPv8A3/ghly9umxXdRzZIBymUFGRFgHEJZGGaGBEadH/xBDIyEGF+ + fs8zbpsV3Uc5wbhidD0CoJ06dOnTp06dOnCBBLBVbILXv7QAAGH1zVumxXdRzYTCcH+IMM3zuVBZVUFl + VQWVVBZVUFlVQWVVBZVUFlVQWVVBZVUFlUHcvnchUFxln+lAgQebt02K7qOhbdNiu6joW3TYruo6Ft02 + K7qOhbdNiu6joW3TYruo6Ft02K7qOhbdNiu6joW3TYruo6Ft02K7qOhbdNiu6joW3TYruo6Ft02K7qOh + bdNiu6joW3TYruo6Ft02K7qOhbdNhOSEnAsjNwehYiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi + IiIiIg5cSAdyCjqK4CHTB3ZQkoSUJKElCShJQkoSUJKElCShJQkoSUJKElCShJQkoSUJKElCShJQkoSU + JKElCShJQkoSUJKElCShJQkoSUJKElCShJQkoSUJKElCShJQkoSUJKElCShJQkoSUJKElCShJQkoSUJK + ElCShJQkoSUJICEP/jP/xAArEQACAQMCBgIDAAIDAAAAAAAAARFhkaEgQSEwMUBg0VBRcbHwgeEQcMH/ + 2gAIAQIBAT8Q8Nnwpi9KlMqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrl + VcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcqrl + VcqrlVcqrlVcqrlVcqrlVcqrlVcqrlVcaJJ7ippyPBchG705HguQjd6cjwXIRu9OR4LkI3enI8FyEbvT + keC5CN3pyPBchG705HguQjd6cjwXIRu9OR4LkI3enI8FyEbvTkeC5CN3pyPBchG705HguQjd6cjwXIRu + 9OR4LkI3enI7ykS+iX0S+iX0S+iX0S+iX0S+iX0S+iX0S+hqO7yEbvTkd20ORLAv/QnqRTKZTKZTKZTK + ZTKZTFMg5fTI7rIRu9OR3jQ+DEQ4H7C4qeZ16ojxcNxsu5yEbvTkd60PgzgOB+x1U8zjsKR9bdfY2Th9 + xkI3enI75ofARDgfsTzJgWNfsMZt17fIRu9OR38iUKRf7AuKnmcdhRPQMHbGQjd6cj4BofUXBkfsLip5 + jIt1bEUSO1yEbvTkfAtDmTgOp+zaeaynxsuHaZCN3pyPgmhi4Oj9jaeajqqH7FHZZCN3pyPg2hnD8D9j + aeahYY+Sp/QlE9jkI3enI+EaNxUHR+3O6kqi47r0NNdewyEbvTkfCtDlCIs9uej+Bj2afPyEbvTkcmUT + 3rNpRwLOP3985zsKJ4AwdQjm5CN3pyOTDmXJQKBQKBQKBQKBQKBQKBQKBQKBQKBQKBQKBQKBQKBQKH/E + ScwJRwXOcbkW6thpKOZkI3enI5PW/PyGSHNcGNRy8hG705HJ635+Q670Pm+h8vIRu9ORyet+fkUkJKEj + /wAT6IfJyEbvTkcnrfn5JiVvIaa5GQjd6cjk9b8/JQ30N1Pt9EyXyMhG705HJ635+Ra+xST632N9XPXk + 5CN3pyOT1vz8g2uJnHt4Dc8rIRu9ORyep+SCCCCCCCCCCCCCCCCCCCCCCCCCCCCBqOxQt7CZ4H7Dc8vI + Ru9ORyXFm9Srh+irh+irh+irh+irh+irh+irh+irh+irh+irh+irh+irh+irh+irh+irh+irh+irh+ir + h+irh+irh+irh+irh+irh+irh+irh+irh+irh+irh+irhn0PD7CRNeENIXBNhueZkI3enI+GSPqAkohc + 94wl+dkI3enI+G4TgCiIXNkRS+L+hxLPPyEbvTkfCsioSSQua+huJHpkvsMhG705HwcHArEkkLnLH/nf + R1G77HIRu9OR8EhkEiSSFzW0uLJpbwHJy+yyEbvTkfAo4FAkkoXN4wcDXfCW/aZCN3pyO/SkSOAV/sSS + ULmt/RQ6joG2+0yEbvTkd8lIkf2OIkkoXNlsT/otl22Qjd6cjvUpEpHN/DEklC5nQnnV9DiW9dvkI3en + I7xKRKSd/DEklC5iEscTGBkt9xkI3enI7tKRKSd/DEklC5kCLrP9DXlue5yEbvTkd2lLGN9QkkoXMfDq + Lad0bNy+6yEbvTkd2zTlCSjm7bbbbbV/QDafHu8hG705HguQjd6cjwXIRu9OR4LkI3enI8FyEbvTkeC5 + CN3pyPBchG705HguQjd6cjwXIRu9OR4LkI3enI8FyEbvTkeC5CN3pyPBchG705HguQjd6cjwXIRu9OR4 + LkI3enI8FyEb6Y4TDKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKix + UWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKixUWKix + UWKixUWKixUWKixUWKixUWKixUWOoHUXTT1IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII + IIIIIIIIIIIIIIIIIIIIIIIIX/TX/8QAKRAAAgECBQMEAwEBAAAAAAAAAAERITFBUXHw8RBhsTBAYMFQ + gZGh0f/aAAgBAQABPxBKXNWnWrIECBAgQIECBAgQIECBAgQIECBAgQIECBAgQIECBAgQIECBAgQIECBA + gQIECBAgQIECBAgQIECBAgQIECBAgQHRRVE6k3U5LenSpEkolEolEolEolEolEolEolEolEolEolEolE + olEolEolEolEolEolEolEolEolEolEolEolEolEolEolEolEolEolEolEolEolEolEolErMTTt08Rb0L + B36SsRsmc1fb4KQIECBAgQIECBAgQIECBAgQIECBAgQIECBAgQIECBAgQIECBAgQIECBAgQIECBAgQIE + CBAgQIECBAgQIMWA0BQKb9yTSbv3v08Rb0LPgwjcsph06eIt6FnwYRuWUw6dPEW9Cz4MI3LKYdOniLeh + Z8GEbllMOnTxFvQs+DCNyymHTp4i3oWfBhG5ZTDp08Rb0LPgwjcsph06eIt6FnwYRuWUw6dPEW9Cz4MI + 3LKYdOniLehZ8GEbllMOnTxFvQs+DCNyymHTp4i3oWfBhG5ZTDp08Rb0LPgwjcsph06eIt6FnwYRuWUw + 6dPEW9Cz4MI3LKYdOniLehZ8GEbllMOnTxFvQs94IYhEt0SGqreFWcLx5Owdg7B2DsHYOwdg7B2DsHYE + 7L9sbLIdnN9Pd7llMOnTxFvQs94IR4MlGngP9OH+hQ+jaWL2pTaz1IaK/acPOHnDzh5w84ecPOHnDzh5 + w8bhwlwjwEDSm20tE2/7GpNukJVPB+63LKYdOniLehZ70Q3pKdJFmmqoVKeI2Y/5/epCQ7+mkoSfaSJS + ZNO5Cs4Nym7+hhgPYg+u2va5Dh9vcbllMOnTxFvQs98Im0IeAs01VCMPLAsf8/vUhEnf1EbdK+BJe7dp + VpaLYkY60bPTtKw0XTWD1Gmq/ft9yymHTp4i3oWe+EIk0KaSLNNVQi3xGyvpVsdRMhJzNvUSVF9sSEkJ + r/izRNBjniiEsH9ZjUe23LKYdOniLehZ78Qh0sZeSLNNVQkqUqiRK7wUVYbQnL9RZZIa6R2Ut4eUui6n + G5M3cncTNN0hd/a7llMOnTxFvQs/AiHmAlmmjFNVQo6MuyRTSK/eookO/b1ElES4OPrE8V2GCnyrHvKe + fa5co6X7e03LKYdOniLehZ+BEK5L3A5DfNNVMgFRjf4qX71G0Jz6knQWMJOKmDMHMWJ+5zDr9BadmNNX + 9nuWUw6dPEW9Cz8GItxQIhZpqooEUuyJf5FfvUT2knM+pUhg2a+UPDtrce4bLkx1TxSrFkKtRM5eSly4 + 9luWUw6dPEW9Cz8GIRZCgTMJqonOkuyJf5FfvUszmfUSYIjLUWUmTQ+ao2vNar5K0VHMJVROMdnk+3sd + yymHTp4i3oWfhBCGh0lIzEqpG1M1URL/ACK/eomuE5n1HYmVEzdPERFZHFpTuvPPFhWg4qzQQ01dDZKa + f319yymHTp4i3oWfhhFsCJGLGVUmpsFkS+q/eonOE5n1UlSmveB0qybRWaVu/HEc5iEYlW7jTV1625ZT + Dp08Rb0LPSEUG4cJxJBBBBBBBBBBBBBBBBBBBBBBBBBBAlUkAASGyxTVURTKMcILPtX71E6if+eqssok + e1rpKeSu4zacWTrcxYaabTVvV3LKYdOniLehZ6IjVFBWdssppJqWGZs37Nm/Zs37Nm/Zs37Nm/Zs37Nm + /Zs37Nm/Zs37Nm/Zs37Nm/Zs37Nm/Zs37Nm/Zs37Nm/Zs37Nm/Zs37Nm/Zs37Nm/Zs37Nm/Y90+RHtKz + aHKac0FK22kiW5dvPrLLJDYmhRqbu8U7Ndyf4Sl1p9DThPB2fqbllMOnTxFvQs9EQr/j/KSEdK5D7Ztg + +1mNKv0H6Xl2DUpapnnpn6e5ZTDp08Rb0LPREK/5DyjcFQXgCEk/5k+46NQpSmvOo8E7PUlExb0tyymH + Tp4i3oWeiIV/yPmyxDnZpB5pjJu1X7r1af8Apgu1S6MqJ1729Hcsph06eIt6FnoiFf8AJeXYS4SaSGrz + +iXEs3JK78z/AIyHsGIad0/Q3LKYdOniLehZ6IhX/JeW0lLFmc9iBOVt9MnJZxNBt5zeWcjlxnXL0Nyy + mHTp4i3oWeiIV/yPl0UiVyECdR1bjm3TkpxH2PkZZnVt4rX0dyymHTp4i3oWeiIV/wAh5bhSxbdm2ISS + u28iRMt0iC7cMErAdBuVBuoqzT/t/S3LKYdOniLehZ6QhkpSY5kcyOZHMjmRzI5kcyOZHMjmRzI5kcyO + ZHMjmRzI5kcyOZHMjmRzI5kcyOZHMjmJHwT67aSlk5SgwkMSLiRWLLsxxKZtI4hQhJZenuWUw6dPEW9C + z0RH8K2UIHUnLFdv5718+fPnz58+fPnz58+fPnz58+fPnz58+fPk09Yhk2iqKL/kDpnDhx6zaSl2E4Sl + t3bBFi2P7lSuppu4vtgMZtTbJRHqbllMOnTxFvQs/DCEQFJm2RERE0Tyv6Sx0EARISVkvr1HYak3Nuwh + 7KlZh0eXZColLluOf9d2NPq7llMOnTxFvQs/CiEII4nLIcsei7sF/wBJY6CFREQlSEtPUbgVKqH99YCq + OHYqPle2IQ8KyStN3jOHrbllMOnTxFvQs/CCEMSUvYeebjb8F4ZFjoUBRFCVKLKPUZCqxna6P0qHHJX/ + AEJfFXS5pRYLJ7Dcsph06eIt6Fn4MQlJKVTmzwGcnY+7L/wsSBAFlgll6jcXJyvYVMMoQ8hCi/bgNS9I + NtyluW/Y7llMOnTxFvQs/BiEaoTih7FoX9V5dsdCOoIqKkJZRh6jaSli+qLtZZzkMleKVabev/HkmBkU + ukJT3dKvv7Lcsph06eIt6Fn4EQqjGtGRxHeq9yMSBCKiwSy9RtJSyk/kpGoxXUGYbt2kl3Y9ibaVqez3 + LKYdOniLehZ+AEMaFFm6uLDW4YukNDKbOD/Q7YiFSAQkrJaeoySW4QiMCb8Y2WbeCEFtWKHV/XsSHUbU + Uol7Tcsph06eIt6FnvxDGhRZurixI1KbTlUdqXfYpsTwTEk/4WOhBSEUJTZaem3CkamZEldkWzcFN4ZG + L/zF0LxMhb1/I/g2qF7Xcsph06eIt6FnvhCNoUWbq4FqsU5VGqOPBEBRw9MaT/hY6DlSxFS0JZR6bcCE + rkRaraC/E9szU/cIadVRCrsDDXH2+5ZTDp08Rb0LPeiEbQos3VwIpTdU5ShqjjwMsJaNTGkv+F9FgIqJ + WSy9NtK4gnLtcnqXwUdobaYlXu8jQmCSwS9xuWUw6dPEW9Cz3ghG0KLN1cEZlptOVVVOL6EXRKLTGkv+ + EKaBRQkrJZem3Clk4pc9lUcM6hKrPBwwG05s05ng2p/tFFMEvcbllMOnTxFvQs94IVA8U4qlWO5984Sk + +BEQJKRgkUKFChQoUKFChPcXASVbbohhONwbT5uOTeUwTF7LlVvOYr7rcsph06eIt6FnvBFUugCTVqNM + TUHLv40HGhxocaHGhxocaHGhxocaHGhxoOPwIH30puBqlJRJSaVXXH7vcsph06eIt6FnwYRuWUw6dPEW + 9Cz4MI3LKYdOniLehZ8GEbllMOnTxFvQs+DCNyymHTp4i3oWfBhG5ZTDp08Rb0LPgwjcsph06eIt6Fnw + YRuWUw6dPEW9Cz4MI3LKYdOniLehZ8GEbllMOnTxFvQs+DCNyymHTp4i3oWfBhG5ZTDp08Rb0LPgwjcs + ph06eIt6FnwYRuWUw6dPEW9Cz4MI3LKYdOniLehZ8GEbllMOnTxFvQs+DaN2yjTEZdPEW9Cwe1K6yTUs + 5UcqOVHKjlRyo5UcqOVHKjlRyo5UcqOVHKjlRyo5UcqOVHKjlRyo5UcqOVHKjlRyo5UcqOVHKjlRyo5U + cqOVHKjlRyo5UcqOVHKjlRyo5UcqOVHKjlRyo5UcqOVHKjlRyo5UcqOVHKjlRyo5UcqHsY0JJJZZYn2X + TxFvQSVBLL9tmwzYZsM2GbDNhmwzYZsM2GbDNhmwzYZsM2GbDNhmwzYZsM2GbDNhmwzYZsM2GbDNhmwz + YZsM2GbDNhmwzYZsM2GbDNhmwzYZsM2GbDNhmwzYZsM2GbDNhmwzYZsM2GbDNhmwzYZsM2GbDNhmwzYZ + Jh/ojpKiOniGSSTvHwltJSyoRgRE1briSJEiRIkSJEiRIkSJEiRIkSJEiRIkSJEiRIkSJEiRIkSJEiRI + kSJEiRIkSJEiRIkSJEiRIkSJEiRIkSJEiRIkSguVdz//2Q== + + \ No newline at end of file diff --git a/Cruiser/Cruiser/IMoveableObject.cs b/Cruiser/Cruiser/IMoveableObject.cs new file mode 100644 index 0000000..e7aafaf --- /dev/null +++ b/Cruiser/Cruiser/IMoveableObject.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +using ProjectCruiser.Drawnings; +namespace ProjectCruiser.MovementStrategy +{ + public interface IMoveableObject + { + ObjectParameters? GetObjectPosition { get; } + + int GetStep { get; } + + bool CheckCanMove(DirectionType direction); + + void MoveObject(DirectionType direction); + } +} + diff --git a/Cruiser/Cruiser/IMoveableObject_Realise.cs b/Cruiser/Cruiser/IMoveableObject_Realise.cs new file mode 100644 index 0000000..112131f --- /dev/null +++ b/Cruiser/Cruiser/IMoveableObject_Realise.cs @@ -0,0 +1,38 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +using ProjectCruiser.DrawningObjects; +using ProjectCruiser.Drawnings; + +namespace ProjectCruiser.MovementStrategy +{ + public class DrawningObjectCruiser : IMoveableObject + { + private readonly DrawningCruiser? _drawningCruiser = null; + public DrawningObjectCruiser(DrawningCruiser drawningCruiser) + { + _drawningCruiser = drawningCruiser; + } + public ObjectParameters? GetObjectPosition + { + get + { + if (_drawningCruiser == null || _drawningCruiser.EntityCruiser == + null) + { + return null; + } + return new ObjectParameters(_drawningCruiser.GetPosX, + _drawningCruiser.GetPosY, _drawningCruiser.GetWidth, _drawningCruiser.GetHeight); + } + } + public int GetStep => (int)(_drawningCruiser?.EntityCruiser?.Step ?? 0); + public bool CheckCanMove(DirectionType direction) => + _drawningCruiser?.CanMove(direction) ?? false; + public void MoveObject(DirectionType direction) => + _drawningCruiser?.MoveTransport(direction); + } +} diff --git a/Cruiser/Cruiser/MoveToBorder.cs b/Cruiser/Cruiser/MoveToBorder.cs new file mode 100644 index 0000000..93c13e0 --- /dev/null +++ b/Cruiser/Cruiser/MoveToBorder.cs @@ -0,0 +1,44 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ProjectCruiser.MovementStrategy +{ + public class MoveToBorder : AbstractStrategy + { + protected override bool IsTargetDestinaion() + { + var objParams = GetObjectParameters; + if (objParams == null) + { + return false; + } + return objParams.RightBorder <= FieldWidth && + objParams.RightBorder + GetStep() >= FieldWidth && + objParams.DownBorder <= FieldHeight && + objParams.DownBorder + GetStep() >= FieldHeight; + } + + protected override void MoveToTarget() + { + var objParams = GetObjectParameters; + if (objParams == null) + { + return; + } + var diffX = objParams.RightBorder - FieldWidth; + if (Math.Abs(diffX) > GetStep()) + { + MoveRight(); + } + var diffY = objParams.DownBorder - FieldHeight; + if (Math.Abs(diffY) > GetStep()) + { + MoveDown(); + } + } + } +} + diff --git a/Cruiser/Cruiser/MoveToCenter.cs b/Cruiser/Cruiser/MoveToCenter.cs new file mode 100644 index 0000000..96ecab0 --- /dev/null +++ b/Cruiser/Cruiser/MoveToCenter.cs @@ -0,0 +1,64 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ProjectCruiser.MovementStrategy +{ + public class MoveToCenter : AbstractStrategy + { + protected override bool IsTargetDestinaion() + { + var objParams = GetObjectParameters; + if (objParams == null) + { + return false; + } + return objParams.ObjectMiddleHorizontal <= FieldWidth / 2 && + objParams.ObjectMiddleHorizontal + GetStep() >= FieldWidth / 2 && + objParams.ObjectMiddleVertical <= FieldHeight / 2 && + objParams.ObjectMiddleVertical + GetStep() >= FieldHeight / 2; + } + protected override void MoveToTarget() + { + var objParams = GetObjectParameters; + if (objParams == null) + { + return; + } + + var diffX = objParams.ObjectMiddleHorizontal - FieldWidth / 2; + var diffY = objParams.ObjectMiddleVertical - FieldHeight / 2; + + if (Math.Abs(diffX) > GetStep() || Math.Abs(diffY) > GetStep()) + { + if (Math.Abs(diffX) > GetStep()) + { + if (diffX > 0) + { + MoveLeft(); + } + else + { + MoveRight(); + } + } + + if (Math.Abs(diffY) > GetStep()) + { + if (diffY > 0) + { + MoveUp(); + } + else + { + MoveDown(); + } + } + } + } + + } +} + diff --git a/Cruiser/Cruiser/ObjectParameters.cs b/Cruiser/Cruiser/ObjectParameters.cs new file mode 100644 index 0000000..7eac0cb --- /dev/null +++ b/Cruiser/Cruiser/ObjectParameters.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ProjectCruiser.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; + } + } +} diff --git a/Cruiser/Cruiser/Program.cs b/Cruiser/Cruiser/Program.cs index 626bc14..4e00cd8 100644 --- a/Cruiser/Cruiser/Program.cs +++ b/Cruiser/Cruiser/Program.cs @@ -1,4 +1,4 @@ -namespace Cruiser +namespace ProjectCruiser { internal static class Program { diff --git a/Cruiser/Cruiser/Properties/Resources.Designer.cs b/Cruiser/Cruiser/Properties/Resources.Designer.cs index d06e6fd..24bc627 100644 --- a/Cruiser/Cruiser/Properties/Resources.Designer.cs +++ b/Cruiser/Cruiser/Properties/Resources.Designer.cs @@ -8,7 +8,7 @@ // //------------------------------------------------------------------------------ -namespace Cruiser.Properties { +namespace ProjectCruiser.Properties { using System; @@ -39,7 +39,7 @@ namespace Cruiser.Properties { internal static global::System.Resources.ResourceManager ResourceManager { get { if (object.ReferenceEquals(resourceMan, null)) { - global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Cruiser.Properties.Resources", typeof(Resources).Assembly); + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ProjectCruiser.Properties.Resources", typeof(Resources).Assembly); resourceMan = temp; } return resourceMan; diff --git a/Cruiser/Cruiser/Status.cs b/Cruiser/Cruiser/Status.cs new file mode 100644 index 0000000..ac56068 --- /dev/null +++ b/Cruiser/Cruiser/Status.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ProjectCruiser.MovementStrategy +{ + public enum Status + { + NotInit, + InProgress, + Finish + } +}