From 86e2b99d9f29881a6ab118ec1ff9e8a3908201d3 Mon Sep 17 00:00:00 2001 From: RozhVan Date: Sun, 2 Jun 2024 16:26:40 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9A=D1=80=D0=B8=D0=B2=D0=BE-=D0=BA=D0=BE?= =?UTF-8?q?=D1=81=D0=BE,=20=D0=BD=D0=BE=20=D1=80=D0=B0=D0=B1=D0=BE=D1=82?= =?UTF-8?q?=D0=B0=D0=B5=D1=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ProjectContainerShip/ProjectContainerShip.sln | 25 + .../AdditionalNumeringDack.cs | 20 + .../ProjectContainerShip/DirectionType.cs | 12 + .../ProjectContainerShip/DrawAddDack.cs | 55 + .../ProjectContainerShip/DrawCont.cs | 175 ++ .../ProjectContainerShip/EntityCont.cs | 46 + .../ProjectContainerShip/FormCont.Designer.cs | 144 ++ .../ProjectContainerShip/FormCont.cs | 72 + .../ProjectContainerShip/FormCont.resx | 1716 +++++++++++++++++ .../ProjectContainerShip/Program.cs | 17 + .../ProjectContainerShip.csproj | 26 + .../Properties/Resources.Designer.cs | 63 + .../Properties/Resources.resx | 120 ++ 13 files changed, 2491 insertions(+) create mode 100644 ProjectContainerShip/ProjectContainerShip.sln create mode 100644 ProjectContainerShip/ProjectContainerShip/AdditionalNumeringDack.cs create mode 100644 ProjectContainerShip/ProjectContainerShip/DirectionType.cs create mode 100644 ProjectContainerShip/ProjectContainerShip/DrawAddDack.cs create mode 100644 ProjectContainerShip/ProjectContainerShip/DrawCont.cs create mode 100644 ProjectContainerShip/ProjectContainerShip/EntityCont.cs create mode 100644 ProjectContainerShip/ProjectContainerShip/FormCont.Designer.cs create mode 100644 ProjectContainerShip/ProjectContainerShip/FormCont.cs create mode 100644 ProjectContainerShip/ProjectContainerShip/FormCont.resx create mode 100644 ProjectContainerShip/ProjectContainerShip/Program.cs create mode 100644 ProjectContainerShip/ProjectContainerShip/ProjectContainerShip.csproj create mode 100644 ProjectContainerShip/ProjectContainerShip/Properties/Resources.Designer.cs create mode 100644 ProjectContainerShip/ProjectContainerShip/Properties/Resources.resx diff --git a/ProjectContainerShip/ProjectContainerShip.sln b/ProjectContainerShip/ProjectContainerShip.sln new file mode 100644 index 0000000..839df47 --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.7.34031.279 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProjectContainerShip", "ProjectContainerShip\ProjectContainerShip.csproj", "{93D347DF-9392-4C7A-A5C8-17819E233C49}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {93D347DF-9392-4C7A-A5C8-17819E233C49}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {93D347DF-9392-4C7A-A5C8-17819E233C49}.Debug|Any CPU.Build.0 = Debug|Any CPU + {93D347DF-9392-4C7A-A5C8-17819E233C49}.Release|Any CPU.ActiveCfg = Release|Any CPU + {93D347DF-9392-4C7A-A5C8-17819E233C49}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {7D7326FF-7C5F-4B61-9210-05CBD33A8DF4} + EndGlobalSection +EndGlobal diff --git a/ProjectContainerShip/ProjectContainerShip/AdditionalNumeringDack.cs b/ProjectContainerShip/ProjectContainerShip/AdditionalNumeringDack.cs new file mode 100644 index 0000000..0ced486 --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/AdditionalNumeringDack.cs @@ -0,0 +1,20 @@ +namespace ProjectContainerShip; + +public enum AdditionalNumeringDack +{ + None = 0, + /// + ///1 палуба + /// + One, + + /// + /// 2 палуба + /// + Two, + + /// + /// 3 палуба + /// + Three, +} \ No newline at end of file diff --git a/ProjectContainerShip/ProjectContainerShip/DirectionType.cs b/ProjectContainerShip/ProjectContainerShip/DirectionType.cs new file mode 100644 index 0000000..0dcb0fa --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/DirectionType.cs @@ -0,0 +1,12 @@ +namespace ProjectContainerShip; + +public enum DirectionType +{ + Up = 1, + + Down = 2, + + Left = 3, + + Right = 4, +} \ No newline at end of file diff --git a/ProjectContainerShip/ProjectContainerShip/DrawAddDack.cs b/ProjectContainerShip/ProjectContainerShip/DrawAddDack.cs new file mode 100644 index 0000000..6009da1 --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/DrawAddDack.cs @@ -0,0 +1,55 @@ +namespace ProjectContainerShip; + +public class DrawAddDack +{ + public EntityCont? EntityCont { get; private set; } + + private AdditionalNumeringDack NumOfDack; + + public int NumDack + { + set + { + if (value == 1) + { + NumOfDack = AdditionalNumeringDack.One; + } + else if (value == 2) + { + NumOfDack = AdditionalNumeringDack.Two; + } + else if (value == 3) + { + NumOfDack = AdditionalNumeringDack.Three; + } + else return; + } + } + + public void DrawAdditdack(Graphics g, int _StartPosX, int _StartPosY) + { + + // Создаем кисть с случайным цветом + Brush bodybrush = new SolidBrush(Color.Gray); + Brush bodybrush2 = new SolidBrush(Color.Blue); + Brush bodybrush3 = new SolidBrush(Color.Red); + + switch (NumOfDack) + { + case AdditionalNumeringDack.One: + g.FillRectangle(bodybrush3, _StartPosX + 5, _StartPosY + 30, 150, 10); + break; + case AdditionalNumeringDack.Two: + g.FillRectangle(bodybrush2, _StartPosX + 10, _StartPosY + 25, 140, 5); + g.FillRectangle(bodybrush3, _StartPosX + 5, _StartPosY + 30, 150, 10); + break; + case AdditionalNumeringDack.Three: + g.FillRectangle(bodybrush, _StartPosX + 15, _StartPosY + 20, 140, 5); + g.FillRectangle(bodybrush2, _StartPosX + 10, _StartPosY + 25, 145, 5); + g.FillRectangle(bodybrush3, _StartPosX + 5, _StartPosY + 30, 150, 10); + break; + + } + + } +} diff --git a/ProjectContainerShip/ProjectContainerShip/DrawCont.cs b/ProjectContainerShip/ProjectContainerShip/DrawCont.cs new file mode 100644 index 0000000..aa50bb5 --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/DrawCont.cs @@ -0,0 +1,175 @@ +namespace ProjectContainerShip; + +public class DrawCont +{ + public EntityCont? EntityContainer { get; private set; } + + public DrawAddDack addDack = new DrawAddDack(); + + private int? _PictureWidth; + + private int? _PictureHeight; + + private int? _StartPosX; + + private int? _StartPosY; + + private readonly int _drawingContWidth = 160; + + private readonly int _drawingContHeight = 90; + + public void Init(int speed, double weight, Color shipColor, Color containerColor, bool container, bool crane) + { + EntityContainer = new EntityCont(); + EntityContainer.Init(speed, weight, shipColor, containerColor, container, crane); + _PictureWidth = null; + _PictureHeight = null; + _StartPosX = null; + _StartPosY = null; + addDack = new DrawAddDack(); + } + + public bool SetPictureSize(int width, int height) + { + if (EntityContainer == null) + { + return false; + } + + if (width >= _drawingContWidth && height >= _drawingContHeight) + { + _PictureWidth = width; + _PictureHeight = height; + + if (_StartPosX.HasValue && _StartPosY.HasValue) + { + if (_StartPosX.Value + _drawingContWidth > _PictureWidth) + { + _StartPosX = _PictureWidth - _drawingContWidth; + } + if (_StartPosY.Value + _drawingContHeight > _PictureHeight) + { + _StartPosY = _PictureHeight - _drawingContHeight; + } + } + 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 + _drawingContWidth > _PictureWidth) + { + x = _PictureWidth.Value - _drawingContWidth; + } + + if (y < 0) + { + y = 0; + } + else if (y + _drawingContHeight > _PictureHeight) + { + y = _PictureHeight.Value - _drawingContHeight; + } + + _StartPosX = x; + _StartPosY = y; + } + + public bool MoveTransport(DirectionType direction) + { + if (EntityContainer == null || !_StartPosX.HasValue || !_StartPosY.HasValue) + { + return false; + } + + switch (direction) + { + case DirectionType.Left: + if (_StartPosX.Value - EntityContainer.Step > 0) + { + _StartPosX -= (int)EntityContainer.Step; + } + return true; + + case DirectionType.Right: + if (_StartPosX.Value + EntityContainer.Step < _PictureWidth - _drawingContWidth) + { + _StartPosX += (int)EntityContainer.Step; + } + return true; + + case DirectionType.Up: + + if (_StartPosY.Value - EntityContainer.Step > 0) + { + _StartPosY -= (int)EntityContainer.Step; + } + return true; + + case DirectionType.Down: + if (_StartPosY.Value + EntityContainer.Step < _PictureHeight - _drawingContHeight) + { + _StartPosY += (int)EntityContainer.Step; + } + return true; + default: + return false; + } + + } + + public void DrawTransport(Graphics g) + { + if (EntityContainer == null || !_StartPosX.HasValue || !_StartPosY.HasValue) + { + return; + } + + Pen pen = new(Color.Black); + Brush ContainerBrush = new SolidBrush(EntityContainer.ContainerColor); + + + // отрисовка контейнера + if (EntityContainer.Container) + { + g.DrawRectangle(pen, _StartPosX.Value + 80, _StartPosY.Value, 60, 40); + g.FillRectangle(ContainerBrush, _StartPosX.Value + 81, _StartPosY.Value + 1, 59, 39); + } + + Brush ShipBrush = new SolidBrush(EntityContainer.ShipColor); + + //отрисовка корабля + Point[] points = + { + new Point(_StartPosX.Value, _StartPosY.Value + 40), + new Point(_StartPosX.Value + 160, _StartPosY.Value + 40), + new Point(_StartPosX.Value + 150, _StartPosY.Value + 90), + new Point(_StartPosX.Value + 10, _StartPosY.Value + 90), + }; + + g.DrawPolygon(pen, points); + g.FillPolygon(ShipBrush, points); + + addDack.DrawAdditdack(g, _StartPosX.Value, _StartPosY.Value); + + //отрисовка крана + if (EntityContainer.Crane) + { + g.DrawLine(pen, _StartPosX.Value + 30, _StartPosY.Value + 50, _StartPosX.Value + 30, _StartPosY.Value + 70); + g.DrawLine(pen, _StartPosX.Value + 20, _StartPosY.Value + 60, _StartPosX.Value + 40, _StartPosY.Value + 60); + } + + } +} \ No newline at end of file diff --git a/ProjectContainerShip/ProjectContainerShip/EntityCont.cs b/ProjectContainerShip/ProjectContainerShip/EntityCont.cs new file mode 100644 index 0000000..1915f0b --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/EntityCont.cs @@ -0,0 +1,46 @@ +namespace ProjectContainerShip; + +public class EntityCont +{ + /// + /// Скорость + /// + public int Speed { get; private set; } + + /// + /// Вес + /// + public double Weight { get; private set; } + + /// + /// Цвет контейнеровоза + /// + public Color ShipColor { get; private set; } + + /// + /// Цвет контейнера + /// + public Color ContainerColor { get; private set; } + + /// + /// Признак наличия контейнера + /// + public bool Container { get; private set; } + + /// + /// Признак наличия крана + /// + public bool Crane { get; private set; } + + public double Step => Speed * 10 / Weight; + + public void Init(int speed, double weight, Color shipColor, Color containerColor, bool container, bool crane) + { + Speed = speed; + Weight = weight; + ContainerColor = containerColor; + ShipColor = shipColor; + Container = container; + Crane = crane; + } +} \ No newline at end of file diff --git a/ProjectContainerShip/ProjectContainerShip/FormCont.Designer.cs b/ProjectContainerShip/ProjectContainerShip/FormCont.Designer.cs new file mode 100644 index 0000000..c1f3f6d --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/FormCont.Designer.cs @@ -0,0 +1,144 @@ +namespace ProjectContainerShip +{ + partial class FormCont + { + /// + /// 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(FormCont)); + pictureBoxCont = new PictureBox(); + buttonCreate = new Button(); + buttonUp = new Button(); + buttonRight = new Button(); + buttonLeft = new Button(); + buttonDown = new Button(); + NumericUpDownDack = new NumericUpDown(); + ((System.ComponentModel.ISupportInitialize)pictureBoxCont).BeginInit(); + ((System.ComponentModel.ISupportInitialize)NumericUpDownDack).BeginInit(); + SuspendLayout(); + // + // pictureBoxCont + // + pictureBoxCont.Dock = DockStyle.Fill; + pictureBoxCont.Location = new Point(0, 0); + pictureBoxCont.Name = "pictureBoxCont"; + pictureBoxCont.Size = new Size(765, 456); + pictureBoxCont.TabIndex = 0; + pictureBoxCont.TabStop = false; + // + // buttonCreate + // + buttonCreate.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonCreate.Location = new Point(12, 418); + buttonCreate.Name = "buttonCreate"; + buttonCreate.Size = new Size(82, 26); + buttonCreate.TabIndex = 1; + buttonCreate.Text = "Создать"; + buttonCreate.UseVisualStyleBackColor = true; + buttonCreate.Click += ButtonCreate_Click; + // + // buttonUp + // + buttonUp.BackgroundImage = (Image)resources.GetObject("buttonUp.BackgroundImage"); + buttonUp.BackgroundImageLayout = ImageLayout.Stretch; + buttonUp.Location = new Point(652, 348); + buttonUp.Name = "buttonUp"; + buttonUp.Size = new Size(47, 45); + buttonUp.TabIndex = 2; + buttonUp.UseVisualStyleBackColor = true; + buttonUp.Click += ButtonMove_Click; + // + // buttonRight + // + buttonRight.BackgroundImage = (Image)resources.GetObject("buttonRight.BackgroundImage"); + buttonRight.BackgroundImageLayout = ImageLayout.Stretch; + buttonRight.Location = new Point(703, 399); + buttonRight.Name = "buttonRight"; + buttonRight.Size = new Size(47, 45); + buttonRight.TabIndex = 3; + buttonRight.UseVisualStyleBackColor = true; + buttonRight.Click += ButtonMove_Click; + // + // buttonLeft + // + buttonLeft.BackgroundImage = (Image)resources.GetObject("buttonLeft.BackgroundImage"); + buttonLeft.BackgroundImageLayout = ImageLayout.Stretch; + buttonLeft.Location = new Point(599, 399); + buttonLeft.Name = "buttonLeft"; + buttonLeft.Size = new Size(47, 45); + buttonLeft.TabIndex = 4; + buttonLeft.UseVisualStyleBackColor = true; + buttonLeft.Click += ButtonMove_Click; + // + // buttonDown + // + buttonDown.BackgroundImage = (Image)resources.GetObject("buttonDown.BackgroundImage"); + buttonDown.BackgroundImageLayout = ImageLayout.Stretch; + buttonDown.Location = new Point(652, 399); + buttonDown.Name = "buttonDown"; + buttonDown.Size = new Size(47, 45); + buttonDown.TabIndex = 5; + buttonDown.UseVisualStyleBackColor = true; + buttonDown.Click += ButtonMove_Click; + // + // NumericUpDownDack + // + NumericUpDownDack.Location = new Point(630, 12); + NumericUpDownDack.Maximum = new decimal(new int[] { 3, 0, 0, 0 }); + NumericUpDownDack.Name = "NumericUpDownDack"; + NumericUpDownDack.Size = new Size(120, 23); + NumericUpDownDack.TabIndex = 6; + // + // FormCont + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(765, 456); + Controls.Add(NumericUpDownDack); + Controls.Add(buttonDown); + Controls.Add(buttonLeft); + Controls.Add(buttonRight); + Controls.Add(buttonUp); + Controls.Add(buttonCreate); + Controls.Add(pictureBoxCont); + Name = "FormCont"; + Text = "FormCont"; + ((System.ComponentModel.ISupportInitialize)pictureBoxCont).EndInit(); + ((System.ComponentModel.ISupportInitialize)NumericUpDownDack).EndInit(); + ResumeLayout(false); + } + + #endregion + + private PictureBox pictureBoxCont; + private Button buttonCreate; + private Button buttonUp; + private Button buttonRight; + private Button buttonLeft; + private Button buttonDown; + private NumericUpDown NumericUpDownDack; + } +} \ No newline at end of file diff --git a/ProjectContainerShip/ProjectContainerShip/FormCont.cs b/ProjectContainerShip/ProjectContainerShip/FormCont.cs new file mode 100644 index 0000000..8c4c2cc --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/FormCont.cs @@ -0,0 +1,72 @@ +namespace ProjectContainerShip +{ + public partial class FormCont : Form + { + private DrawCont? _drawCont; + + public FormCont() + { + InitializeComponent(); + } + + private void Draw() + { + if (_drawCont == null) + { + return; + } + + Bitmap bmp = new(pictureBoxCont.Width, pictureBoxCont.Height); + Graphics gr = Graphics.FromImage(bmp); + _drawCont.DrawTransport(gr); + pictureBoxCont.Image = bmp; + } + + + private void ButtonCreate_Click(object sender, EventArgs e) + { + Random random = new Random(); + _drawCont = new DrawCont(); + _drawCont.Init(random.Next(100, 300), random.Next(100, 300), + 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))); + _drawCont.SetPictureSize(pictureBoxCont.Width, pictureBoxCont.Height); + _drawCont.SetPosition(random.Next(10, 100), random.Next(10, 100)); + _drawCont.addDack.NumDack = (int)NumericUpDownDack.Value; + Draw(); + } + + private void ButtonMove_Click(object sender, EventArgs e) + { + if (_drawCont == null) + { + return; + } + + string name = ((Button)sender)?.Name ?? string.Empty; + bool result = false; + switch (name) + { + case "buttonUp": + result = _drawCont.MoveTransport(DirectionType.Up); + break; + case "buttonDown": + result = _drawCont.MoveTransport(DirectionType.Down); + break; + case "buttonLeft": + result = _drawCont.MoveTransport(DirectionType.Left); + break; + case "buttonRight": + result = _drawCont.MoveTransport(DirectionType.Right); + break; + } + + if (result) + { + Draw(); + } + + } + } +} diff --git a/ProjectContainerShip/ProjectContainerShip/FormCont.resx b/ProjectContainerShip/ProjectContainerShip/FormCont.resx new file mode 100644 index 0000000..e6c3c17 --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/FormCont.resx @@ -0,0 +1,1716 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAABkAAAARrCAIAAABUmv0sAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vwAADr8BOAVTJAAAaOBJREFUeF7s3Xec3FW98PE7M1uy2WRJISRACC2QUEJAyg0I0gWVErgqlxJAfJAm + otIERAVBwAsCFwUFBSO9KCAiHWnSi3QCoaeQRuomW8eHR4/P1StIytndM2fe7z/8Q5Fsdn5zzvd8Xr/f + zL/9GQAAAAASJmABAAAAkDQBCwAAAICkCVgAAAAAJE3AAgAAACBpAhYAAAAASROwAAAAAEiagAUAAABA + 0gQsAAAAAJImYAEAAACQNAELAKA7lMvlN99885e//OWDDz7Y2dkZ/lsAABaDgAUA0OU6Oztff/314447 + bvXVV99ll13uvvvulpaW8L8BAPBxBCwAgC43ffr0U045ZeDAgf/2b//Wu3fvPfbY46mnngr/GwAAH0fA + AgDoQuVyeebMmT/84Q8HDBjwb3/T0NDwhS984Yknnmhvbw//HAAAH03AAgDoQgsWLLjooouGDBkS2tXf + 9O3b98ADD3z++ec7OjrCPwoAwEcQsAAAukpbW9t1111XX18fqtU/qqmpOfjgg995553wTwMA8BEELACA + LtHR0XHjjTf27ds39KoPU19ff8ghh0ycONH3EgIA/AsCFgBAl7jmmmsGDRoUStVH69u379e//vVZs2aF + /xsAAP9EwAIAiKyjo+Oaa675qCcHP9TRRx89e/bs8P8HAOAfCVgAAJFdfvnlK664YkhTi6dXr14nnnhi + a2tr+FcAAPB3BCwAgJguvfTSoUOHhi61JHr16nXccceFfwsAAH9HwAIAiGPRokWXXnrp8OHDC4VCiFJL + qK6u7sQTT5w/f374NwIA8BcCFgBAHFdcccUGG2xQKpVCjloqTU1NJ554Yvg3AgDwFwIWAEAEV1xxxXrr + rbeM9eqv+vTp41lCAIC/J2ABACyTRYsWXXfddWPGjKmrqwsJatkUCoUhQ4aceuqpc+fODX8GAEB1E7AA + AJbJbbfdtsUWW9TW1ob+FEOhUBg6dOh//dd/hT8DAKC6CVgAAEupra3t1ltv3XzzzWtqakJ5iqdQKKy0 + 0kpnnHHGwoULw58HAFCtBCwAgKXR0tJy55137rzzzg0NDaE5xVYqlUaMGHH++ee///774U8FAKhKAhYA + wNJ45JFHPv3pT3fFvVd/r1gsDh8+/MILL5w/f374gwEAqo+ABQCwZNrb2x955JHddtst1qe2/2ulUmm9 + 9db7xS9+oWEBAFVLwAIAWDLPP//8F7/4xd69e4fC1PVqa2s32WST8ePH+15CAKA6CVgAAEvg5Zdf/o// + +I8QlrrX6NGjr7nmmubm5vCjAABUDQELAGBxvfXWWwcccEB9fX1ISt2rVCptvvnmN99886JFi8IPBABQ + HQQsAIDFMnny5B6sV39VU1Pz7//+7w8++GD4mQAAqoOABQDwMcrl8rvvvnvggQfW1taGktSjxowZ8+CD + D3Z0dISfDwAgdwIWAMDHmDdv3qGHHtqdn9r+rxUKhW233fall14KPx8AQO4ELACAf6W1tXW//fbr1atX + qEdpKBQKm2222auvvhp+SgCArAlYAAAfac6cOUceeWSfPn1CN0pJoVDYcccdX3jhhc7OzvDjAgBkSsAC + APhIRxxxRGNjYyhG6SkWi9tvv/3UqVPDjwsAkCkBCwDgQ7S0tBx22GENDQ2hFaWqWCxuueWW77//fvi5 + AQByJGABAPxvU6dOPf7441dYYYVQidJWX1+/6667vvLKK+GnBwDIjoAFAPAP3nvvvRNOOGHgwIGFQiEk + ouTV1NR85jOfefHFF8PfAQAgLwIWAMD/mD59+imnnLLiiitWUL36q9ra2s9//vMaFgCQJQELACCYPn36 + GWecsfrqqxeLxZCFKkrfvn333nvv559/Pvx9AAByIWABAPw/s2fPPuecc4YOHRpqUGVqaGjYd9993YcF + AGRGwAIA+HNzc/PFF1+89tprV+i9V3+vX79+hx122GuvvRb+bgAAlU/AAgD48+WXXz5ixIgM6tUHCoXC + gAEDDj/88DfffDP89QAAKpyABQBUtY6OjquvvnrEiBEh/+RiwIAB3/zmNydNmhT+ngAAlUzAAgCq2u23 + 377RRhuF6pOXwYMHn3LKKbNnzw5/VQCAiiVgAQDV69Zbbx05cmToPTnq37//6aef3t7eHv7CAACVScAC + AKpRa2vrrbfeuvHGG4fSk6+VVlrpRz/60fz588PfHACgAglYAEDVaWlp+f3vf7/pppsWCoWQebK28sor + n3feeXPmzAl/fwCASiNgAQDVpaOj48EHH9xoo42qpF791aBBg3760582NzeH3wIAQEURsACAKtLW1nbP + PfdstdVWtbW1Ie1UjdVXX/3iiy92HxYAUIkELACgWrS3t995551bbrllTU1NiDrVpFAorL766j/5yU98 + LyEAUHEELACgKpTL5T/+8Y/bbrttddarvyoUCmuuueall17qM90BgMoiYAEAVeHRRx/dcccd6+rqQsup + VsViceTIkePHj1+4cGH41QAAJE/AAgDy99hjj+24447FYjFUnOpWKBTWXnvtSy+9tKWlJfyCAADSJmAB + AJl74YUXdt9996r6zsHFsf76699www2dnZ3h1wQAkDABCwDI2csvv7zrrrtW8+defZRCobD++uv/5je/ + Cb8pAICECVgAQLbeeuutffbZp7a2NjQb/sno0aN///vfuw8LAEicgAUA5GnSpElf/vKXGxoaQqrhI2y6 + 6aZ33XVX+K0BACRJwAIAMjR16tRx48b17t07RBo+WqFQGD169D333BN+dwAA6RGwAIDczJ49+8gjj2xq + agqFho9TKpW22mqrBx54wLOEAECaBCwAICvvvvvu1772tf79+4c2w+Kpra3ddtttH3744fB7BABIiYAF + AORj2rRp3/jGN/r16xeqDEuipqbmU5/61J/+9Kfw2wQASIaABQBk4r333jvppJMGDRoUegxLrlevXnvs + scerr74afqcAAGkQsACAHLz11lvHH3/8kCFDCoVCiDEslV69eu26665PPfVU+M0CACRAwAIAKt706dNP + P/30IUOGhAbDsunVq9d//ud/TpgwIfx+AQB6moAFAFS2adOmnXHGGaussop7ryLq06fP/vvv/9JLL4Xf + MgBAjxKwAIAKNn369DPPPHPVVVdVr6Lr27fv/vvv/+KLL4bfNQBAzxGwAIBKNXfu3J/+9KdrrLFGKC7E + 1tTUdOSRR7755pvhNw4A0EMELACgIs2dO/eCCy5YffXVQ2uhayy33HKHHXbY66+/Hn7vAAA9QcACACpP + c3PzxRdfvOaaa4bKQlfq37//V7/61bfeeiv89gEAup2ABQBUmObm5l/+8pcjR44MfYWut/zyyx9zzDFv + vPFGZ2dneBkAALqRgAUAVJLOzs4rr7xy+PDhoazQXQYOHHjMMcdMnjy5XC6HFwMAoLsIWABAxejs7Pzt + b387YsSI0FToXiussMK3v/3t6dOna1gAQDcTsACAinHrrbeuvfbaoabQEwYPHvy9731v6tSp4SUBAOgW + AhYAUBkefPDB1VZbLXQUek7//v3PPPPM1tbW8MIAAHQ9AQsAqADPP//8euutVygUQkShRy2//PIXXHCB + hgUAdBsBCwBI3T333LPRRhsVi8WQT0jAgAEDfvzjH4dXCACgiwlYAEDSXnzxxU033bRUKoVwQjLq6+t/ + /etfh9cJAKArCVgAQLoef/zxT33qU7W1tSGZkJjll1/+t7/9bXi1AAC6jIAFACTqoYce2n777evr60Ms + IT2FQmHo0KFXXnlleM0AALqGgAUAJKdcLj/99NOf+9zn1KuKMGzYsFtuuaWjoyO8fgAAsQlYAEByHn/8 + 8bFjx/bu3TsEEtJWLBbXXXfdG264Ibx+AACxCVgAQFqeeOKJz3/+83369Al1hEpQKpVGjRp17bXXhlcR + ACAqAQsASEVra+ujjz66zz77NDU1hS5C5aipqdl0002vvfbaBQsWhFcUACASAQsASEJ7e/uTTz653377 + LbfccqGIUGnq6uo233zz6667buHCheF1BQCIQcACAHpeZ2fnyy+/fPDBB6tXla6uru6Tn/zkrbfe2t7e + Hl5dAIBlJmABAD2svb39hRdeOOyww/r37x8qCJWsV69e22233U033eRZQgAgFgELAOhJ5XJ50qRJX//6 + 1/v27Rv6B5Wvrq7u05/+9N13393S0hJeaQCAZSBgAQA9plwuT58+/dvf/nZjY2MoH+Sirq5ul112eeih + h9ra2sLrDQCwtAQsAKDHzJ8//5RTTvGdg7nq1avX2LFjH3roodbW1vCSAwAsFQELAOgZbW1tl19+eUgd + 5OvAAw989913w6sOALBUBCwAoAd0dnZeccUVoXCQu3Hjxr366qsfvOjh5QcAWEICFgDQA84777zevXuH + vEHuamtrx40bN2vWrPDyAwAsIQELAOhWLS0tP/3pT0PYoJoccsghM2fODNcBAMCSELAAgO7T3Nx8zjnn + DBgwICQNqsxXvvKV999/P1wNAACLTcACALrP2WefPXjw4EKhEHoGVaZUKh100EHhagAAWGwCFgDQHebM + mXPeeecNGzZMvapyH1wAhx566LRp08KVAQCwGAQsAKDLzZs377//+7/XWmutUqkUMgZVrLGx8bDDDps+ + fXq4PgAAPo6ABQB0rY6OjksuuWTEiBHqFf9fY2PjEUcc0dbWFq4SAIB/ScACALrQ7NmzL7744tGjR9fU + 1IR0AX95kHDgwIFf//rX33333XCtAAB8NAELAOgqixYtuuaaaz7xiU+oV/yzQqEwePDgE088cdasWeGK + AQD4CAIWANAlWlpabrzxxo033rhYLIZiAf/orw3rlFNOmTt3brhuAAA+jIAFAMTX3Nx80003bbXVVrW1 + taFVwIcpFourrbbaaaedNmXKlHD1AAD8EwELAIiso6Pj/vvv32abbdx7xeIoFAqrrbbaueeeO2fOnHAN + AQD8IwELAIiptbX1D3/4w/bbbx/iBCyeNdZY44ILLpg9e3a4kgAA/o6ABQBE09nZ+eSTT+60006eHGRJ + FYvFddZZ58ILL/SZ7gDAPxOwAIA4Ojs7n3vuuc9+9rMhSMCSW3fddcePHz9v3rxwVQEA/IWABQBE0NHR + 8dxzz40dO7ZQKIQUAUvug+tn1KhRV1111fz588O1BQAgYAEAUUyaNGmXXXapqakJHQKWVrFYXG+99e64 + 44729vZweQEAVU/AAgCWSblcnjBhwm677ebeKyJaf/31b7/99tbW1nCdAQDVTcACAJbJO++8s+eee9bX + 14fwAJFstNFG999/v/uwAIAPCFgAwNIrl8uf+cxnisViSA4Q1VprrTVx4sRwtQEAVUzAAgCW0ttvv/2F + L3zBvVd0qQ033PDhhx/u7OwMlx0AUJUELABgacydO/eAAw5oaGgImQG6RqlU2mSTTV5//fVw5QEAVUnA + AgCW2Jw5c8aNG1cqlUJjgC627rrrvvfee+H6AwCqj4AFACyZN95449BDD+3Xr19IC9D1ampqtthiiyee + eCJchQBAlRGwAIAl8O677x511FH9+/cvFAohLUC3KJVKn/rUp5566qlwLQIA1UTAAgAW1zvvvHPMMcf0 + 798/FAXoXqVSaccdd3zsscc6OjrCRQkAVAcBCwBYLJMmTTrppJNWWmkl917Rg3r37r3bbrs98sgj4boE + AKqDgAUAfLxZs2adcsopQ4YMCRUBek6vXr323HPPp59+ulwuhwsUAMidgAUAfIz333//rLPOGjp0aOgH + 0NP69Omz9957P/XUU52dneEyBQCyJmABAB/jkksuGTZsmCcHSccHV+Nyyy13wAEHTJgwIVymAEDWBCwA + 4CMtXLjwoosucu8VaWpqavo//+f/vPHGG+F6BQDyJWABAB+upaXlqquuGj58eKgFkJ5+/fp9/etfnzx5 + crhqAYBMCVgAwIe7+eabV1pppdAJIFUNDQ2nnnpquGoBgEwJWADA/7Zw4cKrr77avVdUiuWWW+7kk0+e + OXNmuIIBgOwIWADAP1i0aNGNN944cuTIYrEY8gAkb8CAAWecccb7778frmMAIC8CFgDwP9ra2m677bY1 + 1lgjVAGoHI2NjWefffbcuXPD1QwAZETAAgCCtra23/3udxtuuGGpVApJACrKkCFDzjnnHPdhAUB+BCwA + 4P/p6Oi4+eab1SsqWqFQGDx48FlnnaVhAUBmBCwA4P/Vq9/97ncbb7xxyABQyVZcccWzzz571qxZ5XI5 + XOIAQIUTsACAP991111jxoypqakJAQAqWaFQWG211c4777zm5uZwiQMAFU7AAoBqd++9937iE58IR3/I + xUorrfSjH/2ora0tXOgAQCUTsACgepXL5QceeGCbbbYJJ37Iy/Dhwy+66KKWlpZwxQMAFUvAAoDq9cwz + z2yzzTaeHCRXf32WcPz48eGKBwAqloAFAFXqpZde2m677dQrsjds2LArrrjCs4QAUNEELACoRm+//fYX + v/jFXr16hSM+ZG399de/6aabwtUPAFQgAQsAqs68efN23XVX915RPQqFwqqrrnrbbbeF9wAAUGkELACo + LlOnTt13330bGhrCyR6qQ7FYHDVq1G233dbe3h7eDABA5RCwAKCKvPHGGwcddFDfvn3DmR6qSW1t7RZb + bHH33XeH9wMAUDkELACoFm+99dYBBxzgc6+oZoVCYfTo0Q8++GB4VwAAFULAAoCqMHHixCOOOKJfv37h + HA/Vqra2dvvtt3/00UfDewMAqAQCFgDk77XXXjv88MP79+8fTvBQ3Wpra7fbbjv3YQFABRGwACBn5XJ5 + 4sSJX/va1wYOHBjO7sC//VtdXd1OO+300EMPdXZ2hncLAJAwAQsAcjZp0qRvfetbQ4YMKRQK4eAO/EXv + 3r333HPPJ554IrxbAICECVgAkK0pU6Yce+yxgwYNCud14B/16tXrc5/73GOPPRbeMwBAqgQsAMjT9OnT + Tz311KFDh4aTOvBh+vbtu88++zzzzDOeJQSAlAlYAJChefPm/fCHPxwyZEg4owMfrbGxcd99950wYUJ4 + /wAA6RGwACA38+fPP/vssz05CIuvsbFxv/32e/XVV8vlcngjAQApEbAAICvNzc0//vGPV1tttXAuBxZP + v379vvKVr0yYMMGzhACQIAELALLyi1/8YsCAAeFEDiyJhoaGgw8+eMqUKe7DAoDUCFgAkIm2trZf/epX + gwcPDmdxYMk1NTUdeeSRkydPDu8rACANAhYAZOKqq64aNmxYOIUDS6t///5HH3301KlTw1sLAEiAgAUA + Ofj1r3/9wak7nL+BZVNbW3vcccc1NzeHNxgA0NMELACoeLfddttaa61VKBTC4RtYZk1NTd/5znc0LABI + hIAFAJXthhtuGDlyZLFYDMduIJK+fft+5zvfCe80AKBHCVgAUKk6OztvuummUaNGlUqlcOAGoqqvrz/j + jDM6OjrCuw4A6CECFgBUqjvuuGPMmDG1tbXhqA10gUGDBl100UXhXQcA9BABCwAq0s0337zpppuqV9DV + CoXCoEGDzjrrrPDeAwB6goAFABWmo6Pj7rvv3n777evr68MJG+hKhUJh1VVX/dnPftbW1hbehwBA9xKw + AKDCPPDAAzvuuKN6Bd2pUCisscYav/jFL8L7EADoXgIWAFSMcrn8hz/8YbvttlOvoPsVi8U11ljjZz/7 + 2QfvxPCeBAC6i4AFAJWhpaXlvvvuGzt2bJ8+fcJ5GuheNTU1o0eP/sUvfjF37tzwzgQAuoWABQAVoLW1 + 9aGHHtp9990bGhrCSRroCaVSaYMNNrj00ks1LADoTgIWAKSuo6PjT3/601577dW7d+9whgZ6Tk1NzSab + bHL11VcvWLAgvEsBgC4mYAFA0trb25955pn99tuvb9++4fQM9LS6urotttji6quvdh8WAHQPAQsA0lUu + lydOnLj//vt/cFoO52YgDcViccyYMb/+9a/dhwUA3UDAAoBElcvlKVOmHH744b169QonZiAlNTU12223 + 3d13393S0hLetwBA1xCwACBR8+fPP/TQQ31qO6SstrZ22223vffee1tbW8NbFwDoAgIWAKTog8Pw0Ucf + HY7IQNp22mmnp556qqOjI7yBAYDYBCwASNFZZ50VTsZAJdh1113feOONcrkc3sMAQFQCFgAk56ijjqqp + qQnHYqASFAqFHXbYYfbs2eFtDABEJWABQEKam5tPOukk9Qoq1B577DFjxozwfgYA4hGwACAVc+fO/fa3 + v93U1BSOwkAF+vznPz9t2rTwrgYAIhGwACAVJ5544oABAwqFQjgHAxXog7fwjjvu2NLSEt7YAEAMAhYA + 9LwZM2aceuqpQ4cOVa8gA6VSaa+99nr77bfDOxwAWGYCFgD0sClTppxyyimrrLJKsVgMx1+gwjU0NOy1 + 114TJkwI73MAYNkIWADQk+bNm/ejH/1ojTXWUK8gM3369Nl///2nTJkS3u0AwDIQsACgx0yfPv3cc88d + OXKkrx2E/BQKhf79+x988MHuwwKAZSdgAUDPmDVr1k9+8pORI0e69wpyVSgUBgwYcPjhh7/66qvhnQ8A + LBUBCwB6wMKFC6+66qoNNthAvYLsDRo06Ljjjps8eXJ4/wMAS07AAoDuNm/evCuuuGLDDTcslUrhgAvk + q1AorLjiiscee+ybb74ZVgEAYAkJWADQrdra2u64444xY8aEoy1QHYYOHfr973/fZ7oDwNIRsACg+7S2 + tt51111bbLFFONEC1WTYsGH/9V//NWPGjLAiAACLTcACgG7S2dn58MMPb7LJJoVCIRxngSqzyiqrnHnm + mdOmTQvrAgCweAQsAOgOHR0dTz755FZbbRVOsUC1WmONNX7yk5+8//77YXUAABaDgAUAXa69vf3hhx/e + dtttw/kVqG5rrrnmxRdfPGfOnLBGAAAfR8ACgK5VLpdfeeWVLbbYwpODwP+3yiqrXHXVVQsXLgwrBQDw + LwlYANCFyuXy888/v+2226pXwP8yfPjwm266adGiRWG9AAA+moAFAF3o8ccf32677UqlUjiwAvyd4cOH + X3vttRoWAHwsAQsAusr06dO33nrrYrEYjqoA/2S11VZ75JFHOjs7w8IBAHwYAQsAusRzzz2300471dTU + hEMqwEdYe+21b731Vg0LAP4FAQsA4nvuued23333urq6cDwF+GiFQmHkyJG33357WEEAgH8iYAFAZNOn + T99nn31qa2vD2RRgMYwcOfL5558P6wgA8I8ELACI6YPz57777tu7d+9wJAVYPIVCYfTo0bfddltYTQCA + vyNgAUA0r7zyykEHHdS3b99wHgVYEsVicZNNNrnrrrvCmgIA/I2ABQBxvPbaa4cffni/fv3CSRRgyZVK + pa222uqee+5pb28PiwsAIGABQBSvv/76EUccMWDAgHAGBVhadXV122233T333BPWFwBAwAKAZTd58uRv + fetbgwYNCqdPgGXTq1evz372sw888EBHR0dYaACguglYALBMpkyZ8u1vf3vw4MHh3AkQQ+/evXfbbbcH + Hnigra0tLDcAUMUELABYerNnzz799NPdewV0hd69e++5555PP/10WHEAoIoJWACwlObOnXvuuee69wro + On369Nlvv/1efPHFsO4AQLUSsABgacycOfPss89eeeWVwykToGv06dPnS1/60oQJE8LqAwBVScACgCXW + 3t5+/fXXL7/88uF8CdCVampqjjrqqFmzZoU1CACqj4AFAEtm3rx5l1xyiXuvgO7U0NDwzW9+c/LkyWEl + AoAqI2ABwBJYsGDBZZddtvrqqxcKhXCsBOgWjY2Nxx133JQpU8J6BADVRMACgMXV2tp60003rbTSSuE0 + CdC9ampqTj31VM8SAlCFBCwAWCxtbW1XXnnlGmusEc6RAD2hqanpO9/5zowZM8LaBADVQcACgI/X2dl5 + 5ZVXjhgxwpODQI/r37//iSee6D4sAKqKgAUAH2PRokXXXHPNOuusE86OAD1twIAB3/3ud6dOnVoul8NS + BQBZE7AA4GNce+2166+/vnuvgKQMHjz4O9/5zrx588JSBQBZE7AA4CN1dnb+7ne/W2+99cJ5ESAlyy+/ + /Pe///3W1tawZgFAvgQsAPhwLS0tN99888Ybb+zeKyBZQ4YM+cEPfuDzsADInoAFAB/uvvvu23TTTUul + UjgmAiRp8ODB5557bli5ACBTAhYAfIgnn3xyiy22qKmpCQdEgIStsMIKF1544cKFC8MSBgDZEbAA4H97 + 5plndthhh7q6unA0BEhboVBYbbXVLrnkkvnz54eFDADyImABwD+YNm3azjvvXCwWw7kQoEKsvPLKv/3t + b8NaBgB5EbAA4H+89tpru+66qycHgUpUKBSGDx9+8803t7e3h0UNAHIhYAFA8Nxzz+2xxx719fXhLAhQ + aUql0gYbbHDzzTeHdQ0AciFgAcCfy+XyK6+8stdee7n3CsjA6NGj77nnns7OzrDGAUDlE7AA4M8vvPDC + fvvt19jYGA5/AJWsWCxuttlmd9xxR7lcDsscAFQ4AQuAavfyyy8feOCBffv2DSc/gMpXKpW22GKLu+66 + K6x0AFDhBCwAqldHR8fzzz9/0EEHqVdAfkql0pZbbnnbbbe1traGVQ8AKpaABUD1euONNw455JABAwaE + 0x5AXurr67fffvt77723o6MjLHwAUJkELACq1OTJkw877LCmpqZwzgPIUW1t7TbbbPPwww+HtQ8AKpOA + BUDV6ezsfP3117/+9a8PHDgwnPAA8tXQ0PCZz3zmvvvu8ywhAJVLwAKg6sybN++EE07o169fONsB5K5X + r1677bbbCy+84HsJAahQAhYA1WXu3Lnf+973+vTpE051ANWhtrb2rw2rs7MzLIgAUDkELACqyLx58844 + 44zll18+nOcAqkljY+Pee+/9pz/9yWe6A1BxBCwAqsiFF17Yu3fvcJIDqD51dXX77bfflClTwrIIABVC + wAKgKixcuPAnP/nJBye3cIYDqFY1NTUHHHDA22+/HdZHAKgEAhYAVeHCCy8cNGhQOL0BVLfGxsaDDz74 + nXfeCUskACRPwAIgc+Vy+bLLLmtqagrnNgD+4tBDD12wYEFYKwEgbQIWADlra2u77LLLVl555UKhEE5s + APxFbW3tV7/61ZkzZ4YVEwASJmABkLNLL710zTXXLBaL4bgGwN9pbGz82te+FlZMAEiYgAVAnhYtWvSL + X/xirbXWUq8A/oWGhoZvfvOb8+fPD6snACRJwAIgQ+Vy+aqrrtpggw1qamrCEQ2AjzBgwICTTz65paUl + rKEAkB4BC4AMXX311euvv36pVAqHMwD+pf79+5900klhDQWA9AhYAGSlubn5mmuu2Wyzzerq6sKxDICP + UygUhgwZ8r3vfW/27NlhPQWAlAhYAGTlzjvv3HLLLdUrgCVVLBaHDRt2/vnnh/UUAFIiYAGQiY6Ojttv + v32zzTbzqe0AS23FFVc855xzWltbw9oKAGkQsADIwcKFC3//+99vv/329fX14RAGwJIrlUprrbXWj370 + o5kzZ4YVFgASIGABUPFaW1vvu+++nXbaqba2NpzAAFhaxWJxxIgRF154oc/DAiAdAhYAla2tre2Pf/zj + zjvv7DsHAWIpFAojR468+OKLNSwAEiFgAVDB2tvbH3vssT322KOhoSGcugCIoaamZqONNrrsssvmzJkT + 1lwA6DkCFgCVqlwuT5w4cddddy0UCuG8BUBUo0aNuvLKK+fNmxdWXgDoIQIWABWpXC6/8cYbe+21lycH + AbpOsVjcdNNNr7vuugULFoT1FwB6goAFQEVauHDhnnvuWVdXF85YAHSNmpqaTTfd9LbbbmtpaQlLMAB0 + OwELgMrT3Ny85557hqMVAF1v4403/uMf/9jR0REWYgDoXgIWABWms7PzwAMP9OQgQDcbM2bMc889Vy6X + w3IMAN1IwAKgwnzxi19UrwB6xLrrruvDsADoEQIWABVjxowZBx10UH19fThIAdDtNt1000mTJoV1GQC6 + i4AFQGWYM2fOoYce2tTUFI5QAPSQzTbbbMqUKWF1BoBuIWABUAE6OzsPPfTQ3r17h8MTAD1qww039KWE + AHQnAQuA1E2ePPmYY44ZPHhwoVAIJycAelRNTc1OO+308ssvh5UaALqYgAVA0t55553jjz9+xRVXVK8A + klJfX//Zz372mWeeCes1AHQlAQuAdE2aNOnb3/72SiutpF4BJKhXr15jx4599tlnw6oNAF1GwAIgUVOm + TDnttNPWWGONUqkUjkoApKRQKCy33HL77rvv888/H9ZuAOgaAhYAKZo6derpp5++6qqruvcKIHFNTU3/ + +Z//+fTTT4cVHAC6gIAFQHJmzJhxwQUXrL322uoVQEUYMGDAV77ylRdffDGs4wAQm4AFQFrmzp17ySWX + rL322sViMRyMAEhboVBYfvnljzjiiFdffTWs5gAQlYAFQEIWLVp0zTXXDB8+PByJAKgcAwcOPOqooyZO + nFgul8OyDgCRCFgApKK1tfW2224bNWpUOAkBUGlWXHHFk08+edKkSWFlB4BIBCwAUvHYY4+tuuqq4QwE + QGUaMGDA9773vWnTpoXFHQBiELAA6Hnt7e0PPPDAiBEjwukHgEq2wgornHnmmTNmzAirPAAsMwELgB7W + 3t5+7733brjhhuHcA0DlW3nllS+44ILZs2eHtR4Alo2ABUBP6uzsfOyxx3xqO0B++vTpc8kllyxYsCCs + +ACwDAQsAHrS448/vvHGGxcKhXDcASAjK6+88jXXXLNo0aKw6APA0hKwAOgx995778Ybb1wsFsNBB4Ds + rLjiij/72c80LACWkYAFQM948MEHN9lkk3C+ASBfQ4YM+dWvftXe3h42AABYcgIWAD3g0Ucf3XrrrUul + UjjcAJC11VZb7Zprrgl7AAAsOQELgO527733brPNNrW1teFYA0DuCoXCKquscskll4SdAACWkIAFQLd6 + 5JFHdtlll7q6unCmAaBqrLnmmu7DAmDpCFgAdJ+nnnpq9913b2hoCEcZAKrMyJEjb7jhhrArAMBiE7AA + 6CZPP/30nnvuqV4BVLNisbj++utfc8015XI5bA8AsBgELAC6wwsvvHDggQc2NTWFEwwA1aqmpmbTTTf9 + zW9+09bWFjYJAPg4AhYAXW7ChAn7779/nz59wtkFgOr214Z1yy23hH0CAD6OgAVA13r99dcPPfTQ5ZZb + LpxaAODf/q2urm6rrba69dZb3YcFwOIQsADoQm+//fbRRx89cODAcF4BgL9paGjYcccd77jjjtbW1rBt + AMBHELAA6CpTpkw5+uijGxsbw0kFAP5RXV3dDjvs8OCDD4adAwA+goAFQJeYNWvWmWee6d4rAP61hoaG + sWPHPvnkk2H/AIAPI2ABEN+UKVNOPPFE9QqAxdHQ0PD5z3/+mWeeCbsIAPwTAQuAyGbOnHn66af3798/ + nEsA4OOUSqW99977lVdeCXsJAPwjAQuAmObOnXveeecNHjw4nEgAYPHU19cffvjhb7/9dthRAODvCFgA + RDN37tzTTjtt8ODBhUIhHEcAYLH16tVrv/32e/XVV8O+AgB/I2ABEMeiRYsuuOCClVZaKZxCAGDJ9erV + 64gjjpg0aVLYXQDgLwQsACJob2+/6KKL1CsAll1DQ8NRRx01bdq0sMcAgIAFQBTnnHPOkCFDwskDAJZN + Y2PjQQcdNGPGjLDNAFD1BCwAlklzc/PFF1+8+uqrhzMHAMSw3HLLff3rX580aVK5XA5bDgBVTMACYOkt + WrToZz/72bBhw8JpAwDiaWpqOvLIIz1LCMAHBCwAllJ7e/vll18+fPjwcM4AgNj69et3zDHHLFy4MOw9 + AFQrAQuApdHc3HzFFVesv/76xWIxHDIAoAsMHDjw+OOPnzJlStiBAKhKAhYAS+PGG29cd9111SsAukG/ + fv1OPvlkn+kOUM0ELACW2B133LHxxhuXSqVwsACALjZo0KAzzzxz3rx5YSsCoMoIWAAsmbvvvnvzzTev + qakJRwoA6HqFQmGllVY688wzZ8+eHTYkAKqJgAXAEnj88cc333zzcJgAgO61wgor/OxnP+vs7AzbEgBV + Q8ACYHE9//zzn/nMZzw5CEAPWnXVVS+//PKwMwFQNQQsABbLAw88sN1223lyEICeVSgU1lprrfHjx4f9 + CYDqIGAB8DE6OzufeOKJXXbZxb1XACRivfXW+81vftPe3h72KgByJ2AB8K90dnY++eSTY8eOra+vD4cG + AEjAqFGjNCyA6iFgAfCvPPvss2PHjm1oaAjHBQBIQ6FQ2GCDDW666aawYwGQNQELgA/X3t7+5JNP/ud/ + /mdjY2M4KwBASorF4qabbvrrX/+6ubk57F4AZErAAuBDtLe3P/XUU3vvvXefPn3CKQEA0lNTU7PZZpvd + cMMNCxYsCHsYADkSsAD438rl8jvvvDNu3Dj3XgGQvpqamjFjxtx///2dnZ1hJwMgOwIWAP/gg+n/xRdf + /PKXv9zU1BROBgCQtrq6uq233vp3v/vdwoULw34GQF4ELAD+R7lcfvPNNw899FBPDgJQWWpra7fddtu7 + 7rqrpaUl7GoAZETAAuB/zJ49++ijj66vrw+nAQCoHKVSaccdd3zmmWc6OjrCxgZALgQsAIIZM2Z885vf + 9LlXAFSu+vr6z372sw899JCGBZAZAQuA4Ac/+EGpVAonAACoTMVicc8993zllVfK5XLY4QCofAIWAH9u + bW09++yz1SsAsvGFL3zhjTfeCPscAJVPwALgz6eddlrfvn3DyA8Ala9UKo0dO3bChAlhqwOgwglYAFWt + ra3t/PPP79evX5j3ASAj++233/Tp08OeB0AlE7AAqte8efPOOeecQYMGhTEfAPJSLBb322+/d955J+x8 + AFQsAQugep1//vlDhw4tFAphzAeA7NTX148bNy7sfABULAELoBrNmzfvvPPOGzZsmHoFQPZ69+59yCGH + zJgxI+yCAFQgAQug6rz//vvnn3/+2muv7WsHAagSffv2PfzwwydNmhT2QgAqjYAFUHXGjx8/fPhw914B + UFX69u37zW9+M+yFAFQaAQugisyePfviiy8eNWqUe68AqEIDBw785je/6T4sgEokYAFUi7lz544fP36j + jTaqqakJgzwAVJNCoTBkyJBvfetbkydPDrsjABVCwAKoCm1tbbfeeusnPvGJMMIDQLUaPHjwWWedtWDB + grBHAlAJBCyA/M2fP//6668fM2aMe68AoFgsDhs27NRTT50yZUrYKQFInoAFkLlFixbddtttW221lc+9 + AoC/KhQKq6666g9/+MPp06eH/RKAtAlYADlrbW29//77t9566zCwAwB/s/rqq59//vkzZ84MuyYACROw + ALLV1tZ23333bbvttu69AoB/VigU1lprrQsuuGDWrFlh7wQgVQIWQJ46OztfeeWVHXbYIQzpAMCHGTFi + xM9//vM5c+aEHRSAJAlYABkql8svvPCCegUAi2Oddda57LLL5s2bF/ZRANIjYAFkqL29fZtttikWi2Ew + BwA+WqFQWGeddW644YaWlpawlQKQGAELIDfTpk3bbrvtwkgOACyeESNG3H333R0dHWFDBSAlAhZAVl5/ + /fXPfvazhUIhDOMAwGIbOXLkvffeWy6Xw7YKQDIELICs7Lzzzr5zEACW2uDBg9va2sK2CkAyBCyATLz5 + 5ptjx46tq6sLAzgAsFSGDx/+7LPPhv0VgDQIWAA5eOutt/bdd98+ffqE0RsAWAbrrrvuc889F3ZZABIg + YAFUvObm5i9/+cu9e/cOQzcAsGwKhcKIESPmzp0b9loAepqABVDZJk6cePDBB/fr1y9M3ABADKVSafPN + N3/sscfCjgtAjxKwACrYxIkTv/rVrw4aNMjXDgJAdHV1dVtvvfUf//jHsO8C0HMELICK1NnZOXHixG98 + 4xuDBg0KUzYAEFt9ff2OO+740EMPtbe3hz0YgJ4gYAFUpDfeeOP4449feeWV3XsFAF2qsbFx9913f+ih + h8IeDEBPELAAKs+kSZNOPvnkFVdcMUzWAEBXamxsHDt27KOPPhp2YgC6nYAFUEnK5fKkSZNOPfXUVVZZ + JczUAEDXa2pq2muvvR5++OG2trawKwPQjQQsgEoya9asc889d5VVVvHkIAB0s+WWW27//fd/7rnnwq4M + QDcSsAAqRnNz8y9/+UtPDgJAT2lqajrooINeeOGFzs7OsD0D0C0ELIDK0NzcfPnllw8bNixM0ABAT+jf + v/8RRxwxYcIEDQugOwlYAJXhiSee6NevX5idAYCe09DQcOKJJ06bNi1s0gB0PQELIHVtbW233nrrkCFD + wtQMAPS0xsbG008/fdasWWG3BqCLCVgASWtvb7/llls8OQgAqenXr99ZZ531/vvvhz0bgK4kYAGkq1wu + P/TQQwMHDgyTMgCQmIsvvri5uTns3AB0GQELIF233XbbmmuuGQZkACA9TU1N559/voYF0NUELIBE3XTT + TWuvvXaxWAwDMgCQpKampnPOOae1tTVs4QB0AQELIDltbW033XTTOuusE+ZiACBtffv2PfvssxcuXBj2 + cgBiE7AAknPzzTdvttlmpVIpDMUAQPIGDx58zjnnhL0cgNgELIC03HLLLZtuumlNTU0YhwGACjFw4MCz + zjor7OgARCVgAaSipaXld7/73dZbb11XVxcGYQCgogwdOvTcc8+dP39+2N0BiETAAkjFfffdt8MOO9TX + 14cRGACoNIVCYfXVV7/ooovC7g5AJAIWQM/r7Oz84x//uP3227v3CgAqXbFYXH311X/605+2t7eHnR6A + ZSZgAfSwcrn85JNP/sd//EdjY2OYfAGASlYqlTbYYIPx48f7XkKAWAQsgB728ssvf/GLX/TkIADkpFQq + jRo16oYbbgj7PQDLRsAC6DHlcvmVV17Ze++9PTkIAPkplUqjR4++/vrrFy1aFPZ+AJaWgAXQY15//fVD + Dz20b9++Yc4FAPJSV1e31VZb3XzzzRoWwDISsAB6xjvvvPOVr3ylUCiECRcAyNEHe/2YMWPuvffeMAEA + sFQELIAe8M477xx11FF9+vQJsy0AkK/a2trtt9/+3nvv9b2EAEtNwALobu++++5Xv/pV9QoAqkddXd1O + O+30yCOPhGkAgCUkYAF0n3K5/M4773z1q19tbGwM8ywAUDV23nnnxx9/vLOzM0wGACw2AQug+8ycOfPY + Y48dMGBAGGMBgGpSV1e3xx57vPDCC2EyAGCxCVgA3WTu3Lnf+MY3+vXrF2ZYAKD61NTUfPazn3355ZfD + fADA4hGwALrDrFmzvvWtby2//PJhegUAqlV9ff0ee+zx/PPPe5YQYPEJWABdrlwun3LKKQMHDgxzKwBQ + 3Xr16rXXXntNnTo1zAoAfBwBC6BrdXZ2fvvb3/ap7QDA36utrd11111nzJgRJgYA/iUBC6ALzZkz56yz + zho8eHCYVQEA/qaxsXG//fZ78803w9wAwEcTsAC6yqJFi84555wVVlghTKkAAP+ooaFh3Lhx06ZNC9MD + AB9BwALoEgsXLrzgggtWXHHFQqEQRlQAgH9SV1d3wAEHeJYQ4F8TsADiW7BgwUUXXbTWWmsVi8UwnAIA + fISmpqYjjjji7bffDpMEAP9EwAKI77LLLlt11VXdewUALKaGhoYjjzxy8uTJYZgA4B8JWAAxtbe3X3PN + Neuuu657rwCAJTJgwIDjjjtuypQpYaoA4O8IWAAx3XDDDRtuuGGpVAqjKADA4ikUCoMHDz7hhBNmzZoV + BgsA/kbAAoijs7PzxhtvXH/99cMQCgCw5AYMGHDqqae2t7eHCQOAvxCwAOK46667tthiC/deAQDLaKWV + VjrnnHM0LIC/J2ABRHD77bdvuumm6hUAsOwKhcJKK6107rnnhjkDAAELYBm1t7ffddddn/rUp2pra8PU + CQCwzFZdddULL7ywpaUlzBwA1U3AAlgmjz/++A477KBeAQDRrbXWWldeeWW5XA5jB0AVE7AAlt6TTz75 + yU9+0pODAEAXWWWVVS6//PIweQBUMQELYGm0tbU99NBDu+yyS0NDQxgwAQBiKxaL66233q9+9av58+eH + KQSgKglYAEusra3tj3/84+c+97levXqF6RIAoGv8tWH98pe/nDt3bphFAKqPgAWwZDo6Op555pndd9+9 + vr4+zJUAAF2pWCyOGjXq2muvbW5uDhMJQJURsACWQGdn55/+9KcvfOELjY2NYaIEAOh6tbW1m2yyyfXX + X69hAdVJwAJYAi+//PIXvvAF3zkIAHS/Uqm0ySabXHfddQsXLgyjCUDVELAAFtfbb7+9//77q1cAQE8p + FotbbLHF73//+7a2tjCgAFQHAQtgsbz33nvjxo3zuVcAQM+qqanZcsst77nnno6OjjCmAFQBAQvg45XL + 5S996UthbAQA6Gmf/OQnH3zwwTCpAFQBAQvg4x199NF1dXVhYAQASMD222//4osvhmEFIHcCFsDHOOqo + oxoaGsKoCACQjDFjxrz22mthZAHImoAF8JGam5uPO+64pqamMCQCACRmxx13fOutt8LsApAvAQvgw73/ + /vsnn3zywIEDw3gIAJCempqa3Xbb7Y033ggTDECmBCyAD9Hc3HzSSSepVwBA+mpqanbeeeeZM2eGOQYg + RwIWwP82a9as0047bejQoYVCIQyGAAAJa2ho2Hfffd99990wzQBkR8AC+AeTJ08+9dRThw0bpl4BABWk + sbFx7733fumll8JMA5AXAQvgf8yYMeOHP/zhaqutpl4BABWnT58+BxxwwJtvvhkmG4CMCFgAwYwZM84/ + //y11167VCqFMRAAoKL079//0EMPff3118N8A5ALAQvg/5k+ffp55503YsSIYrEYBkAAgEpTKBQGDhx4 + yCGHeJYQyIyABfDnOXPmXHbZZaNGjfLkIACQgUGDBh1zzDFvv/12mHUAKp+ABVS7efPm/epXvxo1apR7 + rwCAPBQKhSFDhhx//PFvvfVWmHgAKpyABVS15ubm66+/fsMNN3TvFQCQmZVWWunkk0+eNGlSmHsAKpmA + BVSv1tbW22677d///d/DlAcAkJdVVlnljDPOmDZtWph+ACqWgAVUqfb29jvuuGP06NFhvgMAyNFKK610 + xhlnzJgxI8xAAJVJwAKqUblcfuyxxzbeeOMw2QEA5GvYsGE/+tGPZs2aFSYhgAokYAHV6Mknn9xss83C + TAcAkLvVVlvtxz/+8dy5c8MwBFBpBCyg6rz++uvrrbdemOYAAKrDyiuv/POf/7ylpSWMRAAVRcACqsub + b77pU9sBgOo0bNiw6667rqOjIwxGAJVDwAKqyCOPPLLlllsWCoUwxAEAVJmhQ4def/31YTYCqBwCFlAt + JkyY8KlPfapUKoXxDQCgKi233HIPP/xwmJAAKoSABVSF559//jOf+Ux9fX0Y3AAAqtjQoUPvv//+MCcB + VAIBC8jfo48+uuuuu/bu3TuMbAAAVW/48OG/+c1vwrQEkDwBC8jchAkT9t5778bGxjCsAQDwb/9WLBbX + WWedhx56KMxMAGkTsICcPfvss/vuu2/fvn3DpAYAwN+USqWNNtrojjvuCJMTQMIELCBbzz777AEHHNCv + X78wowEA8I9qa2s322yzW2+9NcxPAKkSsIAMdXR0vPjii4ceeuiAAQPCdAYAwIepq6v71Kc+dfvtt7e2 + toZZCiA9AhaQoQkTJhx++OEDBw4McxkAAB+tV69e22233e23397e3h7GKYDECFhAVsrl8htvvPGNb3xj + +eWXDxMZAAAfp6GhYaeddrr33ns7OzvDXAWQEgELyEe5XH7zzTePP/74wYMHh1kMAIDF09jYuNtuu919 + 992LFi0K0xVAMgQsIB/vvffed77znUGDBoUpDACAJdHY2LjHHns8+OCDbW1tYcACSIOABWRi9uzZ5557 + rs+9AgBYFr17995nn32efvrpjo6OMGYBJEDAAnIwZ86cc845x71XAADLrk+fPuPGjXvmmWc0LCAdAhZQ + 8VpaWq699trevXuHmQsAgGVTW1t72GGHvfPOO2HeAuhpAhZQ2dra2q677rp+/fqFaQsAgBhqa2uPPfbY + 9957L0xdAD1KwAIqWEdHx6WXXurJQQCArtDQ0HDMMcfMmDEjzF4APUfAAipVuVz+3e9+16dPnzBhAQDQ + Bf7rv/5r3rx5YQID6CECFlCprr766hVWWCEMVgAAdI1SqXTqqacuXLgwDGEAPUHAAirSZZddNmzYsEKh + EAYrAAC6TK9evU444YT29vYwigF0OwELqDALFy4cP378mmuuqV4BAHSb+vr6k08+ee7cuWEmA+heAhZQ + SRYuXHjZZZetv/76xWIxDFMAAHSL5ZZb7oQTTpg9e3aYzAC6kYAFVJJrrrlmgw02KJVKYYwCAKAbNTU1 + nXjiiWEyA+hGAhZQGebPn3/11VdvttlmtbW1YYACAKDbDRky5Hvf+960adPClAbQLQQsoAK0tLTcdNNN + W2yxRV1dXRidAADoCYVCYejQoaeffrpnCYHuJGABqWtvb7/nnnu22mqrmpqaMDcBANBzCoXCKqusct55 + 5y1cuDBMbABdTMACktbW1nbPPffsuOOO9fX1YWICAKCnlUqltdZa67zzzps5c2aY2wC6koAFJO3ZZ5/d + bbfd3HsFAJCaYrE4YsSIK664oq2tLYxuAF1GwALS9eqrr37hC18IIxIAAOkZOXLklVde2dzcHAY4gK4h + YAGJeumll/baay+f2g4AkLJSqbThhhteeeWVCxYsCGMcQBcQsIDklMvliRMnHnjggWEsAgAgbZtssskd + d9zxwRQX5jmA2AQsIC2dnZ0vv/zy/vvvX1tbGwYiAACSt9lmm91yyy0tLS1hqgOISsAC0vL222/vv//+ + vXr1CqMQAACVoFQqbbHFFg888ECY6gCiErCAVHR2dr722msHHnigz70CAKhQW2211R/+8AffSwhEJ2AB + SSiXy2+88cZBBx3Up0+fMP4AAFBpSqXSNttsc//992tYQFwCFpCEBQsWfOlLX+rdu3eYfQAAqEzFYnHL + Lbd86aWXwpwHEIOABfS8SZMmfeUrX+nbt2+YegAAqGQ1NTXbbbfdI4880t7eHgY+gGUjYAE9bNasWV/7 + 2tfUKwCAnNTV1e20007PP/98Z2dnGPsAloGABfSklpaWY489tra2Nkw6AADkolgsbr/99lOnTg2TH8Ay + ELCAHvPee++ddNJJ/fr1CzMOAAB5qa+v32WXXV588cUw/wEsLQEL6Bnz588/7bTTBg4cGKYbAAByVFdX + t/vuu7/zzjthCgRYKgIW0APmzZt35plnLrfccmGuAQAga//xH//hWUJgWQhYQHd7//33f/jDH66yyiqF + QiFMNAAAZK2hoWHcuHGvvPJKmAgBlpCABXS3n/70pyuvvHKYZQAAqA719fVf+tKX3nzzzTAUAiwJAQvo + PvPnz7/wwgtXXXXVMMUAAFBNGhsbDznkkNdffz1MhwCLTcACus8vf/nLtddeu1gshhEGAIBqUigUBgwY + cOSRR06ZMiUMiACLR8ACukNra+svf/nLtdZaKwwvAABUq379+h177LELFiwIkyLAYhCwgC63cOHCK6+8 + ctSoUe69AgDgAwMHDjzhhBNmzZoV5kWAjyNgAV3ut7/97brrrqteAQDw/w0cOPD0008P8yLAxxGwgC60 + cOHC66+/fvTo0eoVAAD/yworrHDaaafNmTMnzI4AH03AArpKW1vbXXfdNWbMmNra2jCkAADA3xQKhaFD + h15wwQXNzc1hggT4CAIW0CXK5fKjjz46evToMJ4AAMCHGThw4M9//vPOzs4wRwJ8GAELiK+1tfXOO+/8 + 5Cc/WVNTEwYTAAD4MIVCYdiwYT/+8Y9nz54dpkmAfyJgAZG1tbX94Q9/2GabbTw5CADA4igWi2usscZF + F12kYQEfRcACYuro6Hj44Ye32WabMIwAAMDiWX311X/+85/7THfgQwlYQDR//dyrnXfeub6+PowhAACw + eEql0nrrrXfppZfOnz8/zJcAfyNgAdE899xzO+200weTR5hBAABgSRQKhZEjR44fP37hwoVhxAT4CwEL + iOO5557bZZddwugBAABLa4MNNrjqqquam5vDoAkgYAFRvPPOO7vuuqtPbQcAYNmVSqXRo0ffdNNN5XI5 + jJtA1ROwgGW1aNGiXXbZpVgshokDAACW2TrrrHPHHXd0dnaGoROobgIWsExmzJix995719XVhUEDAAAi + +cQnPnH//feHuROobgIWsEz23Xdf3zkIAEAXGTly5IQJE8LoCVQxAQtYSjNnzjzwwAN79+4dhgsAAIit + UChssskm7777bphBgWolYAFL47333jv88MObmprCZAEAAF2jpqZm2223ffXVV8MkClQlAQtYYvPmzTvy + yCP79OkTZgoAAOhKf70Pa8aMGWEeBaqPgAUsmalTpx5//PGDBg36YIwIAwUAAHSx+vr6XXbZxX1YULUE + LGAJvP3228cff/yKK66oXgEA0M169eq16667PvPMM2E2BaqJgAUslnK5/Pbbb5944omDBw8OEwQAAHSv + hoaGsWPHPv30052dnWFOBaqDgAUslsmTJ5966qmrrbZasVgM4wMAAHS7pqamfffd909/+lOYU4HqIGAB + H2/q1Knf//73V111VU8OAgDQ45qamvbZZx/PEkJVEbCAf6VcLr/33ntnn332GmusEeYFAADoaf379z/o + oIOeffZZzxJClRCwgH9lzpw5F1544fDhw917BQBAUgYOHHj44Ye/9tprYXIFsiZgAR9pwYIFl1122bBh + w8KMAAAAKenXr99hhx32+uuvh/kVyJeABXy4lpaWX//61+uss06YDgAAID2DBw8+4YQTJk+eHKZYIFMC + FvAhOjo67rrrrqFDh4a5AAAAUtWvX7+TTz55xowZYZYFciRgAR/i4YcfXnnllcNEAAAAaevfv/93v/vd + adOmlcvlMNECeRGwgP/tkUceGTFiRJgFAACgEgwZMuTMM8+cO3duGGqBvAhYwD948sknl19++TAFAABA + 5WhoaDjvvPNaW1vDaAtkRMAC/seDDz647rrrhv0fAAAqzcCBAy+88EIPEkJ+BCwguPPOOzfaaKNisRg2 + fwAAqEDLL7/8L37xizDjArkQsIA/l8vlO++88xOf+ESpVArbPgAAVKz6+vqf//znnZ2dYd4FKp+ABfz5 + D3/4w7bbbltXVxc2fAAAqHArr7zy5ZdfHuZdoPIJWFDt7rzzzm233bZXr15hqwcAgMpXKBSGDh160UUX + hakXqHACFlSvzs7O++6773Of+1zv3r3DPg8AALkoFotrrbXW+PHj29vbwwQMVCwBC6rXY489tsceezQ2 + NoYdHgAA8lIqldZff/1rr702TMBAxRKwoEo99thju+++e0NDQ9jbAQAgR6VSaZ111hk/fnyYg4HKJGBB + 1Wlvb3/iiSfGjRu33HLLhV0dAADyVVdXN2bMmOuuu27RokVhJgYqjYAFVefFF18cN25cnz59wn4OAAC5 + q62t/fd///cbb7yxra0tjMVARRGwoIp0dna+9NJLX/7yl9UrAACqTW1t7Sc/+clbbrnFZ7pDJRKwoFqU + y+WJEyceeeSRAwYMCHs4AABUk4aGhh133PHWW29duHBhmJKBCiFgQbWYNGnSkUce6VPbAQCoZrW1tTvs + sMNdd93V0tISBmWgEghYUBVmzJhxwgkn9O3bN+zbAABQrXr16rXbbrs9/PDDniWECiJgQf5mz5793e9+ + 13cOAgDAXzU0NIwdO/bJJ5/s6OgIQzOQNgELMrdgwYJTTjmltrY27NUAAMBfjB079tVXXw1zM5A2AQty + 1tbW9qMf/aipqSls0QAAwN/U1NSMGzfu3XffDdMzkDABC3L23e9+V70CAICPUlNTs88++7z33nthgAZS + JWBBnjo6Os4999x+/fqFnRkAAPgIBx988KxZs8IkDSRJwII8/eQnP+nfv3/YkAEAgI9WLBa/9rWvtbS0 + hGEaSI+ABRn6wQ9+sPzyy4fdGAAA+Dg1NTV77713mKeB9AhYkJV58+adf/75q6++eqFQCFsxAACwGHr1 + 6nXYYYfNmDEjzNZASgQsyMfs2bP/+7//e4011igWi2ETBgAAFltDQ8MhhxwyefLkMGEDyRCwIBOtra0/ + +9nP1l57bfUKAACWWp8+fQ4//PA5c+aEORtIg4AFOfhgf/35z38+evTompqasPECAABLrlAoDBo06Oij + j3733XfDtA0kQMCCijdv3rzx48erVwAAEMVfG9Zxxx339ttvh5kb6GkCFlS21tbWG2+8cbPNNlOvAAAg + lkKhsOKKK5566qk+0x0SIWBBBWtra7vlllu22GKL2trasNMCAAAxFIvFVVdd9fvf//7UqVPD/A30HAEL + Ktj999+/5ZZbFgqFsMcCAADxfDBpr7rqquecc87MmTPDCA70EAELKtVTTz210047ha0VAADoGsOHD7/k + kkvmz58fBnGgJwhYUJGeeuqpT3/608ViMWyqAABA1ygUCmuvvfall166cOHCMI4D3U7AggpTLpf/9Kc/ + fe5znwvbKQAA0PXWW2+9G264ob29PczlQPcSsKCSdHR0PPvss2PHjg27KAAA0F1GjRr161//uqWlJUzn + QDcSsKCSvPnmm5/5zGdqamrCFgoAAHSj9ddf//bbb+/s7AwDOtBdBCyoDB/skS+99NIee+xRV1cXNk8A + AKDbbbTRRr///e9bW1vDpA50CwELKkBnZ+czzzyz55571tfXh20TAADoIRtvvPHNN9/sM92hOwlYUAGm + TZs2duzY2trasGECAAA9avTo0Q8//HBHR0cY2YEuJmBB6l5//fV99tmnd+/eYasEAAB6WqlUGjNmzD33 + 3ON7CaF7CFiQtAkTJuy33369evUK+yQAAJCGUqm0+eab33nnnT7THbqBgAXpmjFjxiGHHOLJQQAASFOh + UNhyyy1feumlMMEDXUbAgkS9+eabhx12WJ8+fcLeCAAApKdUKm299daPPPJImOOBriFgQYqmTp167LHH + LrfccmFXBAAAUlUqlT796U8//fTTYZoHuoCABcl5//33v/vd7/br1y/shwAAQPJ22WWXiRMnhpkeiE3A + grTMmDHjxBNPHDBgQNgGAQCASlBTU7PLLrs8+eSTYbIHohKwICEdHR1nnXXW4MGDwx4IAABUjvr6+s9/ + /vPPP/98mO+BeAQsSMXs2bN/+MMfrrzyymH3AwAAKk3v3r333Xdf30sI0QlYkITm5ubzzjtv2LBhYd8D + AAAqU58+fcaNG/fqq6+GWR+IQcCCntfc3HzRRRetttpqYccDAAAqWVNT01e/+tWZM2eGiR9YZgIW9LBZ + s2ZdcMEFw4cPLxQKYbsDAAAqXL9+/Q477LC33norzP3AshGwoCe1tLRcddVVa665pnoFAACZaWpqOvHE + E+fPnx+mf2AZCFjQY+bNmzd+/PiRI0eqVwAAkKUBAwaccMIJ7733XjgDAEtLwIKeMW/evF/96lejRo0q + lUphcwMAALIzaNCgk046afLkyeEkACwVAQt6QHt7+x/+8If1118/7GkAAEC+BgwY8N///d8LFiwI5wFg + yQlY0N0WLVr0m9/8ZqONNioWi2FDAwAAsjZ48OAf/OAH06dPD6cCYAkJWNCt2trabr311jFjxpSADxNG + PAAqWaFQCMs68DfFYnHYsGHnnHPOrFmzwtkAWBICFnSrzs7Od95554UXXngV+DuvvfbaK6+8cvbZZ4ej + DwCVbPfdd7/77rs/WNvDKg/8xcsvv/zBfy5cuDCcDYAlIWABkIS2trbrr78+HH0AqGT77bffxIkTw/oO + ADEIWAAkobW19dprrw1HHwAq2b777vvaa6+F9R0AYhCwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuA + JAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACI + TsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2 + BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiC + gAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgE + LACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPA + AiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhY + ANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsAC + IAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwA + ohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQ + DQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACS + IGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6 + AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQ + sACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkC + FkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOw + AEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQEL + gOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGAB + ZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuA + JAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACI + TsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2 + BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiC + gAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgE + LACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPA + AiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhY + ANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsAC + IAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwA + ohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQ + DQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACS + IGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6 + AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQ + sACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkC + FkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOw + AEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQEL + gOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGAB + ZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuA + JAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACI + TsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2 + BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiC + gAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgE + LACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPA + AiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhY + ANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsAC + IAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwA + ohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQ + DQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACS + IGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6 + AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQ + sACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkC + FkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOw + AEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQEL + gOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGAB + ZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuA + JAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACI + TsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2 + BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiC + gAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgE + LACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPA + AiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhY + ANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsAC + IAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwA + ohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQ + DQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACS + IGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6 + AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQ + sACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkC + FkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOw + AEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQEL + gOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGAB + ZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuA + JAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACI + TsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2 + BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiC + gAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgE + LACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPA + AiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhY + ANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsAC + IAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwA + ohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQ + DQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACS + IGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6 + AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQ + sACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkC + FkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOw + AEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQEL + gOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGAB + ZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuA + JAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACI + TsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2 + BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiC + gAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgE + LACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPA + AiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhY + ANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsAC + IAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwA + ohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQ + DQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACS + IGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6 + AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQ + sACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkC + FkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOw + AEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQEL + gOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGAB + ZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuA + JAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACI + TsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2 + BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiC + gAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgE + LACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPA + AiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhY + ANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsAC + IAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwA + ohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQ + DQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACS + IGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6 + AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQ + sACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkC + FkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOw + AEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQEL + gOgELACSIGABZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGAB + ZEPAAiA6AQuAJAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuA + JAhYANkQsACITsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGABZEPAAiA6AQuAJAhYANkQsACI + TsACIAkCFkA2BCwAohOwAEiCgAWQDQELgOgELACSIGAB/N927JgGAACGAZB/1ZuJHk0DMpghsACIE1gA + VBBYADMEFgBxAguACgILYIbAAiBOYAFQQWABzBBYAMQJLAAqCCyAGQILgDiBBUAFgQUwQ2ABECewAKgg + sABmCCwA4gQWABUEFsAMgQVAnMACoILAApghsACIE1gAVBBYADMEFgBxAguACgILYIbAAiBOYAFQQWAB + zBBYAMQJLAAqCCyAGQILgDiBBUAFgQUwQ2ABECewAKggsABmCCwAwu4ej4xMIvtH5CsAAAAASUVORK5C + YII= + + + + + iVBORw0KGgoAAAANSUhEUgAABkAAAARrCAYAAADb+Gp7AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + wAAADsABataJCQAASClJREFUeF7s3Q+k3vX///F85SNJJjMzk0ySyXwkk8nMJEkyyWQySSaZZGYmGUmS + ZJJJZpLMJJlkJjOZj5mZmZmZyczMzBwzxxzHMcfv93hXq7ad/+d9Xdf7/Xrf7tx8vt+vjy/V2RXn4Xq+ + 7pMkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkqbiWxdo//0dJkiRJkiRJkqQyWhXHYtsf/5skSZIk + SZIkSVIB/Tf+XwzFN/FgSJIkSZIkSZIktbpqALkV1QhS/eeheCkkSZIkSZIkSZJa278HkNvOxkchSZIk + SZIkSZLUyiYaQCo3Yl8sDEmSJEmSJEmSpFY12QBSqf7v1QPp60KSJEmSJEmSJKk1TTWA3HYlPgxJkiRJ + kiRJkqRWNJMBpFL9d/bG4pAkSZIkSZIkSWp0Mx1Abjsda0OSJEmSJEmSJKmxzXYAqYzF1pAkSZIkSZIk + SWpkcxlAbvshVoQkSZIkSZIkSVKjms8AUjkfr4YkSZIkSZIkSVJjmu8Actv2WBaSJEmSJEmSJEkDr64B + pFKdxHopJEmSJEmSJEmSBlqdA0ilOom1OR4ISZIkSZIkSZKkgVT3AFIZjq9iZUiSJEmSJEmSJPW9Xgwg + ler/56F4IyRJkiRJkiRJkvparwaQ236PHbEgJEmSJEmSJEmS+lKvB5DK9dgXq0KSJEmSJEmSJKnn9WMA + qYzFidgQkiRJkiRJkiRJPa1fA8htV+PjkCRJkiRJkiRJ6ln9HkAqI3EgHg1JkiRJkiRJkqTaG8QAUhmP + S7E6JEmSJEmSJEmSam1QA8i/7QhJkiRJkiRJkqTaasIAUjkSkiRJkiRJkiRJtdSUAaRSvQ3yXEiSJEmS + JEmSJM2rJg0gt30eC0OSJEmSJEmSJGlONXEAqVQnsXwbRJIkSZIkSZIkzammDiCVi7E5loYkSZIkSZIk + SdKMa/IAUhmO3fFsSJIkSZIkSZIkzaimDyCV8ahOYm2I+0OSJEmSJEmSJGnK2jCA3PZ7fByPhSRJkiRJ + kiRJ0qS1aQCp3Igfw0ksSZIkSZIkSZI0aW0bQG47EW+FJEmSJEmSJEnSPbV1AKlcil0hSZIkSZIkSZJ0 + R20eQCojUT2QvigkSZIkSZIkSZL+qO0DyG3VA+kbQ5IkSZIkSZIkqZgBpDIU34YkSZIkSZIkSep4JQ0g + leqv5XgsC0mSJEmSJEmS1NFKG0BuuxybQpIkSZIkSZIkdbBSB5DKWDiJJUmSJEmSJElSByt5ALmtOom1 + JiRJkiRJkiRJUkfqwgBSuRJb48GQJEmSJEmSJEmF15UBpDIee6L6a5YkSZIkSZIkSQXXpQHktv/FhpAk + SZIkSZIkSYXWxQGkUp3E+iiWhCRJkiRJkiRJKqyuDiC37Q0PpEuSJEmSJEmSVFhdH0Aqx+LdkCRJkiRJ + kiRJhWQA+dO1+DIeCUmSJEmSJEmS1PIMIP+o/j78Ei+HJEmSJEmSJElqcQaQe52OD0KSJEmSJEmSJLU0 + A8jEhuLbWBqSJEmSJEmSJKllGUAmNxZHYl1IkiRJkiRJkqQWZQCZ3qXYHpIkSZIkSZIkqSUZQGZmNL6P + JSFJkiRJkiRJkhqeAWR2TsaqkCRJkiRJkiRJDc4AMnvVt0E2hSRJkiRJkiRJamgGkLnbG4tDkiRJkiRJ + kiQ1LAPI/Pweq0OSJEmSJEmSJDUoA0g93o2lIUmSJEmSJEmSGpABpD77wrdBJEmSJEmSJElqQAaQep2N + t+LhkCRJkiRJkiRJA8oAUr8b8UU8E5IkSZIkSZIkaQAZQHpjLA7G+pAkSZIkSZIkSX3OANJb52J7LAxJ + kiRJkiRJktSnDCC9NxTfxcqQJEmSJEmSJEl9yADSH6NxLF4LSZIkSZIkSZLU4wwg/XU5doQkSZIkSZIk + SephBpD+G46fY1FIkiRJkiRJkqQeZAAZjOrv+e/xXEiSJEmSJEmSpJozgAzWWDiJJUmSJEmSJElSzRlA + muFwSJIkSZIkSZKkmjKANMdQrAxJkiRJkiRJkjTPDCDNMh6fhyRJkiRJkiRJmkcGkGb6LVaEJEmSJEmS + JEmaQwaQ5roQm2JRSJIkSZIkSZKkWWQAabYb8XX4NogkSZIkSZIkSbPIANIOh+LVuD8kSZIkSZIkSdI0 + GUDa41x8GItDkiRJkiRJkiRNkQGkXa7H3ngmJEmSJEmSJEnSJBlA2ulovBGSJEmSJEmSJGmCDCDtdSG+ + DEmSJEmSJEmSdFcGkHYbiYOxNCRJkiRJkiRJ0l8ZQMpwOt4KSZIkSZIkSZKUDCDluBq7Q5IkSZIkSZKk + zmcAKctYHIknQ5IkSZIkSZKkzmYAKVP1QPo7IUmSJEmSJElSJzOAlOtmfB2SJEmSJEmSJHUuA0j5/hcr + Q5IkSZIkSZKkzmQA6YYr8W5IkiRJkiRJktSJDCDdsis8kC5JkiRJkiRJKj4DSPf8FutCkiRJkiRJkqRi + M4B0U3USa1s8EpIkSZIkSZIkFZcBpNt2x6qQJEmSJEmSJKmoDCAcibdCkiRJkiRJkqRiMoBQuRqfxpKQ + JEmSJEmSJKn1GUC4bSx+jJdDkiRJkiRJkqRWZwDhbqdia0iSJEmSJEmS1NoMIEzkWnwTj4UkSZIkSZIk + Sa3LAMJkRuNQvBKSJEmSJEmSJLUqAwhTGY8LsSUkSZIkSZIkSWpNBhBmYiR2x6KQJEmSJEmSJKnxGUCY + qerbICdiZUiSJEmSJEmS1OgMIMzWcLwRkiRJkiRJkiQ1NgMIc/VdSJIkSZIkSZLUyAwgzMfFeCwkSZIk + SZIkSWpUBhDq8HYsDEmSJEmSJEmSGpEBhLrsi2dCkiRJkiRJkqSBZwChTmfj9VgQkiRJkiRJkiQNLAMI + dbsen0b1syVJkiRJkiRJ0kAygNALo/FLvBKSJEmSJEmSJPU9Awi9dCa2hAfSJUmSJEmSJEl9zQBCr12N + 3fF0SJIkSZIkSZLUlwwg9EN1EutIrAtJkiRJkiRJknqeAYR+uhAfhCRJkiRJkiRJPc0AQr9dj/3xcEiS + JEmSJEmS1JMMIAxC9TN3Lp4NSZIkSZIkSZJqzwDCIA3H9pAkSZIkSZIkqdYMIAzaWBwKSZIkSZIkSZJq + ywBCU1yKZ0KSJEmSJEmSpHlnAKFJRuOzkCRJkiRJkiRpXhlAaKLqJNbjIUmSJEmSJEnSnDKA0FS/x5vx + YEiSJEmSJEmSNKsMIDTZjfgynghJkiRJkiRJkmacAYQ2OBgvhyRJkiRJkiRJM8oAQlucja2xMCRJkiRJ + kiRJmjIDCG1SncTaEytCkiRJkiRJkqRJM4DQRodjQ0iSJEmSJEmSNGEGENrqfHwRkiRJkiRJkiTdkwGE + NhuJH+OJkCRJkiRJkiTp7wwglOB4vB2SJEmSJEmSJP2RAYRSXI5dIUmSJEmSJEmSAYSiVCexfo0VIUmS + JEmSJEnqcAYQSjMeZ2NTSJIkSZIkSZI6mgGEUg3HlyFJkiRJkiRJ6mAGEEpXncR6MiRJkiRJkiRJHcoA + QhdciY0hSZIkSZIkSepIBhC65ItYGpIkSZIkSZKkwjOA0DWH4/mQJEmSJEmSJBWcAYQuuhbvxMMhSZIk + SZIkSSowAwhd9mU8E5IkSZIkSZKkwjKA0HW/xYaQJEmSJEmSJBWUAQTuu+9q7IhHQ5IkSZIkSZJUQAYQ + +NNo7I0XQ5IkSZIkSZLU8gwg8I/xOBHvhSRJkiRJkiSpxRlA4F5X4qt4PCRJkiRJkiRJLcwAAhO7GQfj + pZAkSZIkSZIktSwDCEyu+rNxPpzEkiRJkiRJkqSWZQCB6Q3H1/FISJIkSZIkSZJakAEEZmYsjkf1Z0aS + JEmSJEmS1PAMIDA7N+L1kCRJkiRJkiQ1OAMIzM3ukCRJkiRJkiQ1NAMIzN3FkCRJkiRJkiQ1MAMIzM94 + vBmSJEmSJEmSpAZlAIF67IsnQpIkSZIkSZLUgAwgUJ8zsS4eDkmSJEmSJEnSADOAQL2G4uN4MiRJkiRJ + kiRJA8oAAvUbjf3xQkiSJEmSJEmSBpABBHrnVGyOR0KSJEmSJEmS1McMINBbV2JXPBWSJEmSJEmSpD5l + AIHeG4nD8VJIkiRJkiRJkvqQAQT651xsC0mSJEmSJElSjzOAQH9dix9DkiRJkiRJktTDDCDQf9WfudOx + MiRJkiRJkiRJPcgAAoNzNT4MSZIkSZIkSVLNGUBgsG7GgZAkSZIkSZIk1ZgBBJrhfDwXkiRJkiRJkqQa + MoBAc9yIj0KSJEmSJEmSNM8MINA8B2NhSJIkSZIkSZLmmAEEmulcrA9JkiRJkiRJ0hwygEBzVSexPo+l + IUmSJEmSJEmaRQYQaL6f4/mQJEmSJEmSJM0wAwi0w5l4Lx4KSZIkSZIkSdI0GUCgPaqTWLtieUiSJEmS + JEmSpsgAAu1zIDyQLkmSJEmSJElTZACBdjofH4UkSZIkSZIkaYIMINBeN+O7eCokSZIkSZIkSf/KAALt + 9794KyRJkiRJkiRJf2UAgTJcjC9CkiRJkiRJkpQMIFCO6iTWz/F0SJIkSZIkSVKnM4BAWcbjdLwdkiRJ + kiRJktTZDCBQpuvhJJYkSZIkSZKkzmYAgbIdiCdDkiRJkiRJkjqVAQTKVz2Qvi4kSZIkSZIkqTMZQKA7 + Po7/hCRJkiRJkiQVnwEEuuVQPB2SJEmSJEmSVHQGEOie6oH01+P+kCRJkiRJkqQiM4BAd30aK0KSJEmS + JEmSissAAt32W3ggXZIkSZIkSVJxGUCAK7E1HgtJkiRJkiRJKiIDCFAZje/i+ZAkSZIkSZKk1mcAAW4b + j2OxKSRJkiRJkiSp1RlAgLtdjs9jWUiSJEmSJElSKzOAABMZjp/DSSxJkiRJkiRJrcwAAkym+mw4G++E + JEmSJEmSJLUqAwgwnaH4KhaEJEmSJEmSJLUiAwgwE6NxNJaHJEmSJEmSJDU+AwgwG9fi9ZAkSZIkSZKk + RmcAAWZrPPaEJEmSJEmSJDU2AwgwV9UD6ZIkSZIkSZLUyAwgwHxUnx9vhCRJkiRJkiQ1KgMIUIe98UhI + kiRJkiRJUiMygAB1OR0vxAMhSZIkSZIkSQPNAALU6Vp8GMtCkiRJkiRJkgaWAQSo22j8GKtDkiRJkiRJ + kgaSAQTolRPxdiwISZIkSZIkSeprBhCgly7Hl/FESJIkSZIkSVLfMoAAvTYSB6J6IF2SJEmSJEmS+pIB + BOiX07E1JEmSJEmSJKnnGUCAfroae0OSJEmSJEmSepoBBOi36jPnWKwKSZIkSZIkSepJBhBgUC7EjpAk + SZIkSZKk2jOAAIM0HPtDkiRJkiRJkmrNAAIM2nhUD6SvDUmSJEmSJEmqJQMI0BTXwkksSZIkSZIkSbVk + AAGapPo2yE8hSZIkSZIkSfPKAAI00dl4JSRJkiRJkiRpThlAgKaqHkj/OBaEJEmSJEmSJM0qAwjQdD/E + cyFJkiRJkiRJM84AArTB6Xg77g9JkiRJkiRJmjYDCNAWN+OzeCIkSZIkSZIkacoMIEDb7I91IUmSJEmS + JEmTZgAB2uhcbA1JkiRJkiRJmjADCNBWw/FNVJ9jkiRJkiRJknRHBhCg7Q7HxpAkSZIkSZKkvzOAACX4 + PT4NSZIkSZIkSfojAwhQiuok1o/xTEiSJEmSJEnqeAYQoCTV59mJeDMkSZIkSZIkdTgDCFCia+EkliRJ + kiRJktThDCBAqarPtv3xZEiSJEmSJEnqWAYQoHQX4qWQJEmSJEmS1KEMIEBXbA9JkiRJkiRJHckAAnTJ + 4VgUkiRJkiRJkgrPAAJ0zY14PiRJkiRJkiQVnAEE6KqP4vGQJEmSJEmSVGAGEKDLfgvfBpEkSZIkSZIK + zAACdN3l2BxLQ5IkSZIkSVIhGUAA7rtvJHbH6pAkSZIkSZJUQAYQgD9Vn4X/i40hSZIkSZIkqeUZQADu + dDE+iWUhSZIkSZIkqaUZQADudSN+ijUhSZIkSZIkqYUZQAAmVn02noq3QpIkSZIkSVLLMoAATO1KfBkP + hiRJkiRJkqSWZAABmN7NOBKPhyRJkiRJkqQWZAABmLnL8XpIkiRJkiRJangGEIDZGY3dIUmSJEmSJKnB + GUAA5qZ6IF2SJEmSJElSQzOAAMzdcKwPSZIkSZIkSQ3LAAIwf9+HJEmSJEmSpAZlAAGox8lYHZIkSZIk + SZIakAEEoD5XYmssCUmSJEmSJEkDzAACUK/R2BsrQ5IkSZIkSdKAMoAA9MbR2BgPhSRJkiRJkqQ+ZwAB + 6J1L8Xk8FpIkSZIkSZL6mAEEoLeqk1g/xdqQJEmSJEmS1KcMIAD9cSK2hCRJkiRJkqQ+ZAAB6J+r8W1I + kiRJkiRJ6nEGEID+qj5zD8eakCRJkiRJktSjDCAAg3EutockSZIkSZKkHmQAARic67EvJEmSJEmSJNWc + AQRgsKrP4OPxfEiSJEmSJEmqKQMIQDNcjg9DkiRJkiRJUg0ZQACaYyycxJIkSZIkSZJqyAAC0DwnY21I + kiRJkiRJmmMGEIBmuhnbQ5IkSZIkSdIcMoAANNv3UX1WS5IkSZIkSZpFBhCA5jsdr4ckSZIkSZKkGWYA + AWiHkdgRj4UkSZIkSZKkaTKAALTLvnghJEmSJEmSJE2RAQSgfc7E5pAkSZIkSZI0SQYQgHYaji9jRUiS + JEmSJEm6KwMIQHuNx8HYEJIkSZIkSZL+lQEEoP3OR/VAuiRJkiRJkqS/MoAAlOFGfB/PhCRJkiRJktT5 + DCAA5RiLY+EkliRJkiRJkjqfAQSgPFfio5AkSZIkSZI6mwEEoEwj8VM8EZIkSZIkSVLnMoAAlGs8qgfS + XwhJkiRJkiSpUy0PAwhA2aq3QbaFJEm1tygejaUAAAANsjDWhQEEoBsOhyRJtXYiJvqXDgAAAAD0082o + zh9KklRL/4uJ/oUDAAAAAIOwI6pvAkqSNK8MIAAAAAA0TXUS69mQJGnOGUAAAAAAaKJL8XYsDkmSZp0B + BAAAAICmqt4F2RW+DSJJmnUGEAAAAACa7FYciddDkqQZZwABAAAAoA1+j+qB9MdCkqRpM4AAAAAA0BbX + 44dYFZIkTZkBBAAAAIA2qU5iHY+NIUnSpBlAAAAAAGijS7EzJEmaMAMIAAAAAG01HIfj0ZAk6Y4MIAAA + AAC03cV4PSRJ+jsDCAAAAAAluBG7QpKkPzKAAAAAAFCK2w+k3x+SpI5nAAEAAACgNNdifUiSOpwBBAAA + AIASjcWekCR1NAMIAAAAACU7Ec+EJKljGUAAAAAAKN3leC8eCklSRzKAAAAAANAF1Umsb2NFSJI6kAEE + AAAAgC75LV6P/4QkqeAMIAAAAAB0zcX4OJaGJKnQDCAAAAAAdFF1EmtvrA5JUoEZQAAAAADosqOxOSRJ + hWUAAQAAAKDrrsSukCQVlAEEAAAAAO6771b8EmtCklRABhAAAAAA+Mep2BaSpJZnAAEAAACAO12L7+L+ + kCS1NAMIAAAAANxrLI7EiyFJamEGEAAAAACY3IVwEkuSWpgBBAAAAACmNhLVSawFIUlqSQYQAAAAAJiZ + Y7E6JEktyAACAAAAADM3HJtDktTwDCAAAAAAMHvfxuMhSWpoBhAAAAAAmJsz8WJIkhqYAQQAAAAA5m40 + tsTikCQ1KAMIAAAAAMzfd+GBdElqUAYQAAAAAKjH6XgrJEkNyAACAAAAAPW5EZ/FipAkDTADCAAAAADU + azx+jtdCkjSgDCAAAAAA0BtnY3v8X0iS+pwBBAAAAAB6Zyj2xDMhSepjBhAAAAAA6K3RqH4Ptz4kSX3K + AAIAAAAA/XEpPgxJUh8ygAAAAABA/wzHj7EsJEk9zAACAAAAAP11K87FmpAk9SgDCAAAAAAMxkhsC0lS + DzKAAAAAAMBgHQpJUs0ZQAAAAABg8K7H4yFJqikDCAAAAAA0xwchSaohAwgAAAAANEt1Emt5SJLmkQEE + AAAAAJrnYrwRC0OSNIcMIAAAAADQTMPxZfw3JEmzzAACAAAAAM01HtVJrFdCkjSLDCAAAAAA0HznYnss + DUnSDDKAAAAAAEA7DMX3sTIkSdNkAAEAAACA9rgV1e/0NoQkaYoMIAAAAADQPr/H5yFJmiQDCAAAAAC0 + 03AcjCUhSborAwgAAAAAtFv1QPqrIUn6VwYQAAAAAGi/q/FVSJL+ygACAAAAAGUYjer3fQ+HJHU+AwgA + AAAAlOVivBGS1OkMIAAAAABQnpuxKySpsxlAAAAAAKBc1e//lockdS4DCAAAAACU7XK8E5LUqQwgAAAA + AFC+sfg6Hg9J6kQGEAAAAADojkOxLiSp+AwgAAAAANAtl2J7LApJKjYDCAAAAAB0z63YE6tCkorMAAIA + AAAA3XUk3g5JKi4DCAAAAAB025X4NCSpqAwgAAAAAEB1EuvHWBOSVEQGEAAAAADgthOxJSSp9RlAAAAA + AIB/uxq74+GQpNZmAAEAAAAA7jYah+KlkKRWZgABAAAAACYyHufDSSxJrcwAAgAAAABM5WZUJ7EeCUlq + TQYQAAAAAGA61bdBjsZzIUmtyAACAAAAAMzUUGwMSWp8BhAAAAAAYLa+iQdDkhqbAQQAAAAAmIuzsTIk + qZEZQAAAAACAuboVb8fDIUmNygACAAAAAMxXdRLrmZCkxmQAAQAAAADqcDrWhyQ1IgMIAAAAAFCXG/FR + LA9JGmgGEAAAAACgTmPxU7wSkjSwDCAAAAAAQC+ciffioZCkvmcAAQAAAAB65Wp8HR5Il9T3DCAAAAAA + QC+NxG+xLiSpbxlAAAAAAIB++D22hyT1JQMIAAAAANAv12NfPBqS1NMMIAAAAABAP41F9UD6qpCknmUA + AQAAAAAG4UZsDUnqSQYQAAAAAGBQxuOXkKTaM4AAAAAAAIN2JRaFJNWWAQQAAAAAaIrtIUm1ZAABAAAA + AJrkUCwJSZpXBhAAAAAAoGkuxPp4KCRpThlAAAAAAIAmuhFfxBMhSbPOAAIAAAAANNV4HIwXQ5JmlQEE + AAAAAGi6M7ElFockzSgDCAAAAADQBkOxJ/4bkjRtBhAAAAAAoC2qk1iHo3ogXZKmzAACAAAAALTNufg0 + JGnSDCAAAAAAQBvdiJ9jYUjSPRlAAAAAAIA2OxmvhSTdkQEEAAAAAGi7S/FlSNLfGUAAAAAAgBKMxKFY + HJJkAAEAAAAAilI9kL4xJHU8AwgAAAAAUJrr4SSW1PEMIAAAAABAqX6Nx0JSBzOAAAAAAAAlqx5IfzMk + dSwDCAAAAABQuluxM5aEpI5kAAEAAAAAuqI6ifVCSOpABhAAAAAAoEuqk1ib4+GQVHAGEAAAAACga8Zj + VzwdkgrNAAIAAAAAdNWheD0kFZgBBAAAAADossuxIx4MSQVlAAEAAAAAuu5WfBdrQlIhGUAAAAAAAP50 + NKoH0iUVkAEEAAAAAOAfV+LLWBSSWpwBBAAAAADgTiNxIF4KSS3NAAIAAAAAcK/qXZCz8V5IamEGEAAA + AACAyd2Ir8NJLKllGUAAAAAAAKZWfRvkSDwbklqSAQQAAAAAYGauxYaQ1IIMIAAAAAAAs/NlSGp4BhAA + AAAAgNk7E94FkRqcAQQAAAAAYO5eDUkNzAACAAAAADA/38QTIalBGUAAAAAAAObvdLwc94ekBmQAAQAA + AACox/X4IHwbRGpABhAAAAAAgPqMxQ/xQkgaYAYQAAAAAID6nYp34uGQNIAMIAAAAAAAvXElvooVIanP + GUAAAAAAAHpnJH6N6oF0SX3MAAIAAAAA0HvnYktI6lMGEAAAAACA/rgW38fikNTjDCAAAAAAAP0zGidj + ZUjqYQYQAAAAAID+GwonsaQeZgABAAAAABiM6tsg+0NSDzKAAAAAAAAM1sV4LCTVmAEEAAAAAGDwbsbW + kFRTBhAAAAAAgOY4GJJqyAACAAAAANAs5+OVkDSPDCAAAAAAAM1zPT6LpSFpDhlAAAAAAACaaTx+jjUh + aZYZQAAAAAAAmu1UbI5HQtIMM4AAAAAAADTfUOyK5SFpBhlAAAAAAADa42CsC0nTZAABAAAAAGiXM/FR + SJoiAwgAAAAAQPvciB9iYUiaIAMIAAAAAEB7Vb/jfS0k3ZUBBAAAAACg3X6PL0LSvzKAAAAAAAC03834 + JZaFpGQAAQAAAAAow3icijdD6nwGEAAAAACAslwLJ7HU+QwgAAAAAADlqb4NciAeD6mTGUAAAAAAAMp1 + Pl4NqXMZQAAAAAAAylZ9G+TTeCCkzmQAAQAAAADohuok1qqQOpEBBAAAAACgOy7Fm+HbICo+AwgAAAAA + QPd8HstDKjYDCAAAAABANx2MV0IqMgMIAAAAAEB3XY6t8UhIRWUAAQAAAADotrHYHatDKiYDCAAAAAAA + ler3xZtCKiIDCAAAAAAAt12Kz2JpSK3OAAIAAAAAwL8Nx/54IaTWZgABAAAAAOBut+J0vBNSKzOAAAAA + AAAwmaH4KhaF1KoMIAAAAAAATGU0DsczIbUmAwgAAAAAANMZjyuxPqRWZAABAAAAAGA2dobU+AwgAAAA + AADMVvVAutToDCAAAAAAAMzVCyE1MgMIAAAAAADz8U0sDKlRGUAAAAAAAJivU7Em7g+pERlAAAAAAACo + w1Bsi2UhDTwDCAAAAAAAdRmNfbE6pIFmAAEAAAAAoG7H461YENJAMoAAAAAAANALl+KLWB5S3zOAAAAA + AADQKzfjl3ghpL5mAAEAAAAAoNdOx3sh9S0DCAAAAAAA/XAlvo2HQup5BhAAAAAAAPplNKoH0p8JqacZ + QAAAAAAA6LfL8X5IPcsAAgAAAADAIAzHTyH1JAMIAAAAAACDMh5nY0VItWYAAQAAAABg0IZie0i1ZQAB + AAAAAKAJboWTWKotAwgAAAAAAE1yLl4MaV4ZQAAAAAAAaJrr8XE8HNKcMoAAAAAAANBUP8azIc06AwgA + AAAAAE12Mt6Oh0KacQYQAAAAAACabii+iCdCmlEGEAAAAAAA2mJ/vBzStBlAAAAAAABok9PxQUhTZgAB + AAAAAKBthmN3PBrShBlAAAAAAABoq0OxPqR7MoAAAAAAANBm5+KTkO7IAAIAAAAAQNvdiB/iyZD+yAAC + AAAAAEAJbsXx2BiSAQQAAAAAgKJciU9DHc8AAgAAAABAacZifziJ1eEMIAAAAAAAlOpsrAt1MAMIAAAA + AAAlq74Nsj3UsQwgAAAAAAB0wS/hJFaHMoAAAAAAANAVl8NJrI5kAAEAAAAAoGs+jMdCBWcAAQAAAACg + i6qTWM+HCs0AAgAAAABAV1Unsd6JRaHCMoAAAAAAANBlo7ErngsVlAEEAAAAAICuG4/fYmOokAwgAAAA + AADwpwvxcTwaankGEAAAAAAA+MeN+CHWhlqcAQQAAAAAAO40FifjrVBLM4AAAAAAAMDErsbnsSDUsgwg + AAAAAAAwuZvxa6wItSgDCAAAAAAATG08LseroZZkAAEAAAAAgJmp3gbZGWpBBhAAAAAAAJidU6GGZwAB + AAAAAIDZG401oYZmAAEAAAAAgLnbHWpgBhAAAAAAAJifE/FMqEEZQAAAAAAAYP6uxnuxJNSADCAAAAAA + AFCPkfguVoYGnAEEAAAAAADqdTQ2xEOhAWUAAQAAAACA+l2MT+Px0AAygAAAAAAAQG/cjJ9iTajPGUAA + AAAAAKC3TsS7oT5mAAEAAAAAgN67FLtDfcoAAgAAAAAA/TEaR+LpUI8zgAAAAAAAQH+dj82hHmYAAQAA + AACA/huKvaEeZQABAAAAAIDBGIvjsTJUcwYQAAAAAAAYrMuxLVRjBhAAAAAAABi86oF0J7FqzAACAAAA + AADNcSrWhOaZAQQAAAAAAJrlenwQmkcGEAAAAAAAaKbqJNaK0BwygAAAAAAAQHMdjw2hWWYAAQAAAACA + ZqtOYn0cj4ZmmAEEAAAAAADaoTqJ9WJoBhlAAAAAAACgPU7Fe6FpMoAAAAAAAEC7DMfOeDw0SQYQAAAA + AABop1/itdAEGUAAAAAAAKC9zsaO0F0ZQAAAAAAAoN2ux/fxVOivDCAAAAAAANB+Y1H9zn9DKBlAAAAA + AACgHJfio+h8BhAAAAAAACjLaPwQj0dnM4AAAAAAAEB5xuNMvBydzAACAAAAAADlqr4NsiU6lwEEAAAA + AADKtz8eiM5kAAEAAAAAgG64FquiExlAAAAAAACgW96PRVF0BhAAAAAAAOieA7Eyis0AAgAAAAAA3XQx + 3oyFUVwGEAAAAAAA6K6R2BnFfRvEAAIAAAAAAN02HodjXRSTAQQAAAAAADgT70YxGUAAAAAAAKC7xuLn + eDWKygACAAAAAADdNBSfx5NRXAYQAAAAAADonhOxKYrNAAIAAAAAAN2yO9ZG0RlAAAAAAACgG27E1lgY + xWcAAQAAAACA8h2N4h46nyoDCAAAAAAAlO3rWB6dygACAAAAAABluh6bo5MZQAAAAAAAoDzVyauV0dkM + IAAAAAAAUI7R2B2dzwACAAAAAABluBCdPXl1dwYQAAAAAABot7Goft+/KvRXBhAAAAAAAGiva7EndFcG + EAAAAAAAaKfT8V5oggwgAAAAAADQLtVD5wfi6dAkGUAAAAAAAKA9LsWu0DQZQAAAAAAAoB2OxqbQDDKA + AAAAAABAs92MH2JlaIYZQAAAAAAAoLnOx8exODSLDCAAAAAAANBMh2N9aA4ZQAAAAAAAoFmqk1e747+h + OWYAAQAAAACA5rgYm2NRaB4ZQAAAAAAAoBmq39k/G6ohAwgAAAAAAAzWrfg6VGMGEAAAAAAAGJyheClU + cwYQAAAAAADov/E4GupRBhAAAAAAAOiv0fgk1MMMIAAAAAAA0B/Vtz4uxdpQjzOAAAAAAABA7w3Hr/FQ + qA8ZQAAAAAAAoLcuh5NXfc4AAgAAAAAAvTEWJ2J9qM8ZQAAAAAAAoH5DsTdWhgaQAQQAAAAAAOr1e3wY + S0IDygACAAAAAAD1qE5eHY7XQwPOAAIAAAAAAPN3I76KZ0MNyAACAAAAAADzU5282hSLQg3JAAIAAAAA + AHN3INaEGpYBBAAAAAAA5mZbLAs1MAMIAAAAAADMztXw1kfDM4AAAAAAAMDM7Y8HQw3PAAIAAAAAANMb + j3dCLckAAgAAAAAAUzsXq0ItygACAAAAAAATuxV7Y3GoZRlAAAAAAADgTtW5qyuxPdTSDCAAAAAAAPCP + sTgar4ZanAEEAAAAAAD+dD2+j+WhlmcAAQAAAACAPx863xEqJAMIAAAAAABdVj10fjDWhwrKAAIAAAAA + QFcNxVfxRKiwDCAAAAAAAHTRiXg/VGgGEAAAAAAAumZvPB8qOAMIAAAAAABdcT0+jiWhwjOAAAAAAADQ + BcfijVBHMoAAAAAAAFC6b+OZUIcygAAAAAAAUKqh2BYPhzqWAQQAAAAAgBKdCA+ddzgDCAAAAAAAJbkV + 34U6ngEEAAAAAIBSXI4tIRlAAAAAAABovepbH8fDQ+f6OwMIAAAAAABtdj32hnRHBhAAAAAAANrqfGwO + 6Z4MIAAAAAAAtM1YHImnQpowAwgAAAAAAG1SPXS+J6QpM4AAAAAAANAWJ+OdkKbNAAIAAAAAQNPdjJ9j + VUgzygACAAAAAECTXYjPYmlIM84AAgAAAABAU1W/w94YD4Q0qwwgAAAAAAA0TXXy6rt4NqQ5ZQABAAAA + AKBJLsXWeDSkOWcAAQAAAACgKY7F2rg/pHllAAEAAAAAYNDG45tYGFItGUAAAAAAABik6r2PdSHVmgEE + AAAAAIBBORFSTzKAAAAAAAAwCJ+G1LMMIAAAAAAA9Ev11sfVqB46l3qaAQQAAAAAgH4YiUOxKKSeZwAB + AAAAAKDXrsVnIfUtAwgAAAAAAL0yFqdjQ0h9zQACAAAAAEAv3IgfY1VIfc8AAgAAAABA3S7EJ7EkpIFk + AAEAAAAAoC634khsDGmgGUAAAAAAAKjDcHwTz4U08AwgAAAAAADMV3Xy6v1YHFIjMoAAAAAAADAfB+Ll + kBqVAQQAAAAAgLn6IJaH1LgMIAAAAAAAzNaV8K0PNToDCAAAAAAAs7E/fOtDjc8AAgAAAADATG0LqRUZ + QAAAAAAAmM75WBtSazKAAAAAAAAwmfH4IZaG1KoMIAAAAAAATORa7AiplRlAAAAAAAD4t1txPNaH1NoM + IAAAAAAA3DYc1cmrJ0JqdQYQAAAAAAAq1UPnn4RURAYQAAAAAIBuq05eHQ4nr1RUBhAAAAAAgO66Hnvi + sZCKygACAAAAANBNp2JbSEVmAAEAAAAA6J798VJIxWYAAQAAAADojqH4Ih4NqegMIAAAAAAA3XA8NoXU + iQwgAAAAAABlG4+98VxInckAAgAAAABQrmuxIxaH1KkMIAAAAAAAZToVr4TUyQwgAAAAAADl+TEWhNTZ + DCAAAAAAAOUYii0hdT4DCAAAAABAGU7HUyEpGUAAAAAAANptOKqTV5L+lQEEAAAAAKC9Lse7IemuDCAA + AAAAAO0zGifjsZA0QQYQAAAAAIB2uRrfhaQpMoAAAAAAALTHmXDySppBBhAAAAAAgOa7GQdjdUiaQQYQ + AAAAAIBmuxQ7Y1lImmEGEAAAAACAZhqPY/F2PBSSZpEBBAAAAACgeaqTV/vCyStpjhlAAAAAAACa5XJs + j8dD0hwzgAAAAAAANMfxeCn+E5LmkQEEAAAAAKAZdodvfUg1ZQABAAAAABiskXgt7g9JNWUAAQAAAAAY + nNMhqQcZQAAAAAAABuOzkNSjDCAAAAAAAP01FM+HpB5mAAEAAAAA6I+xOByPhqQeZwABAAAAAOi96/FF + /F9I6kMGEAAAAACA3rkVZ+PNkNTHDCAAAAAAAL0xHPtjdUjqcwYQAAAAAID6XYrPYnFIGkAGEAAAAACA + +lQnr6rfu24KSQPMAAIAAAAAUI+b8W2sCUkDzgACAAAAADB/F2J7LAxJDcgAAgAAAAAwPwfitZDUoAwg + AAAAAABz93GsCEkNywACAAAAADB7l+LNkNTQDCAAAAAAALOzP54LSQ3OAAIAAAAAMDO34qNYFJIangEE + AAAAAGB6F8JD51KLMoAAAAAAAEytOnm1NCS1KAMIAAAAAMDErscnIamFGUAAAAAAAO40Hqfi9ZDU0gwg + AAAAAAD/uBnVyavHQlKLM4AAAAAAAPypeuj885BUQAYQAAAAAKDrqpNXR+O1kFRIBhAAAAAAoMuqh873 + xeKQVFAGEAAAAACgq87GhyGpwAwgAAAAAEAXHYxXQlKhGUAAAAAAgC65Fl/HspBUcAYQAAAAAKArTsZ7 + 8UBIKjwDCAAAAABQulvxUzwfkjqSAQQAAAAAKFl18urTeCwkdSgDCAAAAABQqtOxPh4MSR3LAAIAAAAA + lOjneDQkdTQDCAAAAABQkpvxQUjqeAYQAAAAAKAU52NZSJIBBAAAAABovdH4KSTp7wwgAAAAAECbXY9N + IUl3ZAABAAAAANpoLM7EYyFJ92QAAQAAAADaZii+D0maNAMIAAAAANAm1UPn74UkTZkBBAAAAABog5tx + KJ4PSZo2AwgAAAAA0HSX46t4IiRpRhlAAAAAAIAmOxnvxkMhSTPOAAIAAAAANNFI/BgvhiTNOgMIAAAA + ANA0V2JHPBmSNKcMIAAAAABAk5yI1+L+kKQ5ZwABAAAAAJpid/w3JGneGUAAAAAAgEGr3vt4Ix4JSaol + AwgAAAAAMEinY2lIUq0ZQAAAAACAQdkZktSTDCAAAAAAQL9djxdDknqWAQQAAAAA6JfxqH4n+URIUk8z + gAAAAAAA/TAcX8YDIUk9zwACAAAAAPTSrTgfb4ck9S0DCAAAAADQKyNxINaEJPU1AwgAAAAA0AtXYmcs + DEnqewYQAAAAAKBO1UPnx2JzSNLAMoAAAAAAAHWpTl7tDSevJA08AwgAAAAAUIeL8XE8HJI08AwgAAAA + AMB8HYw3QpIakwEEAAAAAJir6r2Pr+K/IUmNygACAAAAAMxFdfLqvfi/kKTGZQABAAAAAGbrQLwYktTY + DCAAAAAAwEyNxWexLCSp0RlAAAAAAICZqE5evRmS1IoMIAAAAADAdA7G8pCk1mQAAQAAAAAmMxyfhyS1 + LgMIAAAAADCRs7E+JKmVGUAAAAAAgH8bjerk1eKQpNZmAAEAAAAAbrscO0OSWp8BBAAAAAAYj5PxakhS + ERlAAAAAAKDbbsT+eDgkqZgMIAAAAADQXefj05Ck4jKAAAAAAED3VCevfgsnryQVmwEEAAAAALrlWnwb + T4YkFZsBBAAAAAC641RsjQUhSUVnAAEAAACA8t2KX+KlkKROZAABAAAAgLINxRexPCSpMxlAAAAAAKBc + Z+KNeCQkqVMZQAAAAACgPONRnbx6KiSpkxlAAAAAAKAso/FhSFKnM4AAAAAAQDkuhbc+JCkZQAAAAACg + DPtDkvRXBhAAAAAAaLfq5NVbIUn6VwYQAAAAAGinW3EunghJ0l0ZQAAAAACgfW7EvpAkTZIBBAAAAADa + 5WJsCUnSFBlAAAAAAKAdRuJIvBiSpGkygAAAAABA812Nb2J5SJJmkAEEAAAAAJrtTLwfD4QkaYYZQAAA + AACgmaqTV/vjlZAkzTIDCAAAAAA0z7X4JJ4KSdIcMoAAAAAAQLOcjI0hSZpHBhAAAAAAaI49sSokSfPM + AAIAAAAAg1e99/F2LAlJUg0ZQAAAAABgsE7H0yFJqjEDCAAAAAAMzq54JCRJNWcAAQAAAID+G471IUnq + UQYQAAAAAOivo/FUSJJ6mAEEAAAAAPpjNL6K/4QkqccZQAAAAACgt8bjQrwbkqQ+ZQABAAAAgN6pvvXx + a6wNSVIfM4AAAAAAQG9cja/j4ZAk9TkDCAAAAADU70S8H5KkAWUAAQAAAID6VCevforVIUkaYAYQAAAA + AKjHxfg8/hOSpAFnAAEAAACA+fst3gpJUkMygAAAAADA3I3FnngmJEkNygACAAAAAHNzIbbHgyFJalgG + EAAAAACYvYPxakiSGpoBBAAAAABmbjS+iuUhSWpwBhAAAAAAmJnq5NU78UBIkhqeAQQAAAAApnc4PHQu + SS3KAAIAAAAAkxuJL0OS1LIMIAAAAAAwserk1fqQJLUwAwgAAAAA3GksqpNXC0KS1NIMIAAAAADwj2vh + 5JUkFZABBAAAAAD+dDbWhSSpgAwgAAAAAHTdcBwMSVJBGUAAAAAA6LKL8XlIkgrLAAIAAABAF43H0Vgf + kqQCM4AAAAAA0DVDsTeeCklSoRlAAAAAAOiS6qHzD2JhSJIKzgACAAAAQBfcil9jXUiSOpABBAAAAIDS + VSevvor/hiSpIxlAAAAAACjZuXgrFockqUMZQAAAAAAo1YF4NiRJHcwAAgAAAEBpqvc+doSHziWpwxlA + AAAAACjJlVgZkqSOZwABAAAAoBS/hCRJf2QAAQAAAKAEm0KSpL8zgAAAAADQVuNxPp4MSZLuyAACAAAA + QBuNxA9xf0iSdE8GEAAAAADa5nJsC0mSJs0AAgAAAEBbVN/6OBqvhCRJU2YAAQAAAKANhmJPPBWSJE2b + AQQAAACAJqseOj8XTl5JkmaVAQQAAACAphqNX+K1kCRpVhlAAAAAAGii6uTVF+HklSRpThlAAAAAAGia + U7EpJEmacwYQAAAAAJrku1gbkiTNq+Mx0b9oAAAAAKCfRmJzPBqSJM27l+PteAsAAKBB3owdMR4T/ZIM + gLJUJ69eDEmSJEmSJKn4/hu3YqJflAFQjm/iyZAkSZIkSZI60YowgACU62Z46FySJEmSJEmdyzdAAMp1 + LFaGJEmSJEmS1LkMIADlqT7Xvw5JkiRJkiSpsxlAAMpyMd4LSZIkSZIkqdMZQADKMBa/xZqQJEmSJEmS + Op8BBKD9hmJP/CckSZIkSZIkJQMIQLudjq0hSZIkSZIk6V8ZQADaaTQOxOqQJEmSJEmSdFcGEID2uRRf + hSRJkiRJkqRJMoAAtMux2BSSJEmSJEmSpsgAAtAO1cmrffFcSJIkSZIkSZomAwhA812Mj2NBSJIkSZIk + SZpBBhCAZjscG0KSJEmSJEnSLDKAADTTSOyOp0OSJEmSJEnSLDOAADRPdfLq/VgYkiRJkiRJkuaQAQSg + WY6Eh84lSZIkSZKkeWYAAWiGsfgmJEmSJEmSJNWQAQRg8K7G+pAkSZIkSZJUUwYQgMGpPn//F5IkSZIk + SZJqzgACMBg34quQJEmSJEmS1IMMIAD9dzFeCUmSJEmSJEk9ygAC0D8340hIkiRJkiRJ6nEGEID+uBxf + hCRJkiRJkqQ+ZAAB6K3qM/ZkvB6SJEmSJEmS+pQBBKB3huLHeDokSZIkSZIk9TEDCEBvnI8dsTgkSZIk + SZIk9TkDCEC9xuK3cPJKkiRJkiRJGmAGEID6XI+v49mQJEmSJEmSNMAMIAD1+D3ejSUhSZIkSZIkacAZ + QADm79dYG5IkSZIkSZIakgEEYO6qz8+PY1lIkiRJkiRJalAGEIC5uRJr4v9CkiRJkiRJUsMygADM3sGQ + JEmSJEmS1OAMIACzUz10LkmSJEmSJKnhGUAAZuZCrAhJkiRJkiRJLcgAAjC1sfghFoQkSZIkSZKklmQA + AZjctdgekiRJkiRJklqWAQTgXqNxPF4NSZIkSZIkSS3MAAJwp+vxfXjvQ5IkSZIkSWpxBhCAf5yPD0OS + JEmSJElSyzOAAPz50PnBeD0kSZIkSZIkFZABBOi6odgVTl5JkiRJkiRJBWUAAbrsVLwfkiRJkiRJkgrL + AAJ01d54KSRJkiRJkiQVmAEE6Jqb8UE8GpIkSZIkSZIKzQACdEl18spD55IkSZIkSVIHMoAAXbEnVoYk + SZIkSZKkDmQAAUo3HFvi4ZAkSZIkSZLUkQwgQMlOxgshSZIkSZIkqWMZQIBSVSevJEmSJEmSJHU0AwhQ + mstRnbySJEmSJEmS1OEMIEApxuNYrA5JkiRJkiRJHc8AApTgenwfkiRJkiRJkvRHBhCg7c7F9pAkSZIk + SZKkvzOAAG01GofDyStJkiRJkiRJ92QAAdroSuwOSZIkSZIkSZowAwjQNifjvZAkSZIkSZKkSTOAAG0x + FvvjuZAkSZIkSZKkKTOAAG1wMb6IRSFJkiRJkiRJ02YAAZruSLwZkiRJkiRJkjTjDCBAU43E9/FsSJIk + SZIkSdKsMoAATVSdvNoWS0OSJEmSJEmSZp0BBGiao/FC3B+SJEmSJEmSNKcMIEBTjMWe8NC5JEmSJEmS + pHlnAAGa4EZ46FySJEmSJElSbRlAgEE7HpIkSZIkSZJUawYQYFBGY1dIkiRJkiRJUu0ZQIBBuBbVQ+eS + JEmSJEmS1JMMIEA/jcTRkCRJkiRJkqSeZgAB+qX61sfOkCRJkiRJkqSeZwABeq36jDkTG0KSJEmSJEmS + +pIBBOil67E/VoYkSZIkSZIk9S0DCNArF+KTWBKSJEmSJEmS1NcMIEDdqs+U/8XGkCRJkiRJkqSBZAAB + 6nQj9sTqkCRJkiRJkqSBZQAB6lKdvNoSS0OSJEmSJEmSBpoBBKjDoXg5JEmSJEmSJKkRGUCA+RiPT+Op + kCRJkiRJkqTGZAAB5upqvBQPhiRJkiRJkiQ1KgMIMBfVyauFIUmSJEmSJEmNzAACzNbWkCRJkiRJkqRG + ZwABZupSPB2SJEmSJEmS1PgMIMBM/BSLQpIkSZIkSZJakQEEmMr1+DAkSZIkSZIkqVUZQICJVJ8LJ2N9 + SJIkSZIkSVLrMoAAdxuOH+KpkCRJkiRJkqRWZgAB/u1CfBySJEmSJEmS1OoMIECl+hw4HG+EJEmSJEmS + JLU+AwhQPXS+O1aEJEmSJEmSJBWRAQS67UxsD0mSJEmSJEkqKgMIdNePsS4kSZIkSZIkqbgMINA9w/FZ + LA1JkiRJkiRJKjIDCHTLydgUkiRJkiRJklR0BhDoju9jdUiSJEmSJElS8RlAoHzX48NYHJIkSZIkSZLU + iQwgULZT4aFzSZIkSZIkSZ3LAALl+iF860OSJEmSJElSJzOAQHmuxdaQJEmSJEmSpM5mAIGynIznQpIk + SZIkSZI6nQEEyjAc1ckrSZIkSZIkSVIygED7XYwPQpIkSZIkSZL0VwYQaK+xOBrPhiRJkiRJkiTpXxlA + oJ2qh86/D0mSJEmSJEnSBBlAoH3OxJaQJEmSJEmSJE2SAQTaYzQOxuqQJEmSJEmSJE2RAQTa4VJ8FUtD + kiRJkiRJkjRNBhBovmOxKf4TkiRJkiRJkqQZZACB5roZ+8LJK0mSJEmSJEmaZQYQaKbq5NWOWBaSJEmS + JEmSpFlmAIHmOR6vxEMhSZIkSZIkSZpDBhBojurP4nfxeEiSJEmSJEmS5pEBBJphON4OSZIkSZIkSVIN + GUBg8M7EgpAkSZIkSZIk1ZQBBAZrV0iSJEmSJEmSas4AAoNRnbxaG5IkSZIkSZKkHmQAgf4ai+Nxf0iS + JEmSJEmSepQBBPrnRuwMSZIkSZIkSVKPM4BA71V/xs7HxpAkSZIkSZIk9SEDCPRW9dbHL/FcSJIkSZIk + SZL6lAEEeudyfB5LQ5IkSZIkSZLUxwwgUL/qz9SxeDskSZIkSZIkSQPIAAL1qk5efR/PhyRJkiRJkiRp + QBlAoD4XY3s8GpIkSZIkSZKkAWYAgXocjtdCkiRJkiRJktSADCAwf9VD58+EJEmSJEmSJKkhGUBg7q7F + +ng4JEmSJEmSJEkNygACc/NrPB2SJEmSJEmSpAZmAIHZ+zAeCUmSJEmSJElSQzOAwMxdjpdCkiRJkiRJ + ktTwDCAwM/tjSUiSJEmSJEmSWpABBKY2HB+FJEmSJEmSJKlFGUBgYuNxOjaEJEmSJEmSJKllGUDgXiNR + nbx6KiRJkiRJkiRJLcwAAne6GJ+FJEmSJEmSJKnFGUDgT9Wfg//FmyFJkiRJkiRJankGELjvvhvxfSwP + SZIkSZIkSVIBGUDoujPxUUiSJEmSJEmSCsoAQpcdiHUhSZIkSZIkSSosAwhdVJ282hXLQpIkSZIkSZJU + YAYQuuZUvBeSJEmSJEmSpIIzgNAlP8YLIUmSJEmSJEkqPAMIXTAUn8ZjIUmSJEmSJEnqQAYQSnc6NsT9 + IUmSJEmSJEnqSAYQSrY/nghJkiRJkiRJUscygFCiG7EjJEmSJEmSJEkdzQBCac7GqpAkSZIkSZIkdTgD + CKUYierklSRJkiRJkiRJBhCKcCW2hyRJkiRJkiRJf2QAoc2qn91TUf0cS5IkSZIkSZL0dwYQ2moofgpJ + kiRJkiRJku7JAEIbnY8tIUmSJEmSJEnShBlAaJPqofPfYm1IkiRJkiRJkjRpBhDa4nJ8HctCkiRJkiRJ + kqQpM4DQBidjczwYkiRJkiRJkiRNmwGEJrsZ1UPnL4QkSZIkSZIkSTPOAEJTXYlPYnlIkiRJkiRJkjSr + DCA00YlYHwtCkiRJkiRJkqRZZwChSaqfxb1R/VxKkiRJkiRJkjTnDCA0RfXex6ZYGJIkSZIkSZIkzSsD + CE1wNpaFJEmSJEmSJEm1ZABh0HaFJEmSJEmSJEm1ZgBhUMZibUiSJEmSJEmSVHsGEPptPI7HIyFJkiRJ + kiRJUk8ygNBPI/FlSJIkSZIkSZLU0wwg9EP1M3Yh3gpJkiRJkiRJknqeAYReuxkHY01IkiRJkiRJktSX + DCD00pWoTl4tDUmSJEmSJEmS+pYBhF6ofqZOxLshSZIkSZIkSVLfM4BQt+rk1b54MSRJkiRJkiRJGkgG + EOp0KT4KJ68kSZIkSZIkSQPNAEJdfouNIUmSJEmSJEnSwDOAUIed8WxIkiRJkiRJktSIDCDMx9V4Ox4M + SZIkSZIkSZIakwGEufo1ng9JkiRJkiRJkhqXAYS5+CSWhSRJkiRJkiRJjcwAwmxcjg0hSZIkSZIkSVKj + M4AwUwdjeUiSJEmSJEmS1PgMIEznZnwakiRJkiRJkiS1JgMIUzkbb4QkSZIkSZIkSa3KAMJERuNAPBmS + JEmSJEmSJLUuAwh3qx463xmSJEmSJEmSJLU2Awi3jcfxeDMkSZIkSZIkSWp1BhAqw/FTPB6SJEmSJEmS + JLU+Awjn4rOQJEmSJEmSJKmYDCDd9lu8FpIkSZIkSZIkFZUBpJuux7fh5JUkSZIkSZIkqcgMIN1zOraF + JEmSJEmSJEnFZgDpll/i5ZAkSZIkSZIkqegMIN0wFDvjyZAkSZIkSZIkqfgMIOU7E2/FgpAkSZIkSZIk + qRMZQMpWnbyq/hlLkiRJkiRJktSpDCBluhmfhiRJkiRJkiRJncwAUp4L8VxIkiRJkiRJktTZDCDlqP45 + HghJkiRJkiRJkjqfAaQMN2JrSJIkSZIkSZKkZABpt/E4H4+HJEmSJEmSJEn6KwNIe1Xf+vg5JEmSJEmS + JEnSXRlA2ulSOHklSZIkSZIkSdIkGUDaZSSOxgshSZIkSZIkSZImyQDSHldjTzwRkiRJkiRJkiRpigwg + 7XAmtsRDIUmSJEmSJEmSpskA0mzVyatf4uWQJEmSJEmSJEkzzADSXNXJq89iRUiSJEmSJEmSpFlkAGmm + U7ExFoQkSZIkSZIkSZplBpBmGY+98VxIkiRJkiRJkqQ5ZgBpjuq9j82xNCRJkiRJkiRJ0jwygDTDmXg6 + JEmSJEmSJElSDRlABm93SJIkSZIkSZKkGjOADE719/2VkCRJkiRJkiRJNWcAGYwT4a0PSZIkSZIkSZJ6 + lAGkv8ZiV0iSJEmSJEmSpB5mAOmP8bgYm0KSJEmSJEmSJPU4A0jvjcbheD4kSZIkSZIkSVIfMoD01rWo + Tl4tCUmSJEmSJEmS1KcMIL1Rnbw6Fe+HJEmSJEmSJEnqcwaQ+o3ET/FSSJIkSZIkSZKkAWQAqdfl+CwW + hyRJkiRJkiRJGlAGkPociU0hSZIkSZIkSZIGnAGkHtVD56tCkiRJkiRJkiQ1IAPI/FQnr7aFJEmSJEmS + JElqUAaQuTsUr4YkSZIkSZIkSWpYBpDZG4+d8VRIkiRJkiRJkqQGZgCZnUtRPXT+n5AkSZIkSZIkSQ3N + ADJzh8ND55IkSZIkSZIktSADyPRGozp5JUmSJEmSJEmSWpIBZGq/x5shSZIkSZIkSZJalAFkYmNxKJaF + JEmSJEmSJElqWQaQe12NXSFJkiRJkiRJklqaAeROp2NjSJIkSZIkSZKkFmcA+dPNOBBLQpIkSZIkSZIk + tTwDyH33XYgvQpIkSZIkSZIkFVLXB5Bj8XpIkiRJkiRJkqSC6uoAciP2xZMhSZIkSZIkSZIKq4sDyNnY + EQ+FJEmSJEmSJEkqsC4NIOPxa7wakiRJkiRJkiSp4LoygAzFrlgRkiRJkiRJkiSp8LowgFQnr96JRSFJ + kiRJkiRJkjpQ6QPIwVgVkiRJkiRJkiSpQ5U6gIzEZ/FISJIkSZIkSZKkjlXiAHIlng9JkiRJkiRJktTR + ShtAfg1JkiRJkiRJktTxShlAqr+GLSFJkiRJkiRJktT6AWQ8LsXSkCRJkiRJkiRJ+qM2DyA34+eQJEmS + JEmSJEm6o7YOINVD59tCkiRJkiRJkiTpnto2gIzG8XgpJEmSJEmSJEmSJqxNA8i1+C6eCkmSJEmSJEmS + pElrywByLqqTVw+FJEmSJEmSJEnSlDV9AKlOXh2MV0OSJEmSJEmSJGlGNXkAqU5e7YynQ5IkSZIkSZIk + acY1dQA5HZvCyStJkiRJkiRJkjTrmjiA7IvnQ5IkSZIkSZIkaU41aQCp3vt4P5aFJEmSJEmSJEnSnGvK + AHIm1oYkSZIkSZIkSdK8a8IAsieWhKT/3979okQQBmAc3mAwbhLPYDCJwSwGD2AQwx5gg8kLeAQxiNEj + mEVks8koBlmMmxfDgu+sWETRdeevPA/8YAYG5gAvfB8AAAAAAKVocgAp/jtIAAAAAAAApWpqALlPGwkA + AAAAAKB0dQ8gs3SZVhMAAAAAAEAl6hxAxmmYAAAAAAAAKlXHAPKa7tJeAgAAAAAAqFzVA8gkFUderSUA + AAAAAIBaVDWAFHd9PKSTBAAAAAAAUKsqBpBpuk77CQAAAAAAoHZlDyAv6Sz1EwAAAAAAQCPKHEBGaZgA + AAAAAAAaVdYAcpV2EgAAAAAAQOOWHUDG6TStJAAAAAAAgFZYZgC5TUcJAAAAAACgVf4ygBTfX6StBAAA + AAAA0DqLDiDP6Tj1EwAAAAAAQCstMoDcpd0EAAAAAADQar8ZQD6OvHLROQAAAAAA0Ak/DSDFkVeDBAAA + AAAA0BnfDSCzNErrCQAAAAAAoFO+GkAmqTjyCgAAAAAAoJM+DyCP6TABAAAAAAB0VjGAFMPHNN2kfgIA + AAAAAOi07fSUzudvAAAAAAAA/8BmOnh/BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACY6/XeAGiT85ii7WtUAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAABkAAAARrCAIAAABUmv0sAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vwAADr8BOAVTJAAAVlZJREFUeF7t3X9kl/v/+PGPl5eXmZmZmZmZSSYzk2SSYzLJJJkkmSSZZJIkSRKT + TJIkySRJkkmSJEkySSbJZJJMMslMkiRH3s639/v9fH/f55x3ndPW68d1Pa/b7b9z/up1Xc/nk8fdruv6 + v98AAAAAIMEELAAAAAASTcACAAAAINEELAAAAAASTcACAAAAINEELAAAAAASTcACAAAAINEELAAAAAAS + TcACAAAAINEELAAAAAASTcACAAAAINEELAAAAAASTcACAAAAINEELAAAAAASTcACAAAAINEELAAAAAAS + TcACAAAAINEELAAAAAASTcACAAAAINEELAAAAAASTcACAAAAINEELAAAAAASTcACAAAAINEELAAAAAAS + TcACAAAAINEELAAgZmNjY5OTk+E/AABIJwELAIjW0NDQokWLJiYmwn8DAJBOAhYAEKH379/39vZWVVX9 + 3//939OnT8P/BQAgnQQsACA2ly9fXrx48f/9Sz6fF7AAANJOwAIAorJjx476+vp/16uvBCwAgAgIWABA + JN6+ffvLL7/kcrnQrv5FwAIAiICABQDE4MKFC62traFa/Y6ABQAQAQELAEi3L1++7NixI5/Ph2T1RwIW + AEAEBCwAIMXu3r3b09MTYtW3CFgAABEQsACAVHr//v3Jkye/+djg7wlYAAARELAAgPR5/PjxXzw2+HsC + FgBABAQsACBlLl26tGrVqhCo/o6ABQAQAQELAEiNL1++HDp0qKWlJdSpHyBgAQBEQMACANLh4cOHW7Zs + CV3qhwlYAAARELAAgBQ4ffr0L7/8EqLUfAhYAAARELAAgER7//79rl27mpubQ5GaJwELACACAhYAkFy3 + bt1at25dVVVVyFHzJ2ABAERAwAIAEurYsWOdnZ25XC60qAURsAAAIiBgAQCJMzs7Ozg4WF9fHyrUTxCw + AAAiIGABAMly586dnp6eQqEQEtTPEbAAACIgYAEACXL69OmWlpYQn4pBwAIAiICABQAkwufPnwcHB3/y + jVf/S8ACAIiAgAUAVN7U1NSyZctCcyoqAQsAIAICFgBQYRcuXMjn8yE4FZuABQAQAQELAKiYN2/ebN++ + PaSm0hCwAAAiIGABAJVx7969zs7O0JlKRsACAIiAgAUAlNv09PTJkyerqqpCZColAQsAIAICFgBQVnfv + 3t28eXPIS6UnYAEAREDAAgDK5OPHj6Ojo11dXaEtlYWABQAQAQELACiHJ0+e7Nmzp7GxMYSlchGwAAAi + IGABACV37dq1vr6+8rz06k8ELACACAhYAEAJffz48dixY0uWLAk9qewELACACAhYAECpPHv2bOvWreV/ + bPD3BCwAgAgIWABASdy6dau7u7sijw3+noAFABABAQsAKL5jx441NzeHhlRRAhYAQAQELACgyNavX19T + UxMCUqUJWAAAERCwAICimZmZaW1tzeVyoR4lgIAFABABAQsAKI4TJ07k8/nQjRJDwAIAiICABQAUwZo1 + a0IxShgBCwAgAgIWAPBT7t69m5D3tX+TgAUAEAEBCwBYoHfv3u3fv7+6ujq0okQSsAAAIiBgAQAL8fDh + w76+vlCJEkzAAgCIgIAFAMzP7Ozs2bNnOzo6QiJKNgELACACAhYAMA+Tk5NDQ0MNDQ2hDyWegAUAEAEB + CwD4UdeuXVuzZk0ulwtxKA0ELACACAhYAMDf+/jx4/DwcFoeG/w9AQsAIAICFgDwN54/f7558+a6urrQ + hFJFwAIAiICABQD8lStXrqxYsSLUoBQSsAAAIiBgAQDftXfv3kWLFoUUlE4CFgBABAQsAOAb3rx5s3bt + 2pqamtCBUkvAAgCIgIAFAPzZxYsXu7q6QgFKOQELACACAhYA8AdDQ0NNTU0h/6SfgAUAEAEBCwAIpqen + V69eXSgUQvuJgoAFABABAQsA+KcLFy4sXrw4VJ+ICFgAABEQsACA3/bs2VNVVRWST1wELACACAhYAJBp + Dx8+7O3tDbEnRgIWAEAEBCwAyKhff/11dHS0tbU1lJ5ICVgAABEQsAAgi549e7Znz55cLhcyT7wELACA + CAhYAJA5165dW716dQg8sROwAAAiIGABQLYcO3aspaUl1J0MELAAACIgYAFAVjx8+HBoaCh0ncwQsAAA + IiBgAUAmjI6O9vT0hKiTJQIWAEAEBCwAiNzbt2/379+fqccGf0/AAgCIgIAFADG7devWhg0bqqurQ87J + HgELACACAhYAROvkyZNLly7N5XKh5WSSgAUAEAEBCwAi9ObNm6GhocbGxlBxMkzAAgCIgIAFALG5e/du + b29vVVVVSDjZJmABAERAwAKAqIyOjra1tWX8scHfE7AAACIgYAFAPIaGhgqFQig3/IuABQAQAQELAGIw + MzOzfPny0Gz4HQELACACAhYApN6NGzfy+XwINvyRgAUAEAEBCwDSbXBwMKQavkXAAgCIgIAFAGn15MmT + zs7O0Gn4DgELACACAhYApM/MzMzp06erq6tDpOH7BCwAgAgIWACQMg8ePBgYGMjlcqHQ8JcELACACAhY + AJAa79+/v3jx4tKlS0Ob4QcIWAAAERCwACAdJicn9+/f39TUFMIMP0bAAgCIgIAFAClw8+bNdevWeenV + AghYAAARELAAINE+fvx44sQJXxtcMAELACACAhYAJNeLFy+2b9/uscGfIWABAERAwAKAhLpz587KlSs9 + NviTBCwAgAgIWACQRMePH29tbQ0Nhp8gYAEAREDAAoDEWb9+fV1dXQgw/BwBCwAgAgIWACTIy5cv29vb + c7lcqC/8NAELACACAhYAJMXx48f94VXRCVgAABEQsAAgEdauXZvP50N0oXgELACACAhYAFBhDx48WLRo + UcgtFJuABQAQAQELACrpwIEDNTU1obVQAgIWAEAEBCwAqIynT5+uW7cuVBZKRsACAIiAgAUA5fb+/fvz + 5893dnaGxEIpCVgAABEQsACgrJ4/f75nz56GhobQVygxAQsAIAICFgCUz82bNz02WGYCFgBABAQsACiT + Y8eOdXV1haxCuQhYAAARELAAoORevny5bdu2+vr60FQoIwELACACAhYAlNbVq1dXrVoVagplJ2ABAERA + wAKAEtq/f/+SJUtCSqESBCwAgAgIWABQEi9fvtywYUNtbW3oKFSIgAUAEAEBCwCK78KFC93d3blcLkQU + KkfAAgCIgIAFAEW2Z8+elpaWkE+oNAELACACAhYAFM3z58/Xrl1bVVUV2gkJIGABAERAwAKA4rh06VJH + R0eoJiSGgAUAEAEBCwCK4MCBAzU1NSGZkCQCFgBABAQsAPgpU1NTfX19IZaQPAIWAEAEBCwAWLjLly97 + X3vCCVgAABEQsABgIaanpw8ePBgaCQkmYAEAREDAAoB5u3v37po1a0IgIdkELACACAhYADAPnz59Onfu + XFNTU6gjJJ6ABQAQAQELAH7Uo0eP9uzZE7oIKSFgAQBEQMACgB9y8eLFVatWhShCeghYAAARELAA4G/M + zMwcPny4tbU1FBFSRcACAIiAgAUAf+X27dubN2+uqakJOYS0EbAAACIgYAHAd505c2b58uX5fD60EFJI + wAIAiICABQDfMDMzs3v37ubm5lBBSC0BCwAgAgIWAPzZ/fv3+/r6PDYYBwELACACAhYA/MH58+cXLVrk + scFoCFgAABEQsADgv3bv3l1dXR3KB1EQsAAAIiBgAcA/vXv3rru7O5fLhexBLAQsAIAICFgA8Nu9e/cK + hUIIHsRFwAIAiICABUDWDQ0NhdRBjAQsAIAICFgAZNf09HRHR0foHERKwAIAiICABUAWzc3NjY6O1tTU + hMhBvAQsAIAICFgAZM7Tp08HBgby+XwoHERNwAIAiICABUCGvH//fmxsbPny5aFtkAECFgBABAQsALJi + amrq4MGDzc3NIWyQDQIWAEAEBCwAMuHOnTsbNmzw0qsMErAAACIgYAEQuU+fPp0+fXrZsmWhZ5AxAhYA + QAQELABiNj09vXPnzpaWlhAzyB4BCwAgAgIWANG6d+/eqlWrqqurQ8kgkwQsAIAICFgAxOnEiRPt7e2h + YZBhAhYAQAQELAAitGHDhoaGhhAwyDYBCwAgAgIWAFF5+vTp0qVL8/l8qBdknoAFABABAQuAeIyMjDQ3 + N4duAf8iYAEAREDAAiAS/f393tfO/xKwAAAiIGABkHoPHz7s6OgIuQL+SMACAIiAgAVAug0PD9fV1YVW + Af9DwAIAiICABUBavXjxor+/P1QK+A4BCwAgAgIWAOnz5cuXy5cvd3V1hUQB3ydgAQBEQMACIGVevXp1 + 4MCBhoaG0CfgLwlYAAARELAASJM7d+5s3LgxlAn4AQIWAEAEBCwAUuPUqVNLly4NWQJ+jIAFABABAQuA + FJienh4aGvK1QRZAwAIAiICABUDSXb9+fe3ataFGwDwJWAAAERCwAEi0w4cPd3Z2hhQB8ydgAQBEQMAC + IKGmpqa2bNnisUF+koAFABABAQuAJLpw4cIvv/ySz+dDhICFErAAACIgYAGQOPv3729rawv5AX6OgAUA + EAEBC4AEefbsWX9/f3V1dWgP8NMELACACAhYACTF5cuXu7q6crlcCA9QDAIWAEAEBCwAEuHw4cO1tbUh + OUDxCFgAABEQsACosDdv3vT394fYAMUmYAEAREDAAqCSbt261dLSEkoDlICABQAQAQELgMp49+7dkSNH + QmOAkhGwAAAiIGABUAFPnjxZs2ZNCAxQSgIWAEAEBCwAyurDhw9jY2ONjY2hLkCJCVgAABEQsAAon8eP + H+/bty90BSgLAQsAIAICFgBlcvXq1d7e3hAVoFwELACACAhYAJTc69evR0ZG2traQlGAMhKwAAAiIGAB + UFp3797dsmVLbW1tyAlQXgIWAEAEBCwASujcuXMrVqzI5/OhJUDZCVgAABEQsAAoiZmZmX379rW0tISK + ABUiYAEAREDAAqD4Hjx4sG7dOo8NkgQCFgBABAQsAIrs4sWL7e3tHhskIQQsAIAICFgAFNOePXvq6upC + OYAEELAAACIgYAFQHF++fOnu7i4UCiEbQDIIWAAAERCwACiCe/fueeMVySRgAQBEQMAC4GcNDQ2FVADJ + I2ABAERAwAJg4d6/f9/Z2Rk6ASSSgAUAEAEBC4AFOnfunMcGST4BCwAgAgIWAPP28uXLrVu35vP5UAgg + wQQsAIAICFgAzMPHjx9v3LjR3d0d2gAknoAFABABAQuAHzU9PT08PNza2hrCAKSBgAUAEAEBC4AfMj4+ + vnnz5pqamlAFICUELACACAhYAPyNX3/9dXR0dMWKFaEHQKoIWAAAERCwAPgrMzMzu3bt8tgg6SVgAQBE + QMAC4LvGx8f7+vqqqqpCCYAUErAAACIgYAHwbSdOnOjs7AwNAFJLwAIAiICABcA3bNmypbGxMQQASDMB + CwAgAgIWAH/w6NGjlStXFgqFMP1DyglYAAARELAA+K+jR4+2tbWFuR+iIGABAERAwAIg2LRpU21tbRj6 + IRYCFgBABAQsAH578ODBsmXLwrgPcRGwAAAiIGABZN3x48e9r52ICVgAABEQsACy6+3bt5s2bQpTPkRK + wAIAiICABZBR169fX7p0aRjxIV4CFgBABAQsgMx5+/btkSNH6uvrw3wPUROwAAAiIGABZMv4+PiWLVvC + ZA8ZIGABAERAwALIkNHRUV8bJGsELACACAhYAJkwMzOzf//+2traMNNDZghYAAARELAA4nf9+vWNGzeG + aR4yRsACAIiAgAUQuZGRkc7OzjDKQ/YIWAAAERCwAKI1OTk5ODjoa4NknIAFABABAQsgTpcuXert7f06 + uochHrJKwAIAiICABRChQ4cOLVq0KIzvkG0CFgBABAQsgKg8e/Zs06ZNvjYI/5+ABQAQAQELIB5jY2PL + li3z2CD8noAFABABAQsgEkeOHPG+dvhfAhYAQAQELIDUm52d3bBhQxjWgT8SsAAAIiBgAaTbkydPWltb + w6QO/A8BCwAgAgIWQIodP348zOjAdwhYAAARELAAUmlubm716tVhQAe+T8ACAIiAgAWQMp8+fbp161ZT + U1OYzoG/JGABAERAwAJIk2fPnh04cCCXy4XRHPg7AhYAQAQELIDUuHnzpscGYb4ELACACAhYACkwMzNz + 4sSJRYsWhYkc+GECFgBABAQsgKQbHx/fvn17XV1dGMeB+RCwAAAiIGABJNrFixd/+eWXrxN4mMWBeRKw + AAAiIGABJNSbN28OHjzosUH4SQIWAEAEBCyAJJqYmOjv76+vrw8jOLBQAhYAQAQELIDEuXz5cmdnp8cG + oSgELACACAhYAMmyZ8+exsbGMHkDP03AAgCIgIAFkCArV66srq4OYzdQDAIWAEAEBCyARLhz544/vIJS + ELAAACIgYAFU3tDQUFVVVZi2gaISsAAAIiBgAVRYd3d3mLOBEhCwAAAiIGABVMyFCxfq6urCkA2UhoAF + ABABAQugAmZnZ7dv314oFMKEDZSMgAUAEAEBC6Csvnz5cufOnZUrV4bZGigxAQsAIAICFkD5zMzMHDt2 + rK2tLQzWQOkJWAAAERCwAMrk0aNHW7Zsqa6uDlM1UBYCFgBABAQsgHK4cOFCT09PmKeBMhKwAAAiIGAB + lNbs7OzevXs9NgiVImABAERAwAIooQcPHvT39/vaIFSQgAUAEAEBC6BUTp06tWzZsjBDAxUiYAEAREDA + AiiJwcHB5ubmMEADlSNgAQBEQMACKLLx8fHe3t6qqqowPQMVJWABAERAwAIoppGRkSVLloS5GUgAAQsA + IAICFkDRbNmypb6+PgzNQDIIWAAAERCwAIpgfHx8xYoVuVwuTMxAYghYAAARELAAftaJEydaWlrCrAwk + jIAFABABAQvgp2zfvj1MyUAiCVgAABEQsAAW6M6dO8uWLQsjMpBUAhYAQAQELIB5+/Dhw4kTJ2pra8N8 + DCSYgAUAEAEBC2B+JiYmPDYIKSJgAQBEQMACmIcrV64sXbo0jMVAGghYAAARELAAfsjr16+PHj1aU1MT + ZmIgJQQsAIAICFgAf+/WrVsDAwNhGgZSRcACAIiAgAXwN06ePOmxQUgvAQsAIAICFsB3TU5ODg0NNTQ0 + hDkYSCEBCwAgAgIWwLdduXKlr6+vUCiEIRhIJwELACACAhbANxw5cqS9vT2Mv0CaCVgAABEQsAD+YHJy + csuWLfX19WH2BVJOwAIAiICABfBf165d6+7urqqqCoMvkH4CFgBABAQsgGBkZKSxsTGMvEAsBCwAgAgI + WAC/vX//ftOmTd7XDlESsAAAIiBgAVk3OTm5aNGiMOkC0RGwAAAiIGABmXbmzJkw4wKRErAAACIgYAHZ + 1dfXFwZcIF4CFgBABAQsIHP+8Y9/3L9/v7m5OUy3QNQELACACAhYQLZMT08fOnTo60AbRlsgdgIWAEAE + BCwgQ+7du7dmzZow1ALZIGABAERAwAIy4c2bN2fOnFm8eHGYaIHMELAAACIgYAHxe/To0c6dO+vr68M4 + C2SJgAUAEAEBC4jclStXVq1aVSgUwiwLZIyABQAQAQELiNbbt2+Hh4fb29vDFAtkkoAFABABAQuI05Mn + TzZu3NjQ0BBGWCCrBCwAgAgIWECErly5smzZsq9Ta5hfgQwTsAAAIiBgAbHZu3dvS0tLmFyBzBOwAAAi + IGABUenp6ampqQljK4CABQAQBQELiMSNGzfa2trCwArwHwIWAEAEBCwgBrt27aqrqwvTKsDvCFgAABEQ + sIDU++WXX74OqGFUBfgjAQsAIAICFpBiY2NjTU1NYUgF+BYBCwAgAgIWkFY7duwoFAphQgX4DgELACAC + AhaQPg8ePOjp6QmzKcBfErAAACIgYAFpMjc3d/LkSV8bBH6cgAUAEAEBC0iNJ0+eDA4OVldXh6kU4AcI + WAAAERCwgHS4fPlyb29vmEcBfpiABQAQAQELSLr3798fOnTIY4PAwghYAAARELCARHvw4MHmzZurqqrC + JAowTwIWAEAEBCwguUZHR1esWBFmUIAFEbAAACIgYAEJtWvXrtbW1jCAAiyUgAUAEAEBC0ic8fHxtWvX + emwQKAoBCwAgAgIWkCzHjx/v6uoKcyfATxOwAAAiIGABSfHrr79u3769oaEhDJ0AxSBgAQBEQMACEuH+ + /furVq0qFAph4gQoEgELACACAhZQeadOnWprawuzJkBRCVgAABEQsIAK27lz59fxMgyaAMUmYAEAREDA + AipmYmJixYoVYcQEKA0BCwAgAgIWUBmjo6M1NTVhvgQomXw+Pzk5GY4eAADSScACyu358+c7duwIkyVA + ifkLLACACAhYQFndvn176dKlYawEKL1cLjc8PHzhwoXzAACUy7lz527evBnmwGIQsIAyef369enTp6ur + q8NMCQAAQLy6u7vDNFgMAhZQDvfu3du6dWs4xgAAAIjdL7/8EgbCYhCwgJIbHR312CAAAECmCFhAajx7 + 9mzv3r0NDQ3hAAMAACAbBCwgHa5evbpu3bqqqqpwegEAAJAZAhaQAseOHVuyZEkulwtHFwAAAFkiYAGJ + 9uzZs+3bt3tsEAAAIMsELCC5bty4sXLlyurq6nBiAQAAkEkCFpBQx44da2lpCWcVAAAAGSZgAYnz5cuX + TZs2+cMrAAAA/k3AApLl+fPn7e3t3tcOAADA/ydgAQkyOjoaDicAAAD4DwELSIp169aFkwkAAAB+R8AC + Km9iYqK5uTkcSwAAAPBHAhZQSXNzc8PDw/l8PpxJAAAA8D8ELKBiHj16tHbt2nAaAQAAwHcIWEAFvH37 + 9vz580uWLAlHEQAAAHyfgAWU29OnT3ft2tXQ0BDOIQAAAPhLAhZQVtevX1+zZo2XXgEAAPDjBCygTObm + 5o4ePdrR0RGOHwAAAPgxAhZQDs+ePRsYGPDYIAAAAAsgYAElNzY2tnLlylwuFw4eAAAAmA8BCyitffv2 + tbW1hSMHAAAA5k/AAkqor6+vtrY2nDcAAACwIAIWUBLXr1/3vnYAAACKQsACim/37t2NjY3hmAEAAICf + I2ABxfT+/fve3t5CoRDOGAAAAPhpAhZQNGNjY4sWLQqnCwAAABSJgAUUx+7du6urq8PRAgAAAMUjYAE/ + 6/Hjx729veFQAQAAgGITsICF+/z589mzZz02CAAAQEkJWMACTU1N7dq1q6qqKhwnAAAAUBoCFrAQ165d + 6+vrCwcJAAAAlJKABczPp0+fRkZGPDYIAABA2QhYwDw8fvx4+/bthUIhHCEAAABQegIW8KPOnz+/atWq + cHgAAABAuQhYwN/79ddf9+3b19bWFk4OAAAAKCMBC/gb4+PjGzZs8LVBAAAAKkXAAv7KyZMnly9fHg4M + AAAAqAQBC/i2Dx8+7Ny5s6mpKZwWAAAAUCECFvAN9+7dW7NmjccGAQAASAIBC/izM2fOLFq0KJfLhXMC + AAAAKkrAAv7r119/3bVrlz+8AgAAIFEELCB49uzZypUrw9kAAAAAiSFgAf80NjZWW1sbDgYAAABIEgEL + su7du3dDQ0PhSAAAAIDkEbAg0548edLV1RXOAwAAAEgkAQsy6s2bN+fOnauurg6HAQAAACSVgAVZ9PDh + w+3bt4djAAAAAJJNwILMuXjx4rJly8IZAAAAAIknYEGGPHv27ODBg42NjeEAAAAAgDQQsCArbty40d/f + 76VXAAAApI6ABfH7/PnzyZMnOzs7w74HAACAVBGwIHJTU1M7duxoamoKmx4AAADSRsCCmN2+fbunp8dj + gwAAAKSagAXROnHiRFtbW9jrAAAAkFoCFsRp8+bNdXV1YaMDAABAmglYEJsXL14sWbIkn8+HXQ4AAAAp + J2BBVM6fP19VVRX2NwAAAERBwIJ49Pf3h50NAAAAERGwIAZTU1Otra1hWwMAAEBcBCxIvSNHjnhsEAAA + gIgJWJBiz549W7duXS6XCxsaAAAAYiRgQSq9e/fu0qVLnZ2dYSsDAABAvAQsSJ+pqam9e/c2NDSEfQwA + AABRE7AgZW7durVu3bp8Ph82MQAAAMROwILUeP/+/fHjx5cuXRq2LwAAAGSDgAXp8Pz5823btjU2Noa9 + CwAAAJkhYEEKXLt2bdWqVb42CAAAQDYJWJB0Bw4caG9vD1sWAAAAskfAguT68OFDf39/XV1d2K8AAACQ + SQIWJNS1a9eWLVvmsUEAAAAQsCCJ9uzZ09LSErYpAAAAZJuABcny9u3bvr6+qqqqsEcBAAAg8wQsSJCx + sbGOjo6wOwEAAIB/EbAgKfbt21dbWxu2JgAAAPAfAhZU3tTUVF9fX9iUAAAAwB8JWFBhFy5caGtrCzsS + AAAA+B8CFlTM9PT0/v37C4VC2I4AAADAtwhYUBm3b99eu3Zt2IgAAADA9wlYUG7/+Mc/Tp065bFBAAAA + +EECFpTV06dPd+3alcvlwhYEAAAA/o6ABeVz6dIlXxsEAACA+RKwoBw+fPhw6NAhjw0CAADAAghYUHL3 + 798fGBiorq4O2w4AAACYDwELSuv06dMrVqzw0isAAABYMAELSmVubm7Pnj3Nzc1htwEAAAALImBBSdy/ + f3/t2rUeGwQAAICfJ2BB8Z07d669vT2fz4d9BgAAAPwEAQuK6fPnz7t3766trQ07DAAAAPhpAhYUzYsX + L77uKO9rBwAAgOISsKA4bt++XV9fHzYWAAAAUDwCFhTBnj17wpYCAAAAik3Agp8yMzPT1dUV9hMAAABQ + AgIWLNC7d+8uXbpUXV0dNhMAAABQGgIWLMTTp08HBwfDNgIAAABKScCC+fny5cvVq1eXL18e9hAAAABQ + YgIWzMPz58+Hh4ebm5vDBgIAAABKT8CCH3X79u2NGzd66RUAAACUmYAFf+/jx49nzpxZtmxZ2DcAAABA + GQlY8DdevHixa9eulpaWsGkAAACA8hKw4K/cvXt39erVNTU1YccAAAAAZSdgwXedOnWqvb097BUAAACg + QgQs+LYtW7Y0NDSEjQIAAABUjoAFf/bq1avOzs5CoRB2CQAAAFBRAhb8wejoaH19fdgfAAAAQAIIWPBf + GzZsqKqqCpsDAAAASAYBC/5penra+9oBAAAgmQQs+O3o0aM1NTVhTwAAAAAJI2CRaa9fv16/fn3YDQAA + AEAiCVhk1KdPn8bGxrq6usJWAAAAAJJKwCKLXr16deDAgcbGxrAPAAAAgAQTsMicu3fvbtiwIZ/Ph00A + AAAAJJuARYZ8/vz51KlTy5YtC8sfAAAASAMBi6yYnp7euXOnxwYBAAAgdQQsMuHGjRt9fX1h1QMAAACp + ImARvyNHjnR0dIQlDwAAAKSNgEXM3r59u3nz5vr6+rDeAQAAgBQSsIjW1atXV65cmcvlwmIHAAAA0knA + Ik779u1btGhRWOYAAABAmglYxObVq1f9/f01NTVhjQMAAAApJ2ARlStXrixdutRjgwAAABATAYt4HDx4 + 0PvaAQAAID4CFjGYmZnp7+8PixoAAACIi4BF6l29etX72gEAACBiAhYpNjs7e/jw4Xw+H5YzAAAAECMB + i7R68OCBxwYBAAAgCwQsUunChQutra1hFQMAAABRE7BImcnJyUOHDoX1CwAAAGSAgEWaXL16de3atWHx + AgAAANkgYJEOc3NzIyMjvjYIAAAAGSRgkQL379/ftm1bTU1NWLYAAABAlghYJN3o6OjXZZrP58OaBQAA + ADJGwCK53r59u3//fl8bBAAAgIwTsEio8fHx/v7+2trasFQBAACArBKwSKILFy50dHR4bBAAAAD4SsAi + Wf7xj3/s3bu3vr4+rFAAAAAg8wQsEuT169e9vb2FQiEsTwAAAAABi+S4e/duQ0NDWJgAAAAA/yFgkQj7 + 9+8PSxIAAADgjwQsKq+rqyusRwAAAID/IWBRMV++fLl69Wp1dXVYjAAAAADfImBRGS9fvhwcHAzLEAAA + AOD7BCzK7ddff71161Z3d3dYgwAAAAB/ScCirF6+fDkyMtLS0hIWIAAAAMDfEbAon/Hx8c2bN9fU1ITV + BwAAAPADBCzK4ePHj+fOnVuxYkUulwtLDwAAAODHCFiU3PT09J49e1pbW8OiAwAAAJgPAYvSGh8f7+vr + 89ggAAAAsGACFiV05syZzs7OsNYAAAAAFkTAolS2bt3a1NQUFhoAAADAQglYFN+rV6+WLVtWVVUVVhkA + AADATxCwKLIzZ860tLSE9QUAAADw0wQsimnjxo21tbVhcQEAAAAUg4BFcTx79qyrqyssKwAAAIDiEbAo + ghMnTjQ0NIQ1BQAAAFBUAhY/5f379xs3bgyrCQAAAKAEBCwW7saNG0uXLg1LCQAAAKA0BCwW4u3bt8PD + w42NjWEdAQAAAJSMgMW8PXjwYGBgIJfLhUUEAAAAUEoCFvMzOjra3d0dlg8AAABA6QlY/KjXr1/v3bvX + 1wYBAACAMhOw+CG3bt3q7+8PqwYAAACgjAQs/t6xY8d8bRAAAACoFAGLv/Lq1avt27fX19eH9QIAAABQ + dgIW3zU2Ntbb25vP58NiAQAAAKgEAYtvO3jwYHt7e1gmAAAAAJUjYPFnL1682LRpU21tbVgjAAAAABUl + YPEHY2Nj3d3dHhsEAAAAkkPA4r+Gh4cbGxvD0gAAAABIBgGLf5qZmdm0aVMulwvrAgAAACAxBCx+u3fv + nve1AwAAAIklYGXdsWPHwloAAAAASCQBK7umpqb6+/vDQgAAAABIKgEro27evNnc3BxWAQAAAECCCViZ + MzU1dfTo0XD/AQAAABJPwMqWmzdvrl27Ntx8AAAAgDQQsLLi7du3J0+eXLRoUbjzAAAAACkhYGXCgwcP + duzYUVtbG247AAAAQHoIWPG7ePFiT09PPp8P9xwAAAAgVQSsmL158+bgwYMeGwQAAABSTcCK1sOHDzdu + 3FhXVxduNQAAAEA6CVhxunz5cldXV6FQCPcZAAAAILUErAjt37+/sbEx3GEAAACAlBOwojI7O7t69erq + 6upwewEAAADST8CKx71795qamnK5XLi3AAAAAFEQsCJx4MCBcEsBAAAA4iJgxWD58uXhfgIAAABER8BK + t+vXr9fU1ISbCQAAABAjASut5ubmduzY4Y1XAAAAQPQErPT58uXLvXv3VqxYEe4hAAAAQNQErJR5/fr1 + 8ePHW1tbww0EAAAAiJ2AlSaPHj3aunWrl14BAAAAmSJgpcPnz58vXrz49W6F+wYAAACQGQJWCszMzOzf + v3/RokXhpgEAAABkiYCVdA8fPly/fr3HBgEAAIDMErAS7ezZs8uWLQv3CgAAACCTBKzk2r59e0tLS7hR + AAAAAFklYCXRs2fPenp6CoVCuEsAAAAAGSZgJc7p06fb29vD/QEAAADIPAErWQYGBurr68PNAQAAAEDA + So7Hjx93d3fn8/lwZwAAAAD4FwErEU6cOOF97QAAAADfJGBV3tatW/3hFQAAAMD3CFiVdPfu3eXLl4db + AQAAAMC3CFiV8eHDh2PHjjU0NIT7AAAAAMB3CFgV8Pjx423btoU7AAAAAMBfErDK7dKlSytWrAiXHwAA + AIC/I2CVz5s3bw4dOlRfXx+uPQAAAAA/QMAqk7t37w4MDISrDgAAAMAPE7DK4eTJk742CAAAALAwAlZp + vXjxYteuXb42CAAAALBgAlYJjY2N9fX15fP5cLEBAAAAmD8Bq1SGh4eXLFkSLjMAAAAACyVgFd/U1NSW + LVt8bRAAAACgKASsIrt27drKlSsLhUK4wAAAAAD8HAGrmEZGRpqbm3O5XLi6AAAAAPw0Aas43r59OzAw + 4H3tAAAAAEUnYBXBw4cPva8dAAAAoEQErJ919uxZzwwCAAAAlI6AtXCfPn3q7+8PFxIAAACA0hCwFujR + o0dNTU3hKgIAAABQMgLWvE1PTx87dixcPwAAAABKTMCan/v3769duzZcPAAAAABKT8D6UbOzs6Ojo4sX + Lw5XDgAAAICyELB+yKNHj3bt2lVXVxcuGwAAAADlImD9vStXrvT29hYKhXDNAAAAACgjAeuvvHnz5siR + Ix4bBAAAAKggAeu7JiYmBgYGGhoawqUCAAAAoBIErG8bGxtbvny5xwYBAAAAKk7A+oaDBw+2tLSEKwQA + AABARQlYf/Dx48c1a9bU1taGywMAAABApQlY/3Xv3r3W1tZcLheuDQAAAAAJIGAFBw8erKqqClcFAAAA + gMQQsP5p5cqV/vAKAAAAIJmyHrBu3brV0NAQLgYAAAAAyZPpgLVz5858Ph+uBAAAAACJlNGA9ejRo6+/ + PFwDAAAAABIscwFrdnb29OnTbW1t4QIAAAAAkGzZClhPnz4dHBysqakJvx4AAACAxMtQwBobG+vt7Q2/ + GwAAAICUyETAevv27aFDh9rb28OPBgAAACA94g9YExMTmzZt8tggAAAAQEpFHrBGR0dXrlwZfisAAAAA + KRRzwBoaGmptbQ0/FAAAAIB0ijNgPXnyZO3atVVVVeFXAgAAAJBaEQasU6dOdXV1hd8HAAAAQMrFFrC2 + b9/e2NgYfhwAAAAA6RdPwHr48OHXH1MoFMIvAwAAACAKkQSs06dPL1q0KPwmAAAAACISQ8AaHBz0vnYA + AACAWKU7YE1MTKxcuTL8FAAAAABilOKAdfr06fr6+vA7AAAAAIhUKgPW1NTUzp07wy8AAAAAIGrpC1jX + rl3z2CAAAABAdqQpYM3NzR0/fryuri782wEAAADIgNQErHv37g0ODoZ/NQAAAACZkY6ANTo6unz58vBP + BgAAACBLkh6wnj9/vm/fvoaGhvDvBQAAACBjEh2wrl27tn79+kKhEP6xAAAAAGRPcgPWmTNnOjs7wz8T + AAAAgKxKbsC6fv16b29vLpcL/1IAAAAAMinRjxBOTEzs2bOnuro6/GMBAAAAyJ6kv8R9bm7uwoULbW1t + 4d8LAAAAQMYkPWD928TExNq1a8M/GQAAAIAsSUfA+mp2dvbkyZPhXw0AAABAZqQmYP3bw4cPGxsbw78d + AAAAgAxIWcD66vPnz/39/eGfDwAAAEDs0hew/u3EiRNVVVXhRwAAAAAQr7QGrK9u3rzZ2dmZy+XCTwEA + AAAgRikOWF+9fPly06ZN/hQLAAAAIGLpDlj/dvjw4dbW1vCDAAAAAIhLDAHrq8uXL3/9JYVCIfwsAAAA + AGIRScD66tmzZ1u2bKmvrw+/DAAAAIAoxBOw/m14eLijoyP8OAAAAADSL7aA9dXVq1fXrVsXfh8AAAAA + KRdhwPrq5cuXe/bsqa2tDb8SAAAAgNSKM2D926lTp5YuXRp+KAAAAADpFHPA+ur27dsDAwPhtwIAAACQ + QpEHrK9ev3596NAhXycEAAAASKn4A9a/Xb58ubu7O/xoAAAAANIjKwHrq8nJSY8TAgAAAKROhgLWvx09 + etTjhAAAAAApkrmA9dX9+/d9nRAAAAAgLbIYsP5tYGCgqqoqXAYAAAAAkiq7AeurY8eOtbS0hCsBAAAA + QCJlOmB9NTEx0d3dXSgUwvUAAAAAIGGyHrD+bWBgoKGhIVwSAAAAAJJEwApOnz7d3t4ergoAAAAAiSFg + /deTJ096enq82R0AAAAgUQSsPxscHGxtbQ2XBwAAAIBKE7C+4cyZM8uXLw9XCAAAAICKErC+7f79+xs2 + bKipqQnXCQAAAIAKEbC+6+XLlwcOHGhrawuXCgAAAIBKELD+ysePHy9fvrxy5cpwtQAAAAAoOwHr701M + TGzdurW6ujpcMwAAAADKSMD6IW/evDl16lRTU1O4bAAAAACUi4A1D48fP/Z1QgAAAIAyE7DmbXBwMFw8 + AAAAAEpPwFqI+/fvV1VVhUsIAAAAQCkJWAu3dOnScBUBAAAAKBkB66fs2bOnUCiEawkAAABACQhYP+va + tWstLS25XC5cUQAAAACKSsAqgsnJyTVr1tTU1ISLCgAAAEDxCFjF8f79+3379jU1NYXrCgAAAECRCFjF + dP78+WXLlnkrFgAAAEARCVhFdu/evU2bNtXV1YULDAAAAMDPEbCK7/Xr14cOHVq0aFG4xgAAAAD8BAGr + VC5evLhq1SpfJwQAAAD4SQJWCT148GBoaKiqqipcbAAAAADmT8AqrdnZ2bNnz7a0tITrDQAAAMA8CVjl + cPfu3XXr1oVLDgAAAMB8CFhl8urVqyNHjoSrDgAAAMAPE7DK6vr16x4nBAAAAJgXAavcnj9/7nFCAAAA + gB8nYFXGyMhIoVAINwEAAACA7xOwKub69esdHR3hPgAAAADwHQJWJT1//ry/v9+fYgEAAAD8BQGr8g4c + ONDc3BxuCAAAAAB/JGAlwsWLF7u7u/P5fLgtAAAAAPyHgJUUz58/37RpU11dXbgzAAAAAPyLgJUsBw8e + XLJkSbg5AAAAAAhYCTQ2NrZ69epwfwAAAAAyT8BKotevXw8ODtbW1oa7BAAAAJBhAlZyHT16tKurK9wo + AAAAgKwSsBLt5s2b/f394V4BAAAAZJKAlXQvXrzYu3dvQ0NDuGMAAAAAGSNgpcDHjx/PnTu3bNmycNMA + AAAAskTASo1Hjx5t3Lgx3DcAAACAzBCw0uTDhw+HDh2qr68Pdw8AAAAgAwSs9Ll9+/aSJUvCDQQAAACI + nYCVVhs2bMjn8+E2AgAAAMRLwEqxkZERXycEAAAAoidgpdvk5GRHR0culwv3EwAAACA6AlYMNmzYUFtb + G24pAAAAQFwErEicPHmypaUl3FUAAACAiAhY8Xj8+HF3d3dVVVW4twAAAABRELCi8vHjx23btjU3N4fb + CwAAAJB+AlaETp061dXVFe4wAAAAQMoJWHG6c+fOunXrampqwn0GAAAASC0BK1pTU1N79+5tbW0NtxoA + AAAgnQSsmL1///78+fPd3d3hbgMAAACkkIAVv/Hx8c2bN/s6IQAAAJBSAlYmTE9PHzt2rKGhIdx2AAAA + gPQQsLLiy5cv9+/fX7p0abjzAAAAACkhYGXL3Nzcjh07ws0HAAAASAMBK4vu3LkT7j8AAABA4glY2dXV + 1RVWAQAAAECCCViZtmfPnrAQAAAAAJJKwMq6sbGx5ubmXC4XVgQAAABAwghY/Pb48ePe3t6qqqqwKAAA + AACSRMDin2ZnZ3ft2tXQ0BDWBQAAAEBiCFj819mzZ7u6uvL5fFgdAAAAAAkgYPEHd+7c6e/vr62tDQsE + AAAAoNIELP5sZmZm//79ra2tYY0AAAAAVJSAxbeNjo5+XRxhmQAAAABUjoDFd42Pjw8ODhYKhbBYAAAA + ACpBwOKvvHv37vjx4y0tLWG9AAAAAJSdgMXfu3HjRl9fX1gyAAAAAOUlYPFDpqam9u3bF1YNAAAAQBkJ + WPyoz58/X7hwwdcJAQAAgDITsJifhw8frl27NiwfAAAAgNITsJi3z58/HzhwIJfLhUUEAAAAUEoCFgt0 + 7dq19vb2sI4AAAAASkbAYuFevny5du1af4oFAAAAlJSAxc/au3dvY2NjWFAAAAAAxSZgUQQXLlxYunSp + P8UCAAAASkHAojimp6fXrVtXU1MTVhYAAABAkQhYFNPevXsXL14cFhcAAABAMQhYFNnVq1e/rqqwvgAA + AAB+moBF8c3NzW3atKmuri6sMgAAAICfIGBRKocPH+7s7AwLDQAAAGChBCxK6Pr16319fWGtAQAAACyI + gEVpTU1NDQ0NNTQ0hBUHAAAAME8CFiX37t2706dPL126NCw6AAAAgPkQsCiT+/fvr1+/PpfLhaUHAAAA + 8GMELMpnZmZm//799fX1YfUBAAAA/AABi3K7ceNGe3t7WIAAAAAAf0fAojJ8nRAAAAD4QQIWFXP8+PGa + mpqwEgEAAAC+Q8Cikl69etXW1hYWIwAAAMC3CFhUXn9/f1VVVViSAAAAAH8kYJEIJ06caGhoCKsSAAAA + 4HcELJJiYmJi2bJl/hQLAAAA+BMBiwR5+/btli1bGhsbw/IEAAAAELBIoBMnTixZsiSsUAAAACDzBCyS + 6ObNm2vWrKmurg7rFAAAAMgwAYuEmpyc3LVrV3Nzc1iqAAAAQFYJWCTXhw8fzp49u3Tp0rBaAQAAgEwS + sEi6O3fubNq0qVAohDULAAAAZIyARQq8ePHi6NGj9fX1YdkCAAAAWSJgkQ5fvny5efNmV1dXWLkAAABA + ZghYpMmLFy927NgRFi8AAACQDQIW6XPt2rWwfgEAAIAMELBIpdnZ2c7OzrCKAQAAgKgJWKTY7t27w0IG + AAAA4iVgkW6XL19ubGwMyxkAAACIkYBF6j169Kinpyefz4dFDQAAAMRFwCIGs7OzO3furKurC+saAAAA + iIiARTxOnTrV0dHhT7EAAAAgMgIWUbl169batWurq6vDAgcAAADST8AiNrOzs7t3725ubg5rHAAAAEg5 + AYs4nT59euXKlWGZAwAAAGkmYBGt+/fvb9261SuxAAAAIO0ELGL26dOn4eHhlpaWsN4BAACAFBKwiN+V + K1dWr14dljwAAACQNgIWmfDkyZOhoaFcLhcWPgAAAJAeAhZZ8eHDh9OnT7e2toa1DwAAAKSEgEW23Llz + Z82aNWH5AwAAAGkgYJE5b9682bNnj68TAgAAQFoIWGTUhQsXPE4IAAAAqSBgkV2vXr3yOCEAAAAkn4BF + 1u3evbu+vj5sCAAAACB5BCz47eLFi0uWLAl7AgAAAEgYAQv+6e3bt6tXr66urg47AwAAAEgMAQv+a/fu + 3d7sDgAAAEkjYMEfXL16ddmyZWF/AAAAAAkgYMGfzc3NrV+/vq6uLuwSAAAAoKIELPi2AwcOeLM7AAAA + JIGABd81NjbW29uby+XCdgEAAAAqQcCCv/L06dPt27c3NDSEHQMAAACUnYAFf+Pt27cnTpzo7OwMmwYA + AAAoLwELfsjt27f7+vo8TggAAADlJ2DBj3rx4sXevXt9nRAAAADKTMCCefj48ePY2NiiRYvCBgIAAABK + T8CCeXvz5s3q1avDHgIAAABKTMCCBRoZGQnbCAAAACglAQsWbnZ2trm5OWwmAAAAoDQELPhZ69at83VC + AAAAKB0BC4rg+PHjvk4IAAAAJSJgQXE8fPiws7OzUCiEvQUAAAAUiYAFRfP69evNmzfX19eH7QUAAAAU + g4AFRTYyMrJ48eKwwwAAAICfJmBB8V2/fn3VqlXV1dVhnwEAAAA/QcCCknj8+PHOnTubmprCVgMAAAAW + SsCCUvn48eOpU6c6OzvDbgMAAAAWRMCC0rpx48aGDRt8nRAAAAAWTMCCkpuamjp8+HBdXV3YdgAAAMB8 + CFhQJmNjY11dXWHnAQAAAD9MwILyefz48Y4dO8LmAwAAAH6MgAVl9eHDh3PnzuXz+bAFAQAAgL8jYEEF + TExMdHR0hF0IAAAA/CUBCyrj06dPHicEAACAHyFgQSVdvHixoaEhbEcAAADgWwQsqLAHDx6sXLkyl8uF + TQkAAAD8kYAFlffu3bvBwcGampqwLwEAAIDfEbAgKU6cONHe3u5PsQAAAOBPBCxIkFu3bq1evbqqqips + UAAAAEDAgqT58OHD4OBgU1NT2KMAAACQeQIWJNGJEyeWL18etikAAABkm4AFCXX//v2NGzfm8/mwWQEA + ACCrBCxItAMHDjQ3N4f9CgAAAJkkYEHSnTt3rqenJ2xZAAAAyB4BC1Lg4cOH27dv9zghAAAA2SRgQTrM + zs6OjIy0traGvQsAAACZIWBBmly/fn316tVh+wIAAEA2CFiQMi9fvty5c2ehUAibGAAAAGInYEEqnT17 + tqWlJexjAAAAiJqABWk1NTX1dQOHrQwAAADxErAg3YaGhmpqasKGBgAAgBgJWJB6ly5damtrC3saAAAA + oiNgQQw+fPjwdTNXVVWFnQ0AAAAREbAgHrt27WpqagqbGwAAAGIhYEFUrl27tmTJkrC/AQAAIAoCFsTm + zZs3fX19tbW1YZcDAABAyglYEKd9+/YtXrw4bHQAAABIMwELonX58uWvOzyfz4ftDgAAAOkkYEHMJiYm + tmzZ0tDQEHY8AAAApJCABZGbmZkZGRnxZncAAADSS8CCTLhx48bq1atzuVzY+gAAAJAeAhZkxdOnT3fv + 3u3rhAAAAKSOgAUZMjc3d+nSpba2tnAAAAAAQBoIWJA5U1NTq1evDmcAAAAAJJ6ABRl19OjRcAwAAABA + sglYkF0vX76sr68PhwEAAAAklYAFWedxQgAAABJOwAJ+O3bsWHV1dTgVAAAAIGEELOCf7t+/v2TJknw+ + H84GAAAASAwBCwimp6c3btxYW1sbjgcAAABIBgEL+IMjR460traGEwIAAAASQMAC/mxsbOzr0VBVVRXO + CQAAAKgoAQv4hsePH2/fvr2hoSEcFQAAAFA5Ahbwbf/4xz9GRkY6OjrCaQEAAAAVImABf+Xq1avr16/P + 5XLhzAAAAICyE7CAvzE5Obl///66urpwbAAAAEB5CVjADzl//nxXV1c4OQAAAKCMBCzgR42Pj2/dujUc + HgAAAFAuAhYwD2/fvj1x4kRVVVU4QgAAAKD0BCxg3m7fvt3Z2RlOEQAAACgxAQtYiJcvX27bti0cJAAA + AFBKAhawcKdPn66trQ3HCQAAAJSGgAX8lPHx8RUrVoQTBQAAAEpAwAJ+1vv377du3VpdXR3OFQAAACgq + AQsojmPHji1atCgcLQAAAFA8AhZQNLdv3+7p6SkUCuGAAQAAgGIQsIBi+vLly9atWxsbG8MZAwAAAD9N + wAKK79ixY0uXLg3HDAAAAPwcAQsoifv3769bty6fz4fDBgAAABZKwAJKaGhoqLm5OZw3AAAAsCACFlBa + p0+fXrlyZThyAAAAYP4ELKDkxsfHBwYGfJ0QAACAhRGwgHKYmZk5dOhQW1tbOHsAAADghwlYQJn8+uuv + V65cWbVqVTh+AAAA4McIWEBZTU5Obtu2zeOEAAAA/DgBCyi3jx8/njp1qqWlJZxDAAAA8JcELKAyHj9+ + vHz58nAUAQAAwPcJWEAlbd++3eOEAAAA/DUBC6iwsbGxxsbGcCYBAADA/xCwgMr78uVLd3d3Pp8PJxMA + AAD8joAFJMXQ0FBdXV04nAAAAOA/BCwgQa5cudLW1hbOJwAAAPgXAQtIltevX/f29tbW1oZTCgAAgMwT + sIAk2rNnT2trazioAAAAyDYBC0ioixcverM7AAAAXwlYQHI9fPhw06ZN9fX14cQCAAAgkwQsINFevXo1 + PDy8ePHicGgBAACQPQIWkAJXrlzp6enxOCEAAEA2CVhAOjx69GhoaKimpiacXgAAAGSGgAWkxtu3b8+d + O+frhAAAAFkjYAEp8+jRo97e3nCGAQAAkAECFpA+c3Nzw8PD4RgDAAAgdgIWkFZPnz71SiwAAIAsWL58 + eRgFi0HAAsrN44RAOeXz+evXr8/Nzc0AAFAur1+/np2dDUNgMQhYQAUcO3asUCiE4RKglPL5/NTUVDh9 + AABIJwELqIw7d+60t7fncrkwYgKURj6ff/r0aTh6AABIJwELqJgXL15s2LChuro6TJkAJSBgAQBEQMAC + Kuzw4cPNzc1h0AQoNgELACACAhZQeZcvX16xYoW3YgGlIGABAERAwAIS4fHjx1u2bKmrqwsTJ0CRCFgA + ABEQsIAEGR4ebm9vD0MnQDEIWAAAERCwgGS5fPlyX1+frxMCxSJgAQBEQMACEmdycnL37t21tbVh+gT4 + CQIWAEAEBCwgoU6fPt3Z2RkGUICFErAAACIgYAHJdefOnc2bN4cZFGBBBCwAgAgIWECivXr1anh4uLq6 + OkyiAPMkYAEAREDAAlLgypUrXV1dYRgFmA8BCwAgAgIWkA5f588tW7aEeRTghwlYAAARELCANBkZGamp + qQlTKcAPELAAACIgYAEpc+/evWXLloXBFODvCFgAABEQsIBU2rx5c6FQCOMpwPcJWAAAERCwgLQ6cuRI + S0tLmFABvkPAAgCIgIAFpNjdu3e7u7u/TqdhTgX4HwIWAEAEBCwg9TZv3lxfXx9GVYA/ErAAACIgYAEx + GBkZWbJkSZhWAX5HwAIAiICABUTi/v37vb29HicE/kTAAgCIgIAFRGXbtm1NTU1hbAUQsAAAoiBgAbE5 + ceLE8uXLw+QKZJ6ABQAQAQELiNC9e/c2bNhQVVUV5lcgwwQsAIAICFhAnF69erVv377W1tYwwgJZJWAB + AERAwAKi9fHjx4sXL65cuTJMsUAmCVgAABEQsIDITUxMDAwMeJwQMkvAAgCIgIAFxO/NmzfHjx9vbm4O + 4yyQJQIWAEAEBCwgK8bHx5ctWxYmWiAzBCwAgAgIWEC2bNmyJQy1QDYIWAAAERCwgMwZGxurra0Noy0Q + OwELACACAhaQUUuXLg3TLRA1AQsAIAICFpBdg4ODvk4I0ROwAAAiIGABmXblypWWlpYw5gIxErAAACIg + YAFZ9/Lly56enpqamjDsAnERsAAAIiBgAfz26dOn3bt3Nzc3h3kXiIiABQAQAQELIDh//vzSpUu/zrph + 6gWiIGABAERAwAL4r/v372/YsKGuri4MvkD6CVgAABEQsAD+YHp6+uDBg21tbWH2BVJOwAIAiICABfAN + Fy9e/OWXXzxOCBEQsAAAIiBgAXzb+Pj44OBgdXV1GIKBdBKwAAAiIGABfNfMzMzp06dbWlrCHAykkIAF + ABABAQvgb9y9e3fVqlVhFAbSRsACAIiAgAXw916+fHn48OEwDQOpImABAERAwAL4UXfv3q2rqwszMZAS + AhYAQAQELIB5mJ2d7e3tDWMxkAYCFgBABAQsgHkbGRkJkzGQeAIWAEAEBCyAhbh169aiRYvCfAwkmIAF + ABABAQtggZ4/f97f3/91Ng5TMpBIAhYAQAQELICfcuDAgcbGxjAoA8kjYAEAREDAAvhZFy5cWL58uT/F + gmQSsAAAIiBgARTB48ePN27cWFtbGyZmIDEELACACAhYAEVz4MCBxYsXh6EZSAYBCwAgAgIWQDFdvHix + t7c3zM1AAghYAAARELAAiuzrqLxjxw6PE0JCCFgAABEQsABK4vjx40uWLAkDNFA5AhYAQAQELIBSuX79 + en9/f5ihgQoRsAAAIiBgAZTQixcv9u/fX1NTEyZpoOwELACACAhYAKX15cuXc+fOdXV1hWEaKC8BCwAg + AgIWQDk8ePBg06ZNYZ4GykjAAgCIgIAFUCbv378/dOiQrxNCmQlYAAARELAAyurGjRsdHR1hsAZKT8AC + AIiAgAVQARs2bMjlcmG8BkpJwAIAiICABVAZw8PDjY2NYcIGSkbAAgCIgIAFUDH37t3r6uryp1hQUgIW + AEAEBCyACuvv7/dmdygdAQsAIAICFkDlDQ8PL1q0KEzbQFEJWAAAERCwABLh4cOHK1as+Dpph5kbKBIB + CwAgAgIWQIIMDAw0NTWFsRsoBgELACACAhZAshw/fryrqytM3sBPE7AAACIgYAEkzp07d9auXVtdXR3m + b+AnCFgAABEQsACS6MWLF7t3725paQkjOLBQAhYAQAQELICEev/+/blz55YvXx6mcGBBBCwAgAgIWACJ + Nj4+vnHjxqqqqjCLA/MkYAEAREDAAki66enpI0eONDY2hnEcmA8BCwAgAgIWQAp8/vz5zp07vk4ICyBg + AQBEQMACSI13794NDAyEoRz4MQIWAEAEBCyAlLl06dLXgTyM5sDfEbAAACIgYAGkUkdHR5jOgb8kYAEA + REDAAkir7du353K5MKMD3yFgAQBEQMACSLErV674OiH8NQELACACAhZAuk1NTa1cubKqqioM68AfCVgA + ABEQsABS7/3797t27WpoaAjzOvA7AhYAQAQELIBInD17tqOj4+usHqZ24F8ELACACAhYAPG4e/fu+vXr + a2trw+AOCFgAAFEQsACiMj09vW/fvpaWljC7Q+YJWAAAERCwACI0Ojq6YsWKXC4XJnjIMAELACACAhZA + nO7evbt161ZfJwQBCwAgAgIWQLRevXp1/Pjx5ubmMMdDJglYAAARELAAInf9+vVVq1aFUR6yR8ACAIiA + gAUQv8nJyQMHDoRpHjJGwAIAiICABZAJX758uXLlSn19fZjpITMELACACAhYABny5MmT1atXh7EeskHA + AgCIgIAFkC2//vrroUOHwmQPGSBgAQBEQMACyKLr16+3tbWF+R6iJmABAERAwALIqOfPn69duzaM+BAv + AQsAIAICFkCm7d2715vdiZuABQAQAQELIOvOnTvX1dWVy+XCuA9xEbAAACIgYAHwz68Trl+/vqamJkz8 + EBEBCwAgAgIWAMHevXu92Z34CFgAABEQsAD4r/Pnz//yyy9h7ocoCFgAABEQsAD4g2fPnm3dutXjhERD + wAIAiICABcA3HD58uL29PQQASDMBCwAgAgIWAN82Nja2du3a0AAgtQQsAIAICFgAfNfU1NTQ0FBdXV0o + AZBCAhYAQAQELAD+ysePH0+dOtXZ2RliAKSNgAUAEAEBC4C/d/fu3fXr14ceAKkiYAEAREDAAuCHzMzM + 7Nu3z+OEpI6ABQAQAQELgHkYGxtbsmRJCAOQBgIWAEAEBCwA5mdubq6vry+0AUg8AQsAIAICFgALcfjw + YY8TkgoCFgBABAQsABbowYMH7e3tIRJAUglYAAARELAA+Clr166tqakJqQCSR8ACAIiAgAXAzzpy5EhT + U1OoBZAwAhYAQAQELACKYGJioqurK5/Ph2YAiSFgAQBEQMACoGg2btzY2NgYsgEkg4AFABABAQuAYjp2 + 7NiSJUtCOYAEELAAACIgYAFQZLdu3ert7a2urg79ACpKwAIAiICABUDxPXv2bGhoqLm5OSQEqBwBCwAg + AgIWACXx7t2706dPL126NFQEqBABCwAgAgIWACV0586d/v7+qqqq0BKg7AQsAIAICFgAlNbz588PHTrU + 0NAQcgKUl4AFABABAQuAkvvw4cP169c7OztDUYAyErAAACIgYAFQJi9evNi8eXOIClAuAhYAQAQELADK + 6sKFC7lcLqQFKD0BCwAgAgIWABXQ1tYW6gKUmIAFABABAQuAyhgcHAyBAUpJwAIAiICABUDFXLlypa6u + LmQGKA0BCwAgAgIWAJX09OnT7u7uQqEQYgMUm4AFABABAQuACnv37t3OnTtra2tDb4CiErAAACIgYAGQ + CKdOnWpvb8/n86E6QJEIWAAAERCwAEiKW7du9fX11dTUhPAAxSBgAQBEQMACIEFevny5a9eu5ubm0B7g + pwlYAAARELAASJxTp04tX748l8uFAgE/QcACAIiAgAVAEt2+fXtgYKCqqipECFgoAQsAIAICFgAJ9fr1 + 6+Hh4aamptAhYEEELACACAhYACTa5cuXV61aFVIEzJ+ABQAQAQELgKR7/Pjx7t27Q42AeRKwAAAiIGAB + kAIfPnw4e/ZsY2NjaBLwwwQsAIAICFgApMbdu3d7e3tDloAfI2ABAERAwAIgTWZmZvbu3RvKBPwAAQsA + IAICFgDpc/Hixebm5tAn4C8JWAAAERCwAEil58+fr1mzJiQK+D4BCwAgAgIWACm2e/fu2traECrgWwQs + AIAICFgApNvo6GhHR0culwu5Av5IwAIAiICABUDqTU5Orlmzprq6OhQL+B0BCwAgAgIWAJEYGhpqaWkJ + 0QL+Q8ACAIiAgAVAPM6dO9fd3R26BfyLgAUAEAEBC4CovHjxYuPGjR4n5P8TsAAAIiBgARChvXv3tre3 + h4BBtglYAAARELAAiNPly5d7e3tDwyDDBCwAgAgIWABEa3Jycvv27XV1daFkkEkCFgBABAQsAGI2Nzd3 + /Pjxjo6OEDPIHgELACACAhYA8bt582ZfX1/oGWSMgAUAEAEBC4BMePHixe7duz1OmEECFgBABAQsALLi + 06dPFy5cWLx4cQgbZIOABQAQAQELgGx5+fLl6tWrQ9sgAwQsAIAICFgAZNH+/furqqpC4SBqAhYAQAQE + LAAy6vHjx62trSFyEC8BCwAgAgIWAJm2evXqQqEQUgcxErAAACIgYAGQdSMjI7W1taF2EB0BCwAgAgIW + APz26NGjJUuW5PP50DyIiIAFABABAQsA/unDhw/9/f319fUhexALAQsAIAICFgD819GjRxctWhTKB1EQ + sAAAIiBgAcAfXL9+vaenp6qqKvQPUk7AAgCIgIAFAH/25MmTwcHBpqamkEBIMwELACACAhYAfMPc3NyJ + Eyc6OztDBSG1BCwAgAgIWADwXTdu3Fi3bp3HCVNNwAIAiICABQB/5enTpwcOHPB1wvQSsAAAIiBgAcDf + eP/+/ZUrVzo6OkIRIVUELACACAhYAPBDHj9+vHnz5hBFSA8BCwAgAgIWAPyoubm5c+fOhS5CSghYAAAR + ELAAYH5evXrV1tYW6giJJ2ABAERAwAKAhdi6dWsIJCSbgAUAEAEBCwAW6NKlS7W1tSGTkFQCFgBABAQs + AFi4iYmJ5cuX53K5EEtIHgELACACAhYA/JTZ2dnBwcHq6urQS0gYAQsAIAICFgAUwYkTJxYtWuRPsRJI + wAIAiICABQDFcePGjdWrV1dVVYVwQjIIWAAAERCwAKBoXr16tWPHjsbGxtBOSAABCwAgAgIWABTZ8ePH + ly5dGvIJlSZgAQBEQMACgOK7efPmxo0bC4VCiChUjoAFABABAQsASuLNmzcHDhxoamoKHYUKEbAAACIg + YAFACZ0/f76npyekFCpBwAIAiICABQCl9fDhw8HBwVBTKDsBCwAgAgIWAJTcu3fvjh071tzcHJoKZSRg + AQBEQMACgDK5fv36qlWrQlahXAQsAIAICFgAUD7Pnz8fGhoKZYWyELAAACIgYAFAuZ05c8bjhGUjYAEA + REDAAoAKmJiY+OWXX0JioZQELACACAhYAFAxO3furKmpCaGF0hCwAAAiIGABQCWdPXt20aJFobVQAgIW + AEAEBCwAqLDnz5/39PQUCoVQXCgqAQsAIAICFgAkwuDgYFNTU4guFI+ABQAQAQELAJLi/PnzXV1dobtQ + JAIWAEAEBCwASJCZmZm+vr7q6upQX/hpAhYAQAQELABInN27d3uze7EIWAAAERCwACCJLl26tHLlytBg + +AkCFgBABAQsAEiox48fDwwM1NfXhxLDgghYAAARELAAILnevn175MiRJUuWhBjD/AlYAAARELAAING+ + fPly7dq11atXhx7DPAlYAAARELAAIAUmJyd37txZV1cXqgw/TMACAIiAgAUA6TA7Ozs6OurrhPMlYAEA + REDAAoA0mZycXLVqVWgz/AABCwAgAgIWAKTPvn37crlcKDT8JQELACACAhYApNLExERDQ0OINHyfgAUA + EAEBCwBSrLe3N3QavkPAAgCIgIAFAOk2PDxcKBRCreF/CFgAABEQsAAg9R48eLB48eJ8Ph+aDb8jYAEA + REDAAoAYzM7Orl+/vra2NmQb/kPAAgCIgIAFAPEYHh5uaWkJ5YZ/EbAAACIgYAFAVK5evbpixYqqqqrQ + bzJPwAIAiICABQCxmZiY2Lp1a0NDQ0g42SZgAQBEQMACgAjNzc2NjIwsWbIkVJwME7AAACIgYAFAtMbG + xvr6+gqFQmg5mSRgAQBEQMACgJg9fvx47969dXV1Iedkj4AFABABAQsAIvfhw4fz5893dHSEopMxAhYA + QAQELADIhPHx8c2bN4eokyUCFgBABAQsAMiKmZmZM2fOhK6TGQIWAEAEBCwAyJbx8fHFixeHupMBAhYA + QAQELADInLdv3w4MDITAEzsBCwAgAgIWAGTU6OhoVVVVyDzxErAAACIgYAFAdj18+HDZsmWh9ERKwAIA + iICABQCZ9ubNmy1btkT8p1gCFgBABAQsAOC3kZGR1tbWkHziImABAERAwAIA/un69es9PT2FQiGEn1gI + WAAAERCwAIBgZmZm27ZtDQ0Nof1EQcACAIiAgAUA/MHRo0e7urpC/kk/AQsAIAICFgDwZzdv3ly3bl0+ + nw8RKM0ELACACAhYAMA3vHv3bvfu3Y2NjaEDpZaABQAQAQELAPiuM2fOrFixIqSgdBKwAAAiIGABAH/l + /v37AwMDoQalkIAFABABAQsA+Btv3rw5fPhwc3NzaEKpImABAERAwAIAfsjly5d/+eWXkIXSQ8ACAIiA + gAUA/KinT59u3749l8uFOJQGAhYAQAQELABgHj59+nT8+PEUPU4oYAEAREDAAgDm7f79+93d3SERJZuA + BQAQAQELAFigbdu2FQqFEIqSSsACAIiAgAUALNzo6GhLS0toRYkkYAEAREDAAgB+yvT0dHd3dz6fD8Uo + YQQsAIAICFgAQBFs27atoaEhRKMkEbAAACIgYAEAxXHx4sXFixeHbpQYAhYAQAQELACgaGZnZ3t6eqqr + q0M9SgABCwAgAgIWAFBkQ0NDra2tISBVmoAFABABAQsAKL7z588vX748NKSKErAAACIgYAEAJfHo0aON + GzfW1dWFklQhAhYAQAQELACgVF69enXo0KHKvtldwAIAiICABQCU0JcvXy5fvtzT05PL5UJSKi8BCwAg + AgIWAFByjx49GhwcrK2tDVWpjAQsAIAICFgAQDnMzMycPn26ra0thKVyEbAAACIgYAEA5fPgwYOenp7Q + lspCwAIAiICABQCU1dzc3L59+0JeKj0BCwAgAgIWAFABDx48qK6uDpGplAQsAIAICFgAQMWU4XFCAQsA + IAICFgBQScPDwyE1lYaABQAQAQELAKiw8fHx1tbWXC4XmlNRCVgAABEQsACAynv9+vXatWtL8VYsAQsA + IAICFgCQFIcOHWpqagrlqUgELACACAhYAECCXL58efny5YVCIfSnnyZgAQBEQMACAJLl4cOHmzdvrq+v + Dwnq5whYAAARELAAgMR5//798PDw4sWLQ4X6CQIWAEAEBCwAIKEuXbq0evXqfD4fWtSCCFgAABEQsACA + 5JqYmNi1a1dtbW3IUfMnYAEAREDAAgAS7fPnz6dPn25vbw9Fap4ELACACAhYAEAK3Lp1a9OmTSFKzYeA + BQAQAQELAEiH6enpkZGR0KV+mIAFABABAQsASJNr167N63FCAQsAIAICFgCQMpOTkz/+OKGABQAQAQEL + AEil48ePFwqFkKm+T8ACAIiAgAUApNW9e/e6urpCqfoOAQsAIAICFgCQYm/fvh0YGMjn86FX/Q8BCwAg + AgIWAJB6R44caW5uDsnqjwQsAIAICFgAQAyuX7++YsWK//1TLAELACACAhYAEIm5ubnNmzfX1dWFdvUv + AhYAQAQELAAgKocPH+7o6Aj5SsACAIiCgAUAxObWrVurV6/+9+OEAhYAQAQELAAgQp8+fdqxY0dDQ8P/ + /d//CVgAAGknYAEA0Tp27NiKFSsePnwY/hsAgHQSsACAmN27d296ejr8BwAA6SRgAQAAAJBoAhYAAAAA + iSZgAQAAAJBoAhYAAAAAiSZgAQAAAJBoAhYAAAAAiSZgAQAAAJBoAhYAAAAAiSZgAQAAAJBoAhYAAAAA + iSZgAQAAAJBoAhYAAAAAiSZgAQAAAJBoAhYAAAAAiSZgAQAAAJBoAhYAAAAAiSZgAQAAAJBoAhYAAAAA + iSZgAQAAAJBoAhYAAAAAiSZgAQAAAJBoAhYAAAAACfbbb/8P9Ndkx8lEjvcAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAABkAAAARrCAIAAABUmv0sAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vwAADr8BOAVTJAAAaLtJREFUeF7s3Xec3VWd+H/vvVMyyaQTEiAklEBCCQEpBgTpgkoJrMpSAog/pImo + NAFRQRBwicCioKBgRCAUBUSkI02KBBBCSyBAIIWQhNRJpvtj3bPf1RUk5czMuec+n3/4j0AmM597zvu8 + Hp/PZz72VwCI59VXXz344IM/BkD5u+GGG5qamsL6DgBdSsACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoE + LABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFg + AZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQs + gGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8AC + ICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA + 6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALI + hoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABi + ErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAO + AQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwI + WACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYB + CyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCw + AIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAF + QDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAA + siFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuA + mAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACk + Q8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAb + AhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJ + wALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoE + LABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFg + AZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQs + gGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8AC + ICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA + 6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALI + hoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABi + ErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAO + AQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwI + WACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYB + CyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCw + AIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAF + QDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAA + siFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuA + mAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACk + Q8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAb + AhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJ + wALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoE + LABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFg + AZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQs + gGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8AC + ICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA + 6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALI + hoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABi + ErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAO + AQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwI + WACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYB + CyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCw + AIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAF + QDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAA + siFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuA + mAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACk + Q8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAb + AhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJ + wALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoE + LABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFg + AZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQs + gGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8AC + ICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA + 6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALI + hoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABi + ErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAO + AQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwI + WACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYB + CyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCw + AIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAF + QDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAA + siFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuA + mAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACk + Q8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAb + AhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJ + wALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoE + LABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFg + AZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQs + gGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8AC + ICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA + 6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALI + hoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABi + ErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAO + AQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwI + WACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYB + CyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCw + AIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAF + QDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAA + siFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuA + mAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACk + Q8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAb + AhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJ + wALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoE + LABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFg + AZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQs + gGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8AC + ICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA + 6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALI + hoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABi + ErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAO + AQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwI + WACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYB + CyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCw + AIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAF + QDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAA + siFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuA + mAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACk + Q8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAb + AhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJ + wALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoE + LABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFg + AZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQs + gGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8AC + ICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA + 6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALI + hoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABi + ErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAO + AQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwI + WACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYB + CyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCw + AIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAF + QDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAA + siFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuA + mAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACk + Q8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAb + AhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJ + wALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoE + LABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFg + AZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQs + gGwIWACkQ8ACICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8AC + ICYBCyAbAhYA6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACICYBCyAbAhYA + 6RCwAIhJwALIhoAFQDoELABiErAAsiFgAZAOAQuAmAQsgGwIWACkQ8ACIKbXXnvtkEMOCUcfAMrZTTfd + 1NzcHNZ3AOhSAhasjKVLl06ZMuXll19+/3+B/+fVV1+977779t1333D0AaCcXXjhha+88sr7a3tY5YG/ + eeGFF9566622trZwNgA6hYAFK2PevHnjxo0bMmRIsVgsAf+oUCiEow8A5Sws68A/Gj169B133OH+ROhk + AhaspHffffcHP/jBwIEDw4gHAABkrVgsbrHFFr/97W+XLVsWTgVAZxGwYOUtWbLkP//zP/v16xc2NAAA + IF+bbrrpH//4x5aWlnAeADqRgAWrZMaMGWecccaAAQPCngYAAGSnVCqNHDnyV7/61aJFi8JJAOhcAhas + qnfeeee0005zHxYAAGSpUCiMGDFi/Pjx6hV0IQELIli8ePHpp5/eq1evsMUBAABZKBQK66+//nXXXdfY + 2Bimf6ArCFgQx5tvvnnMMcf06dMnbHQAAECZKxQKw4YNu/TSS+fNmxfmfqCLCFgQzdy5c7/61a+6DwsA + APKwzjrrXH755Q0NDWHiB7qOgAUxTZkyZezYsfX19WHHAwAAytOQIUMuvvhi9QoSIWBBZC+99NLBBx/c + vXv3sO8BAADlZq211vrhD384f/78MOUDXU3AgvgmTZr0+c9/vra2Nux+AABA+Rg4cOAFF1zQ2toa5nsg + AQIWdIiJEyfutddeVVVVYQ8EAADKQb9+/U4//fQ5c+aEyR5Ig4AFHeW1117ba6+9wjYIAAAkr0+fPt/9 + 7nffe++9MNMDyRCwoAM988wzn/70p0ulUtgPAQCAVPXu3fvkk0+eNWtWmOaBlAhY0LEef/zxHXfcUcMC + AICU1dfXH3PMMW+88UaY44HECFjQ4V566aXtt9++UCiEvREAAEhJdXX1UUcd5b1XkDIBCzpcW1vbPffc + s+2227oPCwAAUtOtW7dDDjlk8uTJYXwHkiRgQWdoaWm5//77R48erWEBAEA6unfvftBBB02dOjUM7kCq + BCzoJK2trY899tioUaPCVgkAAHSp6urqMWPGzJ49O4zsQMIELOg8S5cuve2227bccsuwYQIAAF2ktrZ2 + //33f/bZZ9va2sK8DiRMwIJO1dTU9Ic//GGLLbYI2yYAANDpampq9ttvv5deekm9gnIhYEFne3+PvOuu + uzbddNOweQIAAJ2oqqrqM5/5zBtvvBEGdKAcCFjQBRobG3/zm9+MHDkybKEAAEBnGTNmzHPPPdfa2hqm + c6AcCFjQNVpaWm6++eZNNtkk7KIAAEDH+9znPveXv/ylvb09zOVAmRCwoMssXbr0qquu2nDDDQuFQthO + AQCAjlEsFj/96U8//fTTYRwHyoqABV1p8eLFV1555bBhw8KmCgAAdIw99thDvYLyJWBBF5s7d+64ceOG + Dh3qPiwAAOgI70/a22+//UMPPRRGcKAMCVjQ9WbNmvX9739/6NChxWIx7LEAAEAM1dXV22233e23397c + 3Bzmb6AMCViQhDlz5px99tlrrLGG+7AAACCWqqqqbbbZ5pZbbmlqagqTN1CeBCxIxbRp00455ZQBAwZo + WAAAsOqqqqpGjRo1fvz4RYsWhZkbKFsCFiTk7bffPvHEEzUsAABYRf9dr37+858vWLAgTNtAOROwIC3v + 76/HHntsfX192HgBAIAVVCwWN9xww5/97GeeHIRsCFiQnBkzZhx11FF1dXVh+wUAAJZbsVhcb731/vM/ + /3P+/PlhwgbKn4AFKZozZ84xxxzTrVu3sAkDAADLoVAorLvuupdccon3XkFmBCxI14EHHlhVVRW2YgAA + 4KOsttpqP/jBD8I8DWREwIJ0NTY2fu1rXysWi2E3BgAAPlzfvn1/8pOfhGEayIuABUmbN2/ekUceGTZk + AADgQ/Tp0+eiiy5qbW0NkzSQFwELUvfOO+8cdNBBniUEAIAP06tXr+9+97thgAZyJGBBGXj77bfHjh2r + YQEAwD/r1avXj370o+bm5jA9AzkSsKA8TJkyZcyYMWGLBgAA/qa6uvqss85asmRJmJuBTAlYUB5aW1sn + Tpw4ZsyYurq6sFcDAEBl692793e/+9358+eHoRnIl4AFZaOlpeWxxx7bZ599unXrFnZsAACoVD179jzt + tNPmzJkTxmUgawIWlJPGxsZ77713t912q66uDvs2AABUnrq6uuOPP3769OlhUAZyJ2BBmVm6dOkdd9yx + ++67e5YQAIDK1K9fv+OPP/61115rb28PUzKQOwELyk9LS8vtt9/+yU9+0n1YAABUmvr6+i9/+csvvfRS + W1tbmI+BCiBgQVlqbm6+5ZZbPvGJT2hYAABUjvr6+rFjx7744othLAYqhoAF5WrZsmU33njj6NGja2pq + wn4OAAD56t2799ixY5966qmWlpYwEwMVQ8CC8jZ+/PiNNtqoVCqFXR0AAHJUV1e37777Pvnkk2EOBiqM + gAVl74Ybbth00001LAAActWjR4/99ttPvYJKJmBB2WtpaRk/fvwGG2xQLBbDDg8AALno3r375z73uQcf + fNBb26GSCViQicsvv3zw4MGFQiHs8wAAUP66deu2884733PPPWHqBSqVgAX5uOaaa9Zaa62w1QMAQJmr + qanZeeed//jHP4Z5F6hgAhbko62t7ec//3ltbW3Y8AEAoGyVSqWPf/zj99xzT3t7e5h3gQomYEFufvGL + X6y22mph2wcAgDJULBa32GILTw4C/4+ABblpb2+/7LLL+vfvHzZ/AAAoNxtvvPEjjzwSBlwAAQuy1NTU + dPHFF9fV1YX9HwAAysdqq602ceLEMNoC/I2ABXlauHDh+eefP2jQoDAFAABAORg+fPjjjz8ehlqA/yFg + QZ7a29tnz5793e9+t2/fvmEWAACAtK211lqPPfZYmGgB/o6ABTmbM2fOmWee2adPnzARAABAqgYPHnzv + vfe2traGWRbg7whYkLkZM2acdtppAwcODHMBAACkZ6ONNvrNb37T2NgYpliAfyRgQf6mTp16zDHHuA8L + AIA0DRky5Oqrr16yZEmYXwH+iYAFFeHVV1899thj+/fvH2YEAABIQKFQGDZs2GWXXbZgwYIwuQJ8EAEL + KkJbW9tzzz13xBFHeKc7AADpWG+99S688MJ33nmnvb09TK4AH0TAggry7LPPHnTQQb169QrzAgAAdJFC + oTB06NDvf//7s2bNCtMqwIcTsKCy/OUvfzn44IM1LAAAulCxWFxnnXXOPvvsGTNmhDkV4F8SsKCytLW1 + PfPMM2PGjKmrqwvjAwAAdK6BAweefvrp06ZN8+QgsJwELKhEzz777N57792tW7cwQQAAQKcoFAprrLHG + qaeeOm3atDCbAiwHAQsq1JQpU/baa6/a2towSgAAQAcrFAoDBgw49dRTvfcKWFECFlSuOXPmbLXVVu+P + EWGgAACAjlRfX3/88ccvWrQozKMAy03Agoo2ZcqUnXfeuaqqKswUAADQMXr16nXssce+8847YRIFWBEC + FlS6t99+231YAAB0qO7dux9++OFz584NMyjAChKwgL9Onjx5xIgRYbgAAICoamtrDz744DB6AqwUAQv4 + Lw899NDHP/7xMGIAAEAkNTU1Bx544Jw5c8LcCbBSBCzgv7S1td19990bbbRRGDQAAGCVFYvFvfbaa9my + ZWHoBFhZAhYQtLe333rrraNGjSqVSmHiAACAlVVdXb333nu/9dZbYdwEWAUCFvC/Ghoarrvuus022ywM + HQAAsLL22muv559/PgyaAKtGwAL+wdKlS8ePHz9ixAi/lxAAgJVTKpX22GMP9QqISMAC/q/FixdfddVV + m2yyiWcJAQBYUbW1tXvuuecTTzzR3t4e5kuAVSZgAR9gwYIFP//5z9ddd90whgAAwPLZaaedHnvssdbW + 1jBZAsQgYAEfbP78+Zdffvl6661XLBbDMAIAAB+uurp6p512+uMf/9jc3BxmSoBIBCzgQ82fP//HP/7x + kCFDvA8LAIB/raqq6pOf/OQ999zT1NQUpkmAeAQs4F9pa2v7+c9/3r9//zCYAADABxk1apT3XgEdR8AC + PkJDQ8Oll146ePBg92EBAPDPqqurR48efe+993pyEOg4Ahbw0RYsWHDOOeesvvrqYUgBAIC/KRaLo0aN + uummm5YuXRpmR4AOIGABy+vcc8/1LCEAAP9PsVjceOONf/e734V5EaDDCFjA8po3b95pp52mYQEA8L5i + sThy5Mhrr73WvVdAJxCwgBWwZMmSk08+uU+fPmFsAQCgUm2wwQa//OUv/c5BoHMIWMCKmTlz5vHHH9+v + Xz/vdAcAqEzFYnHDDTf85S9/GQZEgI4nYAErbOrUqUcddVSPHj3CCAMAQCUZOnToZZddtnjx4jAdAnQ8 + AQtYGW+88caXvvSl2traMMUAAFAZ1lprrZ/+9KdhKAToLAIWsJJeeeWVsWPH1tXVhVkGAICsFQqFtdde + +4c//OF7770XJkKAziJgAStv1qxZ//Zv/xYmGgAAsta7d+/zzz9/0aJFYRYE6EQCFrBK3nrrrX333bem + pibMNQAA5Kh///7nnHOO914BXUXAAlbViy++uNdee3kfFgBArvr06XPGGWe88847Yf4D6HQCFhDBrFmz + dt1112KxGGYcAAByUV1dffLJJzc2NobJD6ArCFhABG1tbZMmTdpjjz08SwgAkJOePXt+7WtfmzdvXhj7 + ALqIgAXE0dLS8vjjj++yyy5VVVVh3gEAoJz17NnzK1/5yvTp08PAB9B1BCwgppdeemn77bf3LCEAQLnr + 3r37l770pSVLloQ5D6BLCVhATM3NzQ899NBOO+1UKpXC7AMAQLmpr68/4ogjXn/99fb29jDnAXQpAQuI + rLm5+Y9//OMOO+wQxh8AAMpKTU3N4Ycf/uqrr7a1tYUJD6CrCVhAh3j44Ye3224792EBAJSXbt26HXro + odOmTQtTHUAaBCygQzQ2Nt5+++3bbLNNGIUAAEhedXX1oYce+vLLL7v3CkiNgAV0lPb29rvvvnurrbYK + AxEAAGk7/PDDX3vtNe+9AhIkYAEdaMmSJddee+3mm2/uWUIAgJTV1NQccMABL730UhjjABIjYAEdq6Gh + 4dprrx0xYkQYjgAASM8XvvCFKVOmhAEOID0CFtDhmpubf/3rXw8fPrxYLIYRCQCANFRVVe2zzz7PPfdc + GN0AkiRgAZ1h7ty5F1988QYbbOBZQgCAdNTW1u6+++73339/c3NzmNsAkiRgAZ1k6dKlF1988dprr10o + FMLEBABA16mqqtphhx3uv//+lpaWMLEBpErAAjrP/Pnzzz333MGDB2tYAABdq6amZrvttrv11lsbGxvD + rAaQMAEL6FSzZ8/+3ve+N2jQoDA6AQDQ6aqrq7fZZpvrr79+8eLFYUoDSJuABXSB008/vVevXmGAAgCg + E5VKpc0222zChAlhMgMoBwIW0AXmz59/2mmn9e7dO4xRAAB0imKxuOmmm1599dVLly4NkxlAORCwgK6x + cOHCM888s7a2NgxTAAB0sEKhsP76648fP169AsqOgAV0mZaWltNOO61bt25hpAIAoMMUCoUhQ4ZcffXV + YRQDKCsCFtCVli5devbZZ5dKpTBYAQDQMVZfffXrr78+DGEA5UbAArrYokWL/uM//iMMVgAAdID6+vrf + //737e3tYQIDKDcCFtD15syZc9JJJ9XV1YUJCwCAeAYMGHDVVVe1traG2QugDAlYQBLeeeedk08+ubq6 + OsxZAADE0KdPnxtvvLG5uTlMXQDlScACUvHWW28dc8wxGhYAQCzdu3e/4YYbGhsbw7wFULYELCAVra2t + zz777NixY+vr68PMBQDAyhowYMC4ceMWLFgQhi2AciZgAQlpbW195plnDjrooO7du4fJCwCAFde/f/+L + Lrpo/vz5YcwCKHMCFpCW5ubmRx55ZL/99uvRo0eYvwAAWBEDBgz4zne+884774QBC6D8CVhAcpYtW3bf + fffts88+GhYAwIoaOHDgqaee+sYbb7S3t4fpCqD8CVhAitra2h544IE99tijrq4uzGIAAHyU1VZb7Rvf + +Mbrr7+uXgGZEbCARLW0tNx111277LJLt27dwkQGAMCH69+//7HHHjt58uQwTgFkRMAC0tXU1HTXXXd9 + 6lOfqqmpCXMZAAAfpF+/fkcfffSLL77Y2toaZimAjAhYQOruuOOObbbZprq6OkxnAAD8oz59+hx22GHP + PfdcmJ8AsiNgAWXg7rvv3mKLLUqlUpjRAAD4Hz179jz44IPVKyBvAhZQHh599NGNNtqoWCyGSQ0AgI99 + rEePHgceeKD3XgHZE7CAsvHb3/522LBhYVgDAKh43bt333vvvZ944okwLQHkS8ACyslDDz00ePDgMLIB + AFSw2traz3zmM5MmTQpzEkDWBCygzDz22GO9e/cOgxsAQEUqlUqf+tSnPDkIVA4BCyg/N910k/uwAICK + VSgUtt9++8cffzzMRgAVQMACyk9ra+uNN944ZMiQMMQBAFSST3ziE2+88UYYjAAqg4AFlKXGxsaf//zn + a621VpjjAAAqwyabbDJ16tQwEgFUDAELKFcLFy788Y9/vM4664RpDgAgd9tss83EiRPDMARQSQQsoIzN + mzfvRz/6kWcJAYBKsOWWWz755JPt7e1hEgKoJAIWUN7mzJlz3nnnrbnmmmGyAwDI0ahRo+6+++6WlpYw + AwFUGAELKHuzZ88+77zz1l577TDfAQDk5ROf+MSdd97Z1NQUph+AyiNgATmYPn36mWee6T4sACAzhUJh + 8803v+mmmxoaGsLcA1CRBCwgE2+++eapp546aNCg9+e8MPEBAJSzYrE4cuTIX/3qV4sWLQoTD0ClErCA + fEybNu2kk04aMGBAGPoAAMpWoVAYOXLk1VdfvWDBgjDrAFQwAQvIyksvvXTUUUf179/ffVgAQPkqFovD + hw+/+OKL33333TDlAFQ2AQvIzdSpU48++ui+ffuGARAAoKyUSqUNN9zwkksumTNnTphvACqegAVk6I03 + 3jjssMPq6+vDGAgAUCYKhcI666zzwx/+UL0C+HsCFpCnl1566cADD+zRo0cYBgEAklcoFIYMGXL22WfP + mDEjzDQA/I2ABWTr7bffPvjgg+vq6sJICACQsEKhMHjw4HPOOWfevHlhmgHgfwhYQM7mzp275557VlVV + hcEQACBV/fv3P+OMMxoaGsIcA8DfEbCAzL3++uv77LOPhgUApKx///5nnnnme++9FyYYAP6RgAXk7803 + 39x9993DeAgAkJhevXqdcsop7r0C+BcELKAivPrqq6NHjw5DIgBAMurq6k444YQwsgDwIQQsoFK8+OKL + u+66axgVAQASUFNTc+KJJ4ZhBYAPJ2ABFeSRRx755Cc/GQZGAICu9qUvfam9vT1MKgB8OAELqCCtra33 + 33//9ttv753uAEDXqq2tHTt27DvvvBPGFAD+JQELqCzNzc1/+MMftttuu2KxGOZHAIDOVV1dfeihh06b + Ni0MKAB8FAELqDhLly698cYbt9pqq1KpFKZIAIDOUl1d/YUvfOHll18OowkAy0HAAipRQ0PDTTfdtNVW + W70/QYZZEgCg4/Xo0eMLX/jCX/7yl7a2tjCXALAcBCygQjU0NNxwww0jR470LCEA0Dlqa2v33XffZ599 + trW1NUwkACwfAQuoXAsXLvzlL3+5ySabaFgAQEfr1q3b5z73uT/96U/Nzc1hFgFguQlYQEVbvHjxr371 + Kw0LAOhQdXV1e+2116OPPqpeAawcAQvgr9dcc83aa68dBkwAgKhKpdInP/nJiRMnhskDgBUnYAH8tb29 + /dprr91ggw3CmAkAEEl1dfVuu+325z//OYwdAKwUAQvgvzQ2Nl522WVDhw4NwyYAwCqrrq7+1Kc+de+9 + 97a0tISZA4CVImAB/K+LLrpozTXXLBQKYeoEAFhZpVJp6623vuuuu8KcAcAqELAA/ldLS8u4cePWXHPN + MHgCAKyUUqm03Xbb3XvvvWHIAGDVCFgA/6ClpeXss8/u169fGD8BAFbcpptuesstt7S1tYUJA4BVI2AB + /F/z5s077bTTBg4c6FlCAGBFlUqlzTff/Oabbw6DBQAxCFgAH2DmzJmnnHKK+7AAgBVSLBY33njjCRMm + eGs7QFwCFsAHmzFjxvHHH19XVxcGUgCAf6lQKAwdOvTqq68OwwQA8QhYAB9q2rRpxx13XK9evcJYCgDw + IYrF4gYbbHD55ZcvWbIkTBIAxCNgAfwrc+bMOeyww2pqasJwCgDwTwqFwhprrHHppZcuXbo0zBAARCVg + AXyE2bNnjx071rOEAMCHWX311ceNG7ds2bIwPQAQm4AF8NHeeOONQw45pEePHmFKBQD4HwMHDrzgggsW + LFgQ5gYAOoCABbBc5syZs/fee1dXV4dZFQDgYx/r0aPHt7/97ba2tjAxANAxBCyA5TVr1qwDDjigW7du + YWIFACpb//79zzrrrPb29jArANBhBCyA5dXW1jZp0qT99tuvtrY2zK0AQKVabbXVvvWtb82bNy8MCgB0 + JAELYMW8/PLLn/3sZ6uqqsL0CgBUnj59+nzjG99YuHBhmA8A6GACFsAKe+GFF/bbb7+ampowwwIAlaRf + v34nn3zy3Llzw2QAQMcTsABWWFtb25///Oc999wzjLEAQMXo0aPHV7/61bfeesurrwA6k4AFsJIef/zx + PfbYw31YAFA56uvrv/rVr7799tthGgCgswhYACuppaXlgQce2HXXXaurq8NUCwDkq76+/oQTTnjrrbfC + KABAJxKwAFbJAw88MHr06EKhEGZbACBH7+/1X/nKV9QrgK4iYAGskmXLlt1222077LCDZwkBIFc9e/Y8 + +uijp06dGrZ/ADqdgAWwqpYtW3bTTTeNGjWqVCqFORcAyEVNTc2BBx74yiuveGs7QBcSsADiuPnmm0eO + HKlhAUBOamtrv/jFL7788sthvwegiwhYAHEsXbp0/Pjxm222mYYFAHno0aPHv/3bv02cONG9VwBdTsAC + iKalpeWnP/3puuuuWywWw+QLAJSnmpqaXXfd9U9/+lNbW1vY6QHoOgIWQGSXX375uuuu6/cSAkD5qq2t + 3W233R588MGwuwPQ1QQsgMgWL1580UUXDR48OIzAAEBZqamp2XHHHX//+983NjaG3R2AriZgAXSICy64 + oH///mEQBgDKRFVV1dZbb3377beHHR2ANAhYAB1l3LhxAwcODOMwAJC8Uqm0zTbb3HbbbWEvByAZAhZA + R1m6dOmFF17Ys2fPMBQDAGnbaKONbr311ubm5rCXA5AMAQugAzU1NY0bN65Xr15hLgYAklQsFjfccMNb + b701bOEAJEbAAuhYDQ0Nl1xyiYYFAClbf/3177zzzrB5A5AeAQugwzU0NFxxxRVhQAYAEtO/f/9HH320 + vb097NwApEfAAugM77333gUXXNCnT58wKQMAaRgyZMjtt9/e0tIS9mwAkiRgAXSSefPmnXvuuT169Ajz + MgDQ1QYNGnTHHXd4aztA+gQsgM4ze/bs008/va6uLkzNAEDX6dOnz1NPPRU2aQDSJmABdJ62trbJkycf + d9xxffv2DbMzANAVhgwZcs011zQ0NIRNGoC0CVgAnaqtre2FF1444ogj/F5CAOgqa6yxxi9/+Uv1CqCM + CFgAXeD5558/9NBDe/fuHeZoAKBTFAqFtdde+6KLLpo3b17YlQEoBwIWQBdobm5+7LHHDjjgAPdhAUBn + Wnvttc8+++zp06e3t7eHXRmAciBgAXSZJ554YsyYMX4vIQB0jjXWWOPMM8+cPn162IkBKB8CFkBXevTR + R/fdd18NCwA6VKFQWGuttU499dTXX3897MEAlBUBC6ArtbS0PProo7vvvnttbW0YsQGA2AYMGPCNb3zj + tddea2trC3swAGVFwALoen/605923HHHmpqaMGUDAJEUCoUBAwZ89atffe2118K+C0AZErAAkvDkk09u + u+22pVIpjNsAQAx9+vQ58sgj1SuAcidgAaRi4cKFw4cPLxQKYeIGAFZN9+7dv/zlLzc0NIS9FoCyJWAB + JOT555/feOONw9ANAKyC+vr6gw8++M033wy7LADlTMACSMtzzz03bNiwMHoDACulpqZmzJgxb7zxRthf + AShzAhZAcpqbmwcOHBgGcABgBZVKpT333DNsqwBkQcACSE57e/sDDzwwYsSIMIYDAMutUCh89rOfnTp1 + athWAciCgAWQotbW1vvuu2/48OFhGAcAls8uu+wye/bssKECkAsBCyBRjY2NN99880YbbeT3EgLA8igW + izvttFNLS0vYSgHIiIAFkK5FixZdffXVG220URjMAYAPt9tuu73wwgvt7e1hHwUgIwIWQNIWLFjw85// + 3LOEAPCv7bbbbq+88kpbW1vYQQHIi4AFkLp58+ZdeumlG2ywgWcJAeCflUqlnXfe+cEHH2xubg57JwDZ + EbAAysDcuXMvueSSddddN4zqAMD/2HHHHR966KGmpqawawKQIwELoDy8++67P/zhD4cOHeo+LAD4b6VS + aYcddrjzzjuXLVsW9ksAMiVgAZSNmTNnnn322UOGDCkWi2FyB4BKVVVVNXr06Jtuumnx4sVhpwQgXwIW + QDlZsmTJBRdcMHDgwDC8A0Cl+vjHP37HHXd47xVAhRCwAMrMjBkzvvWtbw0aNMizhABUpqqqqi222GL8 + +PELFy4MuyMAuROwAMrP9OnTv/nNb/bv3z8M8gBQMUql0siRI6+44or58+eHfRGACiBgAZSrb37zmz17 + 9gzjPABUgEKhMGzYsPHjx4e9EICKIWABlKvp06cfe+yxGhYAFaJUKm244YaXXHLJe++9F/ZCACqGgAVQ + xubMmXPUUUd17949jPYAkKlCoTBkyJCLL7540aJFYRcEoJIIWABlb+zYsbW1tWHAB4DsFAqFwYMHX3LJ + JWHnA6DyCFgAZe+tt9465JBDisViGPMBIC8DBgwYN26ce68AKpmABZCDd99995BDDgljPgBkpE+fPpdc + cklzc3PY8wCoSAIWQCYmT548ZsyYUqkU5n0AKH89e/Y855xzwlYHQAUTsADy8frrr3/hC18IIz8AlLlS + qXThhRc2NTWFfQ6ACiZgAeSjvb39lVde2X///b0PC4ByVyqVfvCDH4QdDoCKJ2ABZKW1tfXRRx/97Gc/ + 6/cSAlC+evTo8c1vfnPOnDlhewOg4glYALlpbW199tlnd999d+/DAqAc1dbWnnjiifPnzw8bGwAIWABZ + amxsvPfee3feeefq6upwGgCAclBfX3/00Ue/8cYb7e3tYVcDAAELIFdLly79/e9/v+OOO9bU1IQzAQCk + rVevXl/+8pdffPHFtra2sJ8BwN8IWADZen/6f+ihh0aPHl1VVRVOBgCQqh49eowdO/att95y7xUA/0zA + AsjZkiVLbr755m222UbDAiBl9fX1Bx544NNPP93S0hL2MAD4OwIWQOYaGhp+85vfbL311sViMZwSACAl + PXr0+Pd///eJEyeqVwB8GAELoCLceuutm222WaFQCGcFAEhDXV3dmDFjnnvuubBjAcAHEbAAKkJLS8tv + f/vbkSNHhuMCACSgtrZ2zJgxEydO9NZ2AP41AQugUvx3w9pkk03CoQEAulSpVNprr72eeuop9QqAjyRg + AVSW8ePHb7DBBp4lBKBrVVVV7bLLLg8//HDYnwDgXxKwACrONddcM3To0HCAAIBOVyqVPvOZz0yaNCns + TADwUQQsgIrT1tb2s5/9bPXVVw/HCADoXNtuu+2f//znsC0BwHIQsAAq0fz5888///w111zTs4QAdKaq + qqptt932vvvuCxsSACwfAQugQi1atOj8888fMGBAOFIAQAcrlUpbbrnl3XffHbYiAFhuAhZA5ZozZ86Z + Z57Zp0+fcLAAgA5TLBY33njjW265JWxCALAiBCyAijZz5sxTTz21f//+4XgBAB2gWCxuuummv/71rxsa + GsIOBAArQsACqHRLly496aST3IcFQMcZNmzYNddc09LSEvYeAFhBAhYAf509e/bxxx/fq1evcM4AgHiG + DBnys5/9bNmyZWHXAYAVJ2AB8Nf29vbp06d//etf7927dzhtAEAM66677hVXXOHJQQBWkYAFQDBnzpwj + jjiiR48e4cwBAKtm0KBB48aNC9sMAKwCAQuA/zV79uwTTjihrq4unDwAYGWtueaal19+ufdeARCFgAXA + P5g+ffpxxx3XrVu3cP4AgBW35pprXnrppd57BUAsAhYA/9eUKVMOOeQQDQuAlVAoFAYOHHjOOecsXLgw + 7CsAsMoELAA+wLRp04499tja2tpwHAGA5TNw4MCLL75YvQIgLgELgA/2yiuvHHjggaVSKZxIAOCj9O3b + 99xzz507d27YSwAgEgELgA/17LPPfv7zn/dOdwCWR//+/U8//fSZM2eGXQQA4hGwAPhXJk6cOGbMGA0L + gH+tf//+559//rx588L+AQBRCVgAfIRHHnlkt912q6mpCWcUAPhHPXr0OPHEE917BUDHEbAA+AhNTU13 + 33337rvv7j4sAP5Z//79TzzxxGnTpoVtAwA6gIAFwEdrbm6+4447dthhB/dhAfD3evfuffTRR0+dOjVs + GADQMQQsAJbX7bffvvXWW1dVVYVTCwCVrb6+/tBDD508eXLYJwCgwwhYACyv5ubm3/72txoWAO/r1avX + 4Ycf/sILL4RNAgA6koAFwApob2+fMGHCpptuWiwWwwkGgMpTV1e3//77P/PMM2F7AIAOJmABsMJuvvnm + ESNGhEMMABWmrq5u3333ffrpp8OuAAAdT8ACYGVMmDBh/fXXD0cZACpGTU3NXnvt9fjjj4f9AAA6hYAF + wEq68sor11577UKhEM40AOSuurp6p512euCBB8JOAACdRcACYOVNmDBhnXXWCccaALJWKpV23HHHJ554 + IuwBANCJBCwAVl5LS8uvfvWrQYMGhcMNAPnaaqutHnnkkbABAEDnErAAWCXLli372c9+tsYaa4TzDQDZ + KRaLW265pScHAehCAhYAq2rZsmUTJkxYa621wkEHgIwUCoUtt9zyz3/+c1j0AaArCFgARLBkyZIrr7yy + vr4+HHcAyMWwYcOefPLJtra2sOIDQFcQsACIY/78+Zdeeqn7sABysvnmmz/wwAMtLS1hrQeALiJgARDN + nDlzzj///NVXXz2cewAoZ8OHD3/44YfVKwBSIGABENPs2bO/973v9evXL5x+AChPQ4cOffLJJ8PiDgBd + TcACILLp06efeeaZfi8hQPkaOXLknXfe2dTUFFZ2AOhqAhYAkbW3t7/22msnnHBC//79w0kIgPIxbNiw + CRMmLFu2LCzrAJAAAQuADjFlypTjjjtutdVWKxQK4UgEQNqKxeKGG2545ZVXLly4MKzmAJAGAQuAjvLi + iy9+5Stf8T4sgLJQKBQ23HDDSy+9dM6cOWEdB4BkCFgAdKBnnnnm3//933v16hWORwAkqVAoDB069Nxz + z501a1ZYwQEgJQIWAB1r0qRJBx98cO/evT1LCJCmUqm03nrrnXPOOTNnzgxrNwAkRsACoMM999xzY8aM + 6datWzgqAZCMQqGw5pprfvvb354+fXpYtQEgPQIWAJ3h2Wef/exnP1tbWxsOTAAkoFAorLHGGqeeeupb + b70V1msASJKABUAnefnll/fYY4+qqqpwbAKgSxUKhYEDB5500kkzZswIKzUApErAAqDzNDY2br755uHk + BECX6t69+9FHH93W1hbWaABImIAFQKeaOXPmNttsEw5PAHSRXr16HX300QsWLAirMwCkTcACoLNNnz59 + 6623DkcoADpdbW3tEUccMWfOnLAuA0DyBCwAusCSJUs23njjcJACoBOVSqUvfvGLYTkGgDIhYAHQBdrb + 259//vnRo0eH4xQAnaJUKh1++OHeewVA2RGwAOgara2tf/rTn7bccstwqAKg4+2///4NDQ1hIQaA8iFg + AdBlGhsb77zzzq233rqqqiocrQDoGDU1Nfvvv//SpUvDEgwAZUXAAqArLVmy5MYbb9x6662LxWI4YwEQ + W6lUOuCAA15//fX29vaw/gJAWRGwAOhiixYtuvbaa0eOHBmOWQBEVSgU9t5779dee029AqB8CVgAdL0F + CxZcffXVW2yxhWcJAeKqq6vbb7/9nnzyyZaWlrDmAkAZErAASML8+fOvuOKKESNGFAqFcOoCYNWUSqU9 + 99zzT3/6U3Nzc1htAaA8CVgApGL+/PmXXXbZ8OHDvQ8LYNVVV1fvscceDz74YFNTU1hnAaBsCVgAJGTu + 3Lk/+tGPNthgg1KpFE5gAKy42traXXfd9Q9/+INfOwhAHgQsANLS1NQ0bty4NdZYIxzCAFhBxWJxm222 + ueuuu1pbW8PaCgBlTsACIEWXXHLJkCFDPEsIsKJqamq23377e+65J6ynAJAFAQuAFM2fP/973/veoEGD + vNMdYPnV1NRss802EyZMaGhoCOspAGRBwAIgXWeccUbfvn3DsQyAf6lUKm266abXX399WEMBICMCFgDp + amxsPPPMM/v16xcOZwB8iKqqqs022+y6665rb28PaygAZETAAiBpixcv/uY3v1lXVxeOaAD8k2KxuMEG + G/ziF79YtmxZWD0BIC8CFgBl4Gtf+1qPHj3CQQ2Av1MsFtdff/2rrroqrJgAkCMBC4AyMHfu3K9+9avV + 1dXhuAbA3xQKhbXWWuvqq69ubm4OKyYA5EjAAqA8LFmy5Oijjw4nNgD+plevXldffbX3XgGQPQELgLLx + 1ltvHXnkkZ4lBPhvAwYMuOyyy8ISCQBZE7AAKCfTpk077LDDqqqqwukNoFLV1NT85Cc/Wbp0aVgfASBr + AhYAZWbmzJmHHHLI+ye3cIYDqDzdu3d37xUAFUXAAqDMtLa2/uUvfznwwAM9SwhUptVWW+28885btGhR + WBYBoAIIWACUn7a2thdeeGGfffbxewmBSlNfX/+9731v4cKFYUEEgMogYAFQltrb2/+7YXXr1i2c6gBy + 16dPn9NOO829VwBUIAELgHLV1NT04IMPfuYzn6mrqwtnO4B89e/f/+tf//rUqVPb2trCOggAFUPAAqC8 + PfbYYzvttJNnCYG89erV65hjjpkxY0ZY+wCgwghYAJS31tbWBx54YNddd62trQ3nPIC89OvX76ijjnr9 + 9dfDwgcAlUfAAqDsNTU13Xnnndtvv32pVAqnPYBc9OzZ84gjjpg0aVJra2tY9QCg8ghYAGTi3nvv3W67 + 7TQsICc9e/Y8/PDDX3755bDSAUClErAAyER7e/vdd9+9zTbbFIvFcPIDKGc9evQ45JBDXnjhhbDMAUAF + E7AAyEdbW9v9998/atSocPgDKFtVVVUHHHDAK6+80t7eHtY4AKhgAhYAubnttts222wzzxIC5au2tna/ + /fZ7/vnnw7oGABVPwAIgNy0tLbfddtuwYcMKhUI4CwKUj6qqqr333vvVV18NixoAIGABkKvf/e53a621 + VjgOApSJYrG45557zp49O6xlAMDfCFgA5Gnx4sVXXnnlOuus4z4soFzU1NTstttuzz77bFjIAID/IWAB + kK2lS5dedtllq6++ejgaAiSsqqpqu+22mzhxYljCAIC/I2ABkLmLLrpo4MCB4YAIkKRSqbT11ls/+OCD + YeUCAP6RgAVA5ubNm/eDH/xg0KBB4ZgIkJhCobDlllvedtttjY2NYeUCAP6RgAVA/pqamr7//e+vttpq + 4bAIkJJNNtnk97//fVtbW1izAIB/ImABUBEWLVr0ne98x7OEQFIKhcKmm256ww03hKUKAPgQAhYAFaG9 + vX3WrFnf/e53+/XrFw6OAF1to402mjBhwrJly8JSBQB8CAELgAoyb968008/vW/fvuHsCNBFCoXC8OHD + r732Wk8OAsDyELAAqCxz5sz5zne+06tXr3CIBOgK66233rXXXtvc3BzWJgDgXxKwAKg48+bNO/vss6uq + qsI5EqBzrbnmmrfeemtTU1NYlQCAjyJgAVCJZs6cecopp/To0SOcJgE6RaFQWHfdda+++uolS5aE9QgA + WA4CFgAVasaMGd/85jfr6urCsRKg46211lpXXnnlokWLwkoEACwfAQuAyjVv3rwTTjjBs4RA51httdVu + uummlpaWsAYBAMtNwAKgok2ePPlLX/pSfX19OF8CdIy11lrrwgsvnDt3blh9AIAVIWABUOlefPHFQw45 + RMMCOs7AgQMvuuiihQsXhnUHAFhBAhYA/PWZZ57Zf//9u3fvHs6aAPEMGDDg3HPPnT9/flhxAIAVJ2AB + wF+bm5sffvjhffbZR8MC4ho4cOC3v/3tmTNnhuUGAFgpAhYA/JfW1taHH374s5/9bLdu3cK5E2DVDBgw + 4Fvf+taMGTPCQgMArCwBCwD+1/3337/LLrvU1NSE0yfAyurXr99xxx03derUsL4AAKtAwAKA/9XS0nL/ + /ffvsMMOpVIpnEEBVlyfPn2OPfbYV199NSwuAMCqEbAA4P+69957t9pqq2KxGE6iACuiZ8+eRxxxxCuv + vBLWFABglQlYAPAB7rzzzlGjRhUKhXAeBVg+3bt3P/jggydNmhRWEwAgBgELAD7Y++fPESNGhCMpwHKo + rq4+6KCD3n333bCOAACRCFgA8KHuuuuuESNGuA8LWB41NTX77rvv888/H1YQACAeAQsAPlRbW9sdd9yx + 4YYbhuMpwIeoqqraY4891CsA6CACFgD8K21tbY8//vg666wTDqkA/6RYLO64446eHASAjiNgAcBHWLZs + 2Q033DBs2LBwVAX4O6VSaZdddvnzn/8clgwAoAMIWADw0ZYtW3brrbdqWMD/USgUdt5550mTJrW3t4f1 + AgDoAAIWACyXpUuXXnfddWuvvXY4tgIVr1AobLfddq+88op6BQAdTcACgOW1YMGCK664Yv311w+HV6Cy + 7bzzzo899lhLS0tYIwCADiNgAcAKeO+9937yk5+st9564fwKVKoddthh4sSJra2tYXUAADqSgAUAK2b2 + 7Nnnn3++ZwmhYhUKha222uqxxx5ra2sL6wIA0MEELABYYXPmzPmP//iPIUOGhOMsUEm22267e++9t6mp + KawIAEDHE7AAYGXMnDnz+9///uDBg8OJFqgMo0ePvvvuu5ubm8NaAAB0CgELAFbSG2+8cfLJJ6+xxhqF + QiEcbYF8lUqlzTff/Ne//vWiRYvCKgAAdBYBCwBW3owZM0455ZQBAwaEAy6QqWKxuNlmm1133XVLly4N + n38AoBMJWACwSqZMmXLsscf269fPfViQq2KxOGLEiJ/85Cfz5s0Ln3wAoHMJWACwqiZPnnzkkUf27dtX + w4L8VFVVjRgx4qKLLnr33XfDZx4A6HQCFgBEMHPmzEMPPbS+vj4ceYEsFIvF9dZb70c/+pH3XgFA1xKw + ACCOyZMnH3DAAXV1deHgC5S5YrG49tprn3XWWTNnzgyfcwCgiwhYABDNtGnTDjjggFKpFI6/QNkqFAqD + Bw8+++yz58yZEz7hAEDXEbAAIKbGxsbdd9/dy7CgrL3/Ee7Xr9/pp58ePtgAQFcTsAAgstmzZ3/+858P + 52CgDPXq1evb3/72woULw6caAOhqAhYAxDdnzpz99tsvHIWBslJVVXXGGWc0NDSEzzMAkAABCwA6xPz5 + 83fbbTfPEkJ5qaqqOuGEE8LHGABIhoAFAB2ivb399ddf33vvvcOxGCgHF1xwQfgMAwApEbAAoKO0trY+ + /fTTe+yxRzgZA2k78cQTm5qawgcYAEiJgAUAHej9w/ADDzyw8847V1dXhyMykJ66urqjjz568eLF4aML + ACRGwAKAjtXY2HjfffftsssuVVVV4awMpKRbt27HHnvszJkz29vbw+cWAEiMgAUAHW7JkiW/+c1vRo8e + XSwWw4kZSENNTc2hhx762muvqVcAkDIBCwA6w8KFC6+//vrtttvu/dNyODcDXa1nz56HHHLIs88+29LS + Ej6rAECSBCwA6CRLliy5/vrrt9pqK88SQgq6d+9+wAEH/OUvf2ltbQ2fUgAgVQIWAHSehQsXXnXVVZtt + tlmpVApnaKAr1NXV7bvvvo8++qhfOwgAZUHAAoBOtXDhwl/84hejRo1yHxZ0lfr6+jFjxjz44IONjY3h + kwkApE3AAoDO1t7e/rOf/Wy99dbzTnfofLW1tbvssssf//hHb20HgDIiYAFA1/jFL36x3nrrFQqFcKoG + Ol5tbe3uu+/+8MMPh88hAFAmBCwA6BrNzc0/+9nPhg4dqmFB56itrd11113vu+8+b20HgLIjYAFAV7rg + ggsGDBigYUFHq66u3nrrrW+77bbw2QMAyoqABQBd7PLLLx8wYEA4ZAMdoLq6evTo0XfffXf41AEA5UbA + AoAu1traet5559XW1oajNhBVqVQaOXLkrbfe2tbWFj51AEC5EbAAIAnf+c53evbsGQ7cQCTFYnHEiBE3 + 33xz+KQBAOVJwAKAJDQ0NHznO9/p1atXOHYDq6xQKGywwQZ33nln+JgBAGVLwAKAVDQ0NJxyyinV1dXh + 8A2smr59+/7mN78JHzAAoJwJWACQkFmzZp144onvn7rD+RtYWUOGDLnuuuvCRwsAKHMCFgCkZcaMGccf + f7xnCWFVDBw48Fe/+lVzc3P4XAEAZU7AAoC0tLe3z5w588gjj6yrqwtncWBF9OvX7xe/+EX4RAEAWRCw + ACA5bW1tkydP/spXvtKnT59wIgeWzzrrrPPjH/+4oaEhfJwAgCwIWACQovb29ilTphxyyCE9evQI53Lg + owwYMODCCy9cvHhx+CABALkQsAAgXZMnTz744IM1LFgegwYN+uEPf7ho0aLw+QEAMiJgAUC62trann32 + 2YMOOqhnz57hjA58kMGDB5999tnvvvtu+PAAAHkRsAAgdU8++eTnPve5bt26hZM68I8GDBhw8sknz5w5 + M3xmAIDsCFgAUAaeeuqp/fffv3v37uG8DvxNoVAYNGjQt771renTp4dPCwCQIwELAMpAW1vbo48+usce + e9TU1ISDO/Cxj/Xv3/9rX/vaa6+91t7eHj4tAECOBCwAKBuPPPLILrvsUl1dHc7uUNn69u177LHHvvrq + q+ETAgDkS8ACgHLyxBNP7LrrrhoW9OnT57jjjnvttdfCZwMAyJqABQBl5pFHHhk1alShUAjneKg83bp1 + O+yww958883wqQAAcidgAUD5ue+++7bbbjv3YVGZevbsecQRR7z++uvh8wAAVAABCwDKT0tLy5133jly + 5MhisRjO9FAZ6urqDj744FmzZoUPAwBQGQQsAChXd95559ChQz1LSOWoqqrae++9Fy1aFD4DAEDFELAA + oIzdeuutm266aTjcQ9a6dev2xS9+cdq0aeHqBwAqiYAFAGWsubn517/+9ZAhQ8IRHzJVVVW1yy67vPTS + S+HSBwAqjIAFAGVv/Pjx66yzjmcJyVVVVdVOO+307LPPhiseAKg8AhYAlL3GxsbLL7982LBh4bgPedlp + p50efvjh9vb2cMUDAJVHwAKAHDQ3N//oRz9ac801w4kfcvHxj3/8gQceCBc6AFCpBCwAyERDQ8PFF1/s + WUKyUVVVNXr06HvvvTdc4gBABROwACAT7e3t8+bNu/DCC9dYY40QAKCcbbnllr///e9bW1vDJQ4AVDAB + CwCy8t57711wwQUDBw50Hxblq1Qqbb755rfddpt6BQD8NwELAHLz3nvvjRs3btCgQSEGQFn573r1+9// + vrm5OVzTAEDFE7AAIEMLFy688MILe/ToEZIAlI/11lvvzjvvVK8AgL8nYAFAnt57773zzjuvX79+oQpA + 8orF4ogRI2655ZZly5aF6xgA4G8ELADI1ty5c88888zevXuHPABpGzZs2PXXX7906dJwBQMA/A8BCwAy + d/bZZ9fV1YVCAKlac801b7vttnDVAgD8IwELADI3Y8aMr3/963369AmdANIzbNiw6667rrGxMVy1AAD/ + SMACgPy9/vrr/9//9//16tUr1AJIyeDBgy+//HJPDgIA/4KABQAVYfLkyYcddljv3r0LhULIBtDV3r8a + hwwZcuWVV4bLFADgQwhYAFAR2trann766QMPPLC+vj7EA+hqgwcPvuCCC957771wmQIAfAgBCwAqRXt7 + +zPPPLP//vt369Yt9APoOoMGDTrrrLPmzZsXLlAAgA8nYAFAZXn88cf32Wef7t27h4oAna5QKKy55ppn + nHHG9OnTw3UJAPAvCVgAUFlaW1uffPLJ3XffvVQqhZwAnatv374nnXTSW2+9FS5KAICPImABQCV6+umn + P/WpT2lYdLJCodC3b98TTjjh7bffDtciAMByELAAoEI99dRT2223XVVVVUgL0PH69Olz9NFHv/766+Eq + BABYPgIWAFSud955Z+ONNw5pATpYqVQaO3bsggULwvUHALDcBCwAqGhTp07daqutPEtIR6urqzvssMMW + LlwYrjwAgBUhYAFARWtra3vsscc233zzkBmgA9TW1n7hC1+YNm1auOwAAFaQgAUA/PW1117bYIMNQmyA + qIrF4mc+85n29vZwtQEArDgBCwD4a0tLy0MPPbTFFluE5ACR1NbW7r///m+99Va41AAAVoqABQD8l6am + prvuumvTTTcN4QFWWaFQ2GeffSZPnuz2KwBgFQlYAEDQ0tJy9913b7LJJsViMRQIWFlVVVV77bXX9OnT + w+UFALAKBCwA4H8tXrz4uuuuGzlyZKFQCB0CVtz718+YMWOef/751tbWcG0BAKwCAQsA+AeLFi0aP378 + xhtvHFIErLjPfvazzz//fFtbW7iqAABWjYAFAPxf8+bNu+yyyzbaaCPPErKiqqur99hjj4kTJ6pXAEBE + AhYA8AHmz59/6aWXrrfeeiFLwPLZdddd//jHPzY1NYUrCQAgBgELAPhgCxYsuOiii9ZZZx3vw2J5FIvF + nXba6aGHHvLeKwAgOgELAPhQM2fOPOecc9ZZZx3PEvKvVVdX77DDDrfeemtDQ0O4egAA4hGwAIB/ZeHC + hWedddbAgQPdh8WHKRaLW2655S233NLY2BiuGwCAqAQsAOAjzJs37/TTT9ew+EBVVVUf//jHJ0yYsGzZ + snDFAADEJmABAB/t7bff/vrXv96/f38Ni79XVVU1atSoK664Yv78+eFaAQDoAAIWALBcmpubjzvuuB49 + eoR0QcUrlUrDhw+/8sorvbUdAOhoAhYAsLzefffdY445RsPifaVSaYMNNvjP//zPRYsWhesDAKDDCFgA + wAqYPXv20Ucf7UHCCvf+BTBkyJCLL754wYIF4coAAOhIAhYAsMKOOOKIUqkUYgYVplAoDBw48MILLwxX + AwBAxxOwAIAV9t57733lK18JPYMK069fv3HjxjU0NISrAQCg4wlYAMDKmDt37lFHHRWSBpXkpz/9aWNj + Y7gOAAA6hYAFAKykefPmjR07trq6OoQNcte9e/eLL744/PgBADqRgAUArKS2trYpU6aMHTs25A1y9+tf + //r9H3r48QMAdCIBCwBYJW+//fbhhx8eCgf5uuaaa5qbm8NPHQCgcwlYAMAqaWpqevTRR8eMGdOtW7eQ + OshLr169zjrrrMWLF4cfOQBApxOwAIBV1dzc/Oijj+611141NTWheZCLHj16fPvb33733Xfb29vDzxsA + oNMJWABABI2Njffdd9+nP/1pDSsnPXv2/PrXvz59+nT1CgDoWgIWABDHkiVLbr311l122cWzhHno27fv + Mccc88ILL7S0tISfMQBAFxGwAIBoWlpa7rjjjk9+8pPuwyp3vXv3PvLII19++WW/dhAASIGABQDEtHTp + 0htvvHHbbbfVsMpX7969DznkkIkTJ7r3CgBIhIAFAES2ZMmSG264Yeutt66qqgpFhPLRq1evgw466Ikn + nmhqago/UQCAriZgAQAd4oYbbhg5cmSpVApdhHJQX1//+c9//qmnngo/RQCANAhYAEBHufnmmzfeeONi + sRjqCGnr3r37mDFj/vznP4efHwBAMgQsAKCjtLa23n777UOGDAmBhITV1tZ+7nOfe+aZZ9rb28PPDwAg + GQIWANCxrr322sGDBxcKhVBKSE9tbe2uu+766KOPhp8ZAEBiBCwAoMP97ne/W2211UIsITHV1dWf+tSn + PDkIAKRMwAIAOsNvfvOb2trakExIRqlU2nrrrV988cXwcwIASJKABQB0kh//+Mf9+vUL4YQEFIvFLbbY + 4v777w8/IQCAVAlYAEAnaWpquvTSSz1LmIhCobDJJptMmjQp/HgAABImYAEAnaepqen888/v27dviCh0 + nXXWWeeRRx4JPxgAgLQJWABAp5o1a9b3vve9gQMHho5CV9hwww3vuOOO8CMBAEiegAUAdKr29vZ33333 + 29/+9uqrrx5qCp1r+PDhv/vd79ra2sKPBAAgeQIWANDZ2tvbZ8yYcdJJJ/Xv3z80FTrLsGHDrr32WvUK + ACgvAhYA0AXa2tpef/31k046yTvdO9OIESN++ctfNjQ0hB8DAECZELAAgC7z5ptvfvWrX/VO986x/vrr + X3HFFeoVAFCOBCwAoCtNnTr1mGOO6d27d6gsdIx111330ksvXbhwYfi+AwCUFQELAOhib7zxxvHHH9+r + V6/QWohtvfXW++lPf6peAQDlS8ACALreiy++eOihh/bs2TMUFyIpFApDhw49//zz33333fC9BgAoQwIW + AJCEl1566dBDD62vrw/phVVWKBTWXnvt8847b/bs2eG7DABQngQsACAVkydP/vd///du3bqFAMOqGTRo + 0LnnnuveKwAgAwIWAJCQp59+eu+999awVlGhUBg0aNCpp5765ptvhu8sAEA5E7AAgLRMmTJlv/3207BW + xYABA84444x33nknfE8BAMqcgAUAJOcvf/nLpz71qaqqqtBjWBF9+vT5xje+4b1XAEBOBCwAIEWPPfbY + zjvvXF1dHaoMy6dv375f+9rX3n777fB9BADIgoAFAKSora3t4Ycf3mGHHUqlUmgzfJRevXodf/zx8+fP + D99EAIBcCFgAQLruv//+UaNGFQqFUGj4cN27dx87duysWbPC9w4AICMCFgCQtHvvvXfrrbcOkYYPUVdX + 9+Uvf3n69OnhuwYAkBcBCwBIWltb2x/+8IdRo0aFVMM/qa6uPuigg958883wLQMAyI6ABQCUgd/+9reb + brqpZwn/WVVV1d577/3yyy+H7xQAQI4ELACgDLS1td18882bbrppyDb8TaFQ2HfffV944YXwbQIAyJSA + BQCUh8bGxquuumrDDTd0H9Z/KxaLu++++5NPPhm+QQAA+RKwAICysXTp0vHjx48YMaJYLIaKU6lqamp2 + 3333J554InxrAACyJmABAOVk8eLFV1111frrr1/J92FVVVXtvPPOf/rTn9rb28P3BQAgawIWAFBm5s+f + /5Of/GTdddetzIZVVVW1/fbb33PPPS0tLeE7AgCQOwELACg/CxYsuOKKK9Zdd90QdSpGdXX1DjvscP/9 + 9zc3N4fvBQBABRCwAICy1NDQ8NOf/nTAgAEh7VSAQqGwxRZbPPLII62treG7AABQGQQsAKBcLViw4OKL + L15rrbVC4MlaoVDYeuut//CHPzQ2Noa/PwBAxRCwAIAytnjx4h/96EdrrrlmyDz52nLLLe+4446mpqbw + NwcAqCQCFgBQ3lpaWs4999y+ffuG0pOjESNG3HHHHeEvDABQeQQsAKDszZ8//6yzzho4cGDoPXnZYost + 7rrrrvBXBQCoSAIWAJCD6dOnf/Ob3+zXr1+oPrkYPnz49ddf763tAECFE7AAgEy88cYbxx57bL9+/QqF + Qsg/5axYLA4fPvyaa64Jfz0AgAomYAEA+Xj11VePOeaYPn36hAhUtorF4oYbbnjFFVc0NDSEvxsAQAUT + sACArLz44osHH3xwXV1dSEHlafDgwePGjZs/f374WwEAVDYBCwDIzaRJkw488MCePXuGGlRWisXiuuuu + e95557377rvh7wMAUPEELAAgQy+++OLnP//56urqkIXKRKFQWGONNc466yz1CgDg7wlYAECeXnzxxc98 + 5jNVVVUhDiWvUCj079//tNNOe+edd8LfAQCAvxGwAIBsvfLKK3vvvXdtbW1IRGlbffXVTz311FmzZoWv + HgCA/yFgAQA5e++997bffvtisRgqUarq6uqOOeaYxsbG8HUDAPB3BCwAIHOzZs3addddU25YPXr0OO64 + 48KXCwDAPxGwAIDMtbW1vfDCC7vvvnuhUAjFKCX19fXHH3/8ggULwpcLAMA/EbAAgIowZcqUbbbZJrWG + 1a1bt0MOOaSpqSl8lQAAfBABCwCoFC+99NLOO++cTsPq3r370UcfvWjRovD1AQDwIQQsAKBStLa2PvLI + I6NHjw4BqUtVV1cffvjhb7/9dnt7e/j6AAD4EAIWAFBZHnnkkU984hNVVVWhJHWF2traww47bMaMGeFr + AgDgXxKwAIDKsmzZsttuu23bbbctlUqhJ3Wu/65Xb775ZviCAAD4KAIWAFBxGhoaJkyYMGrUqJCUOte/ + /du/vfzyy+FLAQBgOQhYAEAlWrhw4fjx47faaqvq6uoQljpe9+7dv/jFL06aNCl8EQAALB8BCwCoUIsX + L/7FL36xySabdM6zhDU1Nfvss8/jjz/e0tISvgIAAJaPgAUAVK7Fixdfdtllw4YNKxaLoTN1jKqqqk9/ + +tOPP/54+IMBAFgRAhYAUNHee++9Sy65ZPjw4R13H1ZdXd2ee+55zz33NDY2hj8VAIAVIWABAJVu6dKl + 55133pprrlkoFEJziqeqqmrbbbe94447mpubw58HAMAKErAAAP7Lf/zHfwwePDhuw6qurt5uu+3uvPPO + 8GcAALBSBCwAgP+ycOHCs88+e9CgQbEaVk1NzejRo2+88cZly5aFPwMAgJUiYAEA/K9TTjmlvr4+JKhV + UCqVNtlkk1//+tfhvwsAwCoQsAAA/sHpp5/eq1evEKJWSqlU2myzzdQrAIBYBCwAgH+wePHi008/vaam + JuSoFVQoFIYNG3bVVVd5chAAIBYBCwDgA5xyyindunULUWpFDB48+Kqrrgr/FQAAYhCwAAA+QFNT0+mn + n76iDWuNNda45pprwn8CAIBIBCwAgA82f/78E088MaSp5VBbWzthwoTW1tbw7wMAEImABQDwoebNm/f1 + r3+9Z8+eoVF9uAEDBkyYMCH8awAARCVgAQB8qLa2ttdee+2oo46qra0NpeqD9OzZ85ZbbnHvFQBABxGw + AAA+wltvvXXkkUdWVVWFXvWPamtrb7zxxubm5vBPAwAQm4AFAPARWltbJ02adPjhh//zs4SDBg26/PLL + lyxZEv5RAAA6gIAFAPDRWlpannrqqS984Qt1dXWhXX3sY/369fvhD384d+7c9vb28M8BANABBCwAgOX1 + 9NNP77ffft27d//Yxz7Wv3//s84669133w3/HwAAHUbAAgBYXo2Njffdd99ee+217rrrnnLKKVOnTm37 + /9u3YxqAgRgIgvxZmIuBGIn1aULgi0RXzLTHYKXbfTcAAD4jYAEAXNjd7q6qmfEcBAD4h4AFAAAAQDQB + CwAAAIBoAhYAAAAA0QQsAAAAAKIJWAAAAABEE7AAAAAAiCZgAQAAABBNwAIAAAAgmoAFAAAAQDQBCwAA + AIBg5zzPFkwilVPODAAAAABJRU5ErkJggg== + + + \ No newline at end of file diff --git a/ProjectContainerShip/ProjectContainerShip/Program.cs b/ProjectContainerShip/ProjectContainerShip/Program.cs new file mode 100644 index 0000000..062e107 --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/Program.cs @@ -0,0 +1,17 @@ +namespace ProjectContainerShip +{ + internal static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + // To customize application configuration such as set high DPI settings or default font, + // see https://aka.ms/applicationconfiguration. + ApplicationConfiguration.Initialize(); + Application.Run(new FormCont()); + } + } +} \ No newline at end of file diff --git a/ProjectContainerShip/ProjectContainerShip/ProjectContainerShip.csproj b/ProjectContainerShip/ProjectContainerShip/ProjectContainerShip.csproj new file mode 100644 index 0000000..244387d --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/ProjectContainerShip.csproj @@ -0,0 +1,26 @@ + + + + WinExe + net7.0-windows + enable + true + enable + + + + + True + True + Resources.resx + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + \ No newline at end of file diff --git a/ProjectContainerShip/ProjectContainerShip/Properties/Resources.Designer.cs b/ProjectContainerShip/ProjectContainerShip/Properties/Resources.Designer.cs new file mode 100644 index 0000000..306feae --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Этот код создан программой. +// Исполняемая версия:4.0.30319.42000 +// +// Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае +// повторной генерации кода. +// +//------------------------------------------------------------------------------ + +namespace ProjectContainerShip.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("ProjectContainerShip.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/ProjectContainerShip/ProjectContainerShip/Properties/Resources.resx b/ProjectContainerShip/ProjectContainerShip/Properties/Resources.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/ProjectContainerShip/ProjectContainerShip/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 -- 2.25.1