From 719568bc03b9082c23f918f8d6b8b24298c45dd0 Mon Sep 17 00:00:00 2001 From: "leonteva.v" Date: Tue, 2 Apr 2024 13:06:18 +0400 Subject: [PATCH] =?UTF-8?q?1=20=D0=BB=D0=B0=D0=B1=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ProjectBattleship/DirectionType.cs | 10 + .../ProjectBattleship/DrawingBattleship.cs | 152 ++ .../ProjectBattleship/EntityBattleship.cs | 22 + .../ProjectBattleship/Form1.Designer.cs | 39 - ProjectBattleship/ProjectBattleship/Form1.cs | 10 - .../FormBattleship.Designer.cs | 137 ++ .../ProjectBattleship/FormBattleship.cs | 66 + .../ProjectBattleship/FormBattleship.resx | 2152 +++++++++++++++++ .../ProjectBattleship/Program.cs | 2 +- .../ProjectBattleship.csproj | 15 + .../Properties/Resources.Designer.cs | 63 + .../Properties/Resources.resx | 120 + .../ProjectBattleship/Resources/down.png | Bin 0 -> 256 bytes .../ProjectBattleship/Resources/left.png | Bin 0 -> 269 bytes .../ProjectBattleship/Resources/right.png | Bin 0 -> 257 bytes .../ProjectBattleship/Resources/up.png | Bin 0 -> 250 bytes 16 files changed, 2738 insertions(+), 50 deletions(-) create mode 100644 ProjectBattleship/ProjectBattleship/DirectionType.cs create mode 100644 ProjectBattleship/ProjectBattleship/DrawingBattleship.cs create mode 100644 ProjectBattleship/ProjectBattleship/EntityBattleship.cs delete mode 100644 ProjectBattleship/ProjectBattleship/Form1.Designer.cs delete mode 100644 ProjectBattleship/ProjectBattleship/Form1.cs create mode 100644 ProjectBattleship/ProjectBattleship/FormBattleship.Designer.cs create mode 100644 ProjectBattleship/ProjectBattleship/FormBattleship.cs create mode 100644 ProjectBattleship/ProjectBattleship/FormBattleship.resx create mode 100644 ProjectBattleship/ProjectBattleship/Properties/Resources.Designer.cs create mode 100644 ProjectBattleship/ProjectBattleship/Properties/Resources.resx create mode 100644 ProjectBattleship/ProjectBattleship/Resources/down.png create mode 100644 ProjectBattleship/ProjectBattleship/Resources/left.png create mode 100644 ProjectBattleship/ProjectBattleship/Resources/right.png create mode 100644 ProjectBattleship/ProjectBattleship/Resources/up.png diff --git a/ProjectBattleship/ProjectBattleship/DirectionType.cs b/ProjectBattleship/ProjectBattleship/DirectionType.cs new file mode 100644 index 0000000..32380cc --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/DirectionType.cs @@ -0,0 +1,10 @@ +namespace ProjectBattleship +{ + public enum DirectionType + { + Up = 1, + Down = 2, + Left = 3, + Right = 4 + } +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/DrawingBattleship.cs b/ProjectBattleship/ProjectBattleship/DrawingBattleship.cs new file mode 100644 index 0000000..79ca5e4 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/DrawingBattleship.cs @@ -0,0 +1,152 @@ +namespace ProjectBattleship +{ + public class DrawingBattleship + { + public EntityBattleship? EntityBattleship { get; private set; } + private int? _pictureWidth; + private int? _pictureHeight; + private int? _startPosX; + private int? _startPosY; + private readonly int _shipWidth = 150; + private readonly int _shipHeight = 50; + public void Init(int speed, double weight, Color bodyColor, Color additionalColor, bool turret, bool rocketLauncher) + { + EntityBattleship = new EntityBattleship(); + EntityBattleship.Init(speed, weight, bodyColor, additionalColor, turret, rocketLauncher); + _pictureWidth = null; + _pictureHeight = null; + _startPosX = null; + _startPosY = null; + } + public bool SetPictureSize(int width, int height) + { + if (width >= _shipWidth || height >= _shipHeight) + { + _pictureWidth = width; + _pictureHeight = height; + if (_startPosX != null && _startPosY != null) + { + SetPosition(_startPosX.Value, _startPosY.Value); + } + return true; + } + return false; + } + public void SetPosition(int x, int y) + { + if (!_pictureHeight.HasValue || !_pictureWidth.HasValue) + { + return; + } + if (x < 0) + { + x = 0; + } + else if (x > _pictureWidth - _shipWidth) + { + x = _pictureWidth.Value - _shipWidth; + } + if (y < 0) + { + y = 0; + } + else if (y > _pictureHeight - _shipHeight) + { + y = _pictureHeight.Value - _shipHeight; + } + _startPosX = x; + _startPosY = y; + } + public bool MoveTransport(DirectionType direction) + { + if (EntityBattleship == null || !_startPosX.HasValue || !_startPosY.HasValue) + { + return false; + } + switch (direction) + { + // Влево + case DirectionType.Left: + if (_startPosX.Value - EntityBattleship.Step > 0) + { + _startPosX -= (int)EntityBattleship.Step; + } + return true; + //Вверх + case DirectionType.Up: + if (_startPosY.Value - EntityBattleship.Step > 0) + { + _startPosY -= (int)EntityBattleship.Step; + } + return true; + //Вправо + case DirectionType.Right: + { + if (_startPosX.Value + _shipWidth + EntityBattleship.Step < _pictureWidth) + { + _startPosX += (int)EntityBattleship.Step; + } + } + return true; + //Вниз + case DirectionType.Down: + { + if (_startPosY.Value + _shipHeight + EntityBattleship.Step < _pictureHeight) + { + _startPosY += (int)EntityBattleship.Step; + } + } + return true; + default: + return false; + } + } + public void DrawTransport(Graphics g) + { + if (EntityBattleship == null || !_startPosX.HasValue || !_startPosY.HasValue) + { + return; + } + Pen pen = new(Color.Black); + Brush additionalBrush = new SolidBrush(EntityBattleship.AdditionalColor); + Brush bodyBrush = new SolidBrush(EntityBattleship.BodyColor); + //корпус + Point[] hull = new Point[] {new Point(_startPosX.Value + 5, _startPosY.Value), new Point(_startPosX.Value + 100, _startPosY.Value), + new Point(_startPosX.Value + 150, _startPosY.Value + 25), new Point(_startPosX.Value + 100, _startPosY.Value + 50), new Point(_startPosX.Value + 5, _startPosY.Value + 50)}; + g.FillPolygon(bodyBrush, hull); + g.DrawPolygon(pen, hull); + Brush brBlack = new SolidBrush(Color.Black); + g.FillRectangle(brBlack, _startPosX.Value, _startPosY.Value + 6, 5, 13); + g.FillRectangle(brBlack, _startPosX.Value, _startPosY.Value + 31, 5, 13); + //надстройки + Brush brDark = new SolidBrush(Color.DarkGray); + g.FillRectangle(brDark, _startPosX.Value + 39, _startPosY.Value + 20, 40, 10); + g.DrawRectangle(pen, _startPosX.Value + 39, _startPosY.Value + 20, 40, 10); + g.FillRectangle(brDark, _startPosX.Value + 70, _startPosY.Value + 12, 18, 26); + g.DrawRectangle(pen, _startPosX.Value + 70, _startPosY.Value + 12, 18, 26); + g.FillEllipse(brBlack, _startPosX.Value + 94, _startPosY.Value + 19, 12, 12); + //орудийная башня + if (EntityBattleship.Turret) + { + Point[] shield = new Point[] {new Point(_startPosX.Value + 112, _startPosY.Value + 19), new Point(_startPosX.Value + 112, _startPosY.Value + 31), + new Point(_startPosX.Value + 119, _startPosY.Value + 28), new Point(_startPosX.Value + 119, _startPosY.Value + 22)}; + g.FillPolygon(additionalBrush, shield); + g.FillRectangle(additionalBrush, _startPosX.Value + 119, _startPosY.Value + 24, 12, 2); + g.DrawPolygon(pen, shield); + g.DrawRectangle(pen, _startPosX.Value + 119, _startPosY.Value + 24, 12, 2); + } + //ячейки для ракет + if (EntityBattleship.RocketLauncher) + { + g.FillRectangle(additionalBrush, _startPosX.Value + 14, _startPosY.Value + 14, 10, 10); + g.FillRectangle(additionalBrush, _startPosX.Value + 26, _startPosY.Value + 14, 10, 10); + g.FillRectangle(additionalBrush, _startPosX.Value + 14, _startPosY.Value + 26, 10, 10); + g.FillRectangle(additionalBrush, _startPosX.Value + 26, _startPosY.Value + 26, 10, 10); + g.DrawRectangle(pen, _startPosX.Value + 14, _startPosY.Value + 14, 10, 10); + g.DrawRectangle(pen, _startPosX.Value + 26, _startPosY.Value + 14, 10, 10); + g.DrawRectangle(pen, _startPosX.Value + 14, _startPosY.Value + 26, 10, 10); + g.DrawRectangle(pen, _startPosX.Value + 26, _startPosY.Value + 26, 10, 10); + } + } + } +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/EntityBattleship.cs b/ProjectBattleship/ProjectBattleship/EntityBattleship.cs new file mode 100644 index 0000000..70aca75 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/EntityBattleship.cs @@ -0,0 +1,22 @@ +namespace ProjectBattleship +{ + public class EntityBattleship + { + public int Speed { get; private set; } + public double Weight { get; private set; } + public Color BodyColor { get; private set; } + public Color AdditionalColor { get; private set; } + public bool Turret { get; private set; } + public bool RocketLauncher { get; private set; } + public double Step => (double)Speed * 100 / Weight; + public void Init(int speed, double weight, Color bodyColor, Color additionalColor, bool turret, bool rocketLauncher) + { + Speed = speed; + Weight = weight; + BodyColor = bodyColor; + AdditionalColor = additionalColor; + Turret = turret; + RocketLauncher = rocketLauncher; + } + } +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/Form1.Designer.cs b/ProjectBattleship/ProjectBattleship/Form1.Designer.cs deleted file mode 100644 index d6ab4c3..0000000 --- a/ProjectBattleship/ProjectBattleship/Form1.Designer.cs +++ /dev/null @@ -1,39 +0,0 @@ -namespace ProjectBattleship -{ - partial class Form1 - { - /// - /// Required designer variable. - /// - private System.ComponentModel.IContainer components = null; - - /// - /// Clean up any resources being used. - /// - /// true if managed resources should be disposed; otherwise, false. - protected override void Dispose(bool disposing) - { - if (disposing && (components != null)) - { - components.Dispose(); - } - base.Dispose(disposing); - } - - #region Windows Form Designer generated code - - /// - /// Required method for Designer support - do not modify - /// the contents of this method with the code editor. - /// - private void InitializeComponent() - { - this.components = new System.ComponentModel.Container(); - this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; - this.ClientSize = new System.Drawing.Size(800, 450); - this.Text = "Form1"; - } - - #endregion - } -} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/Form1.cs b/ProjectBattleship/ProjectBattleship/Form1.cs deleted file mode 100644 index 6619484..0000000 --- a/ProjectBattleship/ProjectBattleship/Form1.cs +++ /dev/null @@ -1,10 +0,0 @@ -namespace ProjectBattleship -{ - public partial class Form1 : Form - { - public Form1() - { - InitializeComponent(); - } - } -} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/FormBattleship.Designer.cs b/ProjectBattleship/ProjectBattleship/FormBattleship.Designer.cs new file mode 100644 index 0000000..6011277 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/FormBattleship.Designer.cs @@ -0,0 +1,137 @@ +namespace ProjectBattleship +{ + partial class FormBattleship + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FormBattleship)); + pictureBoxBattleship = new PictureBox(); + buttonCreate = new Button(); + buttonLeft = new Button(); + buttonUp = new Button(); + buttonDown = new Button(); + buttonRight = new Button(); + ((System.ComponentModel.ISupportInitialize)pictureBoxBattleship).BeginInit(); + SuspendLayout(); + // + // pictureBoxBattleship + // + pictureBoxBattleship.Dock = DockStyle.Fill; + pictureBoxBattleship.Location = new Point(0, 0); + pictureBoxBattleship.Margin = new Padding(3, 4, 3, 4); + pictureBoxBattleship.Name = "pictureBoxBattleship"; + pictureBoxBattleship.Size = new Size(922, 598); + pictureBoxBattleship.SizeMode = PictureBoxSizeMode.AutoSize; + pictureBoxBattleship.TabIndex = 0; + pictureBoxBattleship.TabStop = false; + // + // buttonCreate + // + buttonCreate.Location = new Point(38, 500); + buttonCreate.Name = "buttonCreate"; + buttonCreate.Size = new Size(121, 62); + buttonCreate.TabIndex = 1; + buttonCreate.Text = "Создать"; + buttonCreate.UseVisualStyleBackColor = true; + buttonCreate.Click += buttonCreate_Click; + // + // buttonLeft + // + buttonLeft.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonLeft.BackgroundImage = (Image)resources.GetObject("buttonLeft.BackgroundImage"); + buttonLeft.BackgroundImageLayout = ImageLayout.Zoom; + buttonLeft.Location = new Point(734, 525); + buttonLeft.Name = "buttonLeft"; + buttonLeft.Size = new Size(39, 37); + buttonLeft.TabIndex = 2; + buttonLeft.UseVisualStyleBackColor = true; + buttonLeft.Click += ButtonMove_Click; + // + // buttonUp + // + buttonUp.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonUp.BackgroundImage = (Image)resources.GetObject("buttonUp.BackgroundImage"); + buttonUp.BackgroundImageLayout = ImageLayout.Zoom; + buttonUp.Location = new Point(794, 471); + buttonUp.Name = "buttonUp"; + buttonUp.Size = new Size(39, 37); + buttonUp.TabIndex = 3; + buttonUp.UseVisualStyleBackColor = true; + buttonUp.Click += ButtonMove_Click; + // + // buttonDown + // + buttonDown.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonDown.BackgroundImage = (Image)resources.GetObject("buttonDown.BackgroundImage"); + buttonDown.BackgroundImageLayout = ImageLayout.Zoom; + buttonDown.Location = new Point(794, 525); + buttonDown.Name = "buttonDown"; + buttonDown.Size = new Size(39, 37); + buttonDown.TabIndex = 4; + buttonDown.UseVisualStyleBackColor = true; + buttonDown.Click += ButtonMove_Click; + // + // buttonRight + // + buttonRight.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonRight.BackgroundImage = (Image)resources.GetObject("buttonRight.BackgroundImage"); + buttonRight.BackgroundImageLayout = ImageLayout.Zoom; + buttonRight.Location = new Point(854, 525); + buttonRight.Name = "buttonRight"; + buttonRight.Size = new Size(39, 37); + buttonRight.TabIndex = 5; + buttonRight.UseVisualStyleBackColor = true; + buttonRight.Click += ButtonMove_Click; + // + // FormBattleship + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(922, 598); + Controls.Add(buttonRight); + Controls.Add(buttonDown); + Controls.Add(buttonUp); + Controls.Add(buttonLeft); + Controls.Add(buttonCreate); + Controls.Add(pictureBoxBattleship); + Name = "FormBattleship"; + Text = "Линкор"; + ((System.ComponentModel.ISupportInitialize)pictureBoxBattleship).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private PictureBox pictureBoxBattleship; + private Button buttonCreate; + private Button buttonLeft; + private Button buttonUp; + private Button buttonDown; + private Button buttonRight; + } +} \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/FormBattleship.cs b/ProjectBattleship/ProjectBattleship/FormBattleship.cs new file mode 100644 index 0000000..4e1edd6 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/FormBattleship.cs @@ -0,0 +1,66 @@ +namespace ProjectBattleship +{ + public partial class FormBattleship : Form + { + private DrawingBattleship? _drawingBattleship; + public FormBattleship() + { + InitializeComponent(); + } + private void Draw() + { + if (_drawingBattleship == null) + { + return; + } + Bitmap bmp = new Bitmap(pictureBoxBattleship.Width, pictureBoxBattleship.Height); + Graphics gr = Graphics.FromImage(bmp); + _drawingBattleship.DrawTransport(gr); + pictureBoxBattleship.Image = bmp; + } + private void buttonCreate_Click(object sender, EventArgs e) + { + Random random = new Random(); + _drawingBattleship = new DrawingBattleship(); + _drawingBattleship.Init(random.Next(100, 300), random.Next(1000, 3000), + Color.FromArgb(random.Next(0, 256), random.Next(0, 256), random.Next(0, 256)), + Color.FromArgb(random.Next(0, 256), random.Next(0, 256), random.Next(0, 256)), + Convert.ToBoolean(random.Next(0, 2)), Convert.ToBoolean(random.Next(0, 2))); + _drawingBattleship.SetPictureSize(pictureBoxBattleship.Width, pictureBoxBattleship.Height); + _drawingBattleship.SetPosition(random.Next(10, 100), random.Next(10, 100)); + Draw(); + } + private void ButtonMove_Click(object sender, EventArgs e) + { + if (_drawingBattleship == null) + { + return; + } + string name = ((Button)sender)?.Name ?? string.Empty; + bool result = false; + switch (name) + { + case "buttonUp": + result = + _drawingBattleship.MoveTransport(DirectionType.Up); + break; + case "buttonDown": + result = + _drawingBattleship.MoveTransport(DirectionType.Down); + break; + case "buttonLeft": + result = + _drawingBattleship.MoveTransport(DirectionType.Left); + break; + case "buttonRight": + result = + _drawingBattleship.MoveTransport(DirectionType.Right); + break; + } + if (result) + { + Draw(); + } + } + } +} diff --git a/ProjectBattleship/ProjectBattleship/FormBattleship.resx b/ProjectBattleship/ProjectBattleship/FormBattleship.resx new file mode 100644 index 0000000..ff5cab1 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/FormBattleship.resx @@ -0,0 +1,2152 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + iVBORw0KGgoAAAANSUhEUgAAB44AAAOdCAYAAAB6bE8jAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + wwAADsMBx2+oZAAAahtJREFUeF7s3V+MnXW99/0JIcYQY2rtXH/X/Ok4ljKdmc4MxhBjjDHGGLNjdnY8 + eA7u7EMOnoN9SO4z4iGHHvbANO261hQGEbACKmI3GCKGiOE2hJjG26cCIgICYsFSy/VcA617XOsH9M/M + rN+11uudvA7uvRWms9a6muxPvveakCRJktrQ8TSdvX1i4rqL/09JkiRJkiRJkiRJ0jjVy8pvVWnx6sbC + wscu/o8kSZIkSZIkSZIkSePQepIkvbS4t0qLepPhWJIkSZIkSZIkSZLGqItXxi9fGo0Nx5IkSZIkSZIk + SZI0Jh1P06SXlfdsHYwNx5IkSZIkSZIkSZI0JlVZ+a1u35XxVoZjSZIkSZIkSZIkSRrRju6Z3dNNyyOh + sXgrw7EkSZIkSZIkSZIkjWC9rPONKi1e6B+JQwzHkiRJkiRJkiRJkjRCbXxq7pOXc2W8leFYkiRJkiRJ + kiRJkkakXpJ/rUqK50Lj8IcxHEuSJEmSJEmSJElSy6v27r3iK+OtDMeSJEmSJEmSJEmS1OK6SfHVKi3O + 9I/BV8JwLEmSJEmSJEmSJEkt7Oie2T1VUhwLDcFXynAsSZIkSZIkSZIkSS2rSoovVGlxun8AvlqGY0mS + JEmSJEmSJElqSRudzse7SXFHlRYX+sffa2E4liRJkiRJkiRJkqQWtJ6Ut/Sy4reh4fdaGY4lSZIkSZIk + SZIkKeKOzs7uyJXxVoZjSZIkSZIkSZIkSYq0Ki1vqdLi2f6hd7sZjiVJkiRJkiRJkiQpsnbjyngrw7Ek + SZIkSZIkSZIkRVQ3KZertHi6f9zdSYZjSZIkSZIkSZIkSYqgIxM3X9/LituqtDjfP+zuNMOxJEmSJEmS + JEmSJA259aS8pUqK34ZG3d1gOJYkSZIkSZIkSZKkIXVqYuLSlfG5/jF3NxmOJUmSJEmSJEmSJGkIHU/T + xSopfhUacneb4ViSJEmSJEmSJEmSdrFLV8bdIV8Zb2U4liRJkiRJkiRJkqRdaj3LFqq0fDI03g6T4ViS + JEmSJEmSJEmSdriNiYnrYrsy3spwLEmSJEmSJEmSJEk72J3J1FyVFD8PDbaxMBxLkiRJkiRJkiRJ0g5U + N3pJfmuVFmf7h9rYGI4lSZIkSZIkSZIkaZvrJclcNy0fDY20MTIcS5IkSZIkSZIkSdI2tfldxlWa/+9Y + v8v4gxiOJUmSJEmSJEmSJGkbOpFls1VanOofZdvAcCxJkiRJkiRJkiRJ19CW7zJ+s3+QbQvDsSRJkiRJ + kiRJkiRdZb08n67S4pH+IbZtDMeSJEmSJEmSJEmSdBV1k/I/qxZfGW9lOJYkSZIkSZIkSZKkK6i7bybr + psXJ0ADbVoZjSZIkSZIkSZIkSbrMeln5rSotXu0fXtvOcCxJkiRJkiRJkiRJH9HRycmsSov7+wfXUWE4 + liRJkiRJkiRJkqQPaVSvjLcyHEuSJEmSJEmSJElSoPUkSaq0uLd/ZB1FhmNJkiRJkiRJkiRJ6uvilfHL + /QPrqDIcS5IkSZIkSZIkSdLFNrJsX5Xkd4fG1VFmOJYkSZIkSZIkSZKkpl6S/68qLV7rH1VjsJGV9bM3 + Hgz+77aD4ViSJEmSJEmSJEnSWHd0z+yebloeCQ2qMfjx9Gz918Mr9d9XV4P/++1gOJYkSZIkSZIkSZI0 + tvWyzjeqtHihf0iNwYmsrJ85cGP97s0313XDcCxJkiRJkiRJkiRJ29jGp+Y+GfuV8RvLh98bjC8xHEuS + JEmSJEmSJEnSNtWdzL9eJcVzoQF12PqvjA3HkiRJkiRJkiRJkrSNVXv3Rn1l/KOpmfqNw/96ZbyV4ViS + JEmSJEmSJEmSrqEqKb5WpZFfGa+tBQfjSwzHkiRJkiRJkiRJknQVteHK+PUPuTLeynAsSZIkSZIkSZIk + SVfY+mT+xSotTvePpDFYz4r66c8e+Mgr460Mx5IkSZIkSZIkSZJ0mR0pihu6SXFHlRYX+gfSGPywM13/ + ZWk5OA5/GMOxJEmSJEmSJEmSJF1G3aT4QhXxlfFT8wfqC4FR+HIYjiVJkiRJkiRJkiTpQ9rodD4e+5Xx + q8tXfmW8leFYkiRJkiRJkiRJkj6g9aS8pUqK34YG0WHrZeU1XRlvZTiWJEmSJEmSJEmSpL6Ozs5GfWV8 + sjNTv3KNV8ZbGY4lSZIkSZIkSZIkaUvH087nq7R4tn8AjcF2XhlvZTiWJEmSJEmSJEmSpKYjEzdf382K + b1exXhmX0/UrS9t3ZbyV4ViSJEmSJEmSJEnS2LeedJartPh1/+gZg17jibn5+vzaWnD03Q6GY0mSJEmS + JEmSJElj2+aVcS8rbqvS4lz/4BmD+8rp+qWlpeDYu50Mx5IkSZIkSZIkSZLGsirtLFZJ8avQ2BmDnb4y + 3spwLEmSJEmSJEmSJGmsOjUxEf2V8Z8Wd/7KeCvDsSRJkiRJkiRJkqSxaT3LFnpp8WRo4IzBbl4Zb2U4 + liRJkiRJkiRJkjTyXboy7kZ6ZXxvMVW/uMtXxlsZjiVJkiRJkiRJkiSNdFWWLVRpGfWV8Turq8FBd7cY + jiVJkiRJkiRJkiSNZLdPTFzXTfP/qtLi7f4xMwbvXRkfWgwOubvNcCxJkiRJkiRJkiRp5LozmZqrkuLR + 0JAZg8dm5+pzQ/gu4w9iOJYkSZIkSZIkSZI0MtWNXpLfWqXF2f4BMwb3FFP1cwuHguPtMBmOJUmSJEmS + JEmSJI1Ex9N0tkrzU6HxMgbvXRkP+buMP4jhWJIkSZIkSZIkSVKr23Jl/Gb/aBmD7xVT9R8ivDLeynAs + SZIkSZIkSZIkqbWdyLLZXlo8EhosY7B5Zbw5yobG2pgYjiVJkiRJkiRJkiS1ruivjPNO9FfGWxmOJUmS + JEmSJEmSJLWqXp5PV2nxcP9AGYu2XBlvZTiWJEmSJEmSJEmS1Jp6WfmtKi1e6x8nY7CRlfX/PXhTcJiN + neFYkiRJkiRJkiRJUvQdnZzMqrS4v3+UjMWpmf31WyvtujLeynAsSZIkSZIkSZIkKeouXhm/2j9IxmAj + L+vTLb0y3spwLEmSJEmSJEmSJCnK1pMk6aXFvaExMgY/m5mrz7b4yngrw7EkSZIkSZIkSZKk6Ir5yviu + Ebky3spwLEmSJEmSJEmSJCmajqdpUmXlPaEBMgaPzOyvz66sBMfXNjMcS5IkSZIkSZIkSYqii1fGL/cP + jzG4K++M3JXxVoZjSZIkSZIkSZIkSUNtI8v2VUl+d2h0jMHmlfHfRvDKeCvDsSRJkiRJkiRJkqSh1c3K + b1Rp8UL/2BiDO7OyfubAjfW7gaF11BiOJUmSJEmSJEmSJO16R/fM7umm5ZHQ0BiDH0/P1n89PNpXxlsZ + jiVJkiRJkiRJkiTtalWWfb2K9Mr4xBhdGW9lOJYkSZIkSZIkSZK0K218au6TsV8Zv7F8ODisjjrDsSRJ + kiRJkiRJkqQdr5fkX6uS4rnQsDhs/7wyXlsLjqrjwHAsSZIkSZIkSZIkaceq9u6N+sr4R1Mz9RuHx/PK + eCvDsSRJkiRJkiRJkqQdqZsUX63S4kz/kBgDV8b/ynAsSZIkSZIkSZIkaVs7UhQ3VGnxnf4BMRYPTc3U + r7sy/heGY0mSJEmSJEmSJEnb1vpk/sUqLU73j4cxWM+K+qn5A/WFtfB4Os4Mx5IkSZIkSZIkSZKuuY1O + 5+PdpLijSosL/cNhDH7Yma7/srQcHE0xHEuSJEmSJEmSJEm6xrpJ8YVeVvw2NBoOWy8r378yDoyl/A/D + sSRJkiRJkiRJkqSrKv4r45n61WVXxpfDcCxJkiRJkiRJkiTpiqvS8pYqcWU8KgzHkiRJkiRJkiRJki67 + o7OzUV8Zn+zM1K+4Mr5ihmNJkiRJkiRJkiRJl1Uv63y+Sotn+4fBGLgyvjaGY0mSJEmSJEmSJEkf2pGJ + m6/vZcVtVVqc7x8FY3BfOVW/tLQUHES5PIZjSZIkSZIkSZIkSR/YetJZ7mbFr0ODYAyemJuvz6+tBcdQ + Lp/hWJIkSZIkSZIkSdJApyYmLl0Zn+sfAmNwXzldv7S4GBxBuXKGY0mSJEmSJEmSJEn/0vE0XayS4leh + ETAGroy3n+FYkiRJkiRJkiRJ0nvFfmV8bzFV/2nRdxnvBMOxJEmSJEmSJEmSpIn1LFvopcWToeEvBq6M + d5bhWJIkSZIkSZIkSRrjLl0ZdyO+Mn7RlfGOMxxLkiRJkiRJkiRJY9rxPD9YpfkvQ2NfDB6fm6/fWV0N + Dp1sL8OxJEmSJEmSJEmSNGbdPjFxXS/Jb63S4mz/yBeDe4pO/fyhxeDAyc4wHEuSJEmSJEmSJEljVC9J + 5qqkeDQ08MXgsdm5+pwr411nOJYkSZIkSZIkSZLGoLoR95XxVP3cwqHgqMnOMxxLkiRJkiRJkiRJI97x + NJ2t0uJU/6AXi80r483hMjRosjsMx5IkSZIkSZIkSdKItuXK+M3+MS8G3yum6j+4Mo6C4ViSJEmSJEmS + JEkawXp5Pl2lxSP9I14sXBnHxXAsSZIkSZIkSZIkjVDRXxnnnfrMTQvB8ZLhMRxLkiRJkiRJkiRJI1J3 + 30xWpcXJ/uEuFq6M42U4liRJkiRJkiRJkkagXlZ+q0qL1/pHuxhs5GV9+uBNwcGSOBiOJUmSJEmSJEmS + pBZ3dHJy88r4/v6xLhY/m9lfv7Xiyjh2hmNJkiRJkiRJkiSppV28Mn61f6iLgSvjdjEcS5IkSZIkSZIk + SS1rPUmSKi3u7R/oYrF5ZXx2ZSU4UBInw7EkSZIkSZIkSZLUoi5eGb/cP87F4C5Xxq1lOJYkSZIkSZIk + SZJa0PE0TXpZeU9omIvBI66MW81wLEmSJEmSJEmSJEXe5pVxN9or444r4xFgOJYkSZIkSZIkSZIirTc9 + vafKym5ojIvBT6Zm678edmU8CgzHkiRJkiRJkiRJUoT1ss43qrR4oX+Ei8GdWVk/c+DG+t3AAEk7GY4l + SZIkSZIkSZKkiDq6Z3ZPNy2PhAa4GPx42pXxKDIcS5IkSZIkSZIkSZFUZdnXq0ivjE+4Mh5phmNJkiRJ + kiRJkiRpyG18au6TMV8Z/2hqpn7j8OHg4MhoMBxLkiRJkiRJkiRJQ6yX5F+r0uK5/rEtBv+8Ml5bC46N + jA7DsSRJkiRJkiRJkjSEqr17XRkTDcOxJEmSJEmSJEmStMv1kuKrVVqc6R/YYuDKeDwZjiVJkiRJkiRJ + kqRd6khR3NBNijuqtLjQP67F4IHOdP2XpeXgsMhoMxxLkiRJkiRJkiRJu1CVFF+o0uJ0/6gWg/WsqJ+a + P1BfWAuPiow+w7EkSZIkSZIkSZK0g210Oh+P+cr4h66MaRiOJUmSJEmSJEmSpB1qPSlv6WXFb0Nj2rD1 + svL9K+PAiMj4MRxLkiRJkiRJkiRJ29zR2dnIr4xn6leXXRnzPwzHkiRJkiRJkiRJ0jZWpeUtVVo82z+e + xcCVMR/EcCxJkiRJkiRJkiRtQ7FfGZ8sp+tXlpaCoyEYjiVJkiRJkiRJkqRrrJuUy1VaPN0/mMWg13jy + M591ZcyHMhxLkiRJkiRJkiRJV9mRiZuv72XFbVVanO8fy2JwXzlVv+TKmMtgOJYkSZIkSZIkSZKuovWk + s9zNil+HhrIYPDE3X59fWwuOhNDPcCxJkiRJkiRJkiRdQacmJi5dGZ/rH8hicF85Xf9p0ZUxV8ZwLEmS + JEmSJEmSJF1mx9N0sUqKX4XGsRi4MuZqGY4lSZIkSZIkSZKkj+jSlXE30ivje4up+kVXxlwDw7EkSZIk + SZIkSZL0IVVZtlCl5ZOhQSwGm1fG76yuBsdAuFyGY0mSJEmSJEmSJCnQxsTEddFfGR9aDI6AcKUMx5Ik + SZIkSZIkSVJfdyZTc1VS/Dw0gsXgsdm5+pzvMmYbGY4lSZIkSZIkSZKki9WNXpLfWqXF2f7xKwb3FJ36 + eVfG7ADDsSRJkiRJkiRJktTUS5K5blo+Ghq+YvDelbHvMmaHGI4lSZIkSZIkSZI01m25Mn6zf/CKwfeK + qfoPC4eCYx9sF8OxJEmSJEmSJEmSxrYTWTZbpcWp/qErFptXxpuDXmjog+1kOJYkSZIkSZIkSdLYFf2V + cd5xZcyuMhxLkiRJkiRJkiRprOrl+XSVFo/0j1uxcGXMMBiOJUmSJEmSJEmSNDZ1k/I/q0ivjO/OO/UZ + V8YMieFYkiRJkiRJkiRJI19330zWTYuToVErBqdm9tdvrbgyZngMx5IkSZIkSZIkSRrpeln5rSotXu0f + s2KwkZf16YM3BYc82E2GY0mSJEmSJEmSJI1kRycnsyot7u8fsWLxs5n99VlXxkTCcCxJkiRJkiRJkqSR + K+Yr47tcGRMhw7EkSZIkSZIkSZJGpvUkSaq0uLd/uIrFI+9dGa8EhzsYJsOxJEmSJEmSJEmSRqKLV8Yv + 949WMbgr77gyJmqGY0mSJEmSJEmSJLW6jSzbVyX53aHBKgaujGkDw7EkSZIkSZIkSZJaW5WV3+pGemV8 + Z1bWz954MDjSQWwMx5IkSZIkSZIkSWpdR/fM7umm5ZHQSBWDH0/P1n897MqY9jAcS5IkSZIkSZIkqVX1 + ss43qrR4oX+cisGJrKyfOXBj/W5gmIOYGY4lSZIkSZIkSZLUijY+NffJ2K+M31g+HBzlIHaGY0mSJEmS + JEmSJEVfdzL/epUUz4VGqWFzZcwoMBxLkiRJkiRJkiQp2qq9e6O+Mv7R1Ez9xmFXxrSf4ViSJEmSJEmS + JElRViXF16o08ivjtbXgCAdtYziWJEmSJEmSJElSVLXhyvh1V8aMGMOxJEmSJEmSJEmSoml9Mv9ilRan + +4enGKxnRf30Zw+4MmYkGY4lSZIkSZIkSZI09I4UxQ3dpLijSosL/aNTDH7Yma7/srQcHNxgFBiOJUmS + JEmSJEmSNNS6SfGFKuIr46fmD9QXAkMbjBLDsSRJkiRJkiRJkobSRqfz8divjF9ddmXMeDAcS5IkSZIk + SZIkaddbT8pbqqT4bWhkGrZeVroyZuwYjiVJkiRJkiRJkrRrHZ2djfrK+GRnpn7FlTFjyHAsSZIkSZIk + SZKkXel42vl8lRbP9o9KMXBlzLgzHEuSJEmSJEmSJGlHOzJx8/XdrPh2FeuVcTldv7LkypjxZjiWJEmS + JEmSJEnSjrWedJartPh1/5AUg17jibn5+vzaWnBIg3FiOJYkSZIkSZIkSdK2t3ll3MuK26q0ONc/IsXg + vnK6fmlpKTigwTgyHEuSJEmSJEmSJGlbq9LOYpUUvwoNSDFwZQyDDMeSJEmSJEmSJEnalk5NTER/Zfyn + RVfGEGI4liRJkiRJkiRJ0jW3nmULvbR4MjQaxcCVMXw4w7EkSZIkSZIkSZKuuktXxt1Ir4zvLabqF10Z + w0cyHEuSJEmSJEmSJOmqqrJsoUrLqK+M31ldDY5kwL8yHEuSJEmSJEmSJOmKun1i4rpumv9XlRZv9w9E + Mbin6NTPH1oMjmNAmOFYkiRJkiRJkiRJl92dydRclRSPhsahGDw2O1ef813GcMUMx5IkSZIkSZIkSfrI + 6kYvyW+t0uJs/ygUg3uKqfq5hUPBQQz4aIZjSZIkSZIkSZIkfWjH03S2SvNToUEoBu9dGfsuY7gmhmNJ + kiRJkiRJkiQF23Jl/Gb/EBSD7xVT9R9cGcO2MBxLkiRJkiRJkiRpoBNZNttLi0dCI1AMNq+MN4eu0AAG + XDnDsSRJkiRJkiRJkv5Z9FfGeac+c9NCcPgCrp7hWJIkSZIkSZIkSe91LM+nq7R4uH/0iYUrY9g5hmNJ + kiRJkiRJkiRN9LLyW1VavNY/+MRgIyvr/3vwpuDYBWwPw7EkSZIkSZIkSdIYd3RyMqvS4v7+oScWp2b2 + 12+tuDKGnWY4liRJkiRJkiRJGtMuXhm/2j/yxGAjL+vTroxh1xiOJUmSJEmSJEmSxqz1JEl6aXFvaOCJ + wc9m5uqzroxhVxmOJUmSJEmSJEmSxqiYr4zvcmUMQ2M4liRJkiRJkiRJGoOOp2lSZeU9oVEnBo/M7K/P + rqwEBy1g5xmOJUmSJEmSJEmSRryLV8Yv9485Mbgr77gyhggYjiVJkiRJkiRJkka0jSzbVyX53aEhJwab + V8Z/c2UMUTAcS5IkSZIkSZIkjWDdrPxGlRYv9A84MbgzK+tnDtxYvxsYr4DhMBxLkiRJkiRJkiSNUEf3 + zO7ppuWR0HgTgx9Pz9Z/PezKGGJjOJYkSZIkSZIkSRqRqiz7ehXplfEJV8YQNcOxJEmSJEmSJElSy9v4 + 1NwnY78yfmP5cHCsAuJgOJYkSZIkSZIkSWpxvST/WpUUz4XGmmH755Xx2lpwqALiYTiWJEmSJEmSJElq + YdXevVFfGf9oaqZ+47ArY2gLw7EkSZIkSZIkSVLL6ibFV6u0ONM/zsTAlTG0k+FYkiRJkiRJkiSpJR0p + ihuqtPhO/ygTi4emZurXXRlDKxmOJUmSJEmSJEmSWtD6ZP7FKi1O9w8yMVjPivqp+QP1hbXwIAXEz3As + SZIkSZIkSZIUcRudzse7SXFHlRYX+seYGPywM13/ZWk5OEQB7WE4liRJkiRJkiRJirRuUnyhlxW/DQ0x + w9bLyvevjAMDFNA+hmNJkiRJkiRJkqTIiv/KeKZ+ddmVMYwSw7EkSZIkSZIkSVJEVWl5S5W4MgZ2l+FY + kiRJkiRJkiQpgo7OzkZ9ZXyyM1O/4soYRpbhWJIkSZIkSZIkacj18vxL3bT4XWhwGbb1rKj/z2dvrC+s + hccmYDTs5HBcJcWvAAAAAIBtlJZfuTgxSJJGoSMTN1/fy4rbqrQ4PzC0ROC+cqp+aWkpODIBo2VHh2MA + AAAAYHtl5bcuTg2SpLa3nnSWu1nx6+ADPwJPzM3X59fWggMTMHoMxwAAAADQIoZjSWp/pyYmLl0Znxt4 + 0EfgvnK6fmlxMTgsAaPLcAwAAAAALWI4lqR2dzxNF9//7oHAQz4CroxhfBmOAQAAAKBFDMeS1M5ivzK+ + t5iq/7Tou4xhnBmOAQAAAKBFDMeS1L7Ws2yhlxZPBh/sEXBlDGwyHAMAAABAixiOJak9Xboy7kZ8Zfyi + K2PgIsMxAAAAALSI4ViS2tHxPD9Ypfkvgw/zCDw+N1+/s7oaHI+A8WQ4BgAAAIAWMRxLUtzdPjFxXS/J + b20e2mcHHuIRuKfo1M8fWgyORsB4MxwDAAAAQIsYjiUp3npJMlclxaPBB3gEHpudq8+5MgY+gOEYAAAA + AFrEcCxJ8bX5XcZVmv9v32UMtJnhGAAAAABaxHAsSXF1PE1nmwf0qYEHdiQ2r4w3x6DQSASwleEYAAAA + AFrEcCxJcVQ3Ln6X8ZsDD+sIfK+Yqv+wcCg4DgGEGI4BAAAAoEUMx5I0/Hp5Pt08lB8ZeEhHwpUxcDUM + xwAAAADQIoZjSRpe0V8Z5536zE0LwUEI4KMYjgEAAACgRQzHkjScuvtmsuZBfHLgwRwJV8bAtTIcAwAA + AECLGI4laffrNQ/f5iH82sBDOQIbeVmfPnhTcAQCuBKGYwAAAABoEcOxJO1eRycnN6+M7x94GEfiZzP7 + 67dWXBkD28NwDAAAAAAtYjiWpN3p4pXxqwMP4gjc5coY2AGGYwAAAABoEcOxJO1s60mSNA/cewcewJHY + vDI+u7ISHH0AroXhGAAAAABaxHAsSTvXxSvjlwcevhFwZQzsNMMxAAAAALSI4ViStr9jn+4UVVI+FHzw + RuDR2bn6bVfGwA670DizcAgAAAAA2EY/KKeD/7f/a2Y4lqTtbfPKuBvtlXHHlTEAAAAAALTYj6dngxvA + NTMcS9L2dHTP7J7modoNPmwj8JOp2fqvh10ZAwAAAABAmxmOJSnielnnG81D9YWBh2wE7szK+pkDN9bv + Bv5yAQAAAAAA2sVwLEkRtnll3E3LI8EHbAQ2//JwZQwAAAAAAKPDcCxJkdWdzL/ePEijvDI+4coYAAAA + AABGkuFYkiJp41Nzn4z5yvhHUzP1G4cPB/8yAQAAAAAA2s1wLEkR1EvyrzUPz+cGHqYR+OeV8dpa8C8S + AAAAAACg/QzHkjTEqr17XRkDAAAAAABDZziWpCHVS4qvNg/MMwMP0Ai4MgYAAAAAgPFiOJakXe5IUdzQ + TYo7moflhYGHZwQe6EzXf1laDv6lAQAAAAAAjCbDsSTtYlVSfKF5SJ4eeGhGYD0r6qfmD9QX1sJ/YQAA + AAAAAKPLcCxJu9BGp/PxmK+Mf+jKGAAAAAAAxprhWJJ2uPWkvKWXFb8NPiyHrJeV718ZB/6CAAAAAAAA + xofhWJJ2qKOzs5FfGc/Ury67MgYAAAAAAAzHkrQjVWl5S/MwfHbg4RgBV8YAAAAAAEA/w7EkbWOxXxmf + LKfrV5aWgn8hAAAAAAAA48twLEnbVDcpl5sH4NMDD8QI9BpPfuazrowBAAAAAIAgw7EkXWNHJm6+vpcV + tzUPv/MDD8MI3FdO1S+5MgYAAAAAAD6E4ViSrqH1pLPczYpfBx+EEXhibr4+v7YW/AsAAAAAAADgEsOx + JF1FpyYmLl0Znxt4AEbgvnK6/tOiK2MAAAAAAODyGI4l6Qo7nqaLVVL8Kvjwi4ArYwAAAAAA4EoZjiXp + Mrt0ZdyN9Mr43mKqftGVMQAAAAAAcBUMx5J0GVVZtlCl5ZPBB14ENq+M31ldDT7oAQAAAAAAPorhWJI+ + pI2JieuivzI+tBh8wAMAAAAAAFwuw7EkfUB3JlNzVVL8PPiQi8Bjs3P1Od9lDAAAAAAAbAPDsST1VTd6 + SX5r8zA7O/Bwi8A9Rad+3pUxAAAAAACwjQzHkrSlXpLMddPy0eCDLQLvXRn7LmMAAAAAAGCbGY4lqWnL + lfGbAw+0CHyvmKr/sHAo+CAHAAAAAAC4VoZjSWPfiSybbR5cpwYeZJHYvDL+uytjAAAAAABgBxmOJY1t + 0V8Z5x1XxgAAAAAAwK4wHEsay3p5Pt08rB4ZeHhFwpUxAAAAAACwmwzHksaublL+Z/OgivLK+O68U59x + ZQwAAAAAAOwyw7Gksam7bybrpsXJ4EMrAqdm9tdvrbgyBgAAAAAAdp/hWNJY1GseSs3D6dWBh1UENvKy + Pn3wpuBDGgAAAAAAYDcYjiWNdEcnJ7PmoXT/wEMqEj+bmavPujIGAAAAAACGzHAsaWSL+cr4LlfGAAAA + AABARAzHkkau9SRJmgfRvQMPpkg8MrO/PruyEnwoAwAAAAAADIPhWNJIdfHK+OWBh1IE7so7rowBAAAA + AIAoGY4ljUQbWbavSvK7gw+kCGxeGf/NlTEAAAAAABApw7Gk1rf5wOlGemV8Z1bWz954MPgABgAAAAAA + iIXhWFJrO7pndk83LY8EH0IR2HzA/vWwK2MAAAAAACB+hmNJrayXdb7RPGxeGHj4ROBEVtbPHLixfjfw + 0AUAAAAAAIiR4VhSq9r41NwnY78yfmP5cPCBCwAAAAAAECvDsaTW1J3Mv14lxXPBh86QuTIGAAAAAADa + zHAsKfqqvXujvjL+0dRM/cZhV8YAAAAAAEB7GY4lRV2VFF9rHipxXxmvrQUfsAAAAAAAAG1hOJYUZbFf + GT80NVO/7soYAAAAAAAYEYZjSdG1Ppl/sXmQnB54sERgPSvqp+YP1BfWwg9VAAAAAACANjIcS4qmjU7n + 492kuKN5iFwYeKhE4Ied6fovS8vBhykAAAAAAECbGY4lRVE3Kb7QPDyivDLuZeX7V8aBhygAAAAAAMAo + MBxLGmptuDJ+ddmVMQAAAAAAMNoMx5KG1npS3lIlxW+DD5Ehc2UMAAAAAACME8OxpF3v6Oxs1FfGJzsz + 9SuujAEAAAAAgDFiOJa0qx1PO59vHhLPDjw0IuDKGAAAAAAAGFeGY0m70pGJm6/vZsW3mwdEnFfG5XT9 + ypIrYwAAAAAAYDwZjiXteOtJZ7l5MPx64EERgV7jibn5+vzaWvAhCQAAAAAAMA4Mx5J2rM0r415W3NY8 + FM4NPCQicF85Xb+0tBR8OAIAAAAAAIwTw7GkHalKO4tVUvwq+ICIgCtjAAAAAACA/2E4lrStnZqYiP7K + +E+LrowBAAAAAAC2MhxL2rbWs2yhlxZPBh8KEXBlDAAAAAAAEGY4lnTNXboy7kZ6ZXxvMVW/6MoYAAAA + AADgAxmOJV1TVZYtVGkZ9ZXxO6urwQcgAAAAAAAA7zMcS7qqbp+YuK6b5v/VfODfHngAROCeolM/f2gx + +OADAAAAAADgXxmOJV1xvSSZq5Li0eCHPwKPzc7V53yXMQAAAAAAwGUzHEu67OpGL8lvbT7kZwc+9BG4 + p5iqn1s4FHzYAQAAAAAA8MEMx5Iuq+NpOlul+angBz4C710Z+y5jAAAAAACAq2I4lvShbbkyfnPggx6B + 7xVT9R9cGQMAAAAAAFwTw7GkD+xEls320uKR4Ic8AptXxn93ZQwAAAAAAHDNDMeSBor+yjjv1GduWgg+ + 1AAAAAAAALhyhmNJ/9KxPJ9uPsQPD3yoI+HKGAAAAAAAYPsZjiX9s17zwW0+wK8NfKAjsJGV9f89eFPw + QQYAAAAAAMC1MRxLmjg6OZk1H9z7Bz7IkTg1s79+a8WVMQAAAAAAwE4xHEtj3sUr41cHPsQR2MjL+rQr + YwAAAAAAgB1nOJbGtPUkSXppcW/wAxyBn83M1WddGQMAAAAAAOwKw7E0hsV8ZXyXK2MAAAAAAIBdZziW + xqjjaZo0H857gh/aCDwys78+u7ISfFgBAAAAAACwcwzH0ph08cr45YEPawTuyjuujAEAAAAAAIbIcCyN + eBtZtq9K8ruDH9QIbF4Z/82VMQAAAAAAwFAZjqURrpuV32g+kC8MfEAjcGdW1s8cuLF+N/BgAgAAAAAA + YHcZjqUR7Oie2T3dtDwS/HBGYPPB89fDrowBAAAAAABiYTiWRqwqy77efAijvDI+4coYAAAAAAAgSoZj + aUTa+NTcJ2O+Mv7R1Ez9xvLh4IMIAAAAAACA4TIcSyNQL8m/ViXFc8EP45D988p4bS34EAIAAAAAAGD4 + DMdSi6v27o3/yviwK2MAAAAAAIDYGY6lltZNiq82H7YzAx++CLgyBgAAAAAAaBfDsdSyjhTFDc2H7DsD + H7pIPNCZrv/iu4wBAAAAAABaxXAstaj1yfyLzQfs9MAHLgLrWVE/NX+gvrAWftgAAAAAAAAQL8Ox1II2 + Op2Pd5PijubDdWHgwxaBH25eGS8tBx8yAAAAAAAAxM9wLEVeNym+0MuK3wY/aEPWy8r3r4wDDxcAAAAA + AADaw3AsRVr8V8Yz9avLrowBAAAAAABGgeFYirAqLW+pElfGAAAAAAAA7A7DsRRRR2dno74yPtmZqV9Z + Wgo+TAAAAAAAAGgvw7EUSb2s8/nmw/PswIcpAq6MAQAAAAAARpvhWBpyRyZuvr6XFbc1H5zzAx+kCNxX + TtUvuTIGAAAAAAAYaYZjaYitJ53lblb8OvghisATc/P1+bW14MMDAAAAAACA0WE4lobQqYmJS1fG5wY+ + PBG4r5yuX1pcDD40AAAAAAAAGD2GY2mXO56mi1VS/Cr4wYmAK2MAAAAAAIDxYziWdqnYr4zvLabqPy36 + LmMAAAAAAIBxZDiWdqH1LFvopcWTwQ9LBFwZAwAAAAAAjDfDsbSDXboy7kZ8ZfyiK2MAAAAAAICxZziW + dqjjeX6wSvNfBj8gEXh8br5+Z3U1+GAAAAAAAABgvBiOpW3u9omJ63pJfmvzQTg78MGIwD1Fp37+0GLw + gQAAAAAAAMB4MhxL21gvSea6aflo8EMRgcdm5+pzrowBAAAAAADoYziWtqG6EfeV8VT93MKh4EMAAAAA + AAAADMfSNXY8TWebN/2pgQ9BJDavjP/uyhgAAAAAAIAPYTiWrrItV8ZvDnwAIvC9Yqr+gytjAAAAAAAA + LoPhWLqKenk+3bzRHxl440fClTEAAAAAAABXwnAsXUHRXxnnnfrMTQvBDzsAAAAAAAB8EMOxdJl1981k + zZv75MCbPRKujAEAAAAAALhahmPpMuo1b+jmjf3awBs9Aht5WZ8+eFPwAw4AAAAAAACXw3AsfUhHJyc3 + r4zvH3iDR+JnM/vrt1ZcGQMAAAAAAHBtDMfSB3TxyvjVgTd3BO5yZQwAAAAAAMA2MhxLfa0nSdK8ie8d + eFNHYvPK+OzKSvADDQAAAAAAAFfDcCxt6eKV8csDb+gIuDIGAAAAAABgpxiOpabjaZr0svKe4Js5Ao+4 + MgYAAAAAAGAHGY419m1eGXejvTLuuDIGAAAAAABgxxmONbYd3TO7p3mjdoNv4Aj8ZGq2/uthV8YAAAAA + AADsPMOxxrJe1vlG80Z9YeCNG4E7s7J+5sCN9buBDywAAAAAAADsBMOxxqrNK+NuWh4JvmkjsPmBdGUM + AAAAAADAbjMca2zqTuZfb96cUV4Zn3BlDAAAAAAAwBAZjjXybXxq7pMxXxn/aGqmfuPw4eAHFAAAAAAA + AHaD4VgjXS/Jv9a8IZ8beING4J9XxmtrwQ8nAAAAAAAA7BbDsUayau9eV8YAAAAAAABwmQzHGrl6SfHV + 5k14ZuBNGQFXxgAAAAAAAMTIcKyR6UhR3NBNijuaN+CFgTdkBB7oTNd/WVoOfhABAAAAAABgmAzHGomq + pPhC88Y7PfBGjMB6VtRPzR+oL6yFP4QAAAAAAAAwbIZjtbqNTufjMV8Z/7AzXb+67MoYAAAAAACAuBmO + 1drWk/KWXlb8NvgGHLJeVr5/ZRz40AEAAAAAAEBsDMdqXUdnZ6O+Mj7ZmXFlDAAAAAAAQKsYjtWqqrS8 + pXmDPTvwhouAK2MAAAAAAADaynCsVhT9lXE5Xb+ytBT8kAEAAAAAAEDsDMeKvm5SLjdvqqcH3mQR6DWe + /MxnXRkDAAAAAADQaoZjRduRiZuv72XFbc0b6vzAGywC95VT9UuujAEAAAAAABgBhmNF2XrSWe5mxa+D + b64IPDE3X59fWwt+qAAAAAAAAKBtDMeKqlMTE5eujM8NvKkicF85Xf9p0ZUxAAAAAAAAo8VwrGg6nqaL + VVL8KviGioArYwAAAAAAAEaV4VhD79KVcTfSK+N7i6n6RVfGAAAAAAAAjDDDsYZalWULVVo+GXwTRWDz + yvid1dXghwcAAAAAAABGheFYQ2ljYuK66K+MDy0GPzQAAAAAAAAwagzH2vXuTKbmqqT4efCNE4HHZufq + c77LGAAAAAAAgDFiONauVTd6SX5r8wY5O/CGicA9xVT9vCtjAAAAAAAAxpDhWLtSL0nmumn5aPDNEoH3 + rox9lzEAAAAAAABjynCsHW3LlfGbA2+SCHyvmKr/sHAo+OEAAAAAAACAcWE41o51IstmmzfDqYE3RyQ2 + r4z/7soYAAAAAAAADMfa/qK/Ms47rowBAAAAAABgC8OxtrVenk83b4BHBt4QkXBlDAAAAAAAAIMMx9q2 + ukn5n82LH+WV8d15pz7jyhgAAAAAAACCDMe65rr7ZrJuWpwMvhEicGpmf/3WiitjAAAAAAAA+CCGY11T + veaFbl7wVwfeABHYyMv69MGbgm98AAAAAAAA4H8YjnVVHZ2czJoX+v6BFz4SP5uZq8+6MgYAAAAAAIDL + YjjWFRfzlfFdrowBAAAAAADgihmOddkdT9OkeXHvHXixI/HIzP767MpK8I0OAAAAAAAAfDDDsS6ri1fG + Lw+80BG4K++4MgYAAAAAAIBrYDjWh7aRZfuqJL87+CJHYPPK+G+ujAEAAAAAAOCaGI71gVVp+W/Ni/ni + wIsbgTuzsn72xoPBNzUAAAAAAABwZQzHGujontk93bQ8EnxhI7D5pv3rYVfGAAAAAAAAsF0Mx/qXelnn + G80L+MLACxqBE1lZP3PgxvrdwBsZAAAAAAAAuHqGY73XxqfmPhn7lfEby4eDb2IAAAAAAADg2hiONdGd + zL9eJcVzwRdyyFwZAwAAAAAAwM4zHI9x1d69UV8Z/2hqpn7jsCtjAAAAAAAA2GmG4zGtSoqvNS9U3FfG + a2vBNy0AAAAAAACwvQzHY1bsV8YPTc3Ur7syBgAAAAAAgF1lOB6j1ifzLzYvzumBFysC61lRPzV/oL6w + Fn6jAgAAAAAAADvHcDwGbXQ6H+8mxR3NC3Nh4IWKwA870/VflpaDb1AAAAAAAABg5xmOR7xuUnyheUGi + vDLuZeX7V8aBNyYAAAAAAACwewzHI1obroxfXXZlDAAAAAAAADEwHI9g60l5S5UUvw2+MEPmyhgAAAAA + AADiYzgeoY7OzkZ9ZXyyM1O/4soYAAAAAAAAomM4HpGOp53PN7/4ZwdeiAi4MgYAAAAAAIC4GY5b3pGJ + m6/vZsW3m196nFfG5XT9ypIrYwAAAAAAAIiZ4bjFrSed5eaX/euBX34Eeo0n5ubr82trwTceAAAAAAAA + EA/DcQvbvDLuZcVtzS/63MAvPgL3ldP1S0tLwTccAAAAAAAAEB/Dccuq0s5ilRS/Cv7SI+DKGAAAAAAA + ANrHcNySTk1MRH9l/KdFV8YAAAAAAADQRobjFrSeZQu9tHgy+IuOgCtjAAAAAAAAaDfDccRdujLuRnpl + fG8xVb/oyhgAAAAAAABaz3AcaVWWLVRpGfWV8Turq8E3FQAAAAAAANAuhuPIun1i4rpumv9X80t8e+CX + GoF7ik79/KHF4JsJAAAAAAAAaCfDcUT1kmSuSopHg7/QCDw2O1ef813GAAAAAAAAMHIMxxFUN3pJfmvz + izs78IuMwD3FVP3cwqHgGwgAAAAAAABoP8PxkDueprNVmp8K/hIj8N6Vse8yBgAAAAAAgJFmOB5SW66M + 3xz45UXge8VU/QdXxgAAAAAAADAWDMdD6ESWzfbS4pHgLy4Cm1fGf3dlDAAAAAAAAGPDcLyLRX9lnHfq + MzctBN8oAAAAAAAAwOgyHO9Sx/J8uvnFPDzwi4qEK2MAAAAAAAAYX4bjXajX/DKaX8prA7+kCGxkZf27 + g66MAQAAAAAAYJwZjnewo5OTWfPLuH/glxOJUzP767dWXBkDAAAAAADAuDMc71AXr4xfHfjFRGAjL+vT + B28KviEAAAAAAACA8WM43ubWkyTppcW9wV9KBH42M1efdWUMAAAAAAAAbGE43sZivjK+y5UxAAAAAAAA + 8AEMx9vQ8TRNmj/wPcFfRAQemdlfn11ZCb4BAAAAAAAAAAzH19jFK+OXB34BEbgr77gyBgAAAAAAAD6S + 4fgq601P72n+kN3gHz4Cm1fGf3NlDAAAAAAAAFwGw/FV1M3KbzR/yBcG/tARuDMr62cO3Fi/G3ixAQAA + AAAAAEIMx1fQ0T2ze7ppeST4B47A5ov518OujAEAAAAAAIArYzi+zKos+3rzB4vyyviEK2MAAAAAAADg + GhiOP6KNT819MuYr4x9NzdRvLB8OvrgAAAAAAAAAl8Nw/CH1kvxrVVI8F/wDDtk/r4zX1oIvLAAAAAAA + AMDlMhwHqvbujf/K+LArYwAAAAAAAGB7GI776ibFV5s/wJmBP1AEXBkDAAAAAAAAO8FwfLEjRXFD84N/ + Z+APEokHOtP1X3yXMQAAAAAAALADDMdN65P5F5sf+vTAHyIC61lRPzV/oL6wFn4BAQAAAAAAAK7VWA/H + G53Ox7tJcUfzA18Y+ANE4IebV8ZLy8EXDgAAAAAAAGC7jO1w3E2KL/Sy4rfBH37Ieln5/pVx4AUDAAAA + AAAA2G5jNxzHf2U8U7+67MoYAAAAAAAA2D1jNRxXaXlL88M9O/DDRsCVMQAAAAAAADAsYzEcH52djfrK + +GRnpn5laSn4AgEAAAAAAADstJEfjntZ5/PND+TKGAAAAAAAAOADjOxwfGTi5ut7WXFb88OcH/jhInBf + OVW/5MoYAAAAAAAAiMBIDsfrSWe5mxW/Dv5gEXhibr4+v7YWfEEAAAAAAAAAdttIDcenJiYuXRmfG/iB + InBfOV2/tLgYfCEAAAAAAAAAhmVkhuPjabpYJcWvgj9MBFwZAwAAAAAAALFq/XAc+5XxvcVU/adF32UM + AAAAAAAAxKvVw/F6li300uLJ4A8QAVfGAAAAAAAAQBu0cji+dGXcjfjK+EVXxgAAAAAAAEBLtG44Pp7n + B6s0/2XwXxqBx+fm63dWV4O/bAAAAAAAAIAYtWY4vn1i4rpekt/a/MPPDvzLInBP0amfP7QY/CUDAAAA + AAAAxKwVw3EvSea6aflo8F8Ugcdm5+pzrowBAAAAAACAlop6OK4bcV8ZT9XPLRwK/mIBAAAAAAAA2iLa + 4Tj27zJ+wncZAwAAAAAAACMiuuF4y5XxmwP/0Ah8r5iq/+DKGAAAAAAAABghUQ3HJ7JstpcWjwT/gRHY + /C7jv7syBgAAAAAAAEZMFMNx7FfGd+ed+sxNC8FfIAAAAAAAAEDbDX047uX5dPNfeHjgHxAJV8YAAAAA + AADAqBvacBz7lfFGXtanD94U/KUBAAAAAAAAjJKhDMfdfTNZ8x86OfBfisTPZvbXb624MgYAAAAAAADG + w64Px73mf9H8B14b+C9E4C5XxgAAAAAAAMAY2rXh+OKV8f0D/8FIbF4Zn11ZCf6SAAAAAAAAAEbZjg/H + m99lXGXF/9v8D6P8LuO78079/y0cCv5yAAAAAAAAAMbBrlwcd9Pi/2n+h68O/IciYDgGAAAAAAAAxt2u + /X9VfSzPp5v/xcMD/8FIPDE3X7+zuhb8JQEAAAAAAACMsl0bjje7fWLiul5W3Nb8B84O/Bci8P1iqv7j + ocXgLwoAAAAAAABgVO3qcHyp3mRnvvkPPT7wX4rE+9fHq8FfGAAAAAAAAMCoGcpwvNmW6+O3B/7LEXB9 + DAAAAAAAAIyLoQ3Hl1ovioPNf+EXA/+ASDz5mc/W59d89zEAAAAAAAAwuoY+HG+2Efn18f3lVP3nxaXg + LxAAAAAAAACg7aIYji/VmyxXumnxdPAfOGS9xlPzB+p/uD4GAAAAAAAARkxUw/FmGwsLH+smxR3NP+T8 + wD80Aj/oTLs+BgAAAAAAAEZKdMPxpY7n+cEqzX8Z/IdH4Im5+fqd1dXgLxUAAAAAAACgTaIdjjeL/vq4 + nK5fXloO/mIBAAAAAAAA2iLq4fhSx/P8c80/9JmBf0kEelnpu48BAAAAAACAVmvFcLzZg/PzUV8fn3R9 + DAAAAAAAALRUa4bjS/Wyzuebf8GzA//CCGxeHz/92QP1hbXwLxsAAAAAAAAgRq0bjjc7UhQ3dNPySPMv + ujDwL47AA1Mz9WvLh4O/cAAAAAAAAIDYtHI4vtR6ln2pSsvfBX+AIVtvPHPgRtfHAAAAAAAAQPRaPRxv + djxNL10fh3+QIXuw4/oYAAAAAAAAiFvrh+NL9bLyy82/+PcDP0gELl0fv7u2FnwRAAAAAAAAAIZpZIbj + zTYmJz8R8/XxQ52Z+vXl5eALAQAAAAAAADAsIzUcX6pKy680P8SZgR8qAq6PAQAAAAAAgNiM5HC82Xf3 + 7Yv7+nhqpn79sO8+BgAAAAAAAIZvZIfjS1Vp+W/ND/TiwA8YgTuzsj598Kb63cALAwAAAAAAALBbRn44 + 3qw3Pb2n+aHuHvghI/GTqdn6TdfHAAAAAAAAwJCMxXB8qW5afLP54aK+Pg69SAAAAAAAAAA7aayG482O + leXe5geM9vr44eYFcX0MAAAAAAAA7KaxG44vVSX5vzc/6EsDP3gEXB8DAAAAAAAAu2lsh+PN1otiX/PD + Rnt9/NPmxfnbykrwhQMAAAAAAADYLmM9HF+qm+T/0fzQUV4f35V3XB8DAAAAAAAAO8pwfLGNLIv7+nhm + v+tjAAAAAAAAYEcYjvvqJuV/Nn+A1wb+QBHYyMr6zMKh4AsJAAAAAAAAcLUMx4FO7Jsqumn+QPAPFoH/ + np2r33J9DAAAAAAAAGwTw/GH1EvyW5s/TJzXx3nH9TEAAAAAAACwLQzHH9GxT3eKKiseCv4hI/Do7Fz9 + tutjAAAAAAAA4BoYji+z96+P8zeCf9ghu9v1MQAAAAAAAHANDMdX0Imi6FRZ8ePgHzgC710fr64GX2gA + AAAAAACAD2I4vsLqxsXvPnZ9DAAAAAAAAIwEw/FVdizPp5s/6MMDf/BIPD43X59bWwu+6AAAAAAAAABb + GY6vodsnJq7rZcVtzR/47MAvIAL3FJ36+UOLwRceAAAAAAAA4BLD8TbUm+zMN3/oxwd+CZF4YvP6eNX1 + MQAAAAAAABBmON6mtlwfvz3wy4jA94tO/cIh330MAAAAAAAADDIcb3PH9pUHml/ALwZ+IZHYvD5+x/Ux + AAAAAAAAsIXheAfaiP76eKr+o+8+BgAAAAAAAC4yHO9g60VxsPllRH59vBp8YwAAAAAAAADjw3C8w8V+ + fXyv62MAAAAAAAAYe4bjXao3Wa40v5inB35REeg1npo/UJ9f893HAAAAAAAAMI4Mx7vYkYmbr+8mxR3N + L+j8wC8sAveXU/WfF5eCbxQAAAAAAABgdBmOh9CJyWKlSvPfBH9xQ3bp+vgfro8BAAAAAABgbBiOh9TG + wsLHYr4+/kFn2vUxAAAAAAAAjAnD8ZDr5flalZZxXh9npetjAAAAAAAAGAOG4wh6cH4+7uvjcrp+eWk5 + +AYCAAAAAAAA2s9wHFFVln2u+eU9M/DLjIDrYwAAAAAAABhdhuPI2nJ9fGHglxqBk+V0/YrrYwAAAAAA + ABgphuNI6+b5F7tp8bvgL3fI1rOifubAjfWFtfCbCgAAAAAAAGgXw3HEHU/TG7ppeST4C47AA1Mz9WvL + h4NvLAAAAAAAAKA9DMctaD3LvlSlZZzXx43N6+N3ffcxAAAAAAAAtJbhuCVtTE5+Iubr4wc7m9fHvvsY + AAAAAAAA2shw3LJ6Wfnl5hf8+4FfeARcHwMAAAAAAEA7GY5bWOzXxw91ZurXXR8DAAAAAABAaxiOW1yV + ll9pftlnBn75EXB9DAAAAAAAAO1hOG5539237xPNL7sbfBEi8JOp2frNwyvBNx8AAAAAAAAQB8PxiLSe + Fv/W/OJfHHghInBnVtanD94UfAMCAAAAAAAAw2c4HqE2Op29zS//7oEXIxI/md5fv3n4cPCNCAAAAAAA + AAyP4XgE66XFN5sXwfUxAAAAAAAAcFkMxyPasbKM+vr44eaN97cV330MAAAAAAAAMTAcj3hVkv9784K8 + NPACRcD1MQAAAAAAAMTBcDwGrRfFvuZFifb6+KeujwEAAAAAAGCoDMdj1OaL0k2Ll4Mv2JDdlXfq3x1c + CL5JAQAAAAAAgJ1lOB6zuvtmsuYFOjnwgkXi1Mz++q2V1eCbFQAAAAAAANgZhuMxrZfktzYv1GsDL1wE + NvJOfWbhUPANCwAAAAAAAGw/w/EYd+zTnaKb5g8EX8AI/PfsXP2W7z4GAAAAAACAHWc41sXr4/yN4As5 + ZHe7PgYAAAAAAIAdZzjWe1Vl2amy4qHgixmBR2fn6rddHwMAAAAAAMCOMBzrn9WNi9997PoYAAAAAAAA + xojhWAOdKIpO8yL+eOBFjcRj+z9Tv726GnxDAwAAAAAAAFfOcKxgro8BAAAAAABgfBiO9aF1Jzvz3az4 + efBFjsATc/P1udW14JsbAAAAAAAAuDyGY31kt09MXNfLituaF/btgRc6AvcUnfqFQ4vBNzgAAAAAAADw + 0QzHuux6k5355sV9fODFjoTrYwAAAAAAALg6hmNdUbFfH3+/mHJ9DAAAAAAAAFfIcKyrqlsUB5oX+hcD + L3wkNq+P33F9DAAAAAAAAJfFcKyrbqMF18d/dH0MAAAAAAAAH8lwrGtuvSgOVmn+y+AbIQLvXx+vBj8A + AAAAAAAAgOFY29Tm9XE3K77dvPjnB94MEbi/nKpfWloKfggAAAAAAABg3BmOta31JsuVblo8HXxTDFmv + 8dT8gfr8mu8+BgAAAAAAgK0Mx9r2NhYWPtZNijuaN0K018d/XnR9DAAAAAAAAJcYjrVjdfN8rUrz3wTf + IEN26fr4H66PAQAAAAAAwHCsnS326+MflNP1y0vLwQ8HAAAAAAAAjAvDsXal43n+ueaN8czAGyUCvax0 + fQwAAAAAAMBYMxxr13pwft71MQAAAAAAAETIcKxdr8oy18cAAAAAAAAQEcOxhtLR2dmPN2+U7zQu/Msb + JxIPTM3Uf1k+HPzQAAAAAAAAwKgxHGuo9fL8S1Va/i74Jhqy9ayonzlwY31hLfzhAQAAAAAAgFFhONbQ + O56mN3TT8kjwjRSBzevj11wfAwAAAAAAMMIMx4qmbtb5cvPm+f3AmykC643N6+N3ffcxAAAAAAAAI8hw + rKjamJz8RMzXxw92Nq+Pl4MfJgAAAAAAAGgrw7Gi7HhafqV5I7k+BgAAAAAAgF1gOFa0fXffvqivjx+a + mq1fP+y7jwEAAAAAAGg/w7Gir5cUX23eVGcG3mQR2Lw+fvbGg/W7gQ8XAAAAAAAAtIXhWK2oNz29p3lj + 3T3wRovET6Zm6zcPrwQ/ZAAAAAAAABA7w7FaVTctvtm8wV4ceMNF4M6srE8fvCn4QQMAAAAAAICYGY7V + ujY6nb3Nmyza6+OHmw/Vm777GAAAAAAAgBYxHKu1dZPi35s320sDb74IuD4GAAAAAACgTQzHanXHyjLq + 6+OfNh+wv6347mMAAAAAAADiZjjWSNRL8v9o3nhRXh/flXdcHwMAAAAAABA1w7FGpvWi2Ne8+eK9Pp7Z + 7/oYAAAAAACAKBmONXL1kvx/NW/C1wbelBHYyMr6zMKh4IcRAAAAAAAAhsVwrJHsxL6ponkjPjDwxozE + qZn99Vsrq8EPJQAAAAAAAOw2w7FGul6S39q8IeO8Ps47ro8BAAAAAACIguFYI9+xT3eKKikfCr5RI/Do + 7Fz9tu8+BgAAAAAAYIgMxxqb3r8+zt8IvmGH7G7XxwAAAAAAAAyR4VhjVVWWnSorfhx800bgvevjVd99 + DAAAAAAAwO4yHGvsqhsXv/vY9TEAAAAAAAA0DMca247l+XQvLR4OvoEj8NjsXP1318cAAAAAAADsAsOx + xrrN6+Numv9X86Y9O/AmjsA9Rad+/tBi8MMLAAAAAAAA28VwLDV1JzvzzRv38YE3ciSemJuvz62uBT/E + AAAAAAAAcK0Mx9LFbp+YuK6XFbc1b+C3B97QEfh+0alfcH0MAAAAAADADjAcS30d21ceaN7EUV8fv+P6 + GAAAAAAAgG1kOJYCbUR/fTxV/9H1MQAAAAAAANvEcCx9SOtFcbB5Q/9i4A0eifevj1eDH24AAAAAAAC4 + XIZj6SNyfQwAAAAAAMCoMxxLl9nxPD9Ypfkvg2/4CDz5mc/W59d89zEAAAAAAABXznAsXUFHJm6+vpsU + dzRv8vMDb/oI3F9O1X9eXAp+2AEAAAAAAOCDGI6lq+jEZLHSTYung2/+Ies1npo/UP/D9TEAAAAAAACX + yXAsXWUbCwsfi/n6+AedadfHAAAAAAAAXBbDsXSNdfN8rUrL3wQ/CEPm+hgAAAAAAIDLYTiWtqHor4/L + 6frlpeXgQwAAAAAAAAAMx9I2djzPP9d8AJ4Z+EBEoJeVro8BAAAAAAAIMhxL29yD8/NRXx+fdH0MAAAA + AABAH8OxtEP1ss7nmw/DswMfjghsXh8//dkD9YW18IMBAAAAAACA8WI4lnawI0VxQzctjzQfigsDH5II + PDA1U7+2fDj4cAAAAAAAAGB8GI6lXWg9y75UpeXvgh+WIVtvPHPgRtfHAAAAAAAAY8xwLO1Sx9P00vVx + +EMzZA92XB8DAAAAAACMK8OxtMv1svLLzYfk9wMfmghcuj5+d20t+MAAAAAAAABgNBmOpSG0MTn5iZiv + jx/qzNSvLy8HHxoAAAAAAACMHsOxNMSqtPxK84E5M/ABioDrYwAAAAAAgPFhOJaG3Hf37Yv7+nhqpn79 + sO8+BgAAAAAAGGWGYymSqrT8t+bD8+LAhykCd2ZlffrgTfW7gYcIAAAAAAAA7Wc4liKqNz29p/kA3T3w + gYrET6Zm6zddHwMAAAAAAIwcw7EUYb20+GbzQYr6+jj0QAEAAAAAAKCdDMdSpB0ry73Nhyna6+OHm4eH + 62MAAAAAAIDRYDiWIq9K8n9vPlQvDXzIIuD6GAAAAAAAYDQYjqUWtF4U+5oPVrTXxz9tHiR/W1kJPmQA + AAAAAACIn+FYalHdJP+P5gMW5fXxXXnH9TEAAAAAAEBLGY6llrWRZXFfH8/sd30MAAAAAADQMoZjqaX1 + kvzW5sP22sCHLwIbWVmfWTgUfOgAAAAAAAAQH8Ox1OJO7Jsqumn+QPBDGIH/np2r33J9DAAAAAAAED3D + sTQCRX19nHdcHwMAAAAAAETOcCyNSFVZdqqseCj4gYzAo7Nz9duujwEAAAAAAKJkOJZGrPevj/M3gh/M + Ibvb9TEAAAAAAECUDMfSCHaiKDrNB/HHAx/MSDy2/zP126urwYcSAAAAAAAAu89wLI1odePidx+7PgYA + AAAAAOBDGY6lEe9Ynk83H8qHBz6kkXh8br4+t7YWfEABAAAAAACwOwzH0hh0+8TEdb2suK35cJ4d+LBG + 4J6iUz9/aDH4kAIAAAAAAGDnGY6lMao32ZlvPqCPD3xgI/HE5vXxqutjAAAAAACA3WY4lsasLdfHbw98 + cCPw/aJTv3DIdx8DAAAAAADsJsOxNKYd21ceaD6svxj48EZi8/r4HdfHAAAAAAAAu8JwLI1xG9FfH0/V + f/TdxwAAAAAAADvOcCxpYr0oDjYf3Mivj1eDDzEAAAAAAACuneFY0nvFfn18r+tjAAAAAACAHWM4lvQv + 9SbLleZD/PTAhzoCvcZT8wfq82u++xgAAAAAAGA7GY4lDXRk4ubru0lxR/NhPj/w4Y7A/eVU/efFpeBD + DQAAAAAAgCtnOJb0gZ2YLFaqNP9N8EM+ZJeuj//h+hgAAAAAAOCaGY4lfWgbCwsfi/n6+AedadfHAAAA + AAAA18hwLOmy6uX5WpWWcV4fZ6XrYwAAAAAAgGtgOJZ02T04Px/39XE5Xb+8tBx82AEAAAAAAPDBDMeS + rrgqyz7XfNCfGfjgR8D1MQAAAAAAwJUzHEu6qrZcH18YeABE4GQ5Xb/i+hgAAAAAAOCyGI4lXVPdPP9i + Ny1+F3wQDNl6VtTPHLixvrAWfgACAAAAAADwPsOxpGvueJre0E3LI8GHQQQemJqpX1s+HHwIAgAAAAAA + YDiWtI2tZ9mXqrSM8/q4sXl9/K7vPgYAAAAAABhgOJa0rW1MTn4i5uvjBzub18e++xgAAAAAAGArw7Gk + HamXlV9uHga/H3g4RMD1MQAAAAAAwL8yHEvasWK/Pn6oM1O/7voYAAAAAADAcCxp56vS8ivNg+HMwIMi + Aq6PAQAAAAAADMeSdqnv7tv3iebB0A0+MCLwk6nZ+s3DK8EHJQAAAAAAwKgzHEva1dbT4t+ah8SLAw+N + CNyZlfXpgzcFH5YAAAAAAACjzHAsadfb6HT2Ng+KuwceHJH4yfT++s3Dh4MPTQAAAAAAgFFkOJY0tHpp + 8c3mgeH6GAAAAAAAYMgMx5KG2rGyjPr6+OHmIfm3Fd99DAAAAAAAjDbDsaQoqpL835uHx0sDD5MIuD4G + AAAAAABGneFYUjStF8W+5gES7fXxT10fAwAAAAAAI8pwLCm6Nh8g3bR4OfhwGbK78k79u4MLwQcqAAAA + AABAWxmOJUXZiX1TRfMwOTnwcInEqZn99Vsrq8EHKwAAAAAAQNsYjiVFXS/Jb20eKq8NPGQisJF36jML + h4IPVwAAAAAAgDYxHEuKvmOf7hTdNH8g+LCJwH/PztVv+e5jAAAAAACgxQzHklrT+9fH+RvBh86Q3e36 + GAAAAAAAaDHDsaRWVZVlp8qKh4IPngg8OjtXv+36GAAAAAAAaBnDsaTWVTcufvex62MAAAAAAIBtYDiW + 1NpOFEWneeD8eOABFInH9n+mfnt1NfjwBQAAAAAAiInhWFKrc30MAAAAAABw7QzHkkai7mRnvpsVPw8+ + kCLwxNx8fW51LfggBgAAAAAAGDbDsaSR6faJiet6WXFb8xB6e+ChFIF7ik79wqHF4MMYAAAAAABgmAzH + kkau3mRnvnkQPT7wYIrE5vXxO66PAQAAAACAiBiOJY1ksV8ff7+Ycn0MAAAAAABEw3AsaaTrFsWB5qH0 + i4GHVCRcHwMAAAAAADEwHEsa+TZacH38R9fHAAAAAADAEBmOJY1N60VxsErzXwYfWhF4//p4NfiwBgAA + AAAA2EmGY0lj1eb1cTcrvt08qM4PPLgicH85Vb+0tBR8YAMAAAAAAOwUw7Gksaw3Wa500+Lp4ANsyHqN + p+YP1OfXfPcxAAAAAACwOwzHksa2jYWFj3WT4o7moRXt9fGfF10fAwAAAAAAO89wLGns6+b5WpXmvwk+ + zIbs0vXxP1wfAwAAAAAAO8hwLElNsV8f/6Ccrl9eWg4+yAEAAAAAAK6V4ViStnQ8zz/XPMSeGXioRaCX + la6PAQAAAACAHWE4lqS+Hpyfd30MAAAAAACMFcOxJH1AVZa5PgYAAAAAAMaC4ViSPqSjs7Mfbx5q32lc + +JeHXCQemJqp/7J8OPiABwAAAAAAuFyGY0m6jHp5/qUqLX8XfOAN2XpW1M8cuLG+sBZ+0AMAAAAAAHwU + w7EkXWbH0/SGbloeCT70IrB5ffya62MAAAAAAOAqGI4l6QrrZp0vNw+63w88+CKw3ti8Pn7Xdx8DAAAA + AABXwHAsSVfRxuTkJ2K+Pn6ws3l9vBx88AMAAAAAAPQzHEvSNXQ8Lb/SPPRcHwMAAAAAAK1mOJaka+y7 + +/ZFfX380NRs/fph330MAAAAAAB8MMOxJG1TvaT4avMAPDPwQIzA5vXxszcerN8N/EUAAAAAAABgOJak + baw3Pb2neQjePfBQjMRPpmbrNw+vBP9CAAAAAAAAxpfhWJJ2oG5afLN5GL448HCMwJ1ZWZ8+eFPwLwUA + AAAAAGA8GY4laYfa6HT2Ng/EaK+PH27+AnjTdx8DAAAAAAANw7Ek7XDdpPj35sH40sCDMgKujwEAAAAA + gE2GY0nahY6VZdTXxz9t/jL424rvPgYAAAAAgHFlOJakXayX5P/RPCSjvD6+K++4PgYAAAAAgDFlOJak + XW69KPY1D8p4r49n9rs+BgAAAACAMWM4lqQh1Uvy/9U8MF8beIBGYCMr6zMLh4J/cQAAAAAAAKPHcCxJ + Q+zEvqmieWg+MPAQjcSpmf31Wyurwb9AAAAAAACA0WE4lqQI6iX5rc3DM87r47zj+hgAAAAAAEac4ViS + IunYpztFlZQPBR+qEXh0dq5+23cfAwAAAADASDIcS1JkvX99nL8RfLgO2d2ujwEAAAAAYCQZjiUpwqqy + 7FRZ8ePgAzYC710fr/ruYwAAAAAAGBWGY0mKtLpx8buPXR8DAAAAAAA7ynAsSZF3LM+ne2nxcPBhG4HH + Zufqv7s+BgAAAACAVjMcS1IL2rw+7qb5fzUP2LMDD9wI3FN06ucPLQb/ogEAAAAAAOJnOJakFnXs052i + SsqHgg/eCLz33ccrK8G/cAC2y4W1m+sXDy0CAAAAANvoZDkd/L/9XzPDsSTtTLdPTFzXy4rbmoft2wMP + 3wh8v+jULzR/wYTGHoDtsPn/PX7o+QMAAAAARMhwLEk727F95YHmgfv4wAM4Ek/MzdfvrK4FRx+Aa2E4 + BgAAAIAWMRxL0s63Ef318VT9R9fHwDYzHAMAAABAixiOJWn3Wi+Kg83D9xcDD+NIvH99vBocgACulOEY + AAAAAFrEcCxJu5vrY2BcGI4BAAAAoEUMx5I0nI7n+cEqzX8ZfDhH4MnPfLY+v+a7j4GrZzgGAAAAgBYx + HEvS8DoycfP13aS4o3kgnx94QEfg/nKq/vPiUnAQAvgohmMAAAAAaBHDsSQNvxOTxUo3LZ4OPqiHrNd4 + av5A/Q/Xx8AVMhwDAAAAQIsYjiUpjjYWFj4W8/XxDzrTro+BK2I4BgAAAIAWMRxLUlx183ytSsvfBB/a + Q+b6GLgShmMAAAAAaBHDsSTF16mJieurNP/f3bQ4F3x4D9m9xVT9outj4CMYjgEAAACgRQzHkhRvx/P8 + c83D+pmBh3cEelnp+hj4UIZjAAAAAGgRw7Ekxd2D8/NRf/fxyXK6fmVpOTgaAePNcAwAAAAALWI4lqR2 + 1M3zL3bT4nfBh/mQrWdF/cyBG+sLa+HxCBhPhmMAAAAAaBHDsSS1pyNFcUM3LY80D/ALAw/0CDwwNVO/ + tnw4OCAB48dwDAAAAAAtYjiWpPa1nmVfqtIyzuvjxub18bu++xjGnuEYAAAAAFrEcCxJ7ex4ml66Pg4/ + 4IfswY7rYxh3hmMAAAAAaBHDsSS1u15Wfrl5oP9+4AEfAdfHMN4MxwAAAADQIoZjSWp/G5OTn4j5+vih + zkz9+vJycFgCRpfhGAAAAABaxHAsSaNTlZZfaR7uZwYe9hFwfQzjx3AMAAAAAC1iOJak0eq7+/bFfX08 + NVO/fth3H8M4MBwDAAAAQIsYjiVpNOvl+Ze6afG74MN/yNazov4/n72xvrAWHpuA0bDDw/Hvq7RsnnEA + AAAAwLbIsq9fnBgkSaNWb3p6T5UWd/eNLdH4ydRs/abrYxhZOzkcbywsfOzio06SJEmSJEmSJEmXUy8t + vlmlxYv9w0sM7szK+vTBm4KjE9BuhmNJkiRJkiRJkqTIOlaWe6uIr48fnnZ9DKPGcCxJkiRJkiRJkhRp + VZL/e5UWL/WPMDFwfQyjxXAsSZIkSZIkSZIUcetFsa+K+Pr4p9Oz9d9WVoJDFNAehmNJkiRJkiRJkqQW + 1E3y/6givT6+K++4PoaWMxxLkiRJkiRJkiS1pI0si/r6+NTM/vqtldXgKAXEzXAsSZIkSZIkSZLUsnpJ + fmuVFq/1jzMx2MjK+szCoeAwBcTLcCxJkiRJkiRJktTCTuybKrpp/kBopInBf8/O1W/57mNoDcOxJEmS + JEmSJElSi4v6+jjvuD6GljAcS5IkSZIkSZIktbyqLDtVVjwUGmxi8OjsXP2262OImuFYkiRJkiRJkiRp + RHr/+jh/IzTcDNvdro8haoZjSZIkSZIkSZKkEepEUXSqtPhx/3ATi8f2f6Z+e3U1OFwBw2M4liRJkiRJ + kiRJGrHqxsXvPnZ9DFwWw7EkSZIkSZIkSdKIdizPp6u0eLh/xInF43Pz9bm1teCIBewuw7EkSZIkSZIk + SdIId/vExHW9rLitSouz/WNODO4pOvXzhxaDQxawewzHkiRJkiRJkiRJY1BvsjNfpcXj/YNOLJ7YvD5e + dX0Mw2I4liRJkiRJkiRJGpO2XB+/3T/sxOD7Rad+4ZDvPoZhMBxLkiRJkiRJkiSNWcf2lQeqtPhF/7gT + i83r43dcH8OuMhxLkiRJkiRJkiSNYRvRXx9P1X/03cewawzHkiRJkiRJkiRJY9x6URysor8+Xg0OXcD2 + MRxLkiRJkiRJkiSNebFfH9/r+hh2nOFYkiRJkiRJkiRJ79WbLFeqtHi6f/SJQa/x1PyB+vya7z6GnWA4 + liRJkiRJkiRJ0j87MnHz9d2kuKNKi/P9408M7i+n6j8vLgWHL+DqGY4lSZIkSZIkSZI00InJYqVK89+E + RqBhu3R9/A/Xx7BtDMeSJEmSJEmSJEkKtjn2xHx9/IPOtOtj2CaGY0mSJEmSJEmSJH1ovTxfq9Iyzuvj + rHR9DNvAcCxJkiRJkiRJkqSP7MH5+bivj8vp+uWl5eAgBnw0w7EkSZIkSZIkSZIuuyrLPlelxTP9w1AM + XB/D1TMcS5IkSZIkSZIk6YravD6u0uI7jQtbx6FYnCyn61dcH8MVMRxLkiRJkiRJkiTpqurl+Ze6afG7 + 0FA0bOtZUT9z4Mb6wlp4JAP+leFYkiRJkiRJkiRJV93xNL2hm5ZHQmNRDB6YmqlfWz4cHMqA/2E4liRJ + kiRJkiRJ0jW3nmVfqtLi9/2DUQzWG5vXx+/67mP4QIZjSZIkSZIkSZIkbUsbk5OfiPn6+MHO5vWx7z6G + EMOxJEmSJEmSJEmStrVeVn65cn0MrWI4liRJkiRJkiRJ0rYX+/XxQ1Oz9euuj+GfDMeSJEmSJEmSJEna + sXpJ8dUqLc70D0kxcH0M/8NwLEmSJEmSJEmSpB3tu/v2faLKym5oUIrBT6Zm6zcPrwTHNBgXhmNJkiRJ + kiRJkiTtSutp8W9VWrzYPyrF4M6srE8fvCk4qME4MBxLkiRJkiRJkiRp19rodPZWaXF3/7AUi59M76/f + PHw4OKzBKDMcS5IkSZIkSZIkadfrpcU3K9fHEA3DsSRJkiRJkiRJkobSsbKM+vr44enZ+m8rvvuY8WA4 + liRJkiRJkiRJ0lDrJfl/VGnxUv/YFAPXx4wLw7EkSZIkSZIkSZKG3npR7Ksivj7+qetjRpzhWJIkSZIk + SZIkSdFUZeW3umnxcmh8Gra78k79u4MLwdEN2s5wLEmSJEmSJEmSpKg6sW+qqNLiZP/4FItTM/vrt1ZW + g+MbtJXhWJIkSZIkSZIkSVHWS/Jbq7R4rX+EisFG3qnPLBwKDnDQRoZjSZIkSZIkSZIkRduxT3eKbpo/ + EBqjYvDfs3P1W777mBFgOJYkSZIkSZIkSVL0vX99nL8RGqWG7W7Xx4wAw7EkSZIkSZIkSZJaUVWWnSor + HgoNUzF4dHauftv1MS1lOJYkSZIkSZIkSVJrqhsXv/vY9TFsI8OxJEmSJEmSJEmSWteJouhUafHj/oEq + Fo/t/0z99upqcKCDGBmOJUmSJEmSJEmS1MpcH8P2MRxLkiRJkiRJkiSp1XUnO/PdrPh5aLCKwRNz8/W5 + 1bXgWAexMBxLkiRJkiRJkiSp9d0+MXFdLytuq9Li7f7RKgb3FJ36hUOLwcEOYmA4liRJkiRJkiRJ0sjU + m+zMV2nxeP9wFYvN6+N3XB8TIcOxJEmSJEmSJEmSRqrYr4+/X0y5PiY6hmNJkiRJkiRJkiSNZN2iOFCl + xS/6R6xYuD4mJoZjSZIkSZIkSZIkjWwbLbg+/qPrYyJgOJYkSZIkSZIkSdLIt14UB6s0/2Vo1IrB+9fH + q8FBD3aD4ViSJEmSJEmSJElj0eb1cTcrvl2lxfn+YSsG95dT9UtLS8FRD3aa4ViSJEmSJEmSJEljVW+y + XOmmxdOhgWvYeo2n5g/U59d89zG7y3AsSZIkSZIkSZKksWtzyOomxR1VxNfHf150fczuMRxLkiRJkiRJ + kiRpbOvm+VqV5r8JjV3Ddun6+B+uj9kFhmNJkiRJkiRJkiSNdbFfH/+gnK5fXloOjn2wXQzHkiRJkiRJ + kiRJUtPxPP9clRbP9I9eMehlpetjdpThWJIk/f/t3c+L3fW9x/FBuiiSRbAz5/P9fr5nJpM4NxmNJjNT + F11cghSXRUTu0rXLLuXu5C5ddpmFlJnzOROd0Ja2JEEjWC3ByoWCSCgXCRJoK9ZLo6gJNk2+d8Yk3Nzv + /SbOZH6czznn8YDX4vD9E568zwcAAAAAuO3s3JzrYxvLCccAAAAAAADQkIrC9bGN1YRjAAAAAAAAaPHz + 2dnvpxB/tr4bd0ewXHZm+kD992PHWyOg2VYnHAMAAAAAAMB99MvyRArVpbYgNuitFrG+ePhIfWOpPQaa + bXbCMQAAAAAAAHyHlRAe7oXqZFsUy2Eb18dXXB/bNiYcAwAAAAAAwCb1iu7TKcSPm2Esh62ub+P6+Ka3 + j+0BJhwDAAAAAADAFqxNTe3L+fr4bHfj+vhYaxw0u9eEYwAAAAAAAHgAK6H6cXJ9bCMy4RgAAAAAAAAe + 0KuTk1lfH5+bnq0/P+7tY/vuCccAAAAAAACwTf1OfCaFeLkZzHLYxvXxn47M1zdbYqHZnQnHAAAAAAAA + sAP6MzP7U4inm9Esl705PVt/eXyhNRqaCccAAAAAAACwg3ohPptC/KQZz3LYa0VVfzT/WGs4tPGecAwA + AAAAAAA7bK3bfSRlfH18fmbj+tjbx/a/E44BAAAAAABgl/Q68bkU4qfNkJbDXB/b3ROOAQAAAAAAYBct + V1XW18dvzczWXy14+3jcJxwDAAAAAADAHuh3yudTptfHr5dd18djPuEYAAAAAAAA9shqjJMp5+vjAwdd + H4/phGMAAAAAAADYY/1O+UIK8UozsOWwtaKqLz9+tDUu2uhOOAYAAAAAAIABODU5HVOIZ5qRLZe9feBg + fdX18dhMOAYAAAAAAIAB6nfKF1Ou18dl1/XxmEw4BgAAAAAAgAFb/kE3pk51ri265bB3Zg/V11wfj/SE + YwAAAAAAAMjErevj8ou2+DbonXZ9PNITjgEAAAAAACAjqaq6qYhvtAW4HPbt9fHiYmt8tOGdcAwAAAAA + AACZqdd3++1j18e2JxOOAQAAAAAAIFPLZTnTD/F8W4zLYe/OHvo2OLaFSBuuCccAAAAAAACQsY3r414o + f5pC/LoZ5HLYL2K3/vPRJ1pjpA3PhGMAAAAAAAAYAr2p7lwK8UIzyuWyPxyaq79ZXGqNkpb/hGMAAAAA + AAAYEi9PTDzUL+JLKcRrzTiXw34Zu/Vfjnr7eBgnHAMAAAAAAMCQWZ6sDqfMr4//4fp4qCYcAwAAAAAA + wBBay/76eLr+q7ePh2bCMQAAAAAAAAyx1RjnU4jvNWNdLrt1fbzYGistnwnHAAAAAAAAMORyvz7+levj + 7CccAwAAAAAAwIhYKcv5FMr32+JdDvvPR/+lvr7k7eMcJxwDAAAAAADACDk58cPv9TrxlRTi9WbAy2G/ + rqbrvz3xZGu8tMFNOAYAAAAAAIARdGoqLvRC/KAt5A16/fX9ce5w/U/Xx9lMOAYAAAAAAIARtRHscr4+ + /k13xvVxJhOOAQAAAAAAYMT1ynIpherDtqg36Lk+zmPCMQAAAAAAAIyB7K+Pq5n6syePtUZN2/0JxwAA + AAAAADBGVsryqRTixWbcy2H9onJ9PKAJxwAAAAAAADBmzs7NZX19/Ntqpv5v18d7OuEYAAAAAAAAxlSv + LP+1F+Klttg36K0Wsb54+Eh9Y6k9dNrOTjgGAAAAAACAMXYyxod7oTqZQrzRDH457Mz0gfrKseOtsdN2 + bsIxAAAAAAAAMLFaFCdSqPK8Pl7fxvXxTW8f79qEYwAAAAAAAOBbKyHcuT5uDYCD3tmu6+PdmnAMAAAA + AAAA/B/9ono6hfhxMwDmMNfHuzPhGAAAAAAAAPh/1qam9uV8fXyue6D+/Nix1ghqW59wDAAAAAAAANxT + CtWPU4iXmzEwh7k+3rkJxwAAAAAAAMB9vTo5mff18fSB+vPj3j7ezoRjAAAAAAAAYFNSqH6SQvykGQZz + 2GtFVX80/1h9syWK2ndPOAYAAAAAAAA2rT8zsz+FeLoZB3PZm9Oz9Zeuj7c84RgAAAAAAADYsn6Iz6bM + r4/bAqm1TzgGAAAAAAAAHshyVT2SMr4+Pj/j+nizE44BAAAAAACAbUmd8rkU4qfNYJjDXB9vbsIxAAAA + AAAAsG2rMU6mjK+P35qZrb9aWGiNpiYcAwAAAAAAADuo1ymfT5leH79edl0f32PCMQAAAAAAALCj1ooi + 6+vjtw8crK8uLLYG1HGdcAwAAAAAAADsin6nfDGFeKUZEnPYWlHVlx8/2hpRx3HCMQAAAAAAALBrTk1O + x14oz7QFxRz2u9lD9VVvHwvHAAAAAAAAwO7L+vq47I799bFwDAAAAAAAAOyJVFXdVMRzbXExh70ze6i+ + NqbXx8IxAAAAAAAAsKduXR+XX7RFxkHv9JheHwvHAAAAAAAAwJ47FWM3hfhGMzLmsncPPlpfW1xsjayj + OOEYAAAAAAAAGIh6fbffPnZ9POAJxwAAAAAAAMBALZflTArxfDM45rILh+bqb5aWWoPrqEw4BgAAAAAA + AAbu5YmJh/pFfCmF+HUzPOawX8Ru/eejT7RG11GYcAwAAAAAAABkoz/VnUshXmjGx1z2h43r48XRuz4W + jgEAAAAAAICs3HV9fK0ZIXPYL2O3/svR0Xr7WDgGAAAAAAAAstSL8XAK8b1miMxlG9fH/xiR62PhGAAA + AAAAAMjWWvbXx9P1X0fg7WPhGAAAAAAAAMjeaozzKZTvt4XJHHbr+nixNcoOw4RjAAAAAAAAYCjkfn38 + qyG+PhaOAQAAAAAAgKHSn6oWUogfNANlDuuv749zh+vrS8P19rFwDAAAAAAAAAydkxM//F6vE19JIV5v + hsoc9utquv7bE0+2RtocJxwDAAAAAAAAQ+vUVFxIofywLVgOeneuj/85BNfHwjEAAAAAAAAw1DbCZM7X + x7/pztSfPXmsNdjmMuEYAAAAAAAAGAn9slxKocrz+riosr4+Fo4BAAAAAACAkXF2bi7v6+Mqz+tj4RgA + AAAAAAAYOakonkohXmxGzByW4/WxcAwAAAAAAACMpI3r4xTiz9Z34+6QmcvOdGfqvx873hpy93rCMQAA + AAAAADDS+mV5ohfipbaoOeitFrG+ePhIfWOpPeju1YRjAAAAAAAAYOSthPBwL1Qn28JmDjszfaC+MsDr + Y+EYAAAAAAAAGBurRXEihfhxM27msNX1bVwf3xzA28fCMQAAAAAAADBW1qam9uV8fXy2u3F9fKw18O7W + hGMAAAAAAABgLPWL6unk+vjbCccAAAAAAADA2Mr9+vjc9Gz9+R5cHwvHAAAAAAAAwNjrd+IzKcTLzeiZ + w/bi+lg4BgAAAAAAAFj36uTkvlRUvbb4mcPenJ6tvzy+0Bp+tzvhGAAAAAAAAOAuqyH+JIX4STOA5rDX + iqr+aP6x1vi7nQnHAAAAAAAAAA1r3e4jKcTTzQiay96cOVh/efx4awR+kAnHAAAAAAAAAPfQD/HZNAbX + x8IxAAAAAAAAwH0sV1XW18fnZ2brrxa29/axcAwAAAAAAACwCf1O+XwK8dNmGM1h270+Fo4BAAAAAAAA + Nmk1xsmU8fXxWw94fSwcAwAAAAAAAGxRKqp/64X4WVsoHfReL7v1pfnHWwPxvSYcAwAAAAAAADyAU5PT + MYX422YozWVvHzhYX11YbA3FzQnHAAAAAAAAANvQ75QvphCvNINpDlsru/Xlx4+2xuK7JxwDAAAAAAAA + bNPyD7qxF8ozbeE0h/1u9lB99T5vHwvHAAAAAAAAADvk1vVx+UVbQB30Tt/n+lg4BgAAAAAAANhBqaq6 + qYhvtEXUHPbO7KH6WuP6WDgGAAAAAAAA2GH1+m6/fTwU18fCMQAAAAAAAMAuORVjN4V8r4/fPfhofW1x + UTgGAAAAAAAA2G39TvlCCvFKM6rmsLWiqv90ZL71205MOAYAAAAAAAC4rTfVnesV8fdtcXWUJxwDAAAA + AAAA3OXliYmH+kV8KYV4rRlYR3XCMQAAAAAAAECL/lR3LoV4oRlZR3HCMQAAAAAAAMA9jMv1sXAMAAAA + AAAA8B16MR5OIb7XDK6jMuEYAAAAAAAAYBPWRvj6WDgGAAAAAAAA2IKVspxPoXy/LcAO64RjAAAAAAAA + gC3auD7uFfE/UojXmxF2GCccAwAAAAAAADyg/lS10Avxg7YYO0wTjgEAAAAAAAC2YSO69jrxlTTE18fC + MQAAAAAAAMAO6JXlUgrlh21hNvcJxwAAAAAAAAA7ZOPt4xTKf++F+E1boM11wjEAAAAAAADADlspy6dS + iBebgTbXCccAAAAAAAAAu+Ds3NzQvH0sHAMAAAAAAADsolQU2V8fC8cAAAAAAAAAu+xkjA/3QnUyhXij + GW1zmHAMAAAAAAAAsEf6ZXkihepSW7wd5IRjAAAAAAAAgD20EsKd6+PWiDuICccAAAAAAAAAA9Aruk+n + ED9uRtxBTDgGAAAAAAAAGJC1qal9OVwfC8cAAAAAAAAAA7baqX6UOvG/2qLuXkw4BgAAAAAAAMjAq5OT + A7s+Fo4BAAAAAAAAMtLvxGdSiJebcXc3JxwDAAAAAAAAZKY/M7M/hXi6GXh3a8IxAAAAAAAAQKZ6IT6b + QvykGXp3esIxAAAAAAAAQMbWut1H0i5fHwvHAAAAAAAAAEOg14nPpRA/bUbfnZhwDAAAAAAAADAklqtq + V66PhWMAAAAAAACAIdPvlM+nHbw+Fo4BAAAAAAAAhtDP98/uT5243BaCtzrhGAAAAAAAAGCI9TvlCynE + K80YvJUJxwAAAAAAAABD7tTkdOyF8kxbFN7MhGMAAAAAAACAEdHvlC+mB7g+Fo4BAAAAAAAARkiqqm4q + 4rm2QHyvCccAAAAAAAAAI+j29fEXzUjcNuEYAAAAAAAAYESdirGbQnyjGYqbE44BAAAAAAAARli9vl4o + f5pC/LoZjO9MOAYAAAAAAAAYA72p7lyviL8XjgEAAAAAAADG2MsTEw/1i/hSCvGacAwAAAAAAAAwxpYn + q8MpxAvCMQAAAAAAAMAYW7vr+lg4BgAAAAAAABhjKyHMbvyF9e2fAAAAAAAAAAAAAAAA7IyJif8BICRs + XJwLhxYAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAA50AAAeOCAYAAAB3IVJsAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + wwAADsMBx2+oZAAAg6NJREFUeF7s/V2MZXWd939XiCGGGINM135Ye9cDbdk0/VBdVZiJMcaYiTHGTIwx + HvwPJnPIwX0wh+Q6I3PI4Rz2gSHdu3Y1FCIiAiJiD0yIGCOGvyHEEC//LSIiICA22LTNvtfuXjOjmx9N + P6z1++29f6938sqd+3/NKHRX7bU+yffa14IkSbq8RtX/ryRJkiRJtTZoF//Pdqf4/1X/fyVJkiRJqqdj + 3e7ydrt4rfTWYM9Kp/r/LEmSJEnS1XX7wsI15dh8tDSq3F/9H0mSJEmSdHUNO8VtfzM4zxt2et+o/o8l + SZIkSbqyhov9tXJknp4cnaXXndlKkiRJkq646qz2yYmx+bce8G22kiRJkqQrKnRWO2nY6t5a/Y9LkiRJ + knRp7RTF/nJUvjM5MgPeGna7y9X/miRJkiRJF2/3wlntjyfG5cU86sxWkiRJknRJXcpZ7SRntpIkSZKk + D2242NsoR+SlnNVOeutEp7Na/cdIkiRJkvT37R44cO2gXTwTGJSXZNguHnNmK0mSJEkKNmgVd4TG5OVw + ZitJkiRJel/Hu93xt9WenRyRV+Ct8X9W9R8rSZIkScq98Vntdrv7k8CAvELdnzizlSRJkiSdr46z2knO + bCVJkiRJ47PaT5cjsY6z2kmnh63W3uq/RpIkSZKUWw+trV1bjsNnJ8ZibQbt3uO3LyxcU/3XSZIkSZJy + qomz2knObCVJkiQpw4ad/j+Wo7CJs9pJp32brSRJkiRl1NGiuK4cg89NjMMGdX9ycmHhI9V/vSRJkiRp + nhu0e0fD47A5w05xW/VfL0mSJEma13Y6nc+XI/Dc5Chs2qBdnCn/uw9U/xiSJEmSpHnreLt93Xa796vQ + KIxh2C5+6sxWkiRJkua0FGe1k5zZSpIkSdIcNuz0vhAagQmcOd5uH6r+sSRJkiRJs97u4uLHyrH364nx + l06r+JkzW0mSJEmak6bhrHaSM1tJkiRJmoO2271/Co2+KXBmp9Vfr/4xJUmSJEmz1jf37Bmf1Z6aGHtT + Y9Apfn504RZntpIkSZI0i03jWe0kZ7aSJEmSNINtt3v/HBp5U+jssNP/x+ofW5IkSZI07Q2Xl68vx9xL + E+Numj135+rqR6t/fEmSJEnSNFeOuHsmRt3UG7SKO6p/fEmSJEnStDZoF18NjboZcG673ftM9a8hSZIk + SZq2jvV6N5TjbZbOaic9t9vvO7OVJEmSpGmsHG0zd1Y7yZmtJEmSJE1h263u10IjbgadK4fnZ6t/LUmS + JElS6naKYk851l6eGG8za9gpfunMVpIkSZKmpHKoRTmrvafbPy/0f1Y3Z7aSJEmSNAUNWt2vh0ZbE/6/ + AwfPC/2fNeDczmL3c9W/piRJkiQpdrudTrSz2qf2ro1Gt9xy3o9Wbgz+zzTg+aNFcV31rytJkiRJilk5 + yqKc1X67WBq9u7n1P6Pz9MbG6O5uL/g/24D/qP51JUmSJEmxGrR6/xoYaI343cFD/zM4/9vz+28O/s82 + YdAqvlj9a0uSJEmSmu7EnqWiHGOvT46zJvztWe2kiGe2p7ZvuOHj1b++JEmSJKnJBu3ug4FhVrsLZ7Wb + wcE59vbG5mg30pntoN07Wv3rS5IkSZKaatjq3hoaZU0IndVOinlmW/67f6n6Y5AkSZIk1d2xf+hHO6v9 + 6Sc/FRyZIU+s7g3+Z9SuVbyw+4m9zmwlSZIkqYm2O8XDwTFWs/t7S6OzW//7bbUf5i+bm6N7uv3gf1bd + nNlKkiRJUgPFOqsdlv5w6HBwXF7MqZsPBP/zGtHpfLn6Y5EkSZIkXW0niqK/3e6+GRxgNXt6bV9wVF6K + aGe27eLFO69fvb7645EkSZIkXWmj0naneCQwvGr33f7y6K+XcVY7aXxm+61iKfifXTdntpIkSZJUQzG/ + rfZKzmon/ebAweB/dhMGnd5Xqj8mSZIkSdLldqzbXS7HVZSz2qf2rgVH5JUY/2eF/jsa8OJwedmZrSRJ + kiRdbrcvLFxTjqpHJ0ZWI77bWx69u7kZHJBXYvyfdW+kM9vtTm9Q/ZFJkiRJki61Yae4LTiyajbs9Eav + HF4Pjser8ULEM9vy3+Eb1R+bJEmSJOnDGi7218oxdXpyXDXhar6t9sNE/DbbV463263qj0+SJEmS9EFV + Z7VPToyqRjzQu7pvq/0wZ86f2faD/9216/Turf4IJUmSJEkf1Kyf1U767cFDwf/+JjizlSRJkqSLdGxP + b185nt6ZHFNNeOZTzZ3VTnoy3rfZvrbTajmzlSRJkqTJdi+c1f54YkQ14sGlldG5rfBAbML422zvi/Rt + tsN2cV/1RypJkiRJ+u9indXulF5fPxIch0166dDh4D9PE5zZSpIkSdLftFMU+8uxFOWs9tl9NwVHYQxP + RTyzvXNxsVP98UqSJElSvsU8q32oH/esdtLZra1oZ7al+6s/YkmSJEnKt3k/q530e2e2kiRJkhSn4WJv + oxxHc39WOynime3rx7rd5eqPW5IkSZLy6ejCLR8pR9EzEyOpEQ/3V0bvbW0FB2AK4zPb7/SWg/+sDXh0 + VP2ZS5IkSVI2DVrFHYGBVLvxWe0b6+vB8ZfSy4cOBf95mzBsdW+t/tglSZIkaf47sViMz2rPTo6jJkzT + We2kiGe2b53odFarP35JkiRJmt92Dxy4drvd/UVgGNXu4aXpOquddOHMNs632Q7bxWPObCVJkiTNfbHO + au/q9EZvHEn/bbUf5uXDh8ffMhv8d6ibM1tJkiRJc92w290qx0+Us9rn998cHHnT6Om1fcF/hwa8dbzd + dmYrSZIkaf56aG3t2u12L8pZ7Q+WVkfvBcbdtDpXeqC/Evx3qV/3pDNbSZIkSXNXzLPat2bgrHbSq85s + JUmSJOnK2u50Pl2OHWe1HyLime3pYau1t/rrkSRJkqTZ7cJZbfHsxOhpxKPLq8ExNyvGZ7bfi3Vm2yoe + v31h4Zrqr0mSJEmSZjNntZfntfX1aGe2g3b336q/JkmSJEmavQbd7ufKcXNucuw0YZbPaidFPLN9Z7vT + OVD9dUmSJEnS7HS83b5u0C5+FRg6tfvhjJ/VTrpwZrsc/HetX++nJxcWPlL9tUmSJEnSbDRo946GR069 + 7u72R3/e2AiOt1n2x8Pro51O+N+5bsNOcVv11yZJkiRJ099Op/P50Lhpwjyd1U6KdWY7aBdnyr8zZ7aS + JEmSpr/dxcWPbbd7cc5qV24MjrV5cW7rltGDkc5sh+3Cma0kSZKk6S/WWe1upzeXZ7WT/rh+ZHQi0rfZ + OrOVJEmSNNUNO70vhMZME04dOBgcafPo2X03Bf8MGnBmu90/VP11SpIkSdL0dOGstvj1xIhpxH+u7g2O + s3n13tbW6PtLK8E/i9q1ip8dXbjFma0kSZKk6SraWW23P3o7g7PaSW8ecWYrSZIkKdO2271/Co2XJuR0 + Vjsp5pntTqu/Xv31SpIkSVK6vrlnz/is9tTEaGnE45md1U6KembbLn7uzFaSJElS8rY7vUFgsNTunm5/ + 9E6GZ7WT3oz4bbaDTvHv1V+zJEmSJMVvp138c2isNCHns9pJEc9szx1v9/+x+uuWJEmSpHjt9vs3lKPk + pYmR0ojcz2onvVd6ZHk1+GfVgOfuXF39aPXXLkmSJElxKsfIPRPjpBHnz2o3N4PjK2d/OrIxuivWmW2r + uKP6a5ckSZKk5hu2i6+GxkkTnNV+sJhntjut3meqv35JkiRJaq5jvV60s9on964FxxYXjM9sH1u5Mfhn + V7tW8cvdft+ZrSRJkqRmKwdIlLPae4v+6MzWVnBs8b/+vLExurvbD/4Z1s2ZrSRJkqRG2251vxYaI034 + 7cFDwZHF+z2//+bgn2EDzpXD87PVj4MkSZIk1ddOUewpR8fLEyOkEU85q71s0c5s28XzzmwlSZIk1V45 + NqKc1X57fFa76az2cp0+f2br22wlSZIkzWDbnd43QuOjCS8e9G21Vyrmme3OYvdz1Y+HJEmSJF15gz0r + nUG7eCUwPGrnrPbq/Whlb/DPtgHPb99ww8erHxNJkiRJurLKcfHAxNhoxLeLpdG7zmqv2umNzdFurDPb + du9o9WMiSZIkSZffsNW9NTQ2mvA731Zbm4hntuP/9zu/VP24SJIkSdKld+wf+kU5Kl5/38hogLPa+p2M + 9222LzizlSRJknTZDdrdBwMDo3b3nT+r3QwOJ67c2+Mz244zW0mSJElTWKyz2mHJWW1zfrX/QPDPvQmD + xe6Xqx8fSZIkSfrgtnu9/na7+2ZoWNTt6bV9wbFEfZ5YjfRttq3ihd1P7HVmK0mSJOmDG5W2O8XDwVFR + s/t7S6OzW76ttml/2dwcfavbD/4d1M2ZrSRJkqSLFvOs9g+HDgdHEvU7dXO8M9thp/+V6sdJkiRJkv63 + E0XRL0eDs9o5Fe3Mtl28eOf1q9dXP1aSJEmSVJ3VtotHJsZDI77bXx791VltdOfPbIul4N9J3ZzZSpIk + Sfq7op3VdnrOahP6zYGDwb+XZvT+ufrxkiRJkpRzg8X+WjkSnNVmIuKZ7Uu7nc6e6sdMkiRJUo7dvrBw + zaBT/FdgMNTuuz1ntdPgzObm6N5IZ7bbre491Y+aJEmSpBwbdorbgmOhZuOz2lcOrwdHEPG9EPHMtvy7 + /0b14yZJkiQpp4YXzmrfmRwJTXBWO30intm+crzdblU/dpIkSZJyaHxWW46BJyfGQSMecFY7lc6Ufyf3 + Fv3g31kD7qt+9CRJkiTlUKyz2p1OMXrVWe3U+u3BQ8G/tyY4s5UkSZIyaVAU+8oREOWs9tl9NwXHDtPj + qb1rwb+7Brx25+Jip/oxlCRJkjSP7V44q/3xxBhoxINLK6NzW+Ghw/R4d3NzdF+sb7NtF/dXP4qSJEmS + 5rFoZ7Wl19ePBEcO0+elQ4eDf49NcGYrSZIkzWk7RbG/fOl3VktQzDPbwZ4VZ7aSJEnSPHXhrLb7k8AA + qN1D/ZXRe76tduacLf/OvtNbDv6d1m3QLh6ofjQlSZIkzUODTvHvoZf/ul04q/VttbPq9xHPbAet3r9W + P56SJEmSZrnhYm+jfMk/O/nS3wRntbMv4pntW8Nud7n6MZUkSZI0i+0eOHDtoF08E3jhr93DzmrnQswz + 29Jjo+pnVZIkSdIMNmgVdwRe9Gs3Pqt9w1nt3Hj58OHRcOLvuCnDVvfW6sdVkiRJ0iw16Ha3ypd6Z7Vc + kZhntic6ndXqx1aSJEnSLDQ+q91ud38ReMGv3Q+WVp3VzqHxme0D8c5sTzqzlSRJkmaoWGe1d3V6o7eO + bARHC7Pv1cPro2H5dxz6u6+bM1tJkiRpRjre7X66fImPclb7/P6bg2OF+fH02r7g330D3hq2WnurH2NJ + kiRJ09hDa2vXli/vz068zDfiB8s3BkcK8+Vc6YH+SvBnoG6Ddu9xZ7aSJEnSFBf3rPZIcKQwf15dd2Yr + SZIkZd92p+OslsZEPLM9fVdryZmtJEmSNE3dubr60fJlPcpZ7aPLq8FRwnwbn9l+rx/p22xbxX/tLixc + U/14S5IkSUpd+aL+H+97cW/A+Kz2zxu+rTZXr8U8s+0Ut1U/3pIkSZJSNux2P1++pJ+bfGlvgrNaYp3Z + DtrFme1O50D1Yy5JkiQpRcfb7eu2271fhV7a6/ZDZ7WUop7Ztns/Pbmw8JHqx12SJElS7Abt3tHwy3q9 + 7u72ndXyP/54eH200wn/rNTNma0kSZKUqEGn/4XQS3oTfrX/QHB8kK+YZ7bH2+1D1Y+9JEmSpBjtLi5+ + rHwh//XkC3oTTq7cGBwd5O3c1i2jh5dWgj8ztWsVP3NmK0mSJEUs1lntbrc/entjMzg64I0jR0YnfJut + JEmSNF8db/f+KfRS3oRTBw4Gxwb8t2f33RT82WnAmZ1Wf736NZAkSZLURN/csyfaWe1/ru4Njgz4W+9t + bY2+H+nMdtApfn504RZntpIkSVJTxTqrvef8Wa1vq+XSvOnMVpIkSZr9hq3ii6GX8CY4q+VyRTyzPTto + 9ZzZSpIkSXU2XF6+vnzZPjXx8t2Ix53VcgXeKz2yvBr8mWrAM3eurn60+vWQJEmSdLWVL9n3TLx0N2J8 + VvuOs1qu0Jvr8c5sB63ijurXQ5IkSdLVNGgXXw29dDfBWS1XK+KZ7bntdu8z1a+JJEmSpCtpt9+/oXy5 + fmniZbsRT9z4yeCIgMsR+cz2OWe2kiRJ0lVUvlTHO6vd3AyOCLhcfzqyMbrLma0kSZI03ZUv018LvWQ3 + wVktdXvupv3Bn7UGnNtpObOVJEmSLqtjvd74rPbliZfrRjy1dy04GuBqPbZyY/Bnrm7DTvHL3X7fma0k + SZJ0qZUv0lHOau8t+qMzm1vBwQBX688bG6O7u/3gz17dnNlKkiRJl9iw1f166KW6CS8ePBQcC1CX5/ff + HPzZa8C57Vbx2erXSJIkSVKonaLYU748O6tlrsQ6sy09f7Qorqt+nSRJkiRNVr40Rzmr/Xax5KyWaE6f + P7P1bbaSJElS0oat7r+EXqKb4KyW2GKe2Q5bxRerXytJkiRJ407sWSrKl+XXJ16eG+GsllR+tLI3+DPZ + gFPbN9zw8erXS5IkSVL5kvzgxEtzI8Znte86qyWR0xubo91YZ7bt3tHq10uSJEnKu2Gre2vopbkJv3NW + S2IRz2xH5e/Wl6pfM0mSJCnPjv1D31kt2TkZ79tsX9j9xF5ntpIkScq37Vbv4cCLcu3u743PajeDAwBi + e3tjc3RPtx/8Wa2bM1tJkiRlW6yz2mHp5cOHgy//kMqpAweDP69NGCx2v1z92kmSJEl5tN3r9bfb3TdD + L8h1e3ptX/ClH1J7YjXat9m+eOf1q9dXv36SJEnSfDcqbXeKRwIvxrUbn9We3fJttUynv2xujr7lzFaS + JEmqt5hntX845KyW6fabiGe2w07/K9WvoSRJkjSfHet2l8uXX2e18Dec2UqSJEk1ND6rHbaLRwMvwrX7 + bm959FdntcyI82e2xVLwZ7l2nd7gwm+kJEmSNGcN2t1/C74E12zY6Y1eObwefLmHaRX3zLb3jerXUpIk + SZqPBov9tfJl9/Tky28TnNUyq2Kd2Q7axSvH2+1W9espSZIkzXa3LyxcU77oPjn54tsEZ7XMsjObm6N7 + I53ZDju9e6tfUUmSJGm2G3aK20IvvXVzVss8+O3BQ8Gf7yY4s5UkSdLMd2xPb1/5cvvO5MtuE5zVMi8i + fpvtKzutljNbSZIkzWa7Ec9qH1xacVbL3DhT/izfF+vbbNvFfdWvrCRJkjRbxTqr3ekUoz+uHwm+vMOs + esmZrSRJkvTB7RTF/vJlNspZ7bP7bgq+tMOse2rvWvBnvgGv3bm42Kl+fSVJkqTprjqr/fHES20jxme1 + 57bCL+ww697d3Ix5Znt/9SssSZIkTXfRzmpLrzurZc69dOhw8Oe/Cc5sJUmSNPUd73ad1ULNIp7Zvj7Y + s+LMVpIkSdPZ0YVbPrLd7v4k8CJbu4f6K6P3fFstmThb/qx/p7cc/F1owAOj6ndakiRJmqoGreKOwAts + 7S6c1a4HX85hXv0+5pltq3tr9WstSZIkTUcnFouN8mX17OTLaxOc1ZKriGe2bw273eXq11uSJElK2+6B + A9cO2sUzgRfX2j28tOqslmxdOLON9m22jzmzlSRJ0lQU86z2jSO+rZa8vXz48Gg48bvRFGe2kiRJSt6g + 290qX06jnNU+d9P+4Es45Oann/xU8HekAW8db7dXq193SZIkKW7js9rtdu8XgRfV2v1gfFYbePmGHJ0r + PRDv22xPOrOVJElSkmKd1d7V6Y3eOrIRfPmGXL06PrMtfzdCvzN1c2YrSZKk6B3vdj9dvoxGOat9fv/N + wZduyN3Ta/uCvzMNOD1stfZWv/6SJElSsz20tnZt+RL67MRLaSMeXV4NvmwD1ZltfyX4u1O3Qbv3+O0L + C9dUHwOSJElSc8U9q/VttXAxr62vO7OVJEnS/DTs9P+xfPl0VgtTJOaZ7fFud3/1cSBJkiTV29GiuK58 + 6Xxu4iW0ET90VguXbHxm+71+rG+z7f7k5MLCR6qPBUmSJKm+Bu3e0fBLaL3u7vZHf97wbbVwOcZntjud + 8O9U3Yad4rbqY0GSJEmqp51O5/Ply+a5yZfPJjirhSsT68x20C7OlJ8JB6qPB0mSJOnqOt5uX7fd7v0q + 9PJZtx+u3Bh8mQY+3LmtW0YPRjqzHbaLnzqzlSRJUi3FOqvd7fSc1cJV+uPh9dGJWN9m68xWkiRJV9uw + 0/tC6GWzCacOHAy+RAOX59l9NwV/xxpw5ni7faj6uJAkSZIur93FxY+VL5W/nnjJbMRJZ7VQm/e2tkbf + X1oJ/q7VrlX8zJmtJEmSrqhoZ7Xd/ujtjc3gyzNwZd48csSZrSRJkqa37Xbvn0Ivl01wVgvNiHlmu9Pq + r1cfH5IkSdLF++aePeOz2lMTL5WNeHx1b/BlGbh6Mc9sB53i50cXbnFmK0mSpA8v1lntPd3+6B3fVguN + cmYrSZKkqWq73fvn0MtkE5zVQhwRz2zPDjv9f6w+TiRJkqS/b7i8fH350vjSxEtkI5zVQjzvlR5ZXg3+ + LjbguTtXVz9afaxIkiRJ/1v5snjPxMtjI86f1W76tlqI6U9HNkZ3RTqzHbSKO6qPFUmSJOlCw3bx1dDL + YxOc1UIaEc9sz223e5+pPl4kSZKUe8d6vRvKl8QoZ7VPOKuFZMZntj9YinRm2yp+udvvO7OVJElSvLPa + e4v+6C/OaiGp8Znt3d1+8He0bs5sJUmStLDd6n4t9LLYhN8ePBR8CQbien7/zcHf0QacK4fnZ6uPG0mS + JOXWTlHsKV8KX554SWzEU3vXgi+/QBqPrdwY/F2t27DjzFaSJCnbyhfCKGe13y76ozObW8EXXyCN0xvj + M1vfZitJkqSGGrS6Xw+9HDbhRWe1MJVintnuLHY/V338SJIkad7b7XSc1QLn/SjSmW3p+aNFcV31MSRJ + kqR5rnz5i3RWuzR611ktTLWYZ7al/6g+hiRJkjSvDVvdWwMvgo34nbNamAkRz2zH//c7v1h9HEmSJGne + OrFnqShf+l6ffAlsgrNamC0Rz2xPbd9ww8erjyVJkiTNU4N298HAC2DtLpzVbgZfbIHp9PbG5mg31rfZ + tntHq48lSZIkzUvOaoEPE/PMtvxM+lL18SRJkqRZb7vX65cveVHOan/6yU8FX2aB2fDE6t7g73btWsUL + u5/Y68xWkiRpHtruFA8HX/pqdn9vaXR2y7fVwiz7y+bm6FvdfvB3vG7ObCVJkuagWGe1w9IfDh0OvsQC + s+XUzQeCv+eN6HS+XH1cSZIkadY6URT97Xb3zeCLXs2eXtsXfHkFZlO0M9t28eKd169eX31sSZIkaVYa + lcqXuUcmXu4a8d3+8uivzmphrpw/sy2Wgr/zdXNmK0mSNIM5qwWu1m8OHAz+3jdh0Ol9pfr4kiRJ0rR3 + rNtdLl/inNUCVy3mme1up7On+hiTJEnStHb7wsI15cvboxMvc434bs9ZLcy78ZntvZHObLdb3XuqjzJJ + kiRNa8NOcVvwZa5mw05v9Mrh9eBLKjBfXoh4Zlt+tnyj+jiTJEnStDVc7K+VL22nJ1/imuCsFvIS8cz2 + lePtdqv6WJMkSdK0VJ3VPjnx8taIB5zVQnbOnD+z7Qc/E2rX6d1bfbRJkiRpWnJWCzTttwcPBT8XmuDM + VpIkaYo6tqe3r3xJe2fypa0Jz3zKWS3k7Mm9a8HPhga8ttNqObOVJElK3e6Fs9ofT7ysNeLBpZXRua3w + iyiQh3c3N0f3Rfo222G7uK/6qJMkSVKqYp3V7pReXz8SfAkF8vLSocPBz4kmOLOVJElK2E5R7C9fyqKc + 1T6776bgyyeQp6cintneubjYqT72JEmSFKuYZ7UP9Z3VAn/v7NZWtDPb0v3VR58kSZJi5awWSO33zmwl + SZLms+Fib6N8CXNWCyQX8cz29WPd7nL1MShJkqSmOrpwy0fKl69nJl7GGvFwf2X03tZW8EUTYGx8Zvud + 3nLwM6QBj46qz0JJkiQ11KBV3BF4Eavd+Kz2jfX14EsmwN96+dCh4OdIE4at7q3Vx6EkSZLq7sRiMT6r + PTv5EtYEZ7XA5Yh4ZvvWiU5ntfpYlCRJUl3tHjhw7Xa7+4vAC1jtHl5yVgtcngtntnG+zXbYLh5zZitJ + klRzsc5q7+r0Rm8c8W21wOV7+fDh8bfMBj9b6ubMVpIkqcaG3e5W+ZIV5az2+f03B18mAS7F02v7gp8t + DXjreLvtzFaSJOlqe2ht7drtdi/KWe0PllZH7wVeIgEu1bnSA/2V4GdM/bonndlKkiRdZTHPat9yVgvU + 4FVntpIkSbPRdqfz6fKlylktMHMintmeHrZae6uPTUmSJF1qF85qi2cnXq4a8ejyavClEeBKjc9svxfr + zLZVPH77wsI11cenJEmSLiVntcCse219PdqZ7aDd/bfq41OSJEkf1qDb/Vz5EnVu8qWqCc5qgSZFPLN9 + Z7vTOVB9jEqSJOmDOt5uXzdoF78KvFDV7ofOaoGGXTizXQ5+BtWv99OTCwsfqT5OJUmSFGrQ7h0Nv0zV + 6+5uf/TnjY3gSyJAnf54eH200wl/FtVt2Cluqz5OJUmSNNlOp/P50EtUE5zVAjHFOrMdtIsz5WepM1tJ + kqTJdhcXP7bd7sU5q125MfhSCNCUc1u3jB6MdGY7bBfObCVJkiaLdVa72+k5qwWS+OP6kdGJSN9m68xW + kiTpbxp2el8IvTQ14dSBg8GXQYAYnt13U/CzqQFnttv9Q9XHrCRJUr5dOKstfj3xstSI/1zdG3wJBIjl + va2t0feXVoKfUbVrFT87unCLM1tJkpR30c5qu/3R285qgSnw5hFntpIkSVHabvf+KfSS1ARntcA0iXlm + u9Pqr1cfu5IkSfn0zT17xme1pyZejhrxuLNaYMpEPbNtFz93ZitJkrJru9MbBF6MandPtz96x1ktMIXe + jPhttoNO8e/Vx68kSdL8t9Mu/jn0UtQEZ7XANIt4ZnvueLv/j9XHsCRJ0vy22+/fUL78vDTxMtSIJ278 + ZPAlD2BavFd6ZHk1+BnWgOfuXF39aPVxLEmSNJ+VLz33TLwENeL8We3mZvAlD2Ca/OnIxuiuWGe2reKO + 6uNYkiRp/hq2i6+GXoKa4KwWmCUxz2x3Wr3PVB/LkiRJ89OxXi/aWe2Te9eCL3UA02p8ZvvYyo3Bz7Ta + tYpf7vb7zmwlSdJ8Vb7oRDmrvbfoj85sbQVf6gCm2Z83NkZ3d/vBz7a6ObOVJElz1Xar+7XQS08Tfnvw + UPBlDmAWPL//5uBnWwPOlcPzs9XHtCRJ0uy2UxR7ypeblydedhrxlLNaYA5EO7NtF887s5UkSTNf+VIT + 5az22+Oz2k1ntcDsO33+zNa32UqSJH1o253eN0IvOU148aBvqwXmR8wz253F7ueqj21JkqTZ6cSepWLQ + Ll4JvODUzlktMI9+tLI3+JnXgOe3b7jh49XHtyRJ0mxUvsQ8MPFS04hvF0ujd53VAnPo9MbmaDfWmW27 + d7T6+JYkSZr+hq3uraGXmib8zrfVAnMs4pnt+P/9zi9VH+OSJEnT27F/6Bfly8vr73uZaYCzWiAHJ+N9 + m+0LzmwlSdLUN2h3Hwy8yNTuvvNntZvBFzSAefL2+My248xWkiQp2lntsOSsFsjJ/414ZjtY7H65+liX + JEmanrZ7vf52u/tm6AWmbk+v7Qu+lAHMsydWI32bbat4YfcTe53ZSpKk6WlU2u4UDwdfXmp2f29pdHbL + t9UC+fnL5uboW91+8LOxbs5sJUnSVBXzrPYPhw4HX8YAcnDq5gPBz8cmDDv9r1Qf85IkSek6URT98uXE + WS1AJNHObNvFi3dev3p99XEvSZIUv/Nnte3ikYmXlEZ8t788+quzWoALZ7bFUvCzsm7ObCVJUtKindV2 + es5qAf7Gbw4cDH5eNqLT+0b1sS9JkhSvwWJ/rXwZcVYLkEisM9tBu3hlt9PZU338S5IkNd/tCwvXDDrF + f4VeTur23Z6zWoCQM5ubo3sjndlut7r3VI8ASZKk5ht2ituCLyU1G5/VvnJ4PfiyBcAtoxcintmWn8nO + bCVJUvMNL5zVvjP5MtIEZ7UAHy7it9m+stNqtarHgSRJUv2Nz2rLl44nJ15CGvGAs1qAS3Km/Ky8t+gH + P0sbcF/1SJAkSaq/WGe1O51i9KqzWoBL9tuDh4Kfp01wZitJkhppUBT7ypeNKGe1z+67KfhSBcAHe2rv + WvAztQGv3bm42KkeD5IkSVff7oWz2h9PvHQ04sGlldG5rfALFQAf7N3NzdF9sb7Ntl3cXz0iJEmSrr5o + Z7Wl19ePBF+mAPhwLx06HPx8bYIzW0mSVEs7RbG/fLlwVgswI2Ke2Q72rDizlSRJV96Fs9ruTwIvGrV7 + qL8yes+31QJctbPlZ+l3esvBz9q6DdrFA9UjQ5Ik6fIbdIp/D71k1O3CWa1vqwWoy+8jntkOWr1/rR4b + kiRJl95wsbdRvkycnXy5aIKzWoD6RTyzfWvY7S5Xjw9JkqQPb/fAgWsH7eKZwItF7R52VgvQiJhntqXH + RtUzRJIk6UMbtIo7Ai8UtRuf1b7hrBagMS8fPjwaTnz2NmXY6t5aPUYkSZI+uEG3u1W+PDirBZgTMc9s + T3Q6q9XjRJIk6f2Nz2q3291fBF4kaveDpVVntQARjM9sH4h3ZnvSma0kSfrAYp3V3tXpjd46shF8OQKg + fq8eXh8Ny8/e0Gdy3ZzZSpKkYMe73U+XLwtRzmqf339z8KUIgOY8vbYv+JncgLeGrdbe6vEiSZK0sPDQ + 2tq15UvCsxMvDY34wfKNwZchAJp1rvRAfyX42Vy3Qbv3uDNbSZL0P8U9qz0SfBkCoHmvrjuzlSRJkdvu + dJzVAmQk4pnt6btaS85sJUnKuTtXVz9avhREOat9dHk1+PIDQFzjM9vv9SN9m22r+K/dhYVrqseOJEnK + rfKF4D/e94LQgPFZ7Z83fFstwLR4LeaZbae4rXrsSJKknBp2u58vXwbOTb4cNMFZLcD0iXVmO2gXZ7Y7 + nQPV40eSJOXQ8Xb7uu1271ehl4O6/dBZLcBUinpm2+799OTCwkeqx5AkSZr3Bu3e0fBLQb3u7vad1QJM + sT8eXh/tdMKf4XVzZitJUiYNOv0vhF4GmvCr/QeCLzkATI+YZ7bH2+1D1eNIkiTNY7uLix8rH/y/nnwR + aMLJlRuDLzcATJdzW7eMHl5aCX6W165V/MyZrSRJc1yss9rdbn/09sZm8OUGgOnzxpEjoxO+zVaSJF1N + x9u9fwo9/Jtw6sDB4EsNANPr2X03BT/TG3Bmp9Vfrx5PkiRpHvrmnj3Rzmr/c3Vv8GUGgOn23tbW6PuR + zmwHneLnRxducWYrSdK8FOus9p7zZ7W+rRZgVr3pzFaSJF1uw1bxxdDDvgnOagFmX8Qz27ODVs+ZrSRJ + s9xwefn68qF+auIh34jHndUCzIX3So8srwY/6xvwzJ2rqx+tHluSJGnWKh/m90w83BsxPqt9x1ktwNx4 + cz3eme2gVdxRPbYkSdIsNWgXXw093JvgrBZg/kQ8sz233e59pnp8SZKkWWi337+hfIi/NPFQb8QTN34y + +LICwGyLfGb7nDNbSZJmqPLhHe+sdnMz+LICwOz705GN0V3ObCVJ0t9WPrS/FnqYN8FZLcD8e+6m/cFn + QAPO7bSc2UqSNNUd6/XGZ7UvTzzEG/HU3rXgywkA8+exlRuDz4K6DTvFL3f7fWe2kiRNa+UDO8pZ7b1F + f3Rmcyv4YgLA/Pnzxsbo7m4/+EyomzNbSZKmtGGr+/XQw7sJLx48FHwpAWB+Pb//5uAzoQHntlvFZ6vH + myRJmoZ2imJP+ZB2VgtAo2Kd2ZaeP1oU11WPOUmSlLry4RzlrPbbxdLoXWe1ANk6ff7M1rfZSpKUVcNW + 919CD+smOKsFIOaZ7bBVfLF63EmSpBSd2LNUlA/l1yce0o1wVgvAf/vRyt7gs6IBp7ZvuOHj1WNPkiTF + rnwYPzjxcG6Es1oA/tbpjc3Rbqwz23bvaPXYkyRJMRu2ureGHs5N+J2zWgAmRDyzHZXPvC9Vjz9JkhSj + Y//Qd1YLQHIn432b7Qu7n9jrzFaSpFhtt3oPBx7Itbu/Nz6r3Qy+aADA2xubo3u6/eAzpG7ObCVJilSs + s9ph6eXDh4MvGQDw304dOBh8jjRhsNj9cvU4lCRJTbTd6/W32903Qw/iuj29ti/4cgEAk55YjfZtti/e + ef3q9dVjUZIk1dmotN0pHgk8gGs3Pqs9u+XbagG4NH/Z3Bx9y5mtJEmzXcyz2j8cclYLwOX5TcQz22Gn + /5Xq8ShJkuroWLe7XD5kndUCMNWc2UqSNIONz2qH7eLRwAO3dt/tLY/+6qwWgCt0/sy2WAo+Y2rX6Q0u + PCklSdJVNWh3/y34sK3ZsNMbvXJ4PfgSAQCXKu6Zbe8b1eNSkiRdScf+oV+UD9XTkw/ZJjirBaAusc5s + B+3ilfGzsnpsSpKky+n2hYVrtlu9h0MP2bo5qwWgTmc2N0f3FnG+zXb8rKwenZIk6XIadorbgg/Xmjmr + BaAJvz14KPjcaYIzW0mSLrNje3r7yofoO5MP1SY4qwWgKRG/zfaVnVarVT1GJUnSxdodn9W2iycnHqaN + eHBpxVktAI05Uz5j7ov1bbbt4r7qUSpJki5WrLPanU4x+uP6keBLAgDU5SVntpIkTU87RbG/fGhGOat9 + dt9NwZcDAKjbU3vXgs+iBrx25+Jip3qsSpKkv606q/3xxMOzEeOz2nNb4RcDAKjbu5ubMc9s768erZIk + 6W+LdlZbet1ZLQCRvXTocPC51ARntpIkTXS823VWC8Dci3hm+/pgz4ozW0mSxh1duOUj2+3uTwIPzNo9 + 1F8ZvefbagFI5Gz5DPpObzn4jGrAA6PqWStJUtYNWsUdgQdl7S6c1a4HXwIAIJbfxzyzbXVvrR63kiTl + 2YnFYqN8KJ6dfEg2wVktANMi4pntW8Nud7l67EqSlFe7Bw5cO2gXzwQekLV7eGnVWS0AU+PCmW20b7N9 + zJmtJCnLYp7VvnHEt9UCMF1ePnx4NJx4ZjXFma0kKbsG3e5W+RCMclb73E37gw97AEjtp5/8VPDZ1YC3 + jrfbq9VjWJKk+e7kwsJHttu9XwQeiLX7wfisNvCQB4BpcK70QLxvsz05fgZXj2NJkua37Xb3/wQehLW7 + q9MbvXVkI/iQB4Bp8er4zLZ8ZoWeZfXr/p/qcSxJ0nx2vNv99KBdnAk/COv1/P6bgw93AJg2T6/tCz7L + 6jZ+Bg9brb3VY1mSpPnqobW1a8sH3rOTD8AmPLq8GnyoA8A0Gp/Zfq+/Enym1a5VPH77wsI11eNZkqT5 + Kda31V44q/VttQDMltfW16Od2fo2W0nS3DXodj9XPuSifFuts1oAZlWsM9vS6ePd7v7qMS1J0mx3tCiu + G7SLXwUeeLX7obNaAGbYhTPbWN9m2/2Jb7OVJM1Fg3bvaPhhV6+7u/3Rnzd8Wy0As+2Ph9dHO53ws65u + w05xW/W4liRpNtvpdD5fPtTOTT7kmuCsFoB5EfPbbMtn9YHqsS1J0mx1vN2+brvdi3NWu3Jj8KENALPo + 3NYtowcjndkO28VPndlKkmayWGe1u52es1oA5s74zPZErG+zdWYrSZq1hp3eF0IPtSacOnAw+LAGgFn3 + 7L6bgs++Bpw53m4fqh7jkiRNd7uLix8rH16/nniYNeKks1oA5th7W1uj7y+tBJ+BtWsVP3NmK0maiaKd + 1Xb7o7c3NoMPaQCYF28eOeLMVpKk/2673fun0EOsCc5qAchFzDPbnVZ/vXqsS5I0XX1zz57xWe2piYdX + Ix5f3Rt8KAPAPIp5ZjvoFD8/unCLM1tJ0vQV66z2nm5/9I5vqwUgM85sJUlZN+x2Px96aDXBWS0AuYp4 + Znt2/GyvHvOSJKVtuLx8/aBd/CrwwKqds1oAcvZe6ZHl1eAzsm7jZ/udq6sfrR73kiSlq3ww3TP5oGrC + +bPaTd9WC0De/nRkY3RXpDPbQau4o3rcS5KUpmG7+GroIdUEZ7UAcEHEM9tz2+3eZ6rHviRJcTvW691Q + Poxemng4NeIJZ7UA8D/GZ7Y/WIpzZrvdKn652+87s5Ukxa98EEU5q7236I/+4qwWAP7O+Mz27m4/+Oys + mzNbSVL0tlvdr4UeSk347cFDwYctAOTu+f03B5+dDThXDs/PVq8BkiQ1205R7CkfPi9PPIwa4dtqAeDi + xs/K0DO0bsOOM1tJUqTKB0+Us9pvF/3ROxsbwQcsAHDB+Fl5d9e32UqS5qRBq/v10EOoCS86qwWASxLz + zHZnsfu56rVAkqR62+10op3VPrV3LfhQBQDCfrRyY/CZ2oDnjxbFddXrgSRJ9VU+ZCKd1S6N3t3cCj5Q + AYCw0xHPbEv/Ub0eSJJUT8NW99bAA6cRv3NWCwBXJOKZ7fj/fucXq9cESZKurhN7lory4fL65MOmCc5q + AeDqRDyzPbV9ww0fr14XJEm68gbt7oOBB03tLpzVbgYfoADApXl7Y3O0G+vbbNu9o9XrgiRJV5azWgCY + PTHPbMt3hS9Vrw2SJF1e271ev3yYRDmr/eknPxV8aAIAV+aJ1b3BZ27tWsULu5/Y68xWknT5bXeKh4MP + l5rd31sand3ybbUAUKe/bG6OvtXtB5+9dXNmK0m67GKd1Q5Lfzh0OPiwBACuzqmbDwSfv43odL5cvUZI + knTxThRFf7vdfTP4QKnZ02v7gg9JAKAe0c5s28WLd16/en31OiFJUrhRqXxoPDLxEGnEd/vLo786qwWA + Rp0/sy2Wgs/iujmzlSR9aM5qAWD+/ObAweDzuAmDTu8r1WuFJEl/37Fud7l8WDirBYA5FPPMdrfT2VO9 + XkiSdKHbFxauKR8Sj048NBpxX7HkrBYAIhuf2Y6fwaFnc+1a3XuqVwxJki407BS3BR8aNRt2eqOXnNUC + QBLjZ/DfPpebVD7zv1G9ZkiScm+42F8rHw6nJx8WTXBWCwBpRTyzfeV4u92qXjckSblWndU+OfGQaMQD + Pd9WCwCpndncHN1b9IPP6tp1evdWrxySpFyLdVa70ylGrx5eDz78AIC4fnvwUPB53QRntpKUccf29PaV + D4N3Jh8OTXh2303Bhx4AkMaTe9eCz+wGvLbTajmzlaTc2r1wVvvjiYdCIx5cWhmd2wo/8ACANN6N+G22 + w3ZxX/UKIknKpWhntaXX148EH3YAQFov+TZbSVIT7RTF/vLD31ktADB6KuKZ7Z2Li53qdUSSNK/FPKt9 + qL8yes+31QLAVDtbPqtjndmW7q9eSSRJ85qzWgBg0u+d2UqS6mi42NsoP+yd1QIA7xPxzPb1Y93ucvV6 + Ikmal44u3PKR8kP+mYkP/UY87KwWAGbO+Mz2O73l4LO9AY+OqncUSdKcNGgVdwQ+8Gs3Pqt9Y309+DAD + AKbby4cOBZ/vTRi2urdWrymSpFnvxGIxPqs9O/lh3wRntQAw2yKe2b51otNZrV5XJEmz2u6BA9dut7u/ + CHzQ1+7hJWe1ADDrLpzZxvk222G7eMyZrSTNeNHOajvF6I0jvq0WAObBy4cPn3+2h575dXNmK0kz3LDb + 3So/zKOc1f6/n3JWCwDzZPxsDz3zG/DW8Xbbma0kzVoPra1du93uRTmr/cHS6ujcVviBBQDMpvGz/YH+ + SvDZX7/uSWe2kjRjxTqrvavTG73lrBYA5tKr6+ujYfmsD70D1M2ZrSTNUNudzqfLD+8oZ7XP7785+JAC + AObD02v7gu8ADTh9V2tpb/U6I0ma1i6c1RbPTnyIN+LR5dXgwwkAmB/nSt+LdWbbKh6/fWHhmuq1RpI0 + jZUf2P/xvg/wBjirBYB8vBbxzHbQ7v5b9VojSZq2ht3u58sP63OTH95NcFYLAHmJeGb7znanc6B6vZEk + TUvH2+3rBu3iV4EP7tr90FktAGTnwpntcvDdoH69n55cWPhI9ZojSZqGBu3e0fCHdr3u7vZHf97YCD6M + AID59sfD66OdTvgdoW7DTnFb9ZojSUrdTqczPqsNfmDXzVktAOQt1pntoF2cKd9xnNlKUup2Fxc/Vn4w + /3ryg7oJJ1duDD58AIB8nNu6ZfTwUpxvsx22C2e2kpS6WGe1u53e6O2NzeDDBwDIyxtHjoxORPo2W2e2 + kpSwYaf3hdCHcxNOHTgYfOgAAHl6dt9NwXeGBpzZbvcPVa8/kqRYxTyr/c/VvcGHDQCQr/e2tkbfj3Rm + u90qfnZ04RZntpIUs2hntd3+6G3fVgsABLzpzFaS5rNhq/hi6MO4Cc5qAYCLiXlmu9Pqr1evQ5Kkpvrm + nj3js9pTEx/CjXjcWS0A8CHGZ7aPLK8G3yUa8HNntpLUcNud3iDwAVy7e7r90TvOagGAS/Dmerwz20Gn + +PfqtUiSVHc77eKfQx++TXBWCwBcjohntueOt/v/WL0eSZLqarffv6H8kH1p4kO3EU/c+MngwwQA4IO8 + V4p4ZvvcnaurH61ekyRJdVR+uN4z8WHbiPNntZubwYcJAMDF/OnIxuiuWGe2reKO6jVJknS1DdvFV0Mf + tk1wVgsAXI2YZ7Y7rd5nqtclSdKVdqzXi3ZW++TeteDDAwDgUo3PbB9buTH4rlG7VvHL3X7fma0kXU3l + B2qUs9p7i/7ozNZW8OEBAHA5/ryxMbq72w++c9TNma0kXUXDVvfroQ/XJvz24KHgQwMA4Eo8v//m4DtH + A86Vw/Oz1euTJOlS2ymKPeWH6MsTH6qNeMpZLQDQgGhntu3i+aNFcV31GiVJupTKD88oZ7XfHp/Vbjqr + BQDqd/r8ma1vs5WkqWu70/tG6MO0CS8e9G21AEBzYp7Z7ix2P1e9TkmSPqgTe5aKQbt4JfBBWjtntQBA + DD9a2Rt8F2nA89s33PDx6rVKkhSq/LB8YOLDsxHfLpZG7zqrBQAiOL2xOdqNdWbb7h2tXqskSZMNW91b + Qx+eTfidb6sFACKKeGY7/n+/80vV65Uk6b879g/9ovyQfP19H5oNcFYLAKRwMt632b7gzFaSJhq0uw8G + PjBrd9/5s9rN4IMAAKBJb4/PbDvObCUperHOaoclZ7UAQEr/N+KZ7WCx++XqdUuS8m271+tvt7tvhj4o + 6/b02r7ghz8AQExPrEb6NttW8cLuJ/Y6s5WUb6PSdqd4OPghWbP7e0ujs1u+rRYASO8vm5ujb3X7wXeW + ujmzlZR1Mc9q/3DocPBDHwAghVM3Hwi+tzRh2Ol/pXr9kqR8OlEU/fJD0FktAJCtaGe27eLFO69fvb56 + DZOk+e/8WW27eGTiw7AR3+0vj/7qrBYAmELnz2yLpeA7TN2c2UrKqmhntZ2es1oAYKr95sDB4HtMIzq9 + b1SvY5I0vw0W+2vlh56zWgCASqwz20G7eGW309lTvZZJ0vx1+8LCNYNO8V+hD8G6fbfnrBYAmA1nNjdH + 90Y6s91ude+pXs0kaf4adorbgh9+NRuf1b5yeD34oQ4AMI1eiHhmW74rObOVNH8NL5zVvjP5odcEZ7UA + wCyK+G22r+y0Wq3qNU2SZr/xWW354fbkxIddIx5wVgsAzKgz5TvMvUU/+I7TgPuqVzVJmv1indXudIrR + q85qAYAZ9tuDh4LvOU1wZitpLhoUxb7yQy3KWe2z+24KfngDAMySp/auBd91GvDanYuLneq1TZJmr90L + Z7U/nvhwa8SDSyujc1vhD24AgFny7ubm6L5Y32bbLu6vXt0kafaKdlZben39SPBDGwBgFr106HDwvacJ + zmwlzWQ7RbG//BBzVgsAcIVintkO9qw4s5U0O104q+3+JPCBVruH+iuj93xbLQAwh86W7zjf6S0H34Hq + NmgXD1SvcpI0/Q06xb+HPszqduGs1rfVAgDz6/cRz2wHrd6/Vq9zkjS9DRd7G+WH1tnJD7EmOKsFAHIQ + 8cz2rWG3u1y91knS9LV74MC1g3bxTOADrHYPL606qwUAshDzzLb02Kh6t5OkqWvQKu4IfHDVbnxW+4az + WgAgIy8fPjwaTrwTNWXY6t5avd5J0vQ06Ha3yg8pZ7UAAA2JeWZ7otNZrV7zJCl947Pa7Xb3F4EPrNr9 + wFktAJCp8ZntA/HObE86s5U0NcU6q72r0xu9dWQj+CEMAJCDVw+vj4blO1HoXaluzmwlTUXHu91Plx9K + Uc5qn99/c/DDFwAgJ0+v7Qu+KzXgrWGrtbd67ZOk+D20tnZt+WH07MSHUyN+sHxj8EMXACA350oP9FeC + 70x1G7R7jzuzlZSsuGe1R4IfugAAOXp13ZmtpDlvu9NxVgsAkFDEM9vTd7WWnNlKitedq6sfLT98opzV + Prq8GvyQBQDI3fjM9nv9SN9m2yr+a3dh4ZrqdVCSmq384PmP930QNWB8VvvnDd9WCwDwQV5bXx/tdMLv + UnUbdorbqtdBSWquYbf7+fJD59zkh1ATnNUCAHy4WGe2g3ZxZrvTOVC9FkpS/R1vt6/bbvd+FfoQqtsP + ndUCAFySqGe27d5PTy4sfKR6PZSkehu0e0fDHz71urvbd1YLAHAZ/njYma2kGW/Q6X8h9KHThF/tPxD8 + MAUA4IM986l4Z7bH2+1D1WuiJF19u4uLHys/YH49+YHThJMrNwY/RAEAuLj3trZG319aCb5j1a5V/MyZ + raTainVWu9vtj97e2Ax+iAIA8OHeOHJkdKLTC75r1c2ZraRaOt7u/VPoQ6YJpw4cDH54AgBw6Z7dd1Pw + XasBZ3Za/fXqtVGSLr9v7tkT7az2P1f3Bj80AQC4PDHPbAed4udHF25xZivpyop1VnvP+bNa31YLAFCX + N53ZSpr2hq3ii6EPlSY4qwUAqF/EM9uzg1bPma2kS2+4vHx9+eFxauLDpBGPO6sFAGjEe6VHlleD72AN + eObO1dWPVq+TknTxyg+NeyY+RBoxPqt9x1ktAEBj3lyPd2Y7aBV3VK+TkvTBDdrFV0MfIk1wVgsA0LyI + Z7bnttu9z1SvlZL0/nb7/RvKD4uXJj48GvHEjZ8MfigCAFCvyGe2zzmzlfSBlR8S8c5qNzeDH4oAANTv + T0c2Rnc5s5WUsvLD4WuhD40mOKsFAIjvuZv2B9/NGnBup+XMVtLfdKzXG5/VvjzxYdGIp/auBT8EAQBo + 3mMrNwbf0eo27BS/3O33ndlKulD5wRDlrPbeoj86s7kV/AAEAKB5pzc2Rnd3+8F3tbo5s5V0vmGr+/XQ + h0QTXjx4KPjhBwBAPM/vvzn4rtaAc9ut4rPVa6ekHNspij3lh4GzWgCAzMQ6sy09f7QorqtePyXlVvkh + EOWs9tvF0uhdZ7UAAFPjwpmtb7OV1GDDVvdfQh8KTXBWCwAwfWKe2Q5bxRer11BJOXRiz1JR/vK/PvFh + 0AhntQAA0+tH8c5sT23fcMPHq9dRSfNe+Uv/4MSHQCOc1QIATLfTG5uj3Vhntu3e0ep1VNI8N2x1bw19 + CDThd85qAQCmXsQz21H5Lvql6rVU0jx27B/6zmoBAHifk/HObF/Y/cReZ7bSvLbd6j0c+MWv3f298Vnt + ZvADDQCA6fP2xubonm4/+G5XN2e20pwW66x2WHr58OHghxkAANPr1IGDwfe7RnQ6X65eUyXNQ9u9Xn+7 + 3X0z+Atfs6fX9gU/xAAAmH5PrO4NvuM14MU7r1+9vnpdlTTLjUrbneKRwC967cZntWe3fFstAMCs+svm + 5uhbzmwlXU4xz2r/cMhZLQDArPtNxDPbYaf/leq1VdIsdqzbXS5/mZ3VAgBwWWKe2Q6Xl53ZSrPY+Kx2 + 2C4eDfxi1+67veXRX53VAgDMjfNntsVS8N2vdp3e4MIbrKSZatDu/lvwl7pmw05v9Mrh9eCHFQAAsyvu + mW3vG9VrrKRZaLDYXyt/eU9P/jI3wVktAMD8inVmO2gXrxxvt1vV66ykae72hYVryl/cJyd/kZvgrBYA + YL6d2dwc3VvE+TbbYad3b/VKK2maG3aK20K/xHVzVgsAkIffHjwUfB9sgjNbaco7tqe3r/xlfWfyl7cJ + zmoBAPIR8dtsX9lptZzZStPYbsSz2geXVpzVAgBk5Ez57ndfrG+zbRf3Va+4kqapWGe1O51i9Mf1I8EP + IwAA5tdLzmylfNspiv3lL2eUs9pn990U/BACAGD+PbV3LfiO2IDX7lxc7FSvu5JSVp3V/njil7QR47Pa + c1vhDyAAAObfu5ubMc9s769eeSWlLNpZbel1Z7UAANl76dDh4PtiE5zZSok73u06qwUAILqIZ7avD/as + OLOVUnR04ZaPbLe7Pwn8Ytbuof7K6D3fVgsAQOVs+W74nd5y8N2xAQ+MqndgSREbtIo7Ar+QtbtwVrse + /LABACBfv495Ztvq3lq9BkuK0YnFYqP85Ts7+cvYBGe1AAB8kIhntm8Nu93l6nVYUpPtHjhw7aBdPBP4 + Razdw0urzmoBAPhAF85so32b7WPObKUIxTyrfeOIb6sFAODiXj58eDSceJdsijNbqeEG3e5W+csW5az2 + uZv2Bz9UAABg0k8/+angO2UD3jrebq9Wr8eS6mx8Vrvd7v0i8ItXux+Mz2oDHyYAABByrvRAvG+zPenM + VmqgWGe1d3V6o7eObAQ/TAAA4IO8Oj6zLd8lQ++YdXNmK9Xc8W730+UvV5Sz2uf33xz8EAEAgA/z9Nq+ + 4DtmA04PW6291euypKvpobW1a8tfqmcnfska8ejyavDDAwAALsX4zPZ7/ZXgu2btWsXjty8sXFO9Nku6 + 0uKe1fq2WgAArs5r6+vObKVZadDtfq78ZXJWCwDATIl5Znu8291fvT5LupyOFsV1g3bxq8AvVu1+6KwW + AIAaXTizjfVttt2fnFxY+Ej1Gi3pUhu0e0fDv1T1urvbH/15w7fVAgBQrz8eXh/tdMLvoHUbdorbqtdo + SZfSTqfz+fKX59zkL1MTnNUCANCUWGe2g3ZxpnyHPlC9Tku6WMfb7eu22704Z7UrNwY/HAAAoA7ntm4Z + PRjpzHbYLn7qzFa6hGKd1e52es5qAQBo3PjM9kSsb7N1ZitdvGGn94XQL08TTh04GPxQAACAuj2776bg + O2kDzhxvtw9Vr9eS/rbdxcWPlb8kv574pWnESWe1AABE9N7W1uj7SyvBd9PatYqfObOVAkU7q+32R287 + qwUAILI3jxxxZiularvd+6fQL0sTnNUCAJBKzDPbnVZ/vXrdlvLum3v2jM9qT038kjTi8dW9wV9+AACI + IeaZ7aBT/Pzowi3ObKVYZ7X3dPujd5zVAgCQmDNbKWLb7d4/h345muCsFgCAaRHxzPbssNP/x+r1W8qr + 4fLy9eUvwUsTvxSNcFYLAMA0ea/0yPJq8N21Ac/dubr60eo1XMqn8of/nolfhkacP6vd3Az+sgMAQCp/ + OrIxuivSme2gVdxRvYZLeTRsF18N/TI0wVktAADTKuKZ7bntdu8z1eu4NN8d6/VuKH/oo5zVPuGsFgCA + KTY+s/3BUqQz21bxy91+35mt5r/yBz7KWe29RX/0F2e1AABMufGZ7d3dfvCdtm7ObDX3bbe6Xwv98Dfh + twcPBX+pAQBg2jy//+bgO20DzpXD87PV67k0X+0UxZ7yh/zliR/6Rjy1dy34ywwAANPqsZUbg++2dRt2 + nNlqTit/wKOc1X676I/ObG4Ff5EBAGBand4Yn9n6Nlvpihq0ul8P/bA34cWDvq0WAIDZFPPMdmex+7nq + dV2a7XY7HWe1AABwiX4U6cy29PzRoriuem2XZrfyhznSWe3S6F1ntQAAzLjxme1upDPb0n9Ur+3SbDZs + dW8N/GA34ne+rRYAgDkR8cx2/H+/84vV67s0W53Ys1SUP8SvT/5QN8FZLQAA8ybime2p7Rtu+Hj1Gi/N + ToN298HAD3Tt7jt/VrsZ/EUFAIBZ9fbGZrQz20G7d7R6jZdmI2e1AABw9WKe2Zbv8F+qXuel6W671+uX + P7RRzmp/+slPBX85AQBgXjyxujf4Lly7VvHC7if2OrPV9LfdKR4O/hDX7P7e0ujslm+rBQBgvv1lc3P0 + rW4/+E5cN2e2mvpindUOS384dDj4SwkAAPPm1M0Hgu/Fjeh0vly93kvT1Ymi6G+3u28Gf3Br9vTavuAv + IwAAzKtoZ7bt4sU7r1+9vnrNl6ajUan84Xxk4oe1Ed/tL4/+6qwWAIDMnD+zLZaC78h1c2arqctZLQAA + NO83Bw4G35ObMOj0vlK97ktpO9btLpc/lM5qAQAggphntrudzp7qtV9K0+0LC9eUP4yPTvxwNuK7PWe1 + AAAwPrO9N9KZ7Xare0/16i+ladgpbgv+cNZs2OmNXjm8HvylAwCA3LwQ8cy2fBf/RvX6L8VtuNhfK38I + T0/+UDbBWS0AAPy9iGe2rxxvt1vVDJDiVJ3VPjnxw9iIB5zVAgDA+5w5f2bbD75D167Tu7eaAlKcYp3V + 7nSK0avOagEAIOi3Bw8F36Ob4MxW0RoUxb7yh+6dyR/CJjy776bgLxcAAHDBk3vXgu/SDXhtp9VyZqtm + 271wVvvjiR++Rjy4tDI6txX+xQIAAC54d3NzdF+kb7Mdtov7qmkgNVO0s9rS6+tHgr9UAADA33vp0OHg + e3UTnNmqsXaKYn/5Q+asFgAAptBTEc9s71xc7FQzQaqnC2e13Z8EfuBq91B/ZfSeb6sFAIDLcrZ8h451 + Zlu6v5oKUj05qwUAgOn3e2e2msWGi72N8ofKWS0AAMyAiGe2rw+73eVqNkhX1tGFWz5S/jA9M/HD1YiH + ndUCAMBVG5/Zfqe3HHznbsCjo2o7SFfUoFXcEfjBqt34rPaN9fXgLw0AAHB5Xj50KPje3YRhq3trNR+k + y+vEYjE+qz07+UPVBGe1AABQr4hntm+d6HRWqxkhXVq7Bw5cu93u/iLwA1W7h5ec1QIAQN0unNnG+Tbb + Ybt4zJmtLqtYZ7V3dXqjN474tloAAGjCy4cPj79lNvguXjdntrrkht3uVvlDE+Ws9vn9Nwd/OQAAgHo8 + vbYv+C7egLeOt9vObHXxHlpbu3a73YtyVvuDpdXRe4FfCgAAoD7nSg/0V4Lv5PXrnnRmq4sW86z2LWe1 + AAAQxavr685slb7tTufT5Q+Js1oAAJhDEc9sT9/VWtpbzQzpQhfOaotnJ35YGvHo8mrwlwAAAGjO+Mz2 + e7HObFvF47cvLFxTzQ1pYaH8wfiP9/2gNMBZLQAApPNaxDPbQbv7b9XcUO4Nu93Plz8U5yZ/SJrgrBYA + ANKKeGb7znanc6CaHcq14+32dYN28avAD0jtfuisFgAAkrtwZrscfGevX++nJxcWPlLND+XYoN07Gv7h + qNfd3f7ozxsbwR96AAAgrj8eXh/tdMLv7nUbdorbqvmh3NrpdMZntcEfjLo5qwUAgOkS68x20C7OlNvD + mW1u7S4ufqz8Afj15A9EE06u3Bj8IQcAANI5t3XL6OGlON9mO2wXzmxzK9ZZ7W6nN3p7YzP4Qw4AAKT1 + xpEjoxORvs3WmW1GDTu9L4R+CJpw6sDB4A83AAAwHZ7dd1PwXb4BZ7bb/UPVLNG8FvOs9j9X9wZ/qAEA + gOnx3tbW6PuRzmy3W8XPji7c4sx2not2Vtvtj972bbUAADAT3nRmqzoatoovhv7Sm+CsFgAAZkvMM9ud + Vn+9mimal765Z8/4rPbUxF92Ix53VgsAADNnfGb7yPJq8B2/AT93ZjtnbXd6g8BfdO3u6fZH7zirBQCA + mfTmerwz20Gn+PdqrmjW22kX/xz6S26Cs1oAAJhtEc9szx1v9/+xmi2a1Xb7/RvKv8yXJv5yG/HEjZ8M + /tACAACz471SxDPb5+5cXf1oNV80i5V/ifdM/KU24vxZ7eZm8IcWAACYLX86sjG6K9aZbau4o5ovmrWG + 7eKrob/UJjirBQCA+RLzzHan1ftMNWM0Kx3r9aKd1T65dy34QwoAAMyu8ZntYys3BjdA7VrFL3f7fWe2 + s1T5FxflrPbeoj86s7UV/CEFAABm2583NkZ3d/vBLVA3Z7Yz1LDV/XroL7EJvz14KPjDCQAAzIfn998c + 3AINOFcOz89Ws0bT2k5R7Cn/sl6e+MtrxFPOagEAIAvRzmzbxfNHi+K6at5oGiv/kqKc1X57fFa76awW + AABycPr8ma1vs82+7U7vG6G/tCa8eNC31QIAQE5intnuLHY/V80cTUsn9iwVg3bxSuAvrHbOagEAIE8/ + Wtkb3AgNeH77hhs+Xs0dTUPlX8oDE39Jjfh2sTR611ktAABk6fTG5mg31pltu3e0mjtK3bDVvTX0l9SE + 3/m2WgAAyFrEM9vx//udX6pmj1J17B/6RfmX8fr7/nIa4KwWAAAYOxnv22xfcGabuEG7+2DgL6Z2950/ + q90M/sABAAB5eXt8ZttxZjv3xTqrHZac1QIAAH/r/0Y8sx0sdr9czSDFarvX62+3u2+G/kLq9vTavuAP + GQAAkLcnViN9m22reGH3E3ud2cZqVNruFI8E/zJqdn9vaXR2y7fVAgAA7/eXzc3Rt7r94JaomzPbiMU8 + q/3DocPBHy4AAICx3xw4GNwTTRh2+l+pZpGa6kRR9Ms/bGe1AADA1Ih2ZtsuXrzz+tXrq3mkJir/kKOc + 1X63vzz6q7NaAADgEpw/sy2Wgtuibs5sG2zY6v5L6A+9bsNOb/TK4fXgDxMAAEBI1DPbchtVM0l1NVjs + r5V/uK9P/mE3wVktAABwJSKe2b6+2+nsqeaSrrbbFxauGXSK/wr8Qdfuuz1ntQAAwJU5s7k5ujfSme12 + q3tPNZl0tQ07xW3BP+SaOasFAACu1gtRv822941qNulKG144q31n8g+3Cc5qAQCAOkQ8s31lp9VqVfNJ + l9v4rLb8Q3xy4g+1EQ/6tloAAKAmZ8ptcV+sM9t2cV81oXS5xTqr3ekUoz+uHwn+sAAAAFyJlw4eCu6P + JjizvYIGRbGv/MOLclb77L6bgj8kAAAAV+OpvWvBDdKA1+5cXOxUc0of1u6Fs9ofT/whNuLBpZXRua3w + DwgAAMDVeHdzM+aZ7f3VpNKHFe2stvS6s1oAAKBBLx06HNwjTXBmewkd73b3l39YzmoBAIC5EfPMdrBn + xZntB3XhrLb7k8AfXO0e6q+M3vNttQAAQARny+3xnd5ycJvUbdAuHqgmliYbdIp/D/2h1e3CWe168IcB + AACgCb+PeGY7aPX+tZpZ+u+Gi72N8g/n7OQfVhOc1QIAAClEPLN9a9jtLldzS7sHDlw7aBfPBP6gavfw + 0qqzWgAAIImYZ7alx0bV5sq+Qau4I/AHVLvxWe0bzmoBAICEXj58eDSc2CpNGba6t1azK98G3e5W+Yfh + rBYAAMhGzDPbE53OajW/8qv6ttpfBP5gavcDZ7UAAMCUGJ/ZPhDvzPbkeHtVMyyvysH5fwJ/ILW7q9Mb + vXVkI/iXDQAAkMKrh9dHw3KrhDZM/br/p5ph+XS82/30oF2cCf+B1Ov5/TcH/5IBAABSenptX3DD1G28 + vYat1t5qjs1/D62tXVv+iz87+QfRhB8s3xj8ywUAAEjtXOmB/kpwy9Rt0O49ns232cb6ttoLZ7VHgn+5 + AAAA0+DV9Xhntll8m+12p/Pp8l82yrfVOqsFAABmQawz29Lpu1pL83tme7Qoriv/JaOc1T66vBr8ywQA + AJg24zPb7/UjfZttq/ivuf0220G7dzT4L12z8Vntnzd8Wy0AADA7XltfH+10whunbsNOcVs10+anYbf7 + +fJf7tzkv2wTnNUCAACzKOa32e50OgequTb7HW+3r9tu934V+pet2w+d1QIAADMq6pltu/fTkwsLH6lm + 22wX66z27m7fWS0AADDT/njYme1lNej0vxD6l2vCr/YfCP6lAQAAzJJnPhXvzPZ4u32omm+z1+7i4sfK + f5FfT/6LNeHkyo3BvywAAIBZ897W1uj7SyvB7VO7VvGzmT2zjXVWu9vtj97e2Az+ZQEAAMyiN44cGZ3o + 9IIbqG4zeWa70+p9JvQv04RTBw4G/5IAAABm2bP7bgpuoAacGW+4as5Nf9/cs+dj263il4F/kdr95+re + 4F8OAADArIt8ZvvLowu3zMaZbayz2nvOn9X6tloAAGB+venM9u8btoovhv7hm+CsFgAAyEHEM9uzg1Zv + vZp309dwefn68h/y1MQ/dCMed1YLAABk4r3SI8urwW3UgGfuXF39aDXzpqvyH+6eiX/YRozPat9xVgsA + AGTkzfV4Z7aDVnFHNfOmp0G7+GroH7YJzmoBAIAcRTyzPbfdnqJvs93t928o/6FemviHbMQTN34y+IcP + AAAw7yKf2T43NWe25T9MlLPa3U5v9M7mZvAPHwAAIAd/OrJxfhuFNlPdpuLMtvyH+FroH64Jz920f/SX + cnRCTs5thT9sAIALzpVCz1CYZ+NtFNpMDTi300p4Znus1xuf1b488Q8F1Oilg4eCD1gA4ILx932EnqFA + PYad4pe7/X6aM9vyHyDKWS3kzOgEgIszOqF5Sc5sh63u10P/MEC9jE4AuDijE6I4t90qPlvNwea78/rV + 68v/Ume1EIHRCQAXZ3RCNM+Pt2A1C5utXLjHAv8AQAOMTgC4OKMTIiq3YDULm2vY6v5L8L8caITRCQAX + Z3RCXINW8cVqHtbfiT1LRflf8vrkfynQHKMTAC7O6IToTm3fcMPHq5lYb4N298HAfyHQIKMTAC7O6IT4 + Bu3e0Wom1tew1b019F8GNMvoBICLMzohjXIjfqmai1ffdq/XL/9DndVCAkYnAFyc0QmJtIoXdj+xt54z + 2+1O8XDwvwRonNEJABdndEI6tZzZOquFtIxOALg4oxPSGnb6X6nm4+V3oijGZ7VvTv6HAvEYnQBwcUYn + JPfindevXl/NyEtvVCr/lx+Z+A8DIjM6AeDijE5I74rObAft7r+F/sOAuIxOALg4oxOmRKf3jWpOfniD + xf5a+b90+n3/IUB0RicAXJzRCdNh0C5eOd5ut6pZ+cHdvrBwzaBT/FfoPwSIz+gEgIszOmF6DDu9e6tp + +cENO8Vtof9lIA2jEwAuzuiE6VIOzw8+sz22p7ev/B96Z/J/CUjH6ASAizM6Yeq8stNqvf/Mdndh4Zry + //DJif9hIDGjEwAuzuiE6TNsF/dVU/N/c1YL08noBICLMzphOv3dme3xdnu1/P/orBamkNEJABdndMLU + em28Nc+PzvE31u4eOHAtcOXKX6pfT/yS1cLoBICLa2x0toqfhZ75wKUbb83zo1PS1bfd7v0q+MC6SkYn + AFxck6OzesxLkpQ+oxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRF + RicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJ + AGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAa + RqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEp + ScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKy + yOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6 + ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBI + w+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6 + JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklS + FhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVG + JwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkA + aRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpG + pyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJ + yiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI + 6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoB + IA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD + 6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDol + SVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIW + GZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYn + AKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBp + GJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkan + JCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnK + IqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjo + BIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEg + DaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPo + lCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJ + WWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZ + nQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicA + pGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkY + nZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqck + KYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoi + oxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgE + gDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASAN + o1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iU + JGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZ + ZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmd + AJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCk + YXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRid + kqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQp + i4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKj + EwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASA + NIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2j + U5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQk + ZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlk + dAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0A + kIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRh + dEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2S + pCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmL + jE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMT + ANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0 + jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNT + kpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRl + kdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0 + AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQ + htEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0 + SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKk + LDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuM + TgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA + 0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSM + TklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OS + lEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR + 0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQC + QBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG + 0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRK + krLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQs + MjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xO + AEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDS + MDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxO + SVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KU + RUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHR + CQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJA + GkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbR + KUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqS + ssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwy + OgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4A + SMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIw + OiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5J + UhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRF + RicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJ + AGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAa + RqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEp + ScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKy + yOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6 + ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBI + w+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6 + JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklS + FhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVG + JwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkA + aRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpG + pyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJ + yiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI + 6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoB + IA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD + 6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDol + SVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIW + GZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYn + AKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBp + GJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkan + JCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnK + IqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjo + BIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEg + DaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPo + lCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJ + WWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZ + nQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicA + pGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkY + nZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqck + KYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoi + oxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgE + gDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASAN + o1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iU + JGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZ + ZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmd + AJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCk + YXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRid + kqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQp + i4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKj + EwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASA + NIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2j + U5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQk + ZZHRCQBpGJ2SpCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlk + dAJAGkanJCmLjE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0A + kIbRKUnKIqMTANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRh + dEqSssjoBIA0jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2S + pCwyOgEgDaNTkpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmL + jE4ASMPolCRlkdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMT + ANIwOiVJWWR0AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0 + jE5JUhYZnQCQhtEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOgEgDaNT + kpRFRicApGF0SpKyyOgEgDSMTklSFhmdAJCG0SlJyiKjEwDSMDolSVlkdAJAGkanJCmLjE4ASMPolCRl + kdEJAGkYnZKkLDI6ASANo1OSlEVGJwCkYXRKkrLI6ASANIxOSVIWGZ0AkIbRKUnKIqMTANIwOiVJWWR0 + AkAaRqckKYuMTgBIw+iUJGWR0QkAaRidkqQsMjoBIA2jU5KURUYnAKRhdEqSssjoBIA0jE5JUhYZnQCQ + htEpScoioxMA0jA6JUlZZHQCQBpGpyQpi4xOAEjD6JQkZZHRCQBpGJ2SpCwyOuH/334dm1gBBUAU3S78 + 8GGxFiMLsMStQCOr0w0MNZLlPt6cC6eGYQAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKn + EwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqck + aSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAa + TqckaSKnEwAaTqckaSKnEwAaTqckaSKnEwAaTqckaaKPOp0/nq+/fr5+BgD+4fv7Vv5tQ/+b0ylJOqmP + Op0AQMTplCSdlNMJAJdxOiVJJ+V0AsBlnE5J0kk5nQBwGadTknRSTicAXMbplCSdlNMJAJdxOiVJJ+V0 + AsBlnE5J0kk5nQBwGadTknRSTicAXMbplCSdlNMJAJdxOiVJJ+V0AsBlnE5J0kk5nQBwGadTknRSTicA + XMbplCSdlNMJAJdxOiVJJ+V0AsBlnE5J0kk5nQBwGadTknRSTicAXMbplCSdlNMJAJdxOiVJJ+V0AsBl + nE5J0kk5nQBwGadTknRSTicAXMbplCSd1Nvj8fXt8fwGAFzi0/PLn5mXJEmSJEnSeb28/AYZhGxcmodj + rQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAA50AAAeOCAYAAAB3IVJsAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + wwAADsMBx2+oZAAAgjRJREFUeF7s3F+MZQWZ7/0KIYYYQ5Dp3n/W3lVdtG3T9J/qqsJMjDHGTIwxZmIm + Ey8n55LLuSTnzswll3PZF4bQu3Y1FiIiAiI6DEyIGiMTX0OMIRyDioiIDSK00Db73dWsmXF2LxvoXms9 + u/bz+Safq/e8R4WqtdYv50ktSZIkSZIkaY7b6g7+bqs3+CIAsCh6nytf85IkxbfVKX601S0mAMCiGDxb + vuYlSYrP6ASARWN0SpLmKKMTABaN0SlJmqOMTgBYNEanJGmOMjoBYNEYnZKkOcroBIBFY3RKkuYooxMA + Fo3RKUmao4xOAFg0RqckaY4yOgFg0RidkqQ5yugEgEVjdEqS5iijEwAWjdEpSZqjjE4AWDRGpyRpjjI6 + AWDRGJ2SpDnK6ASARWN0SpLmKKMTABaN0SlJmqOMTgBYNEanJGmOMjoBYNEYnZKkOcroBIBFY3RKkuYo + oxMAFo3RKUmao4xOAFg0RqckaY4yOgFg0RidkqQ5qqnR+Y3ByuSRlVUA4K94YPqurHqHXj2jU5I0RzU1 + Op87emwyufVWAOCveOHY8cp36NUzOiVJc5TRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJk + dAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAx + jE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgEgBhGpyQpRUYnAMQwOiVJ + KTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhidkqQUGZ0AEMPolCSlyOgE + gBhGpyQpRUYnAMQwOiVJKTI6ASCG0SlJSpHRCQAxjE5JUoqMTgCIYXRKklJkdAJADKNTkpQioxMAYhid + kqQUGZ0AEMPolPZAX1paumbn6NEPAFfO6ASAGM2NzuLnVe984L3b3ZoXR+fpbnd1+kv18swvGTAHjE4A + uLwGRydwdc7tbs2Lo3O3cW/wxYr/Q0AwoxMALs/ohPk07hW3l3Pzfxp3i/uq/g8DcYxOALg8oxPm0pM7 + /3Va+5dtdzqd6f/Hl2b+DwOBjE4AuDyjE+bOubv2DQ6XM/PSnNnCfDE6AeDyjE6YL5VntbNNh+e9Vf8/ + A+0zOgHg8oxOmB+jXvEf//0Xay/X6W63M3JmC3PB6ASAyzM6YW68Pto/PFTOyndvy5ktzAWjEwAuz+iE + +TDq9v+5nJPvvVF3cKrq/zKgPUYnAFye0Qlz4ZFJuSPfV3fesHrD9P/n52f+LwNaZHQCwOUZnRDu1TNF + MSxn5Ptv3Bt+vuL/UqAlRicAXJ7RCbHGnf5t5Xy88pzZQhyjEwAuz+iEQL3i4XI2Xl07Hz54/Van+GXl + fwjQKKMTAC7P6IQwZ7cGgys/q51t3Ol/tuI/BGiY0QkAl2d0Qoxazmpnc2YL7TM6AeDyjE5o36jbf7Cc + ifW2deON10//A56b/Q8EmmN0AsDlGZ3QurNn9i0X5Uysv1Gn+EzFfyjQEKMTAC7P6IR2jTv9fyrnYXNt + dYq7qv7DgfoZnQBweUYntGi6BctZ2Gx33rB6w/Q/8JlL/gsAtTM6AeDyjE5ozYu7W7Cchc03XbifmP6H + Xpj5LwHUzOgEgMszOqEd407/H8s52F6jTnFH1X8ZoD5GJwBcntEJrbinnIHttjMcXjfuFT+r+C8E1MTo + BIDLMzqhcS/eNRjcWM7A9tvuDD4+/S/RypntT28+MvnTxgakcqHi5QoA/I8Lm7dWvkNhke1uo6rN1IRR + p/iHcv7F1daZ7U5vMPnDyfXKhw0AAEAG56ajc3cbVW2mBsSc1c525+rqddP/Mj+d+S/XiEdWVidvV/yD + BwAAyOCJmz5SuZUa8MLOcBh3VjvbVre9M9unD99c+Q8fAABgke3+vY+qjdSEUbf4Qjn35qe2zmzP9AaT + V9dOVv5LAAAAWETn1tcn9/SHlRupAfNxVjtbeWb745n/so1wZgsAAGTy+OrBym3UgOfGKys3lDNv/hp1 + BmvT/5LnZ/5LN8KZLQAAkEGbZ7XjTvGZct7Nb+NecXvVf/m6XTyzPenMFgAAWFxvtHhWO+oOTpWzbr47 + tXTrtVud4mdV/yPq9q3lA5O3Nzcr/+UAAADsdf/e1lntdMN9ed++D5Wzbv7b7lz8a7ZvXvI/pAHObAEA + gEXU5lnt7oYr59zeqc0z21ec2QIAAAvkjfWNyY6z2sv32NLS7pntj6r+R9XNmS0AALBIHjtwU+X2acDP + d/bv3ztntbOd7naPj1o6s/3xRw9X/ssCAADYS549crRy8zRh1Bt+upxve7e2zmy3e8Xk9yfWKv+lAQAA + 7AV/XF+ffMVZ7fvr4pltd/DDqv+RdfvmcGVyoeJfHAAAwF7wnZXVyq1Tv8Gzp7vdD5azbe+33esdbevM + 9qlDzmwBAIC955kjt1RunAZcGPf7nyrn2uLU5pnty2vObAEAgL1j96z27t6gcuPUbWHOamfbWVq6ZqtT + /EfV/+i6ObMFAAD2kkdbO6stnj5VFItzVjvb3Z3lg9P/ka/P/I9uhDNbAABgL2jxrPb8Vq/3sXKeLW7j + Tv+2iv/xtRv3BpPfObMFAADm2GsnT7Z3Vtsp7ihn2WI3mRp1B49X/UOo2wPDA85sAQCAufXtlZsqt0wD + nn7o0KEPvLPKEjTudA76a7YAAEBmbZ3V7m6v0/3+4p/VzrbV7f/fqn8gdbt4ZnvCmS0AADA/XjvZ3l+r + 3d1e5QzL1cW/ZtstHrv0H0j9HhisTM5vblb+ywYAAGjT29Nt8u3ltv5abf8nu9urnGH5OtPrrU7/Qbx2 + 6T+Y+n3/4KHKf+EAAABtevrwzZWbpQHnR/3+Zjm/8tbaX7OdevHEicp/6QAAAG14ZW1tsj2zVZqS5q/V + vlu7f812+g/ku7P/gJrwdWe2AABAkN2z2odbOqsddYsf7xw9muev1b5b435/ZfoPxpktAACwsNo8qx3v + H6yXc0v/1agz+D8V/7Aa8ZvjzmwBAID2nG3zrLZX/Es5szTbqFs8UPUPrW7ObAEAgLbsntU+NDxQuU3q + 1/9B6r9W+26N9h3oTf9BvXzpP7j6ObMFAADa0OJZ7bnT/f6Rcl7przXuDb5Y8Q+vES84swUAABp0du1k + a2e1415xezmr9G5N/4HdP/sPsAn3FcuTtzY2Kn84AAAArsaFzVsnDy63dVZbfM9Z7fvozv37ndkCAAB7 + WptntaOiOFzOKb3XWj2zPXa88ocEAADgSvx+96y2V70/6uas9iqa/gO8b/YfaBN2z2zf9NdsAQCAGvx5 + ui0eHK5Ubo8GPPklZ7VX3nan05n+Q3xp5h9qI55YPVj5AwMAAPB+PHXocOXmaMC58f7hoXI+6Upr88z2 + l0ePVf7QAAAAvBcvnVibTDdM5d6om7PaGtvq9O+p+odct3t3z2z9NVsAAOAK7J7VfmPQzlntqFf8h7Pa + Gtvp9fZN/8Genf0H3QRntgAAwJVo8az27MhZbf2NO/1/qviH3YhfOLMFAADeh1bPaqfbqJxJqrtRd3Cq + 6h963b5aLE/+5MwWAAB4Dy6e1bb312ofKeeRmujOG1ZvmP5Dfn7mH3ojnNkCAADvRYtnta+eKYphOY/U + VOPe8PMV//Ab4cwWAAC4nN8ePzEZV2yJJow7/dvKWaSma+3Mtj90ZgsAAFQ6v7k5uX+wXLklatcrHpmU + e0gttPPhg9dvdYpfVv7LqJkzWwAAoEp7Z7X9V7cGA2e1bTfa3/9c9b+Q+v2/I7dU/pABAAA5/frYcWe1 + GWrrzHanN5i8se7MFgAAuHXy1sbG5L6inbPaUbf/YDl/FNHWjTdeP/0X0cqZ7WMHbqr8gQMAAHL5/sFD + lZuhAWfv+pthUc4fRbXVKT5b8S+nEc84swUAgNR2z2qrtkITnNXOUa2d2fYHk9ed2QIAQEpvbWxOvtbS + We3UA+Xc0TxUntk+M/MvqRH/dsBfswUAgIzaOqsddYuXzuxbdlY7b23v739y+i/owuy/sCY4swUAgFye + P3aschs0ojf4YjlzNG+NOsUdlf/SavaVi2e265U/jAAAwGJ58+JZ7bByGzTgnnLeaB47VRQfnP5LauXM + 9rv+mi0AAKTQ4l+rfXG7KPaV80bz2qhTfGL6L8uZLQAAcNV+1e5fq/3HctZo3mvvzHY4+aMzWwAAWEhv + bm5O7nVWq6p2hsPrtjrFzyr+RdZu98z27YofUAAAYG97sr2z2hfuGgxuLOeM9krbncHHp//yWjmzffrw + zZU/pAAAwN703NH2/lrtuFt8oZwx2mu1dWZ7d28w+cNJZ7YAALAIzm1sTO7pO6vVe+jO1dXrpv8Sfzrz + L7URj6ysOrMFAIAF8MRNH6n85m/ACzvDobPavd7p7vBvp/8yndkCAADvqs2z2u1u8fflbNFeb9Qr/qXq + X3LdzvQGk1fXTlb+8AIAAPPt3Pp6e2e1vcGonCtahE4t3Xrt9F/sf17yL7oBF89sNzcrf4gBAID59fjq + wcpv/AY89+V9+z5UzhUtStud4dr0X+6bM/+yG+HMFgAA9pZW/1ptp/hMOVO0aI17xe1V/9LrdvHM9qQz + WwAA2AveWF+f7LR0VjvqDk6V80SL2MUz207xo6p/+XX71vIBZ7YAALAH/Ht7Z7U/39m/31ntorfVHR6f + /st2ZgsAALR7VtsbfLqcJVr02jyzfcWZLQAAzKU31jcmO9Nv9qpv+bo5q03WY0tL1467xQ+rfhjq9vDy + gcmFzeofcgAAIM5jB26q/IZvgLPajG33ekdHLZ3ZPnXocOUPOQAAEOOZI7dUfrs3Ybo9PlXOEGWrrTPb + 7V4x+f2JtcofdgAAoF1/XF+ffMVfq1Ub7Z7ZbnUHrZzZfnO4MrlQ8QMPAAC06zsrq5Xf7HUbdYtnT3e7 + Hyznh7K21esdnf5AnJv9AWmCM1sAAIjV4lnthXG/76xW7zTq9v+54oekduPeYPLymjNbAACI8NrJk5O7 + W/prtVP/Ws4NaWnpS0tL12x1iscrflBq983hAWe2AAAQ4NGWzmqnnn7o0KEPlHNDeqe7O8sHpz8cr8/8 + sDTCmS0AALSrxbPa81u93sfKmSH978ad/m0VPzS12z2z/Z0zWwAAaEWbZ7WjTnFHOS+kS5tMbXX7j1X9 + 8NTtAWe2AADQuLenvr3c1lnt4CfOavWune52V6c/MK9d+gNUP2e2AADQrDbPasf9/mY5K6TL1+aZ7Ysn + TlT+cgAAAFfnFWe1mtd2z2zH3eK7VT9Mdfv6YHlyfnOz8pcEAAC4Mm9Pv7EfXj5Q+Q1ev/5Pdo4edVar + 99eZXq+1M9vvHzxU+YsCAABcmacP31z57d2A82f2F+vljJDeX22d2e568fjxyl8WAADg/XllbW2yXfHN + 3QRntbqq3vlrtsWjsz9YTfj6YMWZLQAAXKWLZ7XDts5qix+fWrr12nfWg3SFjfv9lekP09mZH65GOLMF + AICr0+JZ7bnx/oGzWtXTuDf4YsUPWSN+c9xfswUAgCtxdu1ka2e1415xezkXpHqa/mDdP/uD1oT7Cn/N + FgAA3q/ds9qHWjur7f9gZ2npmnIqSPV05/79vekP2MuX/sDVz5ktAAC8P22e1W4XxZFyJkj11uaZ7QvO + bAEA4D1xVquFatwt7qv64avb7pntWxsblb9UAADAOy5s3jp5cLm1v1b7PWe1arztTqcz/WFr5cz2SWe2 + AABwWW2e1Y6K4nA5C6Rma/PM9lfHjlf+cgEAQHa/O7E22e5Vf0fXzVmtWm+rN7i36oexbvcWw8mbzmwB + AOB/+fPm5uSBwUrlN3QDnvySs1q13elud/fM9qWZH8ZGPLF6sPIXDQAAsnrq0OHKb+cGvD7ePzxUzgCp + 3do8s/3l0WOVv2wAAJDNSyfWJtNv8crv5ro5q1V4W53+PVU/nHW7t1ie/MmZLQAAye2e1X6jvbPaR53V + KrydXm/f9Ifx+ZkfzkY4swUAILsWz2pfvavfXyk/+6XYRr3B5yt+SBvxC2e2AAAk9dvjJybjim/kJow7 + /dvKz31pPhp1B6eqfljr9lVntgAAJHTxrHbY2lntI5PyO1+am+68YfWG6Q+nM1sAAGhAe2e1/VfPFMWw + /MyX5qutXu9z1T+49XvulqOVv4wAALBonNVKf1FrZ7b9oTNbAAAW3vnNzcn9g+XKb+La9YqHy896aX7b + +fDB67c6xS8rf4hr5swWAIBF98OPfLTyW7gBZ7cGA2e12huNO/3PVvwQN+KZI7dU/nICAMBe9+tjxyu/ + gZvgrFZ7rrbObHf6g8kb685sAQBYLG9tbEzuK9o5qx11+w+Wn/HS3mnrxhuvn/4APzf7A92EfztwU+Uv + KgAA7FXfP3io8tu3AWfP7Fsuys94aW816hSfqfihboQzWwAAFoWzWul9NP1B/tfZH+wm7J7Zvr6+XvlL + CwAAe8VbG5uTr7V0Vjt1T/nZLu3dThXFB6c/zM/M/HA3wpktAAB7XYtntS/u9Hr7ys92aW+3vb//yekP + 9YWZH/JGOLMFAGCvev7Yscpv3CaMOv1/LD/XpcVo1CnuqPphr9tXnNkCALAHvXnxrHZY+Y3bAGe1Wrx2 + hsPrxr3iZxU/8LX7rjNbAAD2mDbPareLwlmtFrNRp/jE9IfcmS0AAPyFX7X412q3Ov1/KD/PpcWsvTPb + 4eQPJ53ZAgAw3/60sTG511mtVF+7Z7ZbnXbObL+9vDp5u+IXGwAA5sUTqwcrv2Ub8MJdg8GN5We5tNht + dQcfn/7Qt3Jm+/Thmyt/uQEAINpzR9v7a7XjbvGF8nNcylFbZ7Z39wbObAEAmDvnNjYm9/Sd1UqNdefq + 6nXTH/6fzvwyNOKRFWe2AADMl8dbPKsdr6zcUH6GS7ka94Z/O/0lOD/zS9EIZ7YAAMyLNs9qt7qDvy8/ + v6WcjXvF7dW/HPU60xtMXj15svKXHgAA2nJufb21s9pRd3Cq/OyW8nZq6dZrR73iP6t+Ser2reUDk7c3 + Nyt/+QEAoA0tntU+9+V9+z5UfnZLudvuDNemvxRvzvySNMKZLQAAUVo+q/278nNb0m7ObAEAWGRvrK9P + dpzVSnE9trR07Van+FHVL03dnNkCANC2xw7cVPlt2oCf7+zf76xWqup0t3t8+kvizBYAgIXS5lntuDf4 + dPl5LamqNs9sf39irfKhAAAAdfnj7lnt9Nuz6pu0bs5qpffQ7pntuFv8sOqXqG4PDlcmFzarHw4AAFCH + 77R2Vjt49nS3+8Hys1rS5dru9Y6OWjqzferQ4cqHAwAAXK1njtxS+Q3agAvTb+hPlZ/Tkt5LbZ3ZbvcK + Z7YAANRu96z2K/5arTS/Xfxrtt3+D6p+qer2zd0z24oHBQAAXKnvrKxWfnvWbdQtnj1VFM5qpSvpdL9/ + ZPqL9PrsL1YTnNkCAFCXFs9qz4/6/U+Wn8+SrqRxp39bxS9X7ca9weTlNWe2AABcnddOnpzc3dZfq+0U + d5SfzZKutC8tLV2z1Sker/olq9s3hwec2QIAcFUebemsdurphw4d+kD52Szpahp3Ogenv1TObAEAmGtt + ntWe7vc/Vn4uS6qjNs9sf3fiROVDBAAA/prXTq47q5X2cpOp6S/YY7O/cE14YOCv2QIA8N69PfXt5bbO + agc/2Tl61Fmt1ESnu93V6S/aa5f+4tXvhx/5aOUDBQAAZv305iOV35QN2P1rtZvl57GkJmrtzHbqRWe2 + AAC8i1dOnpxsz3xLNsVZrdRC5Zntd2d/AZvw9cHy5PzmZuXDBQAA3p5+Kz7c0lntqFv82Fmt1FLjfn9l + +ovXypnt9w8eqnzAAADA04dvrvyGbMD5M/uL9fJzWFIbtXVmu+s3x53ZAgDwv51dW3NWKy1y5ZntA7O/ + kE34+mDFmS0AAP9t96z2oeGBym/H+vV/cGrp1mvf+QqW1GqjfQd601/Es5f+YtbPmS0AAP+lxbPac6f7 + /SPl56+kiMa9wRcrfjkb8YIzWwCA9M6utffXase94vbys1dSZNNfyPtnf0GbcF+xPHlrY6Py4QMAwOK7 + sHnr5MHlts5qi+/tLC1dU37ySorszv37d89sX575JW2EM1sAgLzaPKvdLgpntdI81eqZ7bHjlQ8hAAAW + 1+93z2p71d+HdXNWK81p01/Q+2Z/YZuwe2b7pr9mCwCQxp+n334tntU+6axWmtO2O53O9Jf0pZlf2kY8 + sXqw8oEEAMDieerQ4cpvwgacu2vf4HD5eStpHmvzzPZXzmwBABbeSyfWJtNvzMrvwbo5q5X2SNOHwr1V + v8R1u7cYTt7012wBABbW7lntNwYrld+CDXjyS85qpb3R6W63M3JmCwDAVWrxrPb10f7hofJzVtJeqM0z + 218cPVb5kAIAYO9q86x21O3/c/kZK2kvtdUbjKp+qev21WJ58idntgAAC6PNs9pxt3h0Un6/StpjjVdW + bpj+Ij8/+4vdBGe2AACLo8Wz2lfv6vdXys9XSXuxcW/4+Ypf7kY4swUA2Pt+e/zE7v/rY+X3Xt3Gnf5t + 5WerpL3cqDs4VfVLXrev9ofObAEA9rDzm5uT+wfLld96tesVjzirlRakO29YdWYLAMC7au+stv/q1mAw + LD9XJS1CW73e56p/4ev3nDNbAIA958UTzmolXWVtndne0x9O3lh3ZgsAsFe8tbHR3lltZ/Bw+XkqadHa + +fDB66e/6L+85Be/AY8duKnygQYAwPz5/sFDld90DTh7198Mi/LzVNIiNu70P1vxy9+IZ47cUvlQAwBg + fvz62PHKb7kmOKuVktTWme1OfzB53ZktAMDcemtjc/K1oqWz2m7xYPk5KmnR27rxxt0z2+dmHgKN+Ddn + tgAAc6vNs9oz+5ad1UqZGneKz0x/+S/MPAwa4cwWAGD+PN/uWe0/lZ+hkjI16hR3VD0U6vaVi2e265UP + OwAA2tfyWe095eenpGydKooPTh8Cz8w8FBrxXWe2AABzo8Wz2he3i2Jf+fkpKWNbneIT04eBM1sAgCRa + Pqv9x/KzU1Lm2juzHTqzBQAI9ObG5uTeYlj5rdYAZ7WS3mlnOLxu3Ct+VvGgqJ0zWwCAOG2e1d41GNxY + fm5K0tLSdmfw8enDoZUz25/efKTyIQgAQHOeO3qs8tusCaNO8Q/lZ6Yk/U9tndne3RtM/nDSmS0AQFvO + bWxM7uk7q5UU3J2rq9dNHxI/nXloNOKRldXJ2xUPRAAA6vfETR+p/CZrwAs7w6GzWkl/va1ue2e2Tx++ + ufKhCABAfVo9q+0WXyg/KyXpr9fWme2Z3mDy6trJyocjAABX79z6urNaSfNXeWb745mHSCOc2QIANOfx + 1YOV32ANeG68snJD+TkpSe/eqDNYmz48zs88TBrhzBYAoH5tntWOO8Vnys9ISXrvjXvF7VUPlbpdPLM9 + 6cwWAKAub7R4VjvqDk6Vn4+S9P46tXTrtaNe8Z9VD5e6fWv5wOTtzc3KhyYAAO/Pv7d3VvvzL+/b96Hy + 81GS3n/bneHume2bMw+XRjizBQC4em2e1Z7uDv6u/GyUpCuvzTPbV5zZAgBcsTfWNyY7zmol7bUeW1q6 + dqtT/KjqYVM3Z7YAAFfusQM3VX5jNeDnO/v3O6uVVF+nu93jo5bObH/80cOVD1EAAP66Z48crfy2asKo + N/x0+ZkoSfXV1pntdq+Y/P7EWuXDFACAS/1xfX3yFWe1kvZ6F89su4MfVj186vbN4crkQsUDFQCAS31n + ZbXym6p+g2dPd7sfLD8PJan+tnq9o22d2T51yJktAMC7eebILZXfUg24MO73P1V+FkpSc7V5ZvvymjNb + AIC/Zves9u7eoPJbqgH/Wn4OSlKz7SwtXbPVKf6j4kFUO2e2AAB/3aOtndUWT9+5unpd+TkoSc13d2f5 + 4PTh8/rMw6gRzmwBAC7V4lnt+a1e72PlZ6Aktde407+t4qFUu3FvMPmdM1sAgP/22smTrZ3VjjrFHeXn + nyS122Rq1B08XvVwqtsDwwPObAEASt9euanym6kBTz906NAH3vn6k6SAxp3O7pntazMPp0Y4swUAaPes + 9nS/76xWUnytntmecGYLAOT12sn2/lqts1pJc9Pume30wfTY7IOqCQ8MVibnNzcrH8IAAIvs7ek30LeX + 2/prtf2f7Bw96qxW0vx0ptdbnT6gWjmz/f7BQ5UPYgCARfb04Zsrv40acH7U72+Wn3mSND+1dmY79eKJ + E5UPYwCARfTK2tpke+abqCnOaiXNbeWZ7XdnH1xN+LozWwAgid2z2odbOqsddYsfO6uVNNeN+/2V6QPL + mS0AQE3aPKsd7x+sl591kjS/jTqD/1PxEGvEb447swUAFtfZNs9qe8W/lJ9zkjT/jbrFA1UPs7o5swUA + FtXuWe1DwwOV30D16/9gZ2npmvJTTpLmv9G+A73pA+zlSx9o9XNmCwAsohbPas9tF8WR8jNOkvZO497g + ixUPtUa84MwWAFggZ9dOtnZWO+4Vt5efb5K095o+yO6ffbA14b5iefLWxkblQxsAYC+5sHnr5MHlts5q + i+85q5W0p7tz/35ntgAA70ObZ7WjojhcfrZJ0t6tzTPbXx07XvnwBgDYC353Ym2y3av+zqmbs1pJC9X0 + wXbf7IOuCfcWw8mb/potALAH/Xn6DfPAYKXyG6cBT37JWa2kRWq70+lMH24vzTzsGvHE6sHKBzkAwDx7 + 6tDhym+bBpwb7x8eKj/TJGlxavPM9pdHj1U+zAEA5tFLJ9Ym02+lyu+aujmrlbTQbXX691Q9/Op2b7E8 + edNfswUA9oDds9pvtHRWO+oV/+GsVtJCt9Pr7Rs5swUA+G8tntW+OnJWKylDWy2e2f7CmS0AMMd+e/xE + e2e1nf5t5eeYJC1+o+7gVNXDsG5fLZYnf3JmCwDMoYtntcPW/lrtI5PyO0ySUnTnDas3TB9+z888DBvh + zBYAmEdtntWeKYph+RkmSXka94afr3goNuK5W45WPuwBACJcPKut+GZpgrNaSalr7cy2P3RmCwDMhfOb + m5P7B8uV3yy16xUPO6uVlLqdDx+8fqtT/LLyIVkzZ7YAwDxo76y2/+rWYOCsVpJG+/ufq35Q1u//Hbml + 8uEPANCGXx877qxWkiJq68x2pzeYvLHuzBYAaN9bGxuT+4p2zmpH3f6D5WeWJGm3rRtvvH76gGzlzPax + AzdVvggAAJr0/YOHKr9NGnD2rr8ZFuVnliTpv9rqFJ+teGg24hlntgBAi3bPaqu+SZrgrFaSLlNrZ7b9 + weR1Z7YAQAve2ticfK2ls9qpB8rPKklSVeWZ7TMzD89G/NsBf80WAGheW2e1o27x0pl9y85qJend2t7f + /+T0wXlh9kHaBGe2AECTnj92rPIbpBG9wRfLzylJ0rs16hR3VD5Ma/aVi2e265UvCQCAq/HmxbPaYeU3 + SAPuKT+jJEnvpVNF8cHpw7OVM9vv+mu2AEADWvxrtS9uF8W+8jNKkvReG3WKT0wfos5sAYA951ft/rXa + fyw/nyRJ77f2zmyHkz86swUAavDm5ubkXme1krQ32hkOr9vqFD+reMDWbvfM9u2KFwcAwPvxZHtntS/c + NRjcWH42SZKutO3O4OPTh2orZ7ZPH7658uUBAPBePHe0vb9WO+4WXyg/lyRJV1tbZ7Z39waTP5x0ZgsA + vH/nNjYm9/Sd1UrSnuzO1dXrpg/Xn848bBvxyMqqM1sA4H174qaPVH5bNOCFneHQWa0k1d3p7vBvpw9Z + Z7YAwNxp86x2u1v8ffl5JEmqu1Gv+Jeqh2/dzvQGk1fXTla+VAAA/tK59fX2zmp7g1H5WSRJaqJTS7de + O33g/uclD+AGXDyz3dysfLkAAPyXx1cPVn5LNOC5L+/b96Hys0iS1FTbneHa9KH75sxDuBHObAGAy2n1 + r9V2is+Un0OSpKYb94rbqx7Gdbt4ZnvSmS0AcKk31tcnOy2d1Y66g1PlZ5AkqY0untl2ih9VPZTr9q3l + A85sAYBL/Ht7Z7U/39m/31mtJLXdVnd4fPoQdmYLALSu1bPa3uDT5eePJKnt2jyzfcWZLQAw9cb6xmRn + +m1Q9c1QN2e1khTcY0tL1467xQ+rHtJ1e3j5wOTCZvXLBwDI47EDN1V+KzTAWa0kzUPbvd7RUUtntk8d + Olz58gEAcnjmyC2V3whNmH7jfKr83JEkRdfWme12r5j8/sRa5UsIAFhsf1xfn3zFX6uVpJztntludQet + nNl+c7gyuVDxIgIAFtt3VlYrvw3qNuoWz57udj9YfuZIkualrV7v6PRBfW72wd0EZ7YAkEuLZ7UXxv2+ + s1pJmtdG3f4/Vzy8azfuDSYvrzmzBYAMXjt5cnJ3S3+tdupfy88aSdI89qWlpWu2OsXjFQ/w2n1zeMCZ + LQAk8GhLZ7VTTz906NAHys8aSdK8dndn+eD0of36zEO8Ec5sAWCxtXhWe36r1/tY+TkjSZr3xp3+bRUP + 89rtntn+zpktACykNs9qR53ijvIzRpK0F5pMbXX7j1U91Ov2wO6Z7Wb1ywoA2Jt23+3fXm7rrHbwE2e1 + krQHO93trk4f5K9d+mCv3//30ZsrX1gAwN60+26veuc34Py4398sP18kSXutts5st3vF5MUTJypfWgDA + 3vLKyZMX3+1V7/y6OauVpD3e7pntuFt8t+ohX7evD5Yn5zc3K19eAMDe8Pb0Xf7w8oHKd339+j/ZOXrU + Wa0k7fXO9Hqtndl+/+ChyhcYALA3PH24vbPaM/uL9fJzRZK012vrzHbXi8ePV77EAID59sra2mS74t3e + BGe1krRgvfPXbItHZx/4Tfj6YMWZLQDsMRfPaodtndUWPz61dOu173ylSJIWprv6/ZXpQ/7szEO/Ec5s + AWBvafGs9tx4/8BZrSQtauPe4IsVD/9G/Oa4v2YLAHvB2bWTrZ3VjnvF7eVniSRpUZs+8O+ffQE04b7C + X7MFgHm3e1b7UHtntd/bWVq6pvwkkSQtanfu39+bPvRfnnkJNMKZLQDMtzbPareL4kj5OSJJWvTaPLN9 + wZktAMwlZ7WSpEYbd4v7ql4Kdds9s31rY6PyZQcAxLiweevkwWVntZKkBtvudDrTl0ArZ7ZPOrMFgLnS + 5lntXfsGh8vPD0lStto8s/3VseOVLz0AoF2/O7E22e5Vv6/r5qxWkrS01RvcW/WSqNu9xXDypjNbAAj1 + 583NyQODlcp3dQOe/JKzWknS6W5398z2pZmXRCOeWD1Y+QIEANrx1KHDle/oBrw+3j88VH5uSJKy56/Z + AsDi230HT9/5le/nujmrlSRd0lanf0/VS6Nuu3/N9k/ObAGgVbtntbvv4Kp3cwMedVYrSbqknV5v3/Ql + 8fzMS6MRzmwBoF0tntW+ele/v1J+XkiS9L8b9Qafr3h5NOIXR49VvhQBgHr9dvestuJd3IRxp39b+Vkh + SVJ1o+7gVNVLpG5fdWYLAI3bPav9xrC1v1b7yKT8npAk6a925w2rN0xfGs5sAWABtHdW23/1TFEMy88J + SZIu31av97nqF0r9nrvlaOVLEgC4Os5qJUlzXWtntv2hM1sAqNn5zc3J/YOW/lptr3i4/HyQJOm9t/Ph + g9dvdYpfVr5caubMFgDq9cOPfLTynduAs1uDgbNaSdKVNe70P1vxcmnEM0duqXxpAgDvz6+PHa981zbB + Wa0k6apr68x2pz+YvLHuzBYArsZbGxuTrxXtnNWOuv0Hy88FSZKuvK0bb7x++mJ5bvZF04R/O3BT5QsU + AHhvvn/wUOU7tgFnz+xbLsrPBUmSrq5Rp/hMxcumEc5sAeDKOKuVJO3ppi+Yf5194TThK/3B5PX19cqX + KQBQ7a2NzdbOaqfuKT8PJEmqr1NF8cHpS+aZmZdOI5zZAsD70+JZ7Ys7vd6+8vNAkqR6297f/+T0ZXNh + 5uXTCGe2APDePN/iWe2o0//H8rNAkqRmGnWKO6peQnXbPbM958wWAC5r9135tWJY+S5tgLNaSVLz7QyH + 1417xc8qXkS1e3z1YOULFgB4x+67suod2oAXt4vCWa0kqZ1GneIT05ePM1sACPSrFs9qtzr9fyg/AyRJ + aqf2zmyHkz+cdGYLAH/pTxsbk3ud1UqSFrndM9utTjtntt9eXp28XfHCBYCsnmjvrPaFuwaDG8vXvyRJ + 7bbVHXx8+jJq5cz26cM3V750ASCb544eq3xXNmHcLb5QvvYlSYqprTPbu3sDZ7YApHduY2NyT99ZrSQp + UXeurl436hbPVryoavfIijNbAHJr66/V7r7bxysrN5Sve0mSYhv3+5+avqDOz76wmuDMFoCsWj2rnb7b + y9e8JEnz0bhX3F710qrbmd5g8urJk5UvYwBYVOfW11s7qx11B6fK17skSfPTqaVbrx31iv+sennV7VvL + ByZvb25WvpQBYBG1dVY79dyX9+37UPl6lyRpvtruDNemL6s3Z15ejXBmC0AWbZ7VbnUHf1e+1iVJms+c + 2QJAfd5Y35jsOKuVJOl/emxp6dqtTvGjqpdZ3ZzZArDoHjtwU+U7sAE/39m/31mtJGlvdLrbPT59eTmz + BYCr0Opfq+0NPl2+xiVJ2hu1eWb7+xNrlS9rANir/ri+PtmZvuOq3n11c1YrSdqT7Z7ZjrvFD6tebnV7 + cLgyubBZ/dIGgL3oO62d1Q6ePd3tfrB8fUuStLfa7vWOjlo6s33q0OHKlzYA7DXPHLml8l3XgAvTd/Wn + yte2JEl7s7bObLd7hTNbAPa83bPar/hrtZIkvfcu/jXbbv8HVS+7un1z98y24gUOAHvFd1ZWK99xdRt1 + i2dPFYWzWknSYnS63z8yfcG9PvvCa4IzWwD2qhbPas+P+v1Plq9pSZIWo3Gnf1vFS692495g8vKaM1sA + 9pbXTp6c3N3WX6vtFHeUr2dJkhanLy0tXbPVKR6vevnV7ZvDA85sAdhTHm3prHbq6YcOHfpA+XqWJGmx + Gnc6B/01WwD439o6q919B5/u9z9WvpYlSVrMtrr9/1v1Iqzb7pnt706cqHy5A8C8eO3kemtntbvv4PJ1 + LEnS4vbOX7MtHrv0RVi/Bwb+mi0A8+vtqW8vt3VWO/jJ7ju4fB1LkrTYne52V6cvwNcufSHW74cf+Wjl + ix4Aov305iOV764G7P612s3yNSxJUo5a+2u2Uy86swVgzrxy8uRke+ad1RR/rVaSlLLJ1PRF+N3ZF2MT + vj5Ynpzf3Kx86QNA296evpMebumsdtQtfrxz9Ki/VitJytm431+ZvhBbObP9/sFDlS9+AGjb04dvrnxX + NeD8mf3FevnalSQpZ22d2e76zXFntgDEOru25qxWkqQ2K89sH5h9UTbh64MVZ7YAhNk9q31oeKDyHVW/ + /g9OLd3qr9VKkrTbaN+B3vQFefbSF2b9nNkCEKXFs9pzp/v9I+VrVpIk7TbuDb5Y8dJsxAvObAFo2dm1 + 9v5a7bhX3F6+XiVJ0l82fVHeP/vibMJ9xfLkrY2Nyo8CAKjbhc1bJw8ut3VWW3xvZ2npmvLVKkmS/rI7 + 9+/fPbN9eebl2QhntgC0pc2z2u2icFYrSdLlavXM9tjxyo8DAKjL73fPanvV76G6OauVJOk9Nn1x3jf7 + Im3C7pntm/6aLQAN+fP0HdPiWe2TzmolSXqPbXc6nenL86WZl2kjnlg9WPmhAABX66lDhyvfPQ04d9e+ + weHyNSpJkt5LbZ7Z/sqZLQA1e+nE2mT6Lqt879TNWa0kSVfYVmfwcNXLtW73FsPJm/6aLQA12T2r/cZg + pfKdU7vpu/JLzmolSbqy7vqbYTFyZgvAHtPiWe3ru+/K8rUpSZKupDbPbH9x9FjlxwMAvFdtntWOuv1/ + Ll+XkiTpatrqDUZVL9u6fbVYnvzJmS0AV6jNs9pxt3h0Ur4nJUnSVXbnDas3TF+wz8++cJvgzBaAK9Xi + We2rd/X7K+VrUpIk1dG4N/x8xUu3Ec5sAXi/fnv8xO7/62Ple6Vu407/tvL1KEmS6mzUHZyqevnW7av9 + oTNbAN6z85ubk/sHy5XvlNr1ikec1UqS1FDObAGYR+2d1fZf3RoMhuVrUZIkNdFof/9z1S/i+j3nzBaA + d/HiCWe1kiQtXG2d2d7TH07eWHdmC0C1tzY22jur7QweLl+DkiSp6XY+fPD66Qv4l5e8kBvw2IGbKj80 + AOD7Bw9VvjsacPauvxkW5WtQkiS10bjT/2zFS7kRzxy5pfJjA4C8fn3seOU7ownOaiVJCqqtM9ud/mDy + ujNbAEpvbWxOvla0dFbbLR4sX3uSJKnttm68cffM9rmZl3Mj/u2Av2YLwDvaPKs9s2/ZWa0kSZGNO8Vn + pi/lCzMv6UY4swXg+XbPav+pfN1JkqTIRp3ijqqXdd2+cvHMdr3yIwSAxdfyWe095WtOkiRFd6ooPjh9 + OT8z87JuxHf9NVuAtFo8q31xuyj2la85SZI0D211ik9MX9LObAFoRMtntf9Yvt4kSdI81d6Z7XDyR2e2 + AGm8ubE5ubcYVr4TGuCsVpKkeW1nOLxu3Ct+VvECr50zW4A82jyrvWswuLF8rUmSpHlsuzP4+PSl3cqZ + 7U9vPlL5cQLA4nju6LHKd0ATRp3iH8rXmSRJmufaOrO9uzeY/OGkM1uARXVuY2NyT99ZrSRJmunO1dXr + pi/vn868zBvxyMrq5O2KDxUA9r4nbvpI5bO/AS/sDIfOaiVJ2kttdds7s3368M2VHysA7F2tntV2iy+U + ry9JkrSXauvM9kxvMHl17WTlRwsAe8+59XVntZIk6d0rz2x/PPNyb4QzW4DF8fjqwcpnfQOeG6+s3FC+ + tiRJ0l5s1BmsTV/q52de8o1wZguw97V5VjvuFJ8pX1eSJGkvN+4Vt1e97Ot28cz2pDNbgL3qjRbPakfd + wanyNSVJkvZ6p5ZuvXbUK/6z6qVft28tH5i8vblZ+TEDwHz79/bOan/+5X37PlS+piRJ0iK03Rnuntm+ + OfPSb4QzW4C9p82z2tPdwd+VrydJkrRItXlm+4ozW4A94431jcmOs1pJknS1Pba0dO1Wp/hR1UdA3R5e + PjC5sFn9cQPAfHnswE2Vz/IG/Hxn/35ntZIkLXKnu93jo5bObJ86dLjy4waA+fHskaOVz/AmjHrDT5ev + I0mStMi1dWa73Ssmvz+xVvmRA0C8P66vT77irFaSJNXdxTPb7uCHVR8FdfvmcGVyoeJDB4B431lZrXx2 + 12/w7Olu94Pla0iSJGVoq9c76swWIK9njtxS+cxuwIVxv/+p8vUjSZIy1daZ7bg3mLy85swWYF7sntXe + PX02Vz2zG/Cv5WtHkiRla2dp6ZqtTvEfFR8ItXNmCzA/Hm3trLZ4+s7V1evK144kScrY3Z3lg9OPgtdn + PhIa4cwWIF6LZ7Xnt3q9j5WvG0mSlLlxp39bxcdC7XbPbH/nzBYgzGsnT7Z2VjvqFHeUrxlJkpS9ydSo + O3i86qOhbg8MDzizBQjy7ZWbKp/NDXj6oUOHPvDOW0aSJGnauNPZPbN9beajoRHObAHa1+ZZ7el+31mt + JEm6tFbPbE84swVoy2sn2/trtc5qJUnSX233zHb6wfDY7AdEEx4YrEzOb25WfhwBUJ+3p8/aby+39ddq + +z/ZOXrUWa0kSfrrnen1VqcfDq2c2X7/4KHKDyQA6vP04Zsrn8ENOD/q9zfL14kkSdJfr7Uz26kXT5yo + /EgC4Oq9srY22Z559jbFWa0kSXrPlWe23539oGjC153ZAjRi96z24eGBymdv3Ubd4sfOaiVJ0vtq3O+v + TD8knNkC7FFtntWO9w/Wy9eHJEnSe2/UGfyfio+LRvzmuDNbgLqcbfOstlf8S/nakCRJev+NusUDVR8Z + dXNmC1CP3bPah1o6q93q9n+ws7R0TfnKkCRJev+N9h3oTT8sXr70Q6N+zmwBrl6LZ7XntoviSPm6kCRJ + uvLGvcEXKz42GvGCM1uAK3Z27WRrZ7XjXnF7+ZqQJEm6+qYfGPfPfnA04b5iefLWxkblxxQAf92FzVsn + Dy63dVZbfM9ZrSRJqrU79+93Zgswx9o8qx0VxeHy9SBJklRfbZ7Z/urY8cqPKgAu9bsTa5PtXvXztG7O + aiVJUqNNPzjum/0AacK9xXDypr9mC/Cu/jx9Vj4wWKl8ljbgyS85q5UkSU223el0ph8dL818hDTiidWD + lR9YAPyPpw4drnyGNuDceP/wUPk6kCRJaq42z2x/efRY5UcWALdOXjqxNpk+kyufn3VzVitJklptq9O/ + p+qjpG73FsuTN/01W4BL7J7VfqOls9pRr/gPZ7WSJKnVdnq9fSNntgBhWjyrfXXkrFaSJEW01eKZ7S+c + 2QL8t98eP9HeWW2nf1v52JckSWq/UXdwquojpW5fLZYnf3JmC/DOWe2wtb9W+8ikfN5LkiSFdOcNqzdM + P0qen/lIaYQzW4B2z2rPFMWwfNxLkiTFNe4NP1/xsdKI5245WvkRBpDBxbPaimdjE5zVSpKkuaq1M9v+ + 0JktkNL5zc3J/YPlymdj7XrFw85qJUnSXLXz4YPXb3WKX1Z+vNTMmS2QUXtntf1XtwYDZ7WSJGn+Gu3v + f676A6Z+/+/ILZUfZQCL6NfHjjurlSRJ2q2tM9ud3mDyxrozW2DxvbWxMbmvaOesdtTtP1g+ziVJkuaz + rRtvvH764dLKme1jB26q/EADWCTfP3io8hnYgLN3/c2wKB/nkiRJ89tWp/hsxcdMI55xZgsssN2z2qpn + XxOc1UqSpD1Va2e2/cHkdWe2wAJ6a2Nz8rWWzmqnHigf35IkSXuj8sz2mZmPmkb82wF/zRZYPG2d1Y66 + xUtn9i07q5UkSXuv7f39T04/aC7MfuA0wZktsEieP3as8lnXiN7gi+VjW5Ikae816hR3VH7k1OwrF89s + 1ys/3gD2kjcvntUOK591DbinfFxLkiTtzXaGw+umHzWtnNl+11+zBRZAi3+t9sXtothXPq4lSZL2bqNO + 8Ynpx40zW4B38asW/1rtVqf/D+VjWpIkae/X3pntcPJHZ7bAHvTm5ubkXme1kiRJV9bFM9tO8bOKD5/a + 7Z7Zvl3xQQcwz55s76z2hbsGgxvLx7MkSdLitN0ZfHz6sdPKme3Th2+u/KgDmEfPHW3vr9WOu8UXysey + JEnS4tXWme3dvcHkDyed2QLz79zGxuSevrNaSZKkWrpzdXX3r9n+dOYjqBGPrKw6swXm3hM3faTyGdaA + F3aGQ2e1kiRp8TvdHf7t9OPHmS2QXptntdvd4u/Lx7AkSdLiN+oV/1L1UVS3M73B5NW1k5UfewCRzq2v + t3dW2xuMysevJElSjk4t3Xrt9EPoPy/5MGrAt5YPTN7e3Kz86AOI8vjqwcpnVgOe+/K+fR8qH7+SJEl5 + 2u4M16YfQ2/OfBw1wpktME/aPKvd6g7+rnzsSpIk5WvcK26v/kiq18Uz25PObIF4b6yvT3ZaOqsddQen + ysetJElSzi6e2XaKH1V9LNXNmS0wD/69vbPan+/s3++sVpIkaas7PD79OHJmCyy8Ns9qx73Bp8vHrCRJ + kto8s/29v2YLBPjj7lnt9BlU9Wyqm7NaSZKkmR5bWrp23C1+WPXxVLcHhyuTC5vVH4UATfnOgZsqn0n1 + GzzrrFaSJKmi7V7v6KilM9unDh2u/CgEaMIzR26pfBY1Yfos/VT5WJUkSdJsbZ3ZbveKye9PrFV+HALU + afes9iv+Wq0kSdJ8tHtmu9UdtHJm+83dM9uKD0SAOn1nZbXyGVS3Ubd49nS3+8HycSpJkqS/1lavd3T6 + AXVu9oOqCc5sgSa1eFZ7YdTvf7J8jEqSJOndGnX7/1zxUVW7cW8weXnNmS1Qv9dOnpzc3dZfq+0Ud5SP + T0mSJL2XvrS0dM1Wp3i86uOqbt8cHnBmC9Tu0ZbOaqeefujQoQ+Uj09JkiS918adzsHpx9TrMx9XjXBm + C9SpxbPa81u93sfKx6YkSZLeb+NO/7aKj6za7Z7Z/u7EicqPR4D3w1mtJEnSHmoytdXtP1b1sVW3B5zZ + Alfp7alvL7d1Vjv4ibNaSZKkGjrd7a5OP7Beu/SDq37ObIGr0eZZ7bjf3ywfk5IkSbra2jyzfdGZLXAF + XnFWK0mStHfbPbMdd4vvVn181e3rg+XJ+c3Nyo9KgCpvT58ZDy8fqHym1K//k52jR53VSpIk1d2ZXq+1 + M9vvHzxU+WEJUOXpwzdXPksacP7M/mK9fCxKkiSp7to6s9314vHjlR+XAH/plbW1yXbFM6QJzmolSZIa + 7p2/Zls8Ovsh1oSvD1ac2QKXdfGsdtjWWW3x41NLt177ztNQkiRJjXVXv78y/fg6O/Mx1ghntsDltHhW + e268f+CsVpIkqa3GvcEXKz7KGvGb4/6aLXCps2snWzurHfeK28vHnyRJktpq+iF2/+yHWRPuK/w1W+B/ + u7B56+Sh9s5qv7eztHRN+eiTJElSW925f39v+jH28szHWSOc2QJ/qc2z2u2iOFI+9iRJktR2bZ7ZvuDM + FphyVitJkpSscbe4r+pjrW67Z7ZvbWxUfoQCOeye1T647KxWkiQpVdudTmf6cdbKme2TzmwhtR9/9HDl + s6EB5+7aNzhcPuYkSZIUXZtntr86drzyYxRYbC+dWJtMnzWVz4W6OauVJEmaw7Z6g3urPt7qdm8xnLzp + zBZS+fPm5uSBwUrlM6EBT37JWa0kSdL8dbrb3T2zfWnm460RT6werPwwBRbTU4daO6t9fbx/eKh8rEmS + JGneavPM9pdHj1V+nAKLxVmtJEmS/ldbnf49VR9zdbu3WJ78yZktLLTds9pvtHdW+6izWkmSpD3QTq+3 + b/rx9vzMx1wjnNnCYmvxrPbVu/r9lfIxJkmSpHlv1Bt8vuKjrhG/cGYLC+m3x09MxhW/800Yd/q3lY8v + SZIk7ZVG3cGpqo+7un3VmS0snItntcPWzmofmZTPLUmSJO2h7rxh9Ybpx5wzW+B9a++stv/qmaIYlo8t + SZIk7bW2er3PVX/o1e+5W45WfrwCe4uzWkmSJL2vWjuz7Q+d2cIed35zc3L/YLnyd7x2veLh8jElSZKk + vdzOhw9ev9Upfln50VczZ7awt/3wIx+t/N1uwNmt/7+du4uxqyz0Pz4hxBBiCNaZvdfLnhfqWMq0nbca + YowxxhhjjDHGcHEu/jmXXJyLc8ktOZdcetkL03T27ClMrYAVkDd74IQIIWKIaYhpCP8KWCtCQSi1re3+ + r13W/xzO5gH6stYz++XzSb4XirQzs9eePE/8Zee5WS0AwKjoNNLvBQ59tXR85x3Bw6ykwe7Pu3YH39N1 + ZFYLADCCYs1sN9O8++Gyma00TJ1fWen+Ioszq20300fKX0sAAIyS9W3bbikOfCf6D4B19JvZ24IHW0mD + 2fPb54Pv5Ro6fXByOit/LQEAMGrajey7gUNgLZnZSsORWS0AAJUqDn4/7T8I1tEDad49s7wcPORKGozO + r6xGm9UWHSp/DQEAMMr2ZdnNxeHveN9hsJbMbKXBLuKs9tRmkkyWv4YAABh1G1PpN4tD4MW+Q2EtmdlK + g9mbEWe17Ub6k/LXDwAA46LdyO4LHQ6rzsxWGrzOXZ7VtoLv2RoyqwUAGEebrdZNnST7Y+CAWHlPm9lK + A1XMWe1GlpnVAgCMq3Yj+0ZxKDSzlcaoNyLOatcb6Y/LXzcAAIyreDPbVvfvS2a20lb2j5WV7mGzWgAA + YurNbNcbcWa2T0zPdS8FDsKS4vTs3Pbge7OGTh7I823lrxkAAMbdejP/enFIjDKzPbbj9uBhWFK9nVjY + FXxP1lGnmf2o/PUCAAAfiTWzvT/JzWylyJ1dWekeSs1qAQDYQvvn5m4qDouv9B0ea+nxGTNbKWbPRJzV + dmZmbi1/rQAAwP/WSVp3FofGC32HyFoys5XiFHNWu97Mf1j+OgEAgLBOkt0TPkxW28Ek7763tBQ8JEuq + prPLy9Fmte1mvq/8NQIAAJ9u38TeG9tJ9vvQobLqfj092720uho8LEu6/iLOak/8bHLyi+WvEQAA+Gwb + jdZicYg813eorCUzW6meIs9qv1P++gAAgCtjZisNbx8ur3Q3zWoBABhkRycmblxvZL8LHTKrzsxWqraj + s7cF32s19Nrm1JRZLQAA12at2dxdHCrNbKUhKuastpPk3y5/XQAAwLWJObN9Z89i8BAt6cr6YHm5u1m8 + l0LvsaozqwUAoBK9mW2nmb0YOnRW3SOtme7F1fBhWtLn91S0WW3+6lqzeXP5awIAAK7PRpIstCPNbF+a + 3xE8TEv67I7vvCP4nqqhi8XvhG+Vvx4AAKAasWa2G0nWfXvRzFa6mnqz2gd8Wi0AAMPs8qfZNtMXQofQ + qvtVb2YbOFhLCvfUzFzwvVRDr+zLMrNaAADqsZamO4tD55m+Q2gtmdlKV1bEWe2FTtK6s/x1AAAA9eg0 + 0rsDh9HK6yS5ma30Ob2/tNS9P9an1Tay+8pfAwAAUJ97JyZuaDfzZ0KH0qo70po1s5U+oyfjzWqPPTo/ + /4Xy1wAAANSr02hsLw6hZrbSFhZzVruWpl8r3/4AABBHzJnt3/bsCR66pXHt/aVls1oAAEZbt6g4kB7t + P6DW0ZHcp9lK/79LRU9Mx5rV5n/YXFgwqwUAYGusNZtzxcH0/U8eVKvvxa98NXgAl8atV27fGXyP1NCF + dpqulm93AADYGtFmtkWnzGw15r27tNTd6Htv1JVZLQAAA6Gc2T7df2Cto4fy6e6F1dXgYVwa9S4Vz/5j + kWa17Wb2slktAAADo5OmM8VBNcrM9vnt88EDuTTqHdtxe/A9UUMXDk5ly+XbGwAABkOsmW2vv+w2s9V4 + dXpx0awWAIDxVs5sj/QfYOvooXzGzFZjU29W+2hrNvheqL70hX0Te2/86F0NAAADpj05mxQH19OfPMhW + n5mtxqWIs9qza2m6s3w7AwDAYOok+V2Bw2wtnTSz1Yh3ejHep9V2kuye8m0MAACDrTjAPtx/oK2jB7Pp + 7vmVleBhXRr2Lq7u7T4yHWtWm/12c2LihvItDAAAg23/1FRvZvt236G2lsxsNarFnNVuZJlZLQAAwyXq + zHbX7uChXRrW3unNapPw8151ZrUAAAyt4kD7YP8Bt456M9tzPs1WI9I/i2c54qz2ObNaAACG1kaj0SgO + tW/1HXJr6dm57cEDvDRsvTS/I/iM19DZA5P5jvLtCgAAwynmzPYNM1sNeW/tWewW75ng8111ZrUAAIyM + 4hB9OHTorbrDvZmtT7PVkNab1f4ynwk+2zX03L1mtQAAjIq1ZrPRNrOVPrOIs9oz7anWfPn2BACA0RBz + ZvunhV3BQ700qMWc1bab6b+Xb0sAABgt60neDh2Cq+7n2XT3H2a2GpJizmo7zezJbvl+BACAkbP/1rlb + i4Pvm/0H4Toys9WwFHFW+96BNJ0p344AADCaOknrB4HDcC2Z2WrQ++vuPb3/9zH4/FZdp5HeXb4NAQBg + tLWb+b7Qobjqfp62zGw1sF1YXe0+nE8Hn93KS7LHzWoBABgbZrZSzFlt+t56nrfKtx8AAIyH9lT6/fAB + ufpOmNlqwDq1x6wWAABqF2tmeyhtdT9cNrPVYHR+ZSXerLaRP1a+3QAAYPxsfmn7LcXB+PVPHJRr6Ojs + bcELgBS757fPB5/RGjp94MutrHy7AQDAeOo00u8FDsu1dHznHcFLgBSrP+/aHXw268isFgAASrFmtptp + 3j1jZqst6vzKavcXWaRZbTN7pHx7AQAA69u29Wa2J/oOzbX0m1mfZqutKeas9uDktFktAAB8XKeRfbc4 + LF/sOzzXkpmtYvdm3Fnt/ynfVgAAwMe1G9l9oUN01T1weWa7HLwcSFV3Lu6s9lD5dgIAAPrty7Kbi0Pz + 8b5DdC097dNsFamIs9pTG1k2Wb6dAACAkPVG9o3i8Gxmq5Eo8qz2J+XbCAAA+CzxZrat7gdmtqqp3qz2 + cNYKPns1ZFYLAABXarPVuqmTZH8MHKwrz8xWdRVzVnsgz7eVbx8AAOBKbDTyrxeH6Sgz21du3xm8NEjX + 2omFXcFnrY7ajezH5dsGAAC4GrFmtvcneffvS2a2qqazKyvdQ6lZLQAADLz9c3M3FYfqV/oO2bX0+Mxc + 91LgAiFdbc/e9pXgM1ZDJzdbLbNaAAC4HuvNeDPbYztuD14ipCst6qy2mf2ofJsAAADXI9bM9mCSd99b + XApeJqTP6+zyslktAAAMo3Jm+3LfobuWzGx1rT0ztz34TNXQic7MzK3l2wMAAKhCu5EvFoftC32H71oy + s9XVFnNW22lk3y3fFgAAQJU6SXZP6BBedZdntktmtrqyPow4q203833l2wEAAKjavom9N7aT7Pehw3jV + /Xp6tntpdTV4yZA+3n/Gm9W+9rPJyS+WbwcAAKAOG41Wb2Z7ru8wXktmtvq8Ys5q15r5d8q3AQAAUKeY + M9t3zWz1KX24vNLdNKsFAIDRc3Ri4sb1Rva70OG86h6bnu1eXA1fOjTeHZ29LfjM1NBrm1NTZrUAABDT + WrO5ux1pZvvS/I7gpUPj26s7F4LPSh21k9a3y8ceAACIKdbMdiPJuu/sWQxePjR+fbC83H3ArBYAAEbf + 5ZltM38xdFivul+1ZroXAxcQjV9PzcwFn5Hqy19dazZvLh93AABgK6wnyYKZrWJ1fOcdwWejhi520vRb + 5WMOAABspVgz206Sd99eNLMd13qz2vuLZyD0bNTQT8vHGwAA2GqbExM3rDey/woc3CvPzHZ8ezLarDY7 + tn9u7qby8QYAAAbB/Y3p7cVh/Uzf4b2WzGzHr4iz2gvrSfK18rEGAAAGSaeR3h04xFdeb2b7NzPbsen9 + paVos9p2I7uvfJwBAIBB0y1qN/NnQof5qjvSmjWzHZOemLkt+AzU0LFH5+e/8NHTDAAADKROo9Gb2b7f + d5ivJTPb0S/mrHYtTc1qAQBgGESd2e4xsx3V3l+K92m1ZrUAADBEejPb4iB/tP9gX0dH8pnuhdXV4KVF + w9ul4jV9YjrWp9Wmf9hcWDCrBQCAYXIwSeaKA32Ume3z2+eDFxcNb8d23B58rWvoQjtNV8vHFgAAGCbR + ZrZFp/bsCV5eNHy9u7jY3eh7jevKrBYAAIZYObN9uv+gX0cPmdmORL1Z7WOt2eBrXHXtZvayWS0AAAy5 + TprOFAd8M1tdUTFntZ2pfLl8TAEAgGHWbuT/Gjj019JfdpvZDmunY85qk+w/yscTAAAYBe1mdiR0+K86 + M9vhrDerfTTSrHa9mb6wOTFxQ/loAgAAo6A9OZsUB/63P3kBqD4z2+Er4qz27EaW7SwfSwAAYJR0kvyu + wCWglk6a2Q5NpxeXos1qO0l2T/k4AgAAo6g4+D/cfxGoowez6e75lZXgJUeD08XVvd1HpmPNarPfmtUC + AMCI2z81ZWar/y7mrLadZTvKxxAAABhlMWe2b+zaHbzsaOv7257F7kYSft2qzqwWAADGTHEReLD/YlBH + h7NW95xPsx24/lm8JkfymeBrVkPP3WtWCwAA42Wt2WwUl4G3+i4HtfTs3PbgxUdb10vzO4KvVQ2d7Uy1 + 5svHDgAAGCcxZ7avL+wKXn4Uv7f2LHaL1z74OlWdWS0AAIy59UZ6KHRZqLrD2XT3nE+z3fJ6s9pfRprV + tpPsv8xqAQBgzG0myWRxQTjZf2GoIzPbrS/irPa9tlktAADQs97Mfxi4NNTSn8xst6y/7t4Tb1bbSO8u + Hy8AAICJiXYz3xe6PFTdz7Pp7j/MbKN3eVbbivZptY93y+cKAADgsv23zt1aXBbe7Ls81JKZbfxizmoP + ZlmrfKwAAAD+Rydp/SBwiailE3csBC9Hqr7Ls9rAa1BHZrUAAMBnijazTVtmthG6sLrafTifDr4GlZdk + j5nVAgAAn2nzS9tvWW9krwcvFRVnZlt/8Wa16XvreW5WCwAAfL72VPr98MWi+l7daWZbV3/etdusFgAA + GEyxZrabSd79cNnMturOr6x0H8zizGrbzfSR8rEBAAC4Muvbtt1SXCiizGyPzt4WvDjp2nt++3zwZ11D + pw98uZWVjw0AAMCVW29k3wtcMmrp+M47gpcnXX29WW3oZ1xHZrUAAMB1iTazTfPuGTPb6+78ymr3F5Fm + tUVHyscEAADg2pQz2+N9l41a+s2sT7O93mLNatvN7K325GxSPiYAAADXbmMq/WZx0bjYf/GoIzPba+/N + XbuCP9NaSvK7yscDAADg+rUb2X3By0fFPXB5ZrscvFTp0zt3eVbbCv5Ma+hQ+VgAAABUY7PVuqm4bESZ + 2T7t02yvuoifVntqI8smy8cCAACgOu1G9o3i0mFmO2C9EfHTatcb6Y/LxwEAAKB68Wa2re4HZraf27nV + 1e5hs1oAAGBUXJ7ZNrI/Bi4kldeb2V4KXLT0Pz0Xb1Z78kCebysfAwAAgPpsNPKvF5eQKDPbYztuD162 + tLd7YiHep9V2mtmPypcfAACgfrFmtvcneffvS2a2/Z1dWekeSs1qAQCAEbV/bq73abav9F1OaunxmTkz + 276emdse/FnV0MnNVsusFgAAiG+t2bqzuJSY2UYu5qx2o5n9sHy5AQAA4msn2X+ELitVdzDJu+8tLgUv + YePU2eXleLPaJG+XLzMAAMDW2Dex98bigvL7T1xYaujX07PdS6urwcvYuBRxVnviZ5OTXyxfZgAAgK2z + 0WgtFpeUc32Xlloa55ltzFntejP/TvnyAgAAbL1Okt0TvrxU2+WZ7dL4zWw/XF7ubkaa1bab+b7yZQUA + ABgMl2e2jex3oUtM1Y3jzPY/481qX9ucmjKrBQAABs96s7W7uLSY2VZczFltJ8m/Xb6cAAAAgyfmzPad + Mfg02w96s9riew39DKrOrBYAABh4Rycmbuw0sxdDl5qqe6Q10724Gr6sjUpPzd4W/N6rL3/VrBYAABgK + G0my0I40s31pfkfwsjYKHd95R/B7rqPiNftW+fIBAAAMvlgz240k676zZzF4aRvmerPaB3xaLQAAQFhv + ZrvezKPMbH/Vm9kGLm7D3FMzc8HvterazezVtWbz5vJlAwAAGB7rSbJQXGzO9l906miUZrYRZ7UX22n6 + zfLlAgAAGD7tZvrvgctO5XWSvPv24vDPbN9fWureH+vTahvZfeXLBAAAMJzunZi4Yb2RPRO69FTdr1qz + Qz+zfTLSrLbo2KPz818oXyYAAIDh1Wk0theXnDN9l55aGuaZbcRZ7YX1JPla+fIAAAAMv04jvTtw+am8 + 3sz2b3v2BC91g5xZLQAAwHXoFq0306OhS1DVHRmyme2loiemY81q8z+Y1QIAACNprdmcKy4+73/yIlR9 + wzSzjTmr7aTpavlyAAAAjJ6YM9tTQzCzfdesFgAAoDq9mW2nmT0duhRV3UP5dPfC6mrwsjcIXSq+tsem + Z4Nfe/Wlf9hcWDCrBQAARt/BJIk2s31++3zwwjcIHdtxe/BrrqELB6ey5fLHDwAAMPpizWx7ndq9O3jp + 28reXVzsbgS+1joyqwUAAMbOR59mmz3Zf0Gqo4fymYGa2V6e1bZizWqzl/dN7L3xo586AADAGDmQpjPF + peh03yWplgZpZhtxVnu2M5Wb1QIAAOOrk+R3BS5LtfSX3Vv/abanF5eizWo7SXZP+WMGAAAYX8UF6eH+ + C1MdPZht7afZXlzd23003qz2t5sTEzeUP2IAAIDxtX9qKikuSW/3XZpqaStntjFntRtZtrP88QIAABBz + ZntyC2a2ZrUAAABbrNPMHgxdoqquN7M9v7ISvBzWUW9W+8i0WS0AAMCW2mg0GsWlKcrM9rmIM9uXv7oj + +DXU0NkDk/mO8scJAABAv5gz2zd27Q5eEqvsrT2L3eJ7Cv79VWdWCwAAcAXWk/xw6FJVdYezVvdcjTPb + f66udo/kM8G/u4aeu9esFgAA4POtNZu9me1bfZeqWnp2bnvwwlhFL81Hm9We6Uy15ssfHwAAAJ8n5sz2 + 9YVdwUvj9WRWCwAAMODWk7wdumRV3eGKP82292f9Mt6s9kmzWgAAgGvQmZm5tbhUvdl3yaql5yv8NNve + nxX6O2rovQNpOlP+uAAAALha7ST/QeCyVUt/qmBm+9fde4J/dh11Gund5Y8JAACAa9Vu5vtCl66q+3k2 + 3f3Hdcxse59W+8tWpFltkj3eLX8+AAAAXIf9t85Fm9lez6fZxvu02vS9g1nWKn88AAAAXK/1JPl++AJW + fSfuWAheKj+r3qy2E/iz6sisFgAAoAaxZraH0tZVzWwvrK52H86ng39W5SXZY+WPAwAAgCptfmn7LeuN + 7PXgZazirmZm++JXvhr8M2ro9IEvt7LyxwEAAEDVOo30e4HLWC0d33lH8JL58f68a3fw360js1oAAIAI + Ys1sN9O8++Hyp89sz6+sdH+RxZnVtpvpI+W3DwAAQJ3Wt227pbiInei/mNXRb2ZvC144ez2/fT7479TQ + 6YOT02a1AAAAsbQb2XcDl7NaCs1sY85q2438X8tvGwAAgFiKC9lP+y9odfRAmnfPLC//94Xz/MpqtFlt + 0aHy2wUAACCmfVl2c3EpO953Saulj89sI85qT20myWT57QIAABDbxlT6zeJydrHvslZL/3dh1+VC/6yO + 2o30J+W3CQAAwFZpN7L7Qpe2qjuUti4X+mc1ZFYLAAAwCDZbrZs6SfbHwMVtWDu1kWVmtQAAAIOi3ci+ + UVzWosxsa6+R/rj8tgAAABgUsWa2NWdWCwAAMIh6M9vi0vZK3yVumDp5IM+3ld8OAAAAg2a9mX+9uLwN + 5cy23cx+VH4bAAAADKohndma1QIAAAyD/XNzwzazPdmZmbm1/PIBAAAYdJ2kdWdxmbvQd7kb0PIfll82 + AAAAw6KTZPeEL3mDU7uZ7yu/XAAAAIbJvom9N7aT7Pehy96AdOJnk5NfLL9cAAAAhs1Go7VYXO7O9V32 + BqT8O+WXCQAAwLAaxJmtWS0AAMCIODoxceN6I/td6PK3Rb22OTVlVgsAADAq1prN3cVlbyBmtp0k/3b5 + ZQEAADAqBmFma1YLAAAwonoz204zezF0GYxT/upas3lz+eUAAAAwajaSZKG9NTPbi8Xf/a3yywAAAGBU + bcXM1qwWAABgTFz+NNtm+kLoclhTr+zLMrNaAACAcbGWpjuLy+CZvsthHV3oJK07y78WAACAcdFppHcH + LomV1m5k95V/HQAAAOPk3omJG9rN/JnQZbGijj06P/+F8q8DAABg3HQaje3F5bCOme2FtTT9WvnXAAAA + MK7qmNma1QIAAHBZt6jaT7NNX9hcWDCrBQAA4CPlp9m+/8kL5FXXm9XuLP9YAAAA+EgVM1uzWgAAAIJ6 + M9tOM3s6dJm8ktrN7GWzWgAAAD7VwSSZKy6Q1zKzPduZypfLPwYAAADCrmVm20mye8p/HQAAAD7dR59m + mz3Zf7H8jH67OTFxw0f/NgAAAHyOTprOFJfJK5nZnt3IMp9WCwAAwNW5kpmtWS0AAADXpJzZHum/aH6s + 5+41qwUAAOBatSdnk+JyebrvstnrTGeqNV/+zwAAAODadJL8rv5Lp1ktAAAAlSkumg9/7NL5pFktAAAA + lSlntr1Ps337QJrOlP81AAAAVGM9yf6t3cz+pfyPAAAAUJ3ep9kCAFdjYuL/AZmYbFw1Ioa7AAAAAElF + TkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAB44AAAOdCAYAAAB6bE8jAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAGYuSURBVHhe7N1djJ11vff/CSHEEGOwzqx1Pax56DC2ZR7X + rJodYwwxxhhjjDHGg//Bzj7k4H/gIdlnxEMOPeyBado1awpTCkKFCogVDBFDxHCThpiG238FrJWHgqXU + trbXf9b0V0G9Cp12ZtbvWuv1Tl4H973d0M6sa+1kf/Ld15AkSZIkSZIkSZIkSZIkSZIkSZI2uPuGhm7Z + X69PhP+nJEmSJEmSJEmSJGnQWpmevm2pnp3rJNm9K0NDt4T/b0mSJEmSJEmSJEnSoBSG4yJ4ft9wviP8 + lyRJkiRJkiRJkiRJg9C/Dcdda9fH3f8T1uE/IkmSJEmSJEmSJEnq50qG4zXtJPt1e6QxFf5jkiRJkiRJ + kiRJkqR+7VrDcXC2XU9/WIT/rCRJkiRJkiRJkiSpD/uU4fiqJw9kWSP8t0iSJEmSJEmSJEmS+qnrHI67 + 3u/U0nvCf5skSZIkSZIkSZIkqV9ax3B8RZIdWcpz18eSJEmSJEmSJEmS1C+tezi+4rTrY0mSJEmSJEmS + JEnqk25wOF7TrqePHxgezcI/SpIkSZIkSZIkSZJUxW5mOA6618f/Hf5xkiRJkiRJkiRJkqSqtQHD8RW1 + bN/eOybuCP9YSZIkSZIkSZIkSVJV2rDh+IpTnVr6/fCPliRJkiRJkiRJkiRVoQ0ejq86uC/Pt4V/hSRJ + kiRJkiRJkiQp5jZpOO461a5l3wv/GkmSJEmSJEmSJElSrG3icHzVwZVGw/WxJEmSJEmSJEmSJMXaFgzH + XSfb9ey74V8pSZIkSZIkSZIkSYqpLRqOrzrYGRu7I/yrJUmSJEmSJEmSJEkxtMXDcdeJTi37RvjXS5Ik + SZIkSZIkSZJ6XQ+G4zXter7nJ8PDnw1/DEmSJEmSJEmSJElSr+rVcLymlv1huZZ/OfxRJEmSJEmSJEmS + JEm9qKfDcdC9Pl4ZGXF9LEmSJEmSJEmSJEm9KIbhOPhjO2l8LfyxJEmSJEmSJEmSJElbVUTD8Zru9fH+ + ev328MeTJEmSJEmSJEmSJG12sQ3HV+SvddL07vBHlCRJkiRJkiRJkiRtZnEOx2suda+P92SZ62NJkiRJ + kiRJkiRJ2swiHo6vOraUJF8Kf1xJkiRJkiRJkiRJ0kZXgeG462K7lt3/xNTUbeGPLUmSJEmSJEmSJEna + qCoyHF91bH+auj6WJEmSJEmSJEmSpI2sYsNx0a5n55fq6f+uDA3dEv4KkiRJkiRJkiRJkqSbqWrD8UfS + V9pp2gp/DUmSJEmSJEmSJEnSjVbd4XjN2ruPu3+H8NeRJEmSJEmSJEmSJK23ig/Ha9r17OXOSN4MfyVJ + kiRJkiRJkiRJ0nrqh+E4uNhOsh9597EkSZIkSZIkSZIkrbM+Go6D9Lf703RX+OtJkiRJkiRJkiRJkj6t + /huO15zrJNm9ro8lSZIkSZIkSZIk6Trq0+H4qt+0s2xH+KtKkiRJkiRJkiRJksrq8+G4a+36+D7Xx5Ik + SZIkSZIkSZJU3gAMx1c93xlpTIW/tiRJkiRJkiRJkiTpagM0HHe5PpYkSZIkSZIkSZKkf2/AhuM17ST7 + ddv1sSRJkiRJkiRJkiRdaTOH41d37ipWkrz0vxaB051a+t/hxyBJkiRJkiRJkiRJg9tmDsd/X1wszq16 + bvudpf/1SDx5IMsa4cchSZIkSZIkSZIkSYPXZg/Hxe7da05MzxQH00bpfy4C73dq6T1F+JlIkiRJkiRJ + kiRJ0kC1VcNx17lms3h2YrL0PxuFJHtyKc9dH0uSJEmSJEmSJEkarLZyOL4q7uvjdO36OPx4JEmSJEmS + JEmSJKn/68Vw3PVhs1n8KuLr43Y9fXzfFxpZ+DFJkiRJkiRJkiRJUv/Wq+H4qu718Uq87z4+7fpYkiRJ + kiRJkiRJUt/X6+G468PmYnF0fHvpPyMShw8Mj7o+liRJkiRJkiRJktSfxTAcX/XaruniwUivj9v17K2l + JP9B+LFJkiRJkiRJkiRJUv8U03Dc9UGzWfxibKL0nxeJg8tZNhx+fJIkSZIkSZIkSZJU/WIbjq86vuuu + 4oEkL/3nRuBUp5Z+P/wIJUmSJEmSJEmSJKnaxTocd3Wvj5+O/Pp4X55vCz9KSZIkSZIkSZIkSapmMQ/H + V0V+fXyyU8++G36ckiRJkiRJkiRJklS9qjAcd51ZWCieGtte+u+JxMGVRsP1sSRJkiRJkiRJkqTqVZXh + +KrYr4+X69l3wo9WkiRJkiRJkiRJkqpR1YbjrjMLzeKp0YjffZzk7Z8MD382/IglSZIkSZIkSZIkKe6q + OBx3XW61imM7dhbLJf/eSJzo1LJvhB+zJEmSJEmSJEmSJMVbVYfjq96bny+ORHx93K7ne1ZGRlwfS5Ik + SZIkSZIkSYq3qg/HXRW4Pv5jJ8m/Fn7kkiRJkiRJkiRJkhRX/TAcX3V6fr54ojFe+meJgetjSZIkSZIk + SZIkSVHWT8NxVxWuj5eT5O7w45ckSZIkSZIkSZKk3tdvw/FVp+cXisdH474+3l+v3x5+DZIkSZIkSZIk + SZLUu/p1OO661Np95fo4Kf/z9Vq7nr3WSVPXx5IkSZIkSZIkSZJ6Wz8Px1e9270+boyV/hkjcGnVj5+Y + mrot/EokSZIkSZIkSZIkaWsbhOG46x+tVvHS1I6ik+Slf9YIHFtKki+FX4skSZIkSZIkSZIkbV2DMhxf + 9dbcfPFYHu318cV2Lbvf9bEkSZIkSZIkSZKkLW3QhuOu+K+P81c6adoKvyJJkiRJkiRJkiRJ2twGcTi+ + au36ON53H69dH3d/P+FXJUmSJEmSJEmSJEmb0yAPx13/vD4u+fPHIX3lwEjWDL8uSZIkSZIkSZIkSdr4 + Bn04vuqvs3PFo/lo6d8jAmvXx3uGdt8afm2SJEmSJEmSJEmStHEZjj9yMfrr4+zlzkju+liSJEmSJEmS + JEnSxmY4/k9/npktHsmivT4+10mye1eGhm4Jv0JJkiRJkiRJkiRJurkMx+UurP7ZX5icKv17xSH97XKW + 7Qq/RkmSJEmSJEmSJEm68QzHn6x7ffyw62NJkiRJkiRJkiRJ/Zzh+NNdWGxFfn2c/aadZTvCr1SSJEmS + JEmSJEmS1pfh+Pq9OTNTPJw1Sv+uEVi7Pr7P9bEkSZIkSZIkSZKk9WY4Xp/z8V8fP98ZaUyFX68kSZIk + SZIkSZIkfXqG4xvzxsxscSje6+Ozro8lSZIkSZIkSZIkXXeG4xt3vtUqno/7+vjpfWk6Fn7VkiRJkiRJ + kiRJklSe4fjmnZieKQ6m0V4fv9+ppfcU4fctSZIkSZIkSZIkSf+R4XhjnFv9uz63/c7Sn0MknjyQZY3w + a5ckSZIkSZIkSZKkjzIcb6y4r4/Ttevj8KuXJEmSJEmSJEmSpCsZjjfeuWazeHZisvRnEoUkO7KU566P + JUmSJEmSJEmSJF3JcLx5utfHK/G++/i062NJkiRJkiRJkiRJaxmON9eHzWbxq4ivj9v19PEDw6NZ+DhI + kiRJkiRJkiRJGsQMx1tj7fo4yUt/ThFwfSxJkiRJkiRJkiQNcobjrfNhc7E4Or699GcViYMrSTIcPhqS + JEmSJEmSJEmSBiXD8dY7vuuu4sF43318ql1Lvx8+HpIkSZIkSZIkSZIGIcNxb3zQbBa/GJso/blF4uBy + lrk+liRJkiRJkiRJkgYhw3Fvda+PH4j33cenlmrp98JHRZIkSZIkSZIkSVK/ZjjuvTMLC8XTkV8f78vz + beEjI0mSJEmSJEmSJKnfMhzHI/Lr45Odevbd8LGRJEmSJEmSJEmS1E8ZjuPSvT5+ajTu6+PO2Ngd4eMj + SZIkSZIkSZIkqR8yHMfn8qrYr4+X6vl3wkdIkiRJkiRJkiRJUtUzHMfrvYWF4sjoeOnPNgbter7nJ8PD + nw0fJUmSJEmSJEmSJElVzXAct8utVnFsx85iueTnG4kTS/X86+HjJEmSJEmSJEmSJKmKGY6r4b35+eJI + I+7r45WREdfHkiRJkiRJkiRJUhUzHFdHBa6P/9hJ8q+Fj5YkSZIkSZIkSZKkqmQ4rp7T8wvFE5FfH++v + 128PHzFJkiRJkiRJkiRJsWc4rqb4r4/z15aT5O7wMZMkSZIkSZIkSZIUc4bjauteHz8+Gu318aXu9fGe + LHN9LEmSJEmSJEmSJMWc4bj6LrV2X7k+Tsp/D73WrmevtdP0q+EjJ0mSJEmSJEmSJCm2DMf94+25+eJw + Plb6u4jAxXYtu/+JqanbwkdPkiRJkiRJkiRJUiwZjvvLP1qt4qWpHUUnyUt/JxE4tj9NvxQ+fpIkSZIk + SZIkSZJiyHDcn96amy8ei/z6uPvZCx9DSZIkSZIkSZIkSb3McNy//nl9XPK7iUP+SjtNW+GjKEmSJEmS + JEmSJKlXGY77319n54rHGq6PJUmSJEmSJEmSJF0jw/FgiP36uF3PXj4wkjXDx1KSJEmSJEmSJEnSVmY4 + Hizd6+NH89HS31cE1q6P9wztvjV8PCVJkiRJkiRJkiRtRYbjwXOx1SpevPOLpb+zOKS/3Z+mu8JHVJIk + SZIkSZIkSdJmZzgeXH+emS0eyaK9Pj7XSbJ7V4aGbgkfVUmSJEmSJEmSJEmbleF4sF1Y/R29MDlV+vuL + xG+Ws8z1sSRJkiRJkiRJkrSZGY7p6l4fP+z6WJIkSZIkSZIkSRrMDMdcdWGxFfv18fP7hvMd4aMrSZIk + SZIkSZIkaaMyHPPv3pyZKR7OGqW/0wisXR/f5/pYkiRJkiRJkiRJ2rgMx5Q5X4Hr4/ZIYyp8jCVJkiRJ + kiRJkiTdTIZjPskbM7PFoXivj8+26+kPi/BZliRJkiRJkiRJknSDGY75NN3f43MTk6W/4xh06tnT+9J0 + LHykJUmSJEmSJEmSJK03wzHX68T0THEwjfb6+P1OLb3H9bEkSZIkSZIkSZJ0AxmOWY9zq7/TZyO+Pl5K + sieX8rwRPt6SJEmSJEmSJEmSrifDMTci7uvjdO36OHzEJUmSJEmSJEmSJH1ahmNu1LlmM+7r41p+ZN8X + Gln4qEuSJEmSJEmSJEm6VoZjblb3+ngl3ncfn3Z9LEmSJEmSJEmSJH1KhmM2wofNZnF0fHvp5yASjx8Y + HnV9LEmSJEmSJEmSJJVlOGYjrV0fJ3np5yEC3evj/w4ffUmSJEmSJEmSJElXMxyz0T5oNotfxH19fHA5 + y4bDIyBJkiRJkiRJkiTJcMxmOb7rruLBeN99fKpTS78fHgNJkiRJkiRJkiRpsDMcs5nWro/HJko/H5E4 + uC/Pt4XHQZIkSZIkSZIkSRrMDMdshe718QPxvvv4VLuWfS88EpIkSZIkSZIkSdLgZThmq5xZWCiejvz6 + eKXRcH0sSZIkSZIkSZKkwctwzFaL/Pr4ZLuefTc8HpIkSZIkSZIkSdJgZDimF84sNIunRuO+Pu6Mjd0R + HhNJkiRJkiRJkiSpvzMc0yuXV726c1exXPLZicSJTi37RnhUJEmSJEmSJEmSpP7NcEyvvbewUByJ+Pq4 + Xc/3/GR4+LPhkZEkSZIkSZIkSZL6L8MxMbjcahXHduyM+fr4j/vr+dfDYyNJkiRJkiRJkiT1V4ZjYnJ6 + fr54ojFe+nmKQff6eGVkxPWxJEmSJEmSJEmS+ivDMbGpwvVxO2l8LTxCkiRJkiRJkiRJUvUzHBOr0/ML + xeOjcV8f76/Xbw+PkiRJkiRJkiRJklTdDMfE7FJr95Xr46T8M9Z7+WudNL07PE6SJEmSJEmSJElSNTMc + UwXvxn19fGnVj/dOTHwmPFaSJEmSJEmSJElStTIcUxX/aLWKl6Z2FJ0kL/28ReDYUpJ8KTxakiRJkiRJ + kiRJUnUyHFM1b83NF4/lY6WfuQhcbNey+5+YmrotPGKSJEmSJEmSJElS/BmOqaIqXB/vT1PXx5IkSZIk + SZIkSapGhmOqrArXx91nLDxukiRJkiRJkiRJUpwZjqm6f14fl3wG45C+0k7TVnjkJEmSJEmSJEmSpPgy + HNMv/jo7Vzyaj5Z+FiPg+liSJEmSJEmSJEnxZjimn1yM/Pq4Xc9e7ozkzfD4SZIkSZIkSZIkSXFkOKYf + nZqL/Po4yX60MjR0S3gMJUmSJEmSJEmSpN5mOKZfXVj9/L0wOVX62YxD+tvlLNsVHkVJkiRJkiRJkiSp + dxmO6Xd/npktHs6ivT4+10mye10fS5IkSZIkSZIkqacZjhkEFxZbkV8fZ79pZ9mO8FhKkiRJkiRJkiRJ + W5vhmEHyZgWuj+9zfSxJkiRJkiRJkqStznDMoKnA9fHznZHGVHhEJUmSJEmSJEmSpM3PcMyg6l4fH8oa + pZ/dCLg+liRJkiRJkiRJ0tZlOGaQnY/8+ridZL9uuz6WJEmSJEmSJEnSZmc4ht3FiemZ4mAa7fXx+51a + ek8RnllJkiRJkiRJkiRpwzMcwxXnVj+vz22/s/SzHIknD2RZIzy6kiRJkiRJkiRJ0sZlOIZ/5fpYkiRJ + kiRJkiRJA5fhGP7TuWazeHZisvRzHYUkO7KU566PJUmSJEmSJEmStDEZjuHa4r4+Tteuj8OjLEmSJEmS + JEmSJN14hmP4ZB82m8WvIr4+btfTx/d9oZGFR1qSJEmSJEmSJElaf4ZjuD7d6+OVeN99fNr1sSRJkiRJ + kiRJkm44wzFcvw+bi8XR8e2ln/dIHD4wPOr6WJIkSZIkSZIkSevLcAzr99qu6eLBSK+P2/XsraUk/0F4 + xCVJkiRJkiRJkqRPz3AMN+aDZrP4xdhE6Wc/EgeXs2w4POqSJEmSJEmSJEnStTMcw805vuuu4oEkL30G + InCqU0u/Hx53SZIkSZIkSZIkqTzDMdy87vXx05FfH+/L823hsZckSZIkSZIkSZL+NcMxbJzIr49PdurZ + d8OjL0mSJEmSJEmSJH2U4Rg21pmFheKpse2lz0QkDq40Gq6PJUmSJEmSJEmS9FGGY9gcsV8fL9ez74Sv + AUmSJEmSJEmSJA16hmPYPGcWmsVToxG/+zjJ2z8ZHv5s+DqQJEmSJEmSJEnSoGY4hs11udUqju3YWSyX + PCORONGpZd8IXwmSJEmSJEmSJEkaxAzHsDXem58vjkR8fdyu53tWRkZcH0uSJEmSJEmSJA1ihmPYOhW4 + Pv5jJ8m/Fr4eJEmSJEmSJEmSNCgZjmHrnZ6fL55ojJc+NzFwfSxJkiRJkiRJkjRgGY6hN6pwfbycJHeH + rwpJkiRJkiRJkiT1c4Zj6K3T8wvF46NxXx/vr9dvD18ZkiRJkiRJkiRJ6scMx9B7l1q7r1wfJ+XPUq+1 + 69lrnTR1fSxJkiRJkiRJktSvGY4hHm/PzReH87HS5ykCl1b9+ImpqdvC14ckSZIkSZIkSZL6JcMxxOUf + rVbx0tSOopPkpc9VBI4tJcmXwleIJEmSJEmSJEmS+iHDMcTprbn54rF4r48vtmvZ/a6PJUmSJEmSJEmS + +iTDMcQr/uvj/JVOmrbC14kkSZIkSZIkSZKqmuEY4vfX2bnisUbc18fd75LwtSJJkiRJkiRJkqSqZTiG + avjn9XHJsxaH9JUDI1kzfLVIkiRJkiRJkiSpShmOoVq618eP5qOlz1wE1q6P9wztvjV8xUiSJEmSJEmS + JKkKGY6hei5Gf32cvdwZyV0fS5IkSZIkSZIkVSXDMVTXn2dmi0eyaK+Pz3WS7N6VoaFbwteNJEmSJEmS + JEmSYs1wDNV2YfU5e2FyqvQZjMRvlrNsV/jKkSRJkiRJkiRJUowZjqE/dK+PH3Z9LEmSJEmSJEmSpBvJ + cAz948JiK/rr433D+Y7w9SNJkiRJkiRJkqRYMhxD/3lzZqZ4OGuUPpcRWLs+vs/1sSRJkiRJkiRJUjwZ + jqE/nY//+vj5zkhjKnwVSZIkSZIkSZIkqZcZjqG/vTEzWxyK9/r4rOtjSZIkSZIkSZKkCDIcQ/8732oV + z8d9ffz0vjQdC19LkiRJkiRJkiRJ2uoMxzA4TkzPFAfTaK+P3+/U0nuK8N0kSZIkSZIkSZKkLcxwDIPl + 3Opz+dz2O0uf2Ug8eSDLGuErSpIkSZIkSZIkSVuR4RgGU9zXx+na9XH4mpIkSZIkSZIkSdJmZziGwXWu + 2SyenZgsfX6jkGRHlvLc9bEkSZIkSZIkSdJmZzgGutfHK/G++/i062NJkiRJkiRJkqRNznAMdH3YbBa/ + ivj6uF1PHz8wPJqFry5JkiRJkiRJkiRtZIZj4OPWro+TvPSZjoDrY0mSJEmSJEmSpM3IcAz8uw+bi8XR + 8e2lz3UkDq4kyXD4GpMkSZIkSZIkSdLNZjgGruX4rruKB+N99/Gpdi39fvgqkyRJkiRJkiRJ0s1kOAY+ + yQfNZvGLsYnSZzwSB5ezzPWxJEmSJEmSJEnSzWQ4Bq5H9/r4gXjffXxqqZZ+L3ytSZIkSZIkSZIkab0Z + joHrdWZhoXg68uvjfXm+LXy9SZIkSZIkSZIk6XozHAPrFfn18clOPftu+IqTJEmSJEmSJEnS9WQ4Bm5E + 9/r4qdG4r487Y2N3hK86SVK/tZQk31qq568BAAAAABsl++O/jS0bxnAM/e1Sa3fxf764s1hOyr8Deq1d + z17rpOndYWKQJPVTS0n+g7IvfwAAAAAgPoZjGAzvLSwUR0bHS78HYtCu53t+Mjz82TA1SJL6IcMxAAAA + AFSH4RgGx+VWqzi2Y2exXPJdEIkTS/X862FukCRVPcMxAAAAAFSH4RgGz3vz88WRRtzXxysjI66PJanq + GY4BAAAAoDoMxzCYKnB9/MdOkn8tTA+SpCpmOAYAAACA6jAcw2A7Pb9QPBH59fH+ev32MEFIkqqU4RgA + AAAAqsNwDMR/fZy/tpwkd4cZQpJUlQzHAAAAAFAdhmPgqu718eOj0V4fX+peH+/JMtfHklSVDMcAAAAA + UB2GY+DjLrV2X7k+Tsq/M3qtXc9ea6fpV8MkIUmKOcMxAAAAAFSH4Rgo8/bcfHE4Hyv93ojAxXYtu/+J + qanbwjQhSYoxwzEAAAAAVIfhGLiWf7RaxUtTO4pOkpd+f0Tg2P40/VKYJyRJsWU4BgAAAIDqMBwDn+bk + 7FzxSDZa+h3Sa+16dn6pnv7v0aGhW8NMIUmKJcMxAAAAAFSH4Ri4Hv+8Pi75HolD/ko7TVthqpAkxZDh + GAAAAACqw3AMrMdfZ+eKxxpxv/t4ZXrau48lKYYMxwAAAABQHYZjYL1ivz5u17OXD4xkzTBbSJJ6leEY + AAAAAKrDcAzcqO718aN5nO8+XrV2fbxnaLd3H0tSrzIcAwAAAEB1GI6Bm3Gx1SpevPOLpd8vcUh/uz9N + d4UJQ5K0lRmOAQAAAKA6DMfARvjzzGzxcBbt9fG5TpLduzI0dEuYMiRJW5HhGAAAAACqw3AMbJQLq98n + L0xOlX7XROI3y1nm+liStirDMQAAAABUh+EY2GiujyVJaxmOAQAAAKA6DMfAZriw2Ir9+vj5fcP5jjBt + SJI2I8MxAAAAAFSH4RjYTG+uXR83Sr9/IrB2fXyf62NJ2pw2azg+nI8VJ1f/BwwAAAAAsHEutcrHHoCN + cq7ZLJ6dmCz93/1HoZYf2feFRhZmDknSRrVZw/GTYxOl/wMHAAAAAACI3xszs8WheK+Pz7br6Q+LsHVI + kjYgwzEAAAAAAFCm+38e/7mIr4879ezpfWk6FiYPSdLNZDgGAAAAAAA+yYnpmeJgGu318fudWnqP62NJ + uskMxwAAAAAAwKc5t7gY97uPk+zJpTxvhPlDkrTeDMcAAAAAAMD1ivv6OF27Pg4TiCRpPRmOAQAAAACA + 9TjXbMZ9fVzLj+z7QiMLU4gk6XoyHAMAAAAAADeie328Eu+7j0+7PpakdWQ4BgAAAAAAbtSHzcXi6Pj2 + 0q0gEo8fGB51fSxJn5bhGAAAAAAAuFlr18dJXroZRKB7ffzfYRqRJJVlOAYAAAAAADbCB81m8Yu4r48P + LmfZcJhIJEkfz3AMAAAAAABspOO77ioejPfdx6c6tfT7YSaRJF3NcAwAAAAAAGy0tevjsYnSDSESB/fl + +bYwl0iSDMcAAAAAAMBm6V4fPxDvu49PtWvZ98JkIkmDneEYAAAAAADYTGcWFoqnI78+Xmk0XB9LGuwM + xwAAAAAAwFaI/Pr4ZLuefTfMJ5I0eBmOAQAAAACArXJmoVk8NRr39XFnbOyOMKNI0uBkOAYAAAAAALbS + 5VWv7txVLJfsC5E40all3whTiiQNRoZjAAAAAACgF95bWCiORHx93K7ne34yPPzZMKlIUn9nOAYAAAAA + AHrlcqtVHNuxM+br4z/ur+dfD7OKJPVvhmMAAAAAAKDXTs/PF080xks3hxh0r49XRkZcH0vq3wzHAAAA + AABADKpwfdxOGl8LE4sk9VeGYwAAAAAAICan5xeKx0fjvj7eX6/fHqYWSeqPDMcAAAAAAEBsLrV2X7k+ + Tsp3iN7LX+uk6d1hbpGk6mc4BgAAAAAAYvVu3NfHl1b9eO/ExGfC7CJJ1c1wDAAAAAAAxOwfrVbx0tSO + opPkpZtEBI4tJcmXwvQiSdXMcAwAAAAAAFTBW3PzxWP5WOkuEYGL7Vp2/xNTU7eFCUaSqpXhGAAAAAAA + qIoqXB/vT1PXx5Kql+EYAAAAAAComipcH69MT7s+llSdDMcAAAAAAEAV/fP6uGSniEP6SjtNW2GSkaS4 + MxwDAAAAAABV9tfZueLRfLR0r4iA62NJ1chwDAAAAAAAVN3FyK+P2/Xs5c5I3gzzjCTFl+EYAAAAAADo + F6fmIr8+TrIfrQwN3RJmGkmKJ8MxAAAAAADQTy4sLhYvTE6V7hdxSH+7nGW7wlQjSXFkOAYAAAAAAPrR + n2dmi4ezaK+Pz3WS7F7Xx5KiyXAMAAAAAAD0qwuLrcivj7PftLNsR5htJKl3GY4BAAAAAIB+92YFro/v + c30sqZcZjgEAAAAAgEFQgevj5zsjjakw4UjS1mY4BgAAAAAABkn3+vhQ1ijdNyLg+lhSbzIcAwAAAAAA + g+Z85NfH7ST7ddv1saStzHAMAAAAAAAMqhPTM8XBNNrr4/c7tfSeImw6krSpGY4BAAAAAIBBdm5xsXhu + +52le0cknjyQZY0w7UjS5mQ4BgAAAAAAcH0sacAzHAMAAAAAAFxxrtksnp2YLN0+opBkR5by3PWxpI3P + cAwAAAAAAPCv4r4+Tteuj8PUI0kbk+EYAAAAAADgP33YbBa/ivj6uF1PH9/3hUYWJh9JurkMxwAAAAAA + ANfWvT5eiffdx6ddH0vakAzHAAAAAAAAn+zD5mJxdHx76SYSicMHhkddH0u68QzHAAAAAAAA1+e1XdPF + g5FeH7fr2Vvd3SdMQJK0vgzHAAAAAAAA1++DZrP4xdhE6T4SiYPLWTYcpiBJur4MxwAAAAAAAOt3fNdd + xQNJXrqTRODUUi39XpiDJOnTMxwDAAAAAADcmO718dORXx/vy/NtYRaSpGtnOAYAAAAAALg5kV8fn+zU + s++GaUiSyjMcAwAAAAAA3LwzCwvFU2PbS3eTSBxcaTRcH0sqz3AMAAAAAACwcWK/Pl6uZ98JM5EkfZTh + GAAAAAAAYGOdWWgWT41G/O7jJG//ZHj4s2EukiTDMQAAAAAAwGa43GoVx3bsLJZLdpRInFiq518Pk5Gk + Qc9wDAAAAAAAsHnem58vjjTGS/eUGLTr+Z6VkRHXx9KgZzgGAAAAAADYXBW4Pv5jJ8m/FuYjSYOY4RgA + AAAAAGBrnJ6fL55wfSwpxgzHAAAAAAAAWyf+6+P8teUkuTtMSZIGJcMxAAAAAADA1js9v1A8Phr39fH+ + ev32MClJ6vcMxwAAAAAAAL1xqbX7yvVxUr639Fq7nr3WTtOvhllJUj9nOAYAAAAAAOitt+fmi8P5WOnm + EoFL7Vp2/xNTU7eFeUlSP2Y4BgAAAAAA6L1/tFrFS1M7ik6Sl24vETi2lCRfChOTpH7LcAwAAAAAABCP + t+bmi8fivT6+6PpY6tMMxwAAAAAAAHGJ//o4f6WTpq0wN0nqhwzHAAAAAAAAcfrr7FzxWCPu6+OV6WnX + x1I/ZDgGAAAAAACI1z+vj0v2mDikrxwYyZphepJU1QzHAAAAAAAA8eteHz+aj5buMhFYuz7eM7T71jBB + SapahmMAAAAAAIBquBj99XH2cmckd30sVTHDMQAAAAAAQLX8eWa2eCSL9vr4XCfJ7l0ZGrolzFGSqpDh + GAAAAAAAoHouLC4WL0xOle40kfjNcpbtCpOUpNgzHAMAAAAAAFRX9/r4YdfHkm42wzEAAAAAAEC1XVhs + RX99vG843xHmKUkxZjgGAAAAAADoD2/OzBQPZ43S7SYCa9fH97k+luLMcAwAAAAAANA/zsd/ffx8Z6Qx + FaYqSbFkOAYAAAAAAOg/b8zMFofivT4+6/pYiizDMQAAAAAAQH8632oVz8d9ffz0vjQdC7OVpF5mOAYA + AAAAAOhvJ6ZnioNptNfH73dq6T1F2K4k9SjDMQAAAAAAQP87t7hYPLf9ztJdJxJPHsiyRpiwJG11hmMA + AAAAAIDBEff1cbp2fRxmLElbmeEYAAAAAABgsJxrNotnJyZLN54oJNmRpTx3fSxtZYZjAAAAAACAwdS9 + Pl6J993Hp10fS1uY4RgAAAAAAGBwfdhsFr+K+Pq4XU8fPzA8moVpS9JmZTgGAAAAAABg7fo4yUt3nwi4 + PpY2O8MxAAAAAAAAXR80m8UvxreXbj+ROLiSJMNh5pK0kRmOAQAAAAAA+Ljju+4qHoz33cen2rX0+2Hq + krRRGY4BAAAAAAD4d2vXx2MTpTtQJA4uZ5nrY2mjMhwDAAAAAABwLd3r4wfifffxqaVa+r0we0m6mQzH + AAAAAAAAfJIzCwvF05FfH+/L821h/pJ0IxmOAQAAAAAAuB6RXx+f7NSz74YJTNJ6MxwDAAAAAABwvbrX + x0+Nxn193BkbuyNMYZKuN8MxAAAAAAAA63F5VezXx0v1/DthDpN0PRmOAQAAAAAAuBHvLSwUR0bHS7ei + GLTr+Z6fDA9/Nsxikj4pwzEAAAAAAAA36nKrVRzbsbNYLtmLInFiqZ5/PUxjkq6V4RgAAAAAAICb9d78 + fHGkEff18crIiOtj6VoZjgEAAAAAANgIFbg+/mMnyb8WZjJJH89wDAAAAAAAwEY6Pb9QPBH59fH+ev32 + MJdJ6mY4BgAAAAAAYKNdau2O/Po4f205Se4Ok5kkwzEAAAAAAACbpXt9/PhotNfHl7rXx3uyzPWxZDgG + AAAAAABgM3Wvj1/+4o6ik+Slu1IEXu0kjf8K85k0mBmOAQAAAAAA2Apvzc0Xh/Ox0m0pAhfbtez+J6am + bgszmjRYGY4BAAAAAADYKv9otYqXpqK+Pj62P02/FKY0aXAyHAMAAAAAALDVutfHj0V+fbwyPe36WIOT + 4RgAAAAAAIBe+Of1ccnWFIf8lXaatsKsJvV3hmMAAAAAAAB66a+zc8VjDdfHUk8zHAMAAAAAANBrsV8f + t+vZywdGsmaY2KT+y3AMAAAAAABALLrXx4/mo6X7UwTWro/3DO2+NUxtUv9kOAYAAAAAACAmF1ut4sU7 + v1i6QcUh/e3+NN0V5japPzIcAwAAAAAAEKM/z8wWD2fRXh+f6yTZvStDQ7eE2U2qdoZjAAAAAAAAYnVh + cbF4YXKqdI+KxG+Ws8z1saqf4RgAAAAAAIDYuT6WNjnDMQAAAAAAAFVwYbEV+/Xx8/uG8x1hhpOqleEY + AAAAAACAKnlz7fq4UbpRRWDt+vg+18eqWoZjAAAAAAAAquZ8Ba6P2yONqTDJSfFnOAYAAAAAAKCq3piZ + LQ7Fe318tl1Pf1iEXU6KOsMxAAAAAAAAVfb3xcXiuYnJ0s0qBp169vS+NB0L85wUZ4ZjAAAAAAAA+sGJ + 6ZniYBrt9fH7nVp6j+tjRZvhGAAAAAAAgH5xbnGxeDbi6+OlJHtyKc8bYaqT4slwDAAAAAAAQL+J+/o4 + Xbs+DnOdFEeGYwAAAAAAAPrRuWYz7uvjWn5k3xcaWZjtpN5mOAYAAAAAAKCfda+PV+J99/Fp18eKIsMx + AAAAAAAA/e7D5mJxdHx76a4ViccPDI+6PlbvMhwDAAAAAAAwKNauj5O8dN+KQPf6+L/DjCdtbYZjAAAA + AAAABskHzWbxi7ivjw8uZ9lwmPOkrclwDAAAAAAAwCA6vuuu4sF43318qlNLvx8mPWnzMxwDAAAAAAAw + qNauj8cmSveuSBzcl+fbwrQnbV6GYwAAAAAAAAZd9/r4gXjffXyqXcu+F+Y9aXMyHAMAAAAAAMDu4szC + QvF05NfHK42G62NtToZjAAAAAAAA+Ejk18cn2/Xsu2HqkzYuwzEAAAAAAAD8qzMLzeKp0bivjztjY3eE + yU+6+QzHAAAAAAAA8J8ur3p1565iuWQLi8SJTi37Rpj9pJvLcAwAAAAAAADX9t7CQnEk4uvjdj3f85Ph + 4c+G+U+6sQzHAAAAAAAA8Mkut1rFsR07Y74+/uP+ev71MAFK689wDAAAAAAAANfn9Px88URjvHQfi0H3 + +nhlZMT1sdaf4RgAAAAAAACuXxWuj9tJ42thDpSuL8MxAAAAAAAArN/p+YXi8dG4r4/31+u3h1lQ+uQM + xwAAAAAAAHBjLrV2X7k+Tso3s97LX+uk6d1hGpSuneEYAAAAAAAAbs67cV8fX1r1470TE58JE6H0nxmO + AQAAAAAA4Ob9o9UqXpraUXSSvHQ/i8CxpST5UpgJpX/NcAwAAAAAAAAb5625+eKxfKx0Q4vAxXYtu/+J + qanbwlwoXclwDAAAAAAAABurCtfH+9PU9bE+ynAMAAAAAAAAm6MK18cr09Ouj2U4BgAAAAAAgM30z+vj + kk0tDukr7TRthflQg5rhGAAAAAAAADbfX2fnikfz0dJtLQKujwc9wzEAAAAAAABsjYuRXx+369nLnZG8 + GaZEDVKGYwAAAAAAANhap+Yivz5Osh+tDA3dEiZFDUKGYwAAAAAAANh6FxYXixcmp0q3tjikv13Osl1h + VlS/ZzgGAAAAAACA3vnzzGzxcBbt9fG5TpLd6/p4ADIcAwAAAAAAQG9dWGxFfn2c/aadZTvCxKh+zHAM + AAAAAAAAcXizAtfH97k+7s8MxwAAAAAAABCP8/FfHz/fGWlMhblR/ZLhGAAAAAAAAOLTvT4+lDVKt7gI + uD7utwzHAAAAAAAAEKfYr4/bSfbrtuvj/shwDAAAAAAAAHE7MT1THEyjvT5+v1NL7ynC/qiKZjgGAAAA + AACA+J1bXCye235n6TYXiScPZFkjzJCqWoZjAAAAAAAAqA7Xx9qUDMcAAAAAAABQLeeazeLZicnSnS4K + SXZkKc9dH1cpwzEAAAAAAABUU9zXx+na9XGYJRV7hmMAAAAAAACorg+bzeJXEV8ft+vp4/u+0MjCPKlY + MxwDAAAAAABA9XWvj1fifffxadfHkWc4BgAAAAAAgP7wYXOxODq+vXS/i8Th9vB4EqZKxZThGAAAAAAA + APrLa7umiwcjvT5u17O3uhtlmCsVS4ZjAAAAAAAA6D8fNJvFL8YmSre8SBxczrLhMFuq1xmOAQAAAAAA + oH8d33VX8UCSl256ETi1VEu/F6ZL9TLDMQAAAAAAAPS37vXx05FfH+/L821hwlQvMhwDAAAAAADAYIj8 + +vhkp559N8yY2uoMxwAAAAAAADA4ziwsFE+NbS/d+CJxcKXRcH281RmOAQAAAAAAYPDEfn28XM++EyZN + bUWGYwAAAAAAABhMZxaaxVOjEb/7OMnbPxke/myYNrWZGY4BAAAAAABgcF1utYpjO3YWyyWbXyROLNXz + r4d5U5uV4RgAAAAAAAB4b36+ONIYL93+YtCu53tWRkZcH29WhmMAAAAAAACgqwLXx3/sJPnXwtSpjcxw + DAAAAAAAAHzc6fn54gnXx4OV4RgAAAAAAAD4d/FfH+evLSfJ3WH21M1mOAYAAAAAAACu5fT8QvH4aNzX + x/vr9dvD/KkbzXAMAAAAAAAAfJJLrd1Xro+T8m2w19r17LV2mn41TKC6kQzHAAAAAAAAwPV4e26+OJyP + le6DEbjUrmX3PzE1dVuYQrWeDMcAAAAAAADA9fpHq1W8NLWj6CR56U4YgWNLSfKlMIfqejMcAwAAAAAA + AOv11tx88Vi818cXXR+vM8MxAAAAAAAAcCPivz7OX+mkaStMo/qkDMcAAAAAAADAzfjr7FzxWCPu6+OV + 6WnXx5+U4RgAAAAAAAC4Wf+8Pi7ZDuOQvnJgJGuGmVT/nuEYAAAAAAAA2Cjd6+NH89HSDTECa9fHe4Z2 + 3xrmUl3NcAwAAAAAAABspIvRXx9nL3dGctfHH89wDAAAAAAAAGyGP8/MFo9k0V4fn+sk2b0rQ0O3hOl0 + sDMcAwAAAAAAAJvlwuJi8cLkVOmmGInfLGfZrjCfDm6GYwAAAAAAAGCzda+PH3Z9HG+GYwAAAAAAAGAr + XFhsRX99vG843xGm1MHKcAwAAAAAAABspTdnZoqHs0bpzhiBtevj+wbt+thwDAAAAAAAAGy18/FfHz/f + GWlMhVm1/zMcAwAAAAAAAL3yxsxscSje6+OzA3N9bDgGAAAAAAAAeul8q1U8H/f18dP70nQsTKz9meEY + AAAAAAAAiMGJ6ZniYBrt9fH7nVp6TxF21r7LcAwAAAAAAADE4tziYvHsxGTpBhmFJHvyQJY1wtzaPxmO + AQAAAAAAgNjEfX2crl0fh8m1PzIcAwAAAAAAADE612zGfn18ZN8XGlmYXqud4RgAAAAAAACIWff6eCXe + dx+f7ovrY8MxAAAAAAAAELsPm83iVxFfH7fr6eMHhkere31sOAYAAAAAAACqYu36OMlLN8oInG7X8v8J + U2y1MhwDAAAAAAAAVfJBs1n8Ynx76U4ZiYMrSTIcJtlqZDgGAAAAAAAAquj4rruKB+N99/Gpdi39fphl + 489wDAAAAAAAAFTV2vXx2ETpZhmJg8tZFv/1seEYAAAAAAAAqLru9fED8b77+NRSLf1emGjjzHAMAAAA + AAAA9IMzCwvF05FfH+/L821hqo0rwzEAAAAAAADQTyK/Pj7ZrmffDXNtPBmOAQAAAAAAgH7TvT5+ajTu + 6+PO2NgdYbbtfYZjAAAAAAAAoB9dXhX79fFSPf9OmG57m+EYAAAAAAAA6GfvLSwUR0bHS3fNGLTr+Z6f + DA9/Nky4vclwDAAAAAAAAPS7y61WcWzHzmK5ZNuMxImlev71MONufYZjAAAAAAAAYFC8Nz9fHGnEfX28 + MjKy9dfHhmMAAAAAAABgkFTg+viPnST/Wph0tybDMQAAAAAAADCITs8vFE9Efn28v16/PUy7m5vhGAAA + AAAAABhUl1q7I78+zl9bTpK7w7y7eRmOAQAAAAAAgEHXvT5+fDTa6+NL3evjPVm2edfHhmMAAAAAAACA + K9fHL39xR9FJ8tINNAKvdpLGf4Wpd2MzHAMAAAAAAAB85K25+eJwPla6g0bgYruW3f/E1NRtYfLdmAzH + AAAAAAAAAP/qH61W8dJU1NfHx/an6ZfC7HvzGY4BAAAAAAAAynWvjx+L/Pp4ZXr65q+PDccAAAAAAAAA + 13ZhcbF4YXKqdBeNQ/rb/Wm6K0zAN5bhGAAAAAAAAODT/XV2rnis0afXx4ZjAAAAAAAAgOvzz3cfl2yk + MWjXs5c7I3kzzMHXn+EYAAAAAAAAYH2618eP5qOlW2kEznWS7N6VoaFbwiz86RmOAQAAAAAAANbvYqtV + vHjnF0v30kj8ZjnLru/dx4ZjAAAAAAAAgBv355nZ4uEs7uvj+z7t+thwDAAAAAAAAHBzLiwuFi9MTpVu + p5F4vjPSmAoz8X9mOAYAAAAAAADYGJFfH5+95vWx4RgAAAAAAABg41xYbMV+ffz0vjQdC5PxlQzHAAAA + AAAAABvv/5ueKQ6mjdI9NQLvtOvZ/xNmY8MxAAAAAAAAwGaIfDg+s5Rk/28RdmPDMQAAAAAAAMAGOtts + Fr8c3166o0bi0fbweBIm4ysZjgEAAAAAAAA2xvFddxUPpnnphhqB050k/0GYiv81wzEAAAAAAADAzfmw + uRj7lfHh/7gy/niGYwAAAAAAAIAb170yXon3yvhMp5be8893GV8rwzEAAAAAAADA+v19cbF4bmKydC+N + xNOdNB0L0/AnZzgGAAAAAAAAWJ8Td00XB9NG6VYageu7Mv54hmMAAAAAAACA6xP7lXGnnj1zIEkmwhx8 + /RmOAQAAAAAAAD7dn6Znioey0dJ9NALrvzL+eIZjAAAAAAAAgGu7sLhYvDA5VbqLxiH97f403RUm4BvL + cAwAAAAAAABQ7vXpmeJQvFfGZ2/qyvjjGY4BAAAAAAAA/tX5yN9l3K7nz3Zqtckw+958hmMAAAAAAACA + j7wxM1scyhqlO2gE1q6M7xsauiVMvhuT4RgAAAAAAADgyruMn+/3dxlfK8MxAAAAAAAAMOhOzs4Vj0T6 + LuN2PTvfSbJ7jw4N3Rpm3o3PcAwAAAAAAAAMqoutVvFCxFfGnXr24nKSTId5d/MyHAMAAAAAAACD6C8R + Xxmv2vwr449nOAYAAAAAAAAGSexXxku17Hf76/XZMOluTYZjAAAAAAAAYFCcmp0tfpqPlW6cEdjaK+OP + ZzgGAAAAAAAA+l3sV8btJPv9cq0xH2bcrc9wDAAAAAAAAPSzU3NzxU/zaN9lfLF7ZbxnaPfWXxl/PMMx + AAAAAAAA0I8urXppakfRSfLSTTMCr3aSxn+F6ba3GY4BAAAAAACAfvP23FxxuDFeumVG4FK7lt2/d2Li + M2G27X2GYwAAAAAAAKBfVOHKeKmefznMtfFkOAYAAAAAAAD6wTvz88XPIr8yXmk04rky/niGYwAAAAAA + AKDKYr8y7iTZH9q17Cthoo0zwzEAAAAAAABQVe/Oda+Mx0o3ywjEfWX88QzHAAAAAAAAQNVcal25Ml5O + yvfKCBxfHkm/GmbZ+DMcAwAAAAAAAFXy7vxC8Xi8V8ZdP96TZbeHSbYaGY4BAAAAAACAKrjcahXHduws + DkT6LuNVJ9q17Bthiq1WhmMAAAAAAAAgdu8vLBQ/Hx0v3SZj0K7ne5a2bftcmGGrl+EYAAAAAAAAiFX0 + V8a17PVOLf1mmF+rm+EYAAAAAAAAiNH78/FfGa98frK6V8Yfz3AMAAAAAAAAxOTyqsjfZfzmUpJ8K0yu + /ZHhGAAAAAAAAIjF3xaaa1tj2QYZg+6V8d47Ju4Ic2v/ZDgGAAAAAAAAeu3qlfEDEV8Zt5P822Fm7b8M + xwAAAAAAAEAvfdBsFs+Mby/dHaOQ5O3O2Fj/XRl/PMMxAAAAAAAA0CvHd91VPJg2SjfHCLzVSfIfhGm1 + vzMcAwAAAAAAAFvtbPxXxof21+u1MKv2f4ZjAAAAAAAAYCtduTKO9l3G7wzMlfHHMxwDAAAAAAAAW+Fs + c7H45fhk6b4Yg049e2S5VhucK+OPZzgGAAAAAAAANlv3ynjFlXG8GY4BAAAAAACAzfJhc7E4GvO7jOvZ + o3tHRpIwnw5uhmMAAAAAAABgM7y2a7pYSaK9Mj498FfGH89wDAAAAAAAAGykvy8uFs9NxPsu41VP70vT + sTCZqpvhGAAAAAAAANgoJ+6aLh5KG6UbYgTOdGrpPUXYSvWxDMcAAAAAAADAzYr9yrhTz545kCQTYSbV + v2c4BgAAAAAAAG7Gn6Znioey0dLdMAKujK8nwzEAAAAAAABwI85H/y7j9Oj+et2V8fVkOAYAAAAAAADW + 6/XpmeJQvFfGZ10ZrzPDMQAAAAAAAHC9zrdacV8Z17JnO7XaZJhDdb0ZjgEAAAAAAIDr8cbMbHEoa5Tu + gxE4166nP7xvaOiWMIVqPRmOAQAAAAAAgE9yYXGxeGFyqnQXjEP+4lKSTIcJVDeS4RgAAAAAAAC4lpOz + c8Ujkb7LuF3PzneS7N6jQ0O3hvlTN5rhGAAAAAAAAPh3F1utqK+MO/XsxWVXxhuX4RgAAAAAAAD4uL/M + zhU/zcdKd8AIuDLejAzHAAAAAAAAQFfsV8ZLtex3S/XGbJg6tZEZjgEAAAAAAIBTc/FfGe8Z2u3KeLMy + HAMAAAAAAMDgunpl3CnZ/CLx++VaYz7Mm9qsDMcAAAAAAAAwmN6emy8Ox3tlfKmdZD9yZbxFGY4BAAAA + AABgsFxa9dLUjqKT5KVbXwRe3V9v/FeYNLUVGY4BAAAAAABgcLw9P18cboyXbnwRuNSuZffvnZj4TJgz + tVUZjgEAAAAAAKD/RX9lXMv+sFzLvxxmTG11hmMAAAAAAADob+/Mzxc/a0T8LuNadv9Ko+HKuJcZjgEA + AAAAAKA/VeBdxsfbtewrYbpULzMcAwAAAAAAQP95d86VsdaR4RgAAAAAAAD6x6XWlSvj5aR8x4vA8eWR + 9KthrlQsGY4BAAAAAACgP7y3sFAcGR0v3e9i0K7ne5a2bftcmCoVU4ZjAAAAAAAAqLbLrVZxbMfO4kC8 + 7zJ+famWfTNMlIoxwzEAAAAAAABU1/sLC8XPXRnrZjMcAwAAAAAAQPVcXhX1lXEte709kn4rzJKKPcMx + AAAAAAAAVMv78wtre1zZTheD7pXxyucnXRlXKcMxAAAAAAAAVEP0V8b17M1O0vh2mCJVpQzHAAAAAAAA + EL+/LTSjvzLee8fEHWGGVNUyHAMAAAAAAEDcXt25q3gg3ivjk0v1/DthflRVMxwDAAAAAABAnD5oNotn + xreX7nFRqKUHV5JkOEyPqnKGYwAAAAAAAIjP8V13FQ+mjdItLgJvdZL8B2FyVD9kOAYAAAAAAIB4nI39 + yriePbK/Xq+FuVH9kuEYAAAAAAAA4nDlyjjadxm/48q4jzMcAwAAAAAAQG+dbS4WvxyfLN3dIvHo3pGR + JEyM6scMxwAAAAAAANA73SvjFVfG6nWGYwAAAAAAANh6HzYXi6MRv8u4Xc8Ot4fHXRkPSoZjAAAAAAAA + 2FonpmeKg2mjdGeLwJl2Lf+fMCdqUDIcAwAAAAAAwNb4++Ji8dxE1O8yfqaTpmNhStQgZTgGAAAAAACA + zfen6ZnioYivjDu19J4ibIgawAzHAAAAAAAAsHkqcGV89ECSTIT5UIOa4RgAAAAAAAA2x9qVcTZauqdF + wJWxPspwDAAAAAAAABvrfORXxu16/mynVpsMk6FkOAYAAAAAAICN9MbMbHEo3ivjs66MVZrhGAAAAAAA + AG7e+VYr7ncZ17JfP1AbdWWs8gzHAAAAAAAAcHNOzswWj0R6ZdyuZ+c7SXbvytDQLWEilP4zwzEAAAAA + AADcmAuLi8ULk1Ole1kc8heXkmQ6TIPStTMcAwAAAAAAwPqdnJ2L/sr46NDQrWEWlD45wzEAAAAAAABc + v4utVtxXxrXsd/vr9dkwB0rXl+EYAAAAAAAArs9fZueKn+ZjpftYBFwZ68YzHAMAAAAAAMAni/3KuJ1k + v1+uNebDBCitP8MxAAAAAAAAXNupue6VcZzvMl51sXtlvGdotytj3VyGYwAAAAAAAPhPl1a9eOcXi07J + FhaJl9u13JWxNibDMQAAAAAAAPyrt+fmisPxvsv4UruW3b93YuIzYfKTbj7DMQAAAAAAAFzRvTJ+aWpH + 0Uny0g0sAq8u1fMvh6lP2rgMxwAAAAAAALC7eGd+vjjcGC/dviLgylibm+EYAAAAAACAQRb7lXEnyf6w + XHNlrE3OcAwAAAAAAMCg6l4Z/6wR97uMVxoNV8ba/AzHAAAAAAAADJpLrStXxstJ+dYVgeNLtewrYdKT + Nj/DMQAAAAAAAIPk3bn54vHIr4z3ZNntYc6TtibDMQAAAAAAAIPgcqtVHNuxszgQ6buMV53o1LJvhBlP + 2toMxwAAAAAAAPS79xcWip+PjpfuWjFo1/M9S9u2fS5MeNLWZzgGAAAAAACgX1Xgyvj1Ti39ZpjupN5l + OAYAAAAAAKAfVeHKeOXzk66MFUeGYwAAAAAAAPrJ5VWRXxm/2R5JvxXmOimODMcAAAAAAAD0i78tNNd2 + qrL9KgbdK+O9d0zcEaY6KZ4MxwAAAAAAAFTd1SvjByK+Mu4kjW+HiU6KL8MxAAAAAAAAVda9Mn5qNN4r + 46Ukb7syVvQZjgEAAAAAAKiq47vuKh5MG6V7Va+169lbnST/QZjlpLgzHAMAAAAAAFA1Z5vN4pnx7aU7 + VQw6SX5of71eC5OcFH+GYwAAAAAAAKrkypVxtO8ydmWsamY4BgAAAAAAoAq6V8a/jPjKeNUjy7WaK2NV + M8MxAAAAAAAAsYv8yvgdV8aqfIZjAAAAAAAAYvVhczH2K+NH946MJGF6k6qb4RgAAAAAAIAYda+MV+K9 + Mj7tylh9leEYAAAAAACAmPx9cbF4bmKydIOKxOH28LgrY/VXhmMAAAAAAABiceKu6eKhtFG6P0XgTKeW + 3lOEnU3qqwzHAAAAAAAA9FoFroyf6aTpWJjYpP7LcAwAAAAAAEAv/Wl6pngoGy3dnCLgyliDkeEYAAAA + AACAXqjAlfHR/fX6RJjVpP7OcAwAAAAAAMBWe316pjgU75XxWVfGGrgMxwAAAAAAAGyV85FfGbfr+bOd + Wm0yTGnS4GQ4BgAAAAAAYCu8MTNbHMoapdtSBNaujO8bGrolzGjSYGU4BgAAAAAAYDNdWFwsnp+cKt2U + 4pD+dn+a7grzmTSYGY4BAAAAAADYLCdn54pHIn2Xcbuene8k2b1Hh4ZuDdOZNLgZjgEAAAAAANhoF1ut + 4oWIr4w79ezF5SSZDpOZJMMxAAAAAAAAG+kvEV8Zr3JlLJVlOAYAAAAAAGAjxH5lvFTLfre/Xp8NM5mk + j2c4BgAAAAAA4Gadmp0tfpqPle5GEXBlLH1ahmMAAAAAAABuVOxXxu0k+/1yrTEfpjFJ18pwDAAAAAAA + wI04NTdX/DSP9l3GF7tXxnuGdrsylq4nwzEAAAAAAADrcWnVS1M7ik6Sl+5EEXi1kzT+K8xhkq4nwzEA + AAAAAADX6+25ueJwY7x0H4rApXYtu3/vxMRnwhQm6XozHAMAAAAAAPBpor8yrmV/WKrnXw4TmKT1ZjgG + AAAAAADgk7wzP1/8LPIr45VGw5WxdDMZjgEAAAAAACgT+5VxJ8n+0K5lXwmzl6SbyXAMAAAAAADAv3t3 + rntlPFa6A0XAlbG00RmOAQAAAAAAuOpS68qV8XJSvgFF4PjySPrVMHVJ2qgMxwAAAAAAAHS9O79QPB7v + lXHXj/dk2e1h5pK0kRmOAQAAAAAABtvlVqs4tmNncSDSdxmvOtGuZd8I85akzchwDAAAAAAAMLjeX1go + fj46Xrr3xKBdz/csbdv2uTBtSdqsDMcAAAAAAACDJ/or41r2eqeWfjNMWpI2O8MxAAAAAADAYHl/Pv4r + 45XPT7oylrYywzEAAAAAAMBguLwq8ncZv7mUJN8KM5akrcxwDAAAAAAA0P/+ttBc22/Kdp0YdK+M994x + cUeYsCRtdYZjAAAAAACA/nX1yviBiK+M20n+7TBdSepVhmMAAAAAAID+9EGzWTwzvr10y4lCLT24kiTD + YbaS1MsMxwAAAAAAAP3n+K67igfTRumOE4G3Okn+gzBXSYohwzEAAAAAAED/OBv7lXGSH9pfr9fCVCUp + lgzHAAAAAAAA/eHKlXG07zJ+x5WxFHGGYwAAAAAAgGo721wsfjk+WbrZxKBTzx5ZrtVcGUsxZzgGAAAA + AACoru6V8YorY0k3m+EYAAAAAACgej5sLhZHY36XcT17dO/ISBImKUmxZzgGAAAAAAColv/bvTJOor0y + Pu3KWKpghmMAAAAAAIBq+PviYvHcRLzvMl719L40HQszlKQqZTgGAAAAAACI34m7pouH0kbpLhOBM51a + ek8R9idJFcxwDAAAAAAAEK/Yr4w79eyZA0kyEaYnSVXNcAwAAAAAABCnP03PFA9lo6VbTARcGUv9lOEY + AAAAAAAgLuejf5dxenR/ve7KWOqnDMcAAAAAAADxeH16pjgU75XxWVfGUp9mOAYAAAAAAOi9861W3FfG + tezZTq02GSYmSf2W4RgAAAAAAKC33piZLQ5ljdLNJQLn2vX0h/cNDd0S5iVJ/ZjhGAAAAAAAoDcuLC4W + L0xOlW4tcchfXEqS6TArSernDMcAAAAAAABb7+TsXPFIpO8ybtez850ku/fo0NCtYVKS1O8ZjgEAAAAA + ALbOxVYr6ivjTj17cdmVsTR4GY4BAAAAAAC2xl9m54qf5mOl20oEXBlLg5zhGAAAAAAAYHPFfmW8VMt+ + t1RvzIb5SNIgZjgGAAAAAADYPKfm4r8y3jO025WxNOgZjgEAAAAAADbe1SvjTsmOEonfL9ca82EykjTo + GY4BAAAAAAA21ttz88XheK+ML7WT7EeujCX9S4ZjAAAAAACAjXFp1UtTO4pOkpfuJxF4dX+98V9hJpKk + jzIcAwAAAAAA3Ly35+eLw43x0t0kApfatez+vRMTnwkTkST9a4ZjAAAAAACAGxf9lXEt+8NyLf9ymIYk + qTzDMQAAAAAAwI15Z36++Fkj4ncZ17L7VxoNV8aSPj3DMQAAAAAAwPpU4F3Gx9u17CthDpKkT89wDAAA + AAAAcP3enXNlLKkPMxwDAAAAAAB8ukutK1fGy0n5NhKB48sj6VfDBCRJ68twDAAAAAAA8MneW1gojoyO + l24iMWjX8z1L27Z9Lsw/krT+DMcAAAAAAADlLrdaxbEdO4sD8b7L+PWlWvbNMPtI0o1nOAYAAAAAAPhP + 7y8sFD93ZSxpUDIcAwAAAAAAfOTyqqivjGvZ6+2R9Fth6pGkjclwDAAAAAAAcMX78wtrG0fZ9hGD7pXx + yucnXRlL2vgMxwAAAAAAwKCL/sq4nr3ZSRrfDvOOJG18hmMAAAAAAGCQ/W2hGf2V8d47Ju4I044kbU6G + YwAAAAAAYFC9unNX8UCkV8btevZWd8cJk44kbW6GYwAAAAAAYNB80GwWz4xvL904olBLD64kyXCYcyRp + 8zMcAwAAAAAAg+T4rruKB9NG6b4Rgbc6rowl9SLDMQAAAAAAMAjOxn5lXM8eWa7VamHCkaStzXAMAAAA + AAD0uytXxnG+y3jVO66MJfU8wzEAAAAAANCvzjYXi1+OT5ZuGZF4dO/ISBJmG0nqXYZjAAAAAACgH3Wv + jFdcGUvS9WU4BgAAAAAA+smHzcXiaMTvMm7Xs8Pt4XFXxpLiynAMAAAAAAD0ixPTM8XBtFG6XUTgTLuW + /0+YaCQprgzHAAAAAABA1f19cbF4biLqdxk/00nTsTDPSFJ8GY4BAAAAAIAq+9P0TPFQxFfGnVp6TxF2 + GUmKNsMxAAAAAABQRRW4Mj56IEkmwiQjSXFnOAYAAAAAAKpm7co4Gy3dKCLgylhS9TIcAwAAAAAAVXE+ + 8ivjdj1/tlOrTYYZRpKqk+EYAAAAAACogjdmZotDWbTvMj7rylhSpTMcAwAAAAAAMTvfasX9LuNa9usH + aqOujCVVO8MxAAAAAAAQq5Mzs8Ujkb7LuF3PzneS7N6VoaFbwuwiSdXNcAwAAAAAAMTmwuJi8cLkVOkG + EYf8xaUkmQ5ziyRVP8MxAAAAAAAQk5Ozc9FfGR8dGro1TC2S1B8ZjgEAAAAAgBhcbLXivjKuZb/bX6/P + holFkvorwzEAAAAAANBrf5mdK36aj5VuDhFwZSyp/zMcAwAAAAAAvRL7lXE7yX6/XGvMh1lFkvo3wzEA + AAAAANALp+a6V8Zxvst41cXulfGeod2ujCUNRoZjAAAAAABgK11a9eKdXyw6JftCJF5u13JXxpIGK8Mx + AAAAAACwVd6emysOx/su40vtWnb/3omJz4QZRZIGJ8MxAAAAAACw2bpXxi9N7Sg6SV66K0Tg1aV6/uUw + n0jS4GU4BgAAAAAANtM78/PFzxrjpXtCBFwZS1I3wzEAAAAAALAZYr8y7iTZH5ZrrowlaS3DMQAAAAAA + sNHeneteGcf9LuOVRsOVsSRdzXAMAAAAAABslEutK1fGy0n5fhCB40u17CthJpEkXc1wDAAAAAAAbITu + lfHjkV8Z78my28NEIkn6eIZjAAAAAADgZlxutYpjO3YWByJ9l/GqE51a9o0wjUiSyjIcAwAAAAAAN+r9 + hYXi56PjpVtBDNr1fM/Stm2fC7OIJOlaGY4BAAAAAID1qsCV8eudWvrNMIdIkj4twzEAAAAAALAeVbgy + Xvn8pCtjSVpPhmMAAAAAAOB6XF4V+ZXxm+2R9FthApEkrSfDMQAAAAAA8Gn+ttBc+9/9l20CMeheGe+9 + Y+KOMH9Iktab4RgAAAAAALiWq1fGD0R8ZdxJGt8Os4ck6UYzHAMAAAAAAGW6V8ZPjcZ7ZbyU5G1XxpK0 + QRmOAQAAAACAf3d8113Fg2mjdAPotXY9e6uT5D8IU4ckaSParOH4sXysODE9AwAAAABsoEsl4w7ARjrX + bBbPTkyW/u/+o1DLj+z7QiMLM4ckaaParOEYAAAAANh4f19cLB16ADbClSvjaN9l7MpYkjYzwzEAAAAA + VIfhGNgMZ5vN4pfj20u/dyLxyHKtVgvThiRpMzIcAwAAAEB1GI6BjRb5lfE7rowlaYsyHAMAAABAdRiO + gY3yYXMx9ivjR/eOjCRhzpAkbXaGYwAAAACoDsMxsBG6V8Yr8V4Zn3ZlLEk9yHAMAAAAANVhOAZuRvc7 + 5LmJydLvl0gcbg+PuzKWpF5kOAYAAACA6jAcAzfqxF3TxUNpo/S7JQJnOrX0niJsF5KkHmQ4BgAAAIDq + MBwD61WBK+NnOmk6FmYLSVKvMhwDAAAAQHUYjoH1+NP0TPFQNlr6fRIBV8aSFFOGYwAAAACoDsMxcD0q + cGV8dH+9PhGmCklSDBmOAQAAAKA6DMfApzk5O1c8EumVcbuenV+qp/97dGjo1jBTSJJiyXAMAAAAANVh + OAau5XzsV8a17NlOrTYZ5glJUmwZjgEAAACgOgzHQJk3ZmaLQ1mj9HsjAme77zK+b2joljBNSJJizHAM + AAAAANVhOAY+7sLqd8Lzk1Ol3xdxSH+7P013hUlCkhRzhmMAAAAAqA7DMXDVycjfZdxJsnu9y1iSKpTh + GAAAAACqw3AMXGy1ihcivjLu1LMXl5NkOswQkqSqZDgGAAAAgOowHMNg+0vEV8arXBlLUpUzHAMAAABA + dRiOYTDFfmW8VMt+t79enw3TgySpihmOAQAAAKA6DMcweE7NzhY/zcdKvxMi4MpYkvolwzEAAAAAVIfh + GAZH7FfG7ST7/XKtMR/mBklS1TMcAwAAAEB1GI5hMJyamyt+mkf7LuOL3SvjPUO7XRlLUj+1VM+/3n33 + AAAAAACwgcrHlptmOIb+dqm1u/g/X9xZLCfl3wG91q5nr3XS9O4wMUiSJEmSJEmSJOlarUxP31Y2uGwE + wzH0r7fn54vDjfHSZz8Cl9q17P69ExOfCV91kiRJkiRJkiRJ+qQMx8B6XFr10tSOopPkpc99z9WyPyzV + 8y+HrzhJkiRJkiRJkiRdT4Zj4Hq9Mz9f/CzyK+OVRsOVsSRJkiRJkiRJ0nozHAOfJvYr406S/aFdy74S + vtYkSZIkSZIkSZK03gzHwCd5d657ZTxW+oxHwJWxJEmSJEmSJEnSRmQ4Bspcal25Ml5Oyp/vCBxfHkm/ + Gr7KJEmSJEmSJEmSdDMZjoF/997CQnFkNNp3GXf9eE+W3R6+xiRJkiRJkiRJknSzGY6Bqy63WsWxHTuL + A5G+y3jViXYt+0b4+pIkSZIkSZIkSdJGZTgGut5fWCh+HvGVcbue71natu1z4atLkiRJkiRJkiRJG5nh + GAZb9FfGtez1Ti39ZvjKkiRJkiRJkiRJ0mZkOIbB9f78QvHk2ETp8xuD7pXxyucnXRlLkiRJkiRJkiRt + doZjGDyXV0X+LuM3l5LkW+FrSpIkSZIkSZIkSZud4RgGy98WmtFfGe+9Y+KO8BUlSZIkSZIkSZKkrchw + DIPh6pXxAxFfGbeT/Nvhq0mSJEmSJEmSJElbmeEY+t8HzWbxzPj20uc0CrX04EqSDIevJUmSJEmSJEmS + JG11hmPob8d33VU8mDZKn9EIvNVJ8h+EryNJkiRJkiRJkiT1KsMx9KezsV8ZJ/mh/fV6LXwVSZIkSZIk + SZIkqZcZjqH/XLkyjvZdxu+4MpYkSZIkSZIkSYoswzH0j7PNxeKX45Olz2MMOvXskeVazZWxJEmSJEmS + JElSbBmOoT90r4xXXBlLkiRJkiRJkiTpRjIcQ7V92Fwsjsb8LuN69ujekZEkfOVIkiRJkiRJkiQpxgzH + UF3/t3tlnER7ZXzalbEkSZIkSZIkSVJFMhxD9XSfrecm4n2X8aqn96XpWPiakSRJkiRJkiRJUuwZjqFa + Ttw1XTyUNkqfuQic6dTSe4rw/SJJkiRJkiRJkqSKZDiGaoj9yrhTz545kCQT4atFkiRJkiRJkiRJVcpw + DPH70/RM8VA2WvqcRcCVsSRJkiRJkiRJUtUzHEO8zkd+ZbxUT4/ur9ddGUuSJEmSJEmSJFU9wzHE6fXp + meJQvFfGZ10ZS5IkSZIkSZIk9VGGY4jL+VYr7ivjWvbsA7XRyfAVIkmSJEmSJEmSpH7IcAzxeGNmtjiU + NUqfpwica9fTH943NHRL+PqQJEmSJEmSJElSv2Q4ht67sPqsvDA5VfocxSF/cSlJpsPXhiRJkiRJkiRJ + kvotwzH01snZueKRSN9l3K5n5ztJdu/RoaFbw1eGJEmSJEmSJEmS+jHDMfTGxVYr6ivjTj17cdmVsSRJ + kiRJkiRJ0mBkOIat95fZueKn+VjpcxMBV8aSJEmSJEmSJEmDluEYtk7sV8ZLtex3S/XGbPh6kCRJkiRJ + kiRJ0qBkOIatcWou/ivjPUO7XRlLkiRJkiRJkiQNYoZj2FxXr4w7Jc9IJH6/XGvMh68ESZIkSZIkSZIk + DWKGY9g8b8/NF4fjvTK+1E6yH7kyliRJkiRJkiRJkuEYNsGlVS9N7Sg6SV76bETg1f31xn+FrwFJkiRJ + kiRJkiQNeoZj2Fhvz88Xhxvjpc9EBC61a9n9eycmPhO+AiRJkiRJkiRJkiTDMWyU6K+Ma9kflmv5l8Oj + L0mSJEmSJEmSJH2U4Rhu3jvz88XPGhG/y7iW3b/SaLgyliRJkiRJkiRJUnmGY7hxV6+Ml5PyZyACx9u1 + 7CvhcZckSZIkSZIkSZLKMxzDjXl3Lv4r4z1Zdnt41CVJkiRJkiRJkqRrZziG9bncahUvfzHuK+PlkfSr + 4RGXJEmSJEmSJEmSPj3DMVy/9xYWip+Pjpd+3mPQrud7lrZt+1x4vCVJkiRJkiRJkqTry3AMn657ZXxs + x87iQJKXftYj8PpSLftmeKwlSZIkSZIkSZKk9WU4hk/2vitjSZIkSZIkSZIk9XuGYyh3eVXUV8a17PX2 + SPqt8ChLkiRJkiRJkiRJN57hGP7T+/MLxZNjE6Wf6xh0r4xXPj/pyliSJEmSJEmSJEkbk+EYPhL9lXE9 + e7OTNL4dHl9JkiRJkiRJkiRpYzIcwxV/W2hGf2W8946JO8KjK0mSJEmSJEmSJG1chmPYXby6c1fxQKRX + xu169tZSkv8gPLKSJEmSJEmSJEnSxmc4ZpCdbTaLZ8a3l35+o1BLD64kyXB4XCVJkiRJkiRJkqTNyXDM + oDq+667iwbRR+tmNwFsdV8aSJEmSJEmSJEnaqgzHDJror4zr2SPLtVotPKKSJEmSJEmSJEnS5mc4ZpBc + uTKO813Gq95xZSxJkiRJkiRJkqSeZDhmEJxtLha/jPvK+NG9IyNJeCwlSZIkSZIkSZKkrc1wTL/rXhmv + uDKWJEmSJEmSJEmSrp3hmH71YXOxOBrxlXG7nh1uD4+7MpYkSZIkSZIkSVLvMxzTj05MzxQH00bp5zIC + Z9q1/H/CIyhJkiRJkiRJkiT1PsMx/aT7mXtuYrL08xiJZzppOhYeP0mSJEmSJEmSJCmODMf0iz9NzxQP + RXxl3Kml9xThuZMkSZIkSZIkSZKiynBM1VXgyvjogSSZCI+cJEmSJEmSJEmSFF+GY6ps7co4Gy39/EXA + lbEkSZIkSZIkSZKqkeGYKjof+ZVxu54/26nVJsNjJkmSJEmSJEmSJMWd4ZiqeWNmtjiURfsu47OujCVJ + kiRJkiRJklS5DMdUxflWK+53GdeyXz9QG3VlLEmSJEmSJEmSpOplOKYKTs7MFo9E+i7jdj0730mye1eG + hm4Jj5UkSZIkSZIkSZJUrQzHxOzC6mfohcmp0s9XHPIXl5JkOjxOkiRJkiRJkiRJUjUzHBOrk7Nz0V8Z + Hx0aujU8SpIkSZIkSZIkSVJ1MxwTm4utVtxXxrXsd/vr9dnwCEmSJEmSJEmSJEnVz3BMTP4yO1f8NB8r + /TxFwJWxJEmSJEmSJEmS+jPDMTGI/cq4nWS/X6415sNjI0mSJEmSJEmSJPVXhmN67dRc98o4zncZr7rY + vTLeM7TblbEkSZIkSZIkSZL6N8MxvXJp1Yt3frHolHx2IvFyu5a7MpYkSZIkSZIkSVL/ZzimF96emysO + x/su40vtWnb/3omJz4THRJIkSZIkSZIkServDMdspe6V8UtTO4pOkv//7d1PiFz1AQfwQTyIB1mD+96b + N5Pd6WKjJvvPFYpIjyLi2WPp0WOP0pv06LHHPS3dmTfR1RAllmpLGmwptIhKDxJCoGBTsRKjjTYtqSSv + O+YXlPqaP5udmd+b9/nA9xDYnZ333i+nL19e5ZmJIKcHaefx8N8DAAAAAAAAmkFxLJPKhdXV8o3uYuVZ + iSBWxgAAAAAAADSX4ljGndhXxkWWnxkmVsYAAAAAAAA0mOJYxpnPVkYr47jfZbzT7VoZAwAAAAAA0GyK + YxlHrmxcWxkPs+qzEUHODpL8ifDfAAAAAAAAAJpNcSz7ndHK+JeRr4w38/ze8F8AAAAAAAAAUBzLfuXq + xkb5waGHyqORvst4Nx8WSf5kOPoAAAAAAADAdYpj2Y9cXFsr3zy4WHkOYkg/7WwODhy4Lxx7AAAAAAAA + 4NsUx3InqcHK+FyRtJ8Kxx0AAAAAAACoojiWvaYOK+Od+5esjAEAAAAAAOBmFMdyu7m6m8hXxh8Nsuzp + cMQBAAAAAACAm1Ecy+3ki7X18q2FXuXzjiGjlfHWXG8uHG8AAAAAAADgViiO5VZyfWX8UsQr4yLrPhOO + NQAAAAAAAHA7FMdys4xWxr8+GO/KeJB1+sXCgpUxAAAAAAAA7JXiWG6Usw8/Ur7c7lY+32mnn+bni6zz + bDjKAAAAAAAAwF4pjqUql9bXy5OL36t8rjGkyDrHttM0CccYAAAAAAAAuBOKY/nfXFsZR/suYytjAAAA + AAAA2G+KY7me0cr4txGvjHdzfJgkVsYAAAAAAACw3xTHMspoZbwT78r4gpUxAAAAAAAAjJHiuNn51/qj + sa+MX9+an8/CcQUAAAAAAADGQXHc3ES+Mv7cyhgAAAAAAAAmRHHcvIyey+96S5XPLJKc6D+waGUMAAAA + AAAAk6I4blY+fORw+Wq7W/m8IsiXRdJ+rgxnEwAAAAAAAJgQxXEzUoOV8cmi3V4IxxIAAAAAAACYJMXx + 7Oevh4+Ur+YHK59RBLEyBgAAAAAAgGlTHM9uarAyPrWdpr1wFAEAAAAAAIBpURzPZs4dPlIei3dlfMnK + GAAAAAAAACKiOJ6tXI59ZZzkbxdJshSOHwAAAAAAABADxfHs5G9HlstjebfyWUSQr1fGL7Rad4WjBwAA + AAAAAMRCcVz//Gf3Pv9h6cHKZxBH2n/abrcfDkcOAAAAAAAAiI3iuN75eHmlPB7pu4z7aX65yPLnT7Va + d4fjBgAAAAAAAMRIcVzPfLWxUf4x4pVxkebvDLPscDhmAAAAAAAAQMwUx/XL3yNeGe/GyhgAAAAAAADq + RnFcn8S+Mh4k+bvbabocjhYAAAAAAABQF4rjeuST5eXytc5C5X2OIFbGAAAAAAAAUGeK47gT+8q4n+Xv + D5PuajhOAAAAAAAAQB0pjuPNJysr5WudaN9l/NVoZbzZeszKGAAAAAAAAOpOcRxfruzmvQcPlUXWqbyv + EeR0kXV/EI4QAAAAAAAAUHeK47jy6epqeaK7WHk/I8iVfpK/uNXr3ROODwAAAAAAADALFMdxJPqVcZKf + GaSdx8OxAQAAAAAAAGaJ4nj6ubC6Wr4R+cp4p9u1MgYAAAAAAIBZpTieXmJfGRdZfqaf5E+EowIAAAAA + AADMKsXxdPLZymhlvFB53yKIlTEAAAAAAAA0ieJ4srmycW1lPMyq71kEOTucb/8wHA8AAAAAAACgCRTH + k8s/1tbKXx2M9l3Go/x8M8/vDUcDAAAAAAAAaArF8fhzdWOj/ODQQ+XRSN9lvJsP+0n+ZDgSAAAAAAAA + QNMojsebi2tr5ZsRr4z7aWdzcODAfeE4AAAAAAAAAE2kOB5Pol8ZJ/m5Imk/FY4BAAAAAAAA0GSK4/3P + xdW18q2FXuU9iSGjlfHO/UtWxgAAAAAAAMA1iuP9y9XdRP4u448GWfZ0ePQAAAAAAAAA1yiO9ydfrK1H + vzLemuvNhccOAAAAAAAA8A3F8Z3l+sr4pYhXxv2s80x43AAAAAAAAADfpTjee/65vl6eXPxe5bVHkaT9 + yk6WPRAeNQAAAAAAAEA1xfHecvbhR8qX293K644g54us82x4xAAAAAAAAAA3pji+vVyKfWWcdY5tp2kS + Hi8AAAAAAADAzSmObz3XVsbRvsv4gpUxAAAAAAAAsCeK45vn0vqj5W8XlyqvMYYUaX58mCRWxgAAAAAA + AMDeKI5vnNHKeMfKGAAAAAAAAJhliuPq/Gv90fJUzO8yTvPXt+bns/AYAQAAAAAAAPZOcfzd/GW0Ms6i + XRl/bmUMAAAAAAAA7CvF8TcZfd/f9eJ9l/FuflO02wvh0QEAAAAAAADsD8Xxtfz18JHy1Xa38joiyJdF + 0n6uDM8MAAAAAAAAYF81vTiOfWVcpPnJo1nWC48LAAAAAAAAYP81uTj+emWcH6z87hHEyhgAAAAAAACY + jCYWx5cjXxkP0vap7TS1MgYAAAAAAAAmo2nF8bnDR8pj8a6ML1kZAwAAAAAAABPXlOL48sZG3CvjJH/7 + peTgUngsAAAAAAAAAJPThOL44yPL5fF4V8b/7qftn7zQat0VHgkAAAAAAADAZM1ycfyf3b//x6UHK79b + HOm8M8iyw+FRAAAAAAAAAEzHrBbHHy+vRLsy7qf55SLLnz/Vat0dHgMAAAAAAADA9MxacfzVxkbUK+Mi + zd8ZWhkDAAAAAAAAMZml4vjvyyvla52Fyu8SQayMAQAAAAAAgDjNQnEc+8p4kOTvDtLucrjlAAAAAAAA + AHGpe3H8yUr8K+PN1mNWxgAAAAAAAEC86locX18ZFxV/N5K8P0y6q+E2AwAAAAAAAMSrjsXxpyur5Yl4 + V8ZX+ln+MytjAAAAAAAAoDbqVBxf2c17Dx4qi6xT+fciyOnttPuDcGsBAAAAAAAA6qEuxfGnq6vlie5i + 5d+JIFf6Sf7iVq93T7itAAAAAAAAAPURe3Ec/co4yc8Mk87j4XYCAAAAAAAA1E/MxfGF1dXyjW7E7zJO + 8hd3ul0rYwAAAAAAAKDeYiyOr6+Mh1n150aQs/0kfyLcQgAAAAAAAIB6i604/mwl/pXxZp7fG24fAAAA + AAAAQP3FUhxf3dgo//z9uFfGw/n2D8NtAwAAAAAAAJgdMRTH/1hbK988uFj5GTGkn3Y2BwcO3BduGQAA + AAAAAMBsmWZxPFoZf3DoofJo1qn8/QhybpDkT4VbBQAAAAAAADCbplUcX7QyBgAAAAAAAIjDpIvjq7uJ + emWc5Of68+2nw+0BAAAAAAAAmH2TLI4vrq6Vby30Kn82hoxWxjv3L1kZAwAAAAAAAM0yieI4+pVxmn9U + ZN1nwi0BAAAAAAAAaJZxF8dfrK1HvzLemuvNhdsBAAAAAAAA0DzjLI5PP/RwuRPvyvjzImn/KNwGAAAA + AAAAgOYaZ3EcbZL2KztZ9kC4BQAAAAAAAADN1rDi+HyRdZ4Nlw4AAAAAAADASIOK4+PDJEnCZQMAAAAA + AABwXQOK4wtWxgAAAAAAAAA3MOPF8etb8/NZuFQAAAAAAAAAqsxocWxlDAAAAAAAAHCrZq047qf5if4D + i1bGAAAAAAAAALdqhorjL/tJ58fhsgAAAAAAAAC4VTNSHJ8s2u2FcEkAAAAAAAAA3I6aF8dfFkn7uTJc + CwAAAAAAAAB7UOPi+NTRLOuFywAAAAAAAABgr+pWHPfT/PIgbf90p9W6K1wCAAAAAAAAAHeiTsVxP+28 + XSTJUvjqAAAAAAAAAOyHmhTHl7zLGAAAAAAAAGBMoi+Ok/z3LyUHrYwBAAAAAAAAxiXW4nj0LuMiy5/3 + LmMAAAAAAACAMYuzOO68M8yyw+ErAgAAAAAAADBOMRXH11fGp1qtu8PXAwAAAAAAAGDcoimOk/zd7TRd + Dl8LAAAAAAAAgEmJoDi2MgYAAAAAAACYpqkWx0l+Zph0Hg9fBQAAAAAAAIBpmFJx/NVoZbzZeszKGAAA + AAAAAGDaplAc/7mfdFbDnwcAAAAAAABg2iZYHF/pJ/mLW73ePeFPAwAAAAAAABCDCRXHpwepdxkDAAAA + AAAARGnMxbGVMQAAAAAAAEDsxlUcF1l+ZphYGQMAAAAAAABEbwzF8dcr451u18oYAAAAAAAAoA72uTg+ + O0jyJ8JHAwAAAAAAAFAH+1YcJ/kvtuZ6c+FjAQAAAAAAAKiLfSiOP+wn+ZPh4wAAAAAAAAComzspjvtp + Z3Nw4MB94aMAAAAAAAAAqKM9FcdJfq5I2k+FjwAAAAAAAACgzm63OB6tjHfuX7IyBgAAAAAAAJgVt1Ec + f1Rk3WfCrwEAAAAAAAAwK26lOB6tjLfmenPhVwAAAAAAAACYJTcqjvtpfn6QdZ4NPwoAAAAAAADALPp/ + xXGRdY5tp2kSfgwAAAAAAACAWVVRHJ8vrIwBAAAAAAAAmuPbxXGR5seHSWJlDAAAAAAAANAkoTi+YGUM + AAAAAAAA0FAvtFp3badpL/wTAAAi1mr9F19mbFwr1UcBAAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/Program.cs b/ProjectBattleship/ProjectBattleship/Program.cs index 886e9f5..fa0f283 100644 --- a/ProjectBattleship/ProjectBattleship/Program.cs +++ b/ProjectBattleship/ProjectBattleship/Program.cs @@ -11,7 +11,7 @@ namespace ProjectBattleship // To customize application configuration such as set high DPI settings or default font, // see https://aka.ms/applicationconfiguration. ApplicationConfiguration.Initialize(); - Application.Run(new Form1()); + Application.Run(new FormBattleship()); } } } \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/ProjectBattleship.csproj b/ProjectBattleship/ProjectBattleship/ProjectBattleship.csproj index b57c89e..13ee123 100644 --- a/ProjectBattleship/ProjectBattleship/ProjectBattleship.csproj +++ b/ProjectBattleship/ProjectBattleship/ProjectBattleship.csproj @@ -8,4 +8,19 @@ enable + + + True + True + Resources.resx + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/Properties/Resources.Designer.cs b/ProjectBattleship/ProjectBattleship/Properties/Resources.Designer.cs new file mode 100644 index 0000000..6d6be8f --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Этот код создан программой. +// Исполняемая версия:4.0.30319.42000 +// +// Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае +// повторной генерации кода. +// +//------------------------------------------------------------------------------ + +namespace ProjectBattleship.Properties { + using System; + + + /// + /// Класс ресурса со строгой типизацией для поиска локализованных строк и т.д. + /// + // Этот класс создан автоматически классом StronglyTypedResourceBuilder + // с помощью такого средства, как ResGen или Visual Studio. + // Чтобы добавить или удалить член, измените файл .ResX и снова запустите ResGen + // с параметром /str или перестройте свой проект VS. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Возвращает кэшированный экземпляр ResourceManager, использованный этим классом. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ProjectBattleship.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Перезаписывает свойство CurrentUICulture текущего потока для всех + /// обращений к ресурсу с помощью этого класса ресурса со строгой типизацией. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/ProjectBattleship/ProjectBattleship/Properties/Resources.resx b/ProjectBattleship/ProjectBattleship/Properties/Resources.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/ProjectBattleship/ProjectBattleship/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectBattleship/ProjectBattleship/Resources/down.png b/ProjectBattleship/ProjectBattleship/Resources/down.png new file mode 100644 index 0000000000000000000000000000000000000000..30e85611d2dabc2d0bf15738b93e938402542c08 GIT binary patch literal 256 zcmeAS@N?(olHy`uVBq!ia0vp^av;pX1SGcvS$+jljKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sBugD~Uq{1quc!Kt1ujv*f2Z?7HXYf#{5NPPMC{>>XHGdmWr z&HbZadSQLq&ZarVS&^s zCQ`v_v&GFad{lhIH@|$_a{pxDQ*RS%yQR|6Lh-kstnE7hbRdJLtDnm{r-UW|io#?g literal 0 HcmV?d00001 diff --git a/ProjectBattleship/ProjectBattleship/Resources/left.png b/ProjectBattleship/ProjectBattleship/Resources/left.png new file mode 100644 index 0000000000000000000000000000000000000000..d7cd9636b33e4c139390cda08ee1284b855e79ce GIT binary patch literal 269 zcmeAS@N?(olHy`uVBq!ia0vp^av;pX1SGcvS$+jljKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sBugD~Uq{1quc!9|`fjv*f2Pp>)hwI~R%2G00>U-Gnv3#Xav zug$Y=ojAts=yYc3lqcHHYk23Z|MRN&+S^OTIZqbN4ZA)kt~k?4e|O47!RdDX9v7B= zT=iIwH>1+INq+S#YD=Y}TdXg&7wcM7~&J~MT8<~Gf{f&JG-zuukxLiZT=n|T773=i8s0$s@9>FVdQ&MBb@0E1;< AY5)KL literal 0 HcmV?d00001 diff --git a/ProjectBattleship/ProjectBattleship/Resources/up.png b/ProjectBattleship/ProjectBattleship/Resources/up.png new file mode 100644 index 0000000000000000000000000000000000000000..fb7362bd55408676349efdfeec740cdf384aeb77 GIT binary patch literal 250 zcmeAS@N?(olHy`uVBq!ia0vp^av;pX1SGcvS$+jljKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sBugD~Uq{1quc!G2E{#}E(iw^tAHwJ7ko2EO|LzgSgMP!fIU}H&<`>~I#h(4y!N9`x6V@({xjThh?DDeiJ30$wm9E%Y#e8GmW%6li z@wpkk&Fij6o4rsBHwrhgedzV}QS-bq)va+ar>`q<=la{J9m-XIhi7W!W@22WQ%mvv4FO#sapVO#(J literal 0 HcmV?d00001