From 8ab1cfd784fd3cc9ea886a75bf3220ba66545b3c Mon Sep 17 00:00:00 2001 From: Lorenz Cuno Klopfenstein Date: Sat, 9 Oct 2010 20:51:23 +0200 Subject: [PATCH] Almost complete command line options implementation. Changed position context menu: now locks on a screen position and keeps it after moving/resizing. Some bugfixes and code refactoring. --- OnTopReplica/Actions.cs | 15 + OnTopReplica/Assets/pos_center.png | Bin 0 -> 231 bytes OnTopReplica/ExtensionAttribute.cs | 11 + OnTopReplica/MainForm.Designer.cs | 34 +- OnTopReplica/MainForm.cs | 78 +- OnTopReplica/MainForm_Features.cs | 118 ++ OnTopReplica/MainForm_Gui.cs | 14 +- OnTopReplica/MainForm_MenuEvents.cs | 81 +- OnTopReplica/NDesk/Options/Options.cs | 1103 ++++++++++++ OnTopReplica/OnTopReplica.csproj | 27 + OnTopReplica/OnTopReplica.csproj.user | 3 + OnTopReplica/Program.cs | 15 +- OnTopReplica/Properties/Resources.Designer.cs | 7 + OnTopReplica/Properties/Resources.resx | 5 +- OnTopReplica/ScreenPosition.cs | 77 + OnTopReplica/SidePanels/RegionPanel.cs | 4 +- OnTopReplica/StartupOptions/CliStatus.cs | 21 + .../CommandLineReportForm.Designer.cs | 116 ++ .../StartupOptions/CommandLineReportForm.cs | 31 + .../StartupOptions/CommandLineReportForm.resx | 1574 +++++++++++++++++ OnTopReplica/StartupOptions/Factory.cs | 79 + OnTopReplica/StartupOptions/Options.cs | 129 ++ .../StartupOptions/RectangleConverter.cs | 61 + .../StartupOptions/ScreenPositionConverter.cs | 50 + OnTopReplica/StartupOptions/SizeConverter.cs | 56 + OnTopReplica/StoredRegion.cs | 8 +- OnTopReplica/Strings.Designer.cs | 20 +- OnTopReplica/Strings.it.Designer.cs | 0 OnTopReplica/Strings.it.resx | 954 +++++----- OnTopReplica/Strings.resx | 957 +++++----- OnTopReplica/WindowHandle.cs | 11 +- 31 files changed, 4696 insertions(+), 963 deletions(-) create mode 100644 OnTopReplica/Actions.cs create mode 100644 OnTopReplica/Assets/pos_center.png create mode 100644 OnTopReplica/ExtensionAttribute.cs create mode 100644 OnTopReplica/MainForm_Features.cs create mode 100644 OnTopReplica/NDesk/Options/Options.cs create mode 100644 OnTopReplica/ScreenPosition.cs create mode 100644 OnTopReplica/StartupOptions/CliStatus.cs create mode 100644 OnTopReplica/StartupOptions/CommandLineReportForm.Designer.cs create mode 100644 OnTopReplica/StartupOptions/CommandLineReportForm.cs create mode 100644 OnTopReplica/StartupOptions/CommandLineReportForm.resx create mode 100644 OnTopReplica/StartupOptions/Factory.cs create mode 100644 OnTopReplica/StartupOptions/Options.cs create mode 100644 OnTopReplica/StartupOptions/RectangleConverter.cs create mode 100644 OnTopReplica/StartupOptions/ScreenPositionConverter.cs create mode 100644 OnTopReplica/StartupOptions/SizeConverter.cs create mode 100644 OnTopReplica/Strings.it.Designer.cs diff --git a/OnTopReplica/Actions.cs b/OnTopReplica/Actions.cs new file mode 100644 index 0000000..8406001 --- /dev/null +++ b/OnTopReplica/Actions.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OnTopReplica { + + public delegate void Action(); + + public delegate void Action(T1 arg1); + + public delegate void Action(T1 arg1, T2 arg2); + + public delegate void Action(T1 arg1, T2 arg2, T3 arg3); + +} diff --git a/OnTopReplica/Assets/pos_center.png b/OnTopReplica/Assets/pos_center.png new file mode 100644 index 0000000000000000000000000000000000000000..d672a20baab23469fa22cbf4d711e4ae2c6c2e60 GIT binary patch literal 231 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`jKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sBugD~Uq{1qucLCF%=h?3y^w370~qEv=}#LT=BJwMkFg)(D3 zQ$179u0Iceio!iz978PplV_M@Ui!b(d-|e;2@=dw2UhYe`FUohv4(_7TONa7>EQzm zIgP@Z$)D|YH8@zCk92V66x?VuxqkinVxan}1CO5Y8!~I~9Z8%pLE{_K(wmYD3x!y+ Um;83;1zN%2>FVdQ&MBb@00?tREdT%j literal 0 HcmV?d00001 diff --git a/OnTopReplica/ExtensionAttribute.cs b/OnTopReplica/ExtensionAttribute.cs new file mode 100644 index 0000000..09eb1e5 --- /dev/null +++ b/OnTopReplica/ExtensionAttribute.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace System.Runtime.CompilerServices { + /// + /// Fake extension attribute that adds extension method support to C# 2 (without System.Core.dll reference). + /// + class ExtensionAttribute : Attribute { + } +} diff --git a/OnTopReplica/MainForm.Designer.cs b/OnTopReplica/MainForm.Designer.cs index 880e5af..5a50c43 100644 --- a/OnTopReplica/MainForm.Designer.cs +++ b/OnTopReplica/MainForm.Designer.cs @@ -53,8 +53,10 @@ this.toolStripSeparator3 = new System.Windows.Forms.ToolStripSeparator(); this.fullscreenToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); this.dockToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.disabledToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.topLeftToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.topRightToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.centerToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.bottomLeftToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.bottomRightToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.chromeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); @@ -115,6 +117,7 @@ this.menuWindows.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { this.noneToolStripMenuItem}); this.menuWindows.Name = "menuWindows"; + this.menuWindows.OwnerItem = this.menuContextWindows; this.menuWindows.Size = new System.Drawing.Size(118, 26); this.menuWindows.Opening += new System.ComponentModel.CancelEventHandler(this.Menu_Windows_opening); // @@ -206,6 +209,7 @@ this.toolStripMenuItem3, this.toolStripMenuItem4}); this.menuOpacity.Name = "menuOpacity"; + this.menuOpacity.OwnerItem = this.fullOpacityToolStripMenuItem; this.menuOpacity.ShowCheckMargin = true; this.menuOpacity.ShowImageMargin = false; this.menuOpacity.Size = new System.Drawing.Size(154, 92); @@ -315,8 +319,10 @@ // dockToolStripMenuItem // this.dockToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.disabledToolStripMenuItem, this.topLeftToolStripMenuItem, this.topRightToolStripMenuItem, + this.centerToolStripMenuItem, this.bottomLeftToolStripMenuItem, this.bottomRightToolStripMenuItem}); this.dockToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_null; @@ -324,12 +330,22 @@ this.dockToolStripMenuItem.Size = new System.Drawing.Size(168, 22); this.dockToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosition; this.dockToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuPositionTT; + this.dockToolStripMenuItem.DropDownOpening += new System.EventHandler(this.Menu_Position_Opening); + // + // disabledToolStripMenuItem + // + this.disabledToolStripMenuItem.Checked = true; + this.disabledToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked; + this.disabledToolStripMenuItem.Name = "disabledToolStripMenuItem"; + this.disabledToolStripMenuItem.Size = new System.Drawing.Size(152, 22); + this.disabledToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosDisabled; + this.disabledToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_Disable); // // topLeftToolStripMenuItem // this.topLeftToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_topleft; this.topLeftToolStripMenuItem.Name = "topLeftToolStripMenuItem"; - this.topLeftToolStripMenuItem.Size = new System.Drawing.Size(145, 22); + this.topLeftToolStripMenuItem.Size = new System.Drawing.Size(152, 22); this.topLeftToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosTopLeft; this.topLeftToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_TopLeft); // @@ -337,15 +353,23 @@ // this.topRightToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_topright; this.topRightToolStripMenuItem.Name = "topRightToolStripMenuItem"; - this.topRightToolStripMenuItem.Size = new System.Drawing.Size(145, 22); + this.topRightToolStripMenuItem.Size = new System.Drawing.Size(152, 22); this.topRightToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosTopRight; this.topRightToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_TopRight); // + // centerToolStripMenuItem + // + this.centerToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_center; + this.centerToolStripMenuItem.Name = "centerToolStripMenuItem"; + this.centerToolStripMenuItem.Size = new System.Drawing.Size(152, 22); + this.centerToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosCenter; + this.centerToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_Center); + // // bottomLeftToolStripMenuItem // this.bottomLeftToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_bottomleft; this.bottomLeftToolStripMenuItem.Name = "bottomLeftToolStripMenuItem"; - this.bottomLeftToolStripMenuItem.Size = new System.Drawing.Size(145, 22); + this.bottomLeftToolStripMenuItem.Size = new System.Drawing.Size(152, 22); this.bottomLeftToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosBottomLeft; this.bottomLeftToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_BottomLeft); // @@ -353,7 +377,7 @@ // this.bottomRightToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_bottomright; this.bottomRightToolStripMenuItem.Name = "bottomRightToolStripMenuItem"; - this.bottomRightToolStripMenuItem.Size = new System.Drawing.Size(145, 22); + this.bottomRightToolStripMenuItem.Size = new System.Drawing.Size(152, 22); this.bottomRightToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosBottomRight; this.bottomRightToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_BottomRight); // @@ -568,6 +592,8 @@ private System.Windows.Forms.ToolStripMenuItem clickThroughToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem groupSwitchModeToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem enableClickthroughToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem centerToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem disabledToolStripMenuItem; } } diff --git a/OnTopReplica/MainForm.cs b/OnTopReplica/MainForm.cs index 38930cc..77e04b8 100644 --- a/OnTopReplica/MainForm.cs +++ b/OnTopReplica/MainForm.cs @@ -8,6 +8,7 @@ using VistaControls.TaskDialog; using System.Collections.Generic; using OnTopReplica.Native; using OnTopReplica.Update; +using OnTopReplica.StartupOptions; namespace OnTopReplica { @@ -23,14 +24,17 @@ namespace OnTopReplica { MessagePumpManager _msgPumpManager = new MessagePumpManager(); UpdateManager _updateManager = new UpdateManager(); - FormBorderStyle _defaultBorderStyle; + Options _startupOptions; - public MainForm() { + public MainForm(Options startupOptions) { + _startupOptions = startupOptions; + + //WinForms init pass InitializeComponent(); KeepAspectRatio = false; + GlassEnabled = true; //Store default values - _defaultBorderStyle = FormBorderStyle; _nonClickThroughKey = TransparencyKey; //Thumbnail panel @@ -98,18 +102,18 @@ namespace OnTopReplica { } } - protected override void OnShown(EventArgs e) { - base.OnShown(e); + protected override void OnHandleCreated(EventArgs e){ + base.OnHandleCreated(e); //Platform specific form initialization Program.Platform.InitForm(this); - - //Glassify window - GlassEnabled = true; } - protected override void OnHandleCreated(EventArgs e) { - base.OnHandleCreated(e); + protected override void OnShown(EventArgs e) { + base.OnShown(e); + + //Apply startup options + _startupOptions.Apply(this); //Check for updates _updateManager.UpdateCheckCompleted += new EventHandler(UpdateManager_CheckCompleted); @@ -132,10 +136,19 @@ namespace OnTopReplica { fullMargins; } + protected override void OnResizeEnd(EventArgs e) { + base.OnResizeEnd(e); + + //If locked in position, move accordingly + if (PositionLock.HasValue) { + this.SetScreenPosition(PositionLock.Value); + } + } + protected override void OnActivated(EventArgs e) { base.OnActivated(e); - //Deactivate click-through if reactivated + //Deactivate click-through if form is reactivated if (ClickThroughEnabled) { ClickThroughEnabled = false; } @@ -147,7 +160,7 @@ namespace OnTopReplica { base.OnDeactivate(e); //HACK: sometimes, even if TopMost is true, the window loses its "always on top" status. - // This is an attempt of a fix that probably won't work... + // This is a fix attempt that probably won't work... if (!IsFullscreen) { //fullscreen mode doesn't use TopMost TopMost = false; TopMost = true; @@ -268,8 +281,8 @@ namespace OnTopReplica { IsFullscreen = false; } //Disable click forwarding - else if (_thumbnailPanel.ReportThumbnailClicks) { - _thumbnailPanel.ReportThumbnailClicks = false; + else if (ClickForwardingEnabled) { + ClickForwardingEnabled = false; } } } @@ -353,13 +366,17 @@ namespace OnTopReplica { /// /// Handle to the window to clone. /// Region of the window to clone. - public void SetThumbnail(WindowHandle handle, StoredRegion region) { + public void SetThumbnail(WindowHandle handle, Rectangle? region) { try { CurrentThumbnailWindowHandle = handle; _thumbnailPanel.SetThumbnailHandle(handle); - if (region != null) - _thumbnailPanel.SelectedRegion = region.Rect; +#if DEBUG + Console.WriteLine("Cloning window HWND {0}.", handle.Handle); +#endif + + if (region.HasValue) + _thumbnailPanel.SelectedRegion = region.Value; else _thumbnailPanel.ConstrainToRegion = false; @@ -474,33 +491,6 @@ namespace OnTopReplica { #endregion - #region Click-through - - bool _clickThrough = false; - Color _nonClickThroughKey; - - public bool ClickThroughEnabled { - get { - return _clickThrough; - } - set { - //Adjust opacity if fully opaque - if (value && Opacity == 1.0) - Opacity = 0.75; - if (!value) - Opacity = 1.0; - - //Enable transparency and force as top-most - TransparencyKey = (value) ? Color.Black : _nonClickThroughKey; - if (value) - TopMost = true; - - _clickThrough = value; - } - } - - #endregion - #region Accessors /// diff --git a/OnTopReplica/MainForm_Features.cs b/OnTopReplica/MainForm_Features.cs new file mode 100644 index 0000000..79f48c7 --- /dev/null +++ b/OnTopReplica/MainForm_Features.cs @@ -0,0 +1,118 @@ +using System; +using System.Collections.Generic; +using System.Text; +using OnTopReplica.Properties; +using VistaControls.TaskDialog; +using System.Drawing; +using System.Windows.Forms; + +namespace OnTopReplica { + //Contains some feature implementations of MainForm + partial class MainForm { + + #region Click forwarding + + public bool ClickForwardingEnabled { + get { + return _thumbnailPanel.ReportThumbnailClicks; + } + set { + if (value && Settings.Default.FirstTimeClickForwarding) { + TaskDialog dlg = new TaskDialog(Strings.InfoClickForwarding, Strings.InfoClickForwardingTitle, Strings.InfoClickForwardingContent) { + CommonButtons = TaskDialogButton.Yes | TaskDialogButton.No + }; + if (dlg.Show(this).CommonButton == Result.No) + return; + + Settings.Default.FirstTimeClickForwarding = false; + } + + _thumbnailPanel.ReportThumbnailClicks = value; + } + } + + #endregion + + #region Click-through + + bool _clickThrough = false; + Color _nonClickThroughKey; + + public bool ClickThroughEnabled { + get { + return _clickThrough; + } + set { + //Adjust opacity if fully opaque + /*if (value && Opacity == 1.0) + Opacity = 0.75; + if (!value) + Opacity = 1.0;*/ + + //Enable transparency and force as top-most + TransparencyKey = (value) ? Color.Black : _nonClickThroughKey; + if (value) + TopMost = true; + + _clickThrough = value; + } + } + + #endregion + + #region Chrome + + public bool IsChromeVisible { + get { + return (FormBorderStyle == FormBorderStyle.SizableToolWindow); + } + set { + if (!value) { + FormBorderStyle = FormBorderStyle.None; + if (IsChromeVisible) { + Location = new Point { + X = Location.X + SystemInformation.FrameBorderSize.Width, + Y = Location.Y + SystemInformation.FrameBorderSize.Height + }; + } + } + else if(value) { + FormBorderStyle = FormBorderStyle.SizableToolWindow; + if (!IsChromeVisible) { + Location = new Point { + X = Location.X - SystemInformation.FrameBorderSize.Width, + Y = Location.Y - SystemInformation.FrameBorderSize.Height + }; + } + } + + Program.Platform.OnFormStateChange(this); + Invalidate(); + } + } + + #endregion + + #region Position lock + + ScreenPosition? _positionLock = null; + + /// + /// Gets or sets the screen position where the window is currently locked in. + /// + public ScreenPosition? PositionLock { + get { + return _positionLock; + } + set { + if (value != null) + this.SetScreenPosition(value.Value); + + _positionLock = value; + } + } + + #endregion + + } +} diff --git a/OnTopReplica/MainForm_Gui.cs b/OnTopReplica/MainForm_Gui.cs index b460479..996d2f9 100644 --- a/OnTopReplica/MainForm_Gui.cs +++ b/OnTopReplica/MainForm_Gui.cs @@ -38,18 +38,24 @@ namespace OnTopReplica { return new Point(finX, finY); } - private int ChromeBorderVertical { + /// + /// Gets the window's vertical chrome size. + /// + public int ChromeBorderVertical { get { - if (FormBorderStyle == _defaultBorderStyle) + if (IsChromeVisible) return SystemInformation.FrameBorderSize.Height; else return 0; } } - private int ChromeBorderHorizontal { + /// + /// Gets the window's horizontal chrome size. + /// + public int ChromeBorderHorizontal { get { - if (FormBorderStyle == _defaultBorderStyle) + if (IsChromeVisible) return SystemInformation.FrameBorderSize.Width; else return 0; diff --git a/OnTopReplica/MainForm_MenuEvents.cs b/OnTopReplica/MainForm_MenuEvents.cs index c0fa130..cb11e63 100644 --- a/OnTopReplica/MainForm_MenuEvents.cs +++ b/OnTopReplica/MainForm_MenuEvents.cs @@ -20,8 +20,8 @@ namespace OnTopReplica { selectRegionToolStripMenuItem.Enabled = showing; switchToWindowToolStripMenuItem.Enabled = showing; resizeToolStripMenuItem.Enabled = showing; - chromeToolStripMenuItem.Checked = (FormBorderStyle == _defaultBorderStyle); - clickForwardingToolStripMenuItem.Checked = _thumbnailPanel.ReportThumbnailClicks; + chromeToolStripMenuItem.Checked = IsChromeVisible; + clickForwardingToolStripMenuItem.Checked = ClickForwardingEnabled; chromeToolStripMenuItem.Enabled = showing; clickThroughToolStripMenuItem.Enabled = showing; clickForwardingToolStripMenuItem.Enabled = showing; @@ -50,7 +50,9 @@ namespace OnTopReplica { } var selectionData = (WindowListHelper.WindowSelectionData)tsi.Tag; - SetThumbnail(selectionData.Handle, selectionData.Region); + Rectangle? bounds = (selectionData.Region != null) + ? (Rectangle?)selectionData.Region.Bounds : null; + SetThumbnail(selectionData.Handle, bounds); } private void Menu_Switch_click(object sender, EventArgs e) { @@ -66,17 +68,7 @@ namespace OnTopReplica { } private void Menu_ClickForwarding_click(object sender, EventArgs e) { - if (Settings.Default.FirstTimeClickForwarding && !_thumbnailPanel.ReportThumbnailClicks) { - TaskDialog dlg = new TaskDialog(Strings.InfoClickForwarding, Strings.InfoClickForwardingTitle, Strings.InfoClickForwardingContent) { - CommonButtons = TaskDialogButton.Yes | TaskDialogButton.No - }; - if (dlg.Show(this).CommonButton == Result.No) - return; - - Settings.Default.FirstTimeClickForwarding = false; - } - - _thumbnailPanel.ReportThumbnailClicks = !_thumbnailPanel.ReportThumbnailClicks; + ClickForwardingEnabled = !ClickForwardingEnabled; } private void Menu_ClickThrough_click(object sender, EventArgs e) { @@ -138,40 +130,37 @@ namespace OnTopReplica { IsFullscreen = true; } - private void Menu_Position_TopLeft(object sender, EventArgs e) { - var screen = Screen.FromControl(this); + private void Menu_Position_Opening(object sender, EventArgs e) { + disabledToolStripMenuItem.Checked = (PositionLock == null); + topLeftToolStripMenuItem.Checked = (PositionLock == ScreenPosition.TopLeft); + topRightToolStripMenuItem.Checked = (PositionLock == ScreenPosition.TopRight); + centerToolStripMenuItem.Checked = (PositionLock == ScreenPosition.Center); + bottomLeftToolStripMenuItem.Checked = (PositionLock == ScreenPosition.BottomLeft); + bottomRightToolStripMenuItem.Checked = (PositionLock == ScreenPosition.BottomRight); + } - Location = new Point( - screen.WorkingArea.Left - ChromeBorderHorizontal, - screen.WorkingArea.Top - ChromeBorderVertical - ); + private void Menu_Position_Disable(object sender, EventArgs e) { + PositionLock = null; + } + + private void Menu_Position_TopLeft(object sender, EventArgs e) { + PositionLock = ScreenPosition.TopLeft; } private void Menu_Position_TopRight(object sender, EventArgs e) { - var screen = Screen.FromControl(this); + PositionLock = ScreenPosition.TopRight; + } - Location = new Point( - screen.WorkingArea.Width - Size.Width + ChromeBorderHorizontal, - screen.WorkingArea.Top - ChromeBorderVertical - ); + private void Menu_Position_Center(object sender, EventArgs e) { + PositionLock = ScreenPosition.Center; } private void Menu_Position_BottomLeft(object sender, EventArgs e) { - var screen = Screen.FromControl(this); - - Location = new Point( - screen.WorkingArea.Left - ChromeBorderHorizontal, - screen.WorkingArea.Height - Size.Height + ChromeBorderVertical - ); + PositionLock = ScreenPosition.BottomLeft; } private void Menu_Position_BottomRight(object sender, EventArgs e) { - var screen = Screen.FromControl(this); - - Location = new Point( - screen.WorkingArea.Width - Size.Width + ChromeBorderHorizontal, - screen.WorkingArea.Height - Size.Height + ChromeBorderVertical - ); + PositionLock = ScreenPosition.BottomRight; } private void Menu_Reduce_click(object sender, EventArgs e) { @@ -180,23 +169,7 @@ namespace OnTopReplica { } private void Menu_Chrome_click(object sender, EventArgs e) { - if (FormBorderStyle == _defaultBorderStyle) { - FormBorderStyle = FormBorderStyle.None; - Location = new Point { - X = Location.X + SystemInformation.FrameBorderSize.Width, - Y = Location.Y + SystemInformation.FrameBorderSize.Height - }; - } - else { - FormBorderStyle = _defaultBorderStyle; - Location = new Point { - X = Location.X - SystemInformation.FrameBorderSize.Width, - Y = Location.Y - SystemInformation.FrameBorderSize.Height - }; - } - - Program.Platform.OnFormStateChange(this); - Invalidate(); + IsChromeVisible = !IsChromeVisible; } private void Menu_Language_click(object sender, EventArgs e) { diff --git a/OnTopReplica/NDesk/Options/Options.cs b/OnTopReplica/NDesk/Options/Options.cs new file mode 100644 index 0000000..871d2d7 --- /dev/null +++ b/OnTopReplica/NDesk/Options/Options.cs @@ -0,0 +1,1103 @@ +// +// Options.cs +// +// Authors: +// Jonathan Pryor +// +// Copyright (C) 2008 Novell (http://www.novell.com) +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// + +// Compile With: +// gmcs -debug+ -r:System.Core Options.cs -o:NDesk.Options.dll +// gmcs -debug+ -d:LINQ -r:System.Core Options.cs -o:NDesk.Options.dll +// +// The LINQ version just changes the implementation of +// OptionSet.Parse(IEnumerable), and confers no semantic changes. + +// +// A Getopt::Long-inspired option parsing library for C#. +// +// NDesk.Options.OptionSet is built upon a key/value table, where the +// key is a option format string and the value is a delegate that is +// invoked when the format string is matched. +// +// Option format strings: +// Regex-like BNF Grammar: +// name: .+ +// type: [=:] +// sep: ( [^{}]+ | '{' .+ '}' )? +// aliases: ( name type sep ) ( '|' name type sep )* +// +// Each '|'-delimited name is an alias for the associated action. If the +// format string ends in a '=', it has a required value. If the format +// string ends in a ':', it has an optional value. If neither '=' or ':' +// is present, no value is supported. `=' or `:' need only be defined on one +// alias, but if they are provided on more than one they must be consistent. +// +// Each alias portion may also end with a "key/value separator", which is used +// to split option values if the option accepts > 1 value. If not specified, +// it defaults to '=' and ':'. If specified, it can be any character except +// '{' and '}' OR the *string* between '{' and '}'. If no separator should be +// used (i.e. the separate values should be distinct arguments), then "{}" +// should be used as the separator. +// +// Options are extracted either from the current option by looking for +// the option name followed by an '=' or ':', or is taken from the +// following option IFF: +// - The current option does not contain a '=' or a ':' +// - The current option requires a value (i.e. not a Option type of ':') +// +// The `name' used in the option format string does NOT include any leading +// option indicator, such as '-', '--', or '/'. All three of these are +// permitted/required on any named option. +// +// Option bundling is permitted so long as: +// - '-' is used to start the option group +// - all of the bundled options are a single character +// - at most one of the bundled options accepts a value, and the value +// provided starts from the next character to the end of the string. +// +// This allows specifying '-a -b -c' as '-abc', and specifying '-D name=value' +// as '-Dname=value'. +// +// Option processing is disabled by specifying "--". All options after "--" +// are returned by OptionSet.Parse() unchanged and unprocessed. +// +// Unprocessed options are returned from OptionSet.Parse(). +// +// Examples: +// int verbose = 0; +// OptionSet p = new OptionSet () +// .Add ("v", v => ++verbose) +// .Add ("name=|value=", v => Console.WriteLine (v)); +// p.Parse (new string[]{"-v", "--v", "/v", "-name=A", "/name", "B", "extra"}); +// +// The above would parse the argument string array, and would invoke the +// lambda expression three times, setting `verbose' to 3 when complete. +// It would also print out "A" and "B" to standard output. +// The returned array would contain the string "extra". +// +// C# 3.0 collection initializers are supported and encouraged: +// var p = new OptionSet () { +// { "h|?|help", v => ShowHelp () }, +// }; +// +// System.ComponentModel.TypeConverter is also supported, allowing the use of +// custom data types in the callback type; TypeConverter.ConvertFromString() +// is used to convert the value option to an instance of the specified +// type: +// +// var p = new OptionSet () { +// { "foo=", (Foo f) => Console.WriteLine (f.ToString ()) }, +// }; +// +// Random other tidbits: +// - Boolean options (those w/o '=' or ':' in the option format string) +// are explicitly enabled if they are followed with '+', and explicitly +// disabled if they are followed with '-': +// string a = null; +// var p = new OptionSet () { +// { "a", s => a = s }, +// }; +// p.Parse (new string[]{"-a"}); // sets v != null +// p.Parse (new string[]{"-a+"}); // sets v != null +// p.Parse (new string[]{"-a-"}); // sets v == null +// + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Globalization; +using System.IO; +using System.Runtime.Serialization; +using System.Security.Permissions; +using System.Text; +using System.Text.RegularExpressions; + +#if LINQ +using System.Linq; +#endif + +#if TEST +using NDesk.Options; +#endif + +namespace NDesk.Options { + + public class OptionValueCollection : IList, IList { + + List values = new List (); + OptionContext c; + + internal OptionValueCollection (OptionContext c) + { + this.c = c; + } + + #region ICollection + void ICollection.CopyTo (Array array, int index) {(values as ICollection).CopyTo (array, index);} + bool ICollection.IsSynchronized {get {return (values as ICollection).IsSynchronized;}} + object ICollection.SyncRoot {get {return (values as ICollection).SyncRoot;}} + #endregion + + #region ICollection + public void Add (string item) {values.Add (item);} + public void Clear () {values.Clear ();} + public bool Contains (string item) {return values.Contains (item);} + public void CopyTo (string[] array, int arrayIndex) {values.CopyTo (array, arrayIndex);} + public bool Remove (string item) {return values.Remove (item);} + public int Count {get {return values.Count;}} + public bool IsReadOnly {get {return false;}} + #endregion + + #region IEnumerable + IEnumerator IEnumerable.GetEnumerator () {return values.GetEnumerator ();} + #endregion + + #region IEnumerable + public IEnumerator GetEnumerator () {return values.GetEnumerator ();} + #endregion + + #region IList + int IList.Add (object value) {return (values as IList).Add (value);} + bool IList.Contains (object value) {return (values as IList).Contains (value);} + int IList.IndexOf (object value) {return (values as IList).IndexOf (value);} + void IList.Insert (int index, object value) {(values as IList).Insert (index, value);} + void IList.Remove (object value) {(values as IList).Remove (value);} + void IList.RemoveAt (int index) {(values as IList).RemoveAt (index);} + bool IList.IsFixedSize {get {return false;}} + object IList.this [int index] {get {return this [index];} set {(values as IList)[index] = value;}} + #endregion + + #region IList + public int IndexOf (string item) {return values.IndexOf (item);} + public void Insert (int index, string item) {values.Insert (index, item);} + public void RemoveAt (int index) {values.RemoveAt (index);} + + private void AssertValid (int index) + { + if (c.Option == null) + throw new InvalidOperationException ("OptionContext.Option is null."); + if (index >= c.Option.MaxValueCount) + throw new ArgumentOutOfRangeException ("index"); + if (c.Option.OptionValueType == OptionValueType.Required && + index >= values.Count) + throw new OptionException (string.Format ( + c.OptionSet.MessageLocalizer ("Missing required value for option '{0}'."), c.OptionName), + c.OptionName); + } + + public string this [int index] { + get { + AssertValid (index); + return index >= values.Count ? null : values [index]; + } + set { + values [index] = value; + } + } + #endregion + + public List ToList () + { + return new List (values); + } + + public string[] ToArray () + { + return values.ToArray (); + } + + public override string ToString () + { + return string.Join (", ", values.ToArray ()); + } + } + + public class OptionContext { + private Option option; + private string name; + private int index; + private OptionSet set; + private OptionValueCollection c; + + public OptionContext (OptionSet set) + { + this.set = set; + this.c = new OptionValueCollection (this); + } + + public Option Option { + get {return option;} + set {option = value;} + } + + public string OptionName { + get {return name;} + set {name = value;} + } + + public int OptionIndex { + get {return index;} + set {index = value;} + } + + public OptionSet OptionSet { + get {return set;} + } + + public OptionValueCollection OptionValues { + get {return c;} + } + } + + public enum OptionValueType { + None, + Optional, + Required, + } + + public abstract class Option { + string prototype, description; + string[] names; + OptionValueType type; + int count; + string[] separators; + + protected Option (string prototype, string description) + : this (prototype, description, 1) + { + } + + protected Option (string prototype, string description, int maxValueCount) + { + if (prototype == null) + throw new ArgumentNullException ("prototype"); + if (prototype.Length == 0) + throw new ArgumentException ("Cannot be the empty string.", "prototype"); + if (maxValueCount < 0) + throw new ArgumentOutOfRangeException ("maxValueCount"); + + this.prototype = prototype; + this.names = prototype.Split ('|'); + this.description = description; + this.count = maxValueCount; + this.type = ParsePrototype (); + + if (this.count == 0 && type != OptionValueType.None) + throw new ArgumentException ( + "Cannot provide maxValueCount of 0 for OptionValueType.Required or " + + "OptionValueType.Optional.", + "maxValueCount"); + if (this.type == OptionValueType.None && maxValueCount > 1) + throw new ArgumentException ( + string.Format ("Cannot provide maxValueCount of {0} for OptionValueType.None.", maxValueCount), + "maxValueCount"); + if (Array.IndexOf (names, "<>") >= 0 && + ((names.Length == 1 && this.type != OptionValueType.None) || + (names.Length > 1 && this.MaxValueCount > 1))) + throw new ArgumentException ( + "The default option handler '<>' cannot require values.", + "prototype"); + } + + public string Prototype {get {return prototype;}} + public string Description {get {return description;}} + public OptionValueType OptionValueType {get {return type;}} + public int MaxValueCount {get {return count;}} + + public string[] GetNames () + { + return (string[]) names.Clone (); + } + + public string[] GetValueSeparators () + { + if (separators == null) + return new string [0]; + return (string[]) separators.Clone (); + } + + protected static T Parse (string value, OptionContext c) + { + TypeConverter conv = TypeDescriptor.GetConverter(typeof(T)); + T t = default (T); + try { + if (value != null) + t = (T) conv.ConvertFromString (value); + } + catch (Exception e) { + throw new OptionException ( + string.Format ( + c.OptionSet.MessageLocalizer ("Could not convert string `{0}' to type {1} for option `{2}'."), + value, typeof (T).Name, c.OptionName), + c.OptionName, e); + } + return t; + } + + internal string[] Names {get {return names;}} + internal string[] ValueSeparators {get {return separators;}} + + static readonly char[] NameTerminator = new char[]{'=', ':'}; + + private OptionValueType ParsePrototype () + { + char type = '\0'; + List seps = new List (); + for (int i = 0; i < names.Length; ++i) { + string name = names [i]; + if (name.Length == 0) + throw new ArgumentException ("Empty option names are not supported.", "prototype"); + + int end = name.IndexOfAny (NameTerminator); + if (end == -1) + continue; + names [i] = name.Substring (0, end); + if (type == '\0' || type == name [end]) + type = name [end]; + else + throw new ArgumentException ( + string.Format ("Conflicting option types: '{0}' vs. '{1}'.", type, name [end]), + "prototype"); + AddSeparators (name, end, seps); + } + + if (type == '\0') + return OptionValueType.None; + + if (count <= 1 && seps.Count != 0) + throw new ArgumentException ( + string.Format ("Cannot provide key/value separators for Options taking {0} value(s).", count), + "prototype"); + if (count > 1) { + if (seps.Count == 0) + this.separators = new string[]{":", "="}; + else if (seps.Count == 1 && seps [0].Length == 0) + this.separators = null; + else + this.separators = seps.ToArray (); + } + + return type == '=' ? OptionValueType.Required : OptionValueType.Optional; + } + + private static void AddSeparators (string name, int end, ICollection seps) + { + int start = -1; + for (int i = end+1; i < name.Length; ++i) { + switch (name [i]) { + case '{': + if (start != -1) + throw new ArgumentException ( + string.Format ("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + start = i+1; + break; + case '}': + if (start == -1) + throw new ArgumentException ( + string.Format ("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + seps.Add (name.Substring (start, i-start)); + start = -1; + break; + default: + if (start == -1) + seps.Add (name [i].ToString ()); + break; + } + } + if (start != -1) + throw new ArgumentException ( + string.Format ("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + } + + public void Invoke (OptionContext c) + { + OnParseComplete (c); + c.OptionName = null; + c.Option = null; + c.OptionValues.Clear (); + } + + protected abstract void OnParseComplete (OptionContext c); + + public override string ToString () + { + return Prototype; + } + } + + [Serializable] + public class OptionException : Exception { + private string option; + + public OptionException () + { + } + + public OptionException (string message, string optionName) + : base (message) + { + this.option = optionName; + } + + public OptionException (string message, string optionName, Exception innerException) + : base (message, innerException) + { + this.option = optionName; + } + + protected OptionException (SerializationInfo info, StreamingContext context) + : base (info, context) + { + this.option = info.GetString ("OptionName"); + } + + public string OptionName { + get {return this.option;} + } + + [SecurityPermission (SecurityAction.LinkDemand, SerializationFormatter = true)] + public override void GetObjectData (SerializationInfo info, StreamingContext context) + { + base.GetObjectData (info, context); + info.AddValue ("OptionName", option); + } + } + + public delegate void OptionAction (TKey key, TValue value); + + public class OptionSet : KeyedCollection + { + public OptionSet () + : this (delegate (string f) {return f;}) + { + } + + public OptionSet (Converter localizer) + { + this.localizer = localizer; + } + + Converter localizer; + + public Converter MessageLocalizer { + get {return localizer;} + } + + protected override string GetKeyForItem (Option item) + { + if (item == null) + throw new ArgumentNullException ("option"); + if (item.Names != null && item.Names.Length > 0) + return item.Names [0]; + // This should never happen, as it's invalid for Option to be + // constructed w/o any names. + throw new InvalidOperationException ("Option has no names!"); + } + + [Obsolete ("Use KeyedCollection.this[string]")] + protected Option GetOptionForName (string option) + { + if (option == null) + throw new ArgumentNullException ("option"); + try { + return base [option]; + } + catch (KeyNotFoundException) { + return null; + } + } + + protected override void InsertItem (int index, Option item) + { + base.InsertItem (index, item); + AddImpl (item); + } + + protected override void RemoveItem (int index) + { + base.RemoveItem (index); + Option p = Items [index]; + // KeyedCollection.RemoveItem() handles the 0th item + for (int i = 1; i < p.Names.Length; ++i) { + Dictionary.Remove (p.Names [i]); + } + } + + protected override void SetItem (int index, Option item) + { + base.SetItem (index, item); + RemoveItem (index); + AddImpl (item); + } + + private void AddImpl (Option option) + { + if (option == null) + throw new ArgumentNullException ("option"); + List added = new List (option.Names.Length); + try { + // KeyedCollection.InsertItem/SetItem handle the 0th name. + for (int i = 1; i < option.Names.Length; ++i) { + Dictionary.Add (option.Names [i], option); + added.Add (option.Names [i]); + } + } + catch (Exception) { + foreach (string name in added) + Dictionary.Remove (name); + throw; + } + } + + public new OptionSet Add (Option option) + { + base.Add (option); + return this; + } + + sealed class ActionOption : Option { + Action action; + + public ActionOption (string prototype, string description, int count, Action action) + : base (prototype, description, count) + { + if (action == null) + throw new ArgumentNullException ("action"); + this.action = action; + } + + protected override void OnParseComplete (OptionContext c) + { + action (c.OptionValues); + } + } + + public OptionSet Add (string prototype, Action action) + { + return Add (prototype, null, action); + } + + public OptionSet Add (string prototype, string description, Action action) + { + if (action == null) + throw new ArgumentNullException ("action"); + Option p = new ActionOption (prototype, description, 1, + delegate (OptionValueCollection v) { action (v [0]); }); + base.Add (p); + return this; + } + + public OptionSet Add (string prototype, OptionAction action) + { + return Add (prototype, null, action); + } + + public OptionSet Add (string prototype, string description, OptionAction action) + { + if (action == null) + throw new ArgumentNullException ("action"); + Option p = new ActionOption (prototype, description, 2, + delegate (OptionValueCollection v) {action (v [0], v [1]);}); + base.Add (p); + return this; + } + + sealed class ActionOption : Option { + Action action; + + public ActionOption (string prototype, string description, Action action) + : base (prototype, description, 1) + { + if (action == null) + throw new ArgumentNullException ("action"); + this.action = action; + } + + protected override void OnParseComplete (OptionContext c) + { + action (Parse (c.OptionValues [0], c)); + } + } + + sealed class ActionOption : Option { + OptionAction action; + + public ActionOption (string prototype, string description, OptionAction action) + : base (prototype, description, 2) + { + if (action == null) + throw new ArgumentNullException ("action"); + this.action = action; + } + + protected override void OnParseComplete (OptionContext c) + { + action ( + Parse (c.OptionValues [0], c), + Parse (c.OptionValues [1], c)); + } + } + + public OptionSet Add (string prototype, Action action) + { + return Add (prototype, null, action); + } + + public OptionSet Add (string prototype, string description, Action action) + { + return Add (new ActionOption (prototype, description, action)); + } + + public OptionSet Add (string prototype, OptionAction action) + { + return Add (prototype, null, action); + } + + public OptionSet Add (string prototype, string description, OptionAction action) + { + return Add (new ActionOption (prototype, description, action)); + } + + protected virtual OptionContext CreateOptionContext () + { + return new OptionContext (this); + } + +#if LINQ + public List Parse (IEnumerable arguments) + { + bool process = true; + OptionContext c = CreateOptionContext (); + c.OptionIndex = -1; + var def = GetOptionForName ("<>"); + var unprocessed = + from argument in arguments + where ++c.OptionIndex >= 0 && (process || def != null) + ? process + ? argument == "--" + ? (process = false) + : !Parse (argument, c) + ? def != null + ? Unprocessed (null, def, c, argument) + : true + : false + : def != null + ? Unprocessed (null, def, c, argument) + : true + : true + select argument; + List r = unprocessed.ToList (); + if (c.Option != null) + c.Option.Invoke (c); + return r; + } +#else + public List Parse (IEnumerable arguments) + { + OptionContext c = CreateOptionContext (); + c.OptionIndex = -1; + bool process = true; + List unprocessed = new List (); + Option def = Contains ("<>") ? this ["<>"] : null; + foreach (string argument in arguments) { + ++c.OptionIndex; + if (argument == "--") { + process = false; + continue; + } + if (!process) { + Unprocessed (unprocessed, def, c, argument); + continue; + } + if (!Parse (argument, c)) + Unprocessed (unprocessed, def, c, argument); + } + if (c.Option != null) + c.Option.Invoke (c); + return unprocessed; + } +#endif + + private static bool Unprocessed (ICollection extra, Option def, OptionContext c, string argument) + { + if (def == null) { + extra.Add (argument); + return false; + } + c.OptionValues.Add (argument); + c.Option = def; + c.Option.Invoke (c); + return false; + } + + private readonly Regex ValueOption = new Regex ( + @"^(?--|-|/)(?[^:=]+)((?[:=])(?.*))?$"); + + protected bool GetOptionParts (string argument, out string flag, out string name, out string sep, out string value) + { + if (argument == null) + throw new ArgumentNullException ("argument"); + + flag = name = sep = value = null; + Match m = ValueOption.Match (argument); + if (!m.Success) { + return false; + } + flag = m.Groups ["flag"].Value; + name = m.Groups ["name"].Value; + if (m.Groups ["sep"].Success && m.Groups ["value"].Success) { + sep = m.Groups ["sep"].Value; + value = m.Groups ["value"].Value; + } + return true; + } + + protected virtual bool Parse (string argument, OptionContext c) + { + if (c.Option != null) { + ParseValue (argument, c); + return true; + } + + string f, n, s, v; + if (!GetOptionParts (argument, out f, out n, out s, out v)) + return false; + + Option p; + if (Contains (n)) { + p = this [n]; + c.OptionName = f + n; + c.Option = p; + switch (p.OptionValueType) { + case OptionValueType.None: + c.OptionValues.Add (n); + c.Option.Invoke (c); + break; + case OptionValueType.Optional: + case OptionValueType.Required: + ParseValue (v, c); + break; + } + return true; + } + // no match; is it a bool option? + if (ParseBool (argument, n, c)) + return true; + // is it a bundled option? + if (ParseBundledValue (f, string.Concat (n + s + v), c)) + return true; + + return false; + } + + private void ParseValue (string option, OptionContext c) + { + if (option != null) + foreach (string o in c.Option.ValueSeparators != null + ? option.Split (c.Option.ValueSeparators, StringSplitOptions.None) + : new string[]{option}) { + c.OptionValues.Add (o); + } + if (c.OptionValues.Count == c.Option.MaxValueCount || + c.Option.OptionValueType == OptionValueType.Optional) + c.Option.Invoke (c); + else if (c.OptionValues.Count > c.Option.MaxValueCount) { + throw new OptionException (localizer (string.Format ( + "Error: Found {0} option values when expecting {1}.", + c.OptionValues.Count, c.Option.MaxValueCount)), + c.OptionName); + } + } + + private bool ParseBool (string option, string n, OptionContext c) + { + Option p; + string rn; + if (n.Length >= 1 && (n [n.Length-1] == '+' || n [n.Length-1] == '-') && + Contains ((rn = n.Substring (0, n.Length-1)))) { + p = this [rn]; + string v = n [n.Length-1] == '+' ? option : null; + c.OptionName = option; + c.Option = p; + c.OptionValues.Add (v); + p.Invoke (c); + return true; + } + return false; + } + + private bool ParseBundledValue (string f, string n, OptionContext c) + { + if (f != "-") + return false; + for (int i = 0; i < n.Length; ++i) { + Option p; + string opt = f + n [i].ToString (); + string rn = n [i].ToString (); + if (!Contains (rn)) { + if (i == 0) + return false; + throw new OptionException (string.Format (localizer ( + "Cannot bundle unregistered option '{0}'."), opt), opt); + } + p = this [rn]; + switch (p.OptionValueType) { + case OptionValueType.None: + Invoke (c, opt, n, p); + break; + case OptionValueType.Optional: + case OptionValueType.Required: { + string v = n.Substring (i+1); + c.Option = p; + c.OptionName = opt; + ParseValue (v.Length != 0 ? v : null, c); + return true; + } + default: + throw new InvalidOperationException ("Unknown OptionValueType: " + p.OptionValueType); + } + } + return true; + } + + private static void Invoke (OptionContext c, string name, string value, Option option) + { + c.OptionName = name; + c.Option = option; + c.OptionValues.Add (value); + option.Invoke (c); + } + + private const int OptionWidth = 29; + + public void WriteOptionDescriptions (TextWriter o) + { + foreach (Option p in this) { + int written = 0; + if (!WriteOptionPrototype (o, p, ref written)) + continue; + + if (written < OptionWidth) + o.Write (new string (' ', OptionWidth - written)); + else { + o.WriteLine (); + o.Write (new string (' ', OptionWidth)); + } + + List lines = GetLines (localizer (GetDescription (p.Description))); + o.WriteLine (lines [0]); + string prefix = new string (' ', OptionWidth+2); + for (int i = 1; i < lines.Count; ++i) { + o.Write (prefix); + o.WriteLine (lines [i]); + } + } + } + + bool WriteOptionPrototype (TextWriter o, Option p, ref int written) + { + string[] names = p.Names; + + int i = GetNextOptionIndex (names, 0); + if (i == names.Length) + return false; + + if (names [i].Length == 1) { + Write (o, ref written, " -"); + Write (o, ref written, names [0]); + } + else { + Write (o, ref written, " --"); + Write (o, ref written, names [0]); + } + + for ( i = GetNextOptionIndex (names, i+1); + i < names.Length; i = GetNextOptionIndex (names, i+1)) { + Write (o, ref written, ", "); + Write (o, ref written, names [i].Length == 1 ? "-" : "--"); + Write (o, ref written, names [i]); + } + + if (p.OptionValueType == OptionValueType.Optional || + p.OptionValueType == OptionValueType.Required) { + if (p.OptionValueType == OptionValueType.Optional) { + Write (o, ref written, localizer ("[")); + } + Write (o, ref written, localizer ("=" + GetArgumentName (0, p.MaxValueCount, p.Description))); + string sep = p.ValueSeparators != null && p.ValueSeparators.Length > 0 + ? p.ValueSeparators [0] + : " "; + for (int c = 1; c < p.MaxValueCount; ++c) { + Write (o, ref written, localizer (sep + GetArgumentName (c, p.MaxValueCount, p.Description))); + } + if (p.OptionValueType == OptionValueType.Optional) { + Write (o, ref written, localizer ("]")); + } + } + return true; + } + + static int GetNextOptionIndex (string[] names, int i) + { + while (i < names.Length && names [i] == "<>") { + ++i; + } + return i; + } + + static void Write (TextWriter o, ref int n, string s) + { + n += s.Length; + o.Write (s); + } + + private static string GetArgumentName (int index, int maxIndex, string description) + { + if (description == null) + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + string[] nameStart; + if (maxIndex == 1) + nameStart = new string[]{"{0:", "{"}; + else + nameStart = new string[]{"{" + index + ":"}; + for (int i = 0; i < nameStart.Length; ++i) { + int start, j = 0; + do { + start = description.IndexOf (nameStart [i], j); + } while (start >= 0 && j != 0 ? description [j++ - 1] == '{' : false); + if (start == -1) + continue; + int end = description.IndexOf ("}", start); + if (end == -1) + continue; + return description.Substring (start + nameStart [i].Length, end - start - nameStart [i].Length); + } + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + } + + private static string GetDescription (string description) + { + if (description == null) + return string.Empty; + StringBuilder sb = new StringBuilder (description.Length); + int start = -1; + for (int i = 0; i < description.Length; ++i) { + switch (description [i]) { + case '{': + if (i == start) { + sb.Append ('{'); + start = -1; + } + else if (start < 0) + start = i + 1; + break; + case '}': + if (start < 0) { + if ((i+1) == description.Length || description [i+1] != '}') + throw new InvalidOperationException ("Invalid option description: " + description); + ++i; + sb.Append ("}"); + } + else { + sb.Append (description.Substring (start, i - start)); + start = -1; + } + break; + case ':': + if (start < 0) + goto default; + start = i + 1; + break; + default: + if (start < 0) + sb.Append (description [i]); + break; + } + } + return sb.ToString (); + } + + private static List GetLines (string description) + { + List lines = new List (); + if (string.IsNullOrEmpty (description)) { + lines.Add (string.Empty); + return lines; + } + int length = 80 - OptionWidth - 2; + int start = 0, end; + do { + end = GetLineEnd (start, length, description); + bool cont = false; + if (end < description.Length) { + char c = description [end]; + if (c == '-' || (char.IsWhiteSpace (c) && c != '\n')) + ++end; + else if (c != '\n') { + cont = true; + --end; + } + } + lines.Add (description.Substring (start, end - start)); + if (cont) { + lines [lines.Count-1] += "-"; + } + start = end; + if (start < description.Length && description [start] == '\n') + ++start; + } while (end < description.Length); + return lines; + } + + private static int GetLineEnd (int start, int length, string description) + { + int end = Math.Min (start + length, description.Length); + int sep = -1; + for (int i = start; i < end; ++i) { + switch (description [i]) { + case ' ': + case '\t': + case '\v': + case '-': + case ',': + case '.': + case ';': + sep = i; + break; + case '\n': + return i; + } + } + if (sep == -1 || end == description.Length) + return end; + return sep; + } + } +} + diff --git a/OnTopReplica/OnTopReplica.csproj b/OnTopReplica/OnTopReplica.csproj index 99264a0..0e22378 100644 --- a/OnTopReplica/OnTopReplica.csproj +++ b/OnTopReplica/OnTopReplica.csproj @@ -106,11 +106,16 @@ AboutForm.cs + Form + + + Form + Form @@ -138,7 +143,9 @@ + + UserControl @@ -148,7 +155,18 @@ GroupSwitchPanel.cs + + + Form + + + CommandLineReportForm.cs + + + + + @@ -184,6 +202,9 @@ GroupSwitchPanel.cs Designer + + CommandLineReportForm.cs + ResXFileCodeGenerator Strings.cs.Designer.cs @@ -238,6 +259,11 @@ + + True + True + Strings.it.resx + Component @@ -271,6 +297,7 @@ + diff --git a/OnTopReplica/OnTopReplica.csproj.user b/OnTopReplica/OnTopReplica.csproj.user index 00156d0..1bf19dd 100644 --- a/OnTopReplica/OnTopReplica.csproj.user +++ b/OnTopReplica/OnTopReplica.csproj.user @@ -15,4 +15,7 @@ false + + /windowId=459573 /r=20,20,100,80 + \ No newline at end of file diff --git a/OnTopReplica/Program.cs b/OnTopReplica/Program.cs index d4c5c2c..5201278 100644 --- a/OnTopReplica/Program.cs +++ b/OnTopReplica/Program.cs @@ -9,6 +9,7 @@ using System.IO; using VistaControls.TaskDialog; using OnTopReplica.Update; using System.Reflection; +using OnTopReplica.StartupOptions; namespace OnTopReplica { @@ -26,7 +27,7 @@ namespace OnTopReplica { /// The main entry point for the application. /// [STAThread] - static void Main() { + static void Main(string[] args) { //Hook abort handler AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); @@ -44,6 +45,16 @@ namespace OnTopReplica { Settings.Default.Upgrade(); Settings.Default.MustUpdate = false; } + + //Load startup options + var options = StartupOptions.Factory.CreateOptions(args); + string optionsMessage = options.DebugMessage; + if (!string.IsNullOrEmpty(optionsMessage)) { //show dialog if debug message present or if parsing failed + var dlg = new CommandLineReportForm(options.Status, optionsMessage); + dlg.ShowDialog(); + } + if (options.Status == CliStatus.Information || options.Status == CliStatus.Error) + return; bool mustReloadForm = false; Point reloadLocation = new Point(); @@ -55,7 +66,7 @@ namespace OnTopReplica { Settings.Default.Language = _languageChangeCode; _languageChangeCode = null; - _mainForm = new MainForm(); + _mainForm = new MainForm(options); if (mustReloadForm) { _mainForm.Location = reloadLocation; _mainForm.Size = reloadSize; diff --git a/OnTopReplica/Properties/Resources.Designer.cs b/OnTopReplica/Properties/Resources.Designer.cs index ee6767b..14e0ce3 100644 --- a/OnTopReplica/Properties/Resources.Designer.cs +++ b/OnTopReplica/Properties/Resources.Designer.cs @@ -165,6 +165,13 @@ namespace OnTopReplica.Properties { } } + internal static System.Drawing.Bitmap pos_center { + get { + object obj = ResourceManager.GetObject("pos_center", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + internal static System.Drawing.Bitmap pos_null { get { object obj = ResourceManager.GetObject("pos_null", resourceCulture); diff --git a/OnTopReplica/Properties/Resources.resx b/OnTopReplica/Properties/Resources.resx index b84794e..6867e30 100644 --- a/OnTopReplica/Properties/Resources.resx +++ b/OnTopReplica/Properties/Resources.resx @@ -223,8 +223,11 @@ ..\Assets\flag_usa.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a - ..\Assets\groupmode.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\pos_center.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + \ No newline at end of file diff --git a/OnTopReplica/ScreenPosition.cs b/OnTopReplica/ScreenPosition.cs new file mode 100644 index 0000000..1859a90 --- /dev/null +++ b/OnTopReplica/ScreenPosition.cs @@ -0,0 +1,77 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using System.Drawing; + +namespace OnTopReplica { + /// + /// Describes a resolution independent position. + /// + enum ScreenPosition { + TopLeft, + TopRight, + BottomLeft, + BottomRight, + Center + } + + /// + /// Extension methods for ScreenPositions. + /// + static class ScreenPositionExtensions { + + /// + /// Sets the form's screen position in independent coordinates. + /// + /// + /// Position is set relative to the form's current screen. + /// + public static void SetScreenPosition(this MainForm form, ScreenPosition position) { + var screen = Screen.FromControl(form); + var wa = screen.WorkingArea; + + Point p = new Point(); + switch (position) { + case ScreenPosition.TopLeft: + p = new Point( + wa.Left - form.ChromeBorderHorizontal, + wa.Top - form.ChromeBorderVertical + ); + break; + + case ScreenPosition.TopRight: + p = new Point( + wa.Right - form.Width + form.ChromeBorderHorizontal, + wa.Top - form.ChromeBorderVertical + ); + break; + + case ScreenPosition.BottomLeft: + p = new Point( + wa.Left - form.ChromeBorderHorizontal, + wa.Bottom - form.Height + form.ChromeBorderVertical + ); + break; + + case ScreenPosition.BottomRight: + p = new Point( + wa.Right - form.Width + form.ChromeBorderHorizontal, + wa.Bottom - form.Height + form.ChromeBorderVertical + ); + break; + + case ScreenPosition.Center: + p = new Point( + wa.X + (wa.Width / 2) - (form.Width / 2) - (form.ChromeBorderHorizontal / 2), + wa.Y + (wa.Height / 2) - (form.Height / 2) - (form.ChromeBorderVertical / 2) + ); + break; + } + + form.Location = p; + } + + } + +} diff --git a/OnTopReplica/SidePanels/RegionPanel.cs b/OnTopReplica/SidePanels/RegionPanel.cs index 871a2a1..f281926 100644 --- a/OnTopReplica/SidePanels/RegionPanel.cs +++ b/OnTopReplica/SidePanels/RegionPanel.cs @@ -55,7 +55,7 @@ namespace OnTopReplica.SidePanels { return; } - SetRegion(region.Rect); + SetRegion(region.Bounds); //Select right combobox if (comboRegions.Items.Contains(region)) { @@ -207,7 +207,7 @@ namespace OnTopReplica.SidePanels { if (region == null) return; - SetRegion(region.Rect); + SetRegion(region.Bounds); } } diff --git a/OnTopReplica/StartupOptions/CliStatus.cs b/OnTopReplica/StartupOptions/CliStatus.cs new file mode 100644 index 0000000..a445e68 --- /dev/null +++ b/OnTopReplica/StartupOptions/CliStatus.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OnTopReplica.StartupOptions { + public enum CliStatus { + /// + /// No errors while parsing. + /// + Ok, + /// + /// User asked for help. + /// + Information, + /// + /// Error while parsing. + /// + Error + } + +} diff --git a/OnTopReplica/StartupOptions/CommandLineReportForm.Designer.cs b/OnTopReplica/StartupOptions/CommandLineReportForm.Designer.cs new file mode 100644 index 0000000..043564a --- /dev/null +++ b/OnTopReplica/StartupOptions/CommandLineReportForm.Designer.cs @@ -0,0 +1,116 @@ +namespace OnTopReplica.StartupOptions { + partial class CommandLineReportForm { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) { + if (disposing && (components != null)) { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(CommandLineReportForm)); + this.buttonOk = new System.Windows.Forms.Button(); + this.labelInstruction = new System.Windows.Forms.Label(); + this.txtDescription = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.txtCliArgs = new System.Windows.Forms.TextBox(); + this.SuspendLayout(); + // + // buttonOk + // + this.buttonOk.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonOk.DialogResult = System.Windows.Forms.DialogResult.OK; + this.buttonOk.Location = new System.Drawing.Point(440, 200); + this.buttonOk.Name = "buttonOk"; + this.buttonOk.Size = new System.Drawing.Size(75, 23); + this.buttonOk.TabIndex = 0; + this.buttonOk.Text = "OK"; + this.buttonOk.UseVisualStyleBackColor = true; + // + // labelInstruction + // + this.labelInstruction.AutoSize = true; + this.labelInstruction.Font = new System.Drawing.Font("Segoe UI", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.labelInstruction.ForeColor = System.Drawing.SystemColors.HotTrack; + this.labelInstruction.Location = new System.Drawing.Point(12, 9); + this.labelInstruction.Name = "labelInstruction"; + this.labelInstruction.Size = new System.Drawing.Size(112, 21); + this.labelInstruction.TabIndex = 1; + this.labelInstruction.Text = "Command line"; + // + // txtDescription + // + this.txtDescription.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.txtDescription.Font = new System.Drawing.Font("Consolas", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.txtDescription.Location = new System.Drawing.Point(12, 42); + this.txtDescription.Multiline = true; + this.txtDescription.Name = "txtDescription"; + this.txtDescription.ReadOnly = true; + this.txtDescription.ScrollBars = System.Windows.Forms.ScrollBars.Vertical; + this.txtDescription.Size = new System.Drawing.Size(503, 152); + this.txtDescription.TabIndex = 2; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(13, 205); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(60, 13); + this.label1.TabIndex = 3; + this.label1.Text = "Arguments:"; + // + // txtCliArgs + // + this.txtCliArgs.Location = new System.Drawing.Point(79, 202); + this.txtCliArgs.Name = "txtCliArgs"; + this.txtCliArgs.ReadOnly = true; + this.txtCliArgs.Size = new System.Drawing.Size(355, 20); + this.txtCliArgs.TabIndex = 4; + // + // CommandLineReportForm + // + this.AcceptButton = this.buttonOk; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.SystemColors.ControlLightLight; + this.ClientSize = new System.Drawing.Size(527, 235); + this.Controls.Add(this.txtCliArgs); + this.Controls.Add(this.label1); + this.Controls.Add(this.txtDescription); + this.Controls.Add(this.labelInstruction); + this.Controls.Add(this.buttonOk); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.Name = "CommandLineReportForm"; + this.Text = "Command line parameters"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button buttonOk; + private System.Windows.Forms.Label labelInstruction; + private System.Windows.Forms.TextBox txtDescription; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox txtCliArgs; + } +} \ No newline at end of file diff --git a/OnTopReplica/StartupOptions/CommandLineReportForm.cs b/OnTopReplica/StartupOptions/CommandLineReportForm.cs new file mode 100644 index 0000000..90eea63 --- /dev/null +++ b/OnTopReplica/StartupOptions/CommandLineReportForm.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Text; +using System.Windows.Forms; + +namespace OnTopReplica.StartupOptions { + public partial class CommandLineReportForm : Form { + + public CommandLineReportForm(CliStatus status, string message) { + InitializeComponent(); + + switch (status) { + case CliStatus.Information: + labelInstruction.Text = "Command line help"; + break; + + case CliStatus.Error: + labelInstruction.Text = "Command line parsing error"; + break; + } + + txtDescription.Text = message; + + txtCliArgs.Text = Environment.CommandLine; + } + + } +} diff --git a/OnTopReplica/StartupOptions/CommandLineReportForm.resx b/OnTopReplica/StartupOptions/CommandLineReportForm.resx new file mode 100644 index 0000000..b6de04b --- /dev/null +++ b/OnTopReplica/StartupOptions/CommandLineReportForm.resx @@ -0,0 +1,1574 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAYAgIAAAAEAIAAoCAEAZgAAADAwAAABACAAqCUAAI4IAQAgIAAAAQAgAKgQAAA2LgEAGBgAAAEA + IACICQAA3j4BABQUAAABACAAuAYAAGZIAQAQEAAAAQAgAGgEAAAeTwEAKAAAAIAAAAAAAQAAAQAgAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAgAAAAMAAAAGAAAABwAAAAoAAAANAAAADwAA + ABEAAAAVAAAAGAAAABoAAAAdAAAAHgAAACAAAAAhAAAAIgAAACIAAAAjAAAAIwAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACAAAAAfAAAAHgAAABwAAAAZAAAAFwAAABMAAAAQAAAADgAAAAsAAAAIAAAABwAAAAQAAAACAAAAAgAA + AAMAAAAEAAAABQAAAAkAAAALAAAADgAAABIAAAAWAAAAGQAAAB0AAAAgAAAAJAAAACcAAAAqAAAAKwAA + AC0AAAAvAAAALwAAADAAAAAwAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAuAAAALQAAACsAAAApAAAAJgAAACIAAAAfAAAAHAAA + ABgAAAAUAAAAEAAAAAwAAAAKAAAABwAAAAQAAAADAAAABAAAAAYAAAAIAAAADAAAAA8AAAATAAAAGAAA + AB0AAAAiAAAAJgAAACoAAAAuAAAAMQAAADQAAAA2AAAAOAAAADoAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOgAA + ADkAAAA4AAAANgAAADMAAAAwAAAALAAAACgAAAAlAAAAIAAAABsAAAAWAAAAEQAAAA4AAAAKAAAABwAA + AAQAAAAFAAAACAAAAAsAAAAPAAAAEwAAABkAAAAfAAAAJQAAACoAAAAvAAAANQAAADoAAAA+AAAAQQAA + AEQAAABGAAAASAAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABIAAAARwAAAEUAAABDAAAAQAAAADwAAAA4AAAAMwAA + AC0AAAAoAAAAIgAAABwAAAAWAAAAEgAAAA0AAAAJAAAABQAAAAcAAAALAAAADQAAABIAAAAYAAAAIAAA + ACYAAAAtAAAANAAAADoAAABAAAAARgAAAEsAAABPAAAAUQAAAFQAAABWAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFYAAABVAAAAUwAAAFAAAABOAAAASQAAAEQAAAA+AAAAOAAAADEAAAAqAAAAIwAAAB0AAAAWAAAAEAAA + AAsAAAAGAAAACAAAAA0AAAARAAAAFwAAAB8AAAAmAAAALgAAADcAAAA+AAAARgAAAEwAAABSAAAAVwAA + AFwAAABfAAAAYgAAAGMAAABkAAAAZQAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAYwAAAGMAAABhAAAAXgAAAFoAAABVAAAAUAAA + AEoAAABDAAAAOgAAADIAAAAqAAAAIwAAABwAAAAVAAAADgAAAAgAAAAKAAAAEAAAABUAAAAdAAAAJAAA + AC0AAAA2AAAAQAAAAEkAAABRAAAAWAAAAF4AAABkAAAAaQAAAGwAAABuAAAAcAAAAHEAAAByAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABwAAAAbwAAAG4AAABqAAAAZwAAAGIAAABcAAAAVQAAAE4AAABFAAAAPAAAADIAAAApAAAAIAAA + ABoAAAASAAAACQAAAA0AAAATAAAAGQAAACEAAAArAAAANQAAAD8AAABJAAAAUwAAAFwAAABlAAAAawAA + AHEAAAB2AAAAeQAAAHsAAAB9AAAAfwAAAH8AAAB+AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH0AAAB8AAAAfAAAAHcAAAB0AAAAbQAA + AGcAAABgAAAAWAAAAE8AAABFAAAAOgAAADAAAAAmAAAAHgAAABUAAAALAAAADwAAABYAAAAeAAAAJgAA + ADAAAAA8AAAASAAAAFQAAABeAAAAagAAAHQAAAB8AAAAgwAAAIcAAACLAAAAjAAAAI0AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjQAAAI0AAACLAAAAhwAAAIEAAAB6AAAAcgAAAGoAAABiAAAAWAAAAE0AAABCAAAANwAA + ACwAAAAiAAAAGQAAAA0AAAARAAAAGQAAACEAAAAqAAAANQAAAEIAAABPAAAAXgAAAG0AAAB8AAAAkAAA + AKAAAACkAAAAqAAAAKoAAACrAAAArAAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACsAAAAqwAAAKoAAAChAAAAlAAA + AIgAAAB9AAAAcwAAAGoAAABgAAAAVQAAAEkAAAA9AAAAMQAAACYAAAAdAAAADwAAABQAAAAbAAAAJQAA + AC4AAAA5AAAARwAAAFcAAABpAAAAgwAAALMMDAzWTk5O8FxcXOxZWVjrWVlY61lZWetaWVnrWllZ61pZ + WetbWlrrWlpa61paWutaWlrrW1pa61paW+taW1vrW1tb61tbW+tbW1vrW1tb61tbW+tbW1vqW1tb6ltb + W+pcW1zqXFtb6lxbW+pcW1vqXFtb6lxbW+pcW1vqXFtb6lxcXOpcXFzqXFxc6lxbW+pcW1vqW1tb6ltb + W+pbW1vqW1tb6lpaW+paWlrqWlpa6lpaWupaWlrqWlpa6lpaWupZWVrqWlla6lpZWepaWlrqWlpa6lpb + WutaW1rrWlta61pbWutaWlrrWlpa61taWutaWlrrWlpa61paWutaWlrrWlpa61paWutaWlrrWlpa61pa + WutaWlrrWlpa61paWutaWlnqWlpZ6lpZWepaWVnqWllZ6lpZWepaWVnqWllZ6lpaWepaWlnqWVlZ61pa + WepaWlnrWlpZ6lpaWupaWlrqWlpa6ltaWupbWlvqWlpa6lpaWupaWlrqWlpa6ltaWupaWlrqWlpa6lpa + WepaWlnqWlpZ6lpaWepbW1vrVFRU7RcXFuEAAADEAAAAngAAAIMAAAB4AAAAcgAAAGYAAABbAAAATwAA + AEMAAAA2AAAAKwAAACEAAAAQAAAAFgAAAB8AAAAoAAAAMgAAAEAAAABRAAAAZQAAAIEAAADLWVlY8ZmY + lc/HwburzsfBp8rGvafKxL2oycO7psbAuaXFvrilxL62pMO+taPBurKjvbiwo7+4r6G9tq6iu7Wtoby0 + rKG6s6yhubOrobeyqqG3s6qgt7KpoLeyqZ62saietK+mnrKupJ6zrqWes66lnrOupZ6zrqWes66lnrOt + pZ6zrKWesquknbKrpJ2yq6Sds6ylnrKspZ60raWdtK6lnbavp524saieurGpn7qzq5+7ta2fvLevnr63 + sZ/AubGfwbqxn8K6sp/FvbSew7yzoMS+tZ/EvrSfxL+1oMS/taHEv7WhxL+1ocW/tqLFv7aixsC4ocfA + uaHHwLmhx8C5ocfAuaHHwLmhyMG5ocjBuaHIwbmhyMG5ocjBuaHIwrqiycK6osnCuaDJwrmhycO7ocnD + u6HJw7uhycO7ocnDu6HJw7uhycK6ocnCuqHKw7uhycK7ocjCuqHHw7mgxsG4oMa+tqDEvbagxLy0nsO7 + sp7BurGew7yznsK7s5/EvLSfxb21nsW+tZ/Gv7igxsC5oMjDuqLJwrqiycO7os3GvqPIw7uloZ6cxWZl + ZO0JCQjdAAAAogAAAIQAAAB7AAAAbQAAAGAAAABUAAAASAAAADsAAAAvAAAAIwAAABIAAAAYAAAAIQAA + ACoAAAA1AAAARAAAAFgAAAB7BQUExHBvbu/Lx8Ktpp2Qd3xxY2RxZVhjcmdZY3JnW2JzZlhhcGZXYW1h + VmBqYFFeZ1xMXmRZSl1hV0hdYVZFXGBURFtdUEFaW01AWlhNP1lXTT1ZVUs7WFJKOlhSSTlYU0g5V1FH + N1dORTRWS0IxVkxBMVZMQTFWTEExVkxBMVZMQTFWTD8xVkw/MVZLPTBWSjwvVUo9MFZMPzFWTEAxVU5B + MVVRQzNVUkU0VVVIOVZZSztWWk09VltPQVdfU0VXYlVIV2NXSFdmWUlXaFpKV2pdTlhqX05YaWBPWGlf + TlhqYE9YamBPWWpgT1lrYVFZbGFSWmxhUlpuYVVabmFVWm9iVlpvYlZab2JWWnBjVlpyZVZacmVWWnJl + VlpyZVZacmVWWnNmV1xzZ1hcdGdYXHRnWF11altddWpbXXVqW111altddWpbXXVqW110aVtddmlaXXZq + Wlx1aVtddGdZXG9lV1twZFRabGBSWmpeUVlqXU1XZ1xMV2lcS1dpXUxXZltMWGleTlhrX09YbWFRWm1i + VFpvZFdbcmVYXHBkVltwZFdccGNVXHNpWluflIdszcfCn4WEg+kODg3XAAAAnQAAAIMAAABzAAAAZgAA + AFkAAABLAAAAPQAAADIAAAAmAAAAFAAAABoAAAAjAAAALQAAADkAAABJAAAAYQAAAI8cGxrmz83JwI2E + eG2Bd2ptioB1dJGIfHeUiYF5l46EepmQh3yakYh8mZKIe5aPhXuUjIJ6k4uAepGJf3mPiH14kId7d46E + e3aLgnh2ioN5doqDeHWKgnd0h4B1dISAdXSFgHV0hn90c4N8cXODe3FygnpvcoJ6b3KCem9ygnpvcoJ5 + b3KCd29ygndvcoJ3b3J/d21ygHducoJ3b3KDem9xhXxwcYZ8cXGGfXJyiYB1couCd3KMhHhyjYZ7c4+G + fXOSiX9zk4p/c5WMgHOWjYF0lo2CdJaPhHSWj4N0lo+EdJeQhXWXkIV1l5GFdpiRhnaYkYd2mZGIdpqR + iHaakIh2mpCIdpqQiHaakIh2m5GIdpySiHackoh2nJKIdpySiHackoh2nZOJd52UiXedlYl4nZWJeJ2W + i3idlot4nZaLeJ2Wi3idlot4nZaLeJ+YjXiflot4npaLeJ2Ui3iblIl3mpKIdpmQh3aYj4d2mJCEdJWN + gnSTjIJ0l4+EdJWNg3WVjoN1mJCEdZmRhXaakId2mpOId5qRiHaZj4Z1lIyCdJKJfnKLg3hvh3xwbH91 + Z2eCeGxi1NDLrjY1NOoAAAC0AAAAjAAAAHgAAABpAAAAXQAAAE4AAABAAAAANQAAACgAAAAUAAAAGQAA + ACMAAAAuAAAAOgAAAE0AAABkAAAAt4OCgeKupp+JiX9zcpGJf3iZk4d8o5yTg6qknYmwqqOMtK2nkLaw + qpK4sauTt7GqkrWvqZK0r6iRs62nkbOspY+xrKSPsaqkjq+po46vqqKOrqmija6poYyuqaGMrKigjKuo + oIyrqKCMq6Wdi6qlnYqqpZ2KqaOciqmjnIqpopyKqaKciqminIqpopyKqaKciqmjnIupo5yLqaKciqqk + nYqtpp6Kraaeiq6noIqvqaGKr6uii7GspIuzrKaLs66ni7Wvp4u3sKmLuLGqi7ewqYy3sKmMt7KrjLey + qoy3sqqMt7Krjbeyq423squNt7KrjbiyrI24sqyNuLKsjbmzrY65s62OubOtjrmzrY66tK2OurStjrq0 + rY66tK2OurStjru0rY67ta2PurWtj7q1rY+6ta6PurWuj7q1ro+6ta6PurWuj7q1ro+8t6+PvLWuj7y2 + ro+7ta6PubStj7m0rY65s6yOuLKsjbiyqoy4squMtbCpjLewqYu1samMtrCpjLeyq4y4sauNubOtjrq0 + rY64sauOtrGqjLOtpYmuqKCFpqCXgJ2Ui3mUjIF0joR5cIF3bGmknZR4lpST1wcHB8wAAACRAAAAfgAA + AGwAAABfAAAAUAAAAEIAAAA2AAAAKgAAABYAAAAcAAAAJQAAAC8AAAA8AAAAUAAAAGkAAADJ0tHP2pWM + g3eWjIJ6nZWNgKijm4m+saqOzLy2l9PFv6HZy8Wm3M/Kq97RzK3dz8ut3c/KrNzPyqvczsmr287JqtvN + yarazcep2s7IqdnMyKnZzMep2MzGqNjMxqjYzMan18vGp9XKxafVysWn1srFp9XKxabVysWm1MnEptTI + xKbUyMSm1MjEptPIxKbTyMSm08nEp9PJxKfUycWn1srFptbKxabWysam18vHptfMyKbXzcmn2M7Jp9nO + yqfZzsqn2c/Kp9vRy6fb0Mun2tDLp9rQzKfa0cyn2tHMqNrQzKjZ0M2o2dDNqNnQzKjZ0Myo2tDNqNrQ + zajZ0M6o2tDOqdrQzqna0M6p2tDPqdrRz6nZ0c+p2dHPqdnRz6nZ0c+p2NDOqdnRzqrZ0c6q2NHOqtjR + zqrY0c6q19HOqtfRzarX0c2q1tLOqtXRzarW0c2q1dHMqtTQzKnU0cyq1NDLqdTPzKnTz8uo08/KqNLO + yqjTz8qn0s7Jp9LOyqjTz8qn0s7KqNPQy6jU0cyp1NDNqtPPzajPzMqky8fFnsO/vpa5s7GLrqehhqOa + kXyXjoR2jIR5cYqBdWvf29jHExIS2gAAAJUAAACAAAAAbgAAAGAAAABSAAAARAAAADgAAAArAAAAFgAA + ABsAAAAlAAAAMAAAAD0AAABUAAAAbAAAAMjT0c/fnZOJe52Vi3+qo5yJvbStk6TJyrqi1NbKq9rc0LDf + 4dey4eTasuLl3LHh49yx4OTcseDj27Lg49uw4eLcseDi27Hg49uy4OLbsuDi2rLg4dqy4OHas+Di2rTh + 4dq04OHateDg2rXg4dq24OHatuDg2bbg4Nm24eDZtt/f2bfg39m44N/ZueDf2brg39q54N7auuDe2rrh + 39m74d/ZvOHf2b3h4Nm+4uHZveLh2sDj4trB5OLawuXj2sPl5NrF5eTaxubk2sbl49rG5eTaxuXi2sbl + 4trG5eHax+Xh2sjm4trJ5eLayuXi2srm4trM5uHazObh2s3n4NrO59/azuff2s7o39rQ6d/a0erf2tHr + 39rT697a0+ze2tXt3trX7d/b1+7g29nu4dvb7uLb3e7i293u4tve7uPb4e7j2+Xu5dvp7ufb7O7n2+7v + 6tvw7urb7+7s2+/u7Nvv7uza7u3s2u7t7Nrv7eza7u3s2u/t7Nru7eza7+7t2u3u7tru7e7a7+7w2u/t + 7tvw7uvb7u3l2uzr3Nbp59TR5ePKy93bv8LCvbWYsKuhh6GakXyVjIF1jYV6bt7d2swTExLaAAAAmAAA + AIEAAABvAAAAYQAAAFMAAABFAAAAOQAAACwAAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAydTS + 0d+hmZCAp5+XhbeyqpLTxL+fW9vm9jjg7f8/3ur/P97r/z/c6f8+2+f/Pdvn/z7b6P8+2+j/Qdzm/0Hc + 5v9B3Ob/Qtvm/0Pc5v9E3OX/Rtzk/0je5f9L3uX/TN/k/03f5P9Q3+T/Ud7k/1Hf4v9T3+P/VeDi/1bg + 4f9Y4OH/WuHh/1zh4P9e4eH/X+Hf/17h3/9g4d7/YuLe/2Pi3v9l4t7/Z+Te/2nj3v9q497/bebe/3Hm + 4P9y59//defh/3nn4v976OL/fOnj/37p4/+B6eP/guni/4Lq4f+G6+H/iezg/4rs3v+M7N//j+3e/5Pv + 3v+V8d//mPPe/5r13f+c9t3/nvjd/6L73P+k/Nv/qf3b/67+2/+w/9v/s//a/7X/2/+3/9v/vP/d/8T/ + 4P/N/+T/1v/n/9//7v/o//T/8P/3//f/+v/8//v////+//////////////////////////////////// + ///////////////////////////9////9v////D////n////2////87////C////t////67///+q/9PQ + xKy9ubOSraWdhJqTiXmRiX1w4N3azBMSEtoAAACYAAAAggAAAHAAAABiAAAAVAAAAEYAAAA6AAAALAAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADJ1NPR36WfloOspZ6KwLu0mt3Qy6xm2+LyQdvk/0bb + 4/9F2uP/Rtni/0fa4f9H2uH/SNvi/0nb4v9K2+D/S9vh/0vb3/9M29//Tdvf/03b3v9P3N3/Utze/1Pd + 3f9U3d3/Vt7d/1fe3P9X3dz/WN7b/1zf2v9e4Nn/YN/Z/2Dg2v9f39n/YN/X/2Hf1v9g4Nb/YuDW/2Th + 1f9m4dX/Z+LU/2rh0/9s4tP/beLT/27j0v9w5ND/ceXQ/3Ll0f9059D/debS/3jo1P976tX/f+zX/4Ts + 2f+F7tv/ifDc/43w3f+R8t7/kvXf/5P23/+W997/mvne/5z83v+f/d7/o/3g/6f+4f+r/+L/rf/j/6// + 4v+z/+P/uP/j/7z/5P/C/+b/yf7m/9L+6f/b/uv/5v7w/+/+9P/3/vn//P/9//////////////////// + ///////////////+///7/v//+P78//r+/v///v/////7///+8f/8/uf/+v7d//j+1P/2/sv/8/6//+/+ + tP/s/6z/7P+m/+z+o//s/6H/6f+j/+r/n//n/53/2tnOuMfCvpyzr6aKoJmPfJSMgnLg3dvNExIS2gAA + AJgAAACDAAAAcQAAAGMAAABUAAAARgAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbgAA + AMnU09Hfp6CYhbGro47FwLuf5djUtWLa3/Q62N7/Qdjd/0HY3f9B2dz/Q9na/0PZ2/9E2dv/Rdna/0Xa + 2f9H2tj/R9nY/0ja2P9I2tj/SNrY/0ra1v9L29X/TNvV/03c1f9Q3NX/UtzV/1Td1P9U3dP/Vd7S/1bd + 0f9W3dD/V97P/1fezv9Y3s3/Wd7M/1nezP9c3sv/Xd/K/1/fyv9h4Mn/Y+DJ/2Liyf9j48j/ZuTI/2jm + x/9p5sj/a+bI/2zox/9u6cf/cOrI/3HsyP9178f/d/DI/3nyyf999cv/gvjO/4f60f+L/df/k//a/5n/ + 3v+d/+L/o//k/6j/5P+t/uT/tP/k/7r+5f/B/uj/yv3t/9T+8v/d/vb/6f74//P++v/5//z/+//9//3/ + /v///////////////////////////////v////v////6////+f////b/+/3y/+v87v/g/ez/3v3p/9f8 + 4//i/d//6f3Q/+P+u//f/63/2P+k/9L/nf/N/5j/zv2V/8/9kv/Q/Y//0PyN/9P8jP/V+pD/wPac/6T3 + pv/Z3tbBzsnFo7mzrI+lnpR+mI+GdOHd3M0TEhLaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAyAAAAPgAAAFQAAABuAAAAydTT0eCqpJqGs66okcnFwKXq3Nm7bN/l9UXd + 5f9M3eX/Td3l/0zd4v9L297/SNvc/0Xa2f9F2dj/RNrV/0PZ0v9E2dL/RdnR/0TY0P9F2ND/RtnP/0na + zv9M3M//TtzP/1Hbzv9Q3Mz/TtvK/07Zyf9P2sn/UNrH/1Dbxv9S28X/VNvF/1XcxP9V3MT/Vt3E/1je + xP9Y3sP/Wd/C/1vhwv9c4sL/X+LB/2Dlwf9j5sD/ZebB/2Xowv9n6sH/aevC/2ruwf9s8cH/bvPC/3D2 + w/9y+cT/dvzE/3n+xv99/8j/gf/I/4f+zP+Q/s//mv7W/6v+3/+8/ur/yv3y/9b+9v/e/vn/5v77/+r+ + /P/t/v7/7P7///H////4///////////////////////////////////////+//3/+f/5//T/9P7n/+z/ + 2f/l/s7/3v/F/9D+wf+5+8L/ofrD/5n8xf+X+8b/l/rF/577yf+j+83/pvvH/7D9uv+8/af/yPyb/8v7 + lv/K+ZL/yfiP/8v2jP/S94//2viS/+T6kv/c+ZX/rfKe/93i2sfSzcqovbexkqihmICakYh14N3bzhMS + EtoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAdAAAAJwAAADIAAAA+AAAAVAAA + AG4AAADJ1NPR4KulnIa2sauSzMfEqO/h3sFc19n2MdLU/zjS1P850tT/OtPT/znS0f850dH/OdLP/znR + zf860sz/O9LM/zrSyv870cr/PNHJ/z3Syf8+0cf/PtHG/0LRxv9D0cX/QdDD/0HSwf9B0sH/RNLA/0XR + wP9G0sD/RtO//0bUvv9J1L3/Sta+/0zVvf9O1rz/Tti7/07Xu/9P2bz/Udu7/1Ldu/9V3br/VuG7/1jj + u/9Z5rv/Wum8/1ztvP9e8b7/YvW+/2X5v/9p/MH/b/3G/3X+yf98/s3/h/7U/5X93f+g/eT/p/3p/639 + 6f+z/ev/t/7s/7j+7v+z/e3/s/7r/7b+7v+9/vT/y/73/9z+/P/w////+//8//r/+//2/vf/7/7x/+b+ + 6f/e/uL/2P7f/9L/3f/P/tb/y/7N/8n/x/+//sD/r/26/6n9tv+j+7H/gfmx/2z4sv9o97P/aPi2/2j4 + tv9v+Lj/ffq//376wP97+8P/hfvL/4j6yP+k+r7/w/iy/9j5qP/d+Z7/2/eV/9r1j//U9IT/z/B5/83t + cP++5G7/4uTazdTQzqzAu7SVqqOagpyTinbh3tzPExIS2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAAB0AAAAnAAAAMgAAAD4AAABUAAAAbgAAAMnU09HgrqafiLizrJPNycap8OLfwlPU + 2fYlzNT/Lc3T/y3O0/8tzdH/LczQ/yzN0P8uztD/Ls7P/y/Nz/8wzM7/MM7M/zHMyv8wzMr/MM3I/zPM + x/8zzcf/Nc3H/zfOxv84zsX/Oc/F/zvPxf860MP/O9DD/zvQw/880MH/PNLA/z/Tv/9A1MD/Q9XA/0bW + v/9G2MD/R9nA/0fbwf9J38H/S+LB/03mv/9N6sH/Uu3D/1jxxf9f9Mn/Z/fM/2z50P90+tb/gPzc/4v+ + 4/+R/ej/kv3s/5T98P+Y/fL/mv3x/5f+7/+S/+r/jf/i/47/3v+P/97/lf/f/6L+5P+x/un/wP7t/8z+ + 8f/U/u7/1v7o/9H+3v/I/tP/vv/N/7b/x/+x/8T/rv+//67/uf+h/7b/i/+0/4T+sv+B/rH/g/2u/3/8 + r/9w+bD/Zfex/2Hyr/9c8K7/WfGx/2bzuP9t9bv/bve7/3j6vv9++8H/fvq+/4H7wf+S+8j/kvvM/5j7 + 1f+b/dT/qP3E/7T4o/+864X/u990/7bZbf+z1mr/sNFl/6/LX//j5NnO19PQrsG8tZasppyDnpWNd+Lf + 3M4TEhLaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAyAAAAPgAA + AFQAAABuAAAAydTT0uGtp6CKubSulc7Lxqrw4t/DVtbd9ijQ1/8v0Nf/L9DW/y/Q1v8x0dX/MdLU/zLR + 1P8y0NT/MtDT/zLR0P8z0tD/NNHP/zXSz/83087/OdTO/zrUz/881c7/PNXN/z3Wzf881sz/P9fL/z/W + yv9A2Mv/QdnL/0Payf9F3cr/R97K/0jhyv9I5Mv/SOfK/0nry/9N7s7/UvDP/1n10v9h+tf/afzb/3H9 + 4/97/ej/hP/u/4v/8/+N//b/jf/3/47/+P+Q//j/jv73/4j/8f+F/uz/gf/l/3//4f+B/tv/hP/Z/4z/ + 3v+X/+T/pv/t/7f+8//F/fb/0P3z/8/+6v/I/t7/vv/V/7P/yv+m/77/mv+0/5T/rv+S/6j/kP6k/5H8 + oP+S+p7/lfed/5b0nP+U8pz/kPGc/43vnv+G7Z//gOyf/37qof9566T/de2o/3jxsf+A9bn/jvXC/5n3 + yf+c+cz/qfrQ/6H7zP+S/Mf/lPrK/4/6yf+J+sT/lPrB/5b5vP+X+Lr/mfe3/5vyp/+k5pD/rtV6/7LL + b/+xym//rshr/+Tk2s7X1NCuwby2lq6mnoWgl4944+HdzxMTEtoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1dPS4bCpoYq5s66VzsvHqvHk + 4MNW1dn3J87T/y/P1P8vztP/L8/S/zHP0v8x0ND/MdDQ/zLQ0P800dD/NdLP/zbUzv821M7/N9TO/znU + zv861c7/OtXN/zvWzP871sz/PNfN/z3Xzf9A2sz/QdzL/0Lezf9D38z/ReLL/0bmy/9I6M3/TuvS/1Tw + 1v9c9Nr/ZPfh/2r56P9z++3/e/vy/3z98/97/fX/fP30/3v98/96/fH/eP3t/3f96P90/eT/dP3e/3L+ + 2v9x/9b/c//R/3j+0P98/tH/gv/Z/4/+4f+d/uj/qP7r/7P96v+1/eT/sP7a/6j+z/+g/8b/l/+8/47/ + sv+K/6r/if2n/4j7pP+I96D/h/Sb/4jvl/+H7ZX/h+mR/4fnjv+F44z/huCJ/4jehf+J24P/kNuD/5je + h/+g5Iv/qOqO/6/wkv+39Zn/tveb/67zmP+q7Jv/seql/7brsv+x7bL/rfC2/6/0vv+w98L/qfe7/6P1 + sf+i9Kv/mvWi/5z0n/+e86L/m/Wn/5r0pv+c65X/nth+/6DEav+lu2P/4+Paz9jU0a/DvreYrqighaKa + kHnj4N3PExIS2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMjU09LhsKqii7u1r5bOy8ir8ePhxFXU1vcnzdD/L87R/y/P0f8w0ND/M9DR/zPS + z/8z0tD/NNPQ/zPTzv810s3/NNPN/zbUzf821M3/ONbN/zrVzf87183/O9jM/zzZzP89283/P97M/0Lg + z/9G49D/TOfT/1Pr2P9a7t7/XvLk/2L16v9q+O//bvrx/2778f9r/PD/aPzt/2f96f9n/OT/Zvzg/2X9 + 3f9k/dj/ZP3V/2T90v9l/s7/af7K/2v+yP9s/sf/b/7I/3T+zP98/tH/h/7Y/5H+3v+a/+L/nf7d/5n/ + 0v+T/sX/iv66/4X9s/+D/K//gfqp/3/3pP9/86L/fvCe/4Dsmv+B6Zb/gOaS/4DikP+A343/gNyM/4Da + iv+A2Ij/gtiF/4bZhf+O3of/l+SK/57qjP+k747/qfKQ/6fxjP+i7ob/n+iD/53jgP+a3Hv/mth3/5nV + df+a0XL/mdBz/5rPcv+gznb/rNR+/7bdhP+85Yj/wO2M/77wkf+w8ZH/pu+Q/57ujv+c7o7/ou6Y/6Tx + m/+n8Jf/ouaI/5rOcP/i5NrO19TRr8S/uZmwqaKHopuSe+Ti3c8TEhLaAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNTS0uKzrKOLu7awl9DM + yKvx4+DEVtXW9ynP0f8w0NL/MdHS/zHT0P8z0tD/M9LO/zPSzf8z0s7/MtTN/zTTzv811c//N9fP/znY + zv872s7/PNvR/z7d0/9C4dX/SeXZ/1Dp3f9V7uP/V/Hn/1316/9h9+//Yfru/1/66/9c+ej/Wvrj/1n5 + 3f9Y+dj/VvjV/1f50f9X+M7/WvjL/1v3yf9c9sb/XfXD/171wv9g9sH/Y/nB/2b8wf9r/sT/cP/H/3r/ + zv+C/9f/if7Y/4z+1f+L/Mz/gvu9/3z5sv9396z/dPWm/3Pxov9z7Z7/deqc/3jom/975Zj/fOGW/3re + k/9424//eteN/3jWif971ob/fNWG/37WhP+D2IT/i96J/5Pki/+Z6oz/n+6O/6Lvjf+e7Ir/l+aG/5Xg + gP+R23z/j9Z4/5DRd/+Qz3X/kMxz/5DKcf+Rx23/kcZq/5HDaP+TwWX/l8Bh/5m/Wv+bvlP/m71Q/52+ + U/+kwl3/q81q/7XZdP+6437/teh+/6voef+n6Xv/pumD/6zskv+y75v/r++a/+Tn38/X1NGwxL65mbCq + o4ilnpN85OLe0BMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI1dPS4rOtpIy9ubGX0M3IrPHj4cVZ19j3KtHQ/zHSz/8v0s7/MNLN/zHT + zv8x083/NNTO/zbVz/8419H/O9rT/z7f1/9D5Nv/SOjg/03s5f9R7uj/UvLr/1T17f9W9+3/Vvbr/1H1 + 5/9Q9OH/TPPZ/0zx1f9L79D/S+7M/07syP9P7Mb/UerD/1Lqwv9T6cH/U+m//1Xovv9V57v/V+m6/1nr + uf9d77r/YvW//2j5xP9v/cr/d/7Q/33+0v+B/c7/gfrK/3v2v/9086//be6l/2rpoP9q5J3/a+Gb/2vf + mP9t3ZT/bduS/27Zkf9x15D/c9WP/3TTjf9304r/eNGI/3nSh/981Yb/gtiG/4veiP+S5Yv/lOqK/5fs + i/+Y7In/lOmG/47ggv+J13z/htJ4/4jOdf+IzHT/iclx/4rGb/+Kxm3/i8Nr/4vCav+NwGn/jL1o/427 + Zv+QumP/krpe/5e5Vv+cuVD/mrlO/5e6Tv+WuVL/k7ZV/5G1VP+Ss1P/lbRU/6C8XP+tyGT/t9Rp/7rc + a/+1327/suB5/7Lkjv+565//5efgz9jU0bDEv7qasquliKefln3j4d7QExIR2gAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjV09LitK2mjL23 + spjRzcmt8uTixVbX1fcp0c3/M9PP/zTV0f8219P/OtrW/z3e2v9D4t7/R+bj/0rr6P9N7+z/UPPu/1H0 + 7v9Q9e3/TvHp/0vv4/9H7N3/Q+nV/0Hlz/9C5Mv/Q+HH/0bhxf9H38P/Sd7C/0ndwP9L3L//TNy+/03d + uv9O3bf/UNy3/1Hdtv9S37X/VeS2/1rruv9h8sH/Z/jH/2/7y/91/dD/dvvN/3f2xv9z8r3/be2w/2jo + pf9k4p//ZN2c/2Xamf9l2Jf/aNeU/2nVk/9p05D/adKN/2fQif9pzYb/acuF/23Nh/930Yj/fNWL/4Pa + jP+K4Y7/j+aN/5Dojf+S6Yv/keeI/4zhgv+G233/gdN6/3/Mdv+ByHP/gsZx/4PEb/+ExG7/hMJr/4PA + av+EvWj/hLxl/4a6Zf+Gt2P/h7di/4e1Yf+LtF//j7Ra/5W1Vf+Yt07/mLdI/5a3Sv+RtlD/j7ZT/5C2 + Vv+Ttlj/lbZY/5u2Wf+duFv/m7dZ/56zVv+jtVj/q7xa/7PFWf+4y1z/ts1i/7rUd//l5t7P2dXSscXA + vJuyraWJqKCWfeTi3tATEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNXU0uK0raiOvreymdLOyq7x5OLGX9/d9zff3f9B5OH/Q+fk/0Lq + 5v9E6+j/RO3p/0Xu6f9G7OX/ROjg/0Pm2/9B4tb/P+HR/z/fzv8+38z/QN3J/0Daxv9A2cT/QdjB/0TW + v/9F1Lz/RdS7/0fTu/9J1Lr/SdS2/0vVtf9L1bT/TNex/07asf9U4Lb/Wui9/2DxxP9m98v/bPnO/3D4 + zv9u9MX/bO68/2jns/9i4af/YNye/13Ymf9f05b/YNOX/2LRlv9k0ZP/Y9CP/2XPjf9kzIr/ZMmI/2PH + hf9myYT/a86G/3XUh/972ov/g+KO/4zokf+M6JD/jOeP/43ki/+I3oT/gtZ+/33PeP95yXP/esZw/3vE + b/98wm3/fcFs/3++af9/vWf/f7tl/3+5ZP+At2P/gLdh/4G1YP+Ds17/g7Jd/4SwXf+Hslv/jLJX/5Oy + T/+Vtkn/lrdH/5G4Sf+Nt07/irZT/4u2WP+SuFr/lrpc/5q8Xv+evF//oL1d/6G9Xf+jvlz/p7xa/6e7 + WP+muVX/qrlU/6y3Uv+ttUz/tbVI/+bk2dDa1tSyx8G9nLStp4unoJh/5OLf0RMSEdoAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tTT47Sw + qI++ubSZ0c3KrvDi4MZj6eb3N+jk/z7o4P895d3/O+HY/zrd0/852c7/ONfL/znWyP871sj/PdfJ/z/Y + yv8+2Mr/QdnJ/0DXxf8/0r7/QdC7/0DQuv9B0bn/RNG4/0TQtv9E0bT/RtC0/0fRs/9J0rD/TNaw/1Dd + tv9Y5r//X+/H/2X0zP9p9c7/afHH/2Xrvv9h47P/Xtur/1zWov9b0p3/WtCZ/1zOlf9ezJT/YMyT/1/K + kf9hy5D/YcmN/1/Hif9fx4b/ZMiF/2nMh/9v1In/dNuL/33ijf+C55H/gOaO/4Hjif+C3oj/gdqG/3/V + gv9/0H//f8t6/3zIdf97xXL/esFu/3i/av95vmj/erxm/3q7ZP96uGP/fLdh/3y2X/9+tF7/frNd/3+y + Xf+BsFv/gbBa/4OwWv+GsFn/i7JU/5G0Tv+Vtkf/k7lF/4+8SP+JvFL/ibxZ/429YP+SwWT/mMRl/57F + Zv+ix2b/o8Zl/6LDYf+iwV3/o75a/6O9WP+kulb/pLhT/6S2UP+mtE7/qLRL/6mySv+ssUX/5eTa0NnX + 1LLGwr2dtq6ojKmimYDk4uDRExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAA + ABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjW1NPjtbCqj7+6tJrRzcqv8eTjx13c1Pcw1Mv/ONLK/zfR + x/840cf/N9HG/zjRxP850MX/OtLF/z3SxP88z8H/PM28/zzKuf89yrr/QM27/0HPvP9Bz7v/Qc65/0HO + tv9CzbP/Rc2w/0bPsP9J1LL/T926/1fmxP9d7cj/YvDM/2Lvyv9g6L//Xd+1/1rarP9X1ab/WNCi/1fN + nP9Xy5j/V8uX/1rJlf9cyJP/XceR/1/Gjv9exYz/YMSL/2LGiP9nzIr/bdON/3Tbjv954pH/feaS/3zm + jv944Iv/d9qG/3TTgP9xz3z/dM16/3bJef94yHr/fMd5/4HHd/+AxHT/fMJv/3q+a/94u2f/eLlj/3m3 + Yf96tWD/e7Rg/3y0Xv97s1z/fbJb/3+xWv+CsVn/g7FY/4OxV/+GsFf/i7NT/5C2Tv+Uu0n/k79K/43E + U/+Kxl7/i8Vn/5DGbP+Tx27/lshv/5jJbf+Zx2n/m8Rm/5vAZP+cv2D/nL9c/5+/WP+jv1b/psBW/6fD + U/+rw1L/rsJP/66/Tf+wvUn/r7tG/7C3Q//m5NnQ2tbVs8jEvp63saiMq6OagOTi4NETEhHaAAAAmQAA + AIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNbU + 0+O2sauQv7u0m9LOyq/y5uPHXdPM9y/Lw/81zcP/NszC/zbMwP80yr3/Nsi6/znEuP84xLb/Ose3/zzL + uv8/z7z/QM6+/0HQvv9Czrz/Qcu2/0HIsf9EyrD/RtCz/0nVuP9Q38D/VOjI/1rrzP9d68r/W+bD/1ff + t/9U163/VNKn/1TOpP9VyqD/VMme/1bInP9YyJn/VsaX/1fHk/9XxpH/WMaP/13Fjf9fx4z/Y8yN/2nT + kf9w25P/deGS/3rllf9545L/dN+L/3HYh/9w0oP/bs9//2/Le/9vyHf/bcZ0/3DDcv90w3L/dsNz/3rE + dP9/xXP/g8N0/4HCcP99vmr/e7tn/3q3Y/95tV//erVe/3u0Xf99tF3/f7Vb/3+1Wf+BtVj/g7ZZ/4e2 + WP+Lt1j/j7lW/5S9T/+Wwkz/lMhQ/4/NWv+Mz2r/itB1/4zNeP+Qy3X/k8p0/5XKcv+Xym//l8xp/5rM + Z/+ezmT/oM1i/6DKXv+hyFv/o8VX/6TBUv+kvU7/o7dL/6KxSf+iq0P/naQ+/5yeOv+cmTf/nJY2/+Th + 2dHc2dWzycS+nrexqo2rpZyB5OLg0hMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tTT47axq5HBvLWc0s/Lr/Lm5Mdbzsb3LcO4/zXD + uf84wrj/NsK2/zbEtv84xbn/Oca3/zjHt/88yLj/Pci3/z3Fs/8/w7D/QMax/0HMt/9H1b7/TNzD/1Dk + yf9U6c7/VujN/1blx/9T3r7/T9ax/07OqP9PyqP/UMqi/1HIof9Tx5//U8ed/1PFmf9TxJf/VsOV/1jD + k/9bxZT/X8iU/2LNk/9o1ZX/bNyV/3Hglv9z5Jf/dOSU/3LekP9v1or/btCH/23Og/9tzH7/bsp7/2/H + ef9ux3b/b8V0/2/Ecf9vwW//cMBt/3XAbv93wW//fcNx/4TDb/+Gw2//hMFr/4G+Z/9/vWT/fbpg/326 + Xf9+vF7/grtc/4a8XP+Jv1z/i8Fc/4/CWv+SxFr/l8VY/5nJVv+ZzlP/ldNW/4/VZf+J13T/idd//4vW + gf+P1n7/k9V7/5LSdf+TzXD/kshq/5HCZv+PvmD/j7la/4+0Vf+Nq0//i6JK/4qcRv+KmEH/i5Q9/4uS + O/+MkTj/jpA3/5OPNf+UjzT/lZAz/5ePMv+YjjD/5OLZ0dzZ1bTJxL6euLOrjqylnYLk4uDTExIR2gAA + AJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAA + AMjW1NPjtrGrksC8tp3T0Muw8+flx1vJwfcwv7T/N8K2/zXDtv82wrX/NsOz/zjBsv84wK//Ob+t/zu/ + rv8+xbT/Q9K+/0fZxP9M4cv/UOfS/1Hq0f9R5sz/UN/E/07Yuv9M0LD/SMmm/0jHo/9LxqL/TsWf/07F + nv9QxJz/UcGa/1HBmP9Vw5j/V8eY/1zMmf9h0Jv/aNef/27dn/9v4J7/ceOb/3LimP9v3pX/bdiP/2zT + iv9s0If/bM2C/23LgP9uyn7/b8l7/23Jev9vyHf/ccV0/3HFcv9xxG//csJt/3HAav9zv2n/eMFq/33E + bf+FxnH/jclx/47Lb/+Mymz/i8to/4nLZP+JzGL/is1h/4zNYv+R0GP/lNJi/5jRYP+b0GD/nNFc/5nV + W/+U2F7/jttk/4rabv+F1Xr/g9CC/4TLgP+GxHf/iL9t/4e4Zv+FsGD/gqdY/36hUP9+mkv/fpVH/32R + RP98j0D/f409/4GMPP+EjTn/h4w3/4iNNf+LjDX/jYwz/4+MMP+PjC7/kYot/5OLLf+UiSz/loks/5iJ + Kv/k4tnS3NrWtcnFv5+3squPr6ifgubj4tITEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNXU0+S3sayTwbu3nNPQzLDy5+XIXce/9zC9 + sP83v7H/N7+u/za9rv83vq7/OcGw/z3Jt/9C0b7/R9jE/0vgy/9P5M//TeLN/07hyP9O28P/S9S6/0jM + rv9Hx6X/SMek/0jGpf9JxqP/SsWg/0vDnP9OwZr/TsOb/1PHmv9YzZ7/XNKi/2TapP9q3qf/a+Gk/23i + o/9v4qD/cN+b/27alv9r15H/atKL/2nQif9rzof/bc6F/3DOgf9wzn//csx9/3LMef9yy3f/csp2/3PJ + cv9zxnH/dcdu/3THbP93yGv/e8tr/4DPa/+J023/kthx/5rcd/+h4Xz/oeF6/57gdP+a3m//ltxq/5PZ + Zv+U1WL/ltJe/5fQW/+Ry13/islf/4XLX/+Az17/fM5g/33HZP9/v2j/fbVs/32uZ/99qF7/f6NU/36d + Tv98mUj/e5VD/3qRP/97jjv/e445/3uMNv99jTP/f4wz/3+KMv+EiTD/hYgu/4WILf+Hhiv/iIYr/4uF + Kv+LhCr/jIQq/42EJ/+OhCf/j4Qn/5KEJ/+UhSf/lYUl/+Th2dLd2de1ysTAoLm0rI+wqaGE5uXi0hMS + EdkAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAA + AG0AAADI1dXT5LmzrZLBvLed1NHMsfLn5chcyLz3L7ys/ze/rv85xLL/Psu6/0LRwP9F1sX/SdvI/0nd + yf9J28P/SNe+/0rUu/9IzbT/Rser/0fGp/9IyKn/Ssqs/0rKqv9KyKb/Scah/0vDnf9Ox57/U82h/1fU + pf9e2qr/ZOCr/2Tiqv9o4qj/auKm/2zgo/9t3p3/bdyZ/27Ylf9w1pP/cNeP/2/UjP9w1Ir/cNOI/3PT + hv9y04T/ctN//3TRfP930Hr/eNB2/3nRdv9+1Xb/gtl3/4bedv+J4Xb/jOV3/5Dpd/+R6Xf/j+V0/5Tj + dP+a4XT/nd92/5/ddv+c13D/lc5l/43EWv+IvVP/hLZP/4C0Uv93tV//brlk/2m8Yv9svlz/dLtS/3q2 + Tf9/rkv/gaZK/3+hSf99nET/fJk//3yVO/97kzf/eZAz/3qPM/96jDD/fIou/3yILP97hyz/e4cr/3yF + Kv9+hSn/f4Mp/4GCJ/+Cgib/goEm/4SAJf+GgCb/h4Al/4h/Jf+JgCX/i38k/4yBJf+NgCX/kYEl/5OB + JP+SgSP/5eLZ0t3Z1rbLxcGhu7Suj7GrooTm5eLSExIR2QAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjV1dPkurStksO9t57U0cyx8ublyV/Q + wvc3zLv/Q9PB/0bWxv9H2cf/RdfC/0LRu/9Bzrb/Qsux/0TGrP9Ew6f/Q8Om/0fHq/9Ky67/S82y/0zM + sP9Nyab/T8mj/1POp/9X1az/Wtyw/17isf9h47D/Y+Os/2Xiqv9m4qf/aOGk/2vgof9q3p7/bd2c/3Hb + mf9z3Jf/dduV/3fbk/933Y//dd2N/3bdiv953Yn/fd6E/4Ddhf+C4Yb/h+WG/4rphv+O7Yb/ke2G/4/t + g/+O6X//jOJ5/4fbcv+D1W3/gc1n/37FX/98vVv/g7tZ/4e8Wf+Lu1j/jbpY/4m3Wf+Aslv/da9j/2mu + a/9fsHL/WrZ0/1+5af9tuFP/f7NC/4WvPf+GqDr/hKE4/3+ZN/97lDX/d5Ey/3aOLv92iy3/doos/3eJ + LP94iCv/eIcq/3mGKv95hSn/eIMn/3mCJ/95gSb/eYAl/3x/Jf99fSX/fHwj/358I/9/eyL/gXsi/4J7 + Iv+DeyL/g3wj/4Z7I/+IfSP/i30j/419JP+NfST/j34j/5B9Iv/k4dnT3NrYtszHwqG9t6+Qsqujhebk + 4tMTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAA + AFQAAABtAAAAyNbV0+S6tK2Sw764ntTRzbLx5uPJatvP90DWxP9D077/Qcu2/z/Isf9Axq3/QMKq/0HA + qP9Cwaj/Q8Wq/0fIrf9Ky6//S82v/07Nq/9S0qr/V9ix/1zguP9h57z/Yuu8/2Hqt/9g6LP/Y+ev/2Pm + q/9j5ar/ZuWm/2rjpP9t5KD/cOOf/3TkoP945p3/fOab/4DonP+D6pv/huya/4fvmP+J8Jj/je+Y/4/t + lv+N6JH/i+OM/4nghv+F2oL/gdR8/3zLc/94w2n/crli/3KzXP9yrlj/catU/3CpUP9wp0//b6dN/3Kp + UP93rFf/eK9j/3iycv90t3//Z7eI/1+2iP9atn//W7Vt/2WxV/90sEP/gas1/4WnM/+DoDL/fpky/3iT + MP90jS//cIou/3GHLf9xhyr/c4Yq/3OGKf91hin/d4Uo/3eDKP93gif/eIEm/3Z/Jf92fiT/dn0j/3h8 + I/96eyP/e3oi/3x6Iv97eSH/fnkh/394If+AeiH/gXoh/4N5If+EeiL/hHoi/4Z7I/+HfCP/iX0j/418 + I/+PfST/kH0i/+Th2dPd2ti2zMjDob23sJGyqqOF5uTi0xMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tXT5Lu0rpPDv7mf1dLOsvPm + 5clj0L/3OMWu/0DErf8/xKz/QMOq/0HEqv9Dxqv/RMes/0bMrP9K0a3/UNSu/1TZsf9a4bn/YOq//2Tw + xP9l8sX/ZPHB/2Tvu/9j77j/ZO+0/2Tvs/9n7rD/au2r/2ztqv9y76n/d++p/3zyqP+A86f/hfSm/4ny + pf+N8aL/j+6i/47nnf+K4pf/hduR/4LTiP99zIL/eMV4/3K7cP9ttGj/arBh/2qtXP9rq1v/a6lX/2up + Vf9uqFP/bqZU/2ylU/9so1T/aaJY/2WgXf9joWL/YqVv/2GrfP9isIb/Y7iK/2m7hP9rt3H/brRb/3Kv + Rf92qjb/eqQx/32fMP97mS7/dpIt/3KMLf9uiCz/bIUr/2yEK/9tgyr/b4Mp/2+DJ/9xgib/coIm/3SC + Jf91gST/dYAk/3d/JP92fiP/d30j/3p7If95eiD/eXkg/3p5H/96eR//e3ge/3p3IP98eCD/f3cg/393 + IP+AeCD/gXkf/4J4IP+DeSH/hXkh/4Z5If+JeiL/inoh/417Iv+OeyH/5eHZ097c2bfNycOivbawkrOs + pIbm5OLTExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMjW1dPkvLavlMO+uKDV0s2y8+fnyWTNvPg5xaz/Qciw/0TMsv9Hz7D/StOw/03Y + sv9Q3LT/VOG3/1rnv/9d7MT/YO7H/2TwyP9l8cb/aPDF/2vxw/9r8b7/bfK+/2/yu/9v8bb/c/K0/3by + sv969LD/fvKt/3zup/9966T/feei/3vgm/962ZP/edGO/3bKhv9zxIH/cLx6/225dP9ptW7/aLFp/2av + Zv9ormL/a61f/2usW/9qqln/aqhX/2mmVv9oo1b/ZaBZ/2SfWf9inWD/XZxi/12dZP9bn2j/V59q/1qj + a/9fqGz/Za1r/22wZv92tV3/fbZQ/3+xQv97qzn/d6Iy/3WZLv9zkCr/cIso/2+HKf9uhCn/bIQp/2qD + KP9qgij/bYIn/26AJv9vgCX/cYAk/3KAI/91gCP/d4Ei/3iAIv94fyH/en8f/3l9H/96fCD/enof/3l5 + H/94eB7/eXge/3h4Hv95eB7/e3cf/3t2Hv98dR7/fnYf/4B3IP+Adx//gXcf/4J4IP+EeCD/h3ch/4l3 + IP+JeCH/i3kh/416If/k4dnT3tvZt83Iw6O9uLGRs62khefl4tMTEhHZAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNXU0+W+uLGVxL+6n9TR + zrPx5ubKa9nA90XWtP9Q27r/VN+7/1bivP9Z5cH/XebG/1/ox/9j6cj/ZerL/2bqy/9q68n/a+rF/23q + wv9x68D/c+7A/3Lvvv9y7Lj/ceas/3Dlq/9v4qf/atqf/2fRlf9lyY3/YcWJ/2DAhf9gu4D/YLZ5/2Kz + df9ksnP/ZrFv/2exbf9psmv/abFo/2isZP9mqWD/Zqdd/2elXP9mo1r/ZaFa/2KfXf9hm2D/X5th/1ya + Yf9ammL/Wppj/1ubY/9am2H/W55f/12fXf9doFn/YqJT/2mlT/9yqUz/e65K/4GzRf+BsDz/e6Y0/3Wa + L/9wkCr/bYcn/2yCJf9qgSb/bIIn/22CJv9tgib/bYEm/22AJf9vgCT/bn4j/3F/I/90fyP/coAi/3aA + Iv95fyH/e38g/3t+H/96fh7/e3we/3t7IP95eR7/eXge/3h3Hf94dx3/eHYd/3l2H/96dR3/fHUe/3x1 + Hv99dR7/fnUe/392Hv+AdiD/gHYe/4J3H/+Fdx//hncg/4l3IP+LeCH/jHgg/+Xh2tTf29m4zcrEor+5 + s5KyraaH5eXj1BMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI1tXT5b62sZXEv7uh1dHPtPDm5sp54sj3WODB/2PhyP9m5Mr/ZeTM/2bi + yv9l4sj/ZeLE/2Tiwv9i47v/ZOCz/2bgsv9m4LL/aN+w/2rfsf9n2qf/YtKf/1/Om/9by5n/WcOR/1a6 + hv9TtoL/UrN+/1Wve/9VrXf/WKx0/1mrc/9crG//YKts/2Ksa/9mrGn/aKtm/2ipZP9np2L/ZKNf/2Cg + Xf9fnV//X5xg/12bYv9cmmP/XJlj/1qYYv9amGL/WZld/1qYW/9cmVv/XJtY/16bVf9fnFH/YpxN/2Ob + R/9pnkP/cqVA/3qpP/99qzz/fqg3/3mgMP91lir/c40o/22IJf9qgiT/bIEk/2uAJf9sgCX/aoEk/2yA + I/9tgCP/boAj/25+I/9wfiH/cn4h/3N+If91gCD/eIAg/3qAH/98fh7/fH4e/3t9Hf96fB3/enkd/3l4 + Hf95eB3/eHcd/3d2HP94dhz/eXUd/3p0Hf97dB3/e3Qd/3x0Hf99dR3/fnYd/391Hv+Adh7/gnYe/4J2 + Hv+Edx//iHYf/4p4H/+Jdx7/5OHa1N/d2rjPysWjvrmzk7Gtpojm5ePUExIR2gAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjW1dPlvLexlsTA + u6HV0s+08Obly33hz/hZ3cT/Xt3C/1zevf9b3rj/Wty2/1resv9Y3K3/Wdmo/1vWpv9b1KT/WNCk/1XG + m/9TvZD/U7uO/1K9kv9UvpP/UreJ/1Gygv9RsX//UbB9/1GreP9Sp3P/UqZw/1Smbv9WpGr/WKNn/1ui + Zv9epGP/YqVi/2OlY/9lpWT/ZaNl/2GgZ/9dnWb/Wppj/1qZYv9dml//XJpg/1yZXv9cmVr/W5dZ/1yY + Vv9cmFX/XJdT/12YUP9gmE3/ZJlI/2SZRf9lmkD/apw9/3CfOf90oDb/dp0y/3adLv96nS3/epgq/3iS + J/9ziyX/bYQj/2l/I/9pfiL/aX4j/2t/Iv9tfyL/bX8i/25/If9wgCD/cn4f/3J+Hv90fR7/dn4e/3p+ + Hv97gB7/fIAd/3yAHP98fhz/fH0d/3t8Hf96ehv/eXgc/3h3Hf93dhz/eHQc/3h0HP94dRz/eXUc/3ly + G/95cxz/e3Mc/310Hf98dBz/fnUe/351Hv+AdR3/g3Yd/4Z1Hv+Hdh//iXcf/4l1Hv/k4trU39zauM7K + xaS9uLOUtK+oiOfl49QSEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNbV1OW/ubOWxMC7odXTz7Tx5ufLdt/B+FHasv9Y2bL/V9eu/1jU + q/9WzaX/VMae/1C/lv9JupP/SLiR/0mxi/9KsIb/S7GG/020i/9PtYz/T66D/06sf/9OrX7/UK9//0+o + dv9Po2//T6Jt/1Cha/9Qn2b/Upxk/1SdY/9VnWH/WZxh/1mdZP9bn2b/XqBo/1+gav9goWb/YJ9k/12d + Yf9dml3/XJhb/12YWf9dmFj/XplW/16ZVP9dmVP/X5hQ/2CYTv9gl0v/YphG/2WYQv9omj//apo7/2ya + Nv9sljL/aZEu/2uSKv9zlSn/e5so/4CdJ/99lif/d5Am/3KIJP9rgCH/aX0h/2l8IP9pfSD/a34g/21/ + IP9ufx//b34f/3F+Hf9zfx3/c34c/3V+Hf92fhz/en8d/3yCHP9+ghv/fYAc/31+HP98fRz/fHsc/3p6 + HP95eBz/eXYc/3h1G/94dBv/eHQb/3hzG/95chv/eXIb/3lyG/96chv/e3Ib/3xyG/9+cxz/f3Md/4B0 + Hf+DdB3/hXQd/4V0Hf+HdR//iHUe/+Ti2tTf3Nq5zsrFpMC6s5S0sKiJ5uXj1RMSEdoAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tXU5b65 + s5bEwryg1dPPtPLo6Mty0LT4S8Kg/029nP9JuZf/R7aT/0WxkP9ErYv/RauI/0Wog/9GqoH/RamB/0ir + g/9IqH//SKZ7/0qlef9Kp3z/Tap9/02kdf9NoHH/TKFt/02ia/9PnGX/UJlh/0+aYf9PlmP/UJZl/1CX + ZP9TmGX/V5tm/1udZf9dn2T/YKBj/2KhYf9joF3/YZ1a/2CYWP9emVb/YJlV/2GZVP9gmVL/YJhP/2CY + TP9il0j/ZJdF/2SXQv9olz7/a5k7/2yZN/9pkzD/ZYsr/2SGJv9niSb/cJAm/3mVJP+AmyT/f5kl/3qT + I/91jCP/b4Qg/2p8H/9pex3/aHse/2p8Hv9sfR7/bn0c/29+HP9yfR3/c38b/3V/G/90fhz/dX4c/3d/ + G/99gBz/foIc/3+CGv9+ghr/fn8b/319G/98exv/enka/3l3Gf95dhv/eHQb/3dzGv93cxr/d3Ea/3ly + G/95chv/eXIb/3pyG/97chv/fHIb/31zG/9/chz/f3Ic/4JzHf+Ecxz/hXQd/4d1Hv+HdB3/5OLZ1d7c + 2rnPysWkv7u0lbOwqInm5ePVExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAA + ABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjW1dTlvbi0l8XCvaLW09C18urqy2S7ovg7rYv/RLCO/0Ov + jP9DrIn/RKiF/0Slgv9EpH7/QqB7/0Khef9DoHb/RKB1/0addP9In3T/SaF0/0mgc/9Lnmz/TZ9s/02h + bP9MnWj/S5hl/02YZ/9LlmT/SpNj/02TZf9NlGT/UZZh/1WYYf9aml//Xp1f/2CgXv9joV3/ZaJd/2Wg + Wv9jnFf/YZpU/2CZUf9imlH/ZZtP/2SYTP9kl0f/ZpZE/2aWQP9plz7/apg7/22XN/9pkTD/ZIoq/2CE + Jv9igyT/Z4Uk/26KI/91jyP/fJUk/3+YJf99liT/eY8h/3SJIP9tgh3/aXod/2h6HP9pexz/bHoc/258 + HP9vfRn/cH0Z/3J+HP91gRz/dYAa/3WAGf94fhr/fIAc/3+CGv+Agxv/f4Ma/3+CGf9/fxn/fn4a/318 + Gv97eRn/eXcZ/3l2Gf94dBv/d3Ma/3dzGf93cRr/eXEb/3lyG/96cBn/enAZ/3twGf98chv/e3Ea/39y + HP9/chz/gnEb/4RzHP+Dchv/hXMc/4VyG//l4tnV4N3buc7Lx6a/vbaWta+piufl49UTEhHZAAAAmQAA + AIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNbW + 1OW+uLSXxcK+otbTz7Xz6+vLZred+DumhP9CqYf/Q6eE/0Gkgf9BoX3/Qp94/0CbdP9BmXP/Q5pw/0OZ + bP9EmW3/RJpt/0ecbf9ImWj/Spto/0ufbP9LnWr/Spdo/0ubaf9KmGn/SpNm/0uVY/9MlGL/T5Nf/1GU + Xf9Tllz/WJhc/1ybXP9gnlr/Y6Ba/2aiWf9po1j/aKFW/2adUv9lmk//ZZlM/2eaS/9pm0n/Z5lE/2mY + QP9qlz//bJg8/2yYOP9nkDL/ZIgr/2GDJ/9ggiP/Y4Mj/2aCI/9shCL/dIki/3mOIf99kyL/f5Yj/3yT + If94jSD/c4ce/2x/G/9peRv/ankb/2t5Gf9sehr/bnwa/3B9GP9wfhj/c4Aa/3WDGv92ghr/d4EY/3qA + GP99ghr/gIQa/4GEGf+Bgxr/gYIZ/4CBGf9/gBj/fnwY/3x5Gf97eBr/encZ/3h1Gv95dBn/eHMY/3hx + Gf93cBn/eHEa/3lwGf95cBn/eXAZ/3pwGf98cRv/fXAa/31wGv+AcRv/gnEa/4NyG/+Fcxz/hXIb/+Xi + 2tXg3du6zszHpr+8tpa2r6mK5+Xj1hISEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tbV5b+8tZfGwr2j19TRtvTs7MxksZX4OZ56/0Gi + f/9Aon3/QZ94/0Kcdf9CmnL/QJhw/0GTa/9Bkmf/Q5Vn/0OYaf9ElGX/RpRl/0aZaP9ImWv/R5Vn/0mZ + af9KnGv/SZdk/0uXY/9Nl2L/TZNf/06TXP9QlFv/U5NZ/1WWWf9amVj/X5tX/2OeV/9moVb/aaNX/22k + U/9solL/ap5N/2maSf9pmkf/a5pE/22ZQv9tmT//bpk8/26YOP9qkjP/Y4gs/2CEKP9igiX/ZIIj/2WC + Iv9ngSH/an8g/3CEH/93iB7/eo0e/36SIf9/lCH/fI8g/3eJH/9yhBz/bXsa/2p4Gf9reRj/a3oY/257 + Gf9vfRn/cH4W/3KAFv91ghj/d4QZ/3aDGf94gBf/fIEX/32DGP+AhRj/goYY/4SEGf+Dgxn/goIY/4GA + GP9/fRf/fXoY/3x4Gf97dxn/eXQZ/3l0Gf94chn/d3EY/3ZwF/93cRj/eXEY/3lwGf95bxj/eW8Y/3tw + Gf99cBr/fXAa/4BwGv+CcRv/g3Ia/4RxGv+EcRn/5eLZ1eDd3LvQzMemwr23lrexq4vn5ePWEhIR2gAA + AJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAA + AMjW1tXlwLy1mMbEvqPX1NG29OzszGSukPg4mnT/P5x3/0Gedv9CnXT/Qppx/0GVa/9Ckmf/Q5Jn/0KT + Z/9CkGT/RI9j/0SSaP9FlWr/RZFl/0iTaP9Mm2r/TJdl/0uVY/9OmWP/TZZf/06TXP9QlFz/T5NZ/1CS + V/9Vk1b/WJZV/1yYVP9gmlX/ZZ9T/2qhUv9to1L/b6RP/2+hSv9tnkb/a5pD/2yaQf9vmj//cZo8/3KZ + Ov9ukzT/ZYst/2OFJ/9jgyX/ZYIl/2SAI/9mgCH/aIAf/2mAHf9vfhz/coIc/3aIHf97jR//fpIe/3+R + H/97ix7/eIgd/3GCGv9sexn/a3kY/2t6GP9texn/b3sZ/3B9F/9xfxb/c4EX/3eEGP96gxn/eYEY/3qA + F/99ghf/f4QX/4KFF/+Ehhj/hIQX/4ODGP+Cghj/gYAY/399F/99ehf/e3gY/3p2F/95dBf/eHMY/3dy + GP93chf/d3AX/3hwF/95cBn/eG8Y/3hvGP95bxj/enAZ/3xvGf98bxn/fHAZ/39xGf+CcBn/hHEa/4Rx + Gf/l4tnW4N3cu9HMx6bDvbiXuLOsi+fl49YSEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNfW1eXAvLWYx8O+o9fU0bb07O3MY6qL+DiW + bf9BnHT/Qpxz/0Gab/9Cl2v/Q5Rp/0KTZv9DjmT/QYxj/0GOZv9DkWb/RY9j/0WQYv9HlWX/SZVk/0mS + X/9NmGL/Tphh/02UW/9Oll3/UJRb/1GRVv9Sk1f/U5JU/1eSU/9ZlVH/XJhQ/2KbUP9nnk7/baFO/3Kj + Tf90o0n/dKFF/3CdQv9umj7/cJo8/3ScO/9xmTb/a48v/2WIKf9lhSf/ZoQl/2aDIv9ngiD/aIAe/2l/ + Hf9rfhz/bH4b/29+G/9ygxv/dogc/3uMHf99kBz/fpAd/3qKHP93hxv/cIEY/2t7Gf9rehj/bHoY/258 + F/9wfhX/cH4U/3J/Ff91gRf/eoUY/3yEGP97ghj/fIEX/36DF/+BhRf/hIYY/4SGGP+Fhhj/hIQY/4OB + F/+CgBj/gH0X/356Fv98eBj/eXUX/3l0F/94cxj/d3IX/3ZxF/93cBf/eHAX/3dvF/94bxj/eG8Y/3hu + GP95bxj/e24Y/3xvGf98bxn/f3AZ/4FvGf+EcRr/g3AZ/+Xh2dbg3ty70c3JpsS/uJe5tKyL5+Xj1hIS + EdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAA + AG0AAADI19bV5cC8tpnHw76j19TRtvTs7cxiqon4OJZo/0Cabf9Cm23/Qplt/0GWav9BkWf/Qo1j/0CN + Y/9CjWH/Q41f/0OLX/9Gj2D/SJFf/0eOXv9JkV3/S5de/0uSWv9PlFv/TpZc/1CSVv9Sk1b/VJNU/1WQ + Uv9XklH/WJJP/1uVT/9gmEv/ZZxJ/2ygSf9xo0j/d6RF/3qkQv94okH/dp89/3OZOf9ylzb/bpQy/2mN + LP9piij/aIgn/2iEJP9ogyL/aIIf/2qAHf9rfxz/bH8b/21+Gv9tfBn/b34Z/3OBGP92hxr/eYob/32Q + HP99jxr/eosa/3eIGv9wgBj/bHsY/2x6F/9ufBf/b30X/3B+Ff9xfxX/dIEU/3mDFv98hRf/fYQX/3uC + Fv98ghX/foQW/4KGFf+GiBb/hocX/4aGF/+GhRb/hIEY/4OAF/+BfhX/f3oV/3x3F/97dhb/eXQW/3lz + F/93chb/d3EW/3hwF/94cBf/d28W/3huFv94bhb/d20W/3luF/97bhj/fG8Y/35uGP+Abxj/gG8Z/4Jw + Gf+Cbxf/5eLZ1uHe3LvRzsmmxL+4l7myrIzn5eTWEhIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjX1tXlv723msjEv6XY1dK39e3tzWOo + hPg5lGX/QZlr/0KZbf9Dl2z/QpNp/0KQZf9CjGH/Qoxd/0SLXP9Filz/Rotd/0eLW/9Hi1n/SZBb/0qP + WP9NkFb/UJRZ/0+TVv9RkVb/U5VW/1KSUf9Uk1D/VpBN/1eSTP9Zk0z/X5ZJ/2SaRv9snUX/cqBF/3ak + Qf97pj//faY9/32kPP95njf/cJQx/2uOLP9qjCn/bYwn/22LJP9rhyD/bIMg/2yBHv9sgB3/bX8c/25+ + Gv9ufRn/b3wX/257Fv9vfRf/c4IZ/3eGGf96ihv/fpAb/32PG/96jBn/d4gY/3B/F/9texb/bnsU/29+ + FP9xfxX/cX8U/3KBFP93ghT/fIQV/36HF/9+hBX/fYIV/32CFf9/hhX/g4YV/4eIFf+Hhxb/h4YV/4aF + Fv+Eghf/gn8V/4F+FP9+exP/fXcV/3x2Ff96dBX/enMW/3hxFP94cRX/d28W/3dvFv93bxb/d28W/3du + Fv93bRb/eW4V/3ptF/96bhb/fW8X/39uF/+Abxf/gHAZ/4JvF//l49rW4d/cvNLNyafDvriYuLKsjebl + 5NcSEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAA + AFQAAABtAAAAyNfW1eXAvbeax8W/pdjV0rf07O7NZKeD+DiRZP9Clmr/RJlr/0OXaP9Dk2T/RJBg/0SN + Xv9EiVr/RIlY/0WKWf9Fh1f/R4pW/0mMVf9Ji1T/TI5U/0+RVP9QjlP/UpNS/1KSUf9Uk0//VZVN/1WS + S/9Ykkr/WpJH/16WRf9lmUP/bJ1B/3KfQf92oj7/e6U8/4GnPP+Epzn/fqE1/3KVL/9rjCj/a4wm/26M + Jf9xjSL/cIoi/26GIP9uhB3/boEc/25/G/9ufhn/cH8W/299Ff9uehb/bnoW/3B+F/9zgxj/eIkZ/3uO + Gf9/khr/fY8a/3qNGP93hxf/cH4V/258E/9vfRT/cH4U/3OAFf90gBX/dIEU/3mDE/99hxT/f4cW/36G + FP99hBT/f4MT/4KHFf+FiBb/iIkV/4iIFf+GhhX/hoQW/4WCFv+CgBT/gH0U/398E/99eBT/fHYW/3p0 + Ff95cxX/eXIV/3hxFf93bxb/d28V/3dvFv93bhX/d20V/3dtFf94bRX/eW0W/3ltFf99bhb/f20W/39t + Fv9/bhf/gW4W/+bi2tbh3ty80c3JqMO+uJm6tK6N5+bl1hISEdoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tXV5sG9t5rIxb+l19bSt/Tt + 7s1jo4H4O5Bi/0SWZ/9ElmX/RZVj/0WUYf9Djlz/RYpY/0SJV/9Eh1X/RYZS/0mJU/9JiFL/SohP/02N + Uf9NjE//To1O/1KQUP9Tj0z/VZNN/1STSf9Yk0n/WpRH/16WRv9hl0P/ZJpC/2qbQP9vnT3/dKA7/3uj + Of+Bpzj/hKg3/3+jMv94mS7/cJAo/2yKJP9uiiP/cowi/3ONIP9zih7/cYYe/3CFGf9ygxj/cYEX/3B/ + Ff9vfhT/bn0U/256Fv9uexT/cX8W/3WFF/95ixf/fpAY/4GTGP9+jxf/fo8X/3mIFv9wfRT/b30T/3F+ + Ff9yfhb/dIAV/3iCFP95ghX/fIYU/4GKFf+AiBX/foQT/32DEv9/hRP/hYgV/4mKFv+HiBX/h4gU/4eH + FP+GgxX/hIEV/4OAE/+BfRP/f3wU/316Ev98eBT/enQT/3lzFP95cxT/eXMU/3hxFP94bxX/eG8V/3dt + Ff93bRX/d20V/3htFf95bRX/eW0V/3xtFf9+bRb/fm0W/39uF/+AbRX/5uLa1uHe3LzQzcmoxL+6mb21 + r43o5+XWEhIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMjX1dXmw723msjFv6XY1dK39OzvzWWkfvg7jlv/RJRi/0eXY/9JlmD/RZBc/0aN + Wf9GjFb/Q4ZQ/0SEUP9IiE//SYVN/0mGTv9LiEz/TIdJ/0+MS/9PjUr/Uo1K/1WPSv9WkEf/WpZF/16X + Rf9hm0P/ZJtC/2aaQP9omz7/bZs7/3OeOf96ojf/g6Y2/4GmMv99oiz/epsp/3mVKP9yjyT/bYki/3KK + If92jB7/dYse/3WJHP91hxn/coQZ/3OCF/9ygRX/b34U/3B+FP9vfRT/bnsV/257E/9xfxX/doUW/3qL + Fv+AkRf/gJMY/36PFv+CkBj/eIcV/3B+FP9wfxX/cn8T/3OAE/93gRP/eYIU/3yEE/+AiRT/gYsU/4GJ + E/9+hBP/fYMS/4CGE/+GiRT/iIkT/4mKFP+HiBT/h4cV/4aEFP+EgRP/g4AT/4F9E/9+ehL/fHoR/3t3 + Ev96dBP/enMU/3lzFP95chP/eHAU/3hvFP93bhT/d20V/3dtFf93bBX/eG0V/3ltFf95bBX/em0V/3xs + Ff9+bRb/f24X/4BtFf/m4trX4d7dvdHOyajFv7qZvLWvjejn5dYSEhHZAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNbW1ebDvbeaycXApdfW + 0bf07u/NZqJ6+DyOWP9Gll//RpVc/0iVWv9Hklr/RYxX/0WIUP9Ghk7/R4RL/0qCS/9Lhkr/SoVK/0yG + R/9OiUf/T4hG/1CKR/9TjEP/V5FD/12XRP9jnEP/Zp5B/2aeQP9mnD3/aZo6/22aOf9znzj/e6Y1/36m + Mv98oS//eJsq/3qaJf98mST/epUm/3OOIv9xiR7/dYod/3iMGv96jBr/eYoZ/3eHGf91hBj/dIMW/3KB + FP9wfxP/cH0U/298E/9ufBP/bnwT/3OCE/94iBT/fI0V/4KTFv+Bkhb/gpEV/4aUFv95hxX/cIAU/3KB + E/90gRP/d4IS/3mCEv95gxL/fIUS/4KKEv+EjBP/gooR/3+GEv9/hBH/gocS/4iKE/+JixL/iYoS/4iI + Ev+HhhP/hoUT/4SCEv+DgBP/gX0Q/396EP99ehD/fHcS/3t0E/97dRH/e3MT/3pyFP95cRT/eHAT/3dv + E/93bhT/d24U/3dsFP94bBT/eW0V/3htFP95bRX/em0V/31sFf99bRb/gG0V/+bi2tfi3929087KqMTA + upm7ta6N6efl1hISEdkAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI1tbV5sK+uJvJxcCl19bRt/Pu781mo3j4PIxU/0aTWP9Jlln/SJVY/0aR + Vf9GjVL/R4hO/0iDSf9Igkf/S4RI/0uDRv9NhEX/TIVF/06EQ/9QiEL/U4xA/1yTQf9gmkD/ZZ9A/2if + Pv9lnjz/ZZs7/2mYOf9umzj/dqQ2/3mpMf93oy3/dZkq/3WVJ/96mST/fpoi/36aJP98lCP/dYwd/3SJ + G/93ihr/eo0Z/3uNGf96ixj/eYgY/3aEFf90hBX/coIU/3F/FP9wfhP/bn0T/298Ev9wfhP/dYYS/3uL + FP9/jxT/hpQV/4aTFP+FlBX/iJUW/3eGE/91gRH/dYMS/3iEEf96hBH/e4US/3yFEf9/iBH/hIwT/4aN + FP+DihH/gIYR/4GFEP+GhxD/iYsR/4mLEf+JihL/iIkQ/4aHEf+FhRL/hIIS/4OBEf+Bfg//f3sR/315 + Ef98dxH/e3YQ/3t2EP96dRL/e3QT/3lxFP95cBP/eHAS/3duE/93bhT/eW4T/3htE/94bRP/eG0U/3ts + E/99axX/fWwV/31tFv+AbhT/5uLb1+Lf3b3TzsqpxMC6mbu2sI7p5+XWEhIR2QAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjX1tXmw764m8jF + v6bY1tK49O7wzmiidPg/i0//R5JV/0iUVP9KlFT/SZBR/0qMTf9Kh0r/SYRG/0mCRP9KgUP/TYNC/0yC + QP9Og0D/UIc//1qOPv9gmD7/ZJw+/2efPP9mnTv/Zps4/2aZOP9qmTj/c6E1/3itNf93qS//b5kp/26Q + Jv90kCP/eZUi/3+aIP+AmSL/gJkg/36TIP93ixv/dYob/3qMGP98jBn/fY0Z/36MGP98hxb/eIUV/3aE + E/9zgRX/c4EU/3J/Ev9wfhH/cX4R/3OAEv95hhL/gIwT/4STFf+Jlxb/hpQW/4qXFf+KlhX/eYUS/3iC + Ef95hBD/e4YS/32GEv99hxL/f4cS/4KLEP+HjxL/ho4S/4OKEf+Ahw//gYcO/4aKD/+JixD/iYsQ/4mL + EP+HiBD/h4UR/4aEEf+DghD/gX8P/4B9Dv9+ehH/fXgR/3x2EP97dxH/e3YQ/3x0Ev99cxP/e3IS/3tx + Ev96bxP/eW4S/3luEv95bhT/eG0T/3htE/94bRP/e20T/31sE/98bRP/fm4V/4BuE//m4tvX4d/dvdLO + y6rFwLuavLawjunn5dYSEhHZAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNfW1ebCvribx8XAptjW0rn07e/OaKBw+ECJS/9JkVH/SpNR/0yU + Uf9NkE//S4xJ/0yHRv9MgkP/S4FA/0uAP/9LgT7/ToQ9/1WKPP9clTz/Yps8/2aePf9mmzr/Zpk4/2OY + Nf9mmDX/bZw1/3erNf94tDL/b58s/2yMJ/9siCX/cI0i/3eTIP99lyD/gJkf/4ObHv+BmB3/f5Me/3mM + Gv94iRj/eYsY/3+NF/+Cjhj/gYsX/3+IFf97hRT/doQT/3SCFP90gRP/cn8R/3J/Ef9yfxH/doIT/32I + E/+CjhP/iJUU/4uYFf+IlRT/j5wU/4qVFP98hRL/e4US/3yFEf9+hxL/focS/3+HEf+AiRD/hI4R/4qQ + E/+HjhL/gooP/4KHDv+DiA//h4sP/4mLD/+Jiw//iIsQ/4iIEP+IhRD/hYMR/4OBEP+CgBD/gH0P/356 + D/98eBD/fHcP/352EP9+dxD/fXUP/310EP98cxD/e3IS/3twE/96bxP/eW4S/3htEv94bRL/eG0T/3ht + E/96bRP/fGwT/3xsE/9+bhX/gG4T/+bi29fh392+0s7LqsXAu5q9tq+O6efl1hISEdkAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI19bV5sK/ + uZzGxb+m19XSufTt785soHD4QopJ/0iQTP9LlE7/TJVO/02QTP9MjUf/TYdD/02DQv9MgD//ToA8/1OG + PP9ZkDr/YJk5/2WeOf9knTn/Ypg4/2OUNv9llDL/aZky/3OmMv95uTP/c7Av/2mRKP9mgiX/a4Uj/3GL + If91kCD/fJQe/3+YH/+CmR//hZwc/4SaHP+DlB3/fIsZ/3qIGP99ixf/g44V/4SPFv+CjBX/f4gU/3uG + Ev95hBP/d4IS/3Z/Ef90fxD/c4AR/3aCEf96hhL/gIsT/4WSFP+LlxX/jJoT/4qXEv+TnxX/iJMT/32H + Ef99hxL/fokR/4CKEP+Aig//gIgR/4OMEP+JkBL/ipES/4eNEf+EiQ7/g4cM/4aJDv+Kiw//iowQ/4mL + D/+Jig7/iYgO/4eFEP+GgxH/hIAP/4N/D/+BfRD/f3oP/314D/9+eA//fncP/353EP9+dxD/fXYP/3x0 + Ef97chL/e3IR/3pwEv96cBL/eW4Q/3ttEP97bRL/e20S/3ttEv98bBP/fWwT/39uFP+AbxL/5ePb1+Lf + 3b7TzsuqxcC7mry2r4/p5+XWEhIR2QAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAA + ABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjX1tXmw764m8jFwKbW1dK58+3wzmudbPhDiEP/S5BL/0qU + S/9LlEr/T5JI/06LRP9OhkH/TIM9/1CDPP9YjDv/YJc6/2SdOf9lnTj/ZJg3/2OUNP9hkDL/Y5Ix/2ye + L/92tTL/eb8w/2yiK/9kgiT/ZoAi/2eFIv9tiCD/c40f/3eRH/99lB7/gpgd/4eaHP+Imxr/hpkc/4SU + Hv97ixn/eogX/4CLFv+DjxX/hI8V/4KMFP9/iBP/e4YT/3qEEv94gRH/d4AQ/3aBD/90gRD/eIMR/3yI + Ef+CjRP/iZQU/42aEv+NmxP/jJkS/5WgFf+GkRL/fogR/3+HEf9/iQ//gIsP/4GLD/+BiQ//hY0Q/4uT + Ef+MlBH/h40R/4WJD/+EiA3/iIoO/4uLDv+LjA//iYoO/4mJDf+Ihw3/hoUO/4WDD/+EgA//g34O/4F8 + Dv+Aeg3/fngO/354Dv9+eA7/f3YP/393EP9+dg//fXQQ/31zEf98cxD/fHER/3twEv97bxL/fG0R/3xt + Ef98bRH/fG0S/3xsEv99bRT/gG8T/4FwEv/l49vX4t/dvtPOyqrFwLubvLawkOnn5dYSEhHZAAAAmQAA + AIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNfW + 1ebDv7mcyMbBptjW07nz7fDOa55o+ESHQP9Lj0f/TZRH/06VRv9QkEP/UIs//1GIPv9Uizv/XZM7/2ac + Of9mnzj/Y5w2/1+TNf9ejjH/X44v/2eSL/9xqzD/eMMy/3G6Lv9kjib/Ynsg/2R/If9mgyH/aYce/3CK + Hv92jR7/eZEe/4CVHf+DmRr/h5kZ/4ebGf+KmRv/iJUf/36LF/99iBX/gYsV/4SNFP+FjhX/gosU/3+J + E/97hhL/eYMR/3iDEP93gg//d4EP/3eCD/95hBH/fokR/4WQEf+LlhL/kJwR/4+bEv+RnBL/lqEU/4SO + EP9/ig//gIoO/4GMDv+DjBD/g4sP/4OKD/+HjxD/jJQQ/4uTEf+GjRH/hIkO/4aJDP+IjA3/i40N/4yN + Dv+Kiw3/iYkN/4iHDf+HhQ3/hYQM/4SADv+Dfw//gX0N/4B6DP9+eAz/f3kO/354Df+Cdw7/gncP/4J2 + D/+BdRD/gHQP/4B0Dv9/chD/f3AR/31uEf99bhH/fG0Q/3xtEf98bRH/fG0R/35uE/+AcBL/gXAS/+bj + 29ji392908/KqsXBu5u9uLGP6Obl1xIREdkAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI19bV5sO/uZzJxsGm2NbTufTu8c5snGb4RIY9/02Q + RP9Ok0T/UZND/1GQQf9TkT7/XZU8/2KcPP9moTr/Zp43/2GXM/9ejzH/W4sw/1+LLv9pmC3/dr0x/3bK + Mv9qqSv/YYEj/2F7IP9kgSD/ZoIg/2eFH/9uhx3/cowd/3ePHf9+kRz/gZYa/4WYGf+KmRj/i5oX/4yZ + HP+KlR//gYsV/3+IFP+BjBT/hI8S/4SOE/+CihL/gIgQ/32GEv97hRD/eoMP/3qDD/95gw//eYMP/3yG + EP+BixH/h5IR/46ZEv+TnRL/kZsT/5WfE/+VnxH/go0P/4GLDv+Diw//hI4O/4SMD/+Diw7/hYwP/4yQ + EP+PlBH/jJIQ/4iMEP+Gig3/h4kN/4qMDP+NjQ3/jYwO/4mKDP+IiA3/ioUM/4iFDP+Egw3/g38N/4J+ + Dv+Aew3/f3kN/354Df9+eA3/f3gN/4J4Df+CeA7/gncP/4F1D/+AdA7/gHQO/39yEP9+cBD/fm8Q/31u + Ef99bRD/fG0Q/3xtEP9+bRL/gXAS/4JyEf+DchH/5uPb2OHg3b7Sz8urxsO8m725sY/o5uXXEhER2QAA + AJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAA + AMjZ19bnwr64m8rGwabZ19O59O7yzmybY/hFhzn/TY5A/0+RP/9SlkH/WZpA/2GiP/9opDz/Z6M5/2Ka + NP9ekjH/XIsv/1yJLf9hjCz/bKUt/3bPMv9xxy//Y5Qn/2F6Iv9ifSL/ZIAh/2WBIP9ogx7/bIQd/3GH + Hv90jB3/epAd/3+TGv+Clhn/h5kY/42bGP+NmhX/jpoc/4uVIf+AihT/fogS/4KNFP+FjhL/ho4R/4KK + EP9/iBD/fYUR/3yFD/97gw7/e4MO/3qDDv97gw7/fogP/4SOD/+KlA//kJsR/5WfEv+SnBH/maES/5Kc + EP+CjQ//g4wO/4SMDv+Gjg//ho0O/4WMDf+Hjw7/jpQQ/5CWEP+MkhD/iIwP/4WKDP+Jiwz/jo0N/5CM + DP+PjAz/jIoK/4uHC/+KhAv/hoQL/4OBDf+Dfw7/gX0M/397C/9+egz/f3gM/4F3DP+CeQ3/gngN/4J4 + Df+CeA3/gHYO/4B1Dv9/dA7/f3MO/39yEP9+cBH/fW8P/3xuD/98bRD/fW0Q/39vEv+BcBH/gnIS/4V0 + D//m5NrY4uDevtTRzKvHw72bu7avjuno5tkTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNrY1+jCvbecysbBqNnX07n07/LObJtg+ESF + NP9NjD3/VJc+/12kQP9mq0D/aas8/2ikN/9imDP/XI0w/1uJLf9diiz/Y5It/2+2L/9x1zH/ZrIt/2GF + Jf9ifCL/ZIEg/2SBH/9lgR7/aIEd/2qDHv9uhRv/cYob/3eMGv98kBv/gJMa/4eWGf+Jmhj/jZoW/46a + FP+Qmh7/jJUh/4GKEf+AiBL/g4oR/4WNEv+FjRD/gooO/4CJD/99hg7/fIQP/3uDD/97gw7/e4MO/3uE + D/+BiQ7/h5AP/42XD/+TnhD/l6AP/5OcD/+cpBL/kZkQ/4WODf+Gjgz/hY4M/4ePDv+Gjg7/hYwN/4mP + Dv+Plg7/kJcP/4uQDv+Hig7/hokM/4qLDP+OjQz/kY0N/4+LDP+NiQv/jIcL/4mEC/+Hgwr/hYEL/4F9 + Df+AfAz/f3oL/355C/+AeQz/gncM/4N4DP+CeA3/g3gN/4N3Dv+CdQ3/gnUN/4JzDf+Acw7/f3IO/4Bw + Dv9/bw//fW4O/3xuDv9+bg7/gHAQ/4BxEP+CcxH/hnUR/+bk29jj4N6+1NHMq8bDvZy5tK6N6unn2hMS + EdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAA + AG0AAADI2djX6MG9t5zKxsGn2dfTuvTv8s9rmV74RYUx/1SWO/9gpj7/Z7E//2mvPf9mpTn/YJgz/16O + L/9ciCz/X4os/2idLv9xyjH/bNIx/2CYKf9deyP/YX4i/2WDIf9lgx//Z4Ie/2iCH/9qgh3/bYMd/3CG + G/9zihn/eIwZ/32QGv+Ekxf/ipYY/4yaF/+QmhX/kJoT/5GaHv+MlCD/f4gR/4CHEv+EihH/hY0Q/4OM + D/+Ciw//gIkM/36GDf99hQ7/e4QN/3uEDf97hAz/foUN/4KKDf+JkQ7/kJgP/5WdEP+Wng7/lJwP/52k + Ev+Olg7/ho4N/4aODP+Ijwz/iI8M/4eODf+IjQ7/jJMO/5GYDf+Qlg7/i44O/4eJDf+JiQv/jYwL/4+O + Cv+RjAv/kIoM/4yIC/+Lhgv/iYQL/4iBCv+EgAr/gX0M/4B8DP+AeQr/f3gK/4F4DP+Bdwv/gngM/4J4 + Df+Ddwz/hHcM/4N1Df+CdA3/gXQN/4B0Dv9/cg3/gHAN/39wDv9+bw//fW8P/35vD/+AcBD/gnIP/4R1 + EP+GdxH/5uTb2OPg3r7U0MurxsS9nLi0rY7q6efaExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjZ2NfowL24ncnHwqjZ1tO59O7yz3Cd + XPhPkjL/YKc7/2auO/9nrjv/Y6U4/16ZNP9bkS//XIst/2COLP9qrS7/cNoy/2bDLf9bgyP/Wncj/15+ + Iv9igSD/ZYIf/2eDIP9ogx//aoId/2qCHP9sghz/cYUZ/3WKGP96jBj/gJAY/4eTF/+Klhb/jZkV/5GY + Ff+QmRL/kpsf/4uUH/9/hxD/gIcS/4OJEP+Fiw//hIwP/4GKDv+AiA3/f4YN/36FDP98hAv/e4QL/3yE + C/9/hwv/hIwO/4uSDv+SmRD/mJ8Q/5idDv+ang7/nqQQ/4uUDv+Gjg3/ho4M/4mPDP+Jjwz/iI0L/4mP + Df+PlQ7/lJkN/5CVDf+Jjg7/h4oM/4yKDP+Qjgz/kI4K/5GNC/+Pigv/jIgL/4uGC/+JhAr/iIEK/4R/ + Cf+BfQv/gHwM/4F5Cv+CeAv/gngM/4J4DP+CeAz/gngM/4N4DP+Edwz/g3YN/4J1Df9/dQz/f3MN/4Bz + Df+AcAz/fnAM/31vD/9/bw//f28P/4BwD/+Ccw//hXYR/4d4EP/m5NvY4+Dev9TQy6vIxL2cubStjurp + 59oTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAA + AFQAAABtAAAAyNnY1+jBvbidyMfCqdnW1Lrz7fLPd6pc+FmeMP9jqTj/Y6k2/2CjNv9dmzX/XJUx/12Q + Lv9ili7/bsAx/2zhMv9grir/WHgj/1l4IP9bfCH/Xn8f/2SCHv9mgh7/aYMe/2qCHP9rghr/a4QY/2+E + Gv9zhhr/d4oY/32NF/+DkBX/h5QU/4uWFP+OmBX/kZgV/5GYE/+UmSH/jJId/4GJDP+Bhw7/hIkP/4WL + Dv+Fiw7/g4gM/4KHDf+AhQz/foUL/32EC/99hAv/fYUL/4CIC/+GjQ3/jZQN/5SbD/+ZoQ7/l54N/56i + Dv+eog//jJEN/4mPDP+Kjwz/i5AN/4qPDP+Kjgv/jZAM/5GWDf+UmQ3/kZUN/4qNC/+JiQv/j4wL/5KO + Cf+Sjgr/ko0L/5CKCv+OiAn/i4cJ/4mECv+HgQr/hn8K/4N9Cv9/fAr/gXkJ/4J4Cf+CeQv/g3gL/4R5 + Cv+EeAz/hHgM/4N3C/+Ddg3/gnUN/4F1DP+Bcw3/gHIM/4BxDf9+bwz/fm4N/35vDP9/cAz/gXIN/4N0 + D/+FdhD/h3kO/+bk2tji4N6/1NDLq8XDvZ24s62O7Onn2hMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2djX6MO+uJzJx8Ko2NbTuvLs + 8s96sFv4V58t/1ygM/9cnjT/W5w0/1yaM/9flzD/ZqIw/27TNP9p2zH/XJon/1dxIf9ZeSD/WHog/1x6 + IP9ffh3/Y4Ee/2aCHP9oghz/aYEb/2uBGP9sghn/boQZ/3KHF/95ihf/fo0V/4OPFP+GkxP/i5YT/5CX + FP+SmRT/kJcT/5OXIf+Mkhr/gYgK/3+GDf+DiA7/hYwO/4WLDf+DiQ3/gYcK/4CFCv99hQr/foQJ/36E + Cf+AhAv/g4kK/4iPDP+QlQ3/mJwN/5ygDf+anQ3/oaQO/5yeDf+MkAz/i48L/4uQDP+LkAz/jI4M/4yP + C/+OkQ3/kpcN/5SZDP+Okgz/iYwL/4uJCv+Qjgr/kpAJ/5KPCv+RjQr/kIoK/46ICf+Lhwn/iIMI/4eC + Cf+Gfwr/gnwJ/357CP+AeQj/gXkI/4F5Cf+CeQr/gnkK/4N4Cf+DeAv/hHgM/4J1C/+CdQv/gXQM/39z + Df9+cgz/f3EL/35vDP9+bgv/fnAM/4ByDf+CdA7/hHYQ/4Z3Ef+HeQ//5uTa2OPg3r/T0MusxsO8nbu0 + ro3r6efaExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMjZ2dfow7+5nMvIw6fa2NS68+zzz3erWfhRlCr/VZUw/1eXMv9anDL/YJ8x/2my + Mv9u4Df/Zc0y/1qJJv9XciH/WXoh/1p7H/9aeR7/Xnoe/2F+Hv9kgR3/aIQa/2qDGv9qghn/bIMX/22C + GP9vhBj/dIgW/3qKFf9+jRX/hJEU/4iVE/+MmBP/kZkU/5GZEv+QlxL/k5cj/4uQGf+Ahgr/gIYO/4SJ + Df+Giw3/hooN/4SIC/+Chwr/gIUK/3+GCv9/hQr/gIUK/4GGCf+Fiwv/i5EM/5GXDf+anQ3/naAO/5ue + Df+ipg3/lpwL/4uRC/+LkAv/i5EL/4yRCv+Mjwv/jJAL/5CUC/+WmQv/lZkL/46RCv+Liwr/josK/5KO + Cv+Tjwr/k44K/5KMCv+Qigr/jogJ/4yGCf+KhAn/h4EI/4R+Cf+DfAn/gHsI/4F5CP+Begj/gnoJ/4J5 + Cv+DeQr/g3gJ/4N3Cv+Ddwz/gnYL/4J1C/+BdAz/gHIM/39xC/9/cAv/fm8L/39vDP9/cAz/gHIN/4J0 + Dv+FdhD/h3kQ/4l7D//n5NvY4+Dev9PRy6vIxL2cubStjuro5tsTEhHaAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNnZ1+jDv7mcy8fDp9rY + 1Lr07/TPdKJV+E2IJf9VkC7/V5cw/1+jMv9qwDb/bOk5/2C/MP9Zgif/WHYk/1p6If9Zeh//W3kd/1t4 + HP9dehv/Yn4d/2aBG/9pgxj/bIIY/2uDF/9sghf/boIW/3KDFv91hxT/e4oU/4CNFP+HkRP/ipUS/4+X + E/+RmBH/kZgP/4+WEf+TmSL/iI8V/3+FCP+Bhgz/hIoN/4aKC/+FiQr/g4cJ/4OHCf+BhQj/f4QJ/3+E + Cf+AhQn/g4cJ/4eMCv+Nkwv/lJkM/5ufDP+coA3/nJ8M/6OmDv+TmQv/i5IK/4uRCv+Nkgv/jpEK/4yQ + Cv+OkQr/k5gK/5qaC/+Wlgz/j48K/42MCf+QjQj/k44K/5SQCf+Ujwn/kowJ/4+KCP+Nhwj/jIYJ/4qD + CP+HgQj/hH8I/4N8CP+Cewj/gXoH/4J6B/+DeQj/g3kH/4N5CP+DeAn/gncJ/4N3Cf+BdQr/gHQK/4Bz + C/9/cwv/fnIL/31xCv99bwr/fnAM/39wC/+Bcwz/g3UN/4V3Dv+Ieg//inwO/+bk2tji4N6/1NHMq8fD + vJ23sayQ6ejm2xMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI2djX6MS+up3MxsOp2tfUuvTv9M9xnFT4TIQl/1iQLv9gozH/a882/2vo + Of9gsS//WYQm/1l/JP9afSH/W3of/1t6Hv9beRz/W3gb/117Gv9hfhv/Z4EZ/2qDGP9sghf/a4MX/22C + Ff9vghT/coMV/3WGE/98ixT/go0T/4aREv+MlBL/kJYR/5GXEP+Rlw//kJYR/5OYIf+HjhL/gIUJ/4GF + DP+Eig3/howL/4aJCv+Ehwn/g4cJ/4GFCP+AhAn/gIQI/4CFCP+Dhwn/h40J/4+UC/+Ymgv/naAM/5yg + DP+eoA3/oaUN/5KXCf+LkQn/jJEK/42RCv+NkQr/jJEJ/4+UCv+VmQr/mpoL/5WUC/+Qjgr/jowJ/5KO + CP+Ujwn/lJEH/5SPCf+SjQj/kIsI/46ICP+MhQj/ioMI/4eCB/+EgAb/g3wH/4F6CP+Begf/gnoH/4N5 + B/+DeQb/g3kI/4N4Cf+DeAn/g3cJ/4F1Cv+AdAr/fnML/35zC/99cQr/fXAK/31vCv99cAv/fnEL/4F0 + DP+Ddg3/hXgN/4h7D/+KfA3/5uTa2eLg3r/U0MysxsG8nrexrJDp6ObbExIR2gAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjZ2NfoxL66nczH + xKna1tO69O/zz3GaVPhNhiT/XaIv/2jWN/9o5Dn/XKUt/1mGJ/9Zhib/WYIi/1t9H/9beh3/XHoc/115 + G/9deBr/XnoZ/2F+Gv9ogRj/bIMW/2uCFv9rghb/boEU/3CBE/9zgxT/d4cT/3qLEv+CjhP/h5AR/4uT + Ef+Olg//kZYQ/5CWDv+PlRH/lJgh/4eMEf9+hQf/gYYL/4aKC/+Gigr/hokK/4SHCf+Dhwn/goYJ/4GF + Cf+Chgj/gYUH/4OJBv+Jjwf/kpUH/5qbCf+foQz/nKAL/6CkCv+hpAr/kJQJ/42QCf+NkAn/jpEK/42R + Cv+Okgn/k5UJ/5qYC/+ZmQr/k5MK/4+NCf+PjAj/ko4I/5SRBv+UkQf/k48I/5GLB/+Qign/jogI/4yF + CP+JgQj/hoEH/4N/Bf+DfAf/gnsI/4F6Bv+Aegf/gnkI/4J3B/+DeAj/gncJ/4N4Cf+Bdgj/gXQK/4Bz + Cf+Acwv/f3IK/31wCP99bwn/fW8J/39wCv9/cgv/gHMK/4N1DP+Gdw3/iHoN/4t+Df/n5drZ4uHev9LP + y6zFv7yft7KskOro5tsTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNnY1+jDvrqdzMfEqNrW1Lr17vPPcp1S+FWfJf9k3DX/YNk1/1qZ + LP9ZiSj/W4wn/1qHJP9ZgiD/WXwd/1t5HP9cehv/XXka/114Gv9gexn/ZX4X/2iBFv9rghb/a4IV/2yB + Ff9wgBT/cYET/3OEEv95hxH/fYsR/4ONEP+IjxH/i5IP/4+WD/+Qlg3/j5YK/5CVEP+TliD/hooO/4GD + B/+BhQr/hYkL/4WJCf+FiQj/hIcI/4OGCf+ChQf/goUH/4KFB/+ChQf/hYoI/4uQCP+Ulgf/m50I/5+g + DP+cnwv/pKYK/56hC/+Skwj/kZII/5GRCP+Skgn/kZAK/5GRCf+Wlgv/mpoK/5maCv+Tkgj/j40I/5GM + CP+Ujwj/l5EI/5aRCP+Tjgj/kYwI/5CLB/+OiAf/i4QI/4mCB/+HgAX/hX4G/4J8Bf+CfAb/gXsE/4B6 + Bf+Cegf/gngG/4J4Bv+Cdwf/gncI/4F2CP+AdAn/f3QJ/35zCP99cgn/fHAJ/3tvCP98cAn/fXEJ/39y + Cf+BdAr/hHcN/4Z6DP+Iew3/in0N/+bk2tni4d6/0s/LrcXAvJ+3sqyQ6ejm2xMSEdoAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2djX6MO+ + up7Lx8Sp2tbUu/Ts8896ulX4Wt0r/1rKMf9VjSj/V4op/1mQKP9aiiX/Wocj/1mAH/9Zexz/XHob/114 + G/9ceBr/XHcY/196F/9lfRX/aIAV/2uCFv9tgRX/boEU/29/Ev9xgRL/c4QQ/3qGD/9/ihH/g4wR/4iP + EP+Lkg7/j5YN/4+WC/+QlAj/kZUR/5KWIf+EiA3/gYQH/4KFCf+Fhwr/h4gJ/4aIB/+Fhwj/hIUI/4KF + B/+DhQf/goUH/4KFCP+Iigf/j5AI/5aYCP+cngj/n6EL/52fCv+mpwv/nZwL/5GSB/+RkQf/kpII/5KS + CP+RkAj/k5EJ/5iWC/+bmwn/mJcI/5KQBv+QjQf/ko4G/5WRCP+XkQb/lpAH/5ONCP+Riwj/kIoF/46H + Bv+Mgwj/iYMG/4iABv+Ffgf/hHwF/4F8Bf+CeQb/gnkH/4J4B/+DeQj/gngH/4J3B/+Cdwb/gXYJ/390 + Cf9+cwn/fHEI/3twCP97cAj/e28I/3pvCP99cgr/gHMJ/4N1C/+Edw7/hnoN/4h9DP+Kfw3/5uXb2eLg + 3r/Sz8utxcC8n7exq5Hp6ObbExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAA + ABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjZ2dfow767nsvHw6na1tS69Ojy0HzoWvhQuCX/UYIl/1aG + Jf9ZkCf/Wo4m/1uLI/9ahSH/WoAd/1t8G/9beRn/XHgZ/1x4GP9cdxf/XnkW/2R8Ff9ofxT/bIEU/26B + E/9tgBH/boAQ/3CCEP90gw7/e4YP/3+KEP+EjRH/iJAO/4yTDf+OlQv/jpUJ/4+UCP+QkxD/kZUh/4OI + C/+AhAb/gYUI/4SICP+Ghwf/hocG/4WGBv+Dhgb/goQH/4KEBv+BhAb/hIYH/4mMBv+Rkgb/mJoG/52e + B/+enwn/np8J/6WnCv+amgf/kpEI/5KSCP+TkQf/kpII/5KRB/+Vkwj/mZgJ/5qbCv+WlAn/kY4H/5CM + CP+Tjgf/lpAH/5aRBv+Wjwf/lI0I/5KKB/+QiAX/jYYH/4uECP+IggX/hn8F/4V9B/+EfAX/g3wF/4N6 + Bv+DeQX/gngF/4N4CP+Bdgb/gXYG/4F2Bv9/dQf/fXMI/3xyCP98cQn/e3AI/3pvB/96bwf/em8I/31y + Cf9/cgj/gnYK/4R4DP+FeQz/iX0N/4p/Df/m5dvZ4uDfwNLOy67Fv7yft7KskOro5tsTEhHaAAAAmQAA + AIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNnZ + 1+jCv7ueysfDqdjX07v17fPQcaxQ+Ep2G/9UfyT/Vooj/1qPJf9ajiX/XIsi/1uGIP9bgB3/XXwb/1x5 + Gf9ceBj/XHgW/1x3Fv9geRb/ZHsU/2h+E/9tgRP/bYAS/21/EP9vgA//cYIO/3eED/98hg7/f4kP/4SN + Dv+IkQ3/i5MM/42UCv+PlQr/j5MI/5CTE/+RlR//g4gI/4CEBv+ChQj/hYgH/4eIB/+Ghwb/hIYG/4OG + Bv+ChAb/goQG/4OFB/+Fhwf/i40G/5OTB/+amwb/np8H/5+gCP+iogj/p6cK/5iXCP+Tkgj/k5MI/5SS + CP+Skgj/k5EH/5aUCP+amQj/mpkJ/5WTCP+Rjgf/kI0G/5SPB/+XkQf/l5EG/5eRB/+Ujgb/kosG/5CJ + B/+Nhwf/i4MG/4iBBv+GfwX/hX0F/4R8BP+EfAT/g3sE/4N7A/+DegT/gnkG/4J3Bv+AdQX/gXYG/4B1 + Bv99cwf/e3EH/3twB/97cAf/em8H/3pvB/97cQf/fXMI/4F1CP+Ddwr/hHkL/4Z7C/+Kfg3/in8M/+Xl + 2tng397A0s3KrsXAu5+3sqyQ6ujm2xMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2dnX6MK/up7LyMSp2tfUu/Xw89BvjEv4SnYa/1KC + If9WiSL/Wo8j/1qPI/9ciyH/XIUf/1yBHf9cfBv/XXgY/1t3F/9beBX/XHcU/2F2Ff9lehP/aX0T/2x/ + Ef9tfw//bX4P/29/Dv9wgA3/doMN/3qGDf+AiA3/g4wN/4eQC/+KkQr/jpMJ/4+UCP+Nkgf/kZMU/5GU + Hv+Chwb/foMF/4OEBv+Ghgb/iYgG/4eGBf+EhQX/hIUG/4OEBv+DhAb/g4UG/4eHBf+OjQX/lZUG/5ub + B/+goQX/oJ8G/6WjB/+lpAj/lpQF/5ORBv+Ukwf/lJMH/5SSB/+Ukwb/lpYH/5yaCP+amAf/lJIE/5GN + BP+Sjgb/lpEG/5eSB/+YkQb/l5AF/5ONBP+RiwX/j4gF/4yGBf+LhAX/iIEF/4Z+Bf+FfQT/hHwD/4R8 + A/+DewT/g3sE/4J7A/+CeQT/gXcF/4F2Bv+Bdgb/f3MF/31yB/97cQb/e3EF/3pvBv96bwf/enAH/3xy + Bv9/cwf/gXUJ/4N3Cv+Fegr/h3wM/4l+DP+LgQr/5eXa2eDf3cDSzsquxcG8n7eyrJDp6ObbExIR2gAA + AJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAA + AMja2dfow7+6nsvIxKna19W89fD10G+RS/hJdxj/UoEg/1aIIf9ajyD/XJAg/12LH/9chR//XIEc/1x8 + GP9ceRb/W3YW/112FP9fdBT/YXcU/2R6E/9ofRH/bH8Q/21/EP9tfg//bn4O/3F/Df94gg3/e4UO/3+I + DP+DjAz/h48L/4yRC/+PlAr/j5MH/5CRBv+SlBX/kJId/4GGBf9/ggX/goMF/4SGBP+IhwX/h4YF/4SF + Bf+DhAX/g4QG/4OEBv+DhQT/h4kE/4+NBf+WlQX/m5wG/6CiBv+foAX/paUG/6OiB/+Vkwb/k5IG/5ST + B/+Ukwf/lJIH/5WTBf+Zlwb/nJoH/5mVBv+TkAX/kY4E/5SPBf+XkQb/mJEG/5iRBv+Wjgb/lIwF/5KK + Bf+PiAb/jIUH/4uCBv+IgQX/hn4F/4V9A/+EfAP/hHwD/4N7BP+DewT/gnkF/4J4Bv+AdgT/gXYG/350 + Bf99cwX/fHIH/3txBv96bwf/eW4G/3lvBv96cQX/fHIH/31zB/9/dQn/gncK/4V6Cv+HfAv/iX4N/4uB + C//m5NrZ4t/dwNHOy67FwbyftbCrkeno5tsTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNrZ1+jFv7yezMjEqdrX1bz18PXQbpBJ+Eh1 + F/9SgB//Vocg/1mPH/9ckCD/XIwe/1yFH/9bgBv/WnsY/1t3Fv9bdhb/XnUU/190Ff9hdhP/ZHkS/2h8 + Ef9rfBD/bX4Q/21+D/9vfQ7/dH8N/3iCDf97hA3/f4gL/4OLC/+Ijgn/ipEK/4yTCP+Pkgf/kY4I/5KU + Gf+Okhz/gYUE/3+BBf+ChAX/hIcE/4iGBf+GhQT/hIUG/4OEBv+DhAb/g4QG/4OFBf+IiQT/j5AF/5eW + B/+enQX/oaIG/6CgBP+npwb/n58F/5SSBv+UkQb/k5EG/5SSB/+Tkgb/lZQF/5uZBv+bmgj/lZIF/5GO + A/+SjgT/lJAF/5eRBv+YkQb/mJEG/5WOBP+Tiwb/kYkF/4+HBf+LhAb/ioEG/4eABf+FfgX/hHwD/4R8 + BP+EfAX/hHwF/4N7A/+CeQX/gXcG/393BP9+dgP/fXQF/3xzBP97cQX/e3EG/3puB/95bgb/eW8G/3px + Bf98cgf/fXMH/351CP+CeAj/hHkK/4Z8C/+Ifw3/jIEL/+bk2tng3t7B0c7LrsXBvZ+3squR6ujm2xMS + EdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAA + AG0AAADI2tjX6MTAvJ7MyMWp29jWvPXw9dBtkEj4R3QX/1GAHv9Whx7/Wo8g/1yRIP9cjB3/XIYc/1yA + G/9cehj/W3YW/1x0Ff9dcxX/XnQV/2F1Ev9jeRH/Z3wQ/2p7D/9sfBD/bnwN/298Df90fg3/d4EN/3qE + DP9+iAv/hIoK/4iNCv+KkAn/jZIJ/42RCP+Ojwj/k5Qc/46RG/+BgwL/f4AG/4KCBP+EhQT/h4UF/4aF + Bf+ChAb/goMF/4KDBf+DhAX/hIUF/4uKBf+RkAb/mJgG/5+eBv+goQb/oKAF/6inBv+cmwX/k5EG/5OQ + Bf+UkQb/lJEG/5SRBv+WlQb/m5kH/5mYBv+Tkgb/kY4E/5ONBv+Vjwb/mJEG/5iRBv+XjwX/lIwF/5KL + Bv+QiQf/joUG/4qCBf+JgQX/h4AF/4V+A/+EfAP/hHwD/4R7Bf+EfAX/g3sD/4J5BP+BdwX/fncF/311 + BP99cwX/e3EF/3twBf96bwX/d28G/3ZuBf93bwX/eXEF/3xxBv98cgb/f3YH/4B3CP+Eewn/hn0K/4iA + Cv+Mgwn/5uPa2uDf3cDS0MquxMG8oLayrJLq6ObbExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMja2dfoxcC8ns3Jxanb2Na89vD20G6O + SfhIdBX/UX8d/1WGHf9bjR7/XJAe/12MHf9bhhr/XH8Z/117F/9cdxX/XXMU/15zFP9echP/X3QS/2N3 + Ef9oeg//a3wO/2x9Dv9tew3/bnsN/3J+DP91gAv/eoMM/3+HCv+DiQr/ho0J/4mPCf+MkAr/jI8J/4uO + B/+TlR3/jY8Z/3+BAv9/fwX/goIE/4KEA/+GhAT/hYQG/4KDBf+Cgwb/goIG/4KDBf+Hhgb/jYsF/5OR + Bf+ZmAX/n58G/5+fBv+hoQb/p6UG/5mXBP+SkAX/lJEG/5SRBv+TkAb/lJEF/5iVBv+bmAb/mJYF/5KQ + Bf+QjAb/k4sH/5eQBf+YkQb/mJAG/5WOBv+TjAb/kYoH/4+HBv+NhAf/ioIG/4mBBf+GfwT/hHwD/4R8 + A/+EfAP/g3sE/4N7BP+DegT/gXgF/4B2BP9+dQT/fHMF/3tyBP97cQb/em8F/3duBP90bgX/dG4F/3Ru + Bf93cAX/enIH/31zB/9/dgf/gHgI/4N7Cf+FfAn/iYAI/4uDCf/l49ra4N/ewdHPy67EwLugtrKrkuro + 5tsTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAA + AFQAAABtAAAAyNrZ1+jFwLyfzcnFqdvY1rz28PbQcI1I+Eh0FP9Rfhz/VYUe/1qNHf9djx7/XYwc/1yH + Gf9dgBn/XHsW/1t3FP9ccxT/XnMU/15yE/9edBH/YncQ/2d5D/9qfA3/a3wN/2x8Df9tfA3/c30L/3WA + DP96ggv/f4YK/4SJCv+HjQn/iI8J/4qPCP+Ljwn/io4I/5KWIP+Ljhb/f4EC/35/BP+BggT/g4QD/4OE + BP+DhAT/goMF/4KDBv+Cggb/goMF/4eGBv+NiwX/lJIF/5uYBv+fnwb/n54G/6SiB/+lpQf/lZMF/5KQ + Bf+TkAX/lJEG/5OQBf+UkQX/mZQF/5qXBv+WkwX/ko0G/5CLB/+TjAf/l5AF/5iRBv+XjwX/lY0F/5OL + Bv+RigX/j4YG/4yDBv+JgQX/iIAF/4V9BP+EfAP/hHwD/4N7A/+DewT/g3sE/4N5Bv+Bdwb/gHYE/390 + BP98cwT/enEE/3pwBf93bgT/dG4F/3RuBf90bgX/dG4F/3VvBP93cQb/fHMH/392B/+BeAj/gXoI/4R9 + Cf+JgQj/i4QJ/+Xk2trg397B0c/LrsTAu6C2sqyS6ejm2xMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2tnX6MXAvJ/NyMWq29jWvPbx + 9tBvjUf4R3IV/1F9Hf9VhR7/Wo0d/12QHf9djRv/XIgZ/12BFv9cexb/W3YU/1xzE/9echP/XnET/2Bz + EP9kdhD/aHkP/2t7DP9rewz/bHwM/2x8DP9xfQv/dn4L/3mDCP9/hQn/g4kJ/4eMCf+IjQr/io8I/4uP + CP+LjQj/k5Yi/4uMFP9/gAD/fn8E/4GCA/+DhAP/g4QE/4OEBP+Cggb/goIG/4KCBv+CgwX/h4YG/46M + Bf+Ukwb/nJoF/5+fBv+fngb/o6QF/6GiBv+TkQX/k5AG/5OQBf+UkQb/k5AG/5WSBv+ZlQb/mZYF/5SR + Bf+RjQb/kosG/5ONBf+XkAX/mJEG/5aPBv+UjAj/kokH/5CHBv+OhQb/jIMG/4mBBf+IgAX/hX0E/4R8 + A/+EfAT/g3sE/4N7BP+DewT/gnkF/4B2Bv9/dAX/fXQF/3xyBv93cQT/dnAE/3RuBP90bgX/dG4F/3Ru + Bf90bgX/dXAE/3dyBf95dAf/fnYH/4F4CP+Bewn/hH0L/4mCCv+Kgwj/5eTa2uDg3sHRz8uuw8C7obWy + rJPq6ObbExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMjZ2NfpxcC8n83Jxarc2ta89vH20G+MR/hIcRT/UHwc/1SEG/9ZjBz/W5Ac/12M + G/9dhxj/XYAW/1x7Fv9bdhT/W3MT/11xEv9dcRH/X3IQ/2R1D/9peQ3/a3oN/2p6C/9rewz/bHoL/298 + Cv91fwr/eoII/36FCf+CiQn/howJ/4iOCP+Ljgn/io0I/4qNCP+UliT/iYsS/32AAP99fgP/gYEE/4KD + A/+CgwT/goME/4GBBf+BgQX/gYEF/4KCBv+HhwX/jo0F/5WTBf+cmwX/oJ8G/6CdBf+mpgX/n54F/5OP + Bf+TkAb/lJAF/5SQBf+Tjwb/lpMF/5mVBv+ZlQb/lI8E/5GLBf+SigX/lI0F/5eQBv+XkAX/lo0G/5OL + B/+RiQX/j4YE/42EBf+LggX/iIAF/4Z+BP+EfAP/hHwD/4N7BP+DewT/g3sE/4N7BP+CeAX/gXYG/390 + BP98cwX/e3EF/3dwBP90bgP/dG4E/3NtBP9zbQT/c20E/3VvBf93cQX/d3IF/3l0B/97dQf/f3gH/4J6 + CP+Ffgj/ioMJ/4mAB//l5Nra4N/dwdHNyq/DwLuhtbKsk+ro5tsTEhHaAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNnY1+nGwbyfzsvGqdza + 1rz28fXQb4tG+ElyEv9SfBr/VYQb/1qMG/9dkBv/Xowb/12HGP9dgBf/XHsW/1p2E/9bchL/XHES/11x + Ef9fchD/ZHUP/2d4Df9qeQ3/anoM/2t7DP9teQz/cXsJ/3V/Cv95ggn/foUI/4GICf+GjAn/iY0I/4qO + Cf+KjQf/io0J/5SWJ/+IiQ//fYAA/31+A/+BgQT/goMD/4KDBP+BggT/gYEF/4GBBf+BgQX/gYIG/4mI + Bf+RjQX/lpQH/52bBv+hngb/oJ0F/6imBv+cmAX/k48E/5OQBv+VkAb/lY8F/5aPBf+ZkwX/mpUG/5eT + BP+TjQX/kYsE/5KKBf+VjQX/mJAG/5ePBf+WjQb/lIsG/5GIBf+PhgX/jIMF/4qCBf+IfwX/hn0E/4R8 + Av+EfAP/g3sE/4N7BP+DewT/gnoF/4F4Bf+AdQX/f3QE/3xzA/97cQX/d3AE/3NtA/9zbQT/c20E/3Fr + BP9ybQT/dG8F/3dwBf93cgX/eXQG/3p2B/98eAf/gXoJ/4aBB/+Iggf/hXsH/+Xj2trg3t3C0c3Kr8PA + u6G1sqyT6efm3BMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI2djX6cfDvp7Py8aq3drWvPfy99BwikX4SXER/1N8Gf9Wgxn/Wowa/2CP + Gf9fjBn/XYYZ/1yAF/9cexb/WnYT/1pyEv9dcBL/XG8Q/2BxEP9kdA7/ZncM/2l4DP9peQz/ankL/2t5 + Cv9xfAr/dX4J/3iBCP99hQj/gYgI/4WKCP+JjAj/i44I/4qMBv+KjQr/lJUp/4aGDf99fgD/fH4E/3+A + BP+BggT/gYIE/4CCBP+AgQT/gIAE/4GBBf+Dgwb/i4kE/5KPBf+Ylgf/nZwF/6GeB/+gnwX/qKQH/5mU + Bf+Tjgb/kpAG/5SOBf+Vjwb/lZAF/5iSBf+alAX/lZAE/5KKBv+RiQb/k4wG/5eOBf+XjgX/lo4G/5WM + Bf+TiQb/kYYE/4+EBv+Lgwb/iYEF/4d+Bf+EfAT/g3wD/4R7BP+DewX/g3sE/4N7A/+CeAb/gHYF/350 + BP99cwX/fHID/3pwBP93bwP/cm4D/3JsBf9ybQX/cGsD/3FtBP9zbgX/d3EE/3dzBf95dQX/enYG/3t3 + B/+Aewj/hoEH/4aBCP+Aegb/5OLZ2uDe3cLRzcqvw8C7obWyrJTp5+bcExIR2gAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjZ2Nfpx8O+oM/K + xqvd2da89/L30G+KRfhJbxH/U3oZ/1WCGf9aixn/X48Y/16LGP9dhxj/XH8W/1x7E/9bdRL/XHER/11v + EP9dbg//YHAP/2NzDf9mdgz/aHgM/2l4DP9pdwv/a3gJ/3B7Cf91fQj/eIAI/32EB/+Bhwj/hIkJ/4iL + CP+LjAf/iIwH/4uMDP+VlSr/hIUK/3x9Av97fAT/f4EE/4GCBP+BggT/gIAD/39/BP+AgAP/gIAE/4WD + BP+MiAX/k5AG/5iYBf+enQX/n5wH/6KgBv+mogb/l5EE/5SNBv+Ujgb/lI0G/5ONBv+VkAX/l5MF/5iT + Bv+UjwX/kYkF/5GJBv+UjAb/lo4G/5iOBv+XjAb/lIoG/5GHBv+PhQX/jYUF/4qCBv+IgAT/hn4D/4R7 + Av+DegT/g3oD/4N6A/+CegP/gXkD/4F4BP+AdQT/fXQF/3xzBf96cAT/eXAE/3VuA/9ybQP/cGwD/3Bs + A/9wbAP/cW0E/3NvBP91cQX/dnIE/3h0Bv96dgb/fHkH/4F9Bv+GgAb/gn4H/3x4Bv/k4tna4N/ewtHP + y6/EwbyhtbKslOnn5twTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNnY1+nHw72gz8rHq93a17z38vbQbotF+EhuD/9Rehj/VoEY/1uJ + GP9ejhf/XowW/1yHF/9cgBb/XXoU/110Ev9ccBH/XXAP/11vDv9fbw7/YnIN/2V1Df9odwv/aXcL/2t3 + C/9vdwn/cnoJ/3R9B/94fwj/fIQH/4CGB/+FiQj/iIoJ/4mLB/+HiwX/i4sP/5SVKv+ChAf/fHwB/3t7 + A/9/gAT/gIAE/4CABP+AgAT/f38D/39/A/+BgQX/hoMF/4yJBf+SkAb/mZgG/6CdBf+fmwX/paEH/6Ke + Bv+TjgT/k40F/5OMB/+UjQj/k4wH/5aQBf+ZkgX/lpEG/5KMBP+QiAX/kYgF/5SMBv+VjAf/mIwI/5WK + Bv+SiAX/kIYG/46EBf+Nggb/ioEG/4h/Bf+GfQT/g3sC/4R6A/+DeQP/hHoD/4J4BP+BdwX/gHYE/4B1 + BP99cwT/fHIE/3pwBP91bwT/dG4E/3JtBP9wawP/b2oD/3BsA/9xbQT/cm8E/3NxBP91cgX/dnMG/3l1 + Bv98eQf/gn0I/4R/B/99egj/eXQG/+Ti2drg4N7C0c/Lr8PAu6K1sqyU6efm3BMSEdoAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2dnX6cfD + vaDPyser3drYvPfy99FuiUT5SG4P/1J5GP9WgBf/WogY/16OF/9fixb/XYcX/1yAFv9eeRP/XXUR/1xx + D/9cbw7/XG8N/19vDf9icgz/ZXUL/2h2DP9odgv/anYK/293Cf9xeQj/dHwH/3iABv98gwb/f4YH/4SJ + CP+Hign/iIoI/4iJBf+LjBH/lJQp/4CDBP97fAL/e3sF/35+BP+AgAT/gIAE/4B/BP9/fgT/f38E/4CA + BP+Ggwb/jYoF/5SRBf+blwb/oJwH/5+bBv+logb/n5sF/5KMBf+RjAf/kowH/5OMB/+TjQf/lpAF/5iR + BP+Vjwb/kYoF/5CHBv+Qhwb/lIoG/5eLB/+Xiwf/lIkF/5GHBf+PhQX/jYMF/4uBBP+KgQX/iH8E/4V7 + Bf+EegT/g3kD/4J4BP+DeAX/gncF/4F3Bf+AdQX/f3QE/31zBP97cgP/eW8D/3htBf90bQT/cWwD/29q + A/9vagP/cGwD/3FtBP9ybwT/c3AD/3RxBP92cwb/eXQG/3x7Bv+Afgb/gH0H/3t3CP94cgf/5OPa2uDg + 3sLRz8uvw8C7orWyrJTp5+bcExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAA + ABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjZ2dfpx8O9oM/MyKvd29i89/L30W6IRPlHbQ7/UngW/1Z/ + F/9aiBf/XY4Y/16KFv9chhb/XoEW/115E/9ddBD/W3AO/1tuDf9cbgz/X3AN/2JyDP9ldAv/Z3UL/2h2 + C/9qdgr/a3YJ/3F5Cf90fAf/eIAG/3yDB/9/hQb/hIkI/4iKCP+Iigj/h4gF/4yNFf+UlCj/gIME/3t8 + A/97fAT/fX8E/4CAA/+AgAT/fn4D/359BP9/fgT/gIAE/4eDBP+Oiwb/lJIF/5uYBf+gnAb/n5sG/6ak + Bf+blgb/kYwG/5GLB/+TjAf/kosG/5KLBv+WkAX/l5EE/5ONBv+PiAb/kIcG/5CHB/+UiQb/losH/5aK + Bv+ThwX/kYUG/4+DBf+MgwX/i4EE/4uBBf+JgAP/hHoE/4R6BP+DeQX/gngF/4J3Bv+CdwX/gXcF/4B0 + Bf9/cwT/fHME/3pxA/94bgT/dm0E/3JsBP9xawP/b2oD/29qA/9vawL/cW0D/3JvBP9zcAP/c3EE/3Zz + Bf94dQb/fXwF/39+B/97eAj/d3QH/3VxBv/k4tra4N/dwtDOyrDFwLuiuLKslOnn5twTEhHaAAAAmQAA + AIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNnZ + 1+nIxL+g0M3Jq93b2L338/fRbYdD+UdsDf9ReBb/VX0W/1uIF/9djBb/XooW/12HFf9egBT/XXoR/1x0 + D/9bbg7/W24N/1ttDP9ebg3/YXEL/2RzCv9mdAv/aHUK/2h0Cf9rdgn/cHgI/3R7B/93gAf/eoIH/3+E + B/+FiQj/iIoH/4iKCP+FhwT/jo4Y/5KSKP+AgQL/ensD/3l7BP99fgT/gH8D/39/BP9/fgT/fn0D/39+ + BP+BgAT/iIMD/4+LBf+Vkwb/nJkF/5+bBv+fmwb/p6QG/5aSBP+Riwb/kooG/5KLBv+RigX/k4wF/5aQ + Bf+VjwT/kYoE/46FBv+OhQb/kIcH/5SKB/+WigX/lYkF/5KGBv+QhAX/jIIF/4uBBf+LgQX/i4AE/4h+ + A/+DegP/g3kE/4N4Bv+Cdwb/gXcF/4F2Bf+AdQX/f3QE/31zA/97cQT/enAE/3huA/90bgT/cmsD/3Fr + BP9vagP/b2oD/29rAv9xbgP/cm8D/3JvA/90cQT/dnQE/3h3Bf9+fQX/fXsG/3h1B/92cgj/c24G/+Ti + 2trf393C0M7KsMXAu6K3sqyU6efm3BMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2dnY6cnFv6DRzcmr3dvYvffz99Fth0L5RmwL/1B2 + FP9WfhX/XIcX/1+LFv9eihX/XYcT/16AEv9cfA//XHMO/1tuDv9abQ3/WmwL/1xuDP9hcAz/ZHIK/2V0 + Cv9odQv/Z3MJ/2x1B/9veAf/c3wH/3Z/CP96ggb/gIUI/4OICP+HiQj/hogH/4SFAv+PkBz/kJIm/35/ + AP94eQX/enoG/319Bf9+fQT/fn4E/319A/99fAP/fn0F/4CABP+JhQX/kIwE/5WUBf+dmgb/n5sG/6Cd + B/+loAb/lI4E/5CKBv+RiQf/kYkH/5GKBf+SjQP/lJAE/5ONBv+QiAX/joUG/4+GBv+Rhwf/k4oG/5aK + Bv+ThwX/kIYF/46EBf+Lggb/in8G/4uBBf+LgQT/hnwE/4N4A/+Bdwb/gncF/4F4Bf+AdgX/gXYF/390 + BP9/cwT/fHME/3lxA/94bwX/d24E/3JsBP9ybAT/cWoD/29rA/9vagP/cGwD/3FsBP9wbQT/c28D/3Ry + A/92dAT/enkF/318Bv96eAb/dXIG/3RwB/9xbAX/4+LZ2uDf3cLRzsqwxcC7oreyrJTp5+bcExIR2gAA + AJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAA + AMjb2tnoy8bAoNHOyKve29i9+PP40W6GQvlFagv/T3YU/1V9Ff9ahhX/XosV/16KFP9ehRH/XIAS/1t7 + D/9acw//Wm0M/1trDf9bawz/XG0M/19vDP9kcQr/ZXMK/2VyCP9ncwj/aXUH/3B4B/9zewf/dnwI/3yB + B/+AhAf/g4cG/4aIB/+Fhgb/hIQD/4+QIf+OkCP/fX4A/3d4Bf95egX/fX0E/359A/98fQL/fH0D/318 + BP9/fQX/g4AE/4iGBP+QjAT/lpQG/5yaBf+dmQb/o54H/6KcBf+Riwb/kIoF/5GJBv+QiAb/kYkF/5KM + BP+TjgT/kowG/42GBf+NhAX/j4UG/5KHB/+TiAX/lYgF/5KHBv+PhAX/jYIE/4qABf+KgAT/i4EF/4qA + BP+FeQP/gncF/4F3Bf+BdwX/gXcF/4B2BP9/dAT/f3QE/31zBP97cQP/em8E/3hvBP90bQT/cmsE/3Br + BP9vawT/b2oD/3BrA/9wbAP/cW0E/3BtA/9ybwP/c3EE/3Z0Bf96eQb/e3sH/3d0Bv9zcQX/cm0G/29p + Bf/j4tna4N/dwtHOyrDFwLuit7KtlOnn5t0TEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNva2ejLxsGh0M7JrN7b2b348/jRbIVB+UZp + Cv9QdRT/VHwU/1qEFf9eihT/XokT/1yGEP9dgBH/XHgQ/1tzD/9abQ3/WWsN/1lqDP9bbQv/YG0L/2Ny + Cf9kcwn/ZXII/2dzCP9rdAb/b3cF/3J5B/91fAj/fIEF/4CEBv+ChQX/hIYE/4WGBv+EhAL/kZIl/4yO + If99fQD/d3gE/3h6BP98fAT/fXwE/3x8BP97fAT/e3wE/399Bf+EgAT/ioYE/5COA/+YlQX/nZkF/5yY + BP+loAb/nZcG/5CKBf+PiAX/kYkF/5CIBf+RiAX/kYoG/5KMBv+QiAX/jYQG/4yDBP+PhQb/kYYG/5KI + Bf+Thgb/kIQF/46CBv+MgQX/iX8E/4l/A/+LgQX/iH8E/4J4Bf+CdwX/gXcF/4F3Bf+AdQX/f3QE/390 + BP9+cwT/fHMD/3lwA/95bwT/d24D/3JsA/9yawT/cGoD/29qA/9vagP/cGsE/3BsA/9vbAP/cG0D/3Fv + Av9zcgT/dnUF/3l5Bv94dgX/c3EF/3JvBv9wbAX/bmcG/+Pi2drg393C0c7KsMTAvKK2sq2V6efm3RMS + EdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAA + AG0AAADI29rZ6MvHwqHRzsqs39zZvfj0+NFthED5RmgL/1B0E/9UexL/WYMU/12JE/9diBL/XIUQ/11/ + EP9ceBD/W3IP/1psDv9Yagz/WWoL/1xrCv9gbgv/Y3EJ/2RyCf9lcgj/Z3II/2t0Bf9vdwb/cnkH/3R8 + B/97gAX/f4MG/4GEBP+DhQT/hIUF/4KDAv+Rkyf/iosd/3x8AP92dgX/eHkE/3t8BP98fAT/e3wE/3p7 + A/97fAT/fnwE/4WAA/+KhgT/kY4E/5iVBP+bmQX/m5gF/6SgBf+YlAX/jokF/46HBv+PhwX/j4cG/5CI + Bf+Rigb/kosG/46GBf+Mgwb/jIIF/4+EBv+RhQb/k4cG/5GGBf+PhAX/jYEF/4qABP+JfgP/iYAD/4uB + BP+GfAT/gXcF/4F3Bf+BdwX/gHYE/4B2Bf9/dAT/f3QE/31zBP97cQP/enAD/3duBf90bQT/cmsE/3Jr + BP9wagP/b2oD/29qA/9vagP/b2wD/29sA/9wbQP/cW8C/3NxA/93dQX/eHkF/3VzBP9ybwX/cW0H/29p + Bv9sZQX/4+LZ2uHf3MLRzsqwxMC8o7ayrZXp5+bdExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjb2tnoy8fCodPPyqzf3Nm9+PT40W6E + QflFZgv/UHIT/1R5Ev9YghP/W4gS/1yIEv9cgw//XH4O/1x4Dv9bcw7/Wm0N/1hqDP9Zagv/XGoK/15u + Cv9icQj/ZHIJ/2RxCP9ncgf/a3MG/252Bf9xeAf/c3wG/3t/Bf9/gwb/gYQE/4OEBP+DhAT/goMD/5KT + LP+IiBr/enoA/3R1BP94eAT/ensE/3t8BP96ewT/eXoE/3p7Bf99fAT/hYED/4uIBP+SjgT/mZUE/5uY + Bv+bmAb/o6AE/5OOA/+NiAX/jYYG/4+GBv+Phgb/kIgF/5GKBv+RiQX/jYUE/4yCBv+Ngwf/j4QG/5GE + Bv+Thgb/kYUF/46DBP+MgAT/iX4D/4l+BP+KgQT/ioED/4R6BP+BdgX/gXYF/4B2BP+AdgT/f3UE/390 + BP9+cwP/fHME/3txBf96cAT/dm8E/3JtBP9yawT/cGoD/3BqA/9vagP/b2oD/29rA/9vbAP/b2wD/29t + A/9xbwP/dHEC/3h2BP93dgX/cnAF/3BuBf9vawb/bWYH/2pkBP/j4tna4d/dw9HNyrDEwLyjtrKtlenn + 5t0TEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAA + AFQAAABtAAAAyNrZ2enLx8Oh08/MrN/d2r349fjRbYNB+UVmCf9OcRL/U3cT/1Z/Ev9ahxH/XIcR/12C + D/9bfg3/XHgN/1tyDf9ZbQv/WGkM/1ppC/9cagr/X20I/2JxCP9icQf/ZHEI/2ZyBv9rcwX/bnUG/3F3 + B/92ewX/fH8G/36ABf+AgwX/goMD/4OEBP+CggX/k5Mw/4aHF/95eQD/dHQE/3d3Bf95egX/ensE/3p6 + Bf95eQX/eXoG/3x8BP+EgQP/jIkD/5OPBf+alQX/nJcG/56ZBv+gnQX/j4sE/4yHBP+Lhgb/jocF/4+F + Bf+QiAT/kYkF/4+HBf+KgwX/iYIF/4yDBv+Pgwb/kIUG/5GGBv+PgwT/jYEE/4t/BP+IfQP/iH0D/4yB + Bf+IfwX/gXgD/4B2Bf+AdQX/gHUF/4B1Bf9/dAT/f3QF/31zBP97cgP/enAE/3luBP92bQP/c20E/3Jr + BP9vagP/b2oD/29qA/9vawL/cGwD/3BsA/9vbAP/cG4D/3FvA/9zcgL/d3cE/3RzBf9vbQX/bWwD/21o + Bf9rZQf/aGEE/+Lh2dvh393D0c3KsMTAvKO2sq2V6ejm3RMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2trZ6cvIxKLTz8yt4N3avfj1 + +NFsgkD5RWQJ/05vEf9RdRH/Vn0Q/1qEEf9chRD/XIEQ/1x9D/9cdg7/XHEO/1lsDP9YaAr/WmkK/1xq + Cf9fbQj/YXAH/2JwB/9icAb/ZXAG/2pxB/9tdQb/cHkG/3Z8Bf96fwT/fYAD/3+CBP+CggT/gYID/4CC + Bf+TlDH/g4UT/3Z5AP9zdAT/eHYE/3l5Bf95eQX/eHgE/3l5Bf95eQX/fXsD/4WCBP+MiQP/k48E/5uW + Bv+alQX/oJsG/56aBP+NiQP/i4UF/4yEBv+MhQb/jYUE/4+HA/+PhwT/jYQE/4iBBf+IgAT/ioID/46D + BP+QhQT/j4UE/42BA/+LfwT/iX4E/4d8A/+KfwT/jIEF/4Z8Bf9/dQP/f3QE/4B1Bf9/dAT/f3QE/35z + BP99cgP/e3ED/3pwBP96cAT/eG0E/3RsBP9ybAP/cWoD/29qA/9vagP/b2oD/25rA/9vbAP/b2sC/29s + A/9wbQP/cXAC/3R0A/91dQP/b24D/2xrBP9raQT/a2UE/2ljBf9mYQX/4uDZ2+Hf3cPRzcqwxL+8o7ay + rZXp6ObdExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMja2tnpzMjEodTQzKzg3dq9+PX40WuBP/lEYwj/T24R/1FzEP9VfQ//WoMP/1yE + D/9agRD/W3wO/1t1D/9ccQ3/WmwK/1hoCv9ZaAn/XGoJ/19sCf9hbQn/Ym8H/2JwBv9lcAb/anEH/21y + B/9xeAj/dXsH/3p8BP99gQT/foEE/3+BBP9+gQL/gYIH/5SUMv+Bgw7/dXgB/3JzBP93dQX/eHgF/3h5 + BP94eAT/eHgE/3h4BP9+fAT/hoIF/42JA/+UkAT/mZUH/5eTBf+hnQT/mpUF/4yIBP+LhAX/i4QF/4qE + BP+LhQX/j4cD/46HBP+KggX/h38D/4d/BP+KggP/jYIE/46CBP+NggT/ioAE/4l/A/+HfQT/hnwE/4t/ + BP+KgAT/g3kD/350BP9/dAT/f3QE/390BP9+cwP/fnME/31yBP96cAT/enAE/3lvA/91bgP/c2wF/3Jr + BP9xagP/b2oD/29qA/9vaQP/b2oD/29sAv9uawL/b2wD/3BtBP9ycQP/dXQD/3JyAv9sawP/a2oD/2lm + BP9oZAX/ZmIE/2RgA//i4Nnb4d/dw9HNyrDEv7yjtrKtleno5t0TEhHaAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNra2enMyMSh1NDMrODe + 27359fnRbIE/+URjB/9NbBD/UXIQ/1Z6D/9ZgRD/W4MP/1uAD/9cewz/XXYL/1xxDP9abAr/WGgJ/1lo + Cv9baQj/XmsJ/2BtB/9hbwb/Ym8G/2VvBf9qcQb/bHQF/3B2Bv90eQb/eX0E/3x/BP99gAT/foED/31/ + Av+Bgwr/lJQ0/3+BDf91dwP/cnEE/3Z1BP93dwX/eHcF/3d3BP93dwT/eHgF/358A/+GgwT/jYkE/5SQ + Bf+YlQX/l5QF/6GeBf+UkAT/i4UE/4uEBf+LgwX/ioIF/4qEBP+MhgT/jIUE/4iABP+GfwP/h4AE/4qB + BP+NggT/joIE/42BBf+KgAX/iH4E/4Z8A/+GfQP/ioAE/4d9Bf+AdgT/f3QE/390BP9/dAT/f3QF/35z + A/99cgT/fHEF/3pwBP96cAX/dW4E/3RtBP9zbAT/cGoD/3BqA/9vagP/bmoC/29rA/9vawP/bmsD/25r + Av9vbAP/cG4E/3NyA/90cwP/b24D/2tqA/9raQP/aWUE/2diBf9lYAX/ZF4D/+Lg2dvi393D0c7KsMS/ + vKO2sq2V6ejm3RMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI2trZ6c7JxaHV0cys4d7bvvn2+dFsgT/4RGEG/01sD/9RcQ//VXkO/1iA + EP9bgg//XH8O/1x6Df9ddgr/W3EL/1psCv9YaAn/WWgK/1ppB/9dagj/X2wG/2FvBf9ibwb/ZG8F/2lw + Bv9scwX/cHYG/3R5Bv94fAT/e34D/3yABP9+gQP/fH4B/4KDDP+TlDP/fX8K/3R1A/9xcQT/dHUE/3d3 + Bf93dwX/d3YE/3d2BP94dwX/fnwE/4aDA/+OigT/lZAG/5eTBP+YlAX/n50E/5GMBP+KgwX/ioMF/4qD + Bv+JgQb/ioIE/4qEBP+KggP/h34D/4Z9A/+HfwX/ioAE/42CBf+OggT/i4AF/4l+BP+HfAT/hHsD/4Z9 + A/+KgAT/hXwF/311BP9/dAT/f3QE/390BP9/dAX/fXID/3xwBP97cAX/enAD/3lvA/90bQT/cmwE/3Js + BP9xaQP/bmoD/29qA/9uagP/bmsC/29rA/9uawP/bmsC/29sA/9xbgP/c3MC/3NyA/9sbAL/a2gC/2lm + A/9nYwT/ZGEF/2NfBP9iXAL/4uHZ2+Lf3cPRzcqxxL+8o7ayrZXp6ObdExIR2gAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMja2tnpzsnGodXR + zKzh3tu++fb60WyAPvhEYAX/TWsN/09wD/9VeA//WX4O/1yADv9cfg7/WnoM/1x2Cv9bcAn/WWsJ/1dn + Cv9YZwj/WmgG/11pCP9ebAj/YG4F/2FuBf9jbgb/aHAF/21zBv9udgb/dHgE/3h7Bf97fgP/fIAD/32A + A/97fQD/g4UQ/5GRMv97fQb/dHQE/3BxBf9zcwT/dnYE/3Z1BP92dQP/dnUE/3l3Bf9/fAT/h4QE/46K + BP+VkAb/lpIE/5qWBf+emwT/jogD/4mDBf+IggX/iIEF/4mABP+KgwT/ioME/4eAA/+FfAL/hnwE/4h+ + BP+KgAT/i4EF/4uABP+JfgT/h30D/4V7BP+EegX/iH8D/4qABP+DeQP/e3MD/31zBP9+cwT/fnMD/35z + A/99cQX/e3AF/3pwBP94bwP/d24D/3NtBP9ybAT/cmoE/3BpAv9uaQL/bmkC/25qAv9tagL/bmsD/25r + A/9uawL/b2wD/3FuA/90cwP/cG8C/2tpAv9oaAH/Z2QC/2ViBP9iYAP/YV4E/19aAv/i4dnb4d7dw9HN + yrHEv7yjt7Ktluno590TEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNva2enQy8ai1tPOreHe27759frRa389+ENgBf9Nag3/UG8N/1N3 + D/9YfA//W38N/1t9Df9Zegz/XHYK/1twCf9Zagn/V2cJ/1ZlB/9aZgf/W2kG/11rBv9gbQX/YG0E/2Nt + Bf9obwX/bHIG/291Bv90eAT/eHkG/3p8BP98gAL/fH4C/3l7AP+EhhX/kJAx/3t8A/9xcwP/cHAF/3N0 + BP92dAX/dXQE/3V0BP91dAT/eHcF/399BP+GhAT/j4oF/5WRBP+VkAX/nJgF/5qXA/+MhQX/iYIF/4iB + Bf+GgAb/iIAF/4iBBP+HgAX/hX0E/4R8A/+GfAP/iH4E/4qABP+KgAT/iYAE/4l+BP+FfAP/g3oE/4V6 + Bf+KfwX/iH0F/391Bf98cgT/fXME/35zBP99cwT/fXID/3xxBf96cQX/eW8D/3dtBP90bgX/c20E/3Jr + A/9vagL/bmoD/25pAv9uaQL/bmoC/25rA/9uawP/bmsD/25rAv9wbQL/cnED/3NyBP9tbAP/amgC/2Zm + Av9kYwT/Y2AD/2JfBP9gXQT/XlgD/+Lh2dvh3t3D0c3KscTAvKS4sq2X6ejn3RMSEdoAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI29rZ6dDL + xqHW086s4d/cvvr2+tFrfz34Ql4G/0xpDf9Pbg3/VHUO/1h7Dv9afwz/W3wM/1p5C/9adgn/Wm8I/1lq + CP9WZgn/VmUH/1lmCP9caAf/XmoG/2BrBv9hawb/Y24E/2hwBP9scQX/b3QE/3N3BP93egX/ensD/3p+ + A/97fgP/eHsA/4aGGv+Ojy//eXwC/29xA/9vcQT/c3QE/3V0BP91dAT/dHMD/3V0BP93eQP/gH0D/4iE + BP+PiwX/k5AF/5OPBP+dmQX/l5IF/4iBBf+HgAX/h4EF/4aABP+GfwT/hn8D/4V9A/+DegP/gnoD/4R8 + A/+GfwT/iX4E/4l+BP+IfgP/iH0D/4R6BP+DeQP/hnsE/4p/BP+DewX/e3MF/3xyA/99cgP/fXID/3ty + A/97cQT/enAE/3pwBP94bgT/d20F/3NtBP9yawP/cmoD/29pAv9uaQL/bWgC/21qAv9tagP/bWoD/21q + Av9uawP/bmsC/3BtAv9zcgP/cXAD/2tqA/9oZgP/ZWQE/2NiBP9hXgP/YFwD/15bAv9bVwH/4eDZ2+Hf + 3cTRzsuyxcC8pLeyrZbp6OfdExIR2gAAAJgAAACCAAAAcAAAAGIAAABUAAAARgAAADoAAAAtAAAAFgAA + ABsAAAAlAAAAMAAAAD4AAABUAAAAbQAAAMjb2tnp0MzHodbTz63h39y9+fb60mp+PPlBXQX/S2gN/09s + Df9Tcw3/V3oN/1p8DP9afAz/WnkK/1pzCf9abgn/WWoI/1ZmCP9WZQf/WWYI/1xoB/9daQj/XmoG/2Bs + Bv9jbQT/Z28F/2lxBf9vdAT/cncD/3Z6A/93fAP/eX0C/3p9Av93egD/iIke/4yMLP94eQH/bnED/25w + A/9ycgT/dHMF/3RzBf90cwP/dXQD/3l5BP+BfgT/iIQE/4+LBP+TjwX/lI8E/56ZBf+RjgT/hoEE/4Z/ + Bf+GfgT/hX0E/4V+A/+FfQP/gnoE/4F4Bf+CeAX/hXsE/4Z+BP+IfgT/iX4F/4h9A/+FegT/g3gD/4N4 + A/+HfAP/ioAE/4B4A/96cQP/e3ID/3txBP97cQT/e3EE/3pwBP96cAT/enAE/3huBP93bQX/c2wF/3Jr + A/9vagP/bmkD/21oAv9uaQP/bWkD/21pA/9saAH/bWoC/25rA/9vbAP/cnAC/3JxA/9tbQP/aWcC/2dl + A/9lYwP/Yl8E/2FdA/9fWwP/XVkD/1pWAf/i4Nnb4d7dw9HPy7LFwLykt7Ktluno590TEhHaAAAAmAAA + AIIAAABwAAAAYgAAAFQAAABGAAAAOQAAACsAAAAWAAAAGwAAACUAAAAwAAAAPQAAAFMAAABsAAAAyNva + 2enQzMeh1tLOreDe2r349PrRan47+UJdAv9LaA7/Tm0N/1JzDP9WeQz/WnsM/1p7DP9ZeAr/WnMJ/1pu + Cf9Zagj/VWUH/1ZlB/9YZgj/WmcH/1xpCP9eagb/X2wF/2JsBP9obgb/anEF/250A/9zdwP/dXoC/3h8 + Av96fAL/enwD/3Z5AP+JiyP/i4so/3Z4AP9tbwL/bm8D/3JxBf9zcwX/c3IF/3RzBf91dAP/eXkD/4F/ + BP+IhQX/kIwF/5KPBf+UkAT/nZgF/46JBP+GfwT/hn8F/4Z+BP+DfAX/g3wE/4J7A/+AeQX/gHgF/4N5 + Bf+FewT/hnwE/4h+BP+HfgP/hnwD/4R6BP+CeAT/hHkD/4l/BP+IfgT/fXUD/3tyA/96cQT/e3EF/3tx + Bf96cAT/enAE/3pwBP95bwX/eG4E/3VsBf9ybAX/cGoD/29qA/9taQP/bWgC/25pA/9taAP/bWkD/2xp + Av9tawP/bWsE/29tA/9ycAT/cG4E/2poA/9oZgP/ZmQD/2RhA/9hXgT/X10C/1xZAv9bWAP/WVUC/+Hf + 2Nrg3tzC0c3LssTAvKS3sq2W6ejn3RMSEdoAAACXAAAAgQAAAG8AAABhAAAAUwAAAEUAAAA5AAAALAAA + ABYAAAAbAAAAJQAAAC8AAAA8AAAAUgAAAGsAAADI3Nva6dDMxqHU0s2s393ZvPfz+M5rfjv4Q10C/0tn + Df9Oawz/UHEL/1V3C/9Zegv/WXoL/1h3Cf9acwn/Wm4I/1hpB/9VZQf/VWQG/1dlBv9ZZgf/XGgG/15q + Bv9fawT/Y2wE/2htBf9qcAP/bXQD/3J3A/91eQL/d3wD/3l7A/95ewP/dXgA/4mLJ/+IiSX/dHYA/2xv + Av9tbwP/cHAD/3JyBP9zcgT/c3IE/3R0BP95eAP/gH4E/4mGBv+Piwb/kI0F/5WSBf+blwX/i4UF/4Z+ + BP+EfQT/g3wF/4F7Bf+BegT/f3gF/353BP9/dwT/gnkG/4N8A/+FfQT/hn4D/4V9A/+EewP/g3kE/4F3 + Bf+DegT/iX8E/4V8A/98cQT/e3AE/3pwBP97cQX/enAE/3pwBP96cAT/eG8E/3dtBf91bQT/cmwD/3Fq + A/9vagP/bmkC/21oAv9taAL/bGgC/2xoAv9saAL/bWkC/21rA/9sawL/bm4C/3FvA/9ubQP/aWcD/2hl + A/9lYgT/Y2AE/2FdA/9eWwL/W1kC/1pXAv9YVAL/397X19/c28DQzMmxw8C7pLeyrpfp6OfdExIR2gAA + AJcAAACBAAAAbgAAAGAAAABSAAAARAAAADgAAAArAAAAFAAAABkAAAAjAAAALgAAADoAAABPAAAAaQAA + AMjc29rp0MvGodTQy6rd2ti59PD0yWp8O/dDWwL/TGYM/09pDP9Rbgz/VHUK/1h6Cv9YeAr/WHUJ/1px + B/9Ybgf/VmgG/1VlBv9VZAb/V2UG/1pmBv9cZgb/XWkG/19rBP9jbAT/aG0D/2pwA/9scwT/cHYC/3Z3 + BP92eQX/eHoD/3h6Af91dwD/iowr/4aHIf9zdQH/am0D/21uBP9wcAP/cXED/3JyBP9zcgT/dHME/3l5 + A/+AgAX/iYYG/4+LBP+QjAP/lpME/5eTBf+IgQX/hH0E/4J9BP+BfAT/gHoF/4B5Bv99dgT/fXUE/391 + BP+CeAT/g3sE/4V8A/+FfAP/hHoE/4N5BP+BdwX/gHYE/4V7BP+IfwT/f3cE/3lvBP96cAT/enAE/3pw + BP96cAT/eXAD/3hvBP92bwT/c20D/3NsBP9xagP/b2oD/29qAv9uaQL/bWgC/21oAv9saAL/bGgC/2xo + Av9taQL/bGoC/2xrA/9vbwL/b28D/2ppAv9oZgL/ZmUC/2NiA/9hXwT/YVwD/11ZAv9bWAP/WVUC/1dS + Av/c2tPT3NnYvc7Lx67Dv7ujt7Kuluno590TEhHaAAAAlQAAAH8AAABsAAAAXwAAAFAAAABCAAAANgAA + ACkAAAAUAAAAGgAAACIAAAAsAAAAOAAAAE0AAABnAAAAx9zb2unPy8Sf0s3JqNnX1LXw7PDCaHo69UJb + Av9MZAv/TmkL/1BsC/9Vcwv/V3cK/1d3Cv9XdQj/WXIH/1dtB/9WaAb/VGQF/1NkBv9XZAb/WmUG/1xn + B/9daAT/YGoE/2JrA/9mbAP/aW8C/2xxBP9vdQP/c3cE/3Z4BP94eQT/eHgE/3R3AP+LjS//g4Uc/3N1 + AP9pbQL/bW0D/29vA/9vbwP/cHAD/3FyA/90cwT/eXkE/4CABf+Jhgb/jowF/46LBv+WkwX/k48E/4Z/ + Bf+DfQX/gnwE/4F7Bf+AeQb/fncF/3l0BP97dQT/fncE/4B4BP+DewP/hXsF/4V6BP+DeAX/g3cF/4B2 + Bf+AdwX/h34E/4Z+Bf99cwT/em8E/3pwBP96bwP/em8D/3pwBP94bwP/dm8E/3RuBf9zbgT/cmwD/3Bq + A/9uaQL/bmkC/25oA/9saAL/bGgC/2xoAv9saAL/bGgC/2xoA/9raQL/bWwC/3BvAv9tbAP/Z2YC/2Zl + A/9kYwP/YmAC/19eA/9eWwT/W1kB/1lWAv9XVAT/VVEB/9fWzszY1tS4y8fEq8K9uKG2sq2V6ejn3RMS + EdoAAACTAAAAfAAAAGkAAABcAAAATgAAAEAAAAA0AAAAKAAAABIAAAAYAAAAIAAAACkAAAA1AAAASgAA + AGMAAADG29rZ6M3JxJ/Oysam19PPsOzn67hgcy32OFQA/0BcAP9CXwD/RWUA/0prAP9MbgD/TG0A/01t + AP9QagD/TWQA/0xgAP9KWwD/SlsA/01bAP9QXAD/Ul4A/1VgAP9VYAD/V2IA/1xkAP9hZwD/ZGoA/2dt + AP9rbwD/bnAA/29xAP9vcAD/bG8A/4SHJf94egv/aWwA/2FjAP9jZgD/ZmcA/2dnAP9oaAD/aWkA/2xs + AP9xcgD/e3oA/4KBAP+HhQD/iIUA/5KPAP+HgwD/e3QA/3p0AP96dAD/eXIA/3ZvAP9xbAD/cGwA/3Ns + AP92bwD/eXEA/3xzAP99cwD/fXIA/3twAP96bwD/eW0A/3txAP+AeAD/fHQA/3FpAP9yaAD/cmgA/3Fn + AP9xZwD/cmgA/3FnAP9tZwD/bGYA/2tlAP9qYwD/Z2IA/2ZhAP9mYQD/ZGAA/2RgAP9jYAD/ZGAA/2Rg + AP9jXwD/Y2AA/2NiAP9mZgD/amcA/2NhAP9fXQD/XVsA/1tZAP9ZVwD/VVUA/1NRAP9RTgD/UEwA/05L + AP9MSAD/0c/GxNPQzrLIxMCnwLu2n7Wwq5bp6OfdExIR2QAAAI8AAAB5AAAAZgAAAFcAAABKAAAAPAAA + ADEAAAAmAAAAEAAAABUAAAAeAAAAJgAAADEAAABGAAAAXgAAAMXb2tnpy8fDn8vGwqLTz8qp3dnVssnK + u8fGybbRy9C82M7SvtzQ1cDg0tfB4tPYweLT18Hi0tjB4tPXweLT1sHi09XB4tLUwOLS1MDi0tTB4tPU + weLT1cDi1NXA4tTVwOLU1sDi1dbB4tbXweLX18Hi19jB4tjYweLY2MHi2NjB4tjYwOLY18Di3dzJ4dnZ + xOHX1r/h1tW/4dbWwODW1r/g19a/39bWv9/W1r/f19a/39jXv9/Z2L/f29m/39vZv9/c2r/e3ty/3tva + v97Z17/e2de/3tnXv97Z17/e2Na/3tfWvt7X1r/e2Na+3tjWv97Z17/e2de+3trXv97a177f2de/39nW + v9/Z1r/f2de+39rZv9/Z2L/f19bA39fWv9/Y1b/f2NW/39jVv9/Y1b/f2NW/4NjVv+DX1b/g19W+4NfU + vuDW1b/g1tW/4NbVv+DW1L/g1tS/4NbUvuDV077g1dO+4NXTvuDV077g1NO+4dXUvuHV1L7h1NO+4dPS + vuHT0r7h09G+4dLRvuHS0b3h0M+94M7Mu93LybjZx8W008G+rcvSzsu2y8fFq8O/vKO9uLSdtrGrlevp + 5twTEhHYAAAAiwAAAHIAAABgAAAAUwAAAEYAAAA4AAAALQAAACMAAAAOAAAAEwAAABsAAAAjAAAALgAA + AEEAAABWAAAAxdLRz93LxsGcyMTAn87KxaTU0Mqq3trYsOPg4Lfn5OS+6ubowuzo6sXs6evG7Onrxuzp + 68bs6evG7Onrxuzp68bs6evG7Onrxuzq68bs6evG7errxuzp68fs6evH7Onrx+zq68br6uvG7Orrxuzq + 68bs6uvG7Orrxuzq68bs6erG7Onqxuvo6sbq6OjF6efpxero6sTq6OnE6+jpw+ro6cPo5ufC6ebnwejl + 58Lo5ufB6Obnwefk58Hn5OfB5+Tnwefk58Hm5efA5uXnwOfl58Dn5efA5+XnwOfm58Dn5ufA5+bnwOfm + 58Dn5ufA6ObnwOfm58Dn5efA5+bnwefm58Hn5ufB5+bnwefm58Hn5efC6Obnwejm58Hp5ufB6Obnwujm + 58Lo5ufC6Obnwujm6MPo5ujD6Obow+jm6MPo5+jD6ejpw+ro6cPq6OnD6ujpw+ro6cPp5+jD6efow+fl + 58Tn5efE5+XnxOfl58Tm5ebE5uXmxObl5sTm5ebE5uXmxObl5sTn5ebF5+Xmxefl5sXn5ObE5OLiwuDf + 4L7d29q419TUscvHxavFwb2lwLu3oLq1sZu3sayV4uDf0REQENYAAACEAAAAbQAAAFoAAABNAAAAQQAA + ADUAAAAqAAAAIAAAAA0AAAASAAAAGQAAACAAAAApAAAAOgAAAE8AAACtcG9u5NzZ1a/EwLmYy8fBoM7J + xKPRzsmo1dLOrdfU0LDZ1dOz3NfVtdzZ1bbc2dW23NnVttzZ1bbb2NW23NnVttzY1bbb2NW23NnVttvY + 1bbc2dW23NjUttvY1Lfa2NS33NnVttzZ1bbb2dW23NnVttzZ1bbc2dW229nUttvZ1Lbb2NS22tfVtdvX + 1LXZ1tO02tbTs9nW07HZ1dOy2NXRsdfU0LDX1NCw1tLQsNXTz6/V08+v1dPOrtXSzq7V0s6u1dLOrtXS + zq7W0s6u1tLOrtbSzq7W0s6u1tLOrtbSzq7W0s6u1tLOrtbSzq7W0s6u1tLOrtbSzq7V086v1dPPr9XT + z7DW0tCw1tLQsNbT0LDX1NCw19TQsNfU0LDX1NCw19TQsNfU0LHX09Cx19PQsdfT0LHX1NCx19XRsdjV + 0rHY1dKx2NXSsdjW0rHY1dKx2NXRsdfU0LHX09Cx1tLPstbSz7LW0s+z1dHPs9TRzrPU0c2z1NHNs9TR + zrPU0c2z1NHOtNTRzrTU0c601NHOtNPQzbPRzsyzz8zJsMzJxazIxcGpw7+8o8C7t6C9uLOdtK+qldLN + yaaHhoXfBQUFxAAAAHkAAABkAAAAUwAAAEYAAAA7AAAAMAAAACYAAAAdAAAACwAAAA8AAAAVAAAAHAAA + ACUAAAAyAAAARwAAAHkSERDm29nX19DMxpzDvreXysS+ncrIwqDNyMSjzsvFpc/Lx6bRzcin0c3Ip9HN + yKfRzcin0c3Ip9LOyKfSzsin0s7Ip9LOyKfRzcin0s7Ip9LOyKfSzsin0s3IqNHNyajRzsin0c7Ip9HO + yKfRzsin0c7Ip9HOyKfRzsmn0c7Jp9HMx6fQzMimz8vHps/LxaXPy8WkzsrFos7JxKPMxsOizMbBocvH + waDKx8GgycXAoMnFvp/Jxb+fyca/n8nFv5/JxL+fycS/n8nEv5/Jxr+eycW/nsnFv57Jxb+eycW/nsnF + v57Jxb+eycW/nsnGv57Jxr+fyca/n8nGwKDJxcCgycXBocnFwaHJxcGhysbBoMzGwaHMxsGhzMbBocvH + waHLxsGhy8XCosvFwqLLxcKiy8XCoszJw6LNycSizcnEos3JxKLNycSizcjEos3Hw6LNx8OizMfCosvG + waPJxcGjycXBo8jEwaTIxMCkx8S/pMfEv6THxMCkyMTApMfDv6XHw7+lx8O/pcfDv6XHw7+lx8O/pcXB + vaXDwLykwr66o7+7t5+9ubWdu7axnLSvqZW+urSV4+DeyyspKO0AAAChAAAAbAAAAFoAAABLAAAAQAAA + ADUAAAArAAAAIgAAABkAAAAJAAAADQAAABMAAAAZAAAAIQAAACoAAAA6AAAAXgMCAqdVVVT13tzZz+fk + 3arHwruWwr63lcPAuZbFwbuXx8G8mMfCvJjHwbyYx8G8mMfBvJjHwryYyMO8mMjDvJjIw7yYyMO8mMfC + vJjIw7yYyMO8mMjDvJjIxLyZx8S9mcfEvJnHw7yYx8O8mMfDvJjHw7yYxsG7mMbBu5jGwbuYxsC6l8XA + upbDvrmVw764lcG8tpTBu7WTwLu0k765spK+ubGQvbexj763sY+9uLGPvbiwjry4r467t6+Ou7evjru2 + r467tq+Ou7avjru3r468tq+Ovbavjb22r428tq+NvLavjby2r428tq+Nu7avjru2r467tq+OvLawj7y2 + sJC8tbCQvLawkL23sZC+ubGPvrixkL64sZC+uLGQvriykb63spG+t7KRvreykb63spG/ubOQwLu0kcC7 + s5HAu7ORwLuzkcG6tJLBubSSwbm0kr+5s5K+uLKTvLexk7u2sZS7trGUurWwlLm1sJS4ta+UurWvlLm1 + sJW5tK+VubSvlbm0r5W5tK+VubSvlbizr5W4s66WuLOulrezrpa3sq2VtrCrlLSvqpK3sa2T1tHOpOPi + 38hsbGrzCQgIwQAAAHsAAABfAAAATgAAAEIAAAA4AAAALwAAACUAAAAeAAAAFQAAAAgAAAALAAAAEAAA + ABQAAAAbAAAAIwAAAC4AAABLAAAAYQAAAKk3NzfxgoF/4eHg3tH39vPS8vHu0vPx79Lz8u/S8/Hv0vPx + 79Lz8e/S8/Hv0vPy79Lz8u/S8/Lv0vPy79Lz8u/S8/Lv0vXy79L08u/S8/Lv0vPy79Lz8u/S8/Lv0vPy + 79Lz8u/S8/Lv0vPy79Ly8e7S8/Hu0vPw7tLz8O/S8/Hu0fLx7tDx8O3Q8e/tz/Hu7NDv7uvQ7+3rz/Du + 687w7evO8O3rzu/t687w7uvO7+3rzu/t687v7evO7+3rzu/t687v7evO7+3rzu/t687v7erN7+3qzfHt + 683y7uzM8u7szPLu7M3y7uzN8e7szfDt7M7x7ezO8e3szvHu7M7x7+zO8e/szvHv7M7x7+zO8e/szvLv + 7M7z7+3O8+/tzvPv7c7z7+3O8+/tzvPw7c7z8O3O8/DtzvPw7c7z8O3O8+/tz/Pw7c/z8O3P8vDsz/Lv + 7M/y7+zP8e7sz/Hu7M/x7uzP7+7r0PHu7M/x7uvQ8O3r0PDt69Dw7evQ8O3r0PDt69Dw7evQ8O3r0fDt + 69Hw7evR8O3r0fDt69Dw7evR8/Dt0Ojl49CPjYzdQD8/8gEBAcMAAAB5AAAAXwAAAFAAAABCAAAAOQAA + ADAAAAAoAAAAIAAAABkAAAASAAAABgAAAAgAAAANAAAAEAAAABUAAAAcAAAAJAAAADcAAABMAAAAYAAA + AIYEAwO9KSko6TEwMOMvLy7jLy8u4y8uLuMvLi7jLy4u4y8uLuMvLi7jLy4u4y8uLuMvLi7jLy4u4y8u + LuMvLi7jLy4u4y8uLuMvLi7jLy4u4y8uLuMvLi7jLy4u4y8uLuMvLi7jLy4u4y8vLuMvLy7jLy4u4y8u + LuMvLy7jLy8u4y8vLuMwLy7jLy8u4y8vLuMvLy7jMC8u4zAvLuMwLy7jLy8u4y8vLuMvLy7jLy8u4y8v + LuMvLy7jLy8u4y8vLuMvLy7jLy8u4y8vLuMvLy7jMC8v4zAvL+MwLy/jMC8v4zAvL+MwLy/jMC8v4zAv + L+MwLy/jMC8v4zAvL+MwLy/jMC8v4zAvL+MwLy/jMC8v4zAvL+MwLy/jMC8v4zAvL+MwLy/jMC8v4zAv + L+MwLy/jMC8v4zAvL+MwLy7jMC8u4zAvLuMwLy/jMC8v4zAvL+MwLy/jMC8v4zAvL+MwLy7jMS8v4zAv + LuMwLy7jMC8u4zAvLuMwLy7jMC8u4zAvLuMwLy/jMC8v4zAvL+MwLy/jMC8v4zAvL+MxMDDjLS0s5woJ + CMwAAACWAAAAdAAAAFsAAABOAAAAQgAAADgAAAAwAAAAKAAAACIAAAAbAAAAFAAAAA4AAAAHAAAACAAA + AAwAAAAQAAAAFQAAABsAAAAiAAAALAAAADkAAABGAAAAUAAAAGAAAABsAAAAcAAAAHIAAABzAAAAdQAA + AHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAA + AHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHcAAAB2AAAAdgAA + AHYAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAA + AHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAA + AHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAA + AHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHYAAAB3AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAA + AHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHUAAAB0AAAAbAAAAGAAAABXAAAATAAAAEIAAAA4AAAAMQAA + ACsAAAAkAAAAHwAAABkAAAATAAAADgAAAAUAAAAGAAAACQAAAAwAAAAQAAAAFQAAABoAAAAhAAAAKAAA + ADEAAAA4AAAAPwAAAEMAAABIAAAASwAAAEwAAABOAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAATwAA + AE0AAABJAAAARQAAAD4AAAA4AAAAMwAAAC0AAAAoAAAAIwAAAB0AAAAYAAAAEwAAAA4AAAAKAAAABAAA + AAUAAAAHAAAACQAAAAwAAAAPAAAAFAAAABgAAAAdAAAAIgAAACYAAAArAAAALgAAADEAAAAzAAAANQAA + ADYAAAA3AAAAOAAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANgAAADMAAAAyAAAALgAAACoAAAAnAAAAIwAA + AB8AAAAbAAAAFgAAABEAAAAOAAAACwAAAAgAAAACAAAAAwAAAAUAAAAHAAAACQAAAAsAAAAPAAAAEwAA + ABUAAAAYAAAAHAAAAB8AAAAhAAAAJAAAACYAAAAnAAAAKAAAACkAAAAqAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAAoAAAAJgAAACUAAAAjAAAAIAAAAB4AAAAaAAAAFwAAABQAAAARAAAADQAAAAoAAAAJAAAABgAA + AAEAAAACAAAAAwAAAAQAAAAHAAAACAAAAAsAAAAOAAAAEAAAABEAAAAVAAAAFwAAABkAAAAcAAAAHQAA + AB0AAAAfAAAAHwAAACAAAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAdAAAAHQAAABsAAAAYAAAAFgAA + ABMAAAARAAAADwAAAA0AAAAJAAAABwAAAAcAAAADAAAAAQAAAAEAAAACAAAAAwAAAAQAAAAFAAAABwAA + AAkAAAALAAAADAAAAA4AAAAQAAAAEgAAABQAAAAVAAAAFQAAABcAAAAXAAAAGAAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABUAAAAVAAAAEwAAABEAAAAPAAAADgAAAAwAAAAKAAAACAAAAAYAAAAFAAAABAAA + AAIAAAABAAAAAQAAAAEAAAACAAAAAwAAAAMAAAAFAAAABgAAAAcAAAAIAAAACgAAAAsAAAAMAAAADQAA + AA8AAAAPAAAADwAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAPAAAADwAAAA4AAAANAAAACwAA + AAsAAAAJAAAACAAAAAYAAAAFAAAABAAAAAMAAAADAAAAAQAAAAAAAAABAAAAAQAAAAEAAAABAAAAAgAA + AAIAAAADAAAABAAAAAQAAAAFAAAABwAAAAcAAAAIAAAACQAAAAkAAAAJAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAkAAAAJAAAACQAAAAcAAAAHAAAABgAAAAUAAAAEAAAABAAAAAIAAAACAAAAAgAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAABAAAAAQAAAAIAAAADAAAAAwAAAAQAAAAFAAAABQAA + AAYAAAAHAAAABwAAAAcAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABwAAAAcAAAAHAAAABQAA + AAUAAAAFAAAABAAAAAMAAAADAAAAAQAAAAEAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAA4AAAAAAAAAAAAAAAAAAAACgAAAAwAAAAYAAAAAEA + IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABgAAAA4AAAAXAAAAIAAAACcAAAArAAAALAAA + ACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAA + ACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAA + ACwAAAAsAAAALAAAACwAAAArAAAAJwAAAB8AAAAXAAAADQAAAAYAAAAGAAAADgAAAB0AAAAtAAAAPQAA + AEgAAABOAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAA + AE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAA + AE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABOAAAASAAAAD0AAAAtAAAAHAAAAA0AAAALAAAAGQAA + ADAAAABHAAAAWwAAAGkAAABwAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABwAAAAaQAAAF0AAABIAAAALwAA + ABgAAAARAAAAJAAAAEEAAABsCgoLpBgYGLIWFxe0FxcXtBcXF7QXFxe0FxcXtRcXGLQXFxi0FxgYtBcY + GLQXGBi0GBgYtBcYGLQXFxi0FxcXtBcXF7QXFxe0FxcXtBcXF7QXFxe1FxcXtRcXF7UXFxe0FxcXtBcX + F7QXFxe0FhcXtBYWF7QWFhe0FhYWtBYWF7QXFxe0FxcXtBcXF7QXFxe0FxcXtBcXF7QYGBi1AQECpgAA + AHkAAABfAAAAQQAAACQAAAAXAAAALAAAAF05OTe7joiApZOMgpSRiICTjIR6kod/dZCEe3KPgHlvjn54 + bY18dWuMeXJni3lyZ4t5cWeLeG5mi3lvZot7cmiKgHdsi4N7coyIf3aMjIJ4jIyFeo2NhnuOjYd8j4+H + fo+Qh3+PkYh/j5KJf4+SiYCPk4uAkJOMgpCTjIKQlIyCkJOLgZCPiH6OjIR6jYuCeIyMg3mNj4d9jpGJ + gI+SioCOfnlzshcXF7UAAABxAAAAUAAAAC4AAAAbAAAAMAkJCYmSjIasnpWJcLKmnYW/s6yQvbKrkbqv + p4+3rKWNtaujjLOqoYuxp5+KsKWdia6knYmuo52JrqKdiq+knYmypp+JtKqjibitp4q7saqKvLKri7yz + q4u7s6yMvLOtjLyzrYy9s66NvbSujb21ro29ta6OvLaujru2ro68tq6Ovbevjry1ro66s6yMuLKri7ex + rIu5s6+Mu7SyjbStqYaelY10n5WIbGdlYb0AAACJAAAAVgAAADMAAAAcAAAAMhESEpKpoZqlsriymXPd + 4+tx4Ofyc+Dn83Xg5/N24ObzeeHl83zi5fJ/4uTyguPk8oXj4vKH4+LyieTg8ozl3/KP5d/yk+bf8pfo + 4PKc6eLyoOrj8qTs4vKo7uLzrfDi8rLz4fK29uHzvPjh88T64fPO++Tz3vvq8+z78/P5+/nz//v98//7 + /vP/+/3y//v38vz77fL3++Lz9vvR8/P5vu7V1rm7qaKbdX98d7UAAACRAAAAWQAAADYAAAAdAAAAMxAQ + EJGwqKKsws7JsEjd5P882d//Pdna/z7Z1/8/2dX/QdnT/0ba0v9K29D/S9vO/07by/9Q3Mn/U9zH/1be + xf9a4cP/XeTC/2Lowv9o78T/cPXH/336zv+M/db/nf/g/7L/6v/F//H/2v/5/+///f/3//z/+f/8//r/ + +v/y/+v/4f/e/7/92v+3/dn/wv7O/8r/sf/V/Zv/2vyO/9f9jP/Q5r7WvbOxgn57d7gAAACRAAAAWgAA + ADcAAAAdAAAAMw8PD5G0q6avxtLPtjzT2f8v0NP/MtDR/zPPz/800Mv/N9DJ/zrQyP880cX/PdLD/0DV + wf9F2cL/St7E/1LlyP9b7M3/ZvLT/3H42P97/d3/gv/g/4v/5P+Z/+j/qf/r/7n/7P/E/+f/x//b/7// + zP+0/L//pfm1/5n3r/+M9qv/ePWs/3P3uP+C+sP/hf3J/5D9y/+q+7n/uO2R/7XXZ//P2a3Zxb27iIB9 + ebkAAACRAAAAWgAAADcAAAAdAAAAMw8PD5G1rqiwx9PQtzjS1f8sz9D/MdDP/zLRzv811M7/OdfP/z/b + 0f9E4dX/TOjY/1Pu3P9a9OD/YPni/2X74f9q/N//bv7d/3T/2/96/9r/gf/X/4r+1P+Q/Mv/kfi//43z + sP+F7p//gOmT/4Hmjf+G5Yr/j+WI/5bmh/+a5ob/nOKG/57ahv+k14n/qdyM/6zmkP+k7pT/n/CW/6Hi + hf/K27fayL+9i4J/e7oAAACRAAAAWgAAADYAAAAdAAAAMw8PD5G3r6qxydXRuT7Y1/8z2dX/Ot3Y/0Di + 3P9F6N//SOrg/0nq2/9M6tb/TujQ/0/myf9R58P/VerB/1zwwv9k9cL/a/fA/2/yuf9w6q//buKh/2vb + lf9r2Y3/dNmM/33bi/+C24f/h9uC/4jafv+K1Hr/ic10/4fFbf+Ivmj/jLhg/5K3Vf+Ttkv/lLVO/5m2 + Vf+kvl3/rsti/7HXbf/S4LzbysLAjYOAfLsAAACQAAAAWgAAADYAAAAdAAAAMw8PD5G4sKyzytfTukbh + 3P853tb/PNvR/z/azf8/2Mj/QNTC/z/Quf9D0bb/Ste4/1Leuv9a5L3/X+S5/1/esP9f1qL/X8+X/2HM + kP9lz4z/bNOJ/3HWiP9314T/ftWD/4PRf/9+yHP/eb5o/3m4Y/97s1//f7Bc/4WwVv+MtVH/j7xS/5DA + W/+TxGT/nMVl/6HDYP+kwFj/qLtS/6mzQP/Qz6LczcfHkISBfrwAAACQAAAAWgAAADYAAAAdAAAAMw8P + D5G5sq60y9bSuz/Kwf8yxLf/NsO0/zvHtv9Bzbv/RtXA/0vZv/9O2rv/Udaz/1PQqf9VyqH/WMia/13L + lf9j0JL/adOQ/27VjP9w04b/cM5+/3DHdf9wwm//e8Nx/4bGcf+CwWX/gb9e/4i/Xv+Mw1z/kMdc/5DM + Yf+Mz27/i8tz/47BbP+PuWD/kbJU/5KoSf+WokH/mJw6/5aRKv/Iw5vc0MzKkYWCf70AAACQAAAAWgAA + ADYAAAAdAAAAMg8PD5G6s6+2zNbRvELFuP84xrb/QM27/0XSvf9J1L3/StK3/0vMrP9MyKT/Ucug/1rR + of9j2KH/a9ye/3Dcl/9x2o//c9eI/3fVgf961Xz/ftV2/4DUcP+F02r/ldRu/5nTbv+JyWX/gcZi/4PH + XP+FwlT/grdU/32pVf98nUn/fJM8/3uLNP98hi//gIMr/4SBKP+IgCf/i4Em/4x8Gv/GvZbd08/Nk4eE + gb0AAACQAAAAWgAAADYAAAAdAAAAMg8PD5G8tbC2ztnTvUrQvv8+yrT/Qsqv/0fMrf9P07H/WN22/1/l + t/9j6rT/au2v/3Lsqf956qP/gead/4LilP+A3Ir/f9N+/33Mc/97xGn/d7th/3KyXf9vr2H/d7Zx/3O4 + cP9pr1n/cadC/3icNP90ji//coYq/3SDJv92giT/d38j/3h8If96eiD/fHgg/4B4IP+DeSD/h3oi/4h2 + F//Eu5be1tHQlYeEgb4AAACQAAAAWgAAADYAAAAdAAAAMg8PD5G8tbG4z9nTvlbXvf9S2rv/WuK//2Hp + wv9o7ML/be2//2zps/9p4KX/adWX/2nMjP9txIH/cLx3/22zbf9nqWP/ZKJd/2GdW/9dmlv/XJlc/1yc + W/9lpVn/drBT/3imO/9xjyf/b4Qk/2yAJf9sfiT/cH4j/3aAIv96fx//ense/3l4Hv95dx3/e3Ue/351 + Hv+Adh//hHcf/4VyFf/Dupbe19PSl4eFgr8AAACQAAAAWgAAADYAAAAdAAAAMg8PD5G9trO40dvVv2Te + v/9Y17P/Vs+o/1PHnP9Tv5T/U7mO/1KzhP9Qqnb/UKFr/1OeZv9anmP/YKFk/2CfYv9cmV3/XJhc/1yY + V/9emFD/ZJpH/2eYOv9wmS//fZ0p/3aPJP9qfSH/an0h/25/IP9yfh7/dX4d/3yAHf99fxz/e3oc/3l2 + HP94dBv/eXMc/3tzHP99dBz/gnQd/4JvEv/CuZXe2NTUmIiGg8AAAACQAAAAWgAAADYAAAAdAAAAMg8P + D5C9t7W50NjSwE+3lv9Bq4f/QqF9/0KddP9FnXL/SJ5w/0uebf9Lmmf/TJVi/1CUYP9ZmV//YqFe/2Wf + Wf9imVL/ZZlM/2eYQ/9olDn/Zo0s/2aFJP90jSL/f5Yj/3KHH/9peRz/bHsb/3F+Gv91gRr/eoAa/4CD + Gv9/gBn/fHsa/3l2Gv94chn/eHEa/3lxGf98cRr/gHIb/4BsEP/BuJTf2dbWmoiGg8AAAACQAAAAWgAA + ADYAAAAdAAAAMg8PD5C+ura60NbQwUmjgP8/nHP/QpVs/0GRZv9EkmX/R5Vn/0uYZv9NlmH/T5Nb/1SU + V/9fmlT/a6JT/26hTP9tm0P/b5g7/2iOL/9khCX/Zn8g/26AHf97jR7/fZAe/3GBG/9reRj/b3wX/3SB + F/95gxj/foMX/4SGGP+Dghj/fnwY/3p2GP93chj/d3AY/3hvGP96bxj/fXAZ/31qDv/BuJTg3NjXm4mH + hMEAAACQAAAAWgAAADYAAAAdAAAAMg8PDpC/ure70NbPwUmedP9Al2r/Qo9k/0OLX/9FjF3/SZBc/06T + Wv9Qk1b/U5JR/1qTTP9onEj/eKVE/3qhPf9vlDH/bIwo/2mDIf9rgBz/bX0Z/3B+GP96ixr/fI4a/3F/ + F/9ufBb/cn8V/3qEFf99gxb/gYUW/4eHFv+Fgxb/f3wV/3t1Fv94chb/d28W/3duFv94bhb/fG4X/3to + DP/AuJTg3dnYm4mHhMEAAACQAAAAWgAAADYAAAAdAAAAMg8ODpC/u7i70NbPwkuabf9ClGH/RI1a/0WH + U/9JiFH/TItP/1GOTv9XlEr/XZdG/2aZQP92ojz/gaY1/3eYLP9uiiP/c4oe/3KEGv9wfxX/bnsU/3KA + Fv99jxj/fo8Y/3KAFP9yfhT/eIMU/4CIFP9+hRP/hogU/4iIFP+FgxT/f3wT/3x2E/95cxT/eHAU/3dt + Ff93bRX/e20V/3hmCv/At5Pg3dnanYqIhcEAAACQAAAAWgAAADYAAAAdAAAAMg4ODpDAvLm80dbPwk6Y + Y/9Gk1b/R4pQ/0iCSP9Kgkb/UIhD/1uUQv9kmz7/ap87/3OhNf94nSz/fZok/3mSIP92ihv/e4wZ/3aF + Fv9xgBT/bnwS/3aFE/+DkxX/hZIV/3aDEv94gxL/f4cS/4SMEv+BhxH/iYoR/4iJEv+EgxL/gHwQ/3x3 + Ef97dBL/eXET/3duE/94bRP/eWwU/3dlCf/At5Ph3trbnYqIhcIAAACQAAAAWgAAADYAAAAdAAAAMg8O + DpDAvLm80dbNw1GUWP9Jkk3/TIhH/0yAP/9Vizz/YJc6/2WYN/9upTX/cKAv/22OJf93kSD/g5oe/3+S + HP97ixf/go0W/3qGFP90gBL/c38R/3+LE/+LmRT/ipUU/3yGEf9+iBH/hY0R/4aNEf+FiQ7/iYsP/4iI + D/+EgRD/f3wP/314D/99dhD/fHMR/3pvEv95bRL/em0S/3dmB//AuJLh3trbnouIhsIAAACQAAAAWgAA + ADYAAAAdAAAAMg8ODpDAvLq80tXNw1SSUP9LkEP/U44//16VOv9hlDT/ZZgx/26sL/9qmCf/ZYIg/3CJ + Hv9/lRz/ipsa/4WSGv+AixX/hI0T/3yGEv94gQ//eYMQ/4aSEv+SnhL/i5YR/4CKD/+Ciw7/ipEQ/4iN + D/+Jiw3/i4wN/4iGDP+EgQ7/gHsN/394Df+BeA//gHUP/35yEP99bhH/fG0R/3loBv/BuZLh39zcn4uJ + hsIAAACPAAAAWgAAADYAAAAdAAAAMg8PD5HBvLq90tXMxFWRR/9Znz3/ZaM6/2CPMP9koC7/aa4t/2WN + JP9kfR//a4Qd/3eNG/+Flhj/j5sX/4iSGv+CihL/g4wQ/32GDv96gg7/focO/42XEP+XoBD/jZUP/4WN + Df+Hjg3/j5QP/4iMDv+NjAz/jooM/4mECv+Cfwz/f3oL/4F4DP+DeA3/gnUN/4BzDv9+bw//fW4P/3xr + BP/Cu5Lh39zcn4uJhsMAAACQAAAAWgAAADYAAAAdAAAAMg8PD5HAvLu+09bMxGOjQv9hpjb/X5cx/2Wu + Lv9ipCn/XH4h/2WAHv9qghz/b4Ua/32NF/+LlhX/kpoW/4mQGP+CiA//g4sN/3+GDP98gwv/g4oM/5Sb + Dv+coQ//jZMN/4iODP+MkQz/kJYN/4uLDP+Rjgr/j4oL/4mDCf+CfQr/gHkK/4J4C/+DeAz/g3YN/4Bz + Df9/bw3/fm8N/35uA//DvZLh3tzcoIuJhsMAAACPAAAAWgAAADYAAAAdAAAAMg8PD5HCvbu91NjMxF+Z + O/9boTD/Zr4z/16YKP9YdR//X3sd/2iDG/9sghj/coUX/4COFP+NlxP/kpkW/4iOFf+CiAz/hYkM/4CF + Cv9/hQn/iI4L/5qeDf+doQ3/jZIL/4uQC/+RlQv/kpQL/46MCf+Ujwn/j4kJ/4mDCP+DfQn/gXkI/4N5 + CP+DeAr/gnYL/39yDP9+bwv/gHEM/4BxAv/EvpHh39vcoIuIhcQAAACPAAAAWgAAADYAAAAdAAAAMg8P + D5DCvby+09TLxGCiOf9hwTH/W5cp/1l3H/9beBv/YXwZ/2uDF/9tgRX/dYUT/4OOEv+Plg//kpcT/4eM + Ev+DiAr/hYkJ/4KFCP+Bhgj/jpII/56hC/+doAv/jZEJ/46RCv+WmAr/k5EJ/5KOCP+Ujwj/j4kI/4mC + B/+DfQb/gXoG/4N5B/+Cdwn/gXQK/35xCv99bwn/gHIL/4FzAP/Ev5Hi3drboYqIhcQAAACPAAAAWgAA + ADYAAAAdAAAAMg8PD5DBvLy/1dzMxWG4N/9WkSX/WoUi/1t8HP9cdxn/YnsW/2uBFP9vgBH/d4UQ/4WN + EP+OlQv/kZUQ/4aKEP+Dhgf/hYgH/4KEB/+Ehgf/lJUH/6GiCv+cnQn/kZEH/5OSCP+ZmAn/ko8I/5WQ + B/+Vjwf/j4gH/4mCBv+EfQX/gnoF/4J4Bv+Cdgf/fnQI/3twCP97cAj/gXQK/4F1AP/Ev5Hi3djbooqI + hcQAAACPAAAAWgAAADYAAAAdAAAAMg8PD5DBvr2/1NbLxlmELP9Wih//XIkg/1x7Gf9cdhb/Y3kU/2x/ + Ef9ufw7/eYQN/4SNDP+Nkwj/kZQQ/4WJDf+EhQX/hoYF/4KEBv+GhwX/mJgG/6OkBv+bmgf/k5EH/5aV + Bv+Zlwf/ko8F/5eRBv+VjgX/jocG/4iBBf+EfAT/g3sE/4J4Bf9/dQb/fHIG/3pvBv97cQb/gnYJ/4J3 + AP/Ev5Di3NnbooqIhcQAAACPAAAAWgAAADYAAAAdAAAAMg8PDpDDvr2/1NXLxleCKf9Xixz/XIoe/1t6 + GP9ddBX/Y3cS/2t8D/9vfQ3/eYIM/4SLC/+MkQj/kJIS/4SGDP+DhAP/hYUF/4KDBf+KiQX/m5oG/6Ok + Bf+YlgX/k5AG/5iWBv+Wkwb/lI8F/5iRBv+Tiwb/jYQG/4d/BP+EfAP/g3sE/4B4Bf99dAT/enAF/3du + Bv96cQb/gHYI/4J3AP/EwI/j3Nnbo4qIhcUAAACPAAAAWgAAADYAAAAdAAAAMg8PDpDDv77A1dXMxliA + KP9Wihv/XYob/1x6Fv9dchP/YnUQ/2t7Dv9tfAz/eIEL/4SKCv+Kjwf/jpET/4KECf+BggP/g4MF/4KC + Bv+NiwX/nZwF/6KiBv+VkwX/k5AG/5iVBv+Tjwb/lY4G/5ePBv+QiQb/i4IG/4V9BP+DfAP/g3oF/391 + Bf96cQT/dW4E/3RuBf94cQb/f3cI/4F5AP/EwY7j29nbpIqIhcUAAACPAAAAWgAAADYAAAAdAAAAMg8O + DpHEwL7A1dbMxll+Jv9XiRj/XooZ/1t6Ff9bcBL/YnMP/2l5DP9segv/d4AJ/4OJCP+KjQf/jpAV/4CC + CP+AgQP/gYIE/4GBBf+PjQX/n50G/6GeBf+Ujwb/lZAG/5iTBf+SiwX/lo4F/5WMBv+PhgX/iIAF/4R7 + A/+DewT/gngF/350BP93cAT/cm0E/3JtBP93cgX/fHcH/4B5AP/Bvo3j29jbpImIhcYAAACPAAAAWgAA + ADYAAAAdAAAAMg4ODpDEwL/A1tbMxll8I/9YhhX/XooY/1x5FP9cbxD/YXEN/2h3DP9teAr/dn8I/4GH + CP+Jiwf/jY4V/36AB/9/gAT/f4AD/4KBBP+Sjwb/oJ4G/56ZBv+SjAf/lY8G/5WQBf+RiQb/l4wG/5OJ + Bf+NgwX/h34E/4N6A/+DeQT/gHYE/3xyBP91bgT/cGsD/3FtBP91cQX/e3gG/3t3AP+9uo3j3NrbpYmI + hcYAAACPAAAAWgAAADYAAAAdAAAAMg4ODpDFwb/A1tfNx1d6If9XhBP/XokW/115Ev9bbg3/X3AM/2d0 + C/9sdgn/dX0H/4GGB/+IiQf/jI0W/3x+Bf9+fgP/fn4D/4OABP+UkQX/oZ4G/5qUBv+RiQf/lY4F/5KL + Bf+Qhwf/looG/5CFBf+LgQX/hnwE/4J4Bf+BdgX/fnME/3pwBP9zbAT/b2oD/3FtA/90cQT/e3oF/3Nw + AP+6uI3j3drbpYqIhcYAAACPAAAAWgAAADYAAAAdAAAAMg8ODpDHw8HB1tfNx1Z4H/9XghL/XogT/1x5 + EP9abA3/Xm4L/2VyCf9qdQf/dXwH/4GEBv+Ghwb/i4sY/3p7Bf98fQT/fHwD/4SBBP+VkwX/oZ0G/5WP + Bv+QiAX/k40F/4+HBf+Rhgb/k4cF/4yCBf+KgAT/hHkE/4F3Bf+AdQT/fHIE/3ZuBP9wawT/b2oD/3Bs + A/9zcQP/eXgF/21pAP+5tY3j3drbpYqIhsYAAACPAAAAWgAAADYAAAAdAAAAMg4ODpDHw8LB2NjOx1Z1 + H/9Vfw//XYYR/1x3Dv9Zag3/XmwK/2NxCP9qcwb/dHsG/3+DBf+EhQb/iYkZ/3h4A/96ewT/enoE/4WC + BP+XlAT/npsF/4+KBf+Phgb/kIkF/4yDBf+RhQb/kIMF/4p/BP+IfwP/gXcF/4B1BP9+cwT/enAE/3Ns + BP9wagP/b2oD/29sA/90cgP/dHMF/2diAP+2s4zj3drcpoqIhsYAAACPAAAAWgAAADYAAAAdAAAAMg4O + DpDHxMPB2NjOx1VyHf9Teg3/XIQQ/1x2Df9ZaQv/XWsI/2JwB/9pcQb/c3kG/36BBP+ChAf/hocZ/3V2 + Av94eAX/eXgE/4aDA/+ZlAX/m5cF/4yFBf+NhgX/jYUE/4mABP+PgwT/i4AE/4l+BP+FewT/f3QE/390 + BP98cgT/d24E/3JrA/9vagP/b2sD/29sA/9zcwP/bm0D/2FdAP+0sozj3drcpoqIhsYAAACPAAAAWgAA + ADYAAAAdAAAAMg4ODpDJxcTB2dnPx1RvG/9Sdgz/W4EO/1x1C/9ZaQn/W2kH/2BuBf9ocQX/cncG/3t+ + A/+Aggj/hIUY/3JzAv92dgX/eHcE/4iEBP+YlAX/lpIE/4iCBf+KgwX/iIAD/4h/BP+NgQT/h30E/4d+ + BP+BeAT/f3ME/31yBP96cAT/dG0E/3BqA/9uagP/bmsD/3BtA/9xcQP/aWcC/1xYAP+zsIvj3trcpoqI + hsYAAACPAAAAWgAAADYAAAAdAAAAMg4ODpDKx8XB2drQyFNtGf9Rcgv/W34N/1t0Cv9YaAj/WmcH/19s + Bv9mbwX/cXYE/3l8Av9/gQr/goIW/3BxAv91dAT/d3YE/4mFBP+YlAX/kYwF/4Z/Bf+GfwT/g3sE/4h+ + BP+JfgT/hXsD/4Z8BP99dAT/fXIE/3txBP93bgT/cWsD/25pAv9tagL/bWoC/3FvA/9tbAP/ZGID/1dU + AP+xrovk39vcqIqIhscAAACPAAAAWgAAADYAAAAbAAAAMQ4ODo/Kx8XB2NjOxlFpFv9NbQb/V3oJ/1hx + Bv9UZQT/V2QE/1xoA/9kbAH/bnMA/3Z5AP99fwr/fX4S/2xtAP9xcAH/dnUB/4iFAv+VkQL/i4QB/4F7 + Av9/eAH/f3cC/4R7Af+EegH/g3gB/4J4Af94bwH/eW8C/3duAf9yawL/bWgA/2tnAP9rZwD/a2kA/25t + AP9mZQD/YF0A/1JOAP+uq4nj3tvcp4qIhscAAACNAAAAWAAAADUAAAAYAAAALBAPD4zKxsS/0tHHvVZt + Hf5TcA//XHsQ/111Dv9aag3/XWkO/2NtDP9qcQr/c3gL/3p8Cv+Bgxf/foEa/3BxCP91dAv/e3sM/42L + Df+XlA3/ioQN/4R+Df9/eQz/g3wM/4iAC/+GfAz/iH8M/4J5DP99dAz/fXQM/3lzDP91bwv/cm0K/3Ft + Cf9xbQr/cnEK/3FwCv9paAv/ZGIK/1ZSB/+ppofa2NXVoYyKiMYAAACJAAAAUgAAADAAAAAUAAAAJAsL + C4K/vLi/1dHLo8zNwMHS1MbM1NbHztXWx87U1cfO1dXHztXVx8/W1sfO2NfHztjXx87Z18jO19bHzNXU + xcvV08PK1dTDydfVw8nY1sPJ1tTDyNbTw8jV08PJ1tPDydfUw8nW08PK19TEytbUxMrW08PK1tPEy9bT + xMvW1MXL1tPFy9XSw8vU0cPM09HCzNLRwszRz8LM0c7CzMnHu8XGwruwzcjEmYSCgMYAAAB7AAAARgAA + ACgAAAAOAAAAGgAAAFNpaGbH2NTOsuDc2avi3duv4t3br+Pe26/j3tuv49/br+Lf27Dh39uv4d7br+Hd + 26/g29qu3trYrNzY1qnb1tOo2dXSp9jU0afY09Gn2NXRptnU0aba1NGl2dXRptnU0qfZ1NOo2tbUqNvW + 1Kjb1tSp3NbVqd3Y1qnd2dap3dfWqtrW1KrY1NOs19TSrNfT0qzX09Ks19PSrdbRz6vQy8envrq2vTEx + MLgAAABXAAAANQAAAB4AAAAJAAAAEgAAACcAAABnMzMyq09OTbRMS0qzS0tKtExLSrRMS0q0TEtKtExL + SrRLS0q0S0tKtEtLSrRLS0qzS0pJs0pJSbNLSkizSkpJs0pKSLNKSkizSkpIs0tJSLNLSkmyS0pJsktK + SbNLSkmzS0pJs0tKSbNMSkmzTEpJs0xKSbNMSkmzTEpJs0tKSbNLSkmzS0pJs0tKSbNLSkmzS0lJs0tK + SbRNTEu2Hh0dowAAAF4AAAA4AAAAJQAAABMAAAAFAAAACwAAABYAAAAhAAAALQAAADcAAAA6AAAAOgAA + ADoAAAA6AAAAOgAAADoAAAA6AAAAOgAAADoAAAA6AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOgAAADsAAAA6AAAAMwAAACsAAAAhAAAAFQAAAAsAAAACAAAABAAAAAkAAAAOAAAAEwAA + ABcAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAA + ABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAA + ABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAYAAAAFwAAABMAAAAOAAAACAAAAAQAAAAAAAAAAQAA + AAIAAAAEAAAABwAAAAkAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACQAAAAcAAAAEAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAoAAAAIAAAAEAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABAAAAA4AAAAfAAAALQAAADQAAAA0AAAANAAAADQAAAA0AAAANAAAADQAAAA0AAAANAAA + ADQAAAA0AAAANAAAADQAAAA0AAAANAAAADQAAAA0AAAANAAAADQAAAA0AAAANAAAADQAAAA0AAAANAAA + ADIAAAApAAAAGQAAAAoAAAAMAAAAJAAAAEQAAABhAAAAawAAAGsAAABrAAAAawAAAGwAAABsAAAAbAAA + AGwAAABsAAAAbAAAAGwAAABsAAAAawAAAGsAAABrAAAAawAAAGsAAABrAAAAawAAAGsAAABrAAAAbAAA + AGwAAABsAAAAaAAAAFcAAAA7AAAAGgAAABcAAAA+ExMSkD07OKo7ODWpODUyqDczMKg1Mi+nNDEupzMw + LaczMC2nMzAtpzQxLqY2MzCnODUypzk2M6c5NzOoOjc0qDs3Nag7ODWoOzg1qDs4Nag7ODWoOzg1qDk3 + NKc4NTKnOTYypzs5Nqg5NzSuCQkJlwAAAFsAAAAuAAAAHAYGBmmCfHamr6adhbevp5GyqqKQraWdjami + mYumn5aKpJyUiaSalImkm5OJqJ+Xia6lnoq0qqOKta2li7WtpYy1rqaNtq6njbawpo22saeOt7Opj7mz + q4+8squPua+ojLWsp4u4rquNt62oiaiek3llYVysAAAAfAAAADoAAAAeEA8PdbClnqGF19nWY+Hn9mng + 5PZs3+L1cOHh9XXi3/V44t31e+La9X/j2PWE5Nf1iefX9ZDr2fWY8Nv1o/Tf9bL35PXB+un11Pzu9eX9 + 8vX2/fn1/v759fX99vXu/PL18P3e9fD9x/bu/bfzy860qIiBfp0AAACHAAAAPQAAAB4ODg1zvbGsrmza + 3uwp09b/MtLR/zTSzf8508r/PdTH/0HXxf9H3MX/UOPI/1rry/9m89D/c/vV/4P/3f+Z/+X/s//s/8f/ + 6v/P/9//yf7R/7z8yP+p/Lz/jfq+/5D9yf+f/8T/ufyk/8Dre//P17a/j4iIowAAAIYAAAA+AAAAHg4O + DXPAtK+xadjZ6yfR0f811tP/O9vV/0Hg1v9H5tf/T+vX/1fx1v9f99f/af3X/3L/1f96+8//f/XF/4Xx + uP+J7ar/humY/4Tmi/+I4oT/jN5//4/YfP+U0Hj/nc12/6HVfv+j4ob/p+SD/8/YvcGTjIumAAAAhgAA + AD4AAAAeDg4Nc8G2srNx4dzrMtzV/z/c0v9C3dD/RNvI/0jcwf9P377/V+O7/1zjtP9h3qn/Zdmd/2nW + kv9s1In/ctOC/37SgP9+y3X/fsJr/4G7Zf+Ft13/i7hY/5G9WP+Vv1r/nL5a/6W8Vf+uv1H/09S0w5SQ + kKgAAACFAAAAPgAAAB4ODg5zw7m1tW/RyewuxLb/PMq4/0PQvP9I0rj/TNCv/1PPqP9az6H/YdCZ/2fS + j/9u1In/c9OB/3bPd/99y3D/jcxw/4XEZP+Ewl//i8Vb/4vDX/+IvmP/h7Rd/4qpUP+PoEL/kpg4/5aQ + K//OyKrFmJWVqwAAAIUAAAA+AAAAHg4ODXPEura2ddTG7DjKs/9H0LX/Udi4/1netf9f4a7/aeWo/3bl + of994Zb/fNmH/3vPeP96x23/d79l/3q+af+Bwm//dbZY/3mrQ/94mzn/dY40/3eFLP94fiT/enoh/395 + IP+EeSD/inod/83FqcabmJisAAAAhQAAAD4AAAAeDg4Nc8W7uLiE4MztUNy6/1zfuP9j37X/Zdyq/2LP + lf9jwoP/arl4/2uxbf9kpWP/YJ1c/16aWP9fmlL/bKNM/3aiO/9tiCb/bH8j/258If91fh//en0e/3l4 + Hf95dRz/fHQd/4B2Hv+GdRr/zcWqx5yamq0AAACFAAAAPgAAAB4ODg5zxr27uYDOtu1DtY//R6mB/0ik + ef9LonP/S5pn/06UYP9aml//Yp5c/2CYVP9jmEv/ZJQ8/2aMK/93kyP/d40g/2l6Hf9ufRz/dX8b/36B + G/9/fxr/eXca/3hyGv96cRr/fXIb/4JxF//MxKrJnZubrwAAAIUAAAA+AAAAHg4ODnPHwL66draa7jiU + av9Bj2T/RJFj/0qWY/9Nk13/U5JV/2SdUf9xo0r/bpk8/2qNLf9mgSH/bH4b/3yNHf90hRv/bHoX/3SB + Fv97gxf/g4YX/4OBF/97dxf/d3EX/3hvF/96bhj/f20U/83FqsmfnJ2wAAAAhQAAAD4AAAAeDg4Oc8jB + wLx4sZHuO5Bd/0SJWP9IiVP/T45R/1aUTP9hl0X/dqM9/3ueMv9wjCT/cIUc/259Fv9wfhb/fY4Y/3WE + Fv9xfhT/fIUU/4CGFP+HiBX/hIEU/3x4E/94cRX/d24V/3htFf98axH/zMWqyqCenrEAAACFAAAAPgAA + AB4ODg5zyMLBvHuvhu5AjU3/SIJH/06GQv9bkj//aKA8/3CeMv96mif/e5Qf/3mLGf96hxb/cH4S/3aD + E/+GlRX/fIkT/3uEEv+DixH/hYkQ/4mKEf+DgRH/fXgQ/3t0Ev95bxP/eGwT/3pqDv/MxarLoZ6fsgAA + AIUAAAA+AAAAHg4ODnPJw8K9fat87kaMP/9XjTz/YJQ1/2qjMv9qmCn/bYkg/4CWHP+FlRr/gYwV/36I + Ev92gBD/gYwR/5CcE/+DjRD/hIwP/4iPEP+Jiw3/iYkO/4N/Dv9+eA7/gHcP/35yEP97bRH/e2sM/83G + qsyhn6CzAAAAhQAAAD4AAAAeDg4Oc8jCw76Dr3PuV5w0/2OcMv9lpCz/ZZAk/2d/Hf91ihr/ipkY/4yV + Gf+DixH/f4gO/3uDDf+LlA//lp4Q/4ePDf+LkQ7/i48O/46MC/+Khgv/gX0L/4F4DP+Ddw3/gXQO/35u + Dv9/bgr/z8mqzKGfoLMAAACFAAAAPgAAAB4ODg5zyMPEvomzbe5apyv/YqYs/1uAIP9kfRv/bYMZ/3yM + Fv+PmBT/jJIW/4OJDf+Bhgr/gIYK/5WaDf+ZnQ3/ipAL/5GVDP+Pjwr/ko0K/4uFCf+CfAj/gnkJ/4N3 + C/+Acwz/fm8L/4FyCP/QyqrNoZ+gswAAAIUAAAA+AAAAHg4ODnPJwsW+ib9r7leoJf9afyD/XHca/2iB + F/9wghT/gIwR/5CXD/+KjxH/hIcJ/4OGCP+FiQj/nJ4K/5mbCv+PkQn/lpYK/5OPCP+Tjgj/ioQH/4N8 + Bv+CeQf/gnYI/31yCf98cAn/g3YG/9DKqc2gnZ+1AAAAhQAAAD4AAAAeDg4Oc8nExr+Fr2TvUYYZ/1t+ + HP9ddxb/aX4S/3GBD/+Ciw3/kJUL/4mMD/+EhgX/g4UG/4qLBv+goQf/mZgH/5WTB/+WlAf/lZAG/5SN + Bv+Kggb/hHwE/4J5Bf9/dQb/enAH/3xxB/+EeAX/z8qozp+dn7UAAACEAAAAPgAAAB4ODg5zy8XHv4Ke + X+9ShhT/XH8Z/15zE/9oeg//cX4N/4GJCv+Okgv/iIoO/4ODA/+CgwX/j44F/6GhBv+XlAX/lpQG/5WR + Bf+XkAb/kYkG/4iABf+EfAP/gXgF/3tyBP92bgX/e3IG/4N6A//Py6fOn52ftQAAAIQAAAA+AAAAHg4O + DnPLxsjAg55d71OFEf9dfxb/XXER/2d3Df9vfAr/gIcI/4yQDP+Ghw3/gIEC/4GBBf+TkQX/oZ8G/5WQ + Bv+XkgX/lI4F/5aOBv+OhQX/hX0E/4N7BP9/dQX/dm8E/3JtBP93cwX/gXsB/87Kp8+fnZ+2AAAAhAAA + AD4AAAAeDg4Oc8zHycCDnFzvU4MN/11+FP9dbw//ZnQM/295Cf9+hQf/i40N/4OEDP9+fgL/gYAE/5eU + Bv+fmwb/k40G/5WPBf+Tigb/lIkG/4uCBf+EewT/gngE/31yBP9zbAP/cGwD/3ZzBP98eAD/ysemz5+d + n7cAAACEAAAAPgAAAB4ODg5zzcnKwYKaWe9TgQr/XX4R/1tsDP9jcgr/bXcH/32CBv+Jiw3/gIEM/3t7 + A/+CgAT/mpYF/5uVBv+Rigb/kYoF/5KHBv+QhAX/iX8E/4J3Bf9/dQT/eXAE/3BrBP9wbAP/dnQD/3Rx + AP/HxKbPoJ6gtwAAAIQAAAA+AAAAHg4ODnPPyszBgpdZ71B8B/9cfA//WmoL/2FvCP9sdQb/fIAE/4eI + Dv99fgz/eHgD/4KABP+blwX/lI8F/46GBf+NhAX/kIQF/4yABP+FewT/f3UE/31yBP91bQT/b2oD/29s + A/90cwP/a2gA/8XBptCgnqC3AAAAhAAAAD4AAAAeDg4Oc9HMzsGBlFbvTnYE/1x5Df9aaQn/X2wG/2py + Bv95fQP/hIUO/3l6C/91dQP/g4AE/5qWBf+OiAX/ioIE/4mABP+LgAT/iH0E/4F3BP9+cgT/eW8E/3Fr + A/9uagP/cG0D/29vAv9jXwD/w8Cm0KGeoLgAAACEAAAAPgAAAB4ODg5z0s7Pwn6RU/FKbgD/WXUH/1Vl + Bf9baAP/Z28B/3V4AP9/gQz/c3QF/3FwAP+DgAH/lZEB/4aAAf+CegH/hHsA/4Z7AP+DeQD/e3EA/3lv + Af9zawH/bGcA/2toAP9ubAD/aGYA/1pXAP/BvqXRop+guAAAAIQAAAA9AAAAGhAPD3HRzM69g5JZ7FNy + DP9hexT/Xm0S/2RvEf9vdg//e38O/4WHHf93ehP/eHgP/4yKEf+XkxH/iIIR/4R9EP+KgRD/ioAR/4d/ + EP+AdxD/fXYQ/3dyD/90cA7/dHEO/3V0D/9sag//X1wM/725o8qjoKG3AAAAgAAAADgAAAARCAgIX7e0 + sL3e3dK13NzOxd7ez8bd3M/G3t3Pxt/ez8bh3s/G4N3Pxd3azMLc2crB3drJv93ayb/c2Mm/3NjIv93Z + yb/d2crB3drKwd3YysHd2cvB3drMwtzYysLa1snD2dbIw9jVycTT0MTA19LMqoqHhbsAAABpAAAAKwAA + AAsAAAAqLy4tj3t5d698eXmte3h4rXt5eK17eXitenl4rXp4eK15d3eseHV2q3d1dap2dHSpdXN0qXZ0 + dKl3dHSodnR1qXd1dap3dXWqeHV2qnh2dqp5dnaqeHV1q3Z0dat2dHSsdnR0rHh2dqxubGqwGhkZiAAA + ADgAAAAaAAAABQAAAA4AAAAdAAAAMAAAADUAAAA1AAAANQAAADUAAAA1AAAANQAAADUAAAA1AAAANQAA + ADUAAAA1AAAANQAAADYAAAA1AAAANQAAADUAAAA1AAAANQAAADUAAAA1AAAANQAAADUAAAA1AAAANQAA + ADQAAAAlAAAAGAAAAAsAAAABAAAAAwAAAAYAAAAKAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAA + AAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAA + AAwAAAAMAAAADAAAAAoAAAAGAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAABgAAAAwAAAAAQAgAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAcAAAAaAAAAMQAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAA + ADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADgAAAAnAAAADwAAABUAAABKDAsKhg8N + DI8ODAuODQsKjg0LCo4MCwqODAsKjg0LCo4NCwuODQwLjg4MC44ODAyODgwMjg0MDI4NDAyODQwMjg0M + C44MDAuODg0NjwkJCY4AAABhAAAAKgAAACYyMC6KmpSMnKGclZ2alY6blZGKmZKOhpeQi4SXkYqEl5WO + iJeclZCYoJmTmJ+ak5mgm5SaoJ2UmqKelZumn5mbq5+bm6ebl5mkmpeZpZyYlo+Hf5YgHx6XAAAAQgAA + AC9kWVWRm9nZy1vg5fRi3t/0Zt7c9Gze2fNw3tXzdeHT833l0/OH7NbzlPPb86f55PTB/O702v/y9Oj/ + 8/Tv//P04f/u9Nj/6/Pj/8706Puu8svNtKc9OjuaAAAASgAAAC5pXVqVid3d4CPS1P8x1ND/ONjP/z/d + z/9I5c//VO7S/2L41v9y/9j/gP/Y/5T91P+k+sr/qPa3/6TyqP+b757/jOmb/5Ppo/+j8qH/seyH/87T + ub1APD6aAAAASgAAAC1qXluWjuHd4C/a1P8/3NL/RN7O/0rgyP9U5MP/XOe9/2Tlsf9q4KT/btuU/3XY + if99037/fMpv/4LDaP+KwGH/ksBd/5m/Wv+hwFv/rMhg/9HSub5BPkCcAAAASQAAAC1rYF6XkNnR4S/H + t/9Bzrn/SdO3/1DTrv9c1qb/Z9ec/27Wjv901IH/d890/4LLcP+IyG3/gcBc/4a7VP+EtFb/g6pR/4ie + RP+NlDb/lo4t/87HrsFDQkSdAAAASQAAAC1rYF+YmuDS4kXXuf9Y3rv/YuO2/2XepP9v15T/d82F/3K+ + c/9ts2b/aqxe/3SyXv91qUv/cZQy/3GHKv92gCT/eHke/3l1HP9/dRz/iXgf/87Hr8NFREaeAAAASQAA + AC1rYmKZn9vI40a+l/9OtIn/Ua5//0+hbf9Wm2L/YZ5e/2CYVP9glEj/Y441/3aWKP9wgx7/a3oc/3V+ + G/9+gBr/enga/3hyGv97cRr/hHQc/87HsMVFRUafAAAASQAAACxtZmaalsWu5DeQZP9CjGD/SZJf/06R + WP9dmFD/cqJI/26VNv9phSP/bX4a/3qLG/9vfhj/c38W/36EF/+FhRf/fXkW/3dwF/94bhb/gHAX/8/I + scZHRkifAAAASQAAACxtZ2ibmcKl5TyLUv9Hg0z/Uo1I/2GaQ/9ynjf/fJsp/3WKHP9ygRb/cn8U/3+P + Fv91ghP/fYcT/4WJEv+HhhP/fnoS/3lxE/93bRP/fG0U/8/IssdHRkifAAAASQAAACxtZ2mbnL+b5UWK + Pv9YjDr/Zp40/2uXKv92kR//g5Ua/4GMFf94gxH/fYkR/4yYE/+BihD/h44Q/4mLDv+GhA7/f3kO/391 + EP97bhD/fW0R/9DJsslHR0mgAAAASQAAACxsZ2ucosKS5lidMP9joS3/ZI8k/2mBG/+Bkhf/jZYY/4OK + EP98hAz/ipIO/5ObD/+Ijw3/jZEN/46LC/+GgQr/gXkL/4N3Df9/cAz/gXEO/9HMsslHR0mgAAAASQAA + ACxtZ2ycpsqN5linJv9bgyD/Y3sZ/3GEFv+JkxL/jpMT/4OIC/+AhQn/lJgL/5aaC/+Pkwv/k5EJ/5GM + Cf+GgAj/gnkI/4J2Cv99cAn/g3UL/9LMsspHRkmhAAAASAAAACxtaG2do8WJ5lGJGf9beBn/ZnwT/3SD + D/+KkQz/jI8O/4SFBv+Ehgb/m5wH/5iYB/+VlAf/lZEH/5KLBv+GfwX/gnkF/390B/96bwb/hXkJ/9HM + sMtHRkmhAAAASAAAACxuaW6dobWE51GDEf9cdxX/ZngQ/3SADP+Ijgr/iowN/4GCBP+HhwX/np0F/5eU + Bv+Wkwb/lo8G/4+HBv+FfQT/gXkE/3lwBP92bwT/hHsH/9HNr8xGRkmhAAAASAAAACxuam6dorWD51KC + Df9cdhP/ZHQN/3J9Cf+Hiwn/h4gN/35/A/+KiQX/n5wG/5WQBv+VjgX/lYsG/4uCBf+DewT/f3UE/3Nt + A/9zbwP/gHsG/87Lr8xGRkmiAAAASAAAACxva2+dorSB51J/Cf9cdA//YXAL/3F6B/+FiAn/hIQN/3t7 + A/+OiwT/nJgG/5KLBv+SiQb/kYYF/4h+BP+BdwX/e3EE/3BrA/9ybwL/eHYE/8vIr81HRkmiAAAASAAA + ACxwbXGeorGB51B6BP9bcg3/X2wI/293Bv+ChQj/f4AN/3h4A/+QjAT/lpEF/42FBf+OgwX/jIEE/4R5 + BP9+cwT/dm0E/29qA/9xbwL/b2wD/8jFr81IR0miAAAASAAAACxyb3Keoa5+6UtwAP9YbQb/WmcD/2px + AP99fwT/eHkJ/3NyAP+OiwH/jogB/4R8AP+HfQD/hXsA/31yAP94bgD/b2kA/2xoAP9tawD/Yl8A/8bD + rs9IR0mjAAAASAAAACl0cXScprGE41Z1D/9idhb/ZG8U/3R6Ef+Ehhj/fn8Z/3x8Ev+WkxP/jokT/4eA + E/+NgxP/ioET/4N6E/99dhL/dnIR/3d0Ef9zchH/ZmMP/sbCsMlLSkuiAAAARAAAABhKSEeN09HJw9DR + w8rR0MPK0dDDy9PRw8rU0cPK0c7Bx8/MvsXQzb3E0My9xM/MvcTQzL3F0c2+xdDMvsbQzb/Gz8y/x83K + vcjMyb3Jyse8xsK+uLwtLSyQAAAALgAAAAgAAAAyJCMjbSwrLHErKitwKyorcCoqK3AqKStwKSkqcCko + Km8oKCpvKSgqbykoKm8pKCpvKSgqbykpKm8qKSpvKikqcCkoKnApKCpwKyoscR0cHG8AAAA6AAAAFAAA + AAIAAAAFAAAACAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAA + AAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAsAAAAKAAAABAAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAA + AEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAA + AEEAAABBAAAAQSgAAAAUAAAAKAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAJgAA + AEMAAABIAAAARwAAAEcAAABHAAAARwAAAEcAAABHAAAARwAAAEcAAABHAAAARwAAAEcAAABHAAAARwAA + AEcAAAA0AAAAFQAAACIWFRN0PzUxlDwwLJI4LSqQNiwokDUqJ481KiiPOC4rkDowLpA5MS6RODEvkTcx + L5E1Mi+RNjIvkTQwLpA0MDCQNjIylRAPDoQAAAA5AAAAPXd1cJyfzsy9k8rIxZLGwsOTxL7BlMG6wZjD + usGhyr/BqtHEwrTWycPC2c/D0dzTxN7e2MTg3tnE2NvRwtvbwcPS0bOsX1xYnAAAAFYAAAA9jI+Mqk/h + 5v8w2Nn/O9zW/0Tg1f9O6NT/XPLX/2382v+A/9//nP/j/7b/3v/B/8//vf3D/6f5vf+n+8L/vP+m/9Pv + qOh1b3CeAAAAVwAAADyNkI2tUuHd+jbZ0v9B3c//SeDJ/1XmxP9g6r3/auix/3Hhof973ZH/gNZ//3/N + b/+Gx2f/jsVj/5jEYv+gyF//xdeT5nh0daIAAABWAAAAPI6Rjq5X1cf6Pc66/0zXuv9V2a//ZNqk/27Y + lP9z04L/dsxy/4HJcP+CwmX/gbdR/4KtTv+Bo0n/hpc8/4uJJ/+4rm3nfHp7pQAAAFYAAAA8kZOQsGvg + xvpT17H/X9ep/2DMkv9rwYD/bbVw/2eoYf9lolT/c6hL/3CVM/9vgyX/dX4g/3h4HP95chv/fG8T/7Gj + aOh/fX6nAAAAVgAAADySlJCyYruZ+0Gccf9Jmmv/TJJf/1yYV/9om03/ZI86/2iGJf94jB3/bXsY/3R/ + GP+Agxn/fXoY/3dxGf93axD/rqFm6YB/gKgAAABVAAAAPJKUj7Nfpnv7QIVS/02MT/9cl0n/c6A7/3eV + Kv9wgxr/cH4V/3uLF/90gBT/f4YU/4eHFP9/exP/eHAU/3NnC/+rnmPqgoCCqQAAAFUAAAA8kpOPs2aj + Z/tPiTz/Ypo2/2yXK/98lR//gpAY/3uFEv97hxH/iJUS/4GKEf+IjA//iIcO/4B7Dv99dBD/dmgH/6uf + YeqDgYOqAAAAVQAAADyTk4+0da9X+1+gLP9kjiP/bYMa/4mVF/+JkBT/foUM/4mQDv+SmQ7/ipAN/4+O + DP+KhQr/gXkL/4N2DP96awP/rqNg6oOBg6sAAABVAAAAPJSVj7V2uE37WIcd/2J6F/91hhP/jZUR/4iM + Dv+BhQf/k5YJ/5eZCv+Tkwn/lI8I/4qDB/+Cegf/gXUJ/3lsAP+xp17rgoCDrAAAAFUAAAA8lJSPtXCd + QfxYexX/ZHkS/3eDDf+MkQz/hogJ/4SEBf+amgb/mZcG/5aTBv+Vjgb/iYEF/4J6BP97cQX/d20A/7Gq + XOuBgIOtAAAAVQAAADyVlJC1cZg8/Fl7Ef9jdA7/dX8J/4qNDP+Cgwj/hIQE/52aBv+XkgX/lY8F/5KJ + Bv+GfgT/gHYE/3RtBP9zbgD/r6pa7IGAg64AAABVAAAAPJaVkLZxlTj8WXkM/2BvC/9zfAf/h4oM/35/ + B/+GhAP/nJcG/5OMBv+TiQb/jYMF/4N5Bf98cgT/cGsD/3BtAP+no1nsgoCDrgAAAFUAAAA8l5aStm+P + NPxXdgj/XmsI/3F4Bf+EhQv/eXkH/4eFBP+XkgX/jIQF/42DBf+IfQT/f3QE/3ZuBP9vawP/a2oA/56a + WOyCgIOuAAAAVQAAADyZmJS4ZYIm/01qAP9TYAD/Z24A/3h6AP9tbQD/goAA/4qDAP9+dgD/gngA/3tx + AP90aQD/amMA/2dlAP9dWwD/kY5P8ISDha8AAABVAAAAM5eVkbGyvY7jo7B16aasd+mwsnXouLd66LCv + dOa8uXPlvLdz5beyc+W7tHPmt7F05rOudOavq3Pmrqty56akcei/u5vWe3l5rQAAAEgAAAASKikoaG5r + bpFtam6PbGptj2tpbY9pZ2yOaGZqjGZkaYtmZGmLZ2Vqi2dlaoxoZmuMaWdrjGlna41nZmqNaWdrjmVj + ZJAdHBtrAAAAHwAAAAMAAAAJAAAAFQAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAA + ABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAAA4AAAAGAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAA + AEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEoAAAAEAAAACAA + AAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQAAAEAAAABXAAAAVQAAAFUAAABVAAAAVQAA + AFUAAABVAAAAVQAAAFUAAABVAAAAVQAAAFcAAABMAAAAHwQEBD5WVFCVc3JuoWpqZp5nZ2KdZmRgnGpo + Y51wbmmdcXBrnnRybZ95dHGffnRzn3txb558dXCdTUpFmAABAVQXDg1Qj7m4w1jj5vRe3tv0ZuHY9G/n + 1vN/8tr0k/zi9LH/6vTP/+n02//i9M//3fTK/9n03/+58qenk68DAQRlGQ8OToS7uc8u29f/OtvP/0Xg + yf9U6sX/Ze69/3Lrrv+C5Z7/idyI/4rUd/+Mzm//ls5v/6/YdP+lp5O7BAIGYhkPEE+KubLQP9bB/1Db + vf9b3K3/a9mb/3HQhP9yxnD/fcRq/322VP9+p0b/gJtA/4WOMf+ZkDP/pJ+MvQUFCGMYEBJPkbqu0U7K + pP9WwJL/WbN7/2asa/9moVn/ZZdE/3OYNP9tgiH/dX0c/3p4Gf93bxf/insl/6SejcAFBgljGRMWUI6r + m9M+kWL/R4tX/1aUT/9vnUH/bo0q/22AGf93hhf/c34V/4KGFf+AfRb/dm4U/4V3If+ln47BBgYJYxkU + GFCQqJHUS41G/12UOv9tmC7/gJYe/3yIFP96hRH/hJAS/4KKEP+Jig//gX0P/3txD/+Edhz/paCPwwYG + CWMYFBlQlqyJ1F6jMP9jjSL/c4cY/4yVFf+BiA7/iI8N/5GYDf+NkQz/jYkK/4J7Cv+BdAr/iXoX/6ei + j8QGBgljGBQaUJeuhdVYjx//YngV/3uIEP+Nkg7/g4UI/5OVB/+YmQj/lZII/4+IBv+DegX/fXIF/4p+ + E/+no47FBgYJYxkWG1CVo4HVV4IV/2J1EP96hAr/iowL/4KCBP+YlgX/mJUG/5aQBf+MhAX/gngE/3Zu + A/+HgBH/pqONxgYGCWMZFhxQlqJ/1liAD/9gcAz/d38I/4aHC/+AgAT/mZUG/5SNBv+SiAb/iH0E/31z + BP9wawH/gH4P/6OhjMYGBgpjGhcdUJagftdTdwb/W2oF/3J4Av99fgj/fXsA/5OOAf+KggH/in4B/4B1 + AP91bAD/bWkA/3RyCf+gnYzIBwcKZBoYHVGhqIrWZoIc/216Hf+Bhhv/iYoh/42LGv+blhv/koob/5SK + G/+LgRv/gXsa/357F/98eiL/paKUxwcHCmMGBgcxenl0oJydkbaZmI20mpmNtZmXjLOYloiwmJaIsJiV + iLCZlomxmZWKsZiVirKWlImzmZeNtGpoZp0BAQE9AAAABQAAAB4AAAAqAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACsAAAAjAAAACgAArEEAAKxBAACsQQAArEEAAKxBAACsQQAA + rEEAAKxBAACsQQAArEEAAKxBAACsQQAArEEAAKxBAACsQQAArEE= + + + \ No newline at end of file diff --git a/OnTopReplica/StartupOptions/Factory.cs b/OnTopReplica/StartupOptions/Factory.cs new file mode 100644 index 0000000..9201383 --- /dev/null +++ b/OnTopReplica/StartupOptions/Factory.cs @@ -0,0 +1,79 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.ComponentModel; + +namespace OnTopReplica.StartupOptions { + class Factory { + + static Factory() { + //Custom type conversions + TypeDescriptor.AddAttributes(typeof(Size), new TypeConverterAttribute(typeof(SizeConverter))); + TypeDescriptor.AddAttributes(typeof(ScreenPosition), new TypeConverterAttribute(typeof(ScreenPositionConverter))); + TypeDescriptor.AddAttributes(typeof(Rectangle), new TypeConverterAttribute(typeof(RectangleConverter))); + } + + public static Options CreateOptions(string[] args) { + var options = new Options(); + + ParseCommandLine(args, options); + + return options; + } + + private static void ParseCommandLine(string[] args, Options options) { + var cmdOptions = new NDesk.Options.OptionSet() + .Add("windowId=", "Window handle ({HWND}) to be cloned.", id => { + options.WindowId = new IntPtr(id); + }) + .Add("windowTitle=", "{TITLE} of the window to be cloned.", s => { + options.WindowTitle = s; + }) + .Add("windowClass=", "{CLASS} of the window to be cloned.", s => { + options.WindowClass = s; + }) + .Add("size=", "Target {SIZE} of the cloned thumbnail.", s => { + options.StartSize = s; + }) + .Add("position=", "Target {COORDINATES} of the OnTopReplica window.", s => { + options.StartLocation = new Point(s.Width, s.Height); + options.StartScreenPosition = null; + }) + .Add("screenPosition=", "Resolution independent window position on current screen, with locking (TR|TL|C|BR|BL).", pos => { + options.StartLocation = null; + options.StartScreenPosition = pos; + }) + .Add("r|region=", "Region {BOUNDS} of the original window.", region => { + options.Region = region; + }) + .Add("o|opacity=", "Opacity of the window (0-255).", opacity => { + options.Opacity = opacity; + }) + .Add("cf|clickForward", "Enables click forwarding.", s => { + options.EnableClickForwarding = true; + }) + .Add("noch|chromeOff", "Disables the window's chrome (border).", s => { + options.DisableChrome = true; + }) + .Add("h|help|?", "Show command line help.", s => { + options.Status = CliStatus.Information; + }); + + List values; + try { + values = cmdOptions.Parse(args); + } + catch (NDesk.Options.OptionException ex) { + options.DebugMessageWriter.WriteLine(ex.Message); + options.DebugMessageWriter.WriteLine("Try 'OnTopReplica /help' for more information."); + options.Status = CliStatus.Error; + } + + if (options.Status == CliStatus.Information) { + cmdOptions.WriteOptionDescriptions(options.DebugMessageWriter); + } + } + + } +} diff --git a/OnTopReplica/StartupOptions/Options.cs b/OnTopReplica/StartupOptions/Options.cs new file mode 100644 index 0000000..7ff2085 --- /dev/null +++ b/OnTopReplica/StartupOptions/Options.cs @@ -0,0 +1,129 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.IO; + +namespace OnTopReplica.StartupOptions { + + /// + /// Represents startup options that can be set via CLI scripting (or other stuff). + /// + class Options { + + public Options() { + Status = CliStatus.Ok; + Opacity = 255; + DisableChrome = false; + } + + #region Position and size + + public Point? StartLocation { get; set; } + + public ScreenPosition? StartScreenPosition { get; set; } + + public Size? StartSize { get; set; } + + #endregion + + #region Window cloning + + public IntPtr? WindowId { get; set; } + + public string WindowTitle { get; set; } + + public string WindowClass { get; set; } + + public Rectangle? Region { get; set; } + + #endregion + + #region Options + + public bool EnableClickForwarding { get; set; } + + public byte Opacity { get; set; } + + public bool DisableChrome { get; set; } + + #endregion + + #region Debug info + + StringBuilder _sb = new StringBuilder(); + TextWriter _sbWriter; + + public CliStatus Status { get; set; } + + /// + /// Gets a debug message writer. + /// + public TextWriter DebugMessageWriter { + get { + if (_sbWriter == null) { + _sbWriter = new StringWriter(_sb); + } + return _sbWriter; + } + } + + /// + /// Gets the debug message. + /// + public string DebugMessage { + get { + if(_sbWriter != null) + _sbWriter.Flush(); + return _sb.ToString(); + } + } + + #endregion + + #region Application + + public void Apply(MainForm form) { + //GUI + form.IsChromeVisible = !DisableChrome; + form.Opacity = (double)Opacity / 255.0; + + //Thumbnail cloning + WindowHandle handle = null; + if (WindowId.HasValue) { + handle = WindowHandle.FromHandle(WindowId.Value); + } + else if (WindowTitle != null) { + //TODO + } + else if (WindowClass != null) { + //TODO + } + if (handle != null) { + form.SetThumbnail(handle, Region); + } + + //Size + if (StartSize.HasValue) { + form.ClientSize = StartSize.Value; + } + + //Position + if (StartLocation.HasValue) { + form.Location = StartLocation.Value; + } + else if (StartScreenPosition.HasValue) { + form.PositionLock = StartScreenPosition.Value; + } + + //Other features + if (EnableClickForwarding) { + form.ClickForwardingEnabled = true; + } + } + + #endregion + + } + +} diff --git a/OnTopReplica/StartupOptions/RectangleConverter.cs b/OnTopReplica/StartupOptions/RectangleConverter.cs new file mode 100644 index 0000000..00c8608 --- /dev/null +++ b/OnTopReplica/StartupOptions/RectangleConverter.cs @@ -0,0 +1,61 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.ComponentModel; +using System.Drawing; +using System.Text.RegularExpressions; + +namespace OnTopReplica.StartupOptions { + class RectangleConverter : TypeConverter { + + public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { + if (value != null) { + var sVal = value.ToString(); + return Convert(sVal); + } + else + return base.ConvertFrom(context, culture, value); + } + + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { + return sourceType == typeof(string); + } + + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { + return destinationType == typeof(Rectangle); + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { + if (value != null && destinationType == typeof(Rectangle)) { + var sVal = value.ToString(); + return Convert(sVal); + } + else + return base.ConvertTo(context, culture, value, destinationType); + } + + static Regex _sizeRegex = new Regex("^\\D*(?\\d*)\\s*,\\s*(?\\d*)\\s*,\\s*(?\\d*)\\s*,\\s*(?\\d*)\\D*$", + RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.Singleline); + + private Rectangle Convert(string s) { + var match = _sizeRegex.Match(s); + + var x = match.Groups["x"]; + var y = match.Groups["y"]; + var width = match.Groups["width"]; + var height = match.Groups["height"]; + + if (match.Success && x.Success && y.Success && width.Success && height.Success) { + var xVal = int.Parse(x.Value); + var yVal = int.Parse(y.Value); + var widthVal = int.Parse(width.Value); + var heightVal = int.Parse(height.Value); + + return new Rectangle(xVal, yVal, widthVal, heightVal); + } + else + throw new ArgumentException("Cannot convert '" + s + "' to rectangle."); + } + + } +} diff --git a/OnTopReplica/StartupOptions/ScreenPositionConverter.cs b/OnTopReplica/StartupOptions/ScreenPositionConverter.cs new file mode 100644 index 0000000..18ca1a5 --- /dev/null +++ b/OnTopReplica/StartupOptions/ScreenPositionConverter.cs @@ -0,0 +1,50 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.ComponentModel; + +namespace OnTopReplica.StartupOptions { + class ScreenPositionConverter : TypeConverter { + + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { + if (sourceType == typeof(string)) + return true; + + return base.CanConvertFrom(context, sourceType); + } + + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { + if (destinationType == typeof(ScreenPosition)) + return true; + + return base.CanConvertTo(context, destinationType); + } + + public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { + var sValue = value.ToString(); + + switch (sValue) { + case "TL": + return ScreenPosition.TopLeft; + case "TR": + return ScreenPosition.TopRight; + case "BL": + return ScreenPosition.BottomLeft; + case "BR": + return ScreenPosition.BottomRight; + case "C": + return ScreenPosition.Center; + default: + throw new ArgumentException("Invalid screen position value '" + sValue + "'."); + } + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { + if (destinationType == typeof(ScreenPosition)) + return ConvertFrom(context, culture, value); + + return base.ConvertTo(context, culture, value, destinationType); + } + + } +} diff --git a/OnTopReplica/StartupOptions/SizeConverter.cs b/OnTopReplica/StartupOptions/SizeConverter.cs new file mode 100644 index 0000000..4f19d23 --- /dev/null +++ b/OnTopReplica/StartupOptions/SizeConverter.cs @@ -0,0 +1,56 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.ComponentModel; +using System.Drawing; +using System.Text.RegularExpressions; + +namespace OnTopReplica.StartupOptions { + class SizeConverter : TypeConverter { + + public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { + if (value != null) { + var sVal = value.ToString(); + return Convert(sVal); + } + else + return base.ConvertFrom(context, culture, value); + } + + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { + return sourceType == typeof(string); + } + + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { + return destinationType == typeof(Size); + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { + if (value != null && destinationType == typeof(Size)) { + var sVal = value.ToString(); + return Convert(sVal); + } + else + return base.ConvertTo(context, culture, value, destinationType); + } + + static Regex _sizeRegex = new Regex("^\\D*(?\\d*)\\s*,\\s*(?\\d*)\\D*$", + RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.Singleline); + + private Size Convert(string s) { + var match = _sizeRegex.Match(s); + + var x = match.Groups["x"]; + var y = match.Groups["y"]; + + if (!match.Success || !x.Success || !y.Success) + throw new ArgumentException("Cannot convert '" + s + "' to coordinates pair."); + + var xVal = Int32.Parse(x.Value); + var yVal = Int32.Parse(y.Value); + + return new Size(xVal, yVal); + } + + } +} diff --git a/OnTopReplica/StoredRegion.cs b/OnTopReplica/StoredRegion.cs index 93a64fd..f8337a1 100644 --- a/OnTopReplica/StoredRegion.cs +++ b/OnTopReplica/StoredRegion.cs @@ -13,11 +13,11 @@ namespace OnTopReplica { } public StoredRegion(Rectangle r, string n) { - Rect = r; + Bounds = r; Name = n; } - public Rectangle Rect { + public Rectangle Bounds { get; set; } @@ -47,14 +47,14 @@ namespace OnTopReplica { reader.Read(); XmlSerializer x = new XmlSerializer(typeof(Rectangle)); - Rect = (Rectangle)x.Deserialize(reader); + Bounds = (Rectangle)x.Deserialize(reader); } public void WriteXml(System.Xml.XmlWriter writer) { writer.WriteAttributeString("name", Name); XmlSerializer x = new XmlSerializer(typeof(Rectangle)); - x.Serialize(writer, Rect); + x.Serialize(writer, Bounds); } #endregion diff --git a/OnTopReplica/Strings.Designer.cs b/OnTopReplica/Strings.Designer.cs index 827c274..c310233 100644 --- a/OnTopReplica/Strings.Designer.cs +++ b/OnTopReplica/Strings.Designer.cs @@ -1025,7 +1025,25 @@ namespace OnTopReplica { } /// - /// Looks up a localized string similar to Position. + /// Looks up a localized string similar to Center. + /// + internal static string MenuPosCenter { + get { + return ResourceManager.GetString("MenuPosCenter", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Disabled. + /// + internal static string MenuPosDisabled { + get { + return ResourceManager.GetString("MenuPosDisabled", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Position lock. /// internal static string MenuPosition { get { diff --git a/OnTopReplica/Strings.it.Designer.cs b/OnTopReplica/Strings.it.Designer.cs new file mode 100644 index 0000000..e69de29 diff --git a/OnTopReplica/Strings.it.resx b/OnTopReplica/Strings.it.resx index f8090e3..59bc73c 100644 --- a/OnTopReplica/Strings.it.resx +++ b/OnTopReplica/Strings.it.resx @@ -1,30 +1,135 @@ - - - - text/microsoft-resx - - - 2.0 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - Annulla il processo di aggiornamento. - - - Mostra dettagli su OnTopReplica. - - - Resetta tutte le impostazioni di OnTopReplica. - - - Aggiorna OnTopReplica ora. - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Annulla il processo di aggiornamento. + + + Mostra dettagli su OnTopReplica. + + + Resetta tutte le impostazioni di OnTopReplica. + + + Aggiorna OnTopReplica ora. + + <html> <head> <style type="text/css"> @@ -75,413 +180,416 @@ a:hover { <p>Alcune delle icone sono state prese da <a href="http://www.vistaico.com">VistaICO.com</a> e dal set di icone Xiao.</p> </body> -</html> - - - OnTopReplica - - - Ripristinare completamente la finestra? - - +</html> + + + OnTopReplica + + + Ripristinare completamente la finestra? + + &Ripristina -Tutte le impostazioni saranno perse. - - - Può essere usato se si è perso il controllo della finestra o si è spostata oltre ai bordi dello schermo. - - - Ripristino - - - Resettare impostazioni? - - - Questa procedura resetterà tutte le impostazioni di OnTopReplica e cancellerà tutte le informazioni memorizzate (come, ad esempio, le regioni salvate). - - - Reimposta - - - Scaricare OnTopReplica {0}? - {0} update version - - +Tutte le impostazioni saranno perse. + + + Può essere usato se si è perso il controllo della finestra o si è spostata oltre ai bordi dello schermo. + + + Ripristino + + + Resettare impostazioni? + + + Questa procedura resetterà tutte le impostazioni di OnTopReplica e cancellerà tutte le informazioni memorizzate (come, ad esempio, le regioni salvate). + + + Reimposta + + + Scaricare OnTopReplica {0}? + {0} update version + + Annulla aggiornamento -OnTopReplica si aggiornerà in un secondo momento. - - +OnTopReplica si aggiornerà in un secondo momento. + + Continua -Scarica OnTopReplica {0}. - {0} update version - - - Sarà possibile scaricare la nuova versione ed installarla. - - +Scarica OnTopReplica {0}. + {0} update version + + + Sarà possibile scaricare la nuova versione ed installarla. + + Versione installata: {0} -Versione disponibile: {1} +Versione disponibile: {1} {0} installed version number -{1} online available version number - - - Aggiornamento disponibile - - - &Annulla - - - Creato da: Lorenz Cuno Klopfenstein. - - - Disegna una regione usando il mouse. - - - Dettagli - - - Dettagli su Windows Aero - - - Windows Aero è disponibile soltanto su Windows Vista Home Premium o superiore. - - - Il servizio di Desktop Composition Aero non è attivo. - - +{1} online available version number + + + Aggiornamento disponibile + + + &Annulla + + + Creato da: Lorenz Cuno Klopfenstein. + + + Disegna una regione usando il mouse. + + + Dettagli + + + Dettagli su Windows Aero + + + Windows Aero è disponibile soltanto su Windows Vista Home Premium o superiore. + + + Il servizio di Desktop Composition Aero non è attivo. + + È necessario attivare la "composizione del desktop" (DWM) selezionando "Windows Aero" come tema utilizzato da Windows. -Per farlo, clicca col tasto destro del mouse sul desktop e poi su Personalizza. - - - Dettagli errore - - - Errore: - - - Sembra che la finestra selezionata sia stata chiusa o che non sia più valida. - - - Errore - - +Per farlo, clicca col tasto destro del mouse sul desktop e poi su Personalizza. + + + Dettagli errore + + + Errore: + + + Sembra che la finestra selezionata sia stata chiusa o che non sia più valida. + + + Errore + + La "composzione del desktop" non è supportata dal tuo sistema operativo. -È necessario utilizzare Windows Vista o superiore per avviare OnTopReplica. - - - Desktop Composition (DWM) non supportato - - - Nessuna finestra clonata al momento. - - - Impossibile clonare la finestra. - - - Impossibile adattare la finestra. - - - Impossibile controllare gli aggiornamenti. - - - Sembra che OnTopReplica non sia stato installato usando 'ClickOnce'. Sarà necessario aggiornare manualmente il programma visitando <a href="http://ontopreplica.codeplex.com">la homepage del progetto</a>. - - - Non è stato possibile controllare se esiste una versione più aggiornata di OnTopReplica. Verificare di essere connessi ad Internet. Se la connessione è attiva, è possibile che il sito ufficiale sia temporaneamente offline. - - - Modalità - - - Sempre in cima - - - OnTopReplica sarà sempre la finestra sopra a tutte le altre. - - - Click through - - - OnTopReplica si comporterà come uno schermo trasparente, che permette di cliccare sulle finestre al di sotto. - - - Normale - - - Si comporta come una finestra normale. Puoi portare altre finestre sopra OnTopReplica. - - - OnTopReplica a pieno schermo - - - Disattiva - - - Abilita modalità - - - Seleziona più finestre per attivare. - - - Modalità Gruppo attivata. - - - Modalità Gruppo di finestre: - - - Finestre - Column Header of list, simply refers to available windows to be cloned - - - Sito internet: www.codeplex.com/ontopreplica. - - - Attivare la modalità di inoltro dei clic? - - +È necessario utilizzare Windows Vista o superiore per avviare OnTopReplica. + + + Desktop Composition (DWM) non supportato + + + Nessuna finestra clonata al momento. + + + Impossibile clonare la finestra. + + + Impossibile adattare la finestra. + + + Impossibile controllare gli aggiornamenti. + + + Sembra che OnTopReplica non sia stato installato usando 'ClickOnce'. Sarà necessario aggiornare manualmente il programma visitando <a href="http://ontopreplica.codeplex.com">la homepage del progetto</a>. + + + Non è stato possibile controllare se esiste una versione più aggiornata di OnTopReplica. Verificare di essere connessi ad Internet. Se la connessione è attiva, è possibile che il sito ufficiale sia temporaneamente offline. + + + Modalità + + + Sempre in cima + + + OnTopReplica sarà sempre la finestra sopra a tutte le altre. + + + Click through + + + OnTopReplica si comporterà come uno schermo trasparente, che permette di cliccare sulle finestre al di sotto. + + + Normale + + + Si comporta come una finestra normale. Puoi portare altre finestre sopra OnTopReplica. + + + OnTopReplica a pieno schermo + + + Disattiva + + + Abilita modalità + + + Seleziona più finestre per attivare. + + + Modalità Gruppo attivata. + + + Modalità Gruppo di finestre: + + + Finestre + Column Header of list, simply refers to available windows to be cloned + + + Sito internet: www.codeplex.com/ontopreplica. + + + Attivare la modalità di inoltro dei clic? + + In questa modalità, OnTopReplica inoltrerà tutti i clic del pulsante sinistro sul clone della finestra alla finestra originale (questo permetterà di interagire in maniera basilare con la finestra clonata, senza averla in primo piano). -Per uscire da questa modalità, usa il tasto ESC. - - - Inoltro dei clic - - - Attivare la modalità Click-Through? - - - La modalità "Click-Through" funziona solo se l'opzione è stata attivata e se la finestra è semitrasparente. - - +Per uscire da questa modalità, usa il tasto ESC. + + + Inoltro dei clic + + + Attivare la modalità Click-Through? + + + La modalità "Click-Through" funziona solo se l'opzione è stata attivata e se la finestra è semitrasparente. + + In questa modalità la finestra clonata si comporterà come una maschera semitrasparente che permette di cliccare sulle finestre dietro di essa. -Per tornare alla modalità normale in qualsiasi momento, attiva OnTopReplica (dalla barra delle applicazioni). - - +Per tornare alla modalità normale in qualsiasi momento, attiva OnTopReplica (dalla barra delle applicazioni). + + No, grazie. -Puoi abilitare il Click-Through in futuro - - - Abilita Click-Through - - - Modalità Click-Through - - - OnTopReplica è stato aggiornato. - - - Per utilizzare la nuova versione di OnTopReplica è necessario riavviare l'applicazione. - - - Aggiornamento completato - - - La versione più aggiornata è già installata. - - - Nessun aggiornamento disponibile - - - Lingua - - - A proposito di... - - - Nasconde la finestra principale e mostra una schermata di informazioni. - - - Avanzate - - - Bordo - - - Abilita o disabilita il bordo della finestra. - - - Inoltro dei clic - - - Attiva la modalità di "inoltro dei clic" alla finestra clonata. - - - Abilita Click-Through - - - OnTopReplica si comporterà come una schermata trasparente, permettendo di cliccare sulle finestre al di sotto di essa. - - - Chiudi - - - Termina OnTopReplica. - - - 2:1 Doppio - - - Tutto schermo - - - 1:2 Metà - - - 1:1 Clone esatto - - - 1:4 Quarto - - - Effetto vetro - - - Abilita o disabilita l'effetto vetro. - - - Modalità Gruppo di finestre - - - OnTopReplica clonerà automaticamente una finestra di un gruppo, scegliendo quella che non è stata in primo piano da più tempo. - - - 100% (opaco) - - - Imposta OnTopReplica come finestra completamente opaca. - - - 25% - - - Imposta l'opacità di OnTopReplica al 25%. - - - 50% - - - Imposta l'opacità di OnTopReplica al 50%. - - - 75% - - - Imposta l'opacità di OnTopReplica al 75%. - - - Opacità - - - Apri - - - Attiva la finestra di OnTopReplica. - - - In basso a sinistra - - - In basso a destra - - - Posizione - - - Posiziona automaticamente OnTopReplica sul monitor corrente. - - - In alto a sinistra - - - In alto a destra - - - Esci da tutto schermo - - - Ripristina posizione e grandezza - - - Imposta se, al prossimo avvio di OnTopReplica, debbano essere ripristinati i valori di grandezza e posizione della finestra alla chiusura. - - - Minimizza - - - Riduce OnTopReplica ad un'icona nella barra delle applicazioni. - - - Seleziona regione... - - - Passa alla modalità di "selezione di regione", che permette di limitare la porzione di finestra che viene clonata. - - - Reimposta finestra - - - Reimposta OnTopReplica e la sua finestra principale. - - - Ridimensionamento - - - Vai alla finestra originale - - - Mostra la finestra originale e nasconde OnTopReplica. - - - Seleziona finestra - - - - nessuna - - - - Mostra una lista di finestre che è possibile clonare. - - - - intera - - - - Regione corrente: - - - Cancella - - - Chiudi - - - Altezz. - - - Reset - - - Salva - - - Regioni memorizzate - - - Regioni: - - - Largh. - - - Clic destro qui per iniziare... - - - Una copia leggera, in tempo reale e sempre in primo piano di una finestra a tua scelta. - - - OnTopReplica controlla automaticamente se sono presenti aggiornamenti. - - - Aggiorna! - +Puoi abilitare il Click-Through in futuro + + + Abilita Click-Through + + + Modalità Click-Through + + + OnTopReplica è stato aggiornato. + + + Per utilizzare la nuova versione di OnTopReplica è necessario riavviare l'applicazione. + + + Aggiornamento completato + + + La versione più aggiornata è già installata. + + + Nessun aggiornamento disponibile + + + Lingua + + + A proposito di... + + + Nasconde la finestra principale e mostra una schermata di informazioni. + + + Avanzate + + + Bordo + + + Abilita o disabilita il bordo della finestra. + + + Inoltro dei clic + + + Attiva la modalità di "inoltro dei clic" alla finestra clonata. + + + Abilita Click-Through + + + OnTopReplica si comporterà come una schermata trasparente, permettendo di cliccare sulle finestre al di sotto di essa. + + + Chiudi + + + Termina OnTopReplica. + + + 2:1 Doppio + + + Tutto schermo + + + 1:2 Metà + + + 1:1 Clone esatto + + + 1:4 Quarto + + + Effetto vetro + + + Abilita o disabilita l'effetto vetro. + + + Modalità Gruppo di finestre + + + OnTopReplica clonerà automaticamente una finestra di un gruppo, scegliendo quella che non è stata in primo piano da più tempo. + + + 100% (opaco) + + + Imposta OnTopReplica come finestra completamente opaca. + + + 25% + + + Imposta l'opacità di OnTopReplica al 25%. + + + 50% + + + Imposta l'opacità di OnTopReplica al 50%. + + + 75% + + + Imposta l'opacità di OnTopReplica al 75%. + + + Opacità + + + Apri + + + Attiva la finestra di OnTopReplica. + + + In basso a sinistra + + + In basso a destra + + + Blocco posizione + + + Posiziona automaticamente OnTopReplica sul monitor corrente. + + + In alto a sinistra + + + In alto a destra + + + Esci da tutto schermo + + + Ripristina posizione e grandezza + + + Imposta se, al prossimo avvio di OnTopReplica, debbano essere ripristinati i valori di grandezza e posizione della finestra alla chiusura. + + + Minimizza + + + Riduce OnTopReplica ad un'icona nella barra delle applicazioni. + + + Seleziona regione... + + + Passa alla modalità di "selezione di regione", che permette di limitare la porzione di finestra che viene clonata. + + + Reimposta finestra + + + Reimposta OnTopReplica e la sua finestra principale. + + + Ridimensionamento + + + Vai alla finestra originale + + + Mostra la finestra originale e nasconde OnTopReplica. + + + Seleziona finestra + + + - nessuna - + + + Mostra una lista di finestre che è possibile clonare. + + + - intera - + + + Regione corrente: + + + Cancella + + + Chiudi + + + Altezz. + + + Reset + + + Salva + + + Regioni memorizzate + + + Regioni: + + + Largh. + + + Clic destro qui per iniziare... + + + Una copia leggera, in tempo reale e sempre in primo piano di una finestra a tua scelta. + + + OnTopReplica controlla automaticamente se sono presenti aggiornamenti. + + + Aggiorna! + + + Disabilitato + \ No newline at end of file diff --git a/OnTopReplica/Strings.resx b/OnTopReplica/Strings.resx index 670c5a7..c02a8c3 100644 --- a/OnTopReplica/Strings.resx +++ b/OnTopReplica/Strings.resx @@ -1,30 +1,135 @@ - - - - text/microsoft-resx - - - 2.0 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - Abort update process. - - - Show details about OnTopReplica. - - - Reset all OnTopReplica settings. - - - Update OnTopReplica now. - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Abort update process. + + + Show details about OnTopReplica. + + + Reset all OnTopReplica settings. + + + Update OnTopReplica now. + + <html> <head> <style type="text/css"> @@ -75,413 +180,419 @@ a:hover { <p>Some icons from <a href="http://www.vistaico.com">VistaICO.com</a> and the Xiao icon set.</p> </body> -</html> - - - OnTopReplica - - - Reset window completely? - - +</html> + + + OnTopReplica + + + Reset window completely? + + &Reset -All settings will be lost. - - - Can be used to reset all settings if you lost control over the window or moved it beyond the screen boundary. - - - Reset - - - Reset settings? - - - This will erase all settings of OnTopReplica, returning it to the original state right after installation (all saved information, like stored regions, will be lost). - - - Reset settings - - - Download OnTopReplica {0}? - {0} update version - - +All settings will be lost. + + + Can be used to reset all settings if you lost control over the window or moved it beyond the screen boundary. + + + Reset + + + Reset settings? + + + This will erase all settings of OnTopReplica, returning it to the original state right after installation (all saved information, like stored regions, will be lost). + + + Reset settings + + + Download OnTopReplica {0}? + {0} update version + + Cancel update -OnTopReplica will prompt you the next time it is started. - - +OnTopReplica will prompt you the next time it is started. + + Download -Install OnTopReplica {0}. - {0} update version - - - The new version can be downloaded and installed from the official website. - - +Install OnTopReplica {0}. + {0} update version + + + The new version can be downloaded and installed from the official website. + + Installed version: {0} -Available version: {1} +Available version: {1} {0} installed version number -{1} online available version number - - - Update available - - - &Cancel - - - Created by: Lorenz Cuno Klopfenstein. - - - Draw regions using mouse. - - - Details - - - Details on Windows Aero - - - Windows Aero is only available on Windows Vista Home Premium or higher. - - - Desktop Composition' is not enabled. - - +{1} online available version number + + + Update available + + + &Cancel + + + Created by: Lorenz Cuno Klopfenstein. + + + Draw regions using mouse. + + + Details + + + Details on Windows Aero + + + Windows Aero is only available on Windows Vista Home Premium or higher. + + + Desktop Composition' is not enabled. + + You must enable desktop composition, by selecting 'Windows Aero' as the theme used by Windows. -To do so, right-click on the desktop and click on Personalize. - - - Error details - - - Error: - - - It appears that the selected window has been closed or is not valid anymore. - - - Error - - +To do so, right-click on the desktop and click on Personalize. + + + Error details + + + Error: + + + It appears that the selected window has been closed or is not valid anymore. + + + Error + + Desktop Composition' is not supported on your Operating System. -You must run this application on Windows Vista Home Premium or better. - - - Desktop Composition unsupported - - - No thumbnail loaded. - - - Unable to create thumbnail. - - - Unable to fit window. - - - Unable to check for updates. - - - It appears that OnTopReplica wasn't installed using 'ClickOnce'. You'll have to update manually (visit <a href="http://ontopreplica.codeplex.com">OnTopReplica's homepage</a>). - - - OnTopReplica was unable to check whether an updated version is available. Make sure you are connected to the Internet. If you are, the website may be temporarily down. - - - Mode - - - Always on top - - - Forces OnTopReplica to stay always on top. - - - Click through - - - OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. - - - Standard - - - Behaves like an ordinary window. You can bring other windows above OnTopReplica. - - - OnTopReplica fullscreen - - - Disable - - - Enable Group mode - - - Select multiple windows to enable. - - - Group switch mode is enabled. - - - Group switch mode: - - - Windows - Column Header of list, simply refers to available windows to be cloned - - - Homepage: www.codeplex.com/ontopreplica. - - - Do you want to enable "click forwarding"? - - +You must run this application on Windows Vista Home Premium or better. + + + Desktop Composition unsupported + + + No thumbnail loaded. + + + Unable to create thumbnail. + + + Unable to fit window. + + + Unable to check for updates. + + + It appears that OnTopReplica wasn't installed using 'ClickOnce'. You'll have to update manually (visit <a href="http://ontopreplica.codeplex.com">OnTopReplica's homepage</a>). + + + OnTopReplica was unable to check whether an updated version is available. Make sure you are connected to the Internet. If you are, the website may be temporarily down. + + + Mode + + + Always on top + + + Forces OnTopReplica to stay always on top. + + + Click through + + + OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. + + + Standard + + + Behaves like an ordinary window. You can bring other windows above OnTopReplica. + + + OnTopReplica fullscreen + + + Disable + + + Enable Group mode + + + Select multiple windows to enable. + + + Group switch mode is enabled. + + + Group switch mode: + + + Windows + Column Header of list, simply refers to available windows to be cloned + + + Homepage: www.codeplex.com/ontopreplica. + + + Do you want to enable "click forwarding"? + + If this mode is enabled, OnTopReplica will forward all left mouse clicks to the window that is being cloned (this will allow you to do basic mouse operations on the cloned window without having to activate it). -To exit this mode, push ESC. - - - Click forwarding - - - Enable Click-Through mode? - - - Click-through only works if it has been enabled in the Resize submenu and if the window is semi-transparent. - - +To exit this mode, push ESC. + + + Click forwarding + + + Enable Click-Through mode? + + + Click-through only works if it has been enabled in the Resize submenu and if the window is semi-transparent. + + In this mode the fullscreen window will behave as a partially transparent overlay, allowing you to click on the other windows behind it. -To return to normal mode anytime, activate OnTopReplica by clicking on the task bar (or the tray icon). - - +To return to normal mode anytime, activate OnTopReplica by clicking on the task bar (or the tray icon). + + No, thank you. -You can enable click-through later - - - Use Click-Through - - - Click-Through mode - - - OnTopReplica has been updated. - - - In order to use the updated version of OnTopReplica you'll have to restart the application. - - - Update successful - - - OnTopReplica is up to date. - - - No update available - - - Language - - - About... - - - Hides the main window and displays the "about" box. - - - Advanced - - - Chrome - - - Toggles the display of the window chrome. - - - Enable Click forwarding - - - Enable "click forwarding" to the cloned window. - - - Enable Click-Through - - - OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. - - - Close - - - Closes OnTopReplica. - - - 2:1 Double - - - Fullscreen - - - 1:2 Half - - - 1:1 Fit to window - - - 1:4 Quarter - - - Glass - - - Toggles "glass mode" on and off. - - - Group Switch mode - - - OnTopReplica will automatically clone a window from an user defined group, switching to the one least recently activated to the foreground. - - - 100% (opaque) - - - Sets OnTopReplica to be completely opaque. - - - 25% - - - Sets OnTopReplica to 25% opacity. - - - 50% - - - Sets OnTopReplica to 50% opacity. - - - 75% - - - Sets OnTopReplica to 75% opacity. - - - Opacity - - - Open - - - Displays OnTopReplica. - - - Bottom Left - - - Bottom Right - - - Position - - - Automatically position OnTopReplica on the current screen. - - - Top Left - - - Top Right - - - Quit fullscreen mode - - - Recall last position and size - - - Toggles whether OnTopReplica should store its last position and size and use them when it is restarted. - - - Minimize - - - Minimizes OnTopReplica to the task bar (or the tray). - - - Select region... - - - Switches to "region mode", that allows you to select a limited region of the source's window as thumbnail. - - - Reset window - - - Resets OnTopReplica settings and its main window. - - - Resize - - - Switch to window - - - Switches to the source window and hides OnTopReplica. - - - Select window - - - - none - - - - Displays a list of window you can select as thumbnail source. - - - - whole - - - - Current region: - - - Delete - - - Done - - - Height - - - Reset - - - Save - - - Stored regions - - - Regions: - - - Width - - - Right-click here to start... - - - A lightweight, real-time, always on top thumbnail of a window of your choice. - - - OnTopReplica automatically checks for updates. No information is logged at any point. - - - Update now! - +You can enable click-through later + + + Use Click-Through + + + Click-Through mode + + + OnTopReplica has been updated. + + + In order to use the updated version of OnTopReplica you'll have to restart the application. + + + Update successful + + + OnTopReplica is up to date. + + + No update available + + + Language + + + About... + + + Hides the main window and displays the "about" box. + + + Advanced + + + Chrome + + + Toggles the display of the window chrome. + + + Enable Click forwarding + + + Enable "click forwarding" to the cloned window. + + + Enable Click-Through + + + OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. + + + Close + + + Closes OnTopReplica. + + + 2:1 Double + + + Fullscreen + + + 1:2 Half + + + 1:1 Fit to window + + + 1:4 Quarter + + + Glass + + + Toggles "glass mode" on and off. + + + Group Switch mode + + + OnTopReplica will automatically clone a window from an user defined group, switching to the one least recently activated to the foreground. + + + 100% (opaque) + + + Sets OnTopReplica to be completely opaque. + + + 25% + + + Sets OnTopReplica to 25% opacity. + + + 50% + + + Sets OnTopReplica to 50% opacity. + + + 75% + + + Sets OnTopReplica to 75% opacity. + + + Opacity + + + Open + + + Displays OnTopReplica. + + + Bottom Left + + + Bottom Right + + + Position lock + + + Automatically position OnTopReplica on the current screen. + + + Top Left + + + Top Right + + + Quit fullscreen mode + + + Recall last position and size + + + Toggles whether OnTopReplica should store its last position and size and use them when it is restarted. + + + Minimize + + + Minimizes OnTopReplica to the task bar (or the tray). + + + Select region... + + + Switches to "region mode", that allows you to select a limited region of the source's window as thumbnail. + + + Reset window + + + Resets OnTopReplica settings and its main window. + + + Resize + + + Switch to window + + + Switches to the source window and hides OnTopReplica. + + + Select window + + + - none - + + + Displays a list of window you can select as thumbnail source. + + + - whole - + + + Current region: + + + Delete + + + Done + + + Height + + + Reset + + + Save + + + Stored regions + + + Regions: + + + Width + + + Right-click here to start... + + + A lightweight, real-time, always on top thumbnail of a window of your choice. + + + OnTopReplica automatically checks for updates. No information is logged at any point. + + + Update now! + + + Center + + + Disabled + \ No newline at end of file diff --git a/OnTopReplica/WindowHandle.cs b/OnTopReplica/WindowHandle.cs index 61eaf2f..f158e29 100644 --- a/OnTopReplica/WindowHandle.cs +++ b/OnTopReplica/WindowHandle.cs @@ -8,7 +8,8 @@ namespace OnTopReplica { /// Helper class that keeps a window handle (HWND), the title of the window and can load its icon. public class WindowHandle : System.Windows.Forms.IWin32Window { - IntPtr _handle; + + IntPtr _handle; string _title; public WindowHandle(IntPtr p, string title) { @@ -81,5 +82,13 @@ namespace OnTopReplica { #endregion + /// + /// Creates a new windowHandle instance from a given IntPtr handle. + /// + /// Handle value. + public static WindowHandle FromHandle(IntPtr handle) { + return new WindowHandle(handle, string.Empty); + } + } }