diff --git a/README.md b/README.md index 8372d88..eeef429 100644 --- a/README.md +++ b/README.md @@ -53,6 +53,18 @@ A best screenshot small tool (support high dpi screenshots) - 支持快捷键隐藏、显示所有截图(3.x 新增) - ###### 配置方法:选项 -> 截图设置 + +- 支持显示全屏十字光标 + + - ###### 配置方法:选项 -> 杂项设置 -> 全屏十字光标样式 + +- 支持在截图中保留鼠标的显示 + + - ###### 配置方法:选项 -> 杂项设置 -> 其他 -> 在截图中保留鼠标 + +- 支持显示放大镜以更准确的截取图片 + + - ###### 配置方法:选项 -> 杂项设置 -> 其他 -> 显示放大镜 --- diff --git a/SETUNA/Main/CaptureForm.Designer.cs b/SETUNA/Main/CaptureForm.Designer.cs index 181830b..a547ba6 100644 --- a/SETUNA/Main/CaptureForm.Designer.cs +++ b/SETUNA/Main/CaptureForm.Designer.cs @@ -16,33 +16,27 @@ protected override void Dispose(bool disposing) // Token: 0x060002B8 RID: 696 RVA: 0x0000F360 File Offset: 0x0000D560 private void InitializeComponent() { - this.components = new System.ComponentModel.Container(); - this.timer1 = new System.Windows.Forms.Timer(this.components); this.SuspendLayout(); // - // timer1 - // - this.timer1.Interval = 250; - this.timer1.Tick += new System.EventHandler(this.timer1_Tick); - // // CaptureForm // - this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F); + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 15F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; - this.ClientSize = new System.Drawing.Size(292, 266); + this.ClientSize = new System.Drawing.Size(389, 332); this.ControlBox = false; this.Cursor = System.Windows.Forms.Cursors.Cross; this.DoubleBuffered = true; this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None; this.KeyPreview = true; + this.Margin = new System.Windows.Forms.Padding(4); this.Name = "CaptureForm"; this.ShowIcon = false; this.ShowInTaskbar = false; this.Text = "CaptureForm"; this.TopMost = true; - this.Shown += new System.EventHandler(this.CaptureForm_Shown); - this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.CaptureForm_FormClosed); this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.CaptureForm_FormClosing); + this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.CaptureForm_FormClosed); + this.Shown += new System.EventHandler(this.CaptureForm_Shown); this.Paint += new System.Windows.Forms.PaintEventHandler(this.CaptureForm_Paint); this.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.CaptureForm_KeyPress); this.KeyUp += new System.Windows.Forms.KeyEventHandler(this.CaptureForm_KeyUp); @@ -55,8 +49,5 @@ private void InitializeComponent() // Token: 0x0400013E RID: 318 private global::System.ComponentModel.IContainer components; - - // Token: 0x0400013F RID: 319 - private global::System.Windows.Forms.Timer timer1; - } + } } diff --git a/SETUNA/Main/CaptureForm.cs b/SETUNA/Main/CaptureForm.cs index 9870aee..655a0e4 100644 --- a/SETUNA/Main/CaptureForm.cs +++ b/SETUNA/Main/CaptureForm.cs @@ -88,6 +88,9 @@ public Bitmap ClipBitmap // (get) Token: 0x0600029A RID: 666 RVA: 0x0000DE96 File Offset: 0x0000C096 public Size ClipSize => ptClipSize; + public Screen TargetScreen => targetScreen; + + // Token: 0x1700006F RID: 111 // (set) Token: 0x0600029B RID: 667 RVA: 0x0000DE9E File Offset: 0x0000C09E public CaptureForm.CaptureClosedDelegate OnCaptureClose @@ -142,9 +145,72 @@ public CaptureForm(SetunaOption.SetunaOptionData opt) CaptureForm.selLineVer1.Visible = false; CaptureForm.selLineVer2.Visible = false; CaptureForm.selArea.Visible = false; + + fullscreenHorLine = new CaptureSelLine(SelLineType.Horizon, opt.SelectLineSolid, opt.SelectLineColor); + InitChildForm(fullscreenHorLine, true); + fullscreenVerLine = new CaptureSelLine(SelLineType.Vertical, opt.SelectLineSolid, opt.SelectLineColor); + InitChildForm(fullscreenVerLine, true); + + magnifier = new Magnifier(this); + base.AddOwnedForm(magnifier); + magnifier.Show(); + magnifier.Visible = false; + base.Opacity = 0.99000000953674316; } + + void InitChildForm(Form form, bool adjustOpacity = false) + { + base.AddOwnedForm(form); + form.Cursor = Cursors.Cross; + + if (adjustOpacity) + form.Opacity = 0.0099999997764825821; + + form.MouseDown += (sender, e) => Form_MouseEvent(CaptureForm_MouseDown, sender, e); + form.MouseMove += (sender, e) => Form_MouseEvent(CaptureForm_MouseMove, sender, e); + form.MouseUp += (sender, e) => Form_MouseEvent(CaptureForm_MouseUp, sender, e); + + form.Show(this); + form.Visible = false; + } + + private void Form_MouseEvent(Action action, object sender, MouseEventArgs e) + { + if (sender is Form form) + { + if (form == fullscreenHorLine) + { + action(sender, new MouseEventArgs(e.Button, e.Clicks, e.X, e.Y + form.Top, e.Delta)); + } + else if (form == fullscreenVerLine) + { + action(sender, new MouseEventArgs(e.Button, e.Clicks, e.X + form.Left, e.Y, e.Delta)); + } + else if (form == selLineHor1) + { + action(sender, new MouseEventArgs(e.Button, e.Clicks, e.X, e.Y + form.Top, e.Delta)); + } + else if (form == selLineHor2) + { + action(sender, new MouseEventArgs(e.Button, e.Clicks, e.X, e.Y + form.Top, e.Delta)); + } + else if (form == selLineVer1) + { + action(sender, new MouseEventArgs(e.Button, e.Clicks, e.X + form.Left, e.Y, e.Delta)); + } + else if (form == selLineVer2) + { + action(sender, new MouseEventArgs(e.Button, e.Clicks, e.X + form.Left, e.Y, e.Delta)); + } + else if (form == selArea) + { + action(sender, new MouseEventArgs(e.Button, e.Clicks, e.X, e.Y, e.Delta)); + } + } + } + // Token: 0x0600029D RID: 669 RVA: 0x0000E104 File Offset: 0x0000C304 public void ShowCapture(SetunaOption.SetunaOptionData opt) { @@ -231,6 +297,11 @@ public void ShowCapture(SetunaOption.SetunaOptionData opt) DateTime.Now.Millisecond })); + CaptureForm.fullscreenHorLine.SetPen(opt.FullscreenCursorSolid, opt.FullscreenCursorLineColor); + CaptureForm.fullscreenHorLine.SetBounds(targetScreen.Bounds.X, targetScreen.Bounds.Y, targetScreen.Bounds.Width, targetScreen.Bounds.Height); + CaptureForm.fullscreenVerLine.SetPen(opt.FullscreenCursorSolid, opt.FullscreenCursorLineColor); + CaptureForm.fullscreenVerLine.SetBounds(targetScreen.Bounds.X, targetScreen.Bounds.Y, targetScreen.Bounds.Width, targetScreen.Bounds.Height); + Thread.Sleep(1); Cursor.Clip = targetScreen.Bounds; } @@ -321,9 +392,38 @@ private void ShowForm() base.Opacity = 0.0099999997764825821; base.Visible = true; base.Opacity = 0.0099999997764825821; + + if (Mainform.Instance.optSetuna.Setuna.FullscreenCursor) + { + fullscreenHorLine.Opacity = base.Opacity; + fullscreenHorLine.Visible = base.Visible; + fullscreenVerLine.Opacity = base.Opacity; + fullscreenVerLine.Visible = base.Visible; + fullscreenHorLine.Refresh(); + fullscreenVerLine.Refresh(); + } + + if (Mainform.Instance.optSetuna.Setuna.MagnifierEnabled) + { + magnifier.Opacity = base.Opacity; + magnifier.Visible = base.Visible; + magnifier.Refresh(); + } + Refresh(); Thread.Sleep(10); base.Opacity = 0.99000000953674316; + + if (Mainform.Instance.optSetuna.Setuna.FullscreenCursor) + { + fullscreenHorLine.Opacity = base.Opacity; + fullscreenVerLine.Opacity = base.Opacity; + } + + if (Mainform.Instance.optSetuna.Setuna.MagnifierEnabled) + { + magnifier.Opacity = base.Opacity; + } } // Token: 0x060002A2 RID: 674 RVA: 0x0000E832 File Offset: 0x0000CA32 @@ -361,6 +461,12 @@ private void LineRefresh() CaptureForm.selLineHor2.SetBounds(targetScreen.Bounds.X, targetScreen.Bounds.Y - 10, targetScreen.Bounds.Width, 1); CaptureForm.selLineVer1.SetBounds(targetScreen.Bounds.X - 10, targetScreen.Bounds.Y, 1, targetScreen.Bounds.Height); CaptureForm.selLineVer2.SetBounds(targetScreen.Bounds.X - 10, targetScreen.Bounds.Y, 1, CaptureForm.selLineVer2.Height = targetScreen.Bounds.Height); + + fullscreenHorLine.Hide(); + fullscreenVerLine.Hide(); + + magnifier.Hide(); + base.Hide(); Console.WriteLine("Hide end---"); } @@ -429,8 +535,8 @@ private void CaptureForm_FormClosing(object sender, FormClosingEventArgs e) // Token: 0x060002AB RID: 683 RVA: 0x0000EC00 File Offset: 0x0000CE00 private void CaptureForm_MouseDown(object sender, MouseEventArgs e) { - ptStart.X = targetScreen.Bounds.X + e.Location.X; - ptStart.Y = targetScreen.Bounds.Y + e.Location.Y; + ptStart.X = targetScreen.Bounds.X + e.X; + ptStart.Y = targetScreen.Bounds.Y + e.Y; DrawSelectArea(0, 0, 1, 1, BoundsSpecified.Size); blDrag = true; } @@ -501,12 +607,47 @@ private void CaptureForm_MouseUp(object sender, MouseEventArgs e) // Token: 0x060002AE RID: 686 RVA: 0x0000EEF4 File Offset: 0x0000D0F4 private void CaptureForm_MouseMove(object sender, MouseEventArgs e) { + if (Mainform.Instance.optSetuna.Setuna.FullscreenCursor) + { + var cursorPos = Cursor.Position; + var cursorRealPos = new Point(cursorPos.X - targetScreen.Bounds.X, cursorPos.Y - targetScreen.Bounds.Y); + fullscreenHorLine.SetSelSize(0, targetScreen.Bounds.Width); + if (fullscreenHorLine.Top != cursorPos.Y) + { + fullscreenHorLine.Top = cursorPos.Y; + } + fullscreenVerLine.SetSelSize(0, targetScreen.Bounds.Height); + if (fullscreenVerLine.Left != cursorPos.X) + { + fullscreenVerLine.Left = cursorPos.X; + } + } + if (blDrag) { DrawSelRect(); - return; } - DrawSelectArea(0, 0, 1, 1, BoundsSpecified.All); + else + { + DrawSelectArea(0, 0, 1, 1, BoundsSpecified.All); + } + + if (Mainform.Instance.optSetuna.Setuna.MagnifierEnabled) + { + var cursorPos = Cursor.Position; + var point = Point.Empty; + var point2 = Point.Empty; + + if (blDrag) + { + point.X = Math.Min(ptStart.X, ptEnd.X); + point.Y = Math.Min(ptStart.Y, ptEnd.Y); + point2.X = Math.Max(ptStart.X, ptEnd.X); + point2.Y = Math.Max(ptStart.Y, ptEnd.Y); + } + + magnifier.SetText(cursorPos.X, cursorPos.Y, point2.X - point.X, point2.Y - point.Y); + } } // Token: 0x060002AF RID: 687 RVA: 0x0000EF14 File Offset: 0x0000D114 @@ -594,16 +735,6 @@ private void CreateClip(Point pt, Size size) } } - // Token: 0x060002B4 RID: 692 RVA: 0x0000F248 File Offset: 0x0000D448 - private void timer1_Tick(object sender, EventArgs e) - { - CaptureSelLine.AddDashOffset(); - CaptureForm.selLineVer1.Refresh(); - CaptureForm.selLineVer2.Refresh(); - CaptureForm.selLineHor1.Refresh(); - CaptureForm.selLineHor2.Refresh(); - } - // Token: 0x060002B5 RID: 693 RVA: 0x0000F278 File Offset: 0x0000D478 private void CaptureForm_KeyPress(object sender, KeyPressEventArgs e) { @@ -634,6 +765,7 @@ private void CaptureForm_KeyUp(object sender, KeyEventArgs e) } } + // Token: 0x04000127 RID: 295 private const int GW_OWNER = 4; @@ -744,5 +876,12 @@ public struct RECT // Token: 0x02000070 RID: 112 // (Invoke) Token: 0x060003AE RID: 942 private delegate void LineRefreshDelegate(); + + + private static CaptureSelLine fullscreenHorLine; + private static CaptureSelLine fullscreenVerLine; + + private static Magnifier magnifier; + } } diff --git a/SETUNA/Main/CaptureForm.resx b/SETUNA/Main/CaptureForm.resx index 886d0de..1af7de1 100644 --- a/SETUNA/Main/CaptureForm.resx +++ b/SETUNA/Main/CaptureForm.resx @@ -112,12 +112,9 @@ 2.0 - System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - 17, 17 - \ No newline at end of file diff --git a/SETUNA/Main/Common/Utils.cs b/SETUNA/Main/Common/Utils.cs index a520bee..ae010d9 100644 --- a/SETUNA/Main/Common/Utils.cs +++ b/SETUNA/Main/Common/Utils.cs @@ -1,4 +1,7 @@ -namespace SETUNA.Main +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace SETUNA.Main { class URLUtils { @@ -6,4 +9,25 @@ class URLUtils public const string NewURL = "https://www.github.com/tylearymf/setuna2/"; } + + + static class BitmapUtils + { + public static Bitmap ScaleToSize(this Bitmap bitmap, int width, int height) + { + if (bitmap.Width == width && bitmap.Height == height) + { + return bitmap; + } + + var scaledBitmap = new Bitmap(width, height); + using (var g = Graphics.FromImage(scaledBitmap)) + { + g.InterpolationMode = InterpolationMode.NearestNeighbor; + g.DrawImage(bitmap, 0, 0, width, height); + } + + return scaledBitmap; + } + } } diff --git a/SETUNA/Main/Option/OptionForm.Designer.cs b/SETUNA/Main/Option/OptionForm.Designer.cs index 874bbc9..5610bef 100644 --- a/SETUNA/Main/Option/OptionForm.Designer.cs +++ b/SETUNA/Main/Option/OptionForm.Designer.cs @@ -111,8 +111,16 @@ private void InitializeComponent() this.groupBox8 = new System.Windows.Forms.GroupBox(); this.listScrapMenuStyles = new SETUNA.Main.SetunaListBox(); this.pageMisc = new System.Windows.Forms.TabPage(); - this.groupBox14 = new System.Windows.Forms.GroupBox(); + this.groupBox16 = new System.Windows.Forms.GroupBox(); + this.checkBox_fullscreenCursor = new System.Windows.Forms.CheckBox(); + this.radioButton2_fullscreenCursor = new System.Windows.Forms.RadioButton(); + this.radioButton1_fullscreenCursor = new System.Windows.Forms.RadioButton(); + this.label18 = new System.Windows.Forms.Label(); + this.pictureBox_fullscreenCursor = new System.Windows.Forms.PictureBox(); + this.label19 = new System.Windows.Forms.Label(); + this.groupBox15 = new System.Windows.Forms.GroupBox(); this.checkBox_cursor = new System.Windows.Forms.CheckBox(); + this.checkBox_magnifier = new System.Windows.Forms.CheckBox(); this.panel1 = new System.Windows.Forms.Panel(); this.lblMenuMisc = new System.Windows.Forms.Label(); this.lblMenuStyle = new System.Windows.Forms.Label(); @@ -154,7 +162,9 @@ private void InitializeComponent() this.groupBox9.SuspendLayout(); this.groupBox8.SuspendLayout(); this.pageMisc.SuspendLayout(); - this.groupBox14.SuspendLayout(); + this.groupBox16.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox_fullscreenCursor)).BeginInit(); + this.groupBox15.SuspendLayout(); this.panel1.SuspendLayout(); ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); this.SuspendLayout(); @@ -1308,7 +1318,8 @@ private void InitializeComponent() // pageMisc // this.pageMisc.BackColor = System.Drawing.Color.White; - this.pageMisc.Controls.Add(this.groupBox14); + this.pageMisc.Controls.Add(this.groupBox16); + this.pageMisc.Controls.Add(this.groupBox15); this.pageMisc.Location = new System.Drawing.Point(4, 28); this.pageMisc.Name = "pageMisc"; this.pageMisc.Padding = new System.Windows.Forms.Padding(3); @@ -1316,30 +1327,132 @@ private void InitializeComponent() this.pageMisc.TabIndex = 5; this.pageMisc.Text = "杂项设置"; // - // groupBox14 - // - this.groupBox14.Controls.Add(this.checkBox_cursor); - this.groupBox14.Location = new System.Drawing.Point(7, 7); - this.groupBox14.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3); - this.groupBox14.Name = "groupBox14"; - this.groupBox14.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3); - this.groupBox14.Size = new System.Drawing.Size(574, 92); - this.groupBox14.TabIndex = 12; - this.groupBox14.TabStop = false; - this.groupBox14.Text = "样式"; + // groupBox16 + // + this.groupBox16.Controls.Add(this.checkBox_fullscreenCursor); + this.groupBox16.Controls.Add(this.radioButton2_fullscreenCursor); + this.groupBox16.Controls.Add(this.radioButton1_fullscreenCursor); + this.groupBox16.Controls.Add(this.label18); + this.groupBox16.Controls.Add(this.pictureBox_fullscreenCursor); + this.groupBox16.Controls.Add(this.label19); + this.groupBox16.Location = new System.Drawing.Point(7, 7); + this.groupBox16.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3); + this.groupBox16.Name = "groupBox16"; + this.groupBox16.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3); + this.groupBox16.Size = new System.Drawing.Size(574, 92); + this.groupBox16.TabIndex = 13; + this.groupBox16.TabStop = false; + this.groupBox16.Text = "全屏十字光标样式"; + // + // checkBox_fullscreenCursor + // + this.checkBox_fullscreenCursor.AutoSize = true; + this.checkBox_fullscreenCursor.Location = new System.Drawing.Point(485, 12); + this.checkBox_fullscreenCursor.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3); + this.checkBox_fullscreenCursor.Name = "checkBox_fullscreenCursor"; + this.checkBox_fullscreenCursor.Size = new System.Drawing.Size(89, 19); + this.checkBox_fullscreenCursor.TabIndex = 7; + this.checkBox_fullscreenCursor.Text = "全屏光标"; + this.toolTip1.SetToolTip(this.checkBox_fullscreenCursor, "截图时的光标显示为全屏光标"); + this.checkBox_fullscreenCursor.UseVisualStyleBackColor = true; + // + // radioButton2_fullscreenCursor + // + this.radioButton2_fullscreenCursor.AutoSize = true; + this.radioButton2_fullscreenCursor.Location = new System.Drawing.Point(240, 60); + this.radioButton2_fullscreenCursor.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3); + this.radioButton2_fullscreenCursor.Name = "radioButton2_fullscreenCursor"; + this.radioButton2_fullscreenCursor.Size = new System.Drawing.Size(58, 19); + this.radioButton2_fullscreenCursor.TabIndex = 17; + this.radioButton2_fullscreenCursor.Text = "虚线"; + this.toolTip1.SetToolTip(this.radioButton2_fullscreenCursor, "设置框选范围的边框线的类型。"); + this.radioButton2_fullscreenCursor.UseVisualStyleBackColor = true; + // + // radioButton1_fullscreenCursor + // + this.radioButton1_fullscreenCursor.AutoSize = true; + this.radioButton1_fullscreenCursor.Checked = true; + this.radioButton1_fullscreenCursor.Location = new System.Drawing.Point(175, 61); + this.radioButton1_fullscreenCursor.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3); + this.radioButton1_fullscreenCursor.Name = "radioButton1_fullscreenCursor"; + this.radioButton1_fullscreenCursor.Size = new System.Drawing.Size(58, 19); + this.radioButton1_fullscreenCursor.TabIndex = 16; + this.radioButton1_fullscreenCursor.TabStop = true; + this.radioButton1_fullscreenCursor.Text = "实线"; + this.toolTip1.SetToolTip(this.radioButton1_fullscreenCursor, "设置框选范围的边框线的类型。"); + this.radioButton1_fullscreenCursor.UseVisualStyleBackColor = true; + // + // label18 + // + this.label18.AutoSize = true; + this.label18.Location = new System.Drawing.Point(39, 33); + this.label18.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.label18.Name = "label18"; + this.label18.Size = new System.Drawing.Size(112, 15); + this.label18.TabIndex = 14; + this.label18.Text = "框选线的颜色∶"; + // + // pictureBox_fullscreenCursor + // + this.pictureBox_fullscreenCursor.BackColor = System.Drawing.Color.Blue; + this.pictureBox_fullscreenCursor.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.pictureBox_fullscreenCursor.Cursor = System.Windows.Forms.Cursors.Hand; + this.pictureBox_fullscreenCursor.Location = new System.Drawing.Point(175, 30); + this.pictureBox_fullscreenCursor.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3); + this.pictureBox_fullscreenCursor.Name = "pictureBox_fullscreenCursor"; + this.pictureBox_fullscreenCursor.Size = new System.Drawing.Size(41, 21); + this.pictureBox_fullscreenCursor.TabIndex = 18; + this.pictureBox_fullscreenCursor.TabStop = false; + this.toolTip1.SetToolTip(this.pictureBox_fullscreenCursor, "指定框选范围的边框线的颜色。"); + this.pictureBox_fullscreenCursor.Click += new System.EventHandler(this.pictureBox_Click); + // + // label19 + // + this.label19.AutoSize = true; + this.label19.Location = new System.Drawing.Point(39, 63); + this.label19.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.label19.Name = "label19"; + this.label19.Size = new System.Drawing.Size(112, 15); + this.label19.TabIndex = 15; + this.label19.Text = "框选线的种类∶"; + // + // groupBox15 + // + this.groupBox15.Controls.Add(this.checkBox_cursor); + this.groupBox15.Controls.Add(this.checkBox_magnifier); + this.groupBox15.Location = new System.Drawing.Point(7, 108); + this.groupBox15.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3); + this.groupBox15.Name = "groupBox15"; + this.groupBox15.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3); + this.groupBox15.Size = new System.Drawing.Size(574, 57); + this.groupBox15.TabIndex = 13; + this.groupBox15.TabStop = false; + this.groupBox15.Text = "其他"; // // checkBox_cursor // this.checkBox_cursor.AutoSize = true; - this.checkBox_cursor.Location = new System.Drawing.Point(38, 38); + this.checkBox_cursor.Location = new System.Drawing.Point(42, 24); this.checkBox_cursor.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3); this.checkBox_cursor.Name = "checkBox_cursor"; - this.checkBox_cursor.Size = new System.Drawing.Size(89, 19); + this.checkBox_cursor.Size = new System.Drawing.Size(149, 19); this.checkBox_cursor.TabIndex = 6; - this.checkBox_cursor.Text = "显示鼠标"; + this.checkBox_cursor.Text = "在截图中保留鼠标"; this.toolTip1.SetToolTip(this.checkBox_cursor, "截图时是否显示鼠标"); this.checkBox_cursor.UseVisualStyleBackColor = true; // + // checkBox_magnifier + // + this.checkBox_magnifier.AutoSize = true; + this.checkBox_magnifier.Location = new System.Drawing.Point(224, 24); + this.checkBox_magnifier.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3); + this.checkBox_magnifier.Name = "checkBox_magnifier"; + this.checkBox_magnifier.Size = new System.Drawing.Size(209, 19); + this.checkBox_magnifier.TabIndex = 6; + this.checkBox_magnifier.Text = "截图时显示放大镜以供参考"; + this.toolTip1.SetToolTip(this.checkBox_magnifier, "截图时显示放大镜以供参考"); + this.checkBox_magnifier.UseVisualStyleBackColor = true; + // // panel1 // this.panel1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(81)))), ((int)(((byte)(163)))), ((int)(((byte)(236))))); @@ -1525,8 +1638,11 @@ private void InitializeComponent() this.groupBox9.ResumeLayout(false); this.groupBox8.ResumeLayout(false); this.pageMisc.ResumeLayout(false); - this.groupBox14.ResumeLayout(false); - this.groupBox14.PerformLayout(); + this.groupBox16.ResumeLayout(false); + this.groupBox16.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox_fullscreenCursor)).EndInit(); + this.groupBox15.ResumeLayout(false); + this.groupBox15.PerformLayout(); this.panel1.ResumeLayout(false); this.panel1.PerformLayout(); ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); @@ -1824,6 +1940,14 @@ private void InitializeComponent() private System.Windows.Forms.TabPage pageMisc; private System.Windows.Forms.Label lblMenuMisc; private System.Windows.Forms.CheckBox checkBox_cursor; - private System.Windows.Forms.GroupBox groupBox14; + private System.Windows.Forms.GroupBox groupBox15; + private System.Windows.Forms.CheckBox checkBox_magnifier; + private System.Windows.Forms.GroupBox groupBox16; + private System.Windows.Forms.CheckBox checkBox_fullscreenCursor; + private System.Windows.Forms.RadioButton radioButton2_fullscreenCursor; + private System.Windows.Forms.RadioButton radioButton1_fullscreenCursor; + private System.Windows.Forms.Label label18; + private System.Windows.Forms.PictureBox pictureBox_fullscreenCursor; + private System.Windows.Forms.Label label19; } } diff --git a/SETUNA/Main/Option/OptionForm.cs b/SETUNA/Main/Option/OptionForm.cs index 71943e6..d6ad246 100644 --- a/SETUNA/Main/Option/OptionForm.cs +++ b/SETUNA/Main/Option/OptionForm.cs @@ -73,6 +73,12 @@ private void LoadSetunaOption() checkBox_topMost.Checked = _so.Setuna.TopMostEnabled; checkBox_autoStartup.Checked = Startup.AutoStartup.IsSetup(); checkBox_cursor.Checked = _so.Setuna.CursorEnabled; + checkBox_fullscreenCursor.Checked = _so.Setuna.FullscreenCursor; + checkBox_magnifier.Checked = _so.Setuna.MagnifierEnabled; + + radioButton1_fullscreenCursor.Checked = _so.Setuna.FullscreenCursorSolid; + radioButton2_fullscreenCursor.Checked = !_so.Setuna.FullscreenCursorSolid; + pictureBox_fullscreenCursor.BackColor = _so.Setuna.FullscreenCursorLineColor; } // Token: 0x060002D5 RID: 725 RVA: 0x00013908 File Offset: 0x00011B08 @@ -140,6 +146,13 @@ private void WriteSetunaOption() _so.Setuna.TopMostEnabled = checkBox_topMost.Checked; Startup.AutoStartup.Set(checkBox_autoStartup.Checked); _so.Setuna.CursorEnabled = checkBox_cursor.Checked; + _so.Setuna.FullscreenCursor = checkBox_fullscreenCursor.Checked; + _so.Setuna.MagnifierEnabled = checkBox_magnifier.Checked; + + _so.Setuna.FullscreenCursorSolid = radioButton1_fullscreenCursor.Checked; + _so.Setuna.FullscreenCursorColorR = pictureBox_fullscreenCursor.BackColor.R; + _so.Setuna.FullscreenCursorColorG = pictureBox_fullscreenCursor.BackColor.G; + _so.Setuna.FullscreenCursorColorB = pictureBox_fullscreenCursor.BackColor.B; } // Token: 0x060002D6 RID: 726 RVA: 0x00013D84 File Offset: 0x00011F84 diff --git a/SETUNA/Main/Option/OptionForm.resx b/SETUNA/Main/Option/OptionForm.resx index df8339b..d54ad1e 100644 --- a/SETUNA/Main/Option/OptionForm.resx +++ b/SETUNA/Main/Option/OptionForm.resx @@ -120,4 +120,7 @@ 17, 17 + + 17, 17 + \ No newline at end of file diff --git a/SETUNA/Main/Option/SetunaOption.cs b/SETUNA/Main/Option/SetunaOption.cs index 60c6466..bf88dc2 100644 --- a/SETUNA/Main/Option/SetunaOption.cs +++ b/SETUNA/Main/Option/SetunaOption.cs @@ -25,12 +25,12 @@ public static SetunaOption GetDefaultOption() setunaOption.Setuna.DustBoxCapacity = 5; setunaOption.Setuna.DustBoxEnable = true; setunaOption.Setuna.SelectAreaTransparent = 80; - setunaOption.Setuna.SelectBackColorR = 0; - setunaOption.Setuna.SelectBackColorG = 0; - setunaOption.Setuna.SelectBackColorB = 139; - setunaOption.Setuna.SelectLineColorR = 0; - setunaOption.Setuna.SelectLineColorG = 0; - setunaOption.Setuna.SelectLineColorB = 0; + setunaOption.Setuna.SelectBackColorR = Color.DarkBlue.R; + setunaOption.Setuna.SelectBackColorG = Color.DarkBlue.G; + setunaOption.Setuna.SelectBackColorB = Color.DarkBlue.B; + setunaOption.Setuna.SelectLineColorR = Color.Blue.R; + setunaOption.Setuna.SelectLineColorG = Color.Blue.G; + setunaOption.Setuna.SelectLineColorB = Color.Blue.B; setunaOption.Setuna.ShowSplashWindow = true; setunaOption.Setuna.SelectLineSolid = false; setunaOption.ScrapHotKeyDatas = new Keys[(int)HotKeyID.__Count__] { Keys.Control | Keys.D1, Keys.Control | Keys.D2 }; @@ -43,6 +43,12 @@ public static SetunaOption GetDefaultOption() setunaOption.Setuna.TopMostEnabled = false; setunaOption.Setuna.CursorEnabled = false; + setunaOption.Setuna.FullscreenCursor = false; + setunaOption.Setuna.MagnifierEnabled = false; + setunaOption.Setuna.FullscreenCursorSolid = true; + setunaOption.Setuna.FullscreenCursorColorR = Color.Orange.R; + setunaOption.Setuna.FullscreenCursorColorG = Color.Orange.G; + setunaOption.Setuna.FullscreenCursorColorB = Color.Orange.B; var cstyle = new CStyle @@ -1020,8 +1026,16 @@ public SetunaOptionData() ClickCapture1 = false; ClickCapture2 = false; ClickCapture3 = false; + TopMostEnabled = false; CursorEnabled = false; + FullscreenCursor = false; + MagnifierEnabled = false; + + FullscreenCursorSolid = true; + FullscreenCursorColorR = Color.Orange.R; + FullscreenCursorColorG = Color.Orange.G; + FullscreenCursorColorB = Color.Orange.B; } // Token: 0x17000072 RID: 114 @@ -1102,6 +1116,18 @@ public SetunaOptionData() public bool CursorEnabled; + public bool FullscreenCursor; + + public bool MagnifierEnabled; + + public Color FullscreenCursorLineColor => Color.FromArgb(FullscreenCursorColorR, FullscreenCursorColorG, FullscreenCursorColorB); + public bool FullscreenCursorSolid; + public byte FullscreenCursorColorR; + public byte FullscreenCursorColorG; + public byte FullscreenCursorColorB; + + + // Token: 0x02000052 RID: 82 public enum ApplicationType { diff --git a/SETUNA/Properties/Resources.Designer.cs b/SETUNA/Properties/Resources.Designer.cs index c376295..5041419 100644 --- a/SETUNA/Properties/Resources.Designer.cs +++ b/SETUNA/Properties/Resources.Designer.cs @@ -308,5 +308,15 @@ internal static System.Drawing.Bitmap PicasaLogo { return ((System.Drawing.Bitmap)(obj)); } } + + /// + /// 查找 System.Drawing.Bitmap 类型的本地化资源。 + /// + internal static System.Drawing.Bitmap white { + get { + object obj = ResourceManager.GetObject("white", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } } } diff --git a/SETUNA/Properties/Resources.resx b/SETUNA/Properties/Resources.resx index 28cfac4..8dfedb5 100644 --- a/SETUNA/Properties/Resources.resx +++ b/SETUNA/Properties/Resources.resx @@ -1,18 +1,96 @@  + + + + + + + + + + + + + + + + + + + - + + @@ -27,5 +105,1154 @@ -text/microsoft-resx1.3System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAbAEAAAKJUE5HDQoaCgAAAA1JSERSAAAAGgAAABYIBgAAAN6IjLUAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA6klEQVRIS2P4//8/Az0wXSwBeWRgLWJgYDAG4sNAfJ0MvAyoxwo9OrD6CKjQBYiB/gXjI0AcAMRcaOK3gPxEIAaBUCD+CFV/Bkj7kmoRyBKQpcgA5oB1QEF1JAlQKHwA4vtAnEWKRY+AGurQLAFxcVkEkusA4gukWJQGVLwYFAQkWgSLW6J9VA60oAmIDUi0CKR8FRAnkhJ0oLgRJsMikD51Yi3CYj5cCF8cIRShlTi4kveoRRghMBpH2BLF8Ep1oCIGuVRHL3Apzke7gSaA6iaYJTD6JVAMVF2AClNZ5HAmKtXRog1Bt6ocABg5oswQdE0cAAAAAElFTkSuQmCCCw==AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA3wMAAAKJUE5HDQoaCgAAAA1JSERSAAAAXAAAAB4IAwAAAJahiQ0AAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAFpQTFRF////+zIz4dDmtpDFl2Gt9/f55OXpwMPKepjJJlqnztHT8vT17O7v297fjJOVaHFzR1JUq7Kz1u7XNKEtZbdf5/Xl/P37/ffw/n8J/bSX/c+7/JFu/d/Y/v7+VT3rjgAAAyNJREFUSEutluuC4iAMhVmVRlvKxVW8tLz/a+45gVpn3H81M1pa4CM5CVRjqpWSy22en895LsZkfL5oxdwe0x+16XH7IpuondjGJh5h0L7gPCBZDod9flTPAb9NT1PyN8Qpxu4PsL19LvB8vz+/I3yp7Df6BPj9WfIXZDHQpNG7ucpC+H3ezi5mt7APBzFKr/Bpu+e5NFGwhKBIZhTNdCMcwmwtmbI6LtxK5jYtcLiOmtwiTn45vtN9SnqVhapvLPalVA47kmCgz1WW+0NvN1jX0tnYundKg08ayQarku/djx25wil5PQf4zWNBAzS84Yd/ta3PdNyaJoXv7YBpq5MNfscJ1vtqnSmdq4y2Vl2HC1RBtbG0a7iE74scCX8t+QZPMdBi6EvwL7eWIuW51Fx+f7QoCfg+y+n4I3eLLPAkRbHD4CSGQfoW+aJUexUsb4TP5HTwO50Uvmq1ak64TvJxFLYok1DAQbxPgyRrXEJr5MLsHJ0fl2Xszh5PDf4Scy1FhTPwFPsQSkkxhhi9NR0uECtE5/QSe2N97YzpFYOyT8cfMeXHRJsRDKDsciF0IeAO2o+YbkNMzgq4LuHOQDaLzjGPwK/wkezTMZ8/bGCKU/QJBlYOYQgBNWuG4CV6rgmm88gKxnks7igXhi6ellw9v17+/rYzKwE60ELKNvge85gbCwUgMkoFwB69PiEgdHIfIJIX3HQV/sG+8EXKoSNsoEsVroXu6SWaPnZm9NQ8CTvhDq/NMED+C79c1cmmeRWjr2KYseNjhoBUsEJdDzHQyXXfPGfNQphPz891x2gp6vaD4Egj0ztGj3+LFnNYpca41ollxjQ629WjA4X+AVfB1XPC2QLcQN8kyK6g7oMIaw/VEqTHF8VPPTpj6rz45LkbVKdfcGiS9ccLFFTPcfBAAhw1mIvsIgMAo6ahfdacB4QE39mJGQnxLHAE8F4tF2xBsPUsczK0cz733HmDiFAGiCMymq7HXLTwDA0n0mcrLo9Dr6Np1PSaLqzGyyWdEY/+5GrnlDaWw7COb3d61rRT4/38+PVu1Nvher06VWqppW3Xf8xwXW7TkfNpAAAAAElFTkSuQmCCCw==AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAgAEAAAKJUE5HDQoaCgAAAA1JSERSAAAACwAAAA8IBgAAADI9NTAAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA/klEQVQoU2P4//8/Awgblf3/jw3D5EE0HOBSjFCBxDKr/P8fG8aq2Lrm/39sGKtix4b//7FhrIo9Wv//x4ZRFAd0/f8ExP/xYf/O/zd9Ov47Muh4d/yM6P//Hxf2rX/yX0TR9iHQBkcGJha2Nsf0bf8Tpv7His2j5n9hYeO0gDmHWVDG8GB4y73/GbP+w3H6zL//7ZNW/OcSkJ0PVMiE7HZVVYuEl1kzvv4vmP8fjGPb7/6XVHfeAVQkhC1EImyjpv4uX/L/f+6MD/8N3MvfABUZYA06kCA7t9CM4LI9/61COn8AuXk4FUIluAUlNI4oGgbOJaQQJi8PZBhhUwwAfsD1AZxsC00AAAAASUVORK5CYIILAAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAANQIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAFpQTFRF/////v//+jQ1/dve59rrxqjQmGGt3cnl8ur10brc5+PyoZjHvcrhJVmmbY/E9Pj63fPi7/jvtt20M6AsXbRX2u7Y/f78/c2b/nsB//Lm/drD/ZZu/ff2/auq3X2RUgAAAXlJREFUOE9tk4uagiAUhCFTUzcpF48m9P6vuTNclLXOV2nOz5wLqFQKLaLx9Z5X/slCvor21du5y8W59+a1nHXle4GawlVaFRYa9/3QtK+DqLZFK5Hkg3xtg+gOj2pZF4VKcqKOetPU+p1yAFgXnSpN6wMhiSAAIhnc4nrGkDwCsG6BEFUfQKf1xiwRcB6Elv7QW4UpVTuQLA6DK3TMEER0WB0d/G5AHc1rVbkErC8Q11zfjWLYEO19dAiNhBmhfuphj/irCyAOafBUYt9sLgEOt6HGWnoD/08AjwjUahiNZIuTA1J0eriP7CDOtgRCka2MdwD7KSoAbvrtaqAD4BRjiMpdYDdE9dQJlLE5xuKxTP1QB/CYi3iEMDRTIcN9fNrfc9gn1iOCxTdgYgU8EcN3wBrWS4BJPh3sIw9GWMYHQD0OjRM2wxlggdx8TjaM0Pzrwk5h29kkPuEMKJltatTaCct5dDDVfXos18wTYn7StpDy+1++8If8B1uuKjpOzOI4AAAAAElFTkSuQmCCCw==AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAIAIAAAKJUE5HDQoaCgAAAA1JSERSAAAADgAAAA8IBgAAANQU/nQAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABnklEQVQ4T3WRz0tCQRDH59Ih6biHurxLCEIodIhAxUsXwYsYqIdOgngy7JD9gCTEICXKTOikUHSSIOkfSKhj2Mn/QAoPEWliT3xOs+vztc9sYWB3Zj4zO98BRARhtdoKVqv3dHcZvnEMYA4DgQPy28YxAfHTr9efNMYGmEjccFg49dO5vDz6jsW6GI3ecVi4RYVs9qIdDLaG/MkYYipVEdUBZrFYPO6Gw68iZqOGicQDxRgH97BQ4H1/jSfE49dqqXQ19Ps1Oaa5XBo2GvMcZAHGhqoM6tXf7famqSD5twEGp/ST8YxrNFT/DywV+6B7jmwZIE0Tzhji0MO5SPBkh/F7HeCLcoiFBUMcIVKlojw7HJtTQa8Xm8nki6z0SFVESzefz2lutzoVtFoRw2HETObWgAWYTu92IpE3IblkppktFkSPB7FcfiRG4d1stCsT0CL4kGyqYIqC2OttiK+GpC6fdN8CaNOXiAXnJLxPcXkdIZ8OnwGoSwA7khAGfE45qyNlTevwcZicJ2TMpKDemXzEgmJah55I7L/HKUd+AAvvaS/EPTWkAAAAAElFTkSuQmCCCw==AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAbQIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEW24/ur2ftpiJ+HxvlruPeNscad0/vB6vxHXWwdJSs6eaxWrviRzPk7TFn////s+PxWlst7wPl6osFjnMfT8PnQ3+s5f7gsO0egvtfR3+uVwN2jxdrJ7/zN4O2NzfzN7/t4Cj7wAAABf0lEQVQ4T4WTjW6DMAyEYxLyU0LbwFgYhfT933LnJECraeoJidj+ODuWENcPEp+ByXz9q9v1Kq7zYIQQ5lUcr8/nuhZgZKAqY3w262rEDgg6iWwlqHCmOrx9XlqtbHA6tH81t+1yOFB0b4ouJ+zh8Aq8sPZw0Pikr8LJlmNsqA55B9CUi5jGxXkz5H3ymrTIt3hkoNxkBfAwQieu78BcACLC9dlBkIZQT8VhvqcKUAYWAJ4BegMQs0fj3CA0JkCg/eHQu74AZJ3rF4zATfwJIM1DCDE47CiOpZ7OFiPvbWgHgBZNcOYGSe4tpEalquUujMDjdKClr/UG6Savux/PGbhjY2OMdkghSBkKYo8hsRgsiR6kg+qUCklnpN9bjPWK5FUHsUeS6uL6sA/Ji9VeylzvlIRCCOquqK4aKympDASPEBFifQCcgAML78wj1R0AQs6i3Cl8iKdoBxKXfRkxF3IrqM5w+f5HlyHPcNt+qrZpm6aJA35P07bhz/74d/8C5j8t+PTbkikAAAAASUVORK5CYIILAAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAXgIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEXP89Btr+Wo2Pu06rbK7PrDxcT///+34vpOVFGTzvywsrHb3dyfvtbk6eTm+Obw8PCFjob5+vrh6/Lw/fHx+v1udnC97b+SnZShr6P9/f1/vvH19vXA2sLMzM3F2ulRkMQncLtPAAABcElEQVQ4T3WSgXKDIAyGUyYx4gCdQ6XK9v5vuQTbWmj39eqJ+e5PzAk/Tc1X03zjA/i8Ni3TtNmTO6YUpH4iVi0o1apnR1WCYtqbwj34VAqXQ8hwfD4UM1xUd6vLiKrr2PhH4ASuvwr5kWp1qrGyDPi8iMCGtr7EejHuglLJ+/GZzaJlQwR5DaW0H88F893oEb2Np5AqIfoY0fqjhYxZJ6DvU+o1C1KWIasEjOO2+SxkurqFDBTHu9B1lyMhTpPLTFN8CF13vV5Z2BzAPH/cmGcAt0mClFlI9qjN/ONrvnzMWRA4AfjpCyz83tCWMytm0LB9HTTcAgKFfafdrYPbAw07sPBYb7IAZBZaKbglAC37Dq4UnKO+J01k1rCGiV8YXJHAwsC5rCzDMsSF9FQI3k0UdNSErBnCkVYshTFSj5gIPQUMwZBBXvU5JK9ayzegEbWOm1mMR95kIdwP/CVg/pcJW6wZnxN06t9gzhbmLf0fzMEpQZ4XfwcAAAAASUVORK5CYIILAAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAWgIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEVkptu0tLP+0bCn1/v////K7PpQS0e34vro6OiMyvv+27+bvdj95NHS0M3PtqXz8/P/9OmRj4vh6/Lx+v10b2qPgXj//PL97N6mqar6+/uxo5q2nIn+xp/jzLr/+/jF2ulW71bcAAABbElEQVQ4T22Si5aDIAxEsWBEiqLdsELr4///chP0uIIdFVEukzmA2OpSr7r+UafE89mw6iZx3CN9ARKVSKIKQMpGnuPckTkgGknIwVAN+rg5nAZkn+gsg5DtAXBE2bZEFECatCdM4yVA/zhBKFVpXgzx5BJEyKDv2gE2JRHgMumoyeMKuPi/wkpFTbfOgeu4Uo6hyBmSmqDpz1WOM3VHSEr5Deh0oN1M82V7A6iCUtVRom3FF4AKJqBlifByah0ma8yDZayd1piANM4O1jzmXA97OggC5jnNvWh+MHAoaDZm//0x3DeVcHrbNF0bAWb5fBaz9Iaf/kNvAs6lCdpYDx4MgpkQLCB4SxkugJ38OEDvobIABpYFSmDw+Ebr0feICy5vmIbMYfodAXEiyL+xA8BlyAEXx1FBhx3CSk0X1bpmDk4FwDGiC6gI2DheAShabt4iava2ALITtWNXB7cfOWri4aLiNUNVhequ8AeDvCLBtjCfmgAAAABJRU5ErkJgggs=AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAhwIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEW8vLzpbZrCwsLztMy1tbX0u9L1w9mAgIDsg6nW1tb///+srKzOzs7vmrzqeaJsbGzukrTwpcPyrsnyqsb21eeoSmzo6Ojwnbz09PTkX4/vocLwob7tjbDvlbfvncHumLg96vaQAAABmUlEQVQ4T4WT4XakIAyFUbRlcKAQtktHQN//LXsD6Lg907P3hyD5uAlBhf6PhL6N91/1V2uhp/fxp4QQ43jH6gFgoa4dOl8qIN7HBjyZBuP5r8MT6vETENN0epw+vHg4YD7dv14JLeBTMHD7rR0HcNd6fquaobc/GIkkJgzAYAIgG8BCXHrvwzw3YFk4RXfoPuu2riTlFWjmXetujCcKFVi6AwMdImO2LZBfD0BwiqckratHgnXrQC1yltBcnzLEiAqeDpPgUzR5sxLFnSvwmz8dkEISTi7JROR2zoQQouk19D4AIOlLorC7gjakUmJzuACUYkCWiASU9mKunaSA3soEA2Mi4iGlmCrAN4sauPczpYSNJaGCFGNsRfI3wH3Aful3pbLKiEVXjGkO/bK4A0ENjwFIKXvG4FqRuKxlhAOFaB+QVcUVp1juCiSXsR8aMoBsLRNXwCH5Y4Csi9FkpFDWHpe1oNXOFTVYKGdn9syqwPLBWrRO0VjLBmyNgcUpvm4s/CK7U1zBgwO1Fp4DOPX5SvICvP7wvwGr2iyrWUn9vAAAAABJRU5ErkJgggs=AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAMAIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEVireiHyPm9hxOshkX///+i1vu0eQH9BjHT09FeamKnoZPNxKrHlbWhZgLeHT6JfmSy4PvF5/DVSm+IayXCpGbo5uWwpcSrfS3XdJa+wKW4jTTHThe5tbqcYQHBxdCawNG4WlxBAAABQklEQVQ4T32TgZaCIBBFQRcxWREBSwjp//9yh0E7gp59FAHv8mbKE/kptPTLUp6Q0g/DEEqiBkI/xOJOBkSTZZ11g8lr36OVAd90XQdnNvbRet/g1mOtA7BOiB4UQoRZOGu7HJGBxg7TNJnHd8DOnwEPkSjJ38eySDiAN+dyPIibBPCB+AdIPv8WaU9NvsxnnnudAR5mkCt7MESpdfe5jACIrkpQ6ldLRLR+zkq5AvCQwJjCGjLZSomxTEBg5VJyGWDJqoSXIekQimitI6MMStQJjKYuVq1X8EFXAG6tMumZ/CuQrikY8HmfgKdoUnxfSiCQ+scAetfDDiB5DyjogNBdbqt+KMynhCAB0w2QjB0Awm2v4nETaByBvQK5JKCREnbVwKPWUDyLdksazQYjz7A9fws7ZgJfh87AYturBP6n/gD9NCKDDX7H8wAAAABJRU5ErkJgggs=AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAApwIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEUEb/4+jNWn1/potfrO7vq65PqautRMlNOJx/r///9Xpfie0/qv3fqTzPpClfbs+PwRcOIsf9d1rtx7v/hdm83I3O0jgfbi7fsxfMGPz/iNxO+SxOVgpOWtyeI9h8qhyP77FFykAAABuUlEQVQ4T12Ti5arIAxFA9RCeTgoSrWXaf//L+cQ8NY2ruUyyebkQUu3T/PrV4A+/Z+cfz4jdFuHy9ssUTm5gOl2nYfDLolgD3YZa8Ay+E64XIHsEUAW0H/Ae2bGmifS1UN+GBj4hUIz1fJEKHqpwUPBS8mAnTgdJwGFKnoCgCAmuYep5vjQAUjnXAXQRIyRJnzUELDeJDwTeBALIOphcPueToALKmue9VFsKWn1+76Po3OHgsP+BIpIz3MKCBqTKasO6DZ+Lla85mq5jNwtKe5h7sPHaYwezUtJuuWJ7P1Gr2M7FZAyBOcAxB7NK93FSUG63UlH4lCI24rLejYiZihAQAbSbaUUF5S4XfWMA9jvop7KWmXTWIqeUCTObVHahJGedZm+bjJuBmVcjtvsO4C+iuYLUxpW4DtnxSOcVo3hkJdQoChMCMEkvLvCUmevaZfabWKPJsHMCcCCXiZZBmJq+aSOHhxLpna+mkCyPrJfN4CaN7izNr5GB1XBHQA8Y4JR/Ue7cYGk3grIYoWItB6Ksoqtl3guzbQQ9V7iVj/Y/nGJdb6+bSHaTi4Dn2bj19/7G7j/fp34A7iHJISlP8EjAAAAAElFTkSuQmCCCw==AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAawIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEWk2Pxtr+Wtr7C54/uUz/z////C6PvBwsNSWFvo6Oifvtbd3t7x8fHo+v9RkMTe8//R7/uw3vydpqyHkpfy+/6xydf5+frh6/PE3eb8/f2BwPNsdHfO3OLNzs7w+P291uJWU8nGAAABfUlEQVQ4T22SiZaDIAxFMSgEhRFxaSld/v8vJ8GlxfYePbVyeQaCuCr/zdQciPamJKMycpDKK1UKchiywhKNk3UShpW3NJRCNQixOTRfykH8Eo7pUpBeJMyVqAXn06cJUfO/oshdyFXSeE0RpcBzCNCPE4Y3Q7TVLhhjC4xlIwu0DiHA2KXANLbbE7h0EuJ7h+nJ0mVyAs/PCSchxmhNFlj5kdA9Hp0mgcd5FeeEuCzWskB7S1cdzgIXtOQEor5VJNCbOD37jHtyRatQ3wgWnFd5xVtV0vdPFvI4C9yoDH1xe5JZYFg4ur53n0QS/jaCoZ7mltKdjxefDi2elxUPRql2nBFHlRCDnxOOUmlx7C4JPmDAK7YYruqF4TUrXwi+h9SmmMbUOjcm17u+FC4OEuCId8R0T2EacXZFwiVqFrqIYKaQokWIhbAABkhUFCbQFlNA3RSCBWiMJkGHoJsIAWyZwL1YoZOw/lIvPpZpFxooWAqBjsc38JGg4QfdP3bQJnFODUFsAAAAAElFTkSuQmCCCw==AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA8QEAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEWp1vfU6/j/2aj/+vL/wnT/tVb/7dX/vGb/58j/4Ln/8+KQyfbD2u7/9en/0ZW95fz//Pj/yIH/sk11u/f/+O7/qz7//v3/////8d////7+///9///+/v7+/v/6/P7/rUKjVo6/AAABA0lEQVQ4T82T2xaCIBBFucitEAcriUz7/78MRDLIVq/xBrNnOHMGkPux0B8CFCpRlUhvVAKArmAFAJMpYEkFDHypzcV5CcjHtQYaEY94vwDtJRdwryuoYQbcwbZRgBA+a33ToGzIjgFoUp1l7VlNzWHrtQSmcRxvpREZuFoS0nCHMS6JDJwJI95p1KFuH3AeghEaoWN3d9IoyVcrSw34eDqhm1NCMLZ6XgDDrLXGUeQA7UcFSoJH0zxP+11QIprVHbq59DKKNz1Tg3dUBqWqz4PanFRWQjDZcxaywbK3V1N2IUUMQbRkdxZe2fQaLtslZYU2BbyKQ/8+zaLPf/xZ5SDC7gkK/lVUrC5dWgAAAABJRU5ErkJgggs=AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAdQEAAAKJUE5HDQoaCgAAAA1JSERSAAAACwAAAA8IBgAAADI9NTAAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA80lEQVQoU2P4//8/AzLOmv1fPmPWfyN0cRAfBaTN/M+dN+fHwcSeJ1NRZbDw0qb/mla+5P//wnk/vwE15uHUkDj1f0TO7F+/Cub//w/CaVM/v4if8t8AQ0PkhP+qCZO+Pge69T8Mp8/8+z+q+92WqAn/heAakqb9Zw7v/rIvYer//9hwWPf3uVXL/jOBNQR1/22L6P//HxcObPvwKaDjlzlYsV/7zx8BXf//48O+rd8f+HT8dwSpfw/E/z1a/2PFIDkgvgjEFnC3Ozb8/48NYw0+65r//7FhrIrNKv//x4axKjYq+/8fG6ZcMdTXIJ+jY7jhAK8aFv7BGYvNAAAAAElFTkSuQmCCCw==AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAQgIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEXetYi7hA35BzKviEX///+lnpTS0tL6yKSscQfoUVHi2M+dYgH707v5sHjgKTv6vZP7zbDDvbXxhXfn5+famW3SiFmtgDChZA6sTg7hj067jS1+c26PhoLBpWiqSCXDNxw+/9/uAAABVElEQVQ4T22TAXKDIBREjRQQEQmJQrTa3P+W3Q+kFXTHZJBd3n4yk+ar0LN/PsudpvQd565M1AEnuCvOpIBcb1G72x0Pab0O0UqB5K/r7oTY2ZpeWez6BFxPEsI5J3qBZXNbxSHAHN+27z9tG+eeHQPddE8a7kN8ZEVAQMpPZhiwbm41AZsDRF/S2nvTHWfw3SStJJ8EH4SuIkgbASRrrLQnAqg0YwZQ4Ejw3ZwCGFXSBOfAhFq6Burx4HMm0Fk4ZF4FFnJjA13BnghhJv8xknDjGPCHn9qH+FM/FHxlrDHGNrq4BQJAgKBGNVHAVENqcI1R7di2Yw7UBOpVLelBAFNV6NlM04zzkFLzsiz1DFqHZKOj/dEh+KKCaeiVA+2b3rQ+XpN52nlnQvILwh7iVip5XQRiRS7JBVVFPoSSMS/LCp8qqORTcE3Qr3+/GLJnF0p/4l/F9SQTQ8+CNgAAAABJRU5ErkJgggs=AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAfQIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEX+/v7W1taioqLMzMz7yaScnJz5sHP6u4qHh4f6w5r81sGxsbH70ri7u7vExMS7qZmoqKj6zLSUk5NtbW3Ouq6fcUzZo3Xnyb780K3YnGj7qGKnnpv3mk3aqISroZ65trV8zYCeAAABj0lEQVQ4T42T4XKDIBCEIxwiUagYm1JN5f3fsnuHJmqmM90fCux3e8jI5fIPadX+pb7i+vbWq1V9kcxkdAYKJ4CAG6CU2TLWt2EA1JqgjHlDYIN6AUaYLYib8MoB2DXhdPgF0LrSrEpXLBnipYZhBdpe/CL4QXxtGDAKCQegUBxzAEJA3T4GM8MBAydkpQMIIAJxE57yHgvQKiy8AiodvD8DsrK2r+B7FEjAlvD0uUPOeQUGAcbx66Alc0DWOKgCfPxcO+gKxYjHwv2C3wNdFHUd/BhnbuAZQEBJSESFuEZyAmCbO+COVW6ALs5SnDkgZ22aLQEAb0J8G2nGoXif9dBA0uLuXJeYiAggt7CPFgI0BsC3owQRkXXRudn7FifxBpAlZx2YObd937YAOEMSUEuJ2Exg5iy/exjKJhhAeupQjwDnaMl8iVSQLTSyyZS6RNNUW2trJLDfq3ATNQKgeno8Jvh1beVHU0rj0vBffOHPROmEBIdBXZfoW3jeaXymRQKAGo/JjufbPn4elU/AL+3rI6OE3K+0AAAAAElFTkSuQmCCCw==AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAXwIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEX+sbf////2ztekmZzINzbRysvQkZH+vcT+e3dyT09+cXH0gH3/hoT/mZjIurv/Tkfe3N3/NSzto6W1Dw3/pKPpmpfx4eLw7+/67e3rhoa7d3b+YlvpkpH7+Pj/j47cp6swuGqPAAABcUlEQVQ4T42T23aDIBBFUSsSMngrGoVI/v8vOzADxvShPU+4zp4rIqo/JP4HHG39qb6lUM7QvrqouotcJzrx0uMFqJhIWCeE1CvXLj20syA3AlI/cm+iqns697NAJUBy/hEtUcmvC4FQrr92DQHySuT4da4ZsIWIs5T4WWTABMdD9wJ9Oq9Pa3MJE06iyf5urMlAgBAkxR28wHUP1gbBPQQAI5igkbcn+kZlAJSyVkjebfR3MFYYOAGwqEJsu0LAhAIoZSKw6IN3qlQw6KvcJAGLxpaSHu5ujMHCuYQCa958JBoE1BuAn88Sn3IgAXBOkfzUwNHRPa8NQICyqNNfvGPC3aFMYUv8fZi8o1lGd/aA/aewQ03TNAyF8HkKTT/YsaM/TV7JnMOmu3jdNN3Tc4j+4AEk7WN0CTh6il/UEOWVgsBEm4CK5puBAY8aHO+0PBz0wVMFP8QDExnY3Pen3EZJ6OFs+vZL17dJ9Jv45qvqB7bCHkEXogf0AAAAAElFTkSuQmCCCw==AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAlQIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEW44vt2i5NttvOJx/qb0vosLCyt2vtAQULlZjSi1PuTzfmy3ftZrfPA5/tTVVak2fpXkb+Kwuqo1vvKyspoaGj/spOn1Omu4PqCve57wPiQ0PhCLCT///9KY3VMTE1QUVEzHVEAAAABp0lEQVQ4T32TjZKjIBCEORhBwAgxXoiup+//ltcz+Fdbe9eVKg18dvdgopblNTrn1p8+42tZ1PJyzU/6atu2cS8AY9OsTeO+Y1/t77ZpRgDYHfuxh8Y7VIG1AujgerTY7gRHCODcn1//0g7kRyyq6lFVity9nROHjAUs3ZBShNuBNRdrS7xDsl/Ke2WHdc0qWdbFPJCAByrgtlwSZBERIclXitfem4y5Zut9SnEvKE1VopTKe5OILSfy3tcp9jkS0Qyg3yM8EQ0q7mOAiTOUUpAI12cKgZB+IEoR9pHxrA4nwBXZJlqaiay9gDmEoQ4ao424Upj9HQhmB7Abgrc+hJCGRHvEloOhgYVnfcBtMAZzUTg7GOMFgJglYwKRD+Z0QAIOgiGYA0LMMKDH55iCDQWwAxrw0GBxuTrUfQyBE+MAfOGi1zkgkRtGxE+QgQcmuxzQoJ5DmLpOA4CYOzvIgBauuoP0AUz6eFncEZ6T7HdaDLTWByDvQjwrMKGeVNHd6SALxuiOn8MUzGNpB/ocPtDz+dFsAeZQJ78ox/+679pkYasR/9XyF5AxL+DIV94SAAAAAElFTkSuQmCCCw==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.xml - AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAKQIAAAKJUE5HDQoaCgAAAA1JSERSAAAAGgAAABYIBgAAAN6IjLUAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABp0lEQVRIS7WUPUjDUBSFA2JoV8Ehi4uDQ0CXiCCIOHZtcXFwViLdHEydilOdLbh1EUT8qaIgTi6CVOgmSCcXl4JuWrTU53drAlFbzZ+BQy6P987Hue8mmlJK80uL/gzI0WKxqBUKha7LF9+EQKP4Gn7If4DGMF0DskASAXaTJQ0yMSwDcYCsUi+hkaRBExjuA6kA2aAWkGgeDSeVaAqjSyBHQHapt9C6D7ZCbcUdhmlMHoFcA6lKKrTjwiSZI3eGZuKABNIC8grklvoMHbgwSVZB22g5Tus8iALSwaiJrtCxC/OAck/dJ0oiP0SJB3pDD6iGztEJ+vxSI4J6QfywJ3zvUdkPCZvoN4gHe3db950TuHXjnGyVSiW5E8+017v6gxCydTeGYSgmLBIkTOtUJpNp6rreD9Q3SZhhOGTzXqPReMlms6HaFXbqVL1ef+Y7ULZtt91x9oB/JgmayBZj0zQ7juN08vm8BzhlPTAkyB21vAQMQzudTqtcLrfJ2ly/6Yo6dZMcvEilUneWZckvfzEsIGjrZN8sGkKDUSFBWid79DiAXok+AAxAfWzVfcsWAAAAAElFTkSuQmCCCw==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AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAASQIAAAKJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIAwAAAESkisYAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEWp466Wibuw1LfksrbJttfO68zRy+3sztPTxNzF1rn///+O25VolnazmcS76L69psu7ruagz6d9tILIvurdl5nhpaj19PibidrovsLHn6Dx+O+iYWCOg7n16u6omd7b8dm4cKxLAAABW0lEQVQ4T4WUgW6DIBiEURDtrIJFW7dZ+/5vubsfsJm67AzF5j7v/pJY9fGPVPI/64OeYmXgW+t5E+7rej4AemPgz/oUAJMobLuEaZpiidZ4nF/+AmpA0/gG7uZp7dO6ZpOtp3FEREq4L5Zyxpim4WrCDB8lGSgE6ABQhA5ACMF2jhnGBOyaDeM7gb5U4HnjBIB/CgzVBeKHrBf0pe5L8DGhMddLWRKJqkBUG8Ahm2spysCr6gXw3tpAwO2Aqk+A/ArjugQwgCk9FBMAhM51AIZhgNXHDqV2gCPwnmEg0MuQUtF1RSEJ5aXEBtHPAM7ar+uaEvoK40uDAAVOIQT/eDwSgGaaslKC934VoJVzoBH9BMBnweqvMiMASAoiQJ8JnKEkQkcmSAlLURSLKA+p2rYFQuorvxfyktwkvIctPrcdoJhNPwK49gmSmwEi+4TsS8pJxe2g3wln/wQ/e5MwDonHQCUAAAAASUVORK5CYIIL \ No newline at end of file + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEXP89Btr+Wo2Pu06rbK7PrDxcT/ + //+34vpOVFGTzvywsrHb3dyfvtbk6eTm+Obw8PCFjob5+vrh6/Lw/fHx+v1udnC97b+SnZShr6P9/f1/ + vvH19vXA2sLMzM3F2ulRkMQncLtPAAABZUlEQVQ4T3WSi3KEIAxFWSoxYAFZi8qi7f//ZRNwH7LtcRyR + eyYBBvHdtVy77gseiM9b1xNdX0IeEWeB8ydstYKUvTzigmwESdBsyagH/Z2FSxVq3nHe942gj5yXKLUm + 4x+BFMrfhTIle7W32BeBDGX9GevZuAtS7t6HV7IFSwYLJZfKBy75IHgAb9NT2Bsh+ZTA+tqCl9lWAD/s + +6BI4JgX2Qop5OyLUNBtCyaFu6D1pVZI0+QK05Qegta3242E7ISY54+DeRbCZRY4JmG3NZvp4bgOi8BQ + BUGzb5Dwc6As1WyYhRL5WumohYgYtw03t45uizhugoS6H2K3QqBZcMXolihw2TbhzoJzOAyoEM0a1zjR + hoVrhZHqkrKMy5gWVNNJ8G7CqJJCIM0gBFzhLISEA30RPEaI0aABOskjLgIovgMKQKmUzWI80EkecRXu + 0E2o77lCTi3htYLahz8wT8H8hRl+AczBKUEbqouYAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAAsAAAAPCAYAAAAyPTUwAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABAUlEQVQoU32OPy+DURhHbxht/QImu3Ro + JaZuBqQMVBet4SUiDYuGGLq0Gq9EI95K1Z9FfAKzxEfwDQwSJgTV9k2a4956RK7eOslZnvO7yVWA5Wqd + 4ZUTon/vRguvxlDutHWb3X8I5NQf7zis5i9h47z9qR/m5NxLNiC1Vg/D9QswesH70+IRo5J/Wagwkjls + POq/8uNyrUPaf75OV4jITKmlKoPz/sdNJgCXc37zbPuKge541u+UUgfQz5nS61uyHMa74+nddiu5B/85 + VWzeT5ZJmP2LlokiTk3T3mnHtN8kCuBSss34DriUbBPbApeSbaKb4FKyjWtolNyDCS4Fpb4ArxoW/mtS + FxIAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEWk2Pxtr+Wtr7C54/uUz/z////C + 6PvBwsNSWFvo6Oifvtbd3t7x8fHo+v9RkMTe8//R7/uw3vydpqyHkpfy+/6xydf5+frh6/PE3eb8/f2B + wPNsdHfO3OLNzs7w+P291uJWU8nGAAABcUlEQVQ4T22Si3aDIAxAaVAIihPw0VLW9v//ckl0btjewzmA + uQQwqJsJ78ztgeruRjNG0FGbYEwt6BhFYYniZJ2EuPEnxVq4RKV2h9ZrHdUn4ViuFc0qYbmoRgTamlAN + z+oMu8BwvKEUtcBrCLCPE+4kOOcrnGdDBDqmUuD8WuFa3/9m4KOTkDnngafmROC4ZDgJOWfvRGDlQ4b+ + 8egtCRyXQ56EvK7es0D/llqTzgKzSgaiuV9IoC95fo7C8GR9E5o7wcIQjNx4P5UO45MFibPAhRJox32k + RWBYOKp+oCIJXzvJUcmkpFx1KT11Vj2vGwGcMd20IE6mIKawFJy0sUpuw5AQEia8YYfpZl6YXosJlRBG + KF3JZSrdMExlGIexFq4DFMAJvxHLd0nzhMtQC9my0GcEN6eSPUKuhBUwQaEhFrAeS0LbVoIHaJ2loU3J + thkS+DoD12KDXsLWUy1kwJCwUqBirQR6Hu/AP8HCO9D/AHbQJnH9J3xgAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABoAAAAWCAYAAADeiIy1AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAACsElEQVRIS72Uz0sbQRzFFxs9lYAgpYj0 + oMEEmxitJsXG0qi0tT2IJyV4EMSbKHjxJpp/oPeAFHoo2oOXemukUiQIioReQ9GakkgTodCWJEXj6/uu + 2WVn/VEF7YPP4e3OvLc7uzMagP+Caq4mT3V19e22tjatrq5O6+rq0pLJpDY4OFi5bctWzOUVIL/Jh9bW + 1ge1tbU3UiQlv6qqqhAOh9Hc3Jyid3V3d19r0UPyg2BqaopTgEgkIhO/9PX1+Xd2drShoSEZp8vIFVRz + sUIkRzA5OcnhwO7uLoaHhzEwMIBAIPB1dnbW3d7erg8WGbmCas5XmGSJWZJOpxEMBsFwxONxOBwOCfhE + 7hNdRq6gmrMlJWliLlc2m0VHR4desr29Df4QMtngI7lD1GzFnNZjskf0ksPDQ+Tzefj9fszPz2Nrawse + j8daYvCG3FWyFaPqETHfpFgs4uDgAD6fD9FoFBsbG2hqarKGWzkmSSXbamQ/VOQn+0T/JoVCAblcTl8i + KUkkEmhsbLSH29mzZitFPT09WkNDg5OD3srgkZERlEolZDIZ8AS4SkmePLFmK0W9vb2CV9a9vr4eExMT + SKVSx7Ix5+bm/rVcBt/JU6JkK4Yl98jn6elpxGIx8FjRC2dmZv5sbm7C5XLZQ+3IFnhOdFmzFdPf359g + 0X65XKYFFhcX0dnZibGxMbjdbnuonQx5QUwZuYJixsfH37OouLCwQHuilZWVy7zJN6KUiDjdRDF8clm+ + V+Tn2toaL51ofX0dLS0t9nADeZOX5JQ41UQxlSLhHcHy8jIvn2h1dVU/0+TUlowKsgXOLBFxmoliRkdH + jSIHeU3KS0tLODo64m3oP4h8s5qaGikx/67zZOQKipGT1+v1GmW3KmWwEwqF4HQ6n1XyzpU1WzE3yZkX + rx9ofwGoydlWklGMdgAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEW24/ur2ftpiJ+HxvlruPeNscad + 0/vB6vxHXWwdJSs6eaxWrviRzPk7TFn////s+PxWlst7wPl6osFjnMfT8PnQ3+s5f7gsO0egvtfR3+uV + wN2jxdrJ7/zN4O2NzfzN7/t4Cj7wAAABc0lEQVQ4T42TgXKCMBBEcxCSIEENlGIV4v//ZfcuCeB0bLs6 + Y+72sXdkRnX+Q/8AJvvxVhcGboNVStmjuF6ez2VJwMiNrOIDWKwqgCIxk4SgxNkCZHE3a+GAPaH5qVvT + 3LcEmtsXzfhAbks4Aoej2xIMHumzcHLpNFeUgSuAKr2Irdr5tlryPnpDRgnwEEB8tQB4WGUi+wVICYqI + 8PqcoMhA8GMBYgZIgDsAzwC9AOKTqtp2UAYboDB+A/q2TwC5tu3vWIGH+B1Am2coNcgtjcmP+4iRr2Vo + BoAOQ3DmAbEuQG3gZDU8hRFk7Al078XFJLQrue5+3HfgiZWb59kNMYS6DglxG4CLwSXRg0zQndYhGkH6 + MmLMr0hedxBnxFqf2j4cRmDpuha/0zUUQtBXTQXwcLklQPAoUaE2G8ANJLDwKzxa3Qag5C7sTuNBfJMK + ENn2aUUxZBSUdzh9vtFpEOCyfmWt0zpNUzqx1lX+vL/qfP4G5j8t+FzwaGIAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAAFpQTFRF//// + /v//+jQ1/dve59rrxqjQmGGt3cnl8ur10brc5+PyoZjHvcrhJVmmbY/E9Pj63fPi7/jvtt20M6AsXbRX + 2u7Y/f78/c2b/nsB//Lm/drD/ZZu/ff2/auq3X2RUgAAAXNJREFUOE9tkwGWgjAMRJNFQGC1ymJQWu9/ + zZ0pQRCd99TS+Z2mqcgiNVN8UuIvH3z+JdNUPGP8+YnxOSU1n16VWoPrioXKJkIxbruqfqxEMY0qZp6D + /eoKataMYryPLGsGRBr6VVXqcwXuo3qlvp4qzQkCILIvcnQb6jwjA/cpEyalu1CjOq1ATCDUWjehGgVr + 8QI8Yg04wEcPQTgQmZDcnX0cXqWIDtwfIA5ud0ea+UI0JQd4ED9j9vMd8Vs3wNykLtFhSWyMiAMRw1xj + aW1AfvbfAEwRKKU7B1sidgnYotHudOYJaL0DGNdVbecTgFzhDuClHw8BPgB2cZbJcgq00qSlT2CrKVJj + wjL5pQ/gctvokhUYJnmH0/k6/O01XLEeyhHfgJ4VQNZ9B4bAeglwk09guCyNMZbxAdCfe8IOh24PsEBe + Pvz5RQxvwNBzHVbCyS8ZhnYbHBmGHsv510FXuUUWyw23HrpdMdxarreZ5UHkH1uuKjpzfxAYAAAAAElF + TkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAAsAAAAPCAYAAAAyPTUwAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABCElEQVQoU2P4//8/GBuV/f+PDcPkQRgO + sCkEYag0KjCr/P8fG4ZKowLrmv//sWGoNCpwbPj/HxuGSqMCj9b//7FhqDQEBHT9/wTE//Fh/87/N306 + /jsy6Hh3/Izo//8fF/atf/JfRNH2IdBcRwYmFrY2x/Rt/xOm/seKzaPmf2Fh47SAuIOBgVlQxvBgeMu9 + /xmz/sNx+sy//+2TVvznEpCdD1TDBFEKAaqqFgkvs2Z8/V8w/z8Yx7bf/S+p7rwDKCcEUYIKImyjpv4u + X/L/f+6MD/8N3MvfAMUMIFJYADu30Izgsj3/rUI6fwC5eRBR3IBbUELjiKJh4FwonyCQB2IjCBMZMDAA + AH7A9QHLdCIjAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEW44vt2i5NttvOJx/qb0vosLCyt + 2vtAQULlZjSi1PuTzfmy3ftZrfPA5/tTVVak2fpXkb+Kwuqo1vvKyspoaGj/spOn1Omu4PqCve57wPiQ + 0PhCLCT///9KY3VMTE1QUVEzHVEAAAABn0lEQVQ4T32TgZKjIBBEPRhBBiPGeCG6nv7/X27PoMZK7V5X + Sgjz7J7RpFqWx+i9X3/6jI9lqZaHr3/SV9M0tX8AGOt6rWv/iX01f5u6HgGgOnZjB41XqABrAdCD75C5 + XQmJUMD7f39+0w70t5iroltRzrp7er8DGboiOeuyA2ufncvxCmk95+cqwLr2VXKiN3ODEfYF8FufE+RQ + iJDmV5WcPTcdc+1dCClFjZWaXBKllJ+bRmx9ohDC6S1KRDOAbo8IRDRUURFl4gylxBrhu56YCekHUlWE + OjLuxeEEVChHRzORc29gZh7KoDG6iJV4DleA7Q6gyhxcYOY0JNqBDQANIhCBsWVrMRfx6WBtUAASlqxl + osD2dEACHoRAMAeEmGFAH6/TQR6UAG5ABzITWCzvHkodQ+CJSQC+SKNnDzhFGTMgfoIsPDDZ2wEdlDF5 + alsDABLu7EEHdHA1LWQOYDKHg/QIz0nrrdG6MeYA9F3oLQWY0F4xaE8HPbDWtHIfphAeRzuAd/GC7veX + EQswh1r9RXn5131q268K/E9++QaQMS/guqd/bQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAAZAAAAB+CAIAAACF5NDdAAAABGdBTUEAALGPC/xhBQAAf3xJREFUeF7t + vW3Mbld539n5Pt9mNKNK/VBpWk01kSoqJeFDqn7KS6NG0XwoKa0UMeo0DEk/DUgOmXHaVAU7oRmRBIUx + uKQlNXEIIBJMzJuLyBiHcMAG1AMmPgaPj815sI+PX3jOeR7wY/TM77r+a/33tdfe937uc2wDI2Xp78vX + Xnvtl3vfe/3Of617P/f91/7FX5W/Kn9V/qr8/6QEsI6Pjw/5b59ycnJ0Ev8nRnJyImmx1lhUPnt8iDhE + HGXR4MXo8PS0aFgc9cy8AYuqUVLzWnl9Olksnpxe7jpIPXZy8ujxyddOXrhw7btfvvYCuv9q6NOHL9zz + 9MmHU3d+81i67dK3pV8/OJJuuXD0psefJUo3fXWML0bs4S2fOb7p3NGL0ldbjF31HRJj/yVRRG8892Qk + fSvpl758VXrtucs//+Bzr/3KFfTqz10hj8Vzl8lVaXkTS/tht7R/3Z+3qOS191y1/sknDhWluspiJ2wY + Z5gvwXr75w/ueOA76L1fCd314NFdDx/d87Vr93zt5M+//rx0/zdesM4fnLxIffmp79aEeKa+9vQL1sXD + E8VHD08dH38mdHA40+VBxy0+oyRFPuhwHnepMsGJ8mnV4aSnD4+kAFau6y0yUiJJKXesJQhlePWkCqYQ + OTxHaicxEOfktCcZgcWUxyriQtlsypNEJxmVL+JLpjxKo5LyKq/tDYyq1IloRYRWA7Cg1RJYA63EFGjl + Xi1NPfOrTymmZm2CDj3WmlB2wlWpe7dOfs/VIQ4atr1eARFFCR4N+qlzT6Kfvfc5JcNay3tAnBXxn/7F + IQkRGL3qzy6KSq/+yBM/+dGn/tGHniU6JyGyVrmaCVjSr3z8os7WtLrtM99eYdaDMOtkF7NeMl0JYJFE + vBJgIipZVcWWmKUoZklgi7jCrAIpRHcWnlyjRYsGnU3HLEbHD2WS9FGCAgvzpCugUfXUM89QaWCllMSu + p6K81syKPFeJVdQgAUtyZVUjVIlKwE3I+VoEDYoS5KK+5TR40cC67CR5NIutfhlnLWnWY2MWErPQKrP+ + 5KkVh2VamVkFVREl13TN4FWZFaL7OUkJPWKQcvVVLbrrulJxKe9Eu9WiE4SxIhoripw5sQJIbDKqao2k + ZoPEKaNqoJUElZZyfQXWL3z8QK9X5w+qbv3MJTELYK3QagGsAVs1Xy5ehyBURjNLiVRpZQ20qhpoNTKr + i14sKpGLTVokAUnKwUXGVCIl13ZUSYaUTFZbDFb0eAykSIQqErTlsFaji9AzsKnWuJINzSxegFu2tT02 + nWrRnOpSHjxSTFplG7jQG984oeYMSk+kPEEj6LRF571+iq5seeMU8eDk+RwSRvSocALW0fHqqHDpsCbW + pMwpCQoQA1J0rbRaMeDKli2J+kXsonsrWqbSLrnNixSIkcANfKn0MZsGea1bSiJUlSGFMFP2VmLTIKNq + oJXsFVGoQvJWYpZo9cfnTwwsc2qXYM1QI1F/X6cYkVw1VYEkJT03qkiMJ2NLnLIAk6I55VGhmVUhNQgY + KVp0baKARX9PVCmGsuMHQEYJUk7gT6gyqxXy4rBau7YLSoYWVWreioizYz5LiWrYluOJWbGf3tKCMquL + HUOrMZBBnszKfI6qDXKBjyEXgLQ4oaetanmlzyyxaKDKWZzGg0mr5zUqtMnaNTDcNllSsmliFr3dOaJ3 + RYyW4lcmItQQtas5qixTaZdqs5psaNlGnkhR3PHobynWDrk2Qd5cqEKC1D6okmipiPQCYRZn+Ma7v80l + glOyV3DK9krAEq0++uALaE9mLQWDhlyEkiqknFRmzR3WVZNrYJaAtddgcCFD6pk5swypzCMpCoAs1WjV + HZZUaVWjkgIstsyo4mRZJkJRRBknKTUwsEg4Euek83OzKqAT0ahKrxRgSjY1TnXBESdNfZOVqaU1TVTK + nbQ8FleNUtQfnD4/ra2rhlxtao69ym1tr8SsR4/R5LNsssSsAVh2WIPJEpti1rmPpyTlbW0mdLZdEdEh + FavUXZG7rhJ35l3R0k68t2mfnGRPhAPzRbhZ0urH7v3mUINoqUh7bej9UKPIKRFNK+nH33+ZRUUWlWvV + 4LAkfTLgkeAALA8GBSwPCW+MWeg/f+O7jsjAqgpOWd1bKYpQySwU2FrSSoQSqsypVVoBICJduNZUCVJK + Op5qPh8JVgk7Siat0EqREsCCIXWDWIzQ4lTsnjKvWq20BCwJZg1rlzK2Im+jvw6vxM2EqnRYIdXbVQlb + C3hBjYg9F00mlZoJT8BFuImYq06enyKVal8rc8PEU+o0ONVin3dXArOqzwJYuwaG77hwDLP0+eBAK0uf + lAULkl9WW9sTDRuRUIXIxZQqOq0i3ZUo1XxVbkDC5sQqD69CnVlghfiqP7to0FgGk2hFlFxfVTe0xCnJ + YPr7H3nO0RKtKrPaeUKr9FZEOPUbn4g42Cu8VbVXwSxoNceW81pfBZ6cq71pVeMg00qJmPX5K9fELAk8 + PXzlaqWVOKU4AMtUGgSPnFh05p5Ex7aCLy1XfcBkkRfs1LwV266JViQNWBS1VhIxQingo8ZV7V7FsQUs + NNUXPxWx5gGpHkMdW1EZuCERg0yrSq5cbMxqkMpVAZesiaQtVugkaLyYSYBGauhZj7l5r4nKOMrUIAmV + bZrDsmSyHj458sCwMks+SyYLDSZL3EEzh2Va9U/6tejEEqqQISUJIuLOjYk91ETdXlL9IGglYBEFGmPI + hKqoqsxyeyVVFVUDpLxYOYWqvTJeQfyvfPxitVf6fHAAFpqAlVRaJhOthsUh74JiCDBBKyVVjVMpjwft + sFJhrwZaKTGzKq0GYEEiJ8qVWKKSEyn4Ms1bUdPxNMsbcGb5YX2ggRIx9lPi5LBU9P++NC8ARXFQrVxt + AGXSFqI8oZOT4qEkMDRf7KhqSUSI0ypLHlSaIFVilQnlEVwApVOpM8u4cV4rkzslP9VsVK/plWMy5RO/ + KrCQR4VmVgLraBgYymRBq2EaSwpOJarCsCSPGB8pCRXPFY17HngqEQlVu8gi0bEdX6T8yR18Ma0kEWop + AcsJLUmgkqI3N61QpdWPvv8ZpIQoGVhIzKpz7XJYeKtqrwwszV4NwKqCRKtRgkqKu2RmDQJSis1YdWyx + aFQhEapKtBKwdqFqkPDkRKIjK9aEnk4MviRGyEFCry+JUNU4Na+JSIk8TVajlZKZw2pJiSox4oMjFEdr + WNwh9qZPKPVKpvrapn0+GEmLLZmYVZNmqYynOadkqZR0k5WQMry6DJdYBCtaFI/6Ki1KJk6tHBbVpsZM + RntleVT45WsxkxXMSmANs+8wqzqsm/LBqwagRJLmcSQt6jFLy7SqkHISsFtDVe3P2xo2tGFxXCaKphV8 + EY8QiHFeZVRpUZsQl5yqkKqoUqK1FVicjMR1ELMGWhlYtldoG1h7CjYpVlQ5WXdYSStH8DQ4rAFVSK5q + f1pBIsWawB0nCyVxQquVqs9khVM9hijTqJAibHWHFeDZXQBKjdZq5clUXFOnsZDrEehxrIuhGbBCUCmT + mFxXDCqJTblWuWgFgFhsYHKSORBpbOquJ+ICT07O1nePx5r95Hn3MFkvzEyWB4YG1nxUGB/5NWB1WjmC + npp4UVH1QpUSRySaWMKQu/R1SZ2fzR2R6hXBiqJlAO2iVZWYJW9FQmQrxYoq8ooq56IVqifMecpbSXJY + 9cGrAVim1apgUM1XdVcOBkmIHyrAqlqllWLTOBiMkeDArOvyViKU80FzHqkGjMwqAUNZnOdiU34+mM2i + TPVRHCMRrciLw9L/touwoqTEyiblNUocjKPKZwEd18eqKdFkVhCqJyOtAklcIEdhq8MLHgWkqkyrjDBo + iqaVlHgaIbVBIq0i3iitLP+xTmBr/MTwaPjEsJiseNLKpglswaNdEoycaM6IzqlFiUXLfbjqH773W+7k + 5K6pba5X8KUySyQSrX70IweoJqtiK9ZqcxLh6UzVF+KX8HPvvcTJwCnZK2glY7VhryRT6XqlqXoSwQs2 + DcwCVYqDyZpQlbSCTYVZbdJqkFAlWpELVavAonPVJPpaskbRiRcPAyDOZzUQYl7TY7Ip13Y1WgXFirdy + jGQ/hzUUaFKiqORSaxwRZyBgxQNgi8dHQ/OJrSWqnG8qyJWoms9bmVZKhKqigSBNnUSPqkGyiTwWM3HN + evvdqg2AlKfeBaxpYLiYfX/HpaeKyVp3WKuCR05EK0fwpLiLVurSlVaDlquGPazqp+/6uqJYI8kciVAW + VHJ0Dapca1sBI8XUK//gCeer0tly/pyJ7BXRg8Gmc096SLh0WKJVXXSN46rEKfAkZjmCJzFLqFKi3LSq + zAJSlrwVbFLUdLti9VaKkGhJK7HJuWvoszXW5DAAMiUMp/piE5zIJDjTkmSTSq9PZb2SObOUdGBtFRHE + RXmJCaVos4xtXRZOQrRKYPXdjmofFy6Fe5otSjlLZQEjKiuhIqYg1MSpGjMxOyYJPSUKMUQlQZmafPeY + RIsrecapMg+hmqVyMqsBK5jVZ9/NrGKy2p/dyGT9/IPtWaSlGDqBJBIRyniqnKKNItQwUwwgif5fI6Kr + 18QtLbFgqJR+4s4LzpeQ+qEPPV5jXRw0oWquv3vn14g/9IfPoVov+dCIM5S3kr0SrTwYHOzVElgWABpy + 13hxVXCKCKeWQ0LRCq3SSsAiClUGVpVclWglY2UJTJbYpMSLCMooDspK+NIW6byiFf27Vw6LUZOLIScz + JbNWaUXZw2HBkRqV9FxFiRcpy5xDGFjDNFYVMHIyzbt3wSPFXTKhqoJWJYpQ5pQTgWlSpxUQMa0MIBZV + L4k1kheVaBPckwyUNqzJUjmZdTwNDBefGM4Hht1nze3VT+14NEkytogQSjnd1bSq/RmJSkv9vXd9Y6iR + 2GRpuyRzagQWHOkMMpgqqlZp1QSYWNthBKqA1P/4nidNKzOLc1NEOkMhFf1v7/0OV4BYHZa8Faq0ErAU + 9xEwUpTqB4sWzBKwltgKWl08XKKq0aqMBFdp9fDVY9FK2qaVNCwi4WaewI22uOqqKH1R+cQZ5bW+KWnV + kmlsSGn/28NhlZLkiRJM6cvLWEu0zISXtA+wpD6ZtaK4fI4xAGyoQvBIsUqEGiWHlQoqGU9FDTe5isQY + gjsDoVTpuEy86Mpas2wcJuvkmmbfxaxxYNgfcajMqg6rsqmSCzApavwliVPSklbq29JPvfMCUZAiVrm+ + CiQRZb6U13qk/TeOJHoEpm1NnEpUoaico8q0quIoipJeoIBVZ6+EKqQ5LDks8DRgCwbVxHFVIGnIjS3b + K40KK61AlWJ9arTSSrK3Wn1AFDlZoVUfAErRsxYCOopSzaXorc6z9EUlEXv9rGgxG3Q1SzWolf3msApK + KI5apdxxKNGsy8BCtX5VsMmJ5rOAkWJRBxYXXVFaYuu4OamJUFVzWsEjZBtVgaJVys2XMzW0J9bEqm1w + WPrQEJ9lkzU8Sro0WWJWBZM49WP5gRo8IjGbhCclnk5SHxZHFCUjaU/RWHQL3f5V78F55ZfURnALPJ2p + 2Kr7KaGqAktr2b8W6xFNKwStELQaJrAELDNrQzCoxm1BKwlUEeuQcAkso6rSSjKqkFBVJUhZK7RCHVh0 + n6XEHSdDTv+fcnprkMRR9VEUPVp0MXaCUxZ4mnLKLO52WOKFkh4FIEeVWlPrKa6UPOmO2iuUFs+RWn7A + HSpVWiXFpsWq/rxVvBNwKuKOweCjxxOkYATR7Ii1fUBnQnmtFqWa35iWe4t593BYx3VgCLCGgeHSZCFN + rotTQpXxVHPYJCk3p5YcEWgi3v5V4lJ/53cfromaubEItaysa0EVccAQxPmb//HriLUSlYpN3TcNkHJS + RU0cogMLimk8iPBWslcMBkHVTe//ziqtiJBIcZcgUc21qKRqoBURwSxkVFlLWj3wjSNUvNXscXZEDp5w + VdbALPA0YqtLPKqoeuaw5UtN/XQiVF8VMaDT6IGytJqeODbJT7U8CDXENWD1k5jlXQKQYy21xm1qJcPR + AqxYowa7tDUw7LFq9FaJqqaEl3JgpBgwSmYpAgtqTA2iJGCpcpdwQzUZF6FPr2c/LGptlQ7BKkVaNvkp + hzWTpT8wrMCqQ0JgpDigyrk5hUAVkc4czBJlCq2qANOZotmAp2FxECQSaCyQJGBZauOWNFBi/e13PjHU + SAIWkQPpdeklwywErXBYmroSs5bAsgDQkAtPVSCp5lpUgiCUE9EKTpFoMDg4rBgJltkrM6vTqj3OvrRX + gpRpJU7tgpQUbOqoqrEmgzx1RW+OrhpJUAOxSqVXrhQgoNIJNcszRt2kdYcFLBQXEmIcV4sbWFqkcOoT + sDj+vNmgQz/4vlBcvjmq2qMM6adYq6QxKxV4yoFhJEc5AMxYgUWUhI/KES8u1UiUDAq+iDVEJ4vK2l75 + hWvfJUFBK0Et7RV64OQogKWB4e5HSavDQgaWUTWb9/nIAd2VCJuUqxvDguawClOcTzx627PO/4d/95Dz + pdjWed2D9jmQqyJmQFXVEm0SqwwskgFe7N/2SjKtNBgEVasOa4kt6KNoDYsSSKpxkGhVmTWgSqqowlVV + e6Vnr4aJdvksoUqWyjrTWFlikBIvbiu6qpIgS0SAJZyZXJHQtecFDNQiKhlPLXfcOekuajhJUZaxFteQ + DIqS4z4Da2vevY8QE096GsvPZGXCpWmLjVYR8+IaW9LMW2VstCp4QgBCnFIUoZQPCpTMWSMGNc3BNK1S + TV1U1ESVV2USu6VeldlAwKoDQzHLJms5KhSwxCzRSlGcImJPzCkg1VDVOWKxKL4MxEFCFXHQK9881ZNo + UdJ+VlWRdKYAUE2EpypzCkjJXiFeaby6fMm8dmjVZq/ecwy2RKvBYS1ptSpDalXgSXGQaQWnPB6szJK3 + 0nS7B4O2V+mwmreqT4rCJtNKrsqJaKVYpb4j0bkc6+KqAEQouyRJr4QvrS8LW40kjr2AIUdKTcCTkxJ3 + DQkVayLo9MSLKssGFFVq0bFOY7nBQhVYVadxRUgUVbObVpJclb0VGBKtBmaBCSI8evhqjApleWx8JNHE + SSBGElwGLetVM9SLTa50m7RXatCAdXR837UjmywNDN9xIbBVTdbgsJbPN+mjNDot0YnYJEhVrAyIMX2M + p31U22vzVYGeGs9UJdR/99vfVI3rK7MUTSt5KzHLs1c2WUDqTJMlgaFlXNUqqkQr4iqtNBgcaGVUdVqN + zzGIVnUYeGO0cuJFKzqm816jSrGpQUp92WW+aJAll6Io8SKlcqrF/R2WipJa6dyLKk5UxCDKfN591oqF + KkhU8iKuUXIqFXkDVnNbC5NldbfVsFWiFKi6ms9MFWY1XQ12BKQqVlaTk2sM4ibuvPACi6pRErmb9U1a + +2qslGQOqoytYfYdWtW/iAZY+pPAaq+mR5z6s5RGlWglVCkaHz/2O190XjUA6LpUN697qwI9iHoxSBGx + Sgk1JhRxKfBkYMEpcvksvV4Byw4LexUqQ8KBWSSQSHFbgMlJFYRSrDKzQJUecM+f21mhlSRmwSlhy7Ty + XLuS6q0qqhC3+iqqnEgikTQsWq1jOu8JDIpkDSDT4n5F5Jpo1Rf3ncOaAWWxVlJZJgwG9X9qOLiB9Wz8 + hk5rRoyRYAwGZ5zKGDWBJ64LScSGKtUYVbriA61mzEpCEUUo0woeOWnASmYFOFItN0QsgymjeaRkKYgz + 1EjeJPaDcuqKJFCV0VqaLDMrRoX5FVcyWf8kvxQYWjVg9ceUTCslcGpAlVVpgrdi8eXWf/vrDYVwh4Oy + SDSJXO+aQfJWJGaWIi/QwDKtkAeDphVgkswsoarGQcCoxppYq7TyJ4PD1BWcaswCVRcPNWlle5Wo8kiw + 2atKq8FhVVVaSdFfdpusXYru2ZOIvUamqdkrU0KJ444iJKkYT4ot8RyWDtPKcABplvdkIXFHxQmlruLY + B088KWDhtoJlyamWZLOlJmYZW51ZcCqT2UWvzBqAhcwsEqkR6upxuKpElXKhaqJV51dbnMu4EXrOFPRZ + zQEfixxC9YMCWPFx4VEA6/FDjQonk5VfcyxaTRNYhVb0WyJ92KhCQpL1I795ThFAKH4vBaQsPBRRlURI + pLgtYcuSzxKtuAimFfYqxoPpsMwsBJWWgkE1bmugFQJSiqaVJGDhraq9ah8L9g8HQZXHg/1jwYgs2l5Z + dlgGFjwyqgZmRU/pCaJnKe5S9MGOp2HRWEiYxH9aXNF+RZByCZeVMR1W3Yt3WpJGNNW0+pKnKDVSVivZ + lR0WiqrdnOqeK3JdMpErFgWsrFEeF93YymQDW/JTYhZskreygIWTUSBpvghEGmj2RhXyVoNqvQjlRIJW + 3WRN3+IgZr0lf7IUYCH/nQ39Ew20Mqc01FoKLjjZX9vtz9yhIOWkqlaCJEfXWJVTSAkvVsCSw7K9WtJK + MqeqIJFiTQZVSFUJVau0ivHgRKtrGgwKVeLUQCsnopWZZXslVBlYElRSHNT6S6p1sTW5AyppfTDAlHmv + iURFi5ZqXK9S890FUplWlDmw+i5s6ibzpVVR2ZO5KI5VtV6xAisqZ8DqeVRO9eaU886pxFYuTrRKQSjF + VWAhOWczq3mrObNmbCqqBNHiwJozdV/JP3v8LPKidquk1khyWDJZAOuub7wwGxXmDyn/wscPBCxMhGil + vlpRtSqzQ7msliurvMlSQ8v99dd/eQVV2zK2KrOQsSVg/djvHvGqiUtaCVgDtgypQSBJcVsQyo/FA6lV + YDVvlfbKtJrmrWBWYsvzVmmsJJmsAJaZhUwr4oAqtKRV7SyCEar5oNb7BkJV1cqhWSs9mWpmxa5KSYsx + ErQ06e7tlWScUKWhaVT2wy8kEi0V9TmBBX2cMxL0qDDOqTdOQqWlmtNKMqcUO6oathqt5syS1pnFW1gc + FnEwWagSygIZTpQrsYSYQeKRIAVxtChOUenoNt6VkmhwLTaUDCwxKwaGDz0FsG77SnzzjEwWzDKwELQS + qhB9eEAMMjW0KFSp3qNCLapeu1J+XdKulhKtboBZ0i5aITiFtSTKXv3MbdcGe3UDtHJSJU4t/4LHtBKw + /tjPtU8jwfhpe2R7JVdlyVXZWw20IlZabXkresGCVggMKe5S9MHV7r+6qla26DIs7izyUwOtiDuHhAZW + Jll5Iyq06gyqwNI0VoPUGqe6Kqdas8wjPkPCFScp70HVyKykFZBCMllEtA2s+6/mNyhc7U9FbUqsMYCU + iErC0yBXKnEzJZFfix1WZhlYHhUCLHrLrZ+5JJMFsH7uvZd+4s4LehZ0QAyMWOLDNUoGh0UuaVe7NDTw + VpL3NkioesXNDxArvIwwkqFmUAXWgC3RigitEIRSlF7ze8/DKUUn5lQVVFLyxt2PO0CoyqyBVmjyVpO9 + Alhhr6q3EqrksFYHg1XcrvZWFVgzWqEdwEICk5Olps440GAVDg1MZTEo4sVeaj4vc1ShoBX/rTgsoYrY + UBWhH+k6taQVAp2gCmYhgNU5NTWwkk2K4tRUP1erWWUWb5KiFe9lRgEL2WcZVQ1Y3B89fv7KNWhFlMCH + 4iDgokSIAVVGj5AUAjo1qbG0FKeWglbEyWGlyRKwkIGFAJaYFX+HXB6wGmAxSA1krMidSDDo7/ZHIszB + QVpV5/WRNtchBok4QpKlmlo/tHEDZFoJVX/nbc8qSqAK2V4NtLJEK3i0C1j+6BAwkVROIXFqm1b+ZDBR + FZySvRKk5LBsr8rs1YxW1VshCGVvtZNW3PkdVYqWeOQkRG/KJPraIs6kmiGOZWi8VYADYIoEPLXFqLAW + DisLK7JEfWDLB3vxOo1rYYeFylojaUq4diRsYiqpcqnwWQJWjSneLcUGrE4rRWFLEYlZJtdSA7kQ+FBc + lSjWFpNEIedK6mKt0eJcQhX604On0R888ZRHhW///AHAQr/y8YsGFrSS9NjnxgMKAorIYlGjZ7KCRFAv + YaSP21bBpLVaNaytu5V8aLzVQKINuYFoVYEFp8ysSitJDstDwkorCxIprmKrMgs5gVOSaVWBJVrBKcW5 + t0paVfWnroQtOCVaiVyVVo6ilTglQSXFSYkq5H4R3SpVc0kdUIkXX5QCJz0qieJkVsSfINSErRZnwJK3 + ivOzw6rHuH6ltxoUALLDIonDhcnyWqttEjzSdSx4GtRoRcyWfkss00pqA8MklIaHns8aFJAafFZ6K6MK + v6OcRMZKDmhdlU3mkfNaee3oo9/+jpKPHD5TI6giilZmFsCywzKwfulDFwDWq9JhIbizzayKEkmVcmdm + kObFTCXzSGyihlV6TlUNqNcq7dNGz+IoYpBJtI+8SQUWMqpWgSWHhaCSomR7pShaVWYZVVWilYBF3KAV + WrNXZa49USVIWeKUUEUuS1VpZW8Vd3KKHCqJVooh3flzWimuyr3veqUyVI5qnKqxFaGK4oRiWhETWCqx + o8YsxanGR3qxahgysFBcnWlUKAWbomV/PktFecx5dTDNaJU1Yla1V5JRhSCUYsNWn8NawdaVRFXQKp7J + gkryVprJEqeEqqXEmn110vF0kmDKRRJVClXilKNQhbeSvVoCK5h152PIDgtgiVkmVJXxMQDFtAJSP33X + 1yGRaCVsiUeVWVplZg3YUmMi+yTxsa4LVZZpZWbJYVVaVWYJVZZptRSoOpNZppWAtW2vkFAlVVoR/7O+ + oi8fE63YKt5K0+0zZq0CSxpp1VGlpHWfrFGy2tcmJ0EDJXOtsmm1MqSdOCZiMu4swpZp1YEV27OtdpTJ + LPbjvSj1V05yeup5d2KbxkoFp+ZXjbU0e+TRi4iExcO2shVdVpFL0hsT6nm8YfF1DqcC1iqtELTSBPwE + LDEr7pWQCWUNkBrUYJSscRR9FMUjsQkpEbPUQEkVkFKU5K0shoQaFUKr1//RIzgsgGWHBaqqgJTiACw4 + QmycSlT9xJ0X6pfS6PuzTK7KLPJplYDVsRWQ6uRSlHS4gUR7SsAytiqqJKNKtDqTWeBJsQJLiTm1iqoz + aRXAEq3izwZlrxqzQBUxHFZ/rt2zV4odWDF75VGhsMXtCq2QUSU1VHVgtY6QtFKsHY3C4tDXoFhtsMRQ + q0k+uNTcZWKIEqJKq1zkWSZaFc2BNY/FZ/Xj3aA6rQTsDiypASvrdYEuXHri9nff8a9uecsrf/J/Rj/0 + ih/+G3/zbxGRav7Z//qL//yX//W/efu7P/Xpz9KYqx8XFGyl4r0p2IJTEbsgFG1orMPFoVNt2x6ly10H + qYtFX9PXV+VfC1bdn4JNAIsoqXJ/3ds1LFZBN8l/o+PPCmEW/UfYgln0N7DF2JD+KXIFj+aoghp+HHwQ + tBKnfrb8SkVV2K5uo+AUNYp/P38iUDnY0h8JLXVjwBKknAhYslcDtjaYBZsUq4Qnq3JqFVtcaiKQqswy + sMysNhjsJismqq7ED3OFMOxX9DO6kYhZA6oGTikRqsSsnbQqw0BkDJGfv/DwH370v9DR6FDLvoaoZy2d + kZbaio1bX04FjOZSTUSzSbGpI8XSYi8gqcZJK3NYdfuev3TjweKwchpP9gqRUMO1IHL5uGr/9X/z1//a + X/uv9hSNdWW5rJ/7y4fj7RGt0lKRGFVyWNRzFHjHO4F2JY412VOQ9NPtS42bq6JmaPOSSxAnWn/rf3mn + IpdUEf33P/qPpVfc/ICGh3gocmpos4ysBTcITvkLl0n099WqVwOwhdTAmzhBP/Kb59jhUtAKwU0BaBAN + OJNVsda0ErACvm979n9606EUtPrNa00AKxPTSoJQihI0r+dmraLKtNpGlWRU4aoYAO66JaiXsTKwJCAl + VWbBKUWYtQtY0Rf6P9KI7qb7n16zf0ejJTcPXYzNA1vZW3eqompazDKrz0Wv6gUwKU4a57C88a4o+UjX + Lb286UUycDOwEDzGK3FFhst0A6KLhkUSqjQMrIp37oQ2w1YvrXghBVgnuKGX5KW9JPI9SifE2sAsIrkb + VMVtmsACN/qD6qVMMZqRvzZ/Shq9ev7TrcTVo3AIQMY5yOtVVFnLfqUavIAYR/zbv3ZZ0TKzZtjqWmUW + 3uofvPGueiCJw2FRK7AGZsGpyqyKrYlWAtaDR9Dqzs8+vnxREvUfO3cRPyVs4a1IVh0W0eNBO6yKKtGK + GGOI7GL80wunhiNel9gcbLE3OYxwUtsaoNHg1WMvMYk2xaI+dbWfw1pKR9pTKxieagwsLij/qux6/65X + XNBn4sfBGp6GqPHg9wBYQMoOC3j94ADLAh8xq5VTVBvAYjwIjEwlMWggEZCy9A2CShx//sHnSDaAxYhy + F7PYauPeYC1sotkqrawNWkmyV69+z/E+wDKqRCsza0CVaTUBK5l135UXXvvv7hgOUQVWvnYSc1iilYBl + SIlZ5tRAq8oseSu6ISMP7sCXqoshehCDRDErJCxswsHzSx60kUAoLRpViqMO/UPQGw6rS6XWLKUyq9GL + mTGr5GUai7YY1OGK3LAAFkhqwJJy3iqAlQmHfrmBxf6rw/rBBBY98x++91sw68fff3kbWFBJtBKwRCjR + ylRC/spTJcqt1z+5E1hA8x996Fm4aWah+ljWdk+jgZglDdj64TddWWUWqrRS3N9hVWAN3qoyawkszbJv + 3w/cw0AKKglVxAu5KFoNqJJm3opbvQOLCFbwRMMhXrw4yfu+cD6ZVfp1J1fiaVbTYtHcVbGoqKTLg8HD + 4/jA7WyHFUuRKCqhKHeNY63sA90VZrGK8xCwWHwJL6iAFfPlBlZhFu/r98Zh1TmsH1iH9eq7vv6qOy8A + iw1geVpK2CKaUOimc41NqH0h15xTWlT9z/zafxr2jwSsf/KJQ83ZazLLDCJybtvA0mTWklZIqBK2VlFl + 6TnSfRyWUSVaESHUqsMyrSZgPRzjwbe994HtV8Ra2jx2Mo0EJTFrQBWyvbLkraQ9gcVBq4a1q2JILmaZ + LJQAEH18NdY58Vxc0KrHwiklohXxbIeFKEMcpEqVVhkfKJAkoRbkUjMBi5NgdL28RtRAH+CCQ+aKI0aO + 5HR+6ndd0xVgwamCre8NsO5v378etPqBmsOywIf+2JC4p8MiMbDEIKTv4ZJYrJyyWMRhrV52DoHLY+fY + vZhT+90jmyyIIwzteq8tzt+NpQosmawJWLtn39EGsGDTKrMGh2VgmVm2VzEe/MYL+9x+tHns5FS0qrNX + 4KmarCWqpD2BxeuivzC+oQF9EPo88uhFxnok1KivDZsMogFdOEET1HAHbwoeTXniKfESRYvaMKnUJGx1 + VClJ7eewOlwca9lu0BY7uTK2hIv4yKXDrzzyhJiFoPVwIbiC+kiiFm0rxsEv3tdhwyWwoBWcipjaABbv + H8d98eKdLg4rhoTcE0Ob/cUrGs7TYpXa4DLIrysaWLibPR2WUCUwGVLvyN+gjscp8qvlK7Ms6mmz4bDY + v0eFCMRUZg2bLMVOKqeqBKxthyVUkWwMCV//R48MtBKqNmi1BBbjwTs/+/hwx66KNvd+6dLF/PXmXcYK + rdIKJarys/IdwOKe4S4NfxTro6hnDeXw8JBtuWG8ISfGtvQg6v/wo/8lHnfITp1dO3nUunnwKJBUKzuz + FJXMNaKKnt5/rV7Aqn/87LhQntMUKcMiZUez5FRjVoOXLgym92Pn4vk0aEXkKviiQKJoli3Ztj0RmjNT + KPaWe6BwvlCPa8cV5K5iWy4utFo6LGOLVbuAxTk8dnRMe6L1cPmj6EHtIfiu1adJNSpE8VT6U8eKf/L4 + of4AMB77/OYxcVXvuPTUR7/9nX/xtncP5ynxen/5Mw/f+tDBW++PeOtnLrGIfuXjF4m/9KEL1j/7gy+h + n/0PX5AYBiJoFbrr67/w8YNtYNlhaQAo+ohQqOYCVuopo+pNjz8bq751vDpTySFwWEATYGGyNDCEWfp0 + D2aBIb2z2wLBIlQll+3VmczaZ0gIpJb2CkiRrDJrtFcPhr3anm6vohdw99pYoeVngktgVVQpoZsYWLwQ + bn5AQ89XD4ouRueq1MjFZw7bx2KQAq5BN85HhKK+dc/syvRrbaikxv0EmxaJmaU8aSW9KIflstqs0arE + KHmZoMxNv/NJXn+7KMcnXBFdUy5uXEdesDhliVyVXxnFLyL7lOd65vRkdFgW78QmsOKHKk5OHz0OXbj2 + XeSk6svXXlBsD/tdbXJ+35VwWIVZJ4p6yHNSfsfxqsSsP9wDWG8896RpJWDprwilQNKdj4lZCFTFMDA5 + RYRZwGLV+yAOIYcleyUAQR8RisiivZViFcClUvr3z31rl8PSB5H66i4Bi1GbrBbMgj7DJrukgeEgaDUC + a/GwO5wiYrI2gFUdliK0MrNWaUWcvvqqTbefVLeyLe5GGas9560koSqTfLKHTpLAEqo+95dhiCh0UtGB + Nh0TUw1coGNylDA1NM0+G5sR4v/BOKol9b66B+98D4lKTkJ50MasyAutUAJrN60kSo2rpa5y3jjVXm2L + lD/+3IV/+RufwGSZ4vpHgH+Eo1lSn51MeDKk5sCK5626uGoUolFlCVUi0TawwJAIhYGqbFIyKNjUH1OW + bLIWwJoEp+yzAJN91p0PTcYqlN96vCewjCpipRUyqkQrRaEqmJVxtZciASvGd/nbFsKQAISxMoxUGSec + hNL5ey3i1d127dvbDku0sslCAtYrbj5jitqi2XJUKFQNtFplFtoeEhpV1kCrAVho+mvntFdnTrcP4l/0 + g+NTwFHnrdAue4XglKNEb8IisSt6B/1PRJOypTdsaihRB6SjuSYlfxA9NCHFyWAUGL3GqkIxt99fwaZO + K7FpSorJ6sCqpR9VotR4ZtlqJqYcn/DOAax/+66/eOTRixoSfurTn2V4TBR0QvH687oYUuLUosbMgk2K + VXBKUdjaBhacErDa3MHVY2LiSX//HL9TIkIFsPKnd8GTXJXq65DQ2Lrn0tWk1Ukkl67aXjWH9VAAi04e + MTmlzv+2ixep2QAWPGI8KFpVVAWPuiqnTCva0Fh63Z+vzy4hDkGDZpf6uE/SovllicgoXlf6RCWQd5fD + 4pQ0JKzM8hz8/sBCGhhWbJ05HtTslaaxth9rGIAlh7VKK1S9FcJbcW/suvF2CcRDkIFWkmi1yqzLnVZp + siKPLsmwo7OpiqFfR1VjU+T0o1wkp4tpLZH22D0RCgLSi+nCDJVe/399ksrouZuoir3NEuGp+bioP2xR + bFrVGrAocKdESo37Flkql1zkVYEnXicv8lfedq+GxDCLhLeTJODdURUnEMokKdaY5ZiEUsyrHE+HKjYp + 1zTWHnNYgaqT2XBPkHJMVB0TxabBXkGoqhmz2qiwf+VeBVZnFlH2BFQJWxiTbWDd9NWnTCtJPKq0qlK9 + WjLK00BvA1gAkRPjbBnM8hJMIlQ5pRrW6jUiuUg3/ui3v7PLYXG2QFPAQqBK0qjwuoCFGBgCqcqs0WSh + hcM6E1gaEppW0jatDKyPPhjfzLdrup3KXS+QVV985PDRw5jJWgKrCpQomlZ7is4i9Vx4mkk0oRuSAyl6 + bpWA9bFzFxNYoyOr+wnlUepaGKRVRhL1zpfa4bB6FGr0v7awZ6m0cs5rys8HQRWvk4hZNbCwV9HSnFLi + mJejMUvAWmWWtGTWdTosmawCrITU1XRYplVJKq3EqTmqklbhs8JkBa0KtlqvfqiPp7rJAlvUbAMLVAEd + AcickqAVEUhVbFFjWhEZTm4Aiw7DWcVT+4eTeAnAazYZ9/hh4qyhahANWMtOdgGLkSxDTpks68YcFqLx + QCsza2mvhCpFhoTE/YeE27QSqtA9Ke4Qz9IO+jdvfzc33lBp3f7uO545XTdZUsWWVddWPC00eTHHqkRJ + Y1D6hvisTJByF0bUaMhJV1VjJAxtCwC1nGN1VTwtdYbDoizj2aUQqiUqCaxzFy4bzJ5318BQwJLiHGy1 + Oq1mi3NsKdmJrSQXzKLZtsMSsOBU81mTvWrMmtRpZVRZYpZoRZJdN7GVtKqjQnsQY0smqzmsPYC1RJVl + Tv1EsVev/sgTotU+DuvuCwf3v/DCff17cgYlvzLRELh8G2oVq7aBxdDytfdchVmcm4HFOTM2vF5gIX9i + aGZVYA3YAlI/9c4LRHTmHJa1MR4cvBW0ym+POVmlEv8k6MOiod5iq4PDU0wW9NnA1lIil9HDToa4UwVb + jSYAiI5Dfzs9xUn9y9/4hDhl0ZcBWfbZyWFpw7qTZY2OAoZq3GbWDmD1Is5cH61UBmZ1DAlYes0Ai9cp + WslkHeZVyc2mDYNchpRjR1XLBSwlc2wNzNoGVn4l1uxjwWayUHorjweb8gFRc6pKhHIiAam7vvFCo1UC + i1iBpeGV7NWtDx38++e+9eq3vHc4T4lehHWCO8aTnRS5CPXT+Q0Kyg0sNjGtznRYAOvLu4El3Z8/oK88 + Gd0gZdGAgfaqxeBVMOrk9YIA/5wiwNKX4ewCFjVQaais0sCw0srAMqos0Yoj7g+sVVSJVvZWolXYq93T + 7TENchI9YnUtop6RBzcttEIPX7mqP9OpAk+KgwBTxki6lLsyeNEXQ1okWkmWhiEBi25bUaWOjPPIrtpa + Vh6tKhr0RHEA01IYGmIACyw0PrWixTYkFLVeLK0UE1j8k6KXKmBp3l3A4pxooJZxxB4zKbQayJWJUGVm + SRO5uC7JLFpuAuv0sZMJWHCKW6Ez65goSEmyV6qpqLIqqjwe9GBK5AJPg8+qo8Jth2X6iESiEngSoYZE + ipYfeeJVfxaPPoS9OhfPSW07rPiSr/KzGgKTcv04kHKJHEI5Iq4btLp4eroLWHd+9nEuhZiFz0KcoRwW + cZfDAknwdKi02ISBIZDadlhwiqiPCPd3WIO9qrSyvTKtYrp9x9Pt7JZ+zi3HPbbrnkSsgmjoi48cnn/s + CGAtmYUqqiT5sho3VLElGS4JlMlhCVgeDwpYg8PaplUVDBoWNwQfGrBURCgVMavnU9y3CFJOOoYoj1w6 + 1KS7XjOcglacij58nY4aGzZUeXMtilMh5wVeIZJCLmPrTGA9dnTMv3jcQ4PPErza8LA+0JASnmy1AFON + phXdUrSaTNYwJHwop7FMq6/E4rbDAj1IwLKfsgZs6QksZIcVzNrDYZlHgaTys4kClqWfxZ4W83na+NZp + bp7dwPrjz13gGn7oayd0fjELYHGq0GoDWPBo1/OuEhbMHxGaVuJUlWlF3AaWOEVcomqDVowH6eSrbOV+ + A0D6O2fu/LqKI6Ifyr9k4LpBK/8JNDehIbWPxKMzgVU1AAtaVWB5SKj+K+fRHVbQKjeZNt8QDBqi65cC + EaxqQ0L4UOOLLcGakjgmsBj3GVhI8+4IqwVK9GSDGsdWc1pVNUgNzKrkmjOLRSIbrk6mIG6OmJgPYMXA + cGAW771oNWFLzDK5FpNZjVZVdcZ9OYGFrmcOqw4JTauBWRYIYFU01jPuOZPFKOz1T149cw7LDJKEKtEq + IJV6+OQItEXsj/5jrEDVwcnzz8RV3wIWF/O+bwSz6PmYvjfe/W0xi9P+kd88R5vlVnpM9MyBYQXWK9/8 + 0BJbApZohVYvBbiRw6reilM1s+CUomg1ASvHg7umqLgg3FdyT/d+6RK3nwjF/Xn7u+/gsoCzuBsP448K + AZYEtoiqIY+78anvrnqubQ2QGrRkVnIhvvxSwBKtpAKs4Bq02t9hSfBI0clQqXxyWC8lrVzAiovyBBaF + l8eL9EvVkJD1vFXcHCOznO/QxCypIKxhS8pF2m84LHoXLiwegOjMWpKrYaurMatjC04Ns1qVVoPDIgFS + Jhd4ssPSL0psO6yf/Q9fEK1QZZP0U/ltyLQhx2FBq3BYnVaojQq/erTrEHJYA7DEKQFLlgpIIfAE6B0T + VVjaE309GWUXsPhHm6tKx4ZZ7/3Kd/T9zvisONv3HK8CC+GwpFXzIrHKQ8JVhzXQioPuclg3vT/wVCVU + WSv2qjss7qthh4h9cufTBlQpSlwKaKIIkrgsyIlyyyCriSnGHhT30QAsNAdWfAIGjPTglYAlqRfzJvIW + X9dgEA1gqpW1njMhQivO6uVxWEMBKyVS+CfFwPK8O4fmHxa/l9lwBqZ91Gi1RFjWqOdsAAtaaeQoq9Wx + NcFLzJJmzBK2lMyntD4dk9DxrbjClmhFFK0UJTilaJ3psEAVHRseefQnTr3y9q8qQbPxYKXVPfFtVrdc + OPtTwooqJeGhurESrSBUFdcwLmbSiitPOQNY+NNvvMBVglkAC5OlM+T8aTNshXBP0AoenTkwFKqsJa3M + rHB2a+wGfL/y8YsbwNJD7QLWxKx8WJTbe9gVtx//MFOv36GAaFLwiFsoqTTVFAlJ1yWRyxogtaqRWe2J + h+i5eiBJtFKinF6sB0evF1iDjCrYRC6JVlr1MjusZYEpiSyOwxvG60QwW/Puh4eHDA/9Dyb3d/0Tzf1F + 94g4MKvXsGpjSMjlfkZ/3MN171brurGVWjJLJoton1VpJc1otcccluyVkISZEqF+7He+6IiWtGrAOhef + EgKsfRzWZKnSVUXMASCoMq2S8mFR4885u7fVNadsA4veRZ+UyQJYDAwlXtQSWNTYYaGNgSEtX3HzAwOq + BmDZXgGsjTmsgVaVWaBK0cxCvK47P/s4eOK+IuqPh6nhNUoQTYJNNbJKwGIntGcr+gh7Y1wGUOCOebQ/ + xWy7hK0aB43ASjE0oXAmdFjRylFdGFTRv5a0qjZtuYhEIiUcUQnNyA0pIjVKvicOS4UbtycUTJZeLS/b + 8+6Qy8BCvNMaHlJi8xtSI1fnF2XDYamPxXVPgyDF0KaTC12MHwSbkUvvdGCLG2JOrs/PH38Xs8Jt5d/o + iFmIUeGHvnYSzMpf66rAOtNhyV4h2FSZVYHF2sasFLR63Z8f6ZmGXz/YC1hGlSyVUWVaNU7JUnEjof4W + qOwC1h9/7gLXMC5X9mFeuIAFPoi8RtoMWyE5LGu1jcQq0YrI1VillbTLYbGH+rGgZFpJoAq4mFzkFi+K + dzze9MSTcBYWzCrkoj1c4J9zDb70j/q/zD+8BVh0Y+4xY0jOaymtdUsnwtYw80WiG9gaaCV7BT44JXXY + yixqOGEa7LJXFVJC0iD2LFqJULRXDUBQjRLVvCwOi7tT/8uledHNm4XXyTvBy8ZYaVSIpRpowr2CIWKV + Nol9Xr+gVcQ9gBXfiKg/TtTVF7NwxSIXNcfTDFcn14mwJRlbQa7utpbY0h1sYCFoJWaJVgbWhsN6zbvu + xSuJVgOqTCvq1UAOK7D1kSfCTSSt9MeAG4f404OncVKyVw1P322z6Wmpnj84ff5ycmpCVbnytewCFu++ + vqzO9qo6rF+48zHaDFuhCqwzB4asBVKmVVyE9xwTgZQiBNfv4uwC1nJIaIEYIKXoRG4LMTx0rkUkZk3Y + SlQBFDotUKBTSLCA3mFsMezC6QAU0QcNnKpym6WEKicCluC1AqzjmPmlYPE4pSWtSBgq0mRJK6NqF7PE + I9WQk7iGhK1IZKzISYgvvcPitdVkNaqQ8+8GVwFygSTsFcBava35px5Hzbm1Ldm2x+sVZWNIqAZuLMZJ + Ml9SEC0MRU545RASFwa/AFa89zuwhRqzGBF0bFWfZWbZZJHv+gYlelF8Spi/kzowC1VmsUqckjQ3BAvg + wjaw5LAELOLEqdPGKV74hKpy3dCy7ALW5/7yYTbncnE1eMkClrH1Sx9amcOiBgYx1oNWimj7E0OaASmu + RrVXXL1qrzaAxY0Km279zKWl1bJAFbHCSzKttAppxIeEKiTEQId7v3TJnKqikm4CGOjDXCuhpxJql9Ry + VaKVmTUAC0xwPrJXmr3SiZlWSJ2XBtiraD+XiCNaKSKBSbkWBSlJq1TjVdVqvZwOa8EpxVo4otyvgaV5 + 91X90Ct+OK5O34n+N8QzRdnlsNg/nYd/8K9LjGgYt3KfYbVglrAlciGTawVbSS6PEMUsxoa4DIBF3AdY + Mb4rv+0sVZMlWiE4JcVcuxzWufY1DGcCi8GgvBUKVDEAjFmq4FSgau6qdJGXZdc/Refz91e4Vrx8XjW+ + 0sDi9F7/R48sgYUEKTMLk0Wy2lLiQIO9Ioa3SmaJVsBoeSnYJzcGp4HJooEEuWCT4qrEJkVuWt3k7uG8 + 2GEOi0XgIlho5GVUSdRQDziAyAAsbau4lJqp/aBVWukczJSYS0ljwQkIUpyMok6Jlrzj1V6ZUIZUZZb2 + rBwMuZmclMFEpSM1qmTt99NhqXBAOrzm3REI2LjtUJ3YUtEeHbdF2eWwEIe+AbEhZ/XY0TGOo40TD+fT + W3ZbfW5rYlZqYFb4rDRZN+awhKqlw6JnVoclk7U9JDx34fLF09NHT5+XsQpXVSzVPpxy2eWwABbbcpW4 + CMI0Mra2HZZkZp05MARSqw5LwEI/82v/iZ0j3lDEIqjSQ1hGlXMEm4hv//yBUQWhMFMwiIQujYAUUo70 + BQwyVpVZwgqeHaLR3qiStC3jMq4510rEEZK0bU2WUvsqU0/3p25UpEdMBZHD43hbOSiH5hxMKwOL24N3 + dmmvhCHkXYlTijVBYMiLakw0uUiINFCz77PDUoHicliK/IM23GqD+NcS6NBSm7NT7XeIq6LsclgvRpwz + V5m7jSifVbGFGrP612nNsMU/tvNZrXgyK03Wnzy1BazXvOteupwdVh0SWp7DssmCVsTX/XkbEm4wket8 + 7uAp8NRo1R+qkqsaruqZZcNhsYe4GvnaedUYE9Fqw2GZVpawtf2J4T94413gKS5FXjdyRY6iGkihqwq8 + OIHKpuqwkMkFmCqqoA8UoGvhPiqnJKzKweEpDSqtKrBi7WNHwgGxir2xOV6GNsKNecSl0x5WfZZaEgfF + PZkyrThtlNTANMW7piGqTsaoInIyjC24CRilDvZKe1DiSjegUjBa1hARje2qvBaRUP/9d1gqnIqARbIn + ULjXGT96d0o2okTZcFg3LIB1+bgBS2rYKlYrbg4xazE2FK3MLBwWwmiQn/mku7rfklnKVS9gSXZYdEiM + DIfYANZXHnmC+9YTVTJW9WLuXzYcFvsUsMws+SzOcMNh/fCbrlRUOV+2t3ibMJ4gSdfnNb/3vDhl2WpV + gSpF8EQ0qoCUR4Waq7orv5uBN9393L1dCfUHx6fgYwCWmcV9Qv8HTKsmi8g7wm1GM0FHuyI68WKVIVXF + rbg+155TV7xl+rNfjltRpTPBBuZocYVWoowWXaNFJV4rPNXohAbCFpH2VJKgHwiHRTk8PARYaNe8+y5B + t2q1tqOSl8lh6asg4p3IfwO56PoMUczSPSFgzZhFL02TZVoZWPTbDz99sj0kpCPRzcCQbBSiH8pViVM1 + oZmeaYgeeO5JcAAUMHcbwOLactEASireP+t6ywawuG5ck3oReO3X67AkKLYcGLIHhPlCmCxNZiGuDMzi + yohcNlz6xFCQ4gRIRKUqoUrYwlsJWPfk3+Lw7ps4oowSzfhwG9BmAlb/lFCg4TrAo+prqtgnpKhT7+KR + xAWsi1WVU5LuQzTQipOXt6q04tBmlowefRla1cGgcIPYD4vam3IStWER9NQaFlWplqIVYFLiRW3bgPWD + 4LA4ruaw0Kc+/dkzR4VV9Kv6uNaZ8WV1WPFmHDefJYcFttqo0N/9UIAVzCrA4t6twCLfAFaYgvwyrEj6 + ZJbwVKOTsFe5CQ5L9oqx56cPd/6xm4DFFbthV1XLBrCemQOLi6CXD09XgUWNHZZ9lhMEmEwoWgKpV775 + IeFJnCLKYS19FkeU4AtSX/3iI4eQBSqJVuKUIqI+3qxAzzXeYsZ06uoijqJYg3kBFrzS+y4eTswqwGIt + yKBzcuglsKgR9dhPHCjRYyppD0upjRpbRhVih4g7dtVbcVyiEtEKTtFomLrSPa/9xBkuaKVElZI5pdyQ + YpF6JYKX4w+Kw2KVJrBkssi5v5d36i7RkvZtV5uRsuGw6KI3plfqKfkEFuK6I89kIW6LYFb/Z22iVf7D + OPRVddczgcXQBi+gbiaTRVeUDClFSyYL4/D2zx9oyAmwdo06eV0CFpdOejFlFVgcQg5Ll0IXAW0DCw2E + qjl4UgKk7KScKHc0p7BRQByvZNbQOSUYQQ/nrQFMZpbFlbS9Ahn0+T/O31gxYhzjj5lzAgt8iFaOZg1r + uVvoh9BNWw1iz/gvTBZ3FDeS9mZ5PxYNllqnVf6RM+/yuQuXB1opcujwd0mrOhL0DS+JQdqhZCo5EYyU + KNe2WqSZXJVXufIHxWFRb2CRsEi57wvnr2v4hnXS3rfjLocFdDj0ntJ56oSVx1/zpGI8GHFGK91eS3s1 + dNTrAlb0tI8fiFZEup8ItUt65B1Hphl3cIA2Rp0DsJRsFzcbRNkeEnIdfAXkMTk3cMCwdwksavBNJtRS + 8lPx9Qy/80XlkrClaXXNSUkcCOjQvWGBIEV3lcg7sK7xjlRg6cNBUSztVYCAfmVzpCjKaL6c24BdCSW8 + 70IVIhdchBJ4hKere7CoCY+To0LtzTu0HvhGjEyR1g66kNI9yU6Q4MI+eac8GjWnlFCT81bRgQdaIe2k + Rte7zSDBqC4ibShaOWoVSQMW5/B9d1gUzsb9H5PVak9Pr2uECIy0lY60jJRdEARY7TxRZhFVGBbl/4kx + m5ORN5izjJjPkSat+h/xxBxWPuJQ7BUxmJXAMra4Uw0s7ngBi7uff7H3cVgYkMBWGQ+uClQp0gbG+TF3 + tP3gqIHluF3iovVkiBvAutyBJVrpIjBi5fR4jQIWEXFKHuUNkLIglKWXD6RABleJSPdTb4QIkEK4EXHo + 4fqz/CoDi8a0oaU45UcZqOGdkr3iTR+mn7wf2yJRQ0CpUr04wo1EY8Dk/VRx8o9cOtTUOzcSW0EoQ2qD + VkKVmIigieESo/6TE7yhzlaQMqrQx85dpBsM81YSexCnyE0oM6uKtZVTzo0qsWlIxCy2bcD6QXBYFM+7 + I86s1WbhrG6f/2T2hs4cG244rNYsSwNTqCXcQxGP/dtHOQZsxir/gidoFaji6tteTTPufTyIRCvuqgFY + lVbRi85yWPGMQpl0V//cJYDFeFAfEcICMWv7bwkrsPYvwzVXsmtI+Lm/DGD5IiAuwp0PPQURwDHnxvti + QsEgRn9IPKqcqhKqRChEf1N0QgQHvCn4Ji64xNuxC1j0c85QwEJClWgVb1PaKzbnHmC3OoS6uiJ7iJ6c + E0+IvQ0oQYPr4aKJfaJGFZVhdk6byeJ20h44AZOL6D1bPoSPIkzErX4cg1CduWmF9BI4E85n+ExQ0h7Y + leNQuUvmkRbp8mxVK4muVE78AXJYHN3AYoTVakuhfp/5cnqy5uA5mI7nqGTbYalZg1RLIgdSTR1VIf2Z + YaIqaJXGCoc1zF7FXXVtsldCFRpoZWAhAYvFbYelD7YAVgXTUvq2GYAVg8ePHwhYjAphFiOvXV8vY2Bd + V/HVHuIuhwWwDk5OAcfdFw7uevgIiVYM2Ri9agDLOcskMsT7kd88JyRVQkmiGM00u3dn/h0MnVD9sEo1 + 9EPeEQ6dH9VdI18CC4Gbh69c5f3iHxIRCplWYYTTXvEue7pdWFFE2BOuQP47p7tlRaxCuse45bho3Gke + XVZRQz1dmva6u1YJWEWDXbTiQM8cTg9SmFY+0Fceab85SONB7AFVMGmfVXWtSTQsLuV6cYqdKP8Bclis + 8qwQiVvWTciBER1puO8HgR5eSNtkLsq2w0JcglAmeffMaBXA6g6r26v4x1MfDsKpiHNvhUQrqTFrx3gQ + 0Qf2cVjDc1hLbMGp4Yux9FiD/y4HAawNh6WbVddtz+LGuphxPXNxFVi4Zv5hh1nQCk4hRoLQ6tb88X2Y + xdkiTlv+UcBCJFVC1QSs33sedwZT4IgtzyAq6Y3qzzRDA7DUY5GAJYfF+8IZ8tZwkgJW2qtr4Ix/qzTd + 7s0lcoB14dITDELZf5VrlBC54CRE5btGhVTK9dCTdYOZTYOEqiWthAz2AAiWtELUUM/Yk/dO/0hrE6uy + acCWtazkcEPixbpKnJKcN2BBgZeKVipxs5ZkiBulTmOLONqLpXL+wsPAZbj1B1WTVUU502EFrVY5NUOV + /mGM66sxIMJY1Xkryd6qomqXvZLDMrC2HRbAssPaHg/SpZXYYenBUeJtl+LvUYadSwCLS+3rtn/xJkpi + pu84vk5W+wRSvAX6fij6JD3581eu/enB06IVqrSKhzYSWLzYeAThXffyWuhLtIkGO9wl9QDrNz7xbS4m + /V/dTxypopJz4N8YGV7eLBrXBvRe2gAsVtFAb404JbEoYIEGOictaS+mVA37rPV17VCjNqviKNCEa8vt + x3E5PVGpogrtopVYw+bkolVFlfcPI3gTD/NZB6HEMq2cDLnEHpaLriSRao4A09BAlcSX3mG5xP26I+4q + nJOBpXl3WrcNs0EsZsLa7Q8QWev2TVmo3HBYMJIWEGqiVaKKRJyKd66MAbmm+kAQDbSqs+wzVKVEKwML + iVZItFLHOPtvCdNhqdOudt0quTANsmSy5LM2gAVQdPU2yrBW7VFcw+NjvAnUuy9/YURmiprHjuLvqB8+ + OQJVkoB160Ph/qCVfm+RCJhATwzxejemLxHxF3gcXotILS9pO8nLhFkQDZMFaKrxWYpd8U/OA9844v0a + gCWBIfr8KrCoQfddjD8PZD9qr1MlVtVVlhbdZn+xFWeF/eHOFLDilpszS4tIa5FRhXiD8AcDrbxz3qlA + Qf5Lg7TJUuxwSJaCMsvFGl2/S0IVEb0sDosSN+6OuFHqvHuMCnOTiLnWUQkNNnwWnW1CXhFl22HBrIaq + pJUtFUkQyrPsCSkNA42quGkWU+xnogrpg/xKK8RgjXimwxKwtmklh6Vm+vtnmKVvHL1p81dz6MC+bkOp + l1Qlrl5AKm4+3V7xO3qXwkOhBqmroS8/dfXcwVMIVBGhVQWWBKqogQV0JOOGBNGp7nnwSPNcvCKYpRku + SR+GwrI33h3Po3MNeRfUM7WTKirp+fQ3/UvDQMyr1HVRBVadxuL0ZK9Yxb9hHMJbqee/rOLM42+huSG7 + yYrbr3BKUj2ijbHCu+Z5q4FW1EArWtAm7n/9I92xYnlXTpbiNljWuFL5meIuqvFlcVi6dzdiLdSokB8e + tnl3/k3WNBa1LS6V81n026GbWfyrnvuf2ueeznBYAay5pYo3zAPA6amFhNT8o8DJVV2LOKIqn2hf/uVg + pZWZBa2iS5z59TL5nXyileKGNOkuYEnxieFX49GBYecSh+Aacsnin9p54SpBMsTFict1fKz7CfHGwaml + BKlPP32kqOTuCwdyWPddix+151Xj+G76ajzQwNiQK0MbjbPEDkROv8LOwAuABZh4Ubw09Mo/eEKJXybA + gmv3XLoKiSr4qtRFYzr88MTA4hBeywlw/lAJSkIojstbw3sEvFgcptu17fdAHIgTgzuc+S5gqRINtKKj + iVbalZmlS6F+Ilppk0G2aRvifhhqkCqJaPsXnqWBVsTvg8NybMV5JnZYyJURF1LZMFngbNoDry67GWXD + YR2dHOPKJk7ZT/VxnxScSmEWgFTj1LXdqNp0VaaVLBVRtNKznRvf/VId1q45rDrp3npyfvVo0Kr/LuEu + YCGApe8p1DVU4VYOo9QxhHtS7hooY7HoGtmoO8tXRKHLpyeMDeHXHzwxc1gw666H40P6ATTk1GD92BU8 + Aliakheqfvz9l1H8oFm+RvYTz68/9BTvAn6k7mcQO+T22OWweH8ZZAlYcEqq9mr5dLs310H3jJYrJe1w + EPVx2vkn90tmKReqTKuYnO1/XG1OaW/UyFvRZoNW2pV3uI8AzRCVbAtC0Wxg1vfUYY1lrbICi3+3o81u + UTa+8I9VcdzkVFOeyYbDomcKWEYVfippVR5eD8UIYumqKqRQs1QLVA20kqWSTCvibZ+Jn/zaABa91A5L + MptQRZVz9Wp9VogYGAIs+vywc+vfvP3dwZr83ArrxB2DNMQTiaqopDGDOA3xENaGGgzUl6/FX73Q89XN + 1CcRPeexk5P7r8Y36mCphCqNVYERwGJvbEVLd11ydsIpwQvayGQFhfuPM/rnFwUsxJ7ZP++RbQX7qZFK + jkIv5WXqKKqXJmB9rTFL0sMQggJt3J5ttTksoF5ovq5YE+Xa5yBOOxDTp96ROCUpVz23Lm30/VZswoaV + VkTOlgNFD9z0VuzKcU8BmiEn1mQf0VjM+l44rLOLmiVc6BWiFaNCTlGVu0TBAgx9zNITpOJUKqal2GrD + YcVbVVDVlU8qJKoYBs44de36UFUHgKYVVKqokreStr9drw4JkWBkSEmeilaiNjRmw3/6F4dyWL/8mYfZ + W93538i/juRCcRPjHRi4AQhxSqhylHWSgAuEglPQgfEdpomB3v1H8R3wl/vXYbs/I3I6D2tpLFoJoxIw + whmtAosOxvlwVgaWfZawxat71Z9dlIUM9j0Uz0zATfwax2UPOrqknEpe6SOXZg5LqzgBuijAYvQXkLK6 + varT7d6KHeYcU0PJquiHu6JEF81BX1y9un+LS+Gpd0moqrRC7Ip7m5ufU/J+BloxTqQBgcYc1OcwSHs7 + U9qDWDPEeEWZ7JLYtBT1L4vDur4CenqEL5wTqBKzYhrLayWVvkih8dDZLNxBAEsWt4uyAazLJ/ojG/3S + RHsEVBPqSANA0cqjv4FWgaqz5qosoUq0aq4qP9dXss+QkI5N56SXmlmVVnpGSTK5aKMurXn3m84d0ef/ + +x/9x4IU9pPr9tb7H6aHyyXBBQQ4JMAkWplTmoSS7skfMUOfPmy/HsT1ie//y2cgRQqLRQErBncPxRA1 + Xk5/UgwJWPQoWtKpJHIDK/5W+eMXzSxbLSRgsZObvho750qCUd644RNDTsOR3dKf1YFrvYDFex3Ayh8T + xGqRQyso9kx/up3GlrZigFxRsi0N64hyQzFnmvNTiCLQcG71KDoQq7ivaczmsnvcopL2nPuJW5+Lpk2I + 2pVeLNHPW8W/2R06L1IgxtGEqvn1qgELAnwfaCX6DDEu2XXMu1NoOfRkS0NCo0piqy1gcaH1JXwAK12V + aMWNLnETmFPEfVC1SisbKydEMcv2avupTgHrtfdcFbBgUAUWbDKnakQyWTIj7AG95l330tXp2zrinf3X + xpBoFWjoi2JWjAGv9fm7kxe+/ELDk2gFtgCWmMWFOjg5pesaBBadnM7GthyUo8MXvRY5LANrw2G9/fMH + sHVglh+JkAQs/gH4gydisp9/dVb5oqhurEWvErB4CRAKTknk+DXq6eqrLw0WazocqEm0R+cfK7E8hSDJ + HMkfmTjaz/IoiJowRwkaNUacknPhD17R23kh2oNepl8sDpGeQuc3ra6XWbX9cltYY0g52SXOc6hBVEoT + sL6nzAI3Q1TJXLQStlpllUrmlE99+rNDT7b07OhEqxjuxYYbc1jxE4QAy8aqTKtPtEIAC1rt/oJ2C04p + VmDRP8WsSisbK0XYcabDct8mQZ54tr0ytoYc/ex/+IJohejk6vOMsOStEH4EIgyRER99nhcekOI6vBCR + ReHJ9uqj3/6OaYUu55/FDYxQV8Gt0JKXKWBhi/yiPCSkX+0CFg6LEzablhKt0NsuXnzHpfCMcBZS6OiO + ddE1rhewePfZUJySwAp+HObq9OomiDNkLW2CRI8dffGRQ7YlAju2JbqGRRrMVMjFoenzEGc59+TDcSxu + bJqZUxaV3Pne3Nsqsi28o1vEKKTYqyV0qljrBrW96xUBjaLqTR9pWbMq8ctxxWF9L5g1AMgx5Wks9Owx + qClEo2Qbrm865fU/+EAMcKAeLblp2AUxxCvbdFjxz9FJTqszBuwz65L6XmhOKytolfaqzlsJVZVWQhWR + XipUWXBKE+2gKvKzfpcQ0IQryfEdUbRCZpP+imWQaCWZWcIWPRxMcFyBgFucvqpRGy8csvDqxKYlpP7k + qWOkXA6rAeuFF7ik7i0Wi+wcp8ZWAIWRKZAKYPWnLuyw6FoigqROSxcFdnJYnHOFlCVUiVYIhyWT9dh3 + j+uHetviiJwnHY/Oz/terZBwsOrXqORmo4FpZWu2Knk3ms341a0W++Eerh8IDIfj8nJj6ySrqEGs8j8Y + lVYSu41/19vjKTF4bMptlwr65Fo1E+OqIAvNHGnjGMl+nBq0Aqwbo9X1tqckZwqqFgJYclhETpGaOAar + MgpVRNXs+goH6MPahiquaUZ6DlttAQt71X/5pj6ykN7qOFB1bcdIsAtI0V0rsO7Jr0wRsxhtOdpeLbFF + 1INIZwJLfxhsewWDNlCFtNbMYjBoWiF6psQNrb4hOjAa4rIAIF4gr04Sm6QYRaZEKyRgITakB9Ixhp7G + nunVNNCL9ZAQZvGKsHtnAssOS8awoioq57TCXkGr9z379EcOn7n/6Pixo5WB4ao4IhckZgkOY1TInaCI + uLs4DZ3VsAm2i1uUlgKWLNWqBpaxKNvVmPVY+DiOJVJwzuy84kaH4wzBE0ekmVDF2QpYVNLVaeANHalh + h+pTBpYUXYYjKrGyZmgpxapOK8VGqxKVON9TQpWTLYc1wGjZZr5+j5KIYYANkoQtSlTOxWkZWG3evYsr + yzFDue32Mw20b8ZKzEpgseEGsEAVHcyuihtFCZwin2g1t1cTsHBYax8LilaKEl1R0ZwaJGwBrI0foYBl + EAeJPqYVWnLKCVsZVUBKI0F1fjqw0eD+QA3/gHNZ8FlilrElWmGRDCwxS9iCWWzyzOn4vU7aP7vF5tCG + lwlW2niwAwudOSTEYXGVYJNo5WhaCVWS7JWAJZN17uApnYxPbFU0oLdzTx70p8+4E+I+KcO0ZXvBAtYI + WAOYOHnnXnQDEsnAin8wOFz/+eV6OIlKT71LOgHueSo5Sc5qoBWRSg5NP4I49OUKoBuWkCQqmU2uuV7Z + WBlbOx3WkPSomhIj7F2SMlw+rpc+Qu51UcgkzbtDK2ErDlFR1bfZeMyd8WBsGMCavJW0DSyM1WMMCecj + wUCVvBWa2ytpApaY1aexIFRlloBFl1Y0s/6k/3jqkl8f/fZ3KrB4vfosD/3Mr/0noWeQmbVLP/XOC6Dq + F+58zLRiYHXXwzFsoacJDeoGFpW8X6CH6yNmARo0YKuKei4Xm9CR2GHdJzk75FhcOlpir276anxeCaQ8 + JGTxTGABWc682isloIoESCki2SsJYN137ehLJ89cPj3ZZ2DIETlVOv/ByfP4Mk1uIuwVHOFMaODGOlXu + cG4zkMGdI2AhTBZXuKKKnBovKndEBhZib4fHs19grqKGfxXokiDDzEL0lLoJiSPiddUOSGFBUqmLNa9F + lfTKGbD6ABAJVdcFLOPJuZk1A5bLoibwZMXaCLO4Z+EV6l8J3XZcZUbXvBi9eEq8/vm8O1dBVyTULxn3 + BF3XPXmQHmiI8WA3VmbW4fanhKfH9LGDrotdUIyIX6iKKec+61yl0ZCxNZALSEEoInmFFxFCKRG5NEHz + z3/5X3NinDOE0sd5SN07Zq/61xiYVo6vvP2rRM/BIxblyKBVBZbQ8Pkr19SBubmHLqEarnmMjHJsyGtc + YksvkIRVXBkuGjsc9qZFjoKhoxkv0+PB6rBYpBKO06u5T3xW2pb9ADIgW+ewSDTFHjW77ZX02eNnHz45 + urz7+SaLtQGs4wDWo8cn8ReRR8e4Le5DsXhoj77yyBPceyAGCTeVWVVm05BLFViwDwDJ060elEqOy1mZ + Vuo4bl9pRaSSVeDsJREo4WgzZnWxylHJ/jKtXBPAalDaWWa0CiV6aty3JGv0NuvC6VJyQ3DtuDU5Idog + TWNJh/zLUgoIow/v8laI7n2Y22gwKE6FzhoSQkD2/JKIQ/CK6MwCln7V2fCSwBYCT+QBqW/Gg0LmFD2Q + vgRQkFwD0RK2NP1UgSVCIT3wLWluC2Bp8Aiq2ER70P7p8ByUERZ2gPdCdPC740g9a/kHBn+B1WrUnvOa + RSpxpvQ3zt+7ksi1H1Zhr3jJvC4o89qvXPmnf3EIqjhbfYYAs3iZjPg2HBaQlcOiJXQjClXSElhmFrRC + 9x8d8+8T5+nXuCpWCVg0BlViVvxQ49q36+mlqetqFgkXhoJZHVuhmueUfF2clM0ELOGPrsELXz1bKrnl + aMChoRVoAJr0Ob0L5pQioj2Rl6DFZbJauZqwTzo1fbMCi77sONTQO5UoV7KnzgTWBKkWkzzLeHYRb8o4 + XC8Y6XIjXjzXlwb0Cpks6b4vnGcAePu77wAEG6hCQCf/XjeeYDCwbK/QhsN6aYXLu/+FgBTuo2KLqGRi + Vg4G6XtC1VKClEVnhjV0bEFHYpF6mZRJ+XCWCIVkrOSwXv9Hj2hDAwtBB/UHvUF6X5R4kVW8TfQN3iPa + 4xrimaynrpKw7T0PHuGqeBP1hnor5dqcd5wNuQhBq3MxGOS0RSuhVq8FBu0CFruinovGmSPRCvDVhxgG + VJlWdliMCr98cg308Fp0eqtiFa83HNbp8499N5hFFDjUYLiNuSys5ZYTsBDmyNhS5HIFjIytXSxLVCEs + jHb1zHFAgfNZnrDOky7NyQUgorc2YKmxznCI3s8y2V5bEyRggYhdzHKUai5ho4DXkl/U7+mwIBQheLQU + pca9inBVHNZSevHckVxlAQurRc/fhpRFMz17xbvVaTVhCzGc2XBYL604bYZFjHokjZtEK0NKH3Lt4hQS + oZwAF1EG6HCv3H0hnodkrXqsxolEJeKaBJ4GwS8iq6rJ4nzgjt4gMcK3Zo2sksh51+gniKSuUktv4g2J + nLYGg5w2p2pvJW+IwmTlb5Hx6vB97Nn7VMJOqOcyilYSV2AJrGH2ysySyYJZ0IexnmwIu12KgzZgnTzP + KDLanz7PXSTM6VUj3b1Eehdrw5HlxLywhSet8BK5nG9LLbU5+6w9yCcpUQkuaSBkVGCpcT1bxZpYQ4Na + uVrD/gUs0SqU3DGnJNegVWOlyrrKqHLSgEWjsYhNToooy7hVcloqIq+pO6zly/Yir5+rLG8FsDBW+wDr + h17xw9CKQwStOrCMKut77LCCUPlt5RLuA05F/OzjRFijKHIpt4QqBFZMBF0f9a7PX4lOS6+u/RbR1UU3 + q6IKiVZIOFObxqyHnuIfdt4j9s9ROFaVju7TkGgmuabKLWnASxCtOGfOU2wVrf7unV+T9Cy+TBbnY2Bp + D4rsk3pOVa9X+5HDErPe9PizoKrSClQNDkuCQZisjYEhlQ1Ypw1YtAcinJXb+77VoIwGAtxBn/NCNlyr + EpWEsJrgrYhuBrDAEIlvhipOgI5DV6MN1NhwWMNi3dtqPUltM9SwfwFr1WEZUhKoQUOleGRUabFG1+9w + WImhKVkoL8oUt4popSSBxZuqe66+cr34mnzuLxuwwNDG/LoEgy5cyuffxCkBi/sm8+8xsMArJwyweKUw + yBKkEN3VER4pVrEK0c3uu3ZED+eGUF+1dAFxQwALq0JjeulbPhNTQnRg0CMZWJKBJVQxMKzAQmbW/Vfi + 283pqBxoODTHHXKiNFQ6aif0HMZxDI05W07ydX9+pJHgT370KQhlWglYr8qfI+NkePncDD4NJewWYNmj + NX3lioAFrZDslZglWlVgmVmYLDB0uHtgSCXXQSNBAYtbSB5naIk07R2o6pqA5Qn77rwk6KO4VEUVopkm + pyjV3ylK5DqHAVhDy7p4ZlSyUcP+Zw4reaQomThe5Zoq15MMtHLyfXBYXFD5BV6nVS+EEjjlaaxX7v7S + K1bpkStkV1VNVqXVywQsEUpfVf6vbnkL5yMzRVTSXFWJUIkoMFEjqXfd+c1jRWCER8Pkq5cO4qIBLBwc + /VbS3ujkSMBywl1rKolWihJo8NrGrPwI78tPXSUxtnRQv1+6UxVX5a3YA/uRH2T/UIYjapYNb2V7Bar+ + 5n/8uoAlk0Xjux48qrtCr37Le4lc2Aqsn/tKzNyLWQIWF/PfP/ctaQksOyzNZOGe8ET1lUo69AAscres + L5aLDPj4ZzI4RTNNeBlYCS+whcJ/5ZhxqV3wYpUi4lbnnxOfgE9DNXJ59FsDa2j5UsW6ODgsgQm+kBhD + klcNUrPKKSKVA7MmhzVDltikxItFlBq3imnVo14YXpeuyMXlgvL2676vF4JVnsZaIgZAUAkaOO3Y4UAr + 570GVJFEzMdNwZyeFdg/SuSAyaJGhII+dCHNJYtTQlWNBhaLRKikr0MgEaGk2y592/k9T8czELpKREuL + n346gEWDgF0+EiFmBQQ/+7jIRSJmASO2ErAGhyWZWb/xifiVUPbGzvWXd5w22/Ie8b4s5bdsEO2Nqvuv + 5lcy6JcjklYVVQhU/Z3ffVgOS8zyNBaHXir2lo+bvvpzV6QBWLd869jMWgJrYJYGhlCgXmSLlw9raCNg + wfGhgcTm/HMoVKmx2jcls6yY5OqK+3OOrVXRzyMGEaIHDUe3OFvZq+iqxzG6Hxq8HLKtCwOl2B2WcIOo + UaXY5BoljpYINVR2hxVYmhexyclcKkq8uLOIViqdWS4cgDPjBYtfiNsRh0Uie+V59woIWKb9xGVKGLXB + ICreylGJxd2pmVFNN1DDPUSbuJMyHhCz/rGT+Aj/3MFTnB6mj7Pi6ERy7gzqgRTSD1VZrEJKVCM2WXQY + 4p/MnxEHVfQxJaqhgf7YWA98WV/Lh85ZFU9slo8arTseaL/KB3oAECdsHqHKKQRBlLgBZGHDAF9iC7cF + dHiZuvt5gyCRHbHFIvWspQ2Hpn1sdSU+D2VXMlZBq0TVj7//smkFqiwWBSza0JgzYVu9RtE5Xmw+D1Fp + hcOSyfr5x54Vs3794Kg6rD/89nd2AeuBk6Mvn1wDLuGz0iJZLCLuB9bSRnLLoTGVFVVLsTZvrRm2glYl + Vs1o1StlYaLT5c0/U1iqYnNay6wfWhapE+0Zh0JlKA/q45pWFTRIlY6qGaIle1VrpB0OiwKJapyLUuNW + idfTYxY51Sj5aoeiluyWMxawJBbjNZRfGyQDUl3x1ImUeOomi8s3MWuazGprYVZZ9NqgVT7HDI8gKTC6 + 7wvnJXIJBilSWWMlFJvfk19e7ij5uXAhSWyyRKvKLH3CSM//dHlcc9ph/+QR3fVw+9JxMUsOiygAmUeS + gTVIa9nkLZ+Jh8LghcglZAheCOeFoBLOQtRmMQiVz/rTkpN5b/6KH7saaAWPhCrYhLeSvbLJot6jQrzY + L+djVtqJJulAkmkFp37q3JMGFnr9k1cFrCWz4NRHM9537YhEtJLJEomElSpVqgGxtnRjJaqpawfF2JD2 + 3WpdjhsylLdrqlNJav2/J4Oah2pRavmsWdJtWjstds0aeJ/Om1yob1mvjwY6HCTihIuHklhEA628yg1c + aS0rb9BhIZ2o41bptJpa9ppIrMUiNgooCFhx6YHURKh1wR3FENeu541KaZrin7KCJ6QJUQiFLlx6QpBC + lVAIDA1RnNIieELqzPcfHSOYYi1pJYlKEpAaaCWpZXsw4umTaZ/5ZS8CVpN/P1nY6iaLSIfHahFNK0Ug + YlRpkEhklTBhDfwKB9fdnI4VB80fbVYDUZIN2ZU4JYlEu2ilRTNLw0a2elV//F0yqn76wSvQiohYxF7J + YYlZjAoNLDks0aoxK1Flk8X7BWsk4OKIKq2qvKqqrlIyAatwcDJZwlb8icWMXPwbHDdwgkBxUHTDxpog + y7B2qcaUhWp97FD7dN7lljWuqIzyLEHKSV2r3BFTQpQOD+MBelcq3qDDkiiKO0tyxy11ZZVHybXCU2B7 + jO0PdOywZKmoP4xkslQWGIq3mdjHiXrLQ1rsAlIQ6vH8OLkSalvGkyQ8xWOT1467XghU9T/QkQ8Kxd+v + NFoRV2llDbTSI6axITxKWoXJyii1Q5hc/SkKcURjQ/AhghhYlmmF9Hypchkia4CX9qNkKe1ZG4Kbn+u/ + xGVaVVQNtELCWWWWPk+URCs4ZVRZAha0sskyswCWZGYhmGVswayJPryVcwZRIwDtr2nbueeaMeu0MIu7 + dD7GbDc2NzMgIAETCSYTKuKUR9JX9Q/sso0aRN4rB6l+19pVrW8CgxSVuDJlbA1KNkUiJPX6oJWZpXoa + zBzWjFlCjBIvFlFq3Fk6s/oFbWXaqhCKMsXyBzrQgVwYks+iAWrv6EIgKWOirc/Hc0PIRolQ2u3+YuAD + oQJPjVDtLwr1B9KBqvIXKgIWOOtjt+CUmVWBtQtbUjwNn18yJW8VeBIE+5e3yNChGJ0xFsuhWfNZ3WTJ + 7+xilmkFWfBWCGbJDVnGVpWQxIZKFC1tCKeMKiAlQaK/965vGFUDrSQB60c/coDELPRj934TYK2iColW + ZtaqwyKaVgOw7LMqcRwlQe16tcSWmRXYiumwgNdsbIgAlhS3cdzJuufPEIDovUMCGYovo+DLUIMad0IF + Q4Vopd5I6pUzWtlhsXa3w1KJS7BCK6mRpcehRKU9VN/EUk3GoJUWG4kEr/797hKUoTLfvFgbMfmVSnIl + m1wfb/lxPuryxJM3TCg2BE8PX82/IIvZ9yY4xW3nr3Po9iqkwSAEEbM6sMSswBb02YdZbjBDVeeU+BiH + YzG/MaIxKz+mHJnV57MMLDHLD5eaWXJYlTUkkMIRCW3L3Iv6dvlVVFkGk7E1MEvAMrMQtBKzBKxVbFVg + IYCFbrv27VWTBapWTZaYpbfSi4q0IXrRcv3qIloySxqwZYXDyps87+0Elu75Hrt25QulG2ryInuriElR + P9RcnzqMQsOqptIglWxa1ohZ4aoUxazdDosSL6zEuYSYIa6UBqP1q6kGwaypUi2DYrw8Aws1MLllsskK + SOWXWohQHk4OGNolWgI1NoyZrKv5vMzJ8/HrCflBoWRgoU4rcSoIEhDp40F037U2GOwOa4VWu6RmS1R1 + ODrJ7xRM0ydmITEL3fVwPHQqYKGlzxK2KrN+odsrolhjAQsiDCIxjByHGklfEVE5JTxJFVtVRtUPfehx + NNBK2sdhGVigCmaZVoPDMrOELZhVfZYSrrNjJMVzIeFJ2xpVA7PYRLTaxawYGy6ZNY0N251P7N2kdwHH + moTI540t0WoPmTLKV1dpoh2mPHnluSefvDLVh7qfUq5EVBqwNSwuHBaVxAYscarGqcTLy7gmUcZxo3iT + FUG01LKeKOhInHpUdsW/P2cRytuurjKh4uMbzSPUmfiOqpiSn9srUOXvI634MK2QKCOJVpVZGxKnjCrt + rR+lfaGg9DX9fg/HvRLYErM0MARY7UPDnAgfmGVgoaXPkl0yd7bl74dA4GmIA62ciE1OLDilCKoUDawq + gEUcgCVVYGlUaGZpSChVZt37wgsVWPBlZrVkjsSsgirza09pWwi1i1n2WZVcGhs2bJ1Gv2ix8ii7z/s+ + +MH3feAD1gc++EFClKifrUJtw7l+/4472qrjkytXnnvgS+e/1KW8xmTQRC6S973vA695zWvAlmrem4vK + g0GROCaVnLumyJACWyTJr4ibDosyf0lVwtAQN4q2Wkio0qXvb0DROO9+EoQiqYSSlniSjCckQrF5/JVD + zMSjeCYrJE7Fx4j5V2Chnd6qMYubLwmStAqaVIfVaDUzWbZaOyGFtKH3oz3rQEgnYImb8lkCVhyRA2kC + vv6hdfn8btVnrQILvigZJPQsZUu1q83SW8lPSQOtNoC1MR40sKrJss8yqhCoGpglh2VsARcpiNOZ5RpX + bmhq2TdElVbIwBKzqtvizlQUsGbMyihRoMPNN9/85ltvveWWWxRvufXWN8f/elEla2+5JbeIEpvn9oS7 + 776bndDgynPPfen8efKNwlZV0Of1r3/Dm998S+PG8fH73vc+molKtcw4NYfUqhJVUdTxz3JYlH5RltLr + dNxZpimqudJDzeJCuKddJNpHQA1CsRMIFZ8VJpjyvW8z8eUDRDmsZrJiSJhaAgtaVWp0WkU0ZVADViow + VGi1KjfW5gOnUB49fyBDPz1dvnVeR4dWNllmlp/PqsxaWq3KLAFLY0AEO5RI4KbGKtcjOSyptkFQiShC + WQO5TKtVVFkDs/xkg5lVTRa0UhywJWZZZlYF1oYCRlz/eY0JNaDKGoC1gq2TiVlVwlajVek10OFLDz4o + S9Wkks6LEvGDHzx//nzvjxGdKLL2F7Ncee4aNqqBibUlsh8aRF70mc+cozFRyEACVi4GpIj/8ffv+PCH + PzyhSnFdlEhkrHoSzLpxh4VUlHhxu3jbuasys1IknWIwdWDQoGqgkAjFVrw2wShGjql8s9NPiVA9yU9n + WpIOa/a8u02WsSV71UjBzdfJwl0brBkea0BpsoykVUghbYW8Qx0i+dgeuO/nMCU0AFtqH5tXkzVn1uCz + jK0KLOQP+AyspcCNImJI6FjbSLWSHBIRlYhQ5pQINagCCzy96s8uVmZVVEGoJa0kA8szWRVVeCvphoEl + 6JCITaLVLk4N0railaKBRYRW1WpJE7CyjzRyCVjnz4+Wyq5KzuuWWz517710sd4ZV5j19a9//ZOfupfk + 4OCAfRKjRS8QQYcQlUKqfPMtOKypso8QQYho9clPfopFmAV9VCkSBbYkLU4Ss9pkFjlJc1i5fUgJ5ehk + ki7HquIFlEhxMitJ9Frq5l2dWUJVFy/MMJIGwwWhwkA98WS8MK5C7kFRyaR4d2NunjgBK2IIQiWzNCoU + s9Jk5dS7aSVGzJjV+SLWmDtSRZLINag21n60W3MKaA7Kk4kv/OR86mloJ+Gw+sNZApaYNcxniVzyWW/t + v0X6y/ldpgaWmGVyrSJMSII4jktVbAlPqxpQNQwGzSlJT40iJUBKccksAUvMssMasAWnxKz7e1wyy3DZ + llp6K4tKUcxtBplWkgeGGWNgWLGFElvtPkfg4OZf/VVBKvCk8WDnlMqbb2n8+vqjj0avlHp57rnniImt + xi+c1Llz53LlVKjEZJHQPSMen2j8GPNfpVSH9clPfpL8rW99qxYpASNhR0mDlNUIxf+AFFE5ccVhEYNT + PVZ8DFJR4sVlma3SBcroDXeKdyLn3e/7wvlKKCQPFSecGPLbZplNPTZaxTudbJozK2LQSj4rk3RYsw8K + O7Nms0iChWX6SEJSJZRU22hD721AVT+ZFn0+FZ0elmqHcYgFsKoGZslkiVbEeDizA2sQxFHckBr8+Psv + u+VyExNq4JQ0oGqVVlXgSbHKwBKz5LBksjT7bloNJgtaCViKJs4qZazVtRuVyx0CKcUqOywrbtfCrLzV + I0KE226//X0fDF/zzttvZ/R3x3veQw6eckQYQ8I77rjj5ptvJm++KbphwxaVkCgGjKX81m/9Fpu0hSz4 + L/ZJpN9RFN/whjdQyR7ojdFt5w5LtOK4V65coV6GixJgStoUTlVRZoti1rrDokzMMj52iKJIceIyqym0 + Umlr85KpnpomuJMJ7mkgFC1blNx+qklI5aqJWVKyiSTectEqEjmsqOnAks9qqJJEK9srbi8lIo4kAAkc + 26pbsRMAJE4hjitCDVK9ZtbksIiVWdqzR4WVWehPD542vMwsOSwBS9ID5QjQCF7Vc4k+SwYhrRWqEJv8 + 3HsvkSgiMFRjpZUgVbWkFVRa0goNqEJAStHAkgDW6jTWAKxqsuLPzoFLRt7xgTLXJW+7aydLWtlnbTBL + AgoPPHiem5/k/IMPHgeLTj/1qRiIQa6Dy5eFJPh1JZ3UVKLfnT537RqraHz3xz7W6nMaHhi1hSzvfOc7 + qYnel52OAgfZihLAolLM6vUf/vCHiUmr52LVjiL+NM05VeONOqxSSamxFtfMVolWnU0tmlZem2LVtNaV + vT6kvNaIUBVSc1opxjstWgWnlEyccmyA6EpmtQlvoUqq6BE1FJeqzZA2N6p0FLHJSoaG6mnoTEwrn4MP + VAeGA7bELIaHekprMFmv7d+wXjUAax/p6668ob9PRoJH0KriSTKkqiqwlqqcqjKtKrDqTJaZZYdVmWVN + zHoRqDpT4ElxVUtsiVaSgfWlBx9U8vvveQ/S2PChR78uElFi0v3BB6OLrZbTU6wZcNHYkHJwcJmtbLs0 + qwUEtUiR4cKFEduQkD6YUUNCym233RY1izJjDjyqsalxqsbrcVgU50UURcquxIuUWjOL8IiSSGqVhlSs + aDXEUDaLlj1ZUbZMVGXstJoxq9HKaBCqIhE7NPVuTCAxYoCFkXGmvC1KTjVU9ePG+UT0ufWxqk5D56Mz + 8a7K/uOZrIotMyuw1cmlr7iRwwJY+prTN+a3IIhZ8lkDvEAPsXJnVWJTA9ZcP/nRpyS1PJNWRtVP5x85 + D6hCA6QsIKW4ZNaqybrvWsxhSRVVxKBVUaXMIMiymp8pNXYcFLTiTRezuD/Lgw5VoAGH9Yl7w1K9/g1v + eOtv//aHP/axL50/j+gLQOe2NEfJkLRRvXM19YIXa1kWLBW8o+MpXxouAY594rBa7cnJuXPncHNUfvju + u6MbGh29VNqYORTyxNTAKSnK3g5LiRe7KDXW4ppdqxxnLfPyKeFCt8gqxUxmsbdZCjDRJoHVOdVz3mDF + UKChMus07olI7LAmZskNeWCoaBVwTKoNkDlF1G7Fozh6O5lCq7IWVVoJVexwOJw4VWO1WoGt4rMqs27N + X9zSN7dYItcv5O/xLCXuIOWKlVDxmWNZ1FYACxjRck9aSZVT+t4r5KRqSStkWlVgVWaFvUps2WQJWLNR + YQFWvI+nzyNTRokXl5XEYXGIq4JTirz7u0wWgg4A6/+9fPDeD34Aq0VOhBfUf4kccj34IPYKxTx69qaI + Cw2z7HJVVFKUtBVZcFgUElYJWLT/rd/6LRYFLGqSGVEmhiyKyRNgikhZxij7OSyK40JxKjsiZVikLBs0 + 6ZJpVbImomoyKlHLljhfKleBJ+WVVo6VCy2GJkcjRhABhEmBYI3Q43imxBehSpzS/lE/7sopaa2aIW2l + c9AOtWfiKrOsT+dfYqPKLJksaIWglYEVzPrKFVktMYso1pwpUwnpr6Al1f/svc95LYJKYMvRAk+KG7Sq + qBqwBZ6cVK0yawas8gSpTJYcVmNWF3CRRCuxRjHemqRMLOrbr7pagzmbar4h0ypMVmEWilvl9OT8ozE0 + E61ItksbFapP9U6nhFU0+NS98VhDqz85YcQHfSj4KdUsC1sBLD16Sku4xiJ5MiPQoZjz7nuVgJNjJE0j + sChKQNWezFJRsoyUXauIVVHTr1FdbFE1uaj2LckLHfkgNSiLE61SAYjKiFC8950RkYgpwoRIkcRpPksA + QpVKziU10Cbej+gj+eiz05vqZbLs9aZzMLBQoVX7uFDYWkrYim8WTGDJZOkXsSqzgJQiLBC2rotZghSb + OCL9nJcEuUDSmZxCy8Hgzz/4nAnFSZpQotKSU0iossSsAVioOaxrE61A1UArxGUHNPHup8MCKLu4gxMf + am5AQavFY1lClYH1/9wf9ocEYL3p1lt0zx+etgcOSl8IslApPM1EOT39wAc/SIOYw+o1BAaJVFKGZ7Jq + YS2EogFRU2CawyJJZiQ6jo/f/OY375rSUgk+RQxQLSJlAawaZ0WHJO5QnNM8V6mLy1Uz9WtEHjGvoyqj + pjdw45ZkrpYbggKKDQqmVZ3JWpgsybCw4EXFVty7ma8qNonnuSLxPvuB2jnoNOLEUrFKJ9MGp7PjSqKV + 4gJbVcBrUjVZAEtfJ/+OS8GsNz3+7OCz0Bvz9/7stpC+jsoyg1hFBEzK0ev+PH4klRolUt1EAlLECqkq + gMUmplW1VwOtKqpqbg3AWjILWtlniVbCVqUVbBKtrGCW3pQBNP2nKCLpbovc9WdKnApgFXvVmdVopfh7 + 77nj//jVm0nu/OAHXveLvwiz0JtvueX//NWboYby0K23sng+Z7WyS/WSPQjdcuutN998c+SqTFpRI4dF + ogHgsghYbSGLHFZb6IWdbABLtFIiPJXYyk6HNStAocaFKMMipSZDpWMTNCmVXKkW8yJONW45RCXOl/Ja + PUbfaRUq7AhGJCaMFUu8sLg7IZHmyyub4l/UDpRoOeeU9jwdTudQY6o2GI6ee47o3nIGrehjkYhWkXhg + eM/TRxVYyMBaYqv6LPARSalZSpACdorUrDILHjmuYgtC0RhmiVbyVqbVwKNtmVaVWUtgeRpLqFoCSzK2 + oBWxISaZJSSJSmJNrWzqpkmxtpwWB+VWBViNWdL//oY3wCwBixyfJf3ft78TarzvA5ETf/+OO97627/9 + +MEBVoseEUhqivy5a9cm7iStGCEGp371V2Om6tFHk1q/yLgvGszLmcCCHJqbx3kFRnYUMSvRtEIryvU7 + LMU9pLKsdGwSUDpWuFIRs0bNhhpdymjsDeOKdzApGVTqIYKi6WBGOEEihQaGVt5tyY4yFSU8oUSYHo5v + q7yhd4t86FCnVZySV9Gse71+XB+rHc60MrPaX0H3OX4BK5IcwnRmte/qErD+5Knj9z0bzBKwPCrcySwL + 7jjZIXGKaNW1YEjYgkpLTkEoiVyoEq3gFAdVhEGK+5NrCSwzy9gyswJVR8cbzNJbgDQqrBKVIimscb0W + Z7EmJYdERO0nck26xweFjVPcJ8TPPRjjvq9dPmCReP7Rr8f9E5+MnzyQq0iiC5ycfOhjd0Ochx7lH9bW + faIrJa2In7r3XhrHQ/D51Ht77vTWWz1CZMSHyYrKW24ZHjGlcgCW5rOItFR55zuDnqAvGLKjgKSWRb7C + rBmwKq2m7VTyBU+JtaxJUYbEi5RlvdTYlEyZoutpI1qVxdpeyYbMiMhJMjdEghGdFIaF1anB/eR8ofZn + Pe3ve5D3ljfQdAJKOPk4sfJRZjuBYvS8c6EKZkUnyaGo2IRqrsUqapbA+kj+cswArDowHJjVCLUUACqJ + 8XTTufBWSqRf+vJVAwuZWQIWuSJsEqeUKwatur1C0EdxTwlSTpbAsskSs4StXbTikipKmsnSwJDbo4HJ + 6FGuMZ0W+/jOlYpsaDZN9YVcXmXF3MXp8b+99RbEPaOkykNCgUYFZl25dq3de63XRCcCKKyiP0EZElpW + t5UPNkSRdaJUqzU17gXM6eNCF/Z5xx13JDBaCXqsFcBUYy0BLKqrolGLZY/aO3E1WZPKUIlcpprstDXP + taJVw1DUKPJfZ9OQKB+VG9ZF0EBSwUEEEIqSWCNkbCjY1DTzYsjfA9GO0o+l05iSuQJVplVOYM2BFTE6 + SZ/yJ65CyvIqMwta0RuhlR2WmWVyga3VKS2Ta0i8Fird9NVAFTnxlgvKG7xWmVVlZlWJVgaWx4OKEmfr + XDKhak3VLmZNDquoAkvyFUa8KQKWFHBZYxYRJIk1rm+LnUqKrGqLiaTebOatkHIcluwV40HrQ3ffTf0D + 589jsqQvZU6EX/GQp/qFOlT2qdtuf2cA5eTkU5/6FB5q13QVBas1/MkOtMJDtYU9SpKj4GWPsg6sWFHi + rOgAfoWZDDVD2VVPqasiBzcumQeqsnBZRaIWy7YtyVW7FO/KQhMjAErHivjSJKdTALSPps1ztz5EHLET + qoq1vIR2Gj4B3Yt9n4VWbdRJ9NP2tdsMyjZt8PjwyZEdFh1SwLLDGoAFZRShFSAQiaTKpl0SoZJ0R+xE + zCIKWzCLuIotE6rmlVaK7Af6cCCiOFXjrx/EWnhUo1RzNADLzPKoUDNZmnofPivkklZm2WFJQZwGHZgS + tqsRx6O5nghMtWYfJaryH7YdOszPu53ng9PRWfJmO7ny3HNejPswe5AWx0IPeqlLAqMl+xQgVWMbEqrE + cFFJRhU93BBFr1DKozpXopohUlYrKVONrlrPI8soZhG5rNGmxJaw1tGVi9iUzVBiotOkw6Ihg/e4E0cA + qhgyRGrloNiP1A7UDqpXMWh2aMW8yXwU26tk1oSt6CQdW8qJ7jC92USrGBWexI/BAKzPHj+7BNaGyVJS + kbQtQeotnzk2qkSrXBux0moAVk0MLEXZK/aAw4J60EcSpxRNK6SkxqUGZtlkaVS4Ya+Qrq0kYJlZplVy + KuASCiRZSagOKY3sZnmrmfK4K3pUslOFVki0EqFqzDswE+UR22J2ullPpKj+pSoNIPsV0UrJNId1dtEB + htgVh98RKcOiy1Sfl6yVvEZcxIj2WY7Z1aNNT2qsizSOWBQEyTipk8V5pc+emnZS9jYRqiftrIrcWMq7 + LXa4BFbHkJNQMkuKxYuns7WSelR+Z1Z8yVx1WB9++gRgoTu/eQywiKKVfh5RnJKgDH1eUFDuWNT8FAJz + zqtkvtQ+aAWDOragkqLwNEi0QmU8eKRzI9dvpopBlVlVy0rTysCqzPLDDWbWQC6uqqKANVx2oap7KyiT + mmAUKGncEY8qlXpeK1tN17C4lE1WA9acVo1ZJZFaF8sSCTetY1l1vaXuObHRkn2KvZVKB1YSS9jagpcO + 4zhXnMQiUpxslPmG2be7scq8Ey37eVSqcV8kb4nW9ppJfREuREyytJpCmaZlTSrYpLwmUubaYZy58qmm + napFeyrbTnLbdqtlYlpVZglbRAhV+4YX3cCNUQMWI5qTazG6SWDJXiFPY4lZCFTZZ9H5BQUJUiwXFYGR + 8oqnd1wIk6VoJbM0bOzMktJqkdQ40ApIaY5MtIJBRCRIDdgirpJr0AAsMQtU7eOzdGF1hfnXAmz534yZ + yUpCNeh0PPW3e76YNc7PpNIurQ4JjaoJUnkThrGaY0uVKlPS/j8lq2W5VjUJjIkeLT+rQKgaKaPDWqGV + D6MD+0i95gZLQmdZhn32gxZIEQuVYpH/tDfXl8X+rkywsIQY42aKVoHRtJg5p6Q2sauKKiUpn087jbm0 + uRT3lvxa//V8M6sCyBiyaoOu2b/29CgJhwWwkB2WmSVgSWbWQCtJeDIprIotganSamCWTVYwK1FlJFVV + VKGYsE9msRUnMJyDCLWM27LDMrPssAZgDXNYklBleVQYtDo9nXmrjo8tVWy9FDKnDCnF1aRpvuii3DXL + RGVoRqk1DRqO+5VKK0qbdI+qjOslD6kkDpxyceV1FPrwaqzFNT2hk7eYcqIGcQJlkagGxJk6U+BOxJ4H + ODqDTKWV+kxEK+0nrobzWIzoM1E+rU21beN2aTuUsYJWJLuAtYf4V70lBhajxQYszR+XIeE9Tx9hrwCW + ZJ+lUeGqybKWzJKEJAilcaXEYmWW5uPNrG1sVbGVZq9y83BVOignWTVQaUMVWGaWsSVgDX9XWGmlaMlk + TcziHRymsSpQdriqafEG+JWb7LJXA6SmmrwVR/XGlBopQ+JFlbFxhwaFRIst2aNAKCcqe8xhlcPoqCp1 + cVi1V6Enr8ZaXEOyW3HcRWWVSTGqMEsMmtjkvETDblLBk9f6uK2+x6a8UO0QqUarJNTSZKG49RuJQtEf + xsqOqvi3PWRg0ZFEK01gacad3git5LA+XH4nEVrFN0YlrYh0fpNo0HKVYCFCKRG2HCuzkGmVo7z2kMSG + 1KyTbnZ0HVoCQzUxm5aCUIoDrZbAss8yrSSurWIFVtIq36M0WQEs3qlKq0oi5wvWVO2qt0BPS3rL4NGc + VihvvCmuJpOy85EMkTIkq4uupLSaCpO9C5BSVGnAiir9b7XkIVtSo85jEV98if3Qz1WUONZkD1WCsNsJ + HJIo03nUIGIw9bVtsefjbkt9VW0Zbay4P/qxYjzYOBWxQ0owclwu1sqaB7wMrO8eN2Dl98/hsAQsOyxJ + tNLsO5K3ssNCu+gwaEDVUgtmTdgCSU6qNBJE+ClitokNd50PwFU0krZlYFVmCViVWasmq9LKwCqjwmay + 4t0RsFa5sweMrFozrFLNsjJvtilxXE1CJac41yLlzPoapcjn3IhkjwKhFFs5PPz/AFtU98uGabB3AAAA + AElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEX+/v7W1taioqLMzMz7yaScnJz5 + sHP6u4qHh4f6w5r81sGxsbH70ri7u7vExMS7qZmoqKj6zLSUk5NtbW3Ouq6fcUzZo3Xnyb780K3YnGj7 + qGKnnpv3mk3aqISroZ65trV8zYCeAAABiElEQVQ4T42TbXODIBCElReRKFaMbam28v//ZXcPE00ynel+ + ULl9bg8drP4jrbq/NNYEuuuodo1Fx/MzUCRLAW+AUlacQ5YAqBtg7QsCG9QBQCjcKA5h5QEolojpUiKg + da2pWteUPOKmpmkHulH8IviD+NoSsOoZEEnMAzAM6DtUc2XpTwSyAoDKDnEIl9xjATqFwhGA9hCeAakU + u66xCmgQ/w6cA3LOOzAJMM+fD9oyA7LGhyrA28+lhy5QjLhsnDeEM9BHUd/Dj3HlgEAAfgGSMYW4ROMF + wDZPwAeqHIAp3pm4MiBnbdsTwE2I76JZ8VFCyHpqoQJ43ycSEQHGb/QxQoDWAvjyJkHGGOej92sIHb7E + C2Cc8c6DWXM3jl0HgIgA6DXJ0Exg1szjPA5T2QQBpKce/Qjw3myZP4waaLetbDKlPpllaZxzDRLkh1LD + VdQKgO7l+3uB3zROzpFSGj8Nj2/F10TrggSPh6Yp0deBx12Et3BIANDgsrh5r981vz8q7/WiqvoF7esj + oxqPXRcAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABoAAAAWCAYAAADeiIy1AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAB7UlEQVRIS6WUPUhCYRiFL0Sia9Dg0tLQ + INRiBEFEo6vS0tBcGG4NXZukyeaCtpYgon8KoqkliAK3IJxaWoLaSkrs65zXLvd98d8OPPqd4+Ucrlz1 + nHOGf2iAL4VCwcvn8xKYXm0k6E+jIK5HKNOrjQS9awysYWQBIxyUO6NMrzYS9KYE2MaIj5FVnJfACD+g + TK82EnSvCXCIkV2MbODMITIPhoHt1UaC7jQFbjBygpF9nLfAOgjGVkDS9GojQWdNgzeM3GHkFOdDsAc4 + xjvzwRqYMb3aSNBeHKlg5AsjjzhfgiPAMd7ZLtgBy8D2aiNBawUjDiM1nF/BLTgDHAsG+dWJTK82EjSX + HuFF5Bu8gHtwBc5B+COCTK82EjSq2UgAx97BM9gGRqZXGwms2o0E/AB+bQ0yvdpIEGocVIrFYrsRwiev + qUyvNhKEeojH4453g3MrWo5QplcbCUK5VCr1GolEdLGm7QhlerWRoK5jcFAulz/T6bQuD+g4QplebSSo + y5VKpQ94l81mq/SKrkYo06uNBJ6X5TWJRKLm+34tl8sFAxeg6xHK9GojAZ40XkPwMFRjsZjLZDKb8HP8 + sBeZXm0k8LxJcB2NRp+SyST/8hcZ9iPTq40Edc2CITAork+ZXm0kqCvy9/4vhb3O+wUMQH1s6fTYywAA + AABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABoAAAAWCAYAAADeiIy1AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABBElEQVRIS+2VoQrCUBiFb7aazauCzWwV + LD7AisEXsBlMvodgMPgCRo0Gm2ARbDZ9gnnOP6fj/693Q9ySBz7Y/cBzYMKdS5KkFryyCryyCvzSuQ7Y + guMXLEHXdGoh0rke4APZgQFogLw/gRgwQ3AH9HvQN51aiHwXcoTP+dCTNYgonuFbuIEzGJtOLUSm5Rcw + 5UHl0xAzBwdQemgEFqDPg0poKPtvSw9NwAy0eVAJDTErEJtOLUSmr440eVApGuLvItOphchwioYkplML + keH8h9JOLUSG8x9KO7UQGU4tQ7xisiHfhfuK6dRCpM0G8FuTjWRcAT8XvExb4BXTqUVVeOXvSdwDGDmi + zIZUMHcAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEX+sbf////2ztekmZzINzbRysvQ + kZH+vcT+e3dyT09+cXH0gH3/hoT/mZjIurv/Tkfe3N3/NSzto6W1Dw3/pKPpmpfx4eLw7+/67e3rhoa7 + d3b+YlvpkpH7+Pj/j47cp6swuGqPAAABaElEQVQ4T42T0WKDIAxFUSdSGqQ6tAqV/v9fLpCAbfew3Sfg + HCAgiuaP/FM4+vYzY59JWaF/DintkNggBvHUNyJlCzYoQki9Mqg19LNgjILUdx5GoR2pNc4CkwXJ698Q + iUZ+vRmYsv86dCTId6PMX+eWBVeNVGmdP4simOj50KNATu314VzZwsTT6ArfjTNFiBCjpPGDL3Ddo3NR + VAGMYIOyPZAbVQRQyjkh+W4x2w7GCQOnAA5TjW1XKJhYBaVMEhZ9kDAqFQ1yVYokYdHYzbn7qzEGN64r + gDMvHI0OBfUiYPfxwskAOE+ReS7gGOg7rx1AhHpRJ1+CZ8NfoZ7CVX61U/B0lps/a8D68rRDTdNkbTVC + ETQ9sGNHPk1ByWK4LDwvOvePh03cBgCZB9DIwjHS/EXZlKAURDb6LDRU3wwspFifhQan8rNHDoF2CDY1 + 2CjC5r8/47dMiqAvv8IPqP5ZH6GTNk3zA7bCHkH3cTKDAAAAAElFTkSuQmCC + + + + + /9j/4AAQSkZJRgABAgEAAAAAAAD/7gAOQWRvYmUAZAAAAAAB/9sAQwABAQEBAQEBAQEBAQEBAQEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAgICAgICAgICAgIDAwMDAwMDAwMD/9sAQwEBAQEBAQECAQEC + AgIBAgIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD/8AAEQgB + cgCqAwERAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMF + BQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2 + Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeo + qaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEB + AQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXET + IjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2Rl + ZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT + 1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQACEQMRAD8A8dr/AHAP8cQoAKACgAoAKACgAoAK + ACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACg + AoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA + KACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAC + gAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAo + AKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKA + CgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgA + oAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAK + ACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACg + AoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA + KACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAC + gAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAo + AKACgAoAKACgAoAKACgAoAKALOz2/Sp0K+YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+Y + bPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+ + YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+YbPb9KNA+Ze8v3ouzSweX70XYW + Dy/ei7CweX70XYWDy/ei7CweX70XYWDy/ei7CweX70XYWDy/ei7CweX70XYWDy/ei7CweX70XYWDy/ei + 7CweX70XYWDy/ei7CweX70XYWDy/ei7CweX70XYWDy/ei7CweX70XYWDy/ei7CweX70XYWNDyvYflUl2 + DyvYflQFg8r2H5UBYPK9h+VAWDyvYflQFg8r2H5UBYPK9h+VAWDyvYflQFg8r2H5UBYPK9h+VAWDyvYf + lQFg8r2H5UBYPK9h+VAWDyvYflQFg8r2H5UBYPK9h+VAWDyvYflQFg8r2H5UBYPK9h+VAWDyvYflQFg8 + r2H5UBYPK9h+VAWNPyR7fkP8anXzNLMPJHt+Q/xo18wsw8ke35D/ABo18wsw8ke35D/GjXzCzDyR7fkP + 8aNfMLMPJHt+Q/xo18wsw8ke35D/ABo18wsw8ke35D/GjXzCzDyR7fkP8aNfMLMPJHt+Q/xo18wsw8ke + 35D/ABo18wsw8ke35D/GjXzCzDyR7fkP8aNfMLMPJHt+Q/xo18wsw8ke35D/ABo18wsw8ke35D/GjXzC + zDyR7fkP8aNfMLMPJHt+Q/xo18wsw8ke35D/ABo18wsw8ke35D/GjXzCzDyR7fkP8aNfMLMPJHt+Q/xo + 18wszW8n2P8An8Kn7jXlYeT7H/P4UfcHKw8n2P8An8KPuDlYeT7H/P4UfcHKw8n2P+fwo+4OVh5Psf8A + P4UfcHKw8n2P+fwo+4OVh5Psf8/hR9wcrDyfY/5/Cj7g5WHk+x/z+FH3BysPJ9j/AJ/Cj7g5WHk+x/z+ + FH3BysPJ9j/n8KPuDlYeT7H/AD+FH3BysPJ9j/n8KPuDlYeT7H/P4UfcHKw8n2P+fwo+4OVh5Psf8/hR + 9wcrDyfY/wCfwo+4OVh5Psf8/hR9wcrDyfY/5/Cj7g5WHk+x/wA/hR9wcrNbyPYfr/hUm3KHkew/X/Cg + OUPI9h+v+FAcoeR7D9f8KA5Q8j2H6/4UByh5HsP1/wAKA5Q8j2H6/wCFAcoeR7D9f8KA5Q8j2H6/4UBy + h5HsP1/woDlDyPYfr/hQHKHkew/X/CgOUPI9h+v+FAcoeR7D9f8ACgOUPI9h+v8AhQHKHkew/X/CgOUP + I9h+v+FAcoeR7D9f8KA5Q8j2H6/4UByh5HsP1/woDlDyPYfr/hQHKHkew/X/AAoDlNryP8/5FRc15Q8j + /P8AkUXDlDyP8/5FFw5Q8j/P+RRcOUPI/wA/5FFw5Q8j/P8AkUXDlDyP8/5FFw5Q8j/P+RRcOUPI/wA/ + 5FFw5Q8j/P8AkUXDlDyP8/5FFw5Q8j/P+RRcOUPI/wA/5FFw5Q8j/P8AkUXDlDyP8/5FFw5Q8j/P+RRc + OUPI/wA/5FFw5Q8j/P8AkUXDlDyP8/5FFw5Q8j/P+RRcOUPI/wA/5FFw5Q8j/P8AkUXDlNnyPY/p/hUG + nKHkex/T/CgOUPI9j+n+FAcoeR7H9P8ACgOUPI9j+n+FAcoeR7H9P8KA5Q8j2P6f4UByh5Hsf0/woDlD + yPY/p/hQHKHkex/T/CgOUPI9j+n+FAcoeR7H9P8ACgOUPI9j+n+FAcoeR7H9P8KA5Q8j2P6f4UByh5Hs + f0/woDlDyPY/p/hQHKHkex/T/CgOUPI9j+n+FAcoeR7H9P8ACgOUPI9j+n+FAcoeR7H9P8KA5TY8j2/8 + dqbm3KHke3/jtFw5Q8j2/wDHaLhyh5Ht/wCO0XDlDyPb/wAdouHKHke3/jtFw5Q8j2/8douHKHke3/jt + Fw5Q8j2/8douHKHke3/jtFw5Q8j2/wDHaLhyh5Ht/wCO0XDlDyPb/wAdouHKHke3/jtFw5Q8j2/8douH + KHke3/jtFw5Q8j2/8douHKHke3/jtFw5Q8j2/wDHaLhyh5Ht/wCO0XDlDyPb/wAdouHKHke3/jtFw5Tc + 8j2/T/69Rdm3Kg8j2/T/AOvRdhyoPI9v0/8Ar0XYcqDyPb9P/r0XYcqDyPb9P/r0XYcqDyPb9P8A69F2 + HKg8j2/T/wCvRdhyoPI9v0/+vRdhyoPI9v0/+vRdhyoPI9v0/wDr0XYcqDyPb9P/AK9F2HKg8j2/T/69 + F2HKg8j2/T/69F2HKg8j2/T/AOvRdhyoPI9v0/8Ar0XYcqDyPb9P/r0XYcqDyPb9P/r0XYcqDyPb9P8A + 69F2HKg8j2/T/wCvRdhyoPI9v0/+vRdhyoPI9v0/+vRdhyoPI9v0/wDr0XYcqNjyPYfrU/1sbWDyPYfr + R/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/W + wWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWD + yPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWDyPYfrR/WwWNnyP85FSa2DyP8A + ORQFg8j/ADkUBYPI/wA5FAWDyP8AORQFg8j/ADkUBYPI/wA5FAWDyP8AORQFg8j/ADkUBYPI/wA5FAWD + yP8AORQFg8j/ADkUBYPI/wA5FAWDyP8AORQFg8j/ADkUBYPI/wA5FAWDyP8AORQFg8j/ADkUBYPI/wA5 + FAWDyP8AORQFg8j/ADkUBYPI/wA5FAWNryPY/pWf9bGlg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j + 2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6 + Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1 + sFg8j2P6Uf1sFg8j2P6Uf1sFg8j2P6Uf1sFjX8ke35f/AF6m5tysPJHt+X/16LhysPJHt+X/ANei4crD + yR7fl/8AXouHKw8ke35f/XouHKw8ke35f/XouHKz+hn9hn4VfDfxh+yZ8O38VeB/DOvy3uoeNrm8l1TS + bW7lubiLxv4gsYpppJUZ3eOzs4ohzwkajtX+dHjxxPxFlHi7mSyvHYrDqnTw0YqnUlFRTw1KTSSa0cpS + l6ybP7e8IOH8kzLw1wP9oYTD1nOeIcueEZNtV6kU22nryxivRI9d8V/sXfso6ol3rPiD4X+HNLtrK2uL + u9vrTVdW8M2FnaW8TzXN3dPpuq6dZwW1tCjO7yYRFUk4Ar4vLPGrxVwCWGwWb4mfM0kpxp1m29kvaU5y + u3ppqz6nH+FXh3jW6+Ky2hGybbjKpSSXd+znFaeZ/M5+0V+3v/wSq8A/F3W/hv8ACzwr8X/iroegubTW + vid8PvGGnnwG+rj/AI+LHwZc+IYLqXxNZae58uXUFf7FLKpW3aZB5lf1zwbjPH7Ncrp43NcRl1CvPVUa + +GftOXo6vsnBQcukEue3xWeh/N/FWW+EmX5hLC5Th8bWpR0lUpYj3L9qXOpOSXWTfL/Lfc4fSf2u/wDg + m/4khx/wsD49+AruQ/J/bvg7w54stod3RZV0e40NmCE8lZSSK+4/tbxgwk17XAZNi6a6U6tag36Oftl/ + 5KfGvKvD6tFqNfNcPPpzQpVkvVR9l/6Uem6H4n/Y18a3em6b4I/bA8N3Wr6tdWthp+i+Jvhp410PU72/ + vJUgtbGzj0weI4rq9uZ3CRRIzPIxAAycUPj3jPBQnVzbhmtChCLk50cZRqRUVq2/aRotJLVt6Iz/ANUu + GcRKMMDnSdabSUauFqwbb0SXJKqm30W7PqDxN+xL458N6mukTfEP4OtqL2sF3/Zl940XRNZgW5jEsMN9 + pWqWME+n3TIwzHMUZTw2K8XLPH7hjMcN9a/s/OI0eZrmjh1Ug7aNxnCo+ZecU79D08y8Jc3y3EfVamPy + v27inyyruE1fVKUZQ91+Tat1OJn/AGQvjyomfT/CGn+IYYf+W3hrxj4K13zVxndDbaf4hmv5Bx/zyz7V + 9DR8aPDqpyqvjamHnLpWw2KpW9ZSoqC/8CseLLw14v1+r4elXiutLEYepf0jGrzf+SnDat8AfjRocXn6 + r8KvHtpCGKmY+FtXliBU4PzwW0q4HrnGK+iwfiHwLj5+zwmb5dOp2+sU0/uckeViOC+LcLHnr5bjVDv7 + KbX3pM871Pw7rWiSCLWdH1TSJW+7FqenXdhI3GeEuoomPHtX0uEzHAY+PPga1GtDvTnGa++LZ4eJwGMw + cuXF0qtKXacZRf8A5MkZXkj2/L/69dlzm5WHkj2/L/69Fw5WHkj2/L/69Fw5WHkj2/L/AOvRcOVh5I9v + y/8Ar0XDlYeSPb8v/r0XDlYeSPb8v/r0XDlZreT7H/P4VN/Q15WHk+x/z+FF/QOVh5Psf8/hRf0DlYeT + 7H/P4UX9A5WHk+x/z+FF/QOVh5Psf8/hRf0DlZ++P7M/xv8AhR+zj+wH4Z+L3xs8b6J8Pfh14RHji61v + xJrs7RW8Rl+IXieO0sbK2hSW+1XVtRuGEVrZ2sUtzcysEjRmOK/zh8bskzXiLxvzDKMloTxGY1lhVGEF + /wBQlC7bekYpaylJqKWraP7j8JszwGTeFODzDM6saODpvEOUpf8AYTVsl1beySTbeiR/JR/wU0/4LO/G + D9u7VNb+EXwXm8QfBr9k2K8vNOuLCC7l07x58btPV1jivPiHNasp0bwxdGLzIvD9vK0ZVgb6WdgIY/6E + 8KPAvLeEYU85zpQxXEdk+dq9LDv+Wgn8c1s60lp9hLd/kviF4p47iF1MsyvmoZNqrXtOsu9W3wxfSmt/ + tN7L8idK8PRRwJDbwBI1AARV7YAAYg84xX9DJwoR5YaR/H1fdn4vadaXM9zvvA/wc8dfFPxv4Z+Gvwz8 + J6v438feMb2LTfDXhfQ7cXGo6peShpCF3sltaWlrD+8uLmeSO3tolaSWREBNcmPzvLsny+rmubVoYfLa + EXKpUm7Ril+LbekYxTlJ6JNndhMrxuZ4qngMvpSrY6q7RhHVt/kkt23ZJat2P6B/gf8As5/CT/gnDpkX + iG9ufDXxj/bVvbDbeeMoorbV/AP7Nt3Kksd3oPwsW5t5IfEXxChWUxX3iSQbLd18uySMB2k/C8dmOe+L + db2c41sB4eRleNF3jWx60anibNOnQdrwoLWSd6jelvu51co8OKTWGlSxvGzjaVbSVLBvVONC6tOsr2lW + ekXpBLW/jHivxd4m8Va5fa5rWr6hfajqFzNeXd3dXc81zc3NzK000880rtJLNLIxZmYkknmv0vLsqweX + 4WOFw1OEaMIqKSSSSSskktkj8gzHMsVj8TLE4mcp1ptttu7bbu2292ypY+KPFOnkGw13VrTacj7Pf3EQ + B9QEkXmumpl2Dra1qUJesUzijiq9P4JSXo2vyPT9D/aF+OPh4Iuk/E/xrZpHjbFF4h1PyeOxhNyYmGPU + GvFxXB3DGNb+sYHCzb6unC/32uelh+Jc+with8ZiYLsqk0vuvYqftAftn/tLXv7NXxw0i4+KOvvBd+DL + HSzcbrUX9vZ6v4q8P6TqS2V8tuLuzmutNvJoTLG6yoshKsrYI/OuMeBuGMgy+Gd5NhYYbM6WLoONSm3F + putBXVn2bt23R97wlxjxJnGZLJ8yxlWvltWhWUqc3zRaVGcknp3S069T0XyfY/5/Cv6ev6H5lysPJ9j/ + AJ/Ci/oHKw8n2P8An8KL+gcrDyfY/wCfwov6BysPJ9j/AJ/Ci/oHKw8n2P8An8KL+gcrDyfY/wCfwov6 + Bys1vIP90/r/AI1HN5o15Q8g/wB0/r/jRzeaDlDyD/dP6/40c3mg5Q8g/wB0/r/jRzeaDlDyD/dP6/40 + c3mg5Q8g/wB0/r/jRzeaDlPy3/4KneKPGHiGH9nzwLrPibV7rwH4M8PeJtQ8N+DTeSx+H7DV9Y8Wa1d6 + nrJ0yJktbjV7lpyn2qVXnWECJWWMba+HyvI8u/1uzfNVSh9drToKc7e/JRw9KMYuW6gkvhVk3q1fU+u/ + trHyyTCZZOpJ4Sgqns4fZjz1Jyk0tnJuT953aVktEfl3pkA3IAAFG0BeAMDPGMDAHt0r7OpG0bRR5UZX + leWrPrr9nTwl4d8XfEDw7oXii9isdIvr62t7m5lbCQxSzIkkjY2swijJbAPOK+V4hxWKwWW1sThIueIh + BtLu0v1PeyyjQr4mnTr2jSb1f4X+R/YH8Nv2Q/hH8IvhH4i0b9h7xB4J8U/GDxfo1sfiV4uTW9MT4tal + 4d8lZl8N+GoLi6S48KeDyzbpre0ZJLx+JpZiFA/i+px3mGd8RUcX4n0cTQyHD1H9Xp+zl9VjUvb2lWya + qVf5ZTTUFrFR1Z/REuFqWC4fqYbw+rUK2bVoL281NLEuH8lNNr2dPXVRacnu2fkf8R/AXjTwtrl/Y+Mt + H1TT9Tt5pEuIdRt54ZoXViGV4plWRCPcCv6uyPMcqzLCQq5XVpzw8krOLTTXk0fyxnWX5nl+KnSzGnUp + 1ovVSTTXyZ5FNZ7nzjHbv2r6iNPljY+XlO7uNFmPTP1//UKOR/IhyF+ynsP8/gDR7PTXYjm+48v+PduY + /wBnv40Mf+hb8Pj/AMvzwr7V+f8AiXG3DLtb/esN/wCn6Z9r4fO/E1L/AK81/wD0xUPu3yD/AHT+v+Nf + tPN5o8DlDyD/AHT+v+NHN5oOUPIP90/r/jRzeaDlDyD/AHT+v+NHN5oOUPIP90/r/jRzeaDlDyD/AHT+ + v+NHN5oOUPIP90/r/jRzeaDlOq+wf7H8/wDCvP8AbHd7EPsH+x/P/Cj2wexD7B/sfz/wo9sHsQ+wf7H8 + /wDCj2wexD7B/sfz/wAKPbB7EPsH+x/P/Cj2wexPz5/4KZ/sxfHS88AfCL9oHRvhp4i8Q/B5NF1/SNU8 + a+GrOTX7TwvqFl4p1i2kTxbY6as+peHLKeSP91eXEK2TkhfODkIficm4v4c/13zPhiti6VLPlKhJUaj5 + HUUsPSkvZSlaNRpPWMXzrfltqfUYjhjPqXDuG4hjhpzyWoqi9rD31BxqSi/aJXlBXTtJrlfe+h+LdhtO + x42DIeQytlSAT0I46iv0mcHaz3PlVVs7rU9K8P6tPp80M9tK8U0bK0ciHYyuMEFSBwfzrgrYZTTTWh2U + sXybXuYXjf43/GG08Q6brw8TeJ/CmqeHrpbrwtr3hvXNR0i/0uaFtsV5YeINIuLW8ivgB1WSNlzjAHX8 + c4ky/GVJywmZYaEMtk3aFlOnJd5OzjKT63Sa2SR+i5JjMJSUcTgK8pY2K1ldxmvRXul6aPe7P06/Z9/4 + LyfFbQ9I0z4a/tr/AAq8P/tjfDa2VrNPG13Pb+E/2g9AspPOCtaeM44xo3jH7G0oZI7+OyupNu2S9bIK + /llXw4ll+IeZ8EY6tlGPvf2avPCzf96k/gv3jzJdIo+3fGtDMKKwHF2DpZlg7WU37mIgn2qL4rb2dm+s + mfrZ4D8B/skftr6LN4t/YX+P3hvxfry2bajqnwF8dzw+CvjZ4cLI9xLYP4W1SSB9bNki7HuLQPZswAjn + l3Ln18u8Ws+4Yqxy/wAR8vqYendRWMop1MNLZczktad+zu+6Wp8xmnhTlGf0p47gLGwr1LOTwtVqniI9 + bJPSdu6sn0bPnHxx8KPG3w71a50Xxd4c1TRL+0kaOW31CxurSVCpwcx3EUb498Y5r9zybPsmz7CxxeV1 + 6dajJXTjJSX3ps/Ec3yLNskxMsLmVCpSrxdmpRaf3NI4T7HjqCPw5/pXtezvseLf7zyL9om32fs6fGps + dPDfh36/8j74V9hX574nRUeF3/2FYf8A9P0z7bw9d+J6X/Xmv/6YqH379g/2P5/4V+oe2OL2IfYP9j+f + +FHtg9iH2D/Y/n/hR7YPYh9g/wBj+f8AhR7YPYh9g/2P5/4Ue2D2IfYP9j+f+FHtg9iH2D/Y/n/hR7YP + Ync/2b7f+OmvF+sHrew8g/s32/8AHTR9YD2HkH9m+3/jpo+sB7DyD+zfb/x00fWA9h5B/Zvt/wCOmj6w + HsPIP7N9v/HTR9YD2Hkbuu/tP/Fb9nEfDKTwJrskOk3Gj64NX8OXyfb/AA9q8M3iTWfNi1HSJybWcOkp + G8BZRn5WFfj3EHAnD3Guc5ks2op4hTo8lSPu1ItUKVnGa1W22q7o+my7jrP+DlhlldZrD8suanL3qck5 + yveD0d776PszzT4gfBf/AIJxft9xNceKvDtv+xh8fryR5/8AhZ/wp0uAeA/E2p3CMGPjLwI6W2jXETT4 + d5ENpeOSSdQXoPn8JiPF3wul/wAJtR8RcLR/5h8TJ+3pxX/PqtrLbRL3or/n0z6v694aeIceXM4LIuIZ + f8v6C/c1JP8A5+Utt/RvrUR+SP7Un/BK79rP9leObxUPD1v8cfg00BvtO+NXwUhufFPhj7BkEv4l0O1F + 14i8JT24KiV54ptP3ZEd3Jhsfr/BfjHwPxnNYB1ZZbxEnaWExlqVTm/6dzdoVU+iTU+8Fpf4Tijw14s4 + ZpvGU4LH5I1eOJwv7ynb+/FXnTa6tpx7Tep+dgK3UTRzKlzDJlZEkVJo5BkghkbKNjpyK/WpYaEounUi + nB7pq6fqmfmn1qqmpwk1NbNPX7zh9e+Fek6mXutLn/si6kJY26p5tg7EAjdCCstqCf8AnmSo/u9q+SzD + g3A4i88BJ0K3b4ofdvH5Nr+6e9gOKcdQ9zHL21LvtP79n81fzPKLjw94t8DatZ6xbS6roep6XdJc6T4m + 0G+u7G4srqM5iu9M1rTZbe9066Q/dZXilU18DmeS47AKVHMaKlhpaN25qcl9zXykk/I+wwGa4TGtVcFV + ccRHW1+WpF/J3XrFv1P2u/Zo/wCC6v7QngrTtG+Gf7YPhPQf2xvgzbpb6ZLfeKorPRPjt4Y0lUaE3Xhn + 4j2kEUHiO9s0cSLHrELXNyU2PfpuMg/Jsb4a4TD4qWb8E4mtk+b35rU25Yao+1Si3ZRe3uaK91DQ/RsP + x5XxOHWV8X4almmV2teoksRBd6dVK7a397V7OR+wHw5P7En7b1smofsZ/HbTofiDdxm4n/Z3+Lv2TwF8 + V7Nzy9rotvqk9vp3i7y2ON2ny3UWB/r2bIHfl3ilxXwlNYTxFy9rArT67huarQfnOKTlT+f/AIClqeLm + Phjw1xPF4rgLGr629XhMRanWXlBu0any/wDAmfHH7avwk8d/Cz4CfHXR/G3hrVtAvYPDnh7CajZTWyyp + /wAJ/wCFAJIXdPLmjbIwyMyn1r6/jTibIuJeCljclxNKvRlisNrCSdv39PRrdPydmfGcL8OZxw9xhDB5 + th6tGtGhX+KLV/3FTVd15q6Ptf8As32/8dNfp31g832HkH9m+3/jpo+sB7DyD+zfb/x00fWA9h5B/Zvt + /wCOmj6wHsPIP7N9v/HTR9YD2HkH9m+3/jpo+sB7DyD+zfb/AMdNH1gPYeR339m/7H8/8K8L6yez7AP7 + N/2P5/4UfWQ9gH9m/wCx/P8Awo+sh7AP7N/2P5/4UfWQ9gH9m/7H8/8ACj6yHsA/s3/Y/n/hR9ZD2B83 + ftRacWtvhyAvC6Nqw/8AK/qbfnzXmZNNTznMJf8ATyn/AOmaZ85xHFw9hH+4/wD0pnyZFZSQMJI2dHBy + rISpB7cgivpWlNWaXL5ny6k4vmjoz6e+Cn7V3xu+Bd5G3hDxhqSaSZFa70G8cahol6o4ZbrSrzzrN2ZT + jeqrIB0YV8JxT4ccK8W0msxwsHiLaVF7s4+k42l8tV5H2/DPiJxPwtUTy7E1FQvrCT5oS9Yy0+e/mes+ + OvhJ/wAE7f275LvVfiH4Tu/2UPj/AKszS3XxX+EdpbweDtf1RwFN74w8Cz/aNH1AzOd00gihvXfk3y5I + Pw+FreL3halSySvHP+FKe2FxTbrU49qVZWkrbJXcEtPZM/Q3jPC7xGbnnVF5LxLPfEYdfuZyfWpSd4u/ + V2Um9faI/LH9pX/glD+1X+zhaX/jGx8PWfxz+DUMc1/Y/Fv4OmbxJp39jRqJl1HxJ4YtxN4i8MGGBh9o + Yx3VlC6ti6dRur9b4O8b+COLasctrVZZZxG2oywuLtTlz7ctOo7U6l38OsZtW9xPQ+E4n8J+LOHacswo + 045jkVrxxOFftI8u/NOCvOFlvpKKd/fa1PzqjtIZ4iAI5YZQVKkLLFIuSrKytuVxkYIxxX6+1dOFRJxe + 6a6eaPy5tXUqb95bNPr6nnWvfCbQ9USWbSydFvsMyiMGTT3k64ltid8IY94iMf3TXzGYcHZdi71ME3h6 + 77awb849PWLXoz2sJxVjsNaGM/f0V30ml5S6/wDb33o8Z1Hwn4q8H3ltqhivLObTbqK807xBo1zcRvY3 + du4e3vbPUrNobzS7uGRQ0cmYpEbBBBr4TM+H8yy2MoYykpYZqzkvfptPo9OvaSR9dgM9wOPcZYSpy4hO + 6i/dmmu2urXeLZ+kWi/8FO/2tviJ+zJ8Yv2Xvjb44j+Ovw51/wAIaDb+Htb+Jdsmr/E3wFf2Pjnwnd2m + oaH8QgF13WLfyrIQS2+qteu0T/JNGQd/4Vxb4f8AD2AUOIMmhLA4yOKoOpGi3GjWi60LxnS+Fau6cVGz + Wz6freQcc55i75Jm0o43CzoVlCVVKVWjL2M2pQq/F0s1K903quv9HP8AZv8Asfz/AMK/fvrJ+c+wD+zf + 9j+f+FH1kPYB/Zv+x/P/AAo+sh7AP7N/2P5/4UfWQ9gH9m/7H8/8KPrIewD+zf8AY/n/AIUfWQ9gH9m/ + 7H8/8KPrIewO8/s/2H6f4V899ZPZ9guwf2f7D9P8KPrIewXYP7P9h+n+FH1kPYLsH9n+w/T/AAo+sh7B + dg/s/wBh+n+FH1kPYLsH9n+w/T/Cj6yHsF2PnH9prTN8Xw/+XO3R9T7dM65qJ9OlVw5U58yx7/6eU/8A + 01A+L4shyVKK/uP/ANKZ8nHSWH8J9Ccf/WxX2Fz41pjf7JPcfoP8DzT5ibLckh054n3JuRuMMmQQR05x + xUTXMve1Q4txd0fTPwN/aG+NHwg1i3TwL4n1WOCedPP0aSY3mlXnYrdaXciayn3A43FN47MCAa+C4u4D + 4V4mwknnGHp88Y6TS5Zx9Jq0l6Xt5H3nCXHPE/DeKisqr1FCT1g3zQl6xd4v7r+Z9p/ti/sWfsafEz9m + PX/2qv2jPBll+yt4/wBN8OT61ceNPhTFaaVqHiPVLmEf2DZan8O52tdA8Y674o1B1jt7SRYdSnaRQbyJ + csn4TwH4h+IORcd0+AuC8VLPsonXUFSxV5RpxT/eOOIV50oUo6ymr01Z/u5PR/v/ABdwRwVnXBc+NeLs + NHJM1VHndTDWi6kmvcUqDtCpOpLSMXao7r34rb+QTy0LyNH5hiLyeUZY1ilMW4+UZokknSKVo8FkWSQK + 2QGYDJ/0Gimkk7Xt01V+tnZXXZ2V+yP4jqTV3Lp+nnq9e+r9WRiEMpV1DIwKujKGVlPBVkYFWVu4PWuh + pNcrV4vp0OJzfNzLR3Oe1HwR4ftPC3xA1zT7QadewaJpDOlp8lpch/F/h9GEtscxxv8ANndHt56g5r8Y + 8Xshy6jwtPMMND2VeOJw91HSMr16ad47J67qx+neG+d5hV4ko4GvP2lCVKv8XxK1CptLdrydz+vH+z/Y + fp/hXzf1k/R/YLsH9n+w/T/Cj6yHsF2D+z/Yfp/hR9ZD2C7B/Z/sP0/wo+sh7Bdg/s/2H6f4UfWQ9guw + f2f7D9P8KPrIewXYP7P9h+n+FH1kPYLsd3/Z/wDsfy/wr576z5ntewD+z/8AY/l/hR9Z8w9gH9n/AOx/ + L/Cj6z5h7AP7P/2P5f4UfWfMPYB/Z/8Asfy/wo+s+YewD+z/APY/l/hR9Z8w9gfO37R2m+Yvgcbfu6Tq + Ix9dZvz6ivW4Tqc+Mx0v+nlP/wBNQPzvjSLjiaS/ufqz5eOkAfwj9P8A9dfbqTPhrEJ0n/Z/T39jmnzE + tDBoxkZVSMliQFC5PJ44603NRV2wUHJ2WrZ+pn7G/wCzV4T8OaBqv7SHx2u9H8M/DfwNp9/4kN/4pubO + w0EWWhwT3ep69rd1fGO3tdA0SKAySPIQkrqV5VWB/mHxj8R8T7ZcF8LudTN8Q1Cfs7uUeeyUI23qTvZW + 1itd2j+l/CDw6oSpPjDiZRhlVBOUFOyjLlu3OV/sQtrfSTVtkz+aX/gpj/wVM8cft8ftDWugfDOOWz/Z + o+HWq3mmfC/wnfRS2sni25hlubLUPjB4k3W8F7pd/rGntt0+1kVhpmnHayGeaYn9G8D+C8X4f0kqNKnX + 4jx0YrENq/JDSXsozV3GMHrOSupzSumlFHy/jBxbheNpt1ak6OQ4Nt0Enbmlt7SUHbmlNaQi9YRe6bkz + 5S1K1sbdrdbC9a+jktLaWeR7aS1MF5JEGu7NY5CxmW1mJUSg7ZRhgByK/q3DOtNN14KE1JpJPmultK9l + utbWutj+Z8S6MWo0JucXFNtx5bPrG13s+uzM8ACuo427hq//ACT74k/9gHRf/Uy8O1+X+MP/ACRFX/sJ + w3/qRSPvPDT/AJLDD/8AXqv/AOmKh/X9/Z/+x/L/AAr8h+s+Z+8ewD+z/wDY/l/hR9Z8w9gH9n/7H8v8 + KPrPmHsA/s//AGP5f4UfWfMPYB/Z/wDsfy/wo+s+YewD+z/9j+X+FH1nzD2Af2f/ALH8v8KPrPmHsDtv + 7PH90/lXgfWfM9b2LD+zx/dP5UfWfMPYsP7PH90/lR9Z8w9iw/s8f3T+VH1nzD2LD+zx/dP5UfWfMPYs + P7PH90/lR9Z8w9iz5I/aT8W6RpureGdGu/DfxQnksdMdX1fw/wDDHxR4t8OSNe391cpHHqXhW31i6WSB + JAJRJbIEbgE9arJOLMJkmPxdLG0cTKE5wanTpyqR/hxTvyptW9D5LiThTH5xVp4jBzw+kGuWdSMJaPtJ + pW+Z8wt8QfhlHdNY3fjKDRbxQTJb+K/DXjXwY8QAyxlfxd4X0SBVQdTvKj1r7Cn4h8LTly1MQ6Uv+nkK + lP8A9Lij42rwHxRBc0cLKpH/AKdyhU/9IlI1NJ8ReAfEUjQ+HfiL8OPEEqsUaHRvHvhO/mDdNhhg1ZpQ + /wDs7c16mH4u4axWmHx2Gk/KpG/53PJxHDWfYTXEYPEwXnSmv/bT7+/ZF/ZUuvix4mj8QeJLaaDwRosq + yaheRsu3UZlw8WmWFwoeGSWbgyMufLi56lc/mPiv4o4XhjKvqeVVIVc3rq0EmpKK2c5Wey6Lq9Nkz9P8 + K/DTEcT5n9bzOE6eU0HebacXJ9IRut317LXex+Nn/Bcf/gp9N8dfENx+w7+zLezWv7P/AMP9Vt9G+JXi + Hw4l3bQ/FrxroNybePwRpTxxwi7+HPg3ULcCUoWh1fU49+XtreNpfmfCDw6xGBa4t4ghKrxLjNaMJe9K + nGp9tr/n9Vvp1hB20k3b7bxR49w2Li+GMinGlw9hdKsou0ajhpyL/p1Tt6Tkr6pK/wCMvgPwZF4T04tc + BJdZvkQ38y4IhTh1sIWycxQvyzf8tH56AV/bXDuRwyfDc1Szx1RLnfZb8i8k931fkkfyHn2cyzXEWp3W + Cpt8i7vbnfm1t2XzPR4WuJYjZIQYXmS4KFQSJlVogytguMo+CAcNxnoK+glJRV3seBZXv9rYWexuLcbp + EIX1wf8APFRCrCbsnqU4yj8SaPcvBHwA8V/EP9mr9rj40i2urH4efBT4f+GJdR1trZza6v4z134h+DbH + RfCVlcnERvIbO8a/u8ZMNukYODMmfwPx/wCMMvyXJsv4ZvGec5pmFBRhfWFGFaEp1ZLezcVTh3k3/Kz9 + p8FeEsbnOa4ziJqUcpyzBV5SnbSdadKcYUk9rpS55dopfzI/q2/s8f3T+VfmX1nzP2D2LD+zx/dP5UfW + fMPYsP7PH90/lR9Z8w9iw/s8f3T+VH1nzD2LD+zx/dP5UfWfMPYsP7PH90/lR9Z8w9iw/s8f3T+VH1nz + D2LOv+xj0/8AQa8X2563svIPsY9P/QaPbh7LyD7GPT/0Gj24ey8g+xj0/wDQaPbh7LyD7GPT/wBBo9uH + svIPsY9P/QaPbh7LyPBPirbyjVrMRllxagfISDyzH+HHrXVllW1Ss+8l/wCko8LNqV6kfT9TzE/bSoVr + id06bXlZ0x6bHyMV6spwnpJJrzR5KpTh8N0/I5zU/BfhfXYZrbXPCXhTWre5BW5g1bwzoWoxTjn/AF6X + dhMJM/7Wa5KuCy2vHlrUKMl5wX+R008Vj6L/AHdWrH0lJfqX/BPwg/Z8tw2g+IPhN4d0nRrxJ7c33gVt + V+H2o2C3kbQ3DxXXgbUdAmaKZGw65JI6eh+G4i4GyrGR+t5bQowxkNUlFJSs7rZXTXRn2fD/ABjmGEbw + WZVas8HPRvmd430fqrbnwx+0D/wT78EfBnxDp3izw1ouv6t8MLuRF8Pa9oPjfxbbDSjOpWPRdetZdW1C + yivEj+WC62LFddDsk3JXo8NZrKpWSjiMdhc1o/FCNep6OUOdyXqunmtTg4gyDDKi/wDZ8HiMsq/DJ0Yf + KM3BRfo+vk9DwuT9mfwvqzvf2fi/xxFbzKVisryx+HOt2to+PuM2o+Bv7WlKZ5D3ZJ/vd6/WMLm/FMYK + tgs8xbh2qU6FSz7O9NO69T8wxPDvDLm6WJymhGXenUrQv5r32rfIwP8AhlG5hWZ7Dxd4Yur0uTAdd+HW + o2UATBG2WTwz47tR5nP3lgC/7NeguLvEGlG31zA11/08oTi//JKiX4fI82XBnBtSXMqGNoy/u1oSX/k9 + Nv8AEwvEH7L3jQaeIrC2+HWr3LjE0qeKfGPhZImB+9FBe+EfFguBjnBkQ9s966sN4icaYecXWwWArpb8 + lapT/CVOa/E5MT4ecPVYP2ONxdK+3PRhNL5xqRf3I/WHxzpms6f/AMEpfGf7Ivwe/Zp12K38e6F4Ujk+ + Ldj8U/hbr/h7xH8QNT+I3g3UfEOv+LmvL/wf4m06a71GxNnFF/ZkrWUEcEDfJHvr+QuMsVxhxT4qxz/i + SEKdeOMpKNKMm40KFOadOEOZLmio+85L45ylP7Vj+r+FMDwzw54ZyyTIZynTlhKrlUcUpVq84v2k5Wb5 + Xze6ot+5FRjsrn6J/Yx6f+g1+v8Atz4L2XkH2Men/oNHtw9l5B9jHp/6DR7cPZeQfYx6f+g0e3D2XkH2 + Men/AKDR7cPZeQfYx6f+g0e3D2XkH2Men/oNHtw9l5HSfZx/kf8A168r2jO/2YfZx/kf/Xo9ow9mH2cf + 5H/16PaMPZh9nH+R/wDXo9ow9mH2cf5H/wBej2jD2YfZx/kf/Xo9ow9meRePtFN7qMDhchYQM49v973r + swVbkc/Nr8keXjsM6lRPyPP28Mt/c/Mf/Xrv+snA8G+xGfDTD+DHvg/zzTWK8yXg32I/+Edbsn6dPwz7 + 1X1gj6mzvvDV+lpYXvhfxHYRa74S1iGS01PSb6JbmBoJwVl2xSErtYHJHHIBBDAGvns2y2GMksXhn7PH + w1Ulpe3f/P8AQ9/KsfUwcXhcQvaYGeji9bX7fr/mfOHxB/ZpXwjqD+IfBE41HwTqDeYsUrPNc6N5jsVs + bw5d5baLO2G4b5x92Tnlu7I85xMqv1eu1Txi+JPRTS6rz8vu0Mc4yjDql7einPCvZrVwfZ+XT89TgJvh + +gGI4i2dpZ2jCsrYO9Fw7Axgng9T7dK+wjmD+1+Z8pPL0vhu16FCTwC//PMkdMbT+XXFaLHIyeBfY7Xw + vLr3hjQNe8Lxu8vhzxDqfhS5utPkJ8q01Oz8W6BcxapaDJ8u4eO2Eco4EiYJ+ZQa+Y4lwmFx6o5g0lja + FSNpLdx5tYvy1uuz8mz6HIMTisC6mCi74SvCV4vZStpJdnpZ915o/Q/7OP8AI/8Ar14/tGe97MPs4/yP + /r0e0YezD7OP8j/69HtGHsw+zj/I/wDr0e0YezD7OP8AI/8Ar0e0YezD7OP8j/69HtGHsw+zj/I/+vR7 + Rh7Ms1mbBQAUAFABQAUAZl7psd44dsZAxz6YFOE3G9iJ01LVlH/hH7b+Jsf7qZP9Kv20uiI9hHqxP7As + F5KXEn+6qL/MnNL21Z7WQ/YUutxp0qwj+7pTS9gZrggHvyESlzVnvNL0QKnQW0Lv1I2gkjz5Gj6WnoXi + knYf99uAT+FL2fN8VSb/AA/Ir3Y/DTh+ZBPJ4hkhe2WeGC3lR45IILG2WN0cYZWVo3BVlOKUcNg1PncW + 5p7uTv8AmN18S4uCaUH0SRwsngiPJ/c9+gUDGcn+7wK9NYvzPOeFv0KkngiP/nmPyq/rnmQ8HfSxzniL + wlHZ6LfXCpgxSaXNwp48rWLCT0/2KwxOJVWlyX+0vwZpRw3s6nPbZP8AI+l64D0goAKACgAoAKACgAoA + KACgAoAKACgBB3+v9BSAWmAUAFABQAmB6UBYNq/3R+QoAaY4z1RfyouBy/jKy+0+GtVghjBkkjtwoA5O + 28t3P5Bc0CkrrzOroGFABQAUAFABQAUAFABQAUAFABQAUAFJDCmIKACgAoAKACgAoAZIiyIUYZVsZB6H + DA/0pAPpgFABQAUAFABQAUAFABQAUAFABQAUALk/5AqbK9+o7vboGfYfyz+VFvNhfyEPsMfn/Wiz7hoF + PUQUajD05/8ArUr+QWCncLBTEFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAf/9k= + + + + + iVBORw0KGgoAAAANSUhEUgAAAFwAAAAeCAMAAACWoYkNAAAABGdBTUEAALGPC/xhBQAAAFpQTFRF//// + +zIz4dDmtpDFl2Gt9/f55OXpwMPKepjJJlqnztHT8vT17O7v297fjJOVaHFzR1JUq7Kz1u7XNKEtZbdf + 5/Xl/P37/ffw/n8J/bSX/c+7/JFu/d/Y/v7+VT3rjgAAAxlJREFUSEutlOtioyAUhGktnkSRSzYhF+X9 + X3NnDljTZn+tmabK9eMwHDRNpeRyXZbHY1mKMRn/b1Qx1/v8oZrv1zeyifoU29jQjG1QtXuXAMny9dXl + e2N/zNf5YUp+hznF2O4L6uxjhefb7fEe40tlP9EJvz1KbgN2CZ5Udf2ywW9L696hYj4bGhKj9Aqf90ee + SzMFEiTJgqSZr4TDmL0pU7bAhVfJXOcVjtCRk23cfyl/B/7JrMykV1vo+s7I11QBW11g7EuN/HbX6g71 + P9l6d0qDz7qTHaqWd+7HjdzgbKrW8MnPggbBT4Y28K+WtU3H1Tel8M6OmLYF2eA3fMEGX9Wb0rvK0Ml1 + CZaVrbWnchXhXZED4WvbMzzFQMUwlOArDVoJeGCWtj03sU4B3mU5HtDzEvmMaSmKHUcnMYwyVAzU1lC1 + 4nPTqh5xp6PCt97Nc8K1ycdJWKJNwjBG8T6NkqxxCaWJi7Bzcn7SGZD9tIdjgyud7wZHKiqcG09xCKGU + FGOI0VvT4wWzQnROX3Ew1tfOmJRMKft4aLWqfJ+pReEDW1wIfQiowfsJ022IyVkB1yXUDGyz6JzyBPwG + n8g+HvLpRSOPOEWfILByCGMIyFkzBi/RczKYzuNUMM5jcYemEUPZRZVcI7+c//zWiZkAH6iQsg1+wDy6 + Z+EATEZeADig1ydsCJ28B9hJYyOOvsIbcdMZI3XoBI0MqcI1LzyjRNHH3kyenidhJ8LhuwkD5J/w80WD + bJ5XM4Zqhpl6NqPX4iiYoW6AGejkuk+RY1qBMa/wk7IxFAmIAuEBx8ilpujxsyjxDKvVGNc6scyUJmd7 + Jh8Y6RWuhmvkhLMEuIG/SXC6grwPIsw9ZEuQAQ+anwZ0xtR78cnzNqhPv+DwJPMrRQc1clxfWIBPDebi + dHECACOn4X3WMw+IGrGzEzMS9rPCsYHnbDnjCoLNz41xMgJNeh5480YRoQ3Yv8hk+gFzUUIbCk5kyFZc + nsZBR1P09JLO5J/P6YQlGTXNqL61H8t8VJtqYW3i2Fb6blql1fFyuTjdDGt7ZcxfzHBdbpEUsskAAAAA + SUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAMAAABg3Am1AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAADAFBMVEUnYa0cW60hc8a90+tWoeF1suRq + su7z+f0aYrUdbsJzteoyQ04VRX6TzPbE3vTa7vs5iNG44vpcod3///9kqeSj0vLX7PkhXaxTiMZQmt0i + YbCHwet8u+waVZiFxfV4o9OzxNiEqtXj6/NxlbqFvOQ7SVEdaLtapeU1cblPmNoTSoRglc1SU1NipuEq + ZbFSnN0eccVbpep7vfMaXrAqOkVRnOEuf8xgqumEvel5tONQmtrq9Pys2fZipN9HhMhVnd0uZ58ybrfo + 6u1pr+slXJVYouFfksqHstwcZbit0u2y2fVcpuaKveVXkMq83PXV5/cfa76UttpCgrtDbJvw9/201fJG + eqmDvfAaU40sabTA2O2VxO3j8fw0aquXscsmeco8dalZntxsruJVnuBCeL45f8VCfsGc0vWSwed2n9By + t/DP5vekzPJYmc2LyPVlruwSRoD5/P7G4Pq4z+aQvOJ/uuYIPnuLxPBSnuRThblZoudvsuh0uPBPksvr + 8fccSYBSmNIMRIFFR0ddpOHY5fPR5/gaXKX3+v3O1+I5dLpnrOhGk9akvdVnmtIWTohqrua03viKvu1W + XF+vy+NWnNtqqeKbxu0cKzh5rd9WoN4iTIEWY7jU4u4ld8ikyutrqd96t+lUm9tWoedKl9hRm+B2ufAf + V6Go1fRUmt1Un+YgbsEPW7JRnNoLVa0vgcxep+geMUAnUYZITlLM4/Ytcr33+PktPEapzu5iq+phq+zA + 5/xfqOZKga+/1u1lqusbY68gM0EwP0gvXZLd6PUVYLRJldc+jdMVUJUxgc4UWq/J4PMoOERopt8tecfz + 8/OvxuCw2/ehx+yjweOfx9/L2+5agKmXrshGk9jO6vnP4PA2eLw/ca+AwPM+eLVcodb7/f///v5oq+OD + m7ltqOEWaL5uq+Vur+TK2ebJ1+jF0t4ZWp+ayfIcWKkqgNJAe8Bcf6hkquwdTohbn9C41vCWx+mSyu6a + wOModMKCuObP5frS3ulWbXlcpORbouFZo+NppeG44I5GAAAF0klEQVRIS2XVeVzTdRzH8QEbcsmx7xCc + DASUSzZQQkFBjo0Ycg05ZIoIgnJEKKHjUuQQlkOnqImAypEQN3ghOI3wNjXtzqOQJEolE1GjAurz/e3E + Xg/gn72f+/32236DhFSy0v9cmX5oRoSBwSxlBtAPX6uARzs1LqxWdOHewLJZJSXvySspKQFirKsEwrCc + 4AWKgv2Fp16Vu6k0J+t1UlL3fAXIt17740ZF9y2EIeOU4fXKhim1ZnOClMAqx2Stnd0uaXZ8C+EYpeaW + pzQmjjY47G427x05OPKAQWLxcT7wS08RBqz3pFLjqcqKmYPDtVtvysBv3tca6XQSicVi8VkktZSMs4+p + 8QcP1kFOTk51XrhJ5l4ddxnIhP2IiYkJIUgjlsJjt6h4vRSaLcupspiWR5GCO96NjSMjIDDgk6T7pqam + 2fY4OUhQgDtrSSQTDGBvl5gYNvAlcT4AVDruSp6QgcycBz4sGbAzTdEYiHT/lxoPJ910/DgMiVwh8oQo + D7+GMUvTRALAGbESU46gjFOHKI89JxMSZFNi7eqaTZaIiBcdZBn8HIAaBvxEi3v5MxAKTRv/hTmZkC2d + QtnZrs25MrDFXwrU8BF2vWsZZmE5V4gi9NdQaBPkbGXNUxI2AZJVAT/R1PQ5pyr85w8RMogsZzNzm5uJ + dXNzve0SVUBXA0EHYedz8USVnmBHeKwvQn+l1Yo6c+thDmDhEnaqDGyUAzq8byeqoB16AsHoH3PPoBn6 + a3Q+BVNfn7uwl72tVg74MkBncap24PT0NhcKBBetnyAUE1me96Izd6EcBAGw49NdALhgYdI4CnMAkECw + Ofw7K4RK0laxX/Ru0iRAyJbt9334fQBcXLDg0rVKGaNSQJjRb/GpffDMLDW1oRZ/vIUaFrtgSwAXLS26 + lpYWt+/ptc1yUigohFN7hGJCnmW5AYiBN+qSf+KN9hsYgMBxh7h9DDEYB6JCgUN4LJyaQQDccSErIkMH + UEbmAnp7+43LcsC14XK5LgyxnDgUFnKs5575ougk6a6x23hypAHcpGHLXdpbLyuBjY0Nt5QhAw7i6Gjv + nNgiR9IK463DNTWHk/UjEPom5XQrJvDsxN6Gx+NxS6OJvTia4x0XVaFL8jDeCrdvfLyn+7FQhCIOBHNb + L6vseTxtXt9TMT4CgPMV3VIQv9Te/iC1JmgsBqGd/hurW6sBEHOopaWF18eIloJ+AjCpdfhmrIv3pBw6 + lYEeaew5XV1NANhioK0Nx/FWgGEm1auNuH/bvKgfjQfAFcj/KpgHBLZEANSPLt6wUgrchmnFlU7w9UB8 + Q3hRmZQ1+Arcs1zOG5ITAhh+X9DVjy9r3iAA+F6QlTDJHBw/C1dAmLnnzyFtmDu3aDtjUFbQpSsDfgny + NVRJ9iumUZLHlsFn4M1tbdg7O6uAT+bo7GVOkvESRybym5qgUQ7BNdNQ1yb2bwFasZ90SPaDpoiYlMgB + dOk2z7lFnQDrZGAfAQKniK10OmVrazsRuPeZEM3YPoTHOBWQVZsnkkzASFFgYKBEVA4ndHgIn89bR/DI + MssT0WCjUqdEZFaC0O5rfS3q6sR+OtBh90g6JZJOWRKJZJNOCEJ/RzuIGRuWE3slMPJIN9PRFC2ZVk9e + WgbKDy8Ui/tuL37rCAAWbdNk98jqhZ/eHs0seA+sYV8K66PTX4PR3dcPG3Q02ZtU0iyfhVAs3ANP4RWo + /74O/z267rrhlYKukySjfTPNFzWkaqqUukofoV858IGGmaIOw6v2BTcdSef2JaWD2JaqqOHhigGUH8Xg + cP7sWCyto6PjuuHVsraf4BY9Z5Q0M9384SJl5sYR6JE1x9v7vqG8q7iypZVvMDjnASLdXFG6Mbxju+Pi + 4laWybrysT38d2zz8qNYScGr5OR5ioKSV/v6PomKijq/XdH7RC9fHvAFEPBPf39/t0q6RUVFXRUVFV3K + PpN2Ex5xJO2fP72Tjo6Out3wJLr/Cx5y3P8fkeEjexGhnF4AAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAA4AAAAPCAYAAADUFP50AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABoUlEQVQ4T3WRzUsCQRjG30uHpOMc6rKX + EIIo6BCBipcughcxKA+dBPFk2CH7gCSkoCT6FDopFJ0kSPoHEuoYduo/kMJDRJrYhuvbM7O7tZo98OzM + PO/7m92dIWY2XS5Pc6l0g7n3J7NNNMTh8CbmY3ZmPqCvSuXeEKLNyeQlMq8KLTXOznY+4/Emx2LXElah + 2mFv77Q+P1/ryKUQzOl0UTZgy0HO5Xabkcizqo3hhcnkLWpCgut8cmK+3LZsSCQu9Hz+vBMKGc6a4fUa + /PQ0jBWLsBAd3VFUBvw6MVHtyuAVovYBvgQrLIlm8VNff2CH3+AsPEWUQf8AUsSmPKOAewHbc0Qf6AFL + I6rbBrlY1B4mJ5d6AeVAgKup1KNqtCVB2NU8OsoaPp/eF3S7mSMR5u3tKwuTKcBMZq0Rjb6oI3e4659d + Lma/n7lQuAOjIcF95XJdQA3egvsemKYxt1qLmDEtOArv8DJRHR8Dljy98AbsvI6FoFU4JNLHiVZlaOkH + PoZnzJPtuo6ghDHuw0Ilv1IwRrCkqcQBSoH9Vx5rhIi+AQvvaS8FQaWnAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEWp466Wibuw1LfksrbJttfO68zR + y+3sztPTxNzF1rn///+O25VolnazmcS76L69psu7ruagz6d9tILIvurdl5nhpaj19PibidrovsLHn6Dx + +O+iYWCOg7n16u6omd7b8dm4cKxLAAABUElEQVQ4T4XSjXKCMBAEYIIhgJgfGqi0VXz/t+zuJcEW7HSd + AHIfd5GxOv+TAj7aQ+5SKODrdFq24LptlwNAClharFdAkswBzPNcSnicX/4CLdY8PcG7vhtzN77bYtp5 + msALuBnGa627jquLC+oYUoASYAEYogOIMRrr2UPriPOJE6YnYF1G4HntBaD+EoxNj/Ag64F8YpMxJNDp + S1/XJCkNRLMBbrK71JICHo0TEIIxkcDvQOMykF+hvc2ARR4csoFovQUYxxElR9L3VbUDnuA5YiRwsknE + WGuVkg51X+OEsF4A3nVY1zV3cNheIxMEKJRjDNfrNQNMZlFW7hBCWAUMbABR6hmgzgFruMgEAEQGJMA6 + O3APdZqBZwlyh5tS6iYpm6yGYQCh+iz/Sckb2zqHstR52oGKvVlPAJ99B94XIRdHkO7+yB4c8xsccz5/ + A3uTMA5cEvacAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEXetYi7hA35BzKviEX///+lnpTS + 0tL6yKSscQfoUVHi2M+dYgH707v5sHjgKTv6vZP7zbDDvbXxhXfn5+famW3SiFmtgDChZA6sTg7hj067 + jS1+c26PhoLBpWiqSCXDNxw+/9/uAAABUUlEQVQ4T22TW5KFIAxEVQRERMS3js7d/y4nCXhH0C4/gD50 + G6vMykhDPQxhGRQDg+PcxUQKOMFd2Hh5QO456XSn44tf7w1ZHvD+vp9OiJPtfsuo6wJcjRLCQUktYJnl + u7gBzPHj+PnqODif2R2oxs6r6Rp6ZJIAgJQX0zSwzvI0AQ7BwuuNtLbLqnvCXI3SSvRR4ENClSRISwEo + a6y0jwRI9f0UgMA9Ya4mD8CbgGm7JzBCLY4BtyngJQHvgoPmG7ChSw04gn0Ay4R+36JgIALmCKBP3Svw + lbHGGJvpOAG/pIQE1aoRAZNUaMg1RhVtUbQBSBOwVxWoHv0U0JMZxwnug5Satm1LE7RevA0dxa9eljkC + mAatASg+uNP6Piab8eTj/ZZsHSWcUAHyJSutY4AqQkkoSCrCGZRcBXECTkFqvwXvCXr996OEmr0If+Ky + /APF9SQT8y52/AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEVkptu0tLP+0bCn1/v////K7PpQ + S0e34vro6OiMyvv+27+bvdj95NHS0M3PtqXz8/P/9OmRj4vh6/Lx+v10b2qPgXj//PL97N6mqar6+/ux + o5q2nIn+xp/jzLr/+/jF2ulW71bcAAABXklEQVQ4T22SgXaDIAxFRTAixapdmNAO/f+/XILMFextpULu + ecnRNntX8+i6L3XS3G490/WpyHfEB+GErUqQspe5eiBLoeklKdmhHrS5JJwBFJ92ZYIcssAjymEgoxL+ + I7pUrwU64wl8jdBZoBZkSK+v5ATukYSpQAc23oUpcOYfQdNXl0IuZWgbdOAZEv1V4CnGPCRN+UkYtT+e + JNWHi0AdlBK5xTA0HwQiCQPT+Mektnm1xrSMsXbdQhJSnROsaX9KWnsmNCTQQcVPy0LGazpJ+cdl+N6I + ZtL7rumzk2Di6xVNvBu+7i/6JSFPq5TXxjpwYBDMimABwVmaIZdZsKtbZrg7EBbAQIxQC7PDJ1qH7o4Y + MT5hnQth/V4AcSXJPXEEwDiXwhSWRcGII8JGyxjUtpWC8oBLwMmjImHn00pQ9Lj5FdFyrJVQ/KOYEN6F + 6RBoCTlFhfcZhPDigvC/g7wiweZA6wYAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEUEb/4+jNWn1/potfrO7vq65Pqa + utRMlNOJx/r///9Xpfie0/qv3fqTzPpClfbs+PwRcOIsf9d1rtx7v/hdm83I3O0jgfbi7fsxfMGPz/iN + xO+SxOVgpOWtyeI9h8qhyP77FFykAAABs0lEQVQ4T12TjXbCIAyFQ7GDQuloabF1TN//LXcTqDqv53hC + 8pE/lIb/GrdmnPoAvnP+bmYTDVt/eckRlWayANPwtfSnLomgW7VfwNqP4up7nxnIIxyIAnoCEAMTx4kM + nxDvewF+KwDpGidC0Qs7zwxj1wngZgnHWSEDzs8SAIDA10kPM8fk0gl03nsG0ESMkWYY7AL2AmzgeO8A + RINxjiO9AT7obGTWW3GlpG08jmOavH8C2J9CkW6UORUSWpsp6waYOn4uTj0WVi6TdEtagEVsnm6KowxE + psaJ3HWgR7MF6LoQvAcQmzNvdFXNFsAfvvOkzgxx39DDvR0yACToApm6UoorSqDJBRew31XftXPapakU + M6NIXNoUNkx052WOvMm4W5TxOe7L2AD0VYw8mDZQwdl7p27hbdX8WpgRGSgqG0KwCd8twyqPibBP9TWx + R5sg+wZgQQ+bnAAx1XjSZw9eUqZ6n6UQ5E/XMgDguMWbiaJBB5zBnwBO1gar24925/yIvzIgihXCU3so + 2mlRA+5rlVGK3yXubIh+BNiWr5dWFGgmS4D/cvHj7/0JXH+bUTUMf7iHJISUtmCpAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEWp1vfU6/j/2aj/+vL/wnT/tVb/ + 7dX/vGb/58j/4Ln/8+KQyfbD2u7/9en/0ZW95fz//Pj/yIH/sk11u/f/+O7/qz7//v3/////8d////7+ + ///9///+/v7+/v/6/P7/rUKjVo6/AAABB0lEQVQ4T9WS2ZKDIBBFWWRLUBuTSIij8/9/Oc0Wg0nVvM7c + l77Aoem6Svwv+osAh2KqDkAYTDbAcz0CIHQ2juX6BGaZekt1TUv9fU/1BehU3JJTAvpbbbA/wQcxgD+5 + Hj0oFfJuM4NxeDseQJf7JB2GTOLDqThUC6zLsjyKL6rA3TG8RkdKaUtU4MoEC96SkYyfAR8Ag7CEnMcv + rwejZYmynYGeLxfy8EYpIUrmDTBv1lqaHPRvHTjDjNZtW8u6qAKcqa6kw/eUUBmQ3STMHDzXOKmZ6oeK + yoBxGjDkIAXeBide/ppmSK9VPIIYSVUDBONS1bf9kbZDnw+CiR89qwU+6B8A3v8ACv5VVO6IwWoAAAAA + SUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEW8vLzpbZrCwsLztMy1tbX0u9L1 + w9mAgIDsg6nW1tb///+srKzOzs7vmrzqeaJsbGzukrTwpcPyrsnyqsb21eeoSmzo6Ojwnbz09PTkX4/v + ocLwob7tjbDvlbfvncHumLg96vaQAAABkUlEQVQ4T4WT0ZqcIAxGUXTL6EAhtM2OgL7/W/YPoLXd7bfn + YkRyTEJ01PIFanmMz//yS4Tp2/gvSqlxfGJxCtioeyfXTRXUKYC2jfv++3eGjoRa/BLUNLVYR8KjbN6E + 6fn+GfWYTXi0U3/kyrAs81tlBm8/cCXSWIiAuAi6CQLiOoQQ57kJ6yoleobGvO3bRlrfhZa8sx3WBqJY + hbVnOEGcrN33SGE7BXUX5lnTtgUU2PYutFNogKAQmdHBnwyTklM0gt2I+JAOwh6uDCihCSfXZBm1vbcx + RrY9Q58DBNKhJIqHLxhDKoU/CJQ4ogqjAKWj2Cr0SVLEbHVCAmsZ8ZgSpyrIm0UPMvuZUsKDJaGDxMyt + SfkGZA54XofDmGwyYuyLtS1DLyETiGZ4DVBKOTIuvjWJd7GOECiyewFnii/eCP4uJJ/xPBgyhOycGHfB + o/hrAM4z24wSxrkqIL6iB++LGRzI2dsjC1VYvwsrSrB1ThJIalwEKfH+EPCBH95IBy8J1F5kDeHi52fo + L/7+y/Ibq9osq6OEvI8AAAAASUVORK5CYII= + + + + SetunaConfig.xml + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAYFBMVEVireiHyPm9hxOshkX///+i1vu0 + eQH9BjHT09FeamKnoZPNxKrHlbWhZgLeHT6JfmSy4PvF5/DVSm+IayXCpGbo5uWwpcSrfS3XdJa+wKW4 + jTTHThe5tbqcYQHBxdCawNG4WlxBAAABOElEQVQ4T22PgYKCIBBE1VJMTkTEEkLv///yhoU6QYaiZecx + S9U90dqvayyjUmB1w+BSIgdcPxzxEBQA3gRpo82whNr2ZAXANl3XoaeP/tDWNnS0NOsDaMN5Dzl3YOdG + 6y5EBKDRwzRNy+O7cLJnwCKSJNg7Vl2S8AHejIkx1iUAPohQFwHvs++Q2wl4Lb/z3KsAMDdDJk1YKim3 + 6DNxAOB5gpQ/SpCv1HOW0iSAT2hbSTOEt6XkY5pAwMaEYMKhbLMEAL6JIUqpo61bjMgT2tq/YlNqgw9d + AdzahNfT+1fAX5NY+C0nUJfMmr5lwL+fAurSGyAPEFkGJF5Q1VFmvwC4XlcVEdgKgDciAMLsrwygfvRR + XRJC+1858Mg1JP/itnuNy44VdhzPgB4DQZ+PzsCqb1dxGPf7H/00IoPwxzc8AAAAAElFTkSuQmCC + + + + + ..\Resources\white.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/SETUNA/SETUNA.csproj b/SETUNA/SETUNA.csproj index a414008..2ddeb46 100644 --- a/SETUNA/SETUNA.csproj +++ b/SETUNA/SETUNA.csproj @@ -163,6 +163,12 @@ + + Form + + + Magnifier.cs + @@ -522,6 +528,9 @@ ContextStyleMenuStrip.cs + + Magnifier.cs + OptionForm.cs @@ -669,6 +678,12 @@ true + + + + + +