From 7b9f51ceb9ca4e4f64bf82149ba4df8167bae3eb Mon Sep 17 00:00:00 2001 From: rlv-dan Date: Sat, 22 Apr 2017 17:40:03 +0200 Subject: [PATCH] v2.0 --- Snap2HTML.sln | 20 + Snap2HTML/CommandLine.cs | 246 +++ Snap2HTML/PortableSettingsProvider.cs | 201 +++ Snap2HTML/Program.cs | 20 + Snap2HTML/Properties/AssemblyInfo.cs | 36 + Snap2HTML/Properties/Resources.Designer.cs | 63 + Snap2HTML/Properties/Resources.resx | 117 ++ Snap2HTML/Properties/Settings.Designer.cs | 148 ++ Snap2HTML/Properties/Settings.settings | 33 + Snap2HTML/Properties/app.manifest | 26 + Snap2HTML/ReadMe.txt | 217 +++ Snap2HTML/Settings.cs | 36 + Snap2HTML/Snap2HTML.csproj | 158 ++ Snap2HTML/app.config | 39 + Snap2HTML/frmMain.Designer.cs | 623 ++++++++ Snap2HTML/frmMain.cs | 266 ++++ Snap2HTML/frmMain.resx | 1539 +++++++++++++++++++ Snap2HTML/frmMain_BackgroundWorker.cs | 268 ++++ Snap2HTML/frmMain_Helpers.cs | 155 ++ Snap2HTML/icon.ico | Bin 0 -> 35033 bytes Snap2HTML/template.html | 1560 ++++++++++++++++++++ 21 files changed, 5771 insertions(+) create mode 100644 Snap2HTML.sln create mode 100644 Snap2HTML/CommandLine.cs create mode 100644 Snap2HTML/PortableSettingsProvider.cs create mode 100644 Snap2HTML/Program.cs create mode 100644 Snap2HTML/Properties/AssemblyInfo.cs create mode 100644 Snap2HTML/Properties/Resources.Designer.cs create mode 100644 Snap2HTML/Properties/Resources.resx create mode 100644 Snap2HTML/Properties/Settings.Designer.cs create mode 100644 Snap2HTML/Properties/Settings.settings create mode 100644 Snap2HTML/Properties/app.manifest create mode 100644 Snap2HTML/ReadMe.txt create mode 100644 Snap2HTML/Settings.cs create mode 100644 Snap2HTML/Snap2HTML.csproj create mode 100644 Snap2HTML/app.config create mode 100644 Snap2HTML/frmMain.Designer.cs create mode 100644 Snap2HTML/frmMain.cs create mode 100644 Snap2HTML/frmMain.resx create mode 100644 Snap2HTML/frmMain_BackgroundWorker.cs create mode 100644 Snap2HTML/frmMain_Helpers.cs create mode 100644 Snap2HTML/icon.ico create mode 100644 Snap2HTML/template.html diff --git a/Snap2HTML.sln b/Snap2HTML.sln new file mode 100644 index 0000000..3db7ed9 --- /dev/null +++ b/Snap2HTML.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap2HTML", "Snap2HTML\Snap2HTML.csproj", "{04CDFDC2-534E-443D-B75D-A7A0F19B4008}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {04CDFDC2-534E-443D-B75D-A7A0F19B4008}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {04CDFDC2-534E-443D-B75D-A7A0F19B4008}.Debug|Any CPU.Build.0 = Debug|Any CPU + {04CDFDC2-534E-443D-B75D-A7A0F19B4008}.Release|Any CPU.ActiveCfg = Release|Any CPU + {04CDFDC2-534E-443D-B75D-A7A0F19B4008}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Snap2HTML/CommandLine.cs b/Snap2HTML/CommandLine.cs new file mode 100644 index 0000000..8610917 --- /dev/null +++ b/Snap2HTML/CommandLine.cs @@ -0,0 +1,246 @@ +// Source: http://jake.ginnivan.net/c-sharp-argument-parser/ (which is based on http://www.codeproject.com/Articles/3111/C-NET-Command-Line-Arguments-Parser , MIT License) + +/* Examples: + + Argument: –flag + Usage: args.IsTrue("flag"); + Result: true + + Argument: –arg:MyValue + //Usage: args.Single("arg"); + Result: MyValue + + Argument: –arg "My Value" + Usage: args.Single("arg"); + Result: ‘My Value’ + + Argument: /arg=Value /arg=Value2 + Usage: args["arg"] + Result: new string[] {"Value", "Value2"} + + Argument: /arg="Value,Value2" + Usage: args["arg"] + Result: new string[] {"Value", "Value2"} +*/ + + +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections.ObjectModel; +using System.Text.RegularExpressions; + +namespace CommandLine.Utility +{ + /// + /// Arguments class + /// + class Arguments + { + /// + /// Splits the command line. When main(string[] args) is used escaped quotes (ie a path "c:\folder\") + /// Will consume all the following command line arguments as the one argument. + /// This function ignores escaped quotes making handling paths much easier. + /// + /// The command line. + /// + public static string[] SplitCommandLine(string commandLine) + { + var translatedArguments = new StringBuilder(commandLine); + var escaped = false; + for (var i = 0; i < translatedArguments.Length; i++) + { + if (translatedArguments[i] == '"') + { + escaped = !escaped; + } + if (translatedArguments[i] == ' ' && !escaped) + { + translatedArguments[i] = '\n'; + } + } + + var toReturn = translatedArguments.ToString().Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries); + for (var i = 0; i < toReturn.Length; i++) + { + toReturn[i] = RemoveMatchingQuotes(toReturn[i]); + } + return toReturn; + } + + public static string RemoveMatchingQuotes(string stringToTrim) + { + var firstQuoteIndex = stringToTrim.IndexOf('"'); + var lastQuoteIndex = stringToTrim.LastIndexOf('"'); + while (firstQuoteIndex != lastQuoteIndex) + { + stringToTrim = stringToTrim.Remove(firstQuoteIndex, 1); + stringToTrim = stringToTrim.Remove(lastQuoteIndex - 1, 1); //-1 because we've shifted the indicies left by one + firstQuoteIndex = stringToTrim.IndexOf('"'); + lastQuoteIndex = stringToTrim.LastIndexOf('"'); + } + + return stringToTrim; + } + + private readonly Dictionary> _parameters; + private string _waitingParameter; + + public Arguments(IEnumerable arguments) + { + _parameters = new Dictionary>(); + + string[] parts; + + //Splits on beginning of arguments ( - and -- and / ) + //And on assignment operators ( = and : ) + var argumentSplitter = new Regex(@"^-{1,2}|^/|=|:", + RegexOptions.IgnoreCase | RegexOptions.Compiled); + + foreach (var argument in arguments) + { + parts = argumentSplitter.Split(argument, 3); + switch (parts.Length) + { + case 1: + AddValueToWaitingArgument(parts[0]); + break; + case 2: + AddWaitingArgumentAsFlag(); + + //Because of the split index 0 will be a empty string + _waitingParameter = parts[1]; + break; + case 3: + AddWaitingArgumentAsFlag(); + + //Because of the split index 0 will be a empty string + string valuesWithoutQuotes = RemoveMatchingQuotes(parts[2]); + + AddListValues(parts[1], valuesWithoutQuotes.Split(',')); + break; + } + } + + AddWaitingArgumentAsFlag(); + } + + private void AddListValues(string argument, IEnumerable values) + { + foreach (var listValue in values) + { + Add(argument, listValue); + } + } + + private void AddWaitingArgumentAsFlag() + { + if (_waitingParameter == null) return; + + AddSingle(_waitingParameter, "true"); + _waitingParameter = null; + } + + private void AddValueToWaitingArgument(string value) + { + if (_waitingParameter == null) return; + + value = RemoveMatchingQuotes(value); + + Add(_waitingParameter, value); + _waitingParameter = null; + } + + /// + /// Gets the count. + /// + /// The count. + public int Count + { + get + { + return _parameters.Count; + } + } + + /// + /// Adds the specified argument. + /// + /// The argument. + /// The value. + public void Add(string argument, string value) + { + if (!_parameters.ContainsKey(argument)) + _parameters.Add(argument, new Collection()); + + _parameters[argument].Add(value); + } + + public void AddSingle(string argument, string value) + { + if (!_parameters.ContainsKey(argument)) + _parameters.Add(argument, new Collection()); + else + throw new ArgumentException(string.Format("Argument {0} has already been defined", argument)); + + _parameters[argument].Add(value); + } + + public void Remove(string argument) + { + if (_parameters.ContainsKey(argument)) + _parameters.Remove(argument); + } + + /// + /// Determines whether the specified argument is true. + /// + /// The argument. + /// + /// true if the specified argument is true; otherwise, false. + /// + public bool IsTrue(string argument) + { + AssertSingle(argument); + + var arg = this[argument]; + + return arg != null && arg[0].Equals("true", StringComparison.OrdinalIgnoreCase); + } + + private void AssertSingle(string argument) + { + if (this[argument] != null && this[argument].Count > 1) + throw new ArgumentException(string.Format("{0} has been specified more than once, expecting single value", argument)); + } + + public string Single(string argument) + { + AssertSingle(argument); + + //only return value if its NOT true, there is only a single item for that argument + //and the argument is defined + if (this[argument] != null && !IsTrue(argument)) + return this[argument][0]; + + return null; + } + + public bool Exists(string argument) + { + return (this[argument] != null && this[argument].Count > 0); + } + + /// + /// Gets the with the specified parameter. + /// + /// + public Collection this[string parameter] + { + get + { + return _parameters.ContainsKey(parameter) ? _parameters[parameter] : null; + } + } + } +} diff --git a/Snap2HTML/PortableSettingsProvider.cs b/Snap2HTML/PortableSettingsProvider.cs new file mode 100644 index 0000000..da0f760 --- /dev/null +++ b/Snap2HTML/PortableSettingsProvider.cs @@ -0,0 +1,201 @@ +// Source: http://www.codeproject.com/Articles/20917/Creating-a-Custom-Settings-Provider , License: The Code Project Open License (CPOL) +// To use: For each setting in properties: Properties->Provider set to PortableSettingsProvider +// If this does not compile: Project->Add Reference->.Net-> Doubleclick "System.Configuration" +using System; +using System.Collections; +using System.Collections.Generic; +using System.Text; +using System.Configuration; +using System.Configuration.Provider; +using System.Windows.Forms; +using System.Collections.Specialized; +using Microsoft.Win32; +using System.Xml; +using System.IO; + +public class PortableSettingsProvider : SettingsProvider { + + const string SETTINGSROOT = "Settings"; + //XML Root Node + + public override void Initialize(string name, NameValueCollection col) { + base.Initialize(this.ApplicationName, col); + } + + public override string ApplicationName { + get { + if (Application.ProductName.Trim().Length > 0) { + return Application.ProductName; + } + else { + FileInfo fi = new FileInfo(Application.ExecutablePath); + return fi.Name.Substring(0, fi.Name.Length - fi.Extension.Length); + } + } + set { } + //Do nothing + } + + public override string Name { + get { return "PortableSettingsProvider"; } + } + public virtual string GetAppSettingsPath() { + //Used to determine where to store the settings + System.IO.FileInfo fi = new System.IO.FileInfo(Application.ExecutablePath); + return fi.DirectoryName; + } + + public virtual string GetAppSettingsFilename() { + //Used to determine the filename to store the settings + return ApplicationName + ".settings"; + } + + public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propvals) { + //Iterate through the settings to be stored + //Only dirty settings are included in propvals, and only ones relevant to this provider + foreach (SettingsPropertyValue propval in propvals) { + SetValue(propval); + } + + try { + SettingsXML.Save(Path.Combine(GetAppSettingsPath(), GetAppSettingsFilename())); + } + catch (Exception ex) { + } + //Ignore if cant save, device been ejected + } + + public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection props) { + //Create new collection of values + SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); + + //Iterate through the settings to be retrieved + foreach (SettingsProperty setting in props) { + + SettingsPropertyValue value = new SettingsPropertyValue(setting); + value.IsDirty = false; + value.SerializedValue = GetValue(setting); + values.Add(value); + } + return values; + } + + private XmlDocument _settingsXML = null; + + private XmlDocument SettingsXML { + get { + //If we dont hold an xml document, try opening one. + //If it doesnt exist then create a new one ready. + if (_settingsXML == null) { + _settingsXML = new XmlDocument(); + + try { + _settingsXML.Load(Path.Combine(GetAppSettingsPath(), GetAppSettingsFilename())); + } + catch (Exception ex) { + //Create new document + XmlDeclaration dec = _settingsXML.CreateXmlDeclaration("1.0", "utf-8", string.Empty); + _settingsXML.AppendChild(dec); + + XmlNode nodeRoot = default(XmlNode); + + nodeRoot = _settingsXML.CreateNode(XmlNodeType.Element, SETTINGSROOT, ""); + _settingsXML.AppendChild(nodeRoot); + } + } + + return _settingsXML; + } + } + + private string GetValue(SettingsProperty setting) { + string ret = ""; + + try { + if (IsRoaming(setting)) { + ret = SettingsXML.SelectSingleNode(SETTINGSROOT + "/" + setting.Name).InnerText; + } + else { + ret = SettingsXML.SelectSingleNode(SETTINGSROOT + "/" + Environment.MachineName + "/" + setting.Name).InnerText; + } + } + + catch (Exception ex) { + if ((setting.DefaultValue != null)) { + ret = setting.DefaultValue.ToString(); + } + else { + ret = ""; + } + } + + return ret; + } + + private void SetValue(SettingsPropertyValue propVal) { + + XmlElement MachineNode = default(XmlElement); + XmlElement SettingNode = default(XmlElement); + + //Determine if the setting is roaming. + //If roaming then the value is stored as an element under the root + //Otherwise it is stored under a machine name node + try { + if (IsRoaming(propVal.Property)) { + SettingNode = (XmlElement)SettingsXML.SelectSingleNode(SETTINGSROOT + "/" + propVal.Name); + } + else { + SettingNode = (XmlElement)SettingsXML.SelectSingleNode(SETTINGSROOT + "/" + Environment.MachineName + "/" + propVal.Name); + } + } + catch (Exception ex) { + SettingNode = null; + } + + //Check to see if the node exists, if so then set its new value + if ((SettingNode != null)) { + SettingNode.InnerText = propVal.SerializedValue.ToString(); + } + else { + if (IsRoaming(propVal.Property)) { + //Store the value as an element of the Settings Root Node + SettingNode = SettingsXML.CreateElement(propVal.Name); + SettingNode.InnerText = propVal.SerializedValue.ToString(); + SettingsXML.SelectSingleNode(SETTINGSROOT).AppendChild(SettingNode); + } + else { + //Its machine specific, store as an element of the machine name node, + //creating a new machine name node if one doesnt exist. + try { + + MachineNode = (XmlElement)SettingsXML.SelectSingleNode(SETTINGSROOT + "/" + Environment.MachineName); + } + catch (Exception ex) { + MachineNode = SettingsXML.CreateElement(Environment.MachineName); + SettingsXML.SelectSingleNode(SETTINGSROOT).AppendChild(MachineNode); + } + + if (MachineNode == null) { + MachineNode = SettingsXML.CreateElement(Environment.MachineName); + SettingsXML.SelectSingleNode(SETTINGSROOT).AppendChild(MachineNode); + } + + SettingNode = SettingsXML.CreateElement(propVal.Name); + SettingNode.InnerText = propVal.SerializedValue.ToString(); + MachineNode.AppendChild(SettingNode); + } + } + } + + private bool IsRoaming(SettingsProperty prop) { + //Determine if the setting is marked as Roaming + foreach (DictionaryEntry d in prop.Attributes) { + Attribute a = (Attribute)d.Value; + if (a is System.Configuration.SettingsManageabilityAttribute) { + return true; + } + } + return false; + } +} + diff --git a/Snap2HTML/Program.cs b/Snap2HTML/Program.cs new file mode 100644 index 0000000..ffa0cc3 --- /dev/null +++ b/Snap2HTML/Program.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.Windows.Forms; + +namespace Snap2HTML +{ + static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main(string[] args) + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new frmMain()); + } + } +} diff --git a/Snap2HTML/Properties/AssemblyInfo.cs b/Snap2HTML/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..b565d22 --- /dev/null +++ b/Snap2HTML/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attr. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Snap2HTML")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("RL Vision")] +[assembly: AssemblyProduct("Snap2HTML")] +[assembly: AssemblyCopyright( "Copyright © RL Vision 2011-2017" )] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("c2979ac5-80cf-4e5d-8365-5395115c30af")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion( "2.00.0.0" )] +[assembly: AssemblyFileVersion( "2.00.0.0" )] diff --git a/Snap2HTML/Properties/Resources.Designer.cs b/Snap2HTML/Properties/Resources.Designer.cs new file mode 100644 index 0000000..5a349f1 --- /dev/null +++ b/Snap2HTML/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.18444 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace Snap2HTML.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Snap2HTML.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/Snap2HTML/Properties/Resources.resx b/Snap2HTML/Properties/Resources.resx new file mode 100644 index 0000000..af7dbeb --- /dev/null +++ b/Snap2HTML/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/Snap2HTML/Properties/Settings.Designer.cs b/Snap2HTML/Properties/Settings.Designer.cs new file mode 100644 index 0000000..f512d73 --- /dev/null +++ b/Snap2HTML/Properties/Settings.Designer.cs @@ -0,0 +1,148 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.18444 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace Snap2HTML.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Configuration.SettingsProviderAttribute(typeof(PortableSettingsProvider))] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("")] + [global::System.Configuration.SettingsManageabilityAttribute(global::System.Configuration.SettingsManageability.Roaming)] + public string txtRoot { + get { + return ((string)(this["txtRoot"])); + } + set { + this["txtRoot"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Configuration.SettingsProviderAttribute(typeof(PortableSettingsProvider))] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("False")] + [global::System.Configuration.SettingsManageabilityAttribute(global::System.Configuration.SettingsManageability.Roaming)] + public bool chkHidden { + get { + return ((bool)(this["chkHidden"])); + } + set { + this["chkHidden"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Configuration.SettingsProviderAttribute(typeof(PortableSettingsProvider))] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("False")] + [global::System.Configuration.SettingsManageabilityAttribute(global::System.Configuration.SettingsManageability.Roaming)] + public bool chkSystem { + get { + return ((bool)(this["chkSystem"])); + } + set { + this["chkSystem"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Configuration.SettingsProviderAttribute(typeof(PortableSettingsProvider))] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("False")] + [global::System.Configuration.SettingsManageabilityAttribute(global::System.Configuration.SettingsManageability.Roaming)] + public bool chkLinkFiles { + get { + return ((bool)(this["chkLinkFiles"])); + } + set { + this["chkLinkFiles"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Configuration.SettingsProviderAttribute(typeof(PortableSettingsProvider))] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("")] + [global::System.Configuration.SettingsManageabilityAttribute(global::System.Configuration.SettingsManageability.Roaming)] + public string txtLinkRoot { + get { + return ((string)(this["txtLinkRoot"])); + } + set { + this["txtLinkRoot"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Configuration.SettingsProviderAttribute(typeof(PortableSettingsProvider))] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("False")] + [global::System.Configuration.SettingsManageabilityAttribute(global::System.Configuration.SettingsManageability.Roaming)] + public bool chkOpenOutput { + get { + return ((bool)(this["chkOpenOutput"])); + } + set { + this["chkOpenOutput"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Configuration.SettingsProviderAttribute(typeof(PortableSettingsProvider))] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("-1")] + public int WindowLeft { + get { + return ((int)(this["WindowLeft"])); + } + set { + this["WindowLeft"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Configuration.SettingsProviderAttribute(typeof(PortableSettingsProvider))] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("-1")] + public int WindowTop { + get { + return ((int)(this["WindowTop"])); + } + set { + this["WindowTop"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("")] + public string txtTitle { + get { + return ((string)(this["txtTitle"])); + } + set { + this["txtTitle"] = value; + } + } + } +} diff --git a/Snap2HTML/Properties/Settings.settings b/Snap2HTML/Properties/Settings.settings new file mode 100644 index 0000000..e4e639c --- /dev/null +++ b/Snap2HTML/Properties/Settings.settings @@ -0,0 +1,33 @@ + + + + + + + + + False + + + False + + + False + + + + + + False + + + -1 + + + -1 + + + + + + \ No newline at end of file diff --git a/Snap2HTML/Properties/app.manifest b/Snap2HTML/Properties/app.manifest new file mode 100644 index 0000000..63cac71 --- /dev/null +++ b/Snap2HTML/Properties/app.manifest @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Snap2HTML/ReadMe.txt b/Snap2HTML/ReadMe.txt new file mode 100644 index 0000000..75cb1e1 --- /dev/null +++ b/Snap2HTML/ReadMe.txt @@ -0,0 +1,217 @@ + + --- Snap2HTML ---------------------------------------------------------------- + + Freeware by RL Vision (c) 2011-2017 + Homepage: http://www.rlvision.com + + Portable: + - Just unzip and run + - Settings are saved in the application folder + + Free Open Source Software: + - Source code available at GitHub: https://github.com/rlv-dan + + + --- About -------------------------------------------------------------------- + + This application takes a "snapshot" of the folder structure on your + harddrive and saves it as an HTML file. What's unique about Snap2HTML is + that the HTML file uses modern techniques to make it feel like a "real" + application, displaying a treeview with folders that you can navigate to + view the files contained within. There is also a built in file search and + ability to export data as plain text, csv or json. Still, everything is + contained in a single HTML file that you can easily store or distribute. + + Exported file listings can be used in many ways. One is as a complement + to your backups (note however that this program does not backup your + files! It only creates a list of the files and directories). You can + also keep a file list of e.g. external HDDs and other computers, in case + you need to look something up or to save for historic reasons and + documentation. When helping your friends with their computer problems + you can ask them to send a snapshot of their folders so you can better + understand their problem. It's really up to you to decide what Snap2HTML + can be used for! + + + --- Search ------------------------------------------------------------------- + + The built in search box accepts the following modifiers: + + Wildcards * and ? can be used. * matches zero or more characters. ? matches + exactly one character. + + Prefix your search with > to search only the current folder. >> searches + the current folder and its sub folders. + + Tip: Search for * to list all files. This is especially useful together with + the export functionality to get all data out of the html file. + + + --- Linking Files ------------------------------------------------------------ + + Linking allows you open the listed files directly in your web browser. + This is designed to be flexible, which also sometimes makes it tricky + to get right. Here are some examples that shows how to use it: + + -> Link to fully qualified local path + Root folder: "c:\my_root\" + Link to: "c:\my_root\" + Use snapshot from: [anywhere locally] + + -> Link to relative local path + Root folder: "c:\my_root\" + Link to: "my_root\" + Use snapshot from: "c:\snapshot.html" + + -> Link to same folder as snapshot is saved in + Root folder: "c:\my_root\" + Link to: [leave textbox empty] + Use snapshot from: "c:\my_root\snapshot.html" + + -> Link to a web server with mirror of local folder + Root folder: "c:\my_www_root\" + Link to: "http://www.example.com/" + Use snapshot from: [anywhere] + + -> Link to a relative path on a web server with mirror of local folder + Root folder: "c:\my_www_root\subfolder" + Link to: "subfolder/" + Use snapshot from: "http://www.example.com/snapshot.html" + + Notes: + + Only files can be linked. Folders are automatically linked to browse the + path in the snapshot. + + Different browsers handle local links in different ways, usually for + security reasons. For example, Internet Explorer will not let you open + links to files on your local machine at all. (You can however copy the + link and paste into the location field.) + + + --- Command Line ------------------------------------------------------------- + + You can automate Snap2HTML by starting it from the command line with the + following options: + + Simple: Snap2HTMl.exe "c:\path\to\root\folder" + + Starts the program with the given root path already set + + + Full: Snap2HTMl.exe [-path:"root folder path"] [-outfile:"filename"] + [-link:"link to path"] [-title:"page title"] + [-hidden] [-system] + + -path:"root folder path" - The root path to load. + Example: -path:"c:\temp" + + -outfile:"filename" - The filename to save the snapshot as. + Don't forget the html extension! + Example: -outfile:"c:\temp\out.html" + + -link:"link to path" - The path to link files to. + Example: -link:"c:\temp" + + -title:"page title" - Set the page title + + -hidden - Include hidden items + + -system - Include system items + + + Notes: Using -path and -outfile will cause the program to automatically + start generating the snapshot, and quit when done! + + Always surround paths and filenames with quotes ("")! + + Do not include the [sqaure brackets] when you write your command + line. (Sqaure brackets signify optional command line parameters) + + + --- Template Design --------------------------------------------------------- + + If you know html and javascript you may want to have a look at the file + "template.html" in the application folder. This is the base for the + output, and you can modify it with your own enhancements and design changes. + If you make something nice you are welcome, to send it to me and I might + distribute it with future versions of the program! + + + --- Known Problems ---------------------------------------------------------- + + The finished HTML file contains embedded javascript. Web browsers (especially + Internet Explorer) may limit execution of scripts as a security measure. + If the page is stuck on "loading..." (with no cpu activity - large files may + take a while to load) this is probably your problem. + + One user reported needing to start Snap2HTML with "Run as Administrator" + on Win7 Basic, otherwise it would hang when clicking on the browse for + folders button. + + Internet Explorer may fail to load very large files. The problems seems + to be a hard limit in some versions of IE. I have seen this problem in + IE11 myself. Being a hard limit there is no easy solution right now. + + Large file tables can be slow to render and appear to have hung the + browser, especially in Internet Explorer. The same can happen when + navigating away from such a large folder and freeing the memory. + + + --- Version History --------------------------------------------------------- + + v1.0 (2011-07-25) + Initial release + + v1.1 (2011-08-11) + Added tooltips when hovering folders + Bugfixes + + v1.2 (2011-08-18) + Fixed some folder sorting problems + Better error handling when permissions do not allow reading + + v1.5 (2012-06-18) + Added command line support + Files can now be linked to a target of your choice + Option to automatically open snapshots when generated + Several bugfixes and tweaks + + v1.51 (2012-07-11) + Improved error handling + + v1.9 (2013-07-24) + Major overhaul of HTML template + MUCH faster HTML loading + Reduced HTML size by about 1/3 + Folders are now also displayed in the HTML file list + Added option to set page title + Application now saves it settings (in application folder) + GUI enhancements: Drag & Drop a source folder, tooltips + Many smaller fixes to both application and HTML + + v1.91 (2013-12-29) + Smaller change to hide root folder when linking files + + v1.92 (2014-06-12) + Fixed various bugs reported by users lately + Slight changes to the internals of the template file + + v2.0 (2017-04-22) + Added export functionality to get data "out" of the HTML + Export data as plain text, CSV or JSON + Added support for searching with wildcards + Search can be limited to current folder and/or subfolders + Breadcrumb path is now clickable + Current path is tracked in URL. Copy URL to link directly to that folder + Opens previous folder when going back after opening a linked file + Data format was tweaked to give slightly smaller output + Fixed some bugs concerning filenames with odd characters + Many other tweaks and fixes to improve the HTML template + + + --- End User License Agreement ----------------------------------------------- + + RL Vision can not be held responsible for any damages whatsoever, direct or + indirect, caused by this software or other material from RL Vision. + diff --git a/Snap2HTML/Settings.cs b/Snap2HTML/Settings.cs new file mode 100644 index 0000000..8279e96 --- /dev/null +++ b/Snap2HTML/Settings.cs @@ -0,0 +1,36 @@ +namespace Snap2HTML.Properties { + // This class allows you to handle specific events on the settings class: + // The SettingChanging event is raised before a setting's value is changed. + // The PropertyChanged event is raised after a setting's value is changed. + // The SettingsLoaded event is raised after the setting values are loaded. + // The SettingsSaving event is raised before the setting values are saved. + internal sealed partial class Settings + { + public Settings() + { + // // To add event handlers for saving and changing settings, uncomment the lines below: + // + // this.SettingChanging += this.SettingChangingEventHandler; + // + this.SettingsSaving += this.SettingsSavingEventHandler; + // + + this.SettingsLoaded += this.SettingsLoadedEventHandler; + } + + private void SettingChangingEventHandler( object sender, System.Configuration.SettingChangingEventArgs e ) + { + // Add code to handle the SettingChangingEvent event here. + } + + private void SettingsSavingEventHandler( object sender, System.ComponentModel.CancelEventArgs e ) + { + // Add code to handle the SettingsSaving event here. + System.Console.WriteLine( "Settings Saving..." ); + } + private void SettingsLoadedEventHandler( object sender, System.Configuration.SettingsLoadedEventArgs e ) + { + System.Console.WriteLine( "Settings Loaded..." ); + } + } +} diff --git a/Snap2HTML/Snap2HTML.csproj b/Snap2HTML/Snap2HTML.csproj new file mode 100644 index 0000000..0c8f46b --- /dev/null +++ b/Snap2HTML/Snap2HTML.csproj @@ -0,0 +1,158 @@ + + + + Debug + AnyCPU + 9.0.21022 + 2.0 + {04CDFDC2-534E-443D-B75D-A7A0F19B4008} + WinExe + Properties + Snap2HTML + Snap2HTML + v4.0 + 512 + false + D8530038F9FC8EE4BB4C9837D304D5D55CC6D2C3 + DirLister_TemporaryKey.pfx + false + LocalIntranet + false + icon.ico + + + 3.5 + + + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 0.0.0.%2a + false + true + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + x86 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + false + + + + + + + + + + + + + + Form + + + frmMain.cs + + + Form + + + Form + + + + + + + frmMain.cs + Designer + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 2.0 %28x86%29 + true + + + False + .NET Framework 3.0 %28x86%29 + false + + + False + .NET Framework 3.5 + false + + + False + .NET Framework 3.5 SP1 + false + + + + + + PreserveNewest + + + PreserveNewest + + + + + \ No newline at end of file diff --git a/Snap2HTML/app.config b/Snap2HTML/app.config new file mode 100644 index 0000000..27a01da --- /dev/null +++ b/Snap2HTML/app.config @@ -0,0 +1,39 @@ + + + + +
+ + + + + + + + + False + + + False + + + False + + + + + + False + + + -1 + + + -1 + + + + + + + diff --git a/Snap2HTML/frmMain.Designer.cs b/Snap2HTML/frmMain.Designer.cs new file mode 100644 index 0000000..52ddc1f --- /dev/null +++ b/Snap2HTML/frmMain.Designer.cs @@ -0,0 +1,623 @@ +namespace Snap2HTML +{ + partial class frmMain + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(frmMain)); + this.statusStrip1 = new System.Windows.Forms.StatusStrip(); + this.toolStripStatusLabel1 = new System.Windows.Forms.ToolStripStatusLabel(); + this.tabControl1 = new System.Windows.Forms.TabControl(); + this.tabPage1 = new System.Windows.Forms.TabPage(); + this.label2 = new System.Windows.Forms.Label(); + this.txtTitle = new System.Windows.Forms.TextBox(); + this.label6 = new System.Windows.Forms.Label(); + this.chkOpenOutput = new System.Windows.Forms.CheckBox(); + this.txtLinkRoot = new System.Windows.Forms.TextBox(); + this.chkLinkFiles = new System.Windows.Forms.CheckBox(); + this.chkHidden = new System.Windows.Forms.CheckBox(); + this.chkSystem = new System.Windows.Forms.CheckBox(); + this.cmdCreate = new System.Windows.Forms.Button(); + this.txtRoot = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.cmdBrowse = new System.Windows.Forms.Button(); + this.tabPage3 = new System.Windows.Forms.TabPage(); + this.linkLabel5 = new System.Windows.Forms.LinkLabel(); + this.linkLabel4 = new System.Windows.Forms.LinkLabel(); + this.label8 = new System.Windows.Forms.Label(); + this.label7 = new System.Windows.Forms.Label(); + this.pictureBox4 = new System.Windows.Forms.PictureBox(); + this.label4 = new System.Windows.Forms.Label(); + this.tabPage2 = new System.Windows.Forms.TabPage(); + this.groupBoxMoreApps = new System.Windows.Forms.GroupBox(); + this.label33 = new System.Windows.Forms.Label(); + this.label32 = new System.Windows.Forms.Label(); + this.linkLabel3 = new System.Windows.Forms.LinkLabel(); + this.label17 = new System.Windows.Forms.Label(); + this.linkLabel2 = new System.Windows.Forms.LinkLabel(); + this.label11 = new System.Windows.Forms.Label(); + this.pictureBox3 = new System.Windows.Forms.PictureBox(); + this.pictureBox2 = new System.Windows.Forms.PictureBox(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.linkLabel1 = new System.Windows.Forms.LinkLabel(); + this.label5 = new System.Windows.Forms.Label(); + this.labelVersion = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.folderBrowserDialog1 = new System.Windows.Forms.FolderBrowserDialog(); + this.saveFileDialog1 = new System.Windows.Forms.SaveFileDialog(); + this.backgroundWorker = new System.ComponentModel.BackgroundWorker(); + this.toolTip1 = new System.Windows.Forms.ToolTip(this.components); + this.statusStrip1.SuspendLayout(); + this.tabControl1.SuspendLayout(); + this.tabPage1.SuspendLayout(); + this.tabPage3.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox4)).BeginInit(); + this.tabPage2.SuspendLayout(); + this.groupBoxMoreApps.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox3)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.SuspendLayout(); + // + // statusStrip1 + // + this.statusStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStripStatusLabel1}); + this.statusStrip1.Location = new System.Drawing.Point(0, 351); + this.statusStrip1.Name = "statusStrip1"; + this.statusStrip1.Size = new System.Drawing.Size(354, 22); + this.statusStrip1.SizingGrip = false; + this.statusStrip1.TabIndex = 3; + this.statusStrip1.Text = "statusStrip1"; + // + // toolStripStatusLabel1 + // + this.toolStripStatusLabel1.Name = "toolStripStatusLabel1"; + this.toolStripStatusLabel1.Size = new System.Drawing.Size(153, 17); + this.toolStripStatusLabel1.Text = "Select a root folder to begin..."; + // + // tabControl1 + // + this.tabControl1.Controls.Add(this.tabPage1); + this.tabControl1.Controls.Add(this.tabPage3); + this.tabControl1.Controls.Add(this.tabPage2); + this.tabControl1.Location = new System.Drawing.Point(8, 8); + this.tabControl1.Name = "tabControl1"; + this.tabControl1.SelectedIndex = 0; + this.tabControl1.Size = new System.Drawing.Size(338, 336); + this.tabControl1.TabIndex = 0; + // + // tabPage1 + // + this.tabPage1.Controls.Add(this.label2); + this.tabPage1.Controls.Add(this.txtTitle); + this.tabPage1.Controls.Add(this.label6); + this.tabPage1.Controls.Add(this.chkOpenOutput); + this.tabPage1.Controls.Add(this.txtLinkRoot); + this.tabPage1.Controls.Add(this.chkLinkFiles); + this.tabPage1.Controls.Add(this.chkHidden); + this.tabPage1.Controls.Add(this.chkSystem); + this.tabPage1.Controls.Add(this.cmdCreate); + this.tabPage1.Controls.Add(this.txtRoot); + this.tabPage1.Controls.Add(this.label1); + this.tabPage1.Controls.Add(this.cmdBrowse); + this.tabPage1.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.tabPage1.Location = new System.Drawing.Point(4, 22); + this.tabPage1.Name = "tabPage1"; + this.tabPage1.Padding = new System.Windows.Forms.Padding(3); + this.tabPage1.Size = new System.Drawing.Size(330, 310); + this.tabPage1.TabIndex = 0; + this.tabPage1.Text = "Snapshot"; + this.tabPage1.UseVisualStyleBackColor = true; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(6, 108); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(54, 13); + this.label2.TabIndex = 18; + this.label2.Text = "Page title:"; + // + // txtTitle + // + this.txtTitle.DataBindings.Add(new System.Windows.Forms.Binding("Text", global::Snap2HTML.Properties.Settings.Default, "txtTitle", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.txtTitle.Location = new System.Drawing.Point(20, 126); + this.txtTitle.Name = "txtTitle"; + this.txtTitle.Size = new System.Drawing.Size(300, 20); + this.txtTitle.TabIndex = 4; + this.txtTitle.Text = global::Snap2HTML.Properties.Settings.Default.txtTitle; + this.toolTip1.SetToolTip(this.txtTitle, "Set the html page title"); + // + // label6 + // + this.label6.AutoSize = true; + this.label6.Location = new System.Drawing.Point(6, 159); + this.label6.Name = "label6"; + this.label6.Size = new System.Drawing.Size(51, 13); + this.label6.TabIndex = 16; + this.label6.Text = "Link files:"; + // + // chkOpenOutput + // + this.chkOpenOutput.AutoSize = true; + this.chkOpenOutput.Checked = global::Snap2HTML.Properties.Settings.Default.chkOpenOutput; + this.chkOpenOutput.DataBindings.Add(new System.Windows.Forms.Binding("Checked", global::Snap2HTML.Properties.Settings.Default, "chkOpenOutput", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.chkOpenOutput.Location = new System.Drawing.Point(160, 285); + this.chkOpenOutput.Name = "chkOpenOutput"; + this.chkOpenOutput.Size = new System.Drawing.Size(161, 17); + this.chkOpenOutput.TabIndex = 18; + this.chkOpenOutput.Text = "Open in browser when ready"; + this.chkOpenOutput.UseVisualStyleBackColor = true; + // + // txtLinkRoot + // + this.txtLinkRoot.DataBindings.Add(new System.Windows.Forms.Binding("Text", global::Snap2HTML.Properties.Settings.Default, "txtLinkRoot", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.txtLinkRoot.Location = new System.Drawing.Point(20, 198); + this.txtLinkRoot.Name = "txtLinkRoot"; + this.txtLinkRoot.Size = new System.Drawing.Size(300, 20); + this.txtLinkRoot.TabIndex = 6; + this.txtLinkRoot.Text = global::Snap2HTML.Properties.Settings.Default.txtLinkRoot; + this.toolTip1.SetToolTip(this.txtLinkRoot, "This is the target files will be linked to. See ReadMe.txt for examples of how to" + + " make links"); + // + // chkLinkFiles + // + this.chkLinkFiles.AutoSize = true; + this.chkLinkFiles.Checked = global::Snap2HTML.Properties.Settings.Default.chkLinkFiles; + this.chkLinkFiles.DataBindings.Add(new System.Windows.Forms.Binding("Checked", global::Snap2HTML.Properties.Settings.Default, "chkLinkFiles", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.chkLinkFiles.Location = new System.Drawing.Point(20, 177); + this.chkLinkFiles.Name = "chkLinkFiles"; + this.chkLinkFiles.Size = new System.Drawing.Size(59, 17); + this.chkLinkFiles.TabIndex = 5; + this.chkLinkFiles.Text = "Enable"; + this.toolTip1.SetToolTip(this.chkLinkFiles, "Files can be linked so you can open them from within the html document"); + this.chkLinkFiles.UseVisualStyleBackColor = true; + this.chkLinkFiles.CheckedChanged += new System.EventHandler(this.chkLinkFiles_CheckedChanged); + // + // chkHidden + // + this.chkHidden.AutoSize = true; + this.chkHidden.Checked = global::Snap2HTML.Properties.Settings.Default.chkHidden; + this.chkHidden.DataBindings.Add(new System.Windows.Forms.Binding("Checked", global::Snap2HTML.Properties.Settings.Default, "chkHidden", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.chkHidden.Location = new System.Drawing.Point(20, 56); + this.chkHidden.Name = "chkHidden"; + this.chkHidden.Size = new System.Drawing.Size(123, 17); + this.chkHidden.TabIndex = 2; + this.chkHidden.Text = "Include hidden items"; + this.toolTip1.SetToolTip(this.chkHidden, "This applies to both files and folders"); + this.chkHidden.UseVisualStyleBackColor = true; + // + // chkSystem + // + this.chkSystem.AutoSize = true; + this.chkSystem.Checked = global::Snap2HTML.Properties.Settings.Default.chkSystem; + this.chkSystem.DataBindings.Add(new System.Windows.Forms.Binding("Checked", global::Snap2HTML.Properties.Settings.Default, "chkSystem", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.chkSystem.Location = new System.Drawing.Point(20, 79); + this.chkSystem.Name = "chkSystem"; + this.chkSystem.Size = new System.Drawing.Size(123, 17); + this.chkSystem.TabIndex = 3; + this.chkSystem.Text = "Include system items"; + this.toolTip1.SetToolTip(this.chkSystem, "This applies to both files and folders"); + this.chkSystem.UseVisualStyleBackColor = true; + // + // cmdCreate + // + this.cmdCreate.Enabled = false; + this.cmdCreate.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.cmdCreate.Image = ((System.Drawing.Image)(resources.GetObject("cmdCreate.Image"))); + this.cmdCreate.Location = new System.Drawing.Point(160, 239); + this.cmdCreate.Name = "cmdCreate"; + this.cmdCreate.Size = new System.Drawing.Size(160, 40); + this.cmdCreate.TabIndex = 7; + this.cmdCreate.Text = " Create Snapshot"; + this.cmdCreate.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + this.cmdCreate.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText; + this.cmdCreate.UseVisualStyleBackColor = true; + this.cmdCreate.Click += new System.EventHandler(this.cmdCreate_Click); + // + // txtRoot + // + this.txtRoot.DataBindings.Add(new System.Windows.Forms.Binding("Text", global::Snap2HTML.Properties.Settings.Default, "txtRoot", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.txtRoot.Location = new System.Drawing.Point(20, 30); + this.txtRoot.Name = "txtRoot"; + this.txtRoot.ReadOnly = true; + this.txtRoot.Size = new System.Drawing.Size(266, 20); + this.txtRoot.TabIndex = 0; + this.txtRoot.Text = global::Snap2HTML.Properties.Settings.Default.txtRoot; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(6, 12); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(62, 13); + this.label1.TabIndex = 1; + this.label1.Text = "Root folder:"; + // + // cmdBrowse + // + this.cmdBrowse.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.cmdBrowse.Image = ((System.Drawing.Image)(resources.GetObject("cmdBrowse.Image"))); + this.cmdBrowse.Location = new System.Drawing.Point(292, 25); + this.cmdBrowse.Name = "cmdBrowse"; + this.cmdBrowse.Padding = new System.Windows.Forms.Padding(2); + this.cmdBrowse.Size = new System.Drawing.Size(28, 28); + this.cmdBrowse.TabIndex = 1; + this.toolTip1.SetToolTip(this.cmdBrowse, "Browse for root folder"); + this.cmdBrowse.UseVisualStyleBackColor = true; + this.cmdBrowse.Click += new System.EventHandler(this.cmdBrowse_Click); + // + // tabPage3 + // + this.tabPage3.Controls.Add(this.linkLabel5); + this.tabPage3.Controls.Add(this.linkLabel4); + this.tabPage3.Controls.Add(this.label8); + this.tabPage3.Controls.Add(this.label7); + this.tabPage3.Controls.Add(this.pictureBox4); + this.tabPage3.Controls.Add(this.label4); + this.tabPage3.Location = new System.Drawing.Point(4, 22); + this.tabPage3.Name = "tabPage3"; + this.tabPage3.Padding = new System.Windows.Forms.Padding(3); + this.tabPage3.Size = new System.Drawing.Size(330, 310); + this.tabPage3.TabIndex = 2; + this.tabPage3.Text = "Custom Design"; + this.tabPage3.UseVisualStyleBackColor = true; + // + // linkLabel5 + // + this.linkLabel5.AutoSize = true; + this.linkLabel5.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline; + this.linkLabel5.LinkColor = System.Drawing.Color.FromArgb(((int)(((byte)(0)))), ((int)(((byte)(0)))), ((int)(((byte)(192))))); + this.linkLabel5.Location = new System.Drawing.Point(17, 191); + this.linkLabel5.Name = "linkLabel5"; + this.linkLabel5.Size = new System.Drawing.Size(99, 13); + this.linkLabel5.TabIndex = 7; + this.linkLabel5.TabStop = true; + this.linkLabel5.Text = "Open contact page"; + this.linkLabel5.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel5_LinkClicked); + // + // linkLabel4 + // + this.linkLabel4.AutoSize = true; + this.linkLabel4.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline; + this.linkLabel4.LinkColor = System.Drawing.Color.FromArgb(((int)(((byte)(0)))), ((int)(((byte)(0)))), ((int)(((byte)(192))))); + this.linkLabel4.Location = new System.Drawing.Point(17, 112); + this.linkLabel4.Name = "linkLabel4"; + this.linkLabel4.Size = new System.Drawing.Size(151, 13); + this.linkLabel4.TabIndex = 4; + this.linkLabel4.TabStop = true; + this.linkLabel4.Text = "Open template.html in notepad"; + this.linkLabel4.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel4_LinkClicked); + // + // label8 + // + this.label8.Location = new System.Drawing.Point(17, 80); + this.label8.Name = "label8"; + this.label8.Size = new System.Drawing.Size(285, 33); + this.label8.TabIndex = 8; + this.label8.Text = "If you know some html/css you can modify the template yourself to better suit you" + + "r needs:"; + // + // label7 + // + this.label7.Location = new System.Drawing.Point(17, 146); + this.label7.Name = "label7"; + this.label7.Size = new System.Drawing.Size(151, 49); + this.label7.TabIndex = 6; + this.label7.Text = "You are also welcome to contact me and I can help you for a small compensation:"; + // + // pictureBox4 + // + this.pictureBox4.Image = ((System.Drawing.Image)(resources.GetObject("pictureBox4.Image"))); + this.pictureBox4.Location = new System.Drawing.Point(174, 143); + this.pictureBox4.Name = "pictureBox4"; + this.pictureBox4.Size = new System.Drawing.Size(128, 128); + this.pictureBox4.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; + this.pictureBox4.TabIndex = 5; + this.pictureBox4.TabStop = false; + // + // label4 + // + this.label4.Location = new System.Drawing.Point(17, 21); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(307, 73); + this.label4.TabIndex = 0; + this.label4.Text = "Did you know that it is possible to change the appearance of the generated html f" + + "ile? For example you might want to change the logo and colors to match your comp" + + "any\'s."; + // + // tabPage2 + // + this.tabPage2.Controls.Add(this.groupBoxMoreApps); + this.tabPage2.Controls.Add(this.pictureBox1); + this.tabPage2.Controls.Add(this.linkLabel1); + this.tabPage2.Controls.Add(this.label5); + this.tabPage2.Controls.Add(this.labelVersion); + this.tabPage2.Controls.Add(this.label3); + this.tabPage2.Location = new System.Drawing.Point(4, 22); + this.tabPage2.Name = "tabPage2"; + this.tabPage2.Padding = new System.Windows.Forms.Padding(3); + this.tabPage2.Size = new System.Drawing.Size(330, 310); + this.tabPage2.TabIndex = 1; + this.tabPage2.Text = "About"; + this.tabPage2.UseVisualStyleBackColor = true; + // + // groupBoxMoreApps + // + this.groupBoxMoreApps.Controls.Add(this.label33); + this.groupBoxMoreApps.Controls.Add(this.label32); + this.groupBoxMoreApps.Controls.Add(this.linkLabel3); + this.groupBoxMoreApps.Controls.Add(this.label17); + this.groupBoxMoreApps.Controls.Add(this.linkLabel2); + this.groupBoxMoreApps.Controls.Add(this.label11); + this.groupBoxMoreApps.Controls.Add(this.pictureBox3); + this.groupBoxMoreApps.Controls.Add(this.pictureBox2); + this.groupBoxMoreApps.Location = new System.Drawing.Point(6, 174); + this.groupBoxMoreApps.Name = "groupBoxMoreApps"; + this.groupBoxMoreApps.Size = new System.Drawing.Size(318, 130); + this.groupBoxMoreApps.TabIndex = 5; + this.groupBoxMoreApps.TabStop = false; + this.groupBoxMoreApps.Text = "More utilities from RL Vision"; + // + // label33 + // + this.label33.AutoSize = true; + this.label33.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.label33.Location = new System.Drawing.Point(210, 29); + this.label33.Name = "label33"; + this.label33.Size = new System.Drawing.Size(91, 13); + this.label33.TabIndex = 13; + this.label33.Text = "Flash Renamer"; + // + // label32 + // + this.label32.AutoSize = true; + this.label32.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.label32.Location = new System.Drawing.Point(66, 29); + this.label32.Name = "label32"; + this.label32.Size = new System.Drawing.Size(66, 13); + this.label32.TabIndex = 10; + this.label32.Text = "Snap2IMG"; + // + // linkLabel3 + // + this.linkLabel3.AutoSize = true; + this.linkLabel3.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline; + this.linkLabel3.LinkColor = System.Drawing.Color.FromArgb(((int)(((byte)(0)))), ((int)(((byte)(0)))), ((int)(((byte)(192))))); + this.linkLabel3.Location = new System.Drawing.Point(66, 100); + this.linkLabel3.Name = "linkLabel3"; + this.linkLabel3.Size = new System.Drawing.Size(51, 13); + this.linkLabel3.TabIndex = 12; + this.linkLabel3.TabStop = true; + this.linkLabel3.Tag = "http://www.rlvision.com/snap2html/about.asp"; + this.linkLabel3.Text = "More info"; + this.linkLabel3.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel3_LinkClicked); + // + // label17 + // + this.label17.Location = new System.Drawing.Point(66, 42); + this.label17.Name = "label17"; + this.label17.Size = new System.Drawing.Size(100, 74); + this.label17.TabIndex = 11; + this.label17.Text = "Generate contact sheets (thumbnail index) for folders on your hard drive."; + // + // linkLabel2 + // + this.linkLabel2.AutoSize = true; + this.linkLabel2.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline; + this.linkLabel2.LinkColor = System.Drawing.Color.FromArgb(((int)(((byte)(0)))), ((int)(((byte)(0)))), ((int)(((byte)(192))))); + this.linkLabel2.Location = new System.Drawing.Point(210, 100); + this.linkLabel2.Name = "linkLabel2"; + this.linkLabel2.Size = new System.Drawing.Size(51, 13); + this.linkLabel2.TabIndex = 10; + this.linkLabel2.TabStop = true; + this.linkLabel2.Tag = "http://www.rlvision.com/flashren/about.asp"; + this.linkLabel2.Text = "More info"; + this.linkLabel2.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel2_LinkClicked); + // + // label11 + // + this.label11.Location = new System.Drawing.Point(210, 42); + this.label11.Name = "label11"; + this.label11.Size = new System.Drawing.Size(102, 71); + this.label11.TabIndex = 9; + this.label11.Text = "File renaming utility with lots of time saving automation features."; + // + // pictureBox3 + // + this.pictureBox3.Image = ((System.Drawing.Image)(resources.GetObject("pictureBox3.Image"))); + this.pictureBox3.Location = new System.Drawing.Point(169, 29); + this.pictureBox3.Name = "pictureBox3"; + this.pictureBox3.Size = new System.Drawing.Size(39, 48); + this.pictureBox3.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; + this.pictureBox3.TabIndex = 1; + this.pictureBox3.TabStop = false; + // + // pictureBox2 + // + this.pictureBox2.Image = ((System.Drawing.Image)(resources.GetObject("pictureBox2.Image"))); + this.pictureBox2.Location = new System.Drawing.Point(12, 29); + this.pictureBox2.Name = "pictureBox2"; + this.pictureBox2.Size = new System.Drawing.Size(48, 48); + this.pictureBox2.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; + this.pictureBox2.TabIndex = 0; + this.pictureBox2.TabStop = false; + // + // pictureBox1 + // + this.pictureBox1.Image = ((System.Drawing.Image)(resources.GetObject("pictureBox1.Image"))); + this.pictureBox1.Location = new System.Drawing.Point(24, 6); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.Size = new System.Drawing.Size(128, 128); + this.pictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; + this.pictureBox1.TabIndex = 4; + this.pictureBox1.TabStop = false; + // + // linkLabel1 + // + this.linkLabel1.AutoSize = true; + this.linkLabel1.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline; + this.linkLabel1.LinkColor = System.Drawing.Color.FromArgb(((int)(((byte)(0)))), ((int)(((byte)(0)))), ((int)(((byte)(192))))); + this.linkLabel1.Location = new System.Drawing.Point(163, 104); + this.linkLabel1.Name = "linkLabel1"; + this.linkLabel1.Size = new System.Drawing.Size(120, 13); + this.linkLabel1.TabIndex = 3; + this.linkLabel1.TabStop = true; + this.linkLabel1.Text = "http://www.rlvision.com"; + this.linkLabel1.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel1_LinkClicked); + // + // label5 + // + this.label5.AutoSize = true; + this.label5.Location = new System.Drawing.Point(163, 87); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(113, 13); + this.label5.TabIndex = 2; + this.label5.Text = "Freeware by RL Vision"; + // + // labelVersion + // + this.labelVersion.AutoSize = true; + this.labelVersion.Location = new System.Drawing.Point(163, 53); + this.labelVersion.Name = "labelVersion"; + this.labelVersion.Size = new System.Drawing.Size(41, 13); + this.labelVersion.TabIndex = 1; + this.labelVersion.Text = "version"; + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Font = new System.Drawing.Font("Microsoft Sans Serif", 18F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.label3.Location = new System.Drawing.Point(161, 23); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(148, 29); + this.label3.TabIndex = 0; + this.label3.Text = "Snap2HTML"; + // + // folderBrowserDialog1 + // + this.folderBrowserDialog1.RootFolder = System.Environment.SpecialFolder.MyComputer; + this.folderBrowserDialog1.ShowNewFolderButton = false; + // + // backgroundWorker + // + this.backgroundWorker.WorkerReportsProgress = true; + this.backgroundWorker.WorkerSupportsCancellation = true; + this.backgroundWorker.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorker_DoWork); + this.backgroundWorker.ProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(this.backgroundWorker_ProgressChanged); + this.backgroundWorker.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker_RunWorkerCompleted); + // + // frmMain + // + this.AcceptButton = this.cmdCreate; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(354, 373); + this.Controls.Add(this.tabControl1); + this.Controls.Add(this.statusStrip1); + this.DoubleBuffered = true; + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.KeyPreview = true; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "frmMain"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Snap2HTML (Press F1 for Help)"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.frmMain_FormClosing); + this.Load += new System.EventHandler(this.frmMain_Load); + this.Shown += new System.EventHandler(this.frmMain_Shown); + this.KeyUp += new System.Windows.Forms.KeyEventHandler(this.frmMain_KeyUp); + this.statusStrip1.ResumeLayout(false); + this.statusStrip1.PerformLayout(); + this.tabControl1.ResumeLayout(false); + this.tabPage1.ResumeLayout(false); + this.tabPage1.PerformLayout(); + this.tabPage3.ResumeLayout(false); + this.tabPage3.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox4)).EndInit(); + this.tabPage2.ResumeLayout(false); + this.tabPage2.PerformLayout(); + this.groupBoxMoreApps.ResumeLayout(false); + this.groupBoxMoreApps.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox3)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.StatusStrip statusStrip1; + private System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabel1; + private System.Windows.Forms.TabControl tabControl1; + private System.Windows.Forms.TabPage tabPage1; + private System.Windows.Forms.TextBox txtRoot; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Button cmdBrowse; + private System.Windows.Forms.TabPage tabPage2; + private System.Windows.Forms.Button cmdCreate; + private System.Windows.Forms.FolderBrowserDialog folderBrowserDialog1; + private System.Windows.Forms.SaveFileDialog saveFileDialog1; + private System.Windows.Forms.PictureBox pictureBox1; + private System.Windows.Forms.LinkLabel linkLabel1; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.Label labelVersion; + private System.Windows.Forms.Label label3; + private System.ComponentModel.BackgroundWorker backgroundWorker; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.CheckBox chkOpenOutput; + private System.Windows.Forms.TextBox txtLinkRoot; + private System.Windows.Forms.CheckBox chkLinkFiles; + private System.Windows.Forms.CheckBox chkHidden; + private System.Windows.Forms.CheckBox chkSystem; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.TextBox txtTitle; + private System.Windows.Forms.ToolTip toolTip1; + private System.Windows.Forms.GroupBox groupBoxMoreApps; + private System.Windows.Forms.Label label33; + private System.Windows.Forms.Label label32; + private System.Windows.Forms.LinkLabel linkLabel3; + private System.Windows.Forms.Label label17; + private System.Windows.Forms.LinkLabel linkLabel2; + private System.Windows.Forms.Label label11; + private System.Windows.Forms.PictureBox pictureBox3; + private System.Windows.Forms.PictureBox pictureBox2; + private System.Windows.Forms.TabPage tabPage3; + private System.Windows.Forms.LinkLabel linkLabel4; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.PictureBox pictureBox4; + private System.Windows.Forms.Label label7; + private System.Windows.Forms.LinkLabel linkLabel5; + private System.Windows.Forms.Label label8; + } +} + diff --git a/Snap2HTML/frmMain.cs b/Snap2HTML/frmMain.cs new file mode 100644 index 0000000..303f4fd --- /dev/null +++ b/Snap2HTML/frmMain.cs @@ -0,0 +1,266 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using CommandLine.Utility; + +namespace Snap2HTML +{ + public partial class frmMain : Form + { + private string outFile = ""; // set when automating via command line + private bool initDone = false; + + public frmMain() + { + InitializeComponent(); + } + + private void frmMain_Load( object sender, EventArgs e ) + { + labelVersion.Text = "version " + Application.ProductVersion.Split( '.' )[0] + "." + Application.ProductVersion.Split( '.' )[1]; + + // initialize some settings + int left = Snap2HTML.Properties.Settings.Default.WindowLeft; + int top = Snap2HTML.Properties.Settings.Default.WindowTop; + if( left >= 0 ) this.Left = left; + if( top >= 0 ) this.Top = top; + + if( System.IO.Directory.Exists( txtRoot.Text ) ) + { + SetRootPath( txtRoot.Text , true); + } + else + { + SetRootPath( "" , false ); + } + + txtLinkRoot.Enabled = chkLinkFiles.Checked; + + // setup drag & drop handlers + tabPage1.DragDrop += DragDropHandler; + tabPage1.DragEnter += DragEnterHandler; + tabPage1.AllowDrop = true; + foreach( Control cnt in tabPage1.Controls ) + { + cnt.DragDrop += DragDropHandler; + cnt.DragEnter += DragEnterHandler; + cnt.AllowDrop = true; + } + + initDone = true; + } + + private void frmMain_Shown( object sender, EventArgs e ) + { + // parse command line + var commandLine = Environment.CommandLine; + var splitCommandLine = Arguments.SplitCommandLine(commandLine); + var arguments = new Arguments(splitCommandLine); + + // first test for single argument (ie path only) + if (splitCommandLine.Length == 2 && !arguments.Exists("path")) + { + if (System.IO.Directory.Exists(splitCommandLine[1])) + { + SetRootPath( splitCommandLine[1] ); + } + } + + if (arguments.IsTrue("hidden")) chkHidden.Checked = true; + if (arguments.IsTrue("system")) chkSystem.Checked = true; + if( arguments.Exists( "path" ) ) + { + // note: relative paths not handled + string path = arguments.Single( "path" ); + if( !System.IO.Directory.Exists( path ) ) path = Environment.CurrentDirectory + System.IO.Path.DirectorySeparatorChar + path; + + if( System.IO.Directory.Exists( path ) ) + { + SetRootPath( path ); + + // if outfile is also given, start generating snapshot + if (arguments.Exists("outfile")) + { + outFile = arguments.Single("outfile"); + cmdCreate.PerformClick(); + } + } + } + + // run link/title after path, since path automatically updates title + if( arguments.Exists( "link" ) ) + { + chkLinkFiles.Checked = true; + txtLinkRoot.Text = arguments.Single( "link" ); + txtLinkRoot.Enabled = true; + } + if( arguments.Exists( "title" ) ) + { + txtTitle.Text = arguments.Single( "title" ); + } + } + + private void frmMain_FormClosing( object sender, FormClosingEventArgs e ) + { + if( backgroundWorker.IsBusy ) e.Cancel = true; + + if( outFile == "" ) // don't save settings when automated through command line + { + Snap2HTML.Properties.Settings.Default.WindowLeft = this.Left; + Snap2HTML.Properties.Settings.Default.WindowTop = this.Top; + Snap2HTML.Properties.Settings.Default.Save(); + } + } + + private void cmdBrowse_Click(object sender, EventArgs e) + { + folderBrowserDialog1.RootFolder = Environment.SpecialFolder.Desktop; // this makes it possible to select network paths too + folderBrowserDialog1.SelectedPath = txtRoot.Text; + if (folderBrowserDialog1.ShowDialog() == DialogResult.OK) + { + try + { + SetRootPath( folderBrowserDialog1.SelectedPath ); + } + catch( System.Exception ex ) + { + MessageBox.Show( "Could not select folder: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); + SetRootPath( "", false ); + } + } + } + + private void cmdCreate_Click(object sender, EventArgs e) + { + // ensure source path format + txtRoot.Text = System.IO.Path.GetFullPath( txtRoot.Text ); + if (txtRoot.Text.EndsWith(@"\")) txtRoot.Text = txtRoot.Text.Substring(0, txtRoot.Text.Length - 1); + if ( IsWildcardMatch( "?:" , txtRoot.Text , false ) ) txtRoot.Text += @"\"; // add backslash to path if only letter and colon eg "c:" + + // add slash or backslash to end of link (in cases where it is clearthat we we can) + if( !txtLinkRoot.Text.EndsWith( @"/" ) && txtLinkRoot.Text.ToLower().StartsWith( @"http" ) ) // web site + { + txtLinkRoot.Text += @"/"; + } + if( !txtLinkRoot.Text.EndsWith( @"\" ) && IsWildcardMatch( "?:*" , txtLinkRoot.Text , false )) // local disk + { + txtLinkRoot.Text += @"\"; + } + + // get output file + if( outFile == "" ) + { + string fileName = new System.IO.DirectoryInfo( txtRoot.Text + @"\" ).Name; + char[] invalid = System.IO.Path.GetInvalidFileNameChars(); + for (int i = 0; i < invalid.Length; i++) + { + fileName = fileName.Replace(invalid[i].ToString(), ""); + } + + saveFileDialog1.DefaultExt = "html"; + if( !fileName.ToLower().EndsWith( ".html" ) ) fileName += ".html"; + saveFileDialog1.FileName = fileName; + saveFileDialog1.InitialDirectory = System.IO.Path.GetDirectoryName(txtRoot.Text); + if (saveFileDialog1.ShowDialog() != DialogResult.OK) return; + } + else // command line + { + saveFileDialog1.FileName = outFile; + } + + if( !saveFileDialog1.FileName.ToLower().EndsWith( ".html" ) ) saveFileDialog1.FileName += ".html"; + + // make sure output path exists + if( !System.IO.Directory.Exists( System.IO.Path.GetDirectoryName( saveFileDialog1.FileName ) ) ) + { + MessageBox.Show( "The output folder does not exists...\n\n" + System.IO.Path.GetDirectoryName( saveFileDialog1.FileName ), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); + return; + } + + // begin generating html + Cursor.Current = Cursors.WaitCursor; + this.Text = "Snap2HTML (Working... Press Escape to Cancel)"; + tabControl1.Enabled = false; + backgroundWorker.RunWorkerAsync(); + + } + + private void chkLinkFiles_CheckedChanged(object sender, EventArgs e) + { + if (chkLinkFiles.Checked == true) + txtLinkRoot.Enabled = true; + else + txtLinkRoot.Enabled = false; + } + + // Link Label handlers + private void linkLabel1_LinkClicked( object sender, LinkLabelLinkClickedEventArgs e ) + { + System.Diagnostics.Process.Start( @"http://www.rlvision.com" ); + } + private void linkLabel3_LinkClicked( object sender, LinkLabelLinkClickedEventArgs e ) + { + System.Diagnostics.Process.Start( @"http://www.rlvision.com/snap2img/about.asp" ); + } + private void linkLabel2_LinkClicked( object sender, LinkLabelLinkClickedEventArgs e ) + { + System.Diagnostics.Process.Start( @"http://www.rlvision.com/flashren/about.asp" ); + } + private void linkLabel4_LinkClicked( object sender, LinkLabelLinkClickedEventArgs e ) + { + System.Diagnostics.Process.Start( "notepad.exe", System.IO.Path.GetDirectoryName( Application.ExecutablePath ) + "\\template.html" ); + } + private void linkLabel5_LinkClicked( object sender, LinkLabelLinkClickedEventArgs e ) + { + System.Diagnostics.Process.Start( @"http://www.rlvision.com/contact.asp" ); + } + + // Drag & Drop handlers + private void DragEnterHandler( object sender, DragEventArgs e ) + { + if( e.Data.GetDataPresent( DataFormats.FileDrop ) ) + { + e.Effect = DragDropEffects.Copy; + } + else + { + e.Effect = DragDropEffects.None; + } + } + private void DragDropHandler( object sender, DragEventArgs e ) + { + if( e.Data.GetDataPresent( DataFormats.FileDrop ) ) + { + string[] files = (string[])e.Data.GetData( DataFormats.FileDrop ); + if( files.Length == 1 && System.IO.Directory.Exists( files[0] ) ) + { + SetRootPath( files[0] ); + } + } + } + + // Escape to cancel + private void frmMain_KeyUp( object sender, KeyEventArgs e ) + { + if( backgroundWorker.IsBusy ) + { + if( e.KeyCode == Keys.Escape ) + { + backgroundWorker.CancelAsync(); + } + } + else + { + if( e.KeyCode == Keys.F1 ) + { + System.Diagnostics.Process.Start( System.IO.Path.GetDirectoryName( Application.ExecutablePath ) + "\\ReadMe.txt" ); + } + } + } + + } +} diff --git a/Snap2HTML/frmMain.resx b/Snap2HTML/frmMain.resx new file mode 100644 index 0000000..06b48cf --- /dev/null +++ b/Snap2HTML/frmMain.resx @@ -0,0 +1,1539 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + 565, 17 + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAACwwAAAsMAT9AIsgAAAAGYktHRAD/AP8A/6C9p5MAAAAHdElNRQfWCQwUMiMbTab0 + AAABFUlEQVQ4T2NQ8GpfDsT/QfhcDANRGKYepBdkwP99l179P3Hz3f8/6+2IwiD1IAzSCzegaP75/z9/ + /iQKg9TiNODRo0d4MV4D/v379//Lly8EMV4Drl+/jhcTNADdNmwYrwHEYJwGkIKxGpDZs+F/Us0UnBgk + P2XbbdwGJNTN+b9r167/R48eBeOHDx/+f/78OTjwdgLFY6tn/i+Ydw5sCFYDEqsmwTWHhgeDMSjuQfyd + O3cC5Sf/L8RnQFI1xACQzTADYAbu378ftwF9K8/8n7HjDtgAkOZnz56hGHDo0KH/mzZtwmlAI8yQZKAB + jx8//n/t2jVwWMAwyPkgnAwMyKL558CWwQ0AAZghMFvxYZA6BG5vBAD22vINLxWTHwAAAABJRU5ErkJg + gg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAhZJREFUOE+l08tP + E0EcB/D9C/xXxCAvHy1oqyfjzZOiHkSgEFRATcTEELhoRYWCgPSABw4SEw8cwAd6UqOlbOm7xdqE2IBN + DLS0tLutX78zqxSJHBo3+WQns5nfY2ZWAfBf/jlZDmVp9PgL1XEUi4OHJDH2PG5Y4jy/Wf42ZlG8wriV + TkiKWIDCMrAVMmhRLAxUwf2objtoyWGZgMGD2wHEJLb8yHsuIKdeRDE5A2TDQC5iyEcZlAkEnRCHOmyC + d8xaWQqQ/YS8v4XayCbHGunBVmi+Zmx8aERK+HgOuZUZWcX7B+aW3wGOAOl30CNXoUe7UIh2G5avQ4t0 + wjdhwWd7DVXDZa+C6/5BuB/W/mklyQDcg805Lu5EymVDeqENabfQzsUnsfbyjNFKNkgB8suWmYVBTOAm + moD1aQScIlN1yb0afJ8/Cz3cAS3QyraakfddpiYUYr3Ixp/hdX/tnKIO1yMTvIvQpAUofuFmMRtPAlqM + bXRxKFrpJo6F8DVgdRKJtz2Y6KhoVDwjx7A6b0PiTTuQeoVijP3HbtBNFL7eots79KAYv8OKn8PrPMVb + pOwTFwnhqdPIRAaAH0/x81sv9RkS/bv0AckRZEJ2ll83Ky6WuF3cDDPPeJqn8QTYGKShveWmsDJ7Cc4r + B87LY/SMWlOiCtVRz5tmglsy72lxiG9Hw7ooXwbgU0GVZdpPxrP77yoPlF9ZpMeGhzZOEwAAAABJRU5E + rkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAE9DSURBVHhe7Z11fBTX+sYnCcEp0AIFChR3d3eCQ3B3d2mBFmmhpUhxdw8SiLsnRCAQAsEDxD1A + oUqBFp7f887u0k2YQNLbey+/z+WPb2f27MyZmfM873ves1m2CoD3/A+j2fie/x00G9/zv4NmY075emId + JdZlgHLXoZ+6DdjbVfl2Sj3lvu9QJd1nqLJyWn3Fn22JnoOVBLeBSrzKIO4PUhLd9VuPwa+RzOMTXfsp + iS69lSRXoU+WJLv1UVK8BimpPkNex3uoJilevIabpZLk1pfbvurrrI+TY3TXSXbXHf+qzd1SPSbFa4ge + 3reLJc/tqDwMbqw8CGr6b0VLEwN/3OuSD0n9OiBlqLnW+681/B3eG+DdNcCfUV2/QMoQJ633BM3GnPLe + AO+mAX6/2fHzl4n9QQPM03pf0GzMKe8N8O4Z4NcrbSe/iLUEUsckI6FXca1jBM3GnPLeAO+WAX682HLw + 87tdnyN9Fl7GD1qR+X1jNBtzynsDZGWATv9xAzwMadbh9xvtfxTxXyRNTn1+p2N54/czo9mYU94b4HUD + JLn2Jb2UFN/GpOG/FYMO9wOb1vzlcsv4l8kTgPtL8Cyy63JjnbTQbMwp7w3wJgM0ek2wfxrRINWvUYnH + oc0iXsQOAh6txvOoQUlPrrUtnVmrzGg25pT3BsjKAL2VFJ8mpAGhWP80BhP4NMx7P7Cx+7M73Sj+GrxI + nIVfI1ot0NIqM5qNOeW9AbIwAOuARNc2SrxrLVLnn8etjpLkWV9J9W+087drbYEHy8gq/Hat0/Wfwlp+ + oKVVZjQbc8p7A2SVAXjvYgAXGsCFgv0bSPKq/9lPYc3wMmUW8OMePL0zEI8vNBulpZMWmo055b0B3mSA + thTq32OABLe6vR4GN3r+R+xw4OfD+CN+Dn680Mzv0fnmJlo6aaHZmFPeGyArAwg9lRiH2qQGqfnP4FhT + iXOuXTvNv0Ha08gewE978fLBOvxyud3LH4KbdtDSKCs0G3PKewO8yQC9KNo/bACHmh8leda78mtEG+CH + dTSAFZ7c7IcHQQ0PaunzJjQbc8p7A7zZANF2tUh1UuNfx74GC8DaZx5faIIXKQuBXx3wPHYmfjjXODU9 + oHElLX3ehGZjTnlvgDdPAVG2NZR7NlVJtX8ZRv/yB4H18UfsGOA3R/yZtg4/hrVCml+DuVravA3Nxpzy + 3gBvzgBRtjUp3r9ugCjb6gNTfOri91s9WfSdwMsfj+PXaz2R7l8/NMWnQR4tbd6GZmNOeW+ALAzgIsf3 + U2Lsmiu3T1ZQIk9V/lvcsa6s3DtTrU6CW50HP19uhZc/bGP0u+Np1CQ8CGzwMtm7fo4KP2M0G3PKewP8 + mw1wqnLRWMeaYY/ON+a8vxh44o8/klfi0fmmSPaqt0dLk+yi2ZhT3hvgTQawVOIdOyqRJynm34EGYPo/ + cj+gHp5Hj6X43swAR/Dz5U7gdBCb6Fb3rZ/3vwnNxpzy3gBZG0C2iS69lNsnqpCKpFL2OV6J6b/K/GSv + Olzmdee8fwb4xR1Pbo/gvF8PnBLGEE1NsotmY055b4A3GUDH3dP1lFvHK2gLnRUnK3WOc6n17KdLLfDy + 4VZGfyCex3+Jh8ENkehexzHepbaS4PreACrvsgGkDoi2baHctPqUJqiYXcpzzR/9MKQh/khaBPweiBf3 + d+LHi62R5FXnIcWvJQYQtDTJLpqNOeW9Ad6SAWiAKJtm2TeAVUXzO6eruKb51cXTe8NZ8Xvi5U+2XPL1 + RSqXgXFOteYRxYCWJtlFszGnvDfAP2sApv7VSR51KHgX4KfjNIA3fr83HVIIMuL9Yxxq5NJ9tKxDS5Ps + otmYU94b4G0GsMzJFGAZ61STqb45U/46pv4ALvlW4dG5JjLv/0TBG8bYU3gjtDTJLpqNOeW9Ad5eBCY4 + d2dhV5kCV8gs+CtuWlWscc+2WuKDwAb4I2EWiz4vvPjhAH4K78T1fh1Q/AWZxX9vAD3vvgF60gBVKXQW + BrCqmDfSunJQig+XfJH9udyz5bLPFr/dHAqpBZgV/KPtqufS/VEpI1qaZBfNxpzy3gBvN0CSqyXrgKZZ + TgNc9m1IcK2NX660x8tHu4BfXfAsdr78iRfxrrV/irKr1jDa9nXx3xtAz7ttALn3N9QBVhWHML3j0Xn5 + E+9SFn0u+DNlLR5faAkpBinygihb+WOQNlqaZBfNxpzy3gBvzwCJ3E9w7vFaHXDTqkLNu2eqpt4PqI/n + MWOZ+s/g5Q978XNED/moF9H21T3v2VQ11f01URstTbKLZmNO+f9jANn/Czk+2bWvCc/PnezaxyTFk+dn + OuafM0BvGkA+EjaqA6wq5o48Wdlf91FvT+DHfcQKv0eOQjqXfFzjP4yyqVZLS3RjtDTJLpqNOeWdMADf + T/EaaJrqMzhfqvegMqQVxR9IpqX6DPsq1Wf4FnIgzXekbZrfKK80v9EeaT4j3FO9hvhStKsU2ivNd5QH + 3xM8eZyDHE+2U9AVFHtOslvv4bxOZ25rcVuE4ufmfrYNIF8SzVQHrI5zqYWfLrXCy/vfMvpP4HncfPwQ + 0hgJrnVAcafcO0OR34KWJtlFszGn/OcNwH2XXrlJBe73Y9uiZI/+hyhcQFrA+IS0wMlP7gdN+/N+yCzc + PzcHD86xmDr3OR6cX4AHoQvJIu5/jvtBM3A/cJq6lde69xbgoQpfn/uM781iNE5Guv8EVuNjkeoz6iVN + 8TTVa+jjFI9B15Ld+jkku/fbQNEnpHgObsltMWKalQGibZvrDGBVsVeUXXWK3YhLvhms+I/gz9SV+DGs + rXzUCxZ91lpia6GlSXbRbMwp/3YDMHVS7A9IOw7m/GT3/qcZaZGp3iOfpPqN0wmoivcF+RIPLhpxgW2C + +p4g4i/UCUvx07lVjXGe7WofOu7TNOmBM5B+lsecna7byvGB3BfOTlVRTRQ8m/3IsVNe8H4eJXsNDaYB + NtEAI5NcelcmZmIA+Qej0bbNlJvHypW9Y10lJs2vPp7eHcC0vxMvH27Gr9d6IdW3nqz371LYssYiR0m6 + P1OF2ypKqmt1JepMJSXeoYoSZ1dZU5PsotmYU/49BhhkmuwxqFqiq+V0cibZc2hqqs/ol+n+k/Qi6AZe + xHt4gUIbxFXRCymiqsLqUV8vpFizkUpB00KYHaRdzg9bouPiF0hj1kijoGm8TpocR6HTzk5RSQ3QkaZe + f64us6jZ5TOk83VawFSk+k1Eiu94JHuPAu/7aZJb/zAaYFWSi2WnaJvWBW+fqGCXqH7U2wl4uAp4vA1P + 74xiNmqAOOdauHumSs+7pyk2Bb97uhKFZ7F4ohL3qynXrKooKyZ8rNw41UKxXVNTCT/aRFOT7KLZmFP+ + MQO4DzJLdB9YN8lzyJJkrxHnk33GPEvhYKYyAtMCZ5HZZCZfM9qC5iL9HMU89wXuS0S/jRDZLkI6DZNK + gdND5ql9pPlOQ7LraCTbDkSyVRckHm2PxBMWSHLga+8x6rVTgmYixX8qUvwmc0tDBPH8YBFcD1+nUni5 + 1xTfSX/hpyOZ+8neY5HkOfrlPZtWD2Mdq//x+GIzLvnmMvq3c96fySVgMyS5y5Kv6vd3KHrkKRFdvgpW + X0lyaqWsmlJRCdzdQQne10kpXSyfcvlEX2XxuHqK/cZOmppkF83GnPKvGWCgkuA6oBQNMDPZe2RIqv/k + P0TgVAqeyvSsIqKr6NrTZNApfPq5Ra8LbQwNIjwIXczIXsoUPQuJp3ogbkcTxK2tg9RvKiB5eTUkflcX + iasbc9sQid/URuKy6oj/sgwSPi+M2OXlkWTdi5FNE7LPdCH4c1X4tKB5FJ4GUYWm+LJ9ZQAxw0SKr8dv + GhI8hiHKpob64c7zmOGM/A14kbyIRWAHGqSuFH0+149Xzh3n2FgJ2d9UWT2thpLCaSPZuZ/y9fhaiv/O + jmy3UKp9UkC5cqKXsnxSXcV5cwdNTbKLZmNO+XsGGGhK4dsmeQw5wnT5OC2QaZeDmsqoTDnLiKMJMpMq + x4QsIIxkRnT6uQVv5D7n/vsXliDFaQRiNjZA7GKK+nUdpG+ywIMDY/DoBCPv+HQ8Pj4FPxwagx/2DsPD + XX3xYHMXPFzTAg9W1ELCrMK4MVrB3YUlkbivA1I9xtNccg/zKepkijvhL5GN8WH7KyYhidu7NvWQ7FUL + TyMtmPqXs/L/Gr9dp7n86iHBpTbOH2y9cNP8hsrjs8OUc0d6K8sn1uJ8LwbooyyfUFMJ2NmBBujy/90A + A3LFuw4YmOg5PDDZn0WTRBLFTA2cx/RKof0ZUUYkyzaA4jPa5DghnSZI57ybEb3w8l4IK/yLizmwMxG9 + siqiZpdAynoLPLKajUc2i/DDKc7dhyfgPgVP29oHqRu6IGV1K6SuYAZYXA1x80oianphRE4qgNvjzHB5 + hIKwwQrCBym4OsoMd5ZWQMLJXkjm9JDsYyS2QXxvmf+N8JmCe/btOL9Xw8+X2+Jl+mc0wErO+0OZDRoj + 3qUGEj0skeg9CfecBl9I9Rw0KvhQ93xLx9WkAfr+/zfAskn1FN89FvmSPAeNp/DXkwOmIZVCpTKSUwIl + kmYgiSkyyW+6EfKa83PAbM7BnyMleIFKKtNvKgXOgLS9aqehLixCsvtk3JheBNFfNsDDExTcivP23jFI + 2TYQKRt6IGl1BySsaI74pfWRsKgqYuZ8grsTCyFimCnChii4SLFDyUXuy+tX0Aih/RRcGqggdldrJLFI + TKT4fzGeQv5FEqeDWBdLRNlXxaPQxniZMJrif40/Ysfj8YUWSHSviTjXDsxwLExZ40jNkcwC8oZt/wj7 + 71sNjHfobfb/2gAs7EwdN7bvf91m4OUUKahERBE+aD6S/GfqhTYS3leQNmYDyQqq8DSAmCArVANw+hBo + Ain0rs4qgduzqyJ9P9PvpgFIWNMN8d8yCpc1ReyiOoiZVwnRM0rizoSCuD4ytyr4OQp7boCC8wIFfhPn + etMEI/OzsBuLRE4Fid4UX4XCe+nxnox4zxGc22siPaAOnt/tDfywCEiZzkzQnpmhDmKdGvNZpzKbzKLZ + ZxCOCTNhEvtK9RzGorC3f7Jz75aLx9RQ/Hb8PzGA3x4LZdmEujTA4MaxroO95cMWSc0pwRLxnzGt8yF9 + p+qENiLRZyrhfsAcJAd+ThbotwLP0yAlyMB8lVQWfQnO4xHSLw+iv+mImOVtEfVFI9ybXxN3ZpXFrQkf + 4eqIArg0KDcuUPCQPgrO9lUQRIItc4Ac38cUsTb9keg7GQkU/BWeerwmI9KGUe5RA0+udwDSZwBps7jf + jYbgks+pDo8ZScFnq4aXAEhkvZDgMRbx7mMQ70HcRiLRdeAzuzUtt4cf6VIscG9npWrp/O+uAaKd+ivh + x3sUddzYYVOa/8SnkuJTghcimSIl+8/SCU3xRehEdV+E14vvywg4O4/Cvll0AwbRjUllHRDvNAEBvfIg + cnplRE4phxvjPqLg5gjqoSCgO+mpwJf7/r24/3fh+X7dzRBnOxiJ/hQtg/jj1GeJce6NWMeqrPJbAMkj + aYDZeHanr/rpX4JrTYrch+LPUcVP9J2inhfvMVonvrtsdftxJMVzOJ+rb8y5Axa9qzADXLJ6Jw1gKVgk + eAyPfBA8myJJBH/Gh+TyS43uKfrtXyR4SxujXqLgLI9V4fTwBpKlbuD08Bo0gCCRFDi0MIIsOIf3zYXg + nibw7UbR/wloID/i04UG6pMbcZwCEpiu41XxGLke47j8m4F4rwmIsquhfoX7RVx/4P4c/Bk7VP2qV5Jn + LdYF7RkMMyn8dB47niKPzsQoxLn9hRhBrSm8R708tarN9mvWvQstG19HcXoXDPDVhDpKnEv/Qvcc+29N + 8JrwUhehC1R3q9EtIqtC/yV6AudHVXwOVlLAPELhAyheFiTKVjUAj9WCppCpI0GuwZXDzR2d4dDBFDZN + FNg0U+DYVoF7JwVeFM7zbyLnetNU7h0VnGlIcy2qyWtPU0WPo/gJXhNpPpneZiPKoSlSfGTJ1xV4MAMv + E8erX/aQj3rjnJvox2QqhR6DWFVkim5AL36sqzCSr8Vkkzh2MoaTcT9gPNJ8hl5YMalO9XciA6ycWqd2 + qs/wiwlSxDF1J6pCcGCkCDKGc6IOeRgaQ9JfJqFVsf0N+xRWUEWeq5IYMBcJbMvIHMRzKoljv3EUIY7R + l8DCKsp6MC6tbgGfGZVh17MQjjU2wZmmClw5Zu7ELRuIadwouFt7BQ6tFZxqrOBoTWaBSWUQ50PhGZVx + kvZl/mZtk+g3D9HOvbi0q47frrYFUseRaXhyoxvuBzZCvGtdxHownXtMVoXXMRoxKqPISB0UXtrjPPks + EjAUP15FAkeKzvG4Zds/7eaZ3t21NMkumo05Ic6l34BIx6GPJfpEnHhV+ImqyH8JrseDAsnD+HJKoHCJ + /llBsdmXMdK3Kj7fU1GF5/WYRuPYt4huEF8GLV4GjoMVbzscidZDkXCkNyLWtcep7h/hQA1mhZYKnNvo + cNFvXY23Iji3x2mY/bUU7K2q4FBdE9j3KYpLa9qxb4PZKAijPoHzeILfbIpL0Rxq4nFoU7xIGMrUP5vV + v6X6DzmT3GvQGN2Zzserka2LcIr+Cp3wMS4jaALWATJmHK+MgSTjqhtfWXWkeA9/uufLppO1tMkOmo3Z + 5fDXLb5I85/wpwgU7zODA08hPDkw6pY3SxJJCknznIo0EZ4CJxiRxIhJJkm+fO1LYbMDj0/wmcVrTOGA + TyATXyOOgxV5uD+uLemH6ws64cbkCrg+9SNE7+8B90k1sLUShWUkH2dEn6LIp8lJckIinOl9X20FWyvw + mPpmcBpRAee4fLx1xJJpngYOmIpYT7kGzU7x42XO96ERSZRDMzw4Ww9/RvVi6p+Fl7HD8HNYK6bs6ohx + aocoNwrHFJ/gRpFdKDqJo+jxrsO5FUZw1TCOBeEU9fkMY/nX2Brg9fnswn2/kdi7uCnXl9o6vQnNxuyw + 9bPGmx4GSUrSR2CGm6NLSTKJolMvcK0fwrXtbWaJxwELkUIB033n42e/z5HkMwcx3jOQzHnzMVP/fTGD + H7OJJmIACk8RYj0YRRwo3dYIiS4i9xTtMB5ulpVwkEIeZ9SfpuCXFtRB+sVFCFrRBjsb5sa6TxWsr0h4 + zAbZL69gY2UFu5vkhcfU6rhzehAz0BTdXM+Ii3Vn2ufgx/uweOOzy1b97IIBEOPSA0leNfD7zXbAwymQ + n2z99WoHPAiog3M2fbFotyf6r/TBoKWHcM6aRnIfjhS3oRR9GK7Zj8VVh4m45joDd9zYN69x32cM0n3G + IlGf1TKgis/n1PMgYBSYCb7Q0upNaDa+iTNr2uS5Y2d5VD7yjGNUx7gz4gSm91cRyNdxbuOxx3ksxvsv + RDvXcSh2uAXMN1RE9/2t8IP/5xy4WfjMvg86OfZAE9ce6OduiQXOA+HO+TTFd45qhARu443xno4Y9h9D + gQWd2BO4n5FYiRyKk8Ca4Y7tOAQsaAnXUdXgN60O7hwfhniZq7kUjTwzDMHftMbZJc1wdllzdRvyXVtE + 7OuNKEeuv7k0EzPHuI1FtKRoEd+LRSxFj1Nh3cEsINe7ZDsVSW7V8Et4QyBlDNf7M/H7re5cBTRCqkdN + rF71LUpaOCNfsxP4qI0VHPbNxC++vWFv9RkGrXdEp3UX0W1TBDptuIJeG0Mwbqszvtp3ECdPfosbrtOR + 6j2acElI8WMFMT/vR4duLO77jxQT5CgTaDZmRcnC5rkCdnc+meg1WhU888CrUPhYFjgpHKA11kNQbkUt + mEzKD2VCAZhNLoS+GxoilhHTysECzc7OxITwjRh16Rv0CF2A+v4TUNG1D/q69IIdl1fpjPgHYgTvWRRe + hKDwblrXFPieWmMweiRL6FNyvCwvz32GRCkgg+YhlnNqtIsIOpYDOZ7Hcg0v63h/ZjMWjvE0diwLrBgO + cLTrGB47mnCuVqcVEZzCS/WuJ8V3AoJOzYaTsz+SbuzmUo9LvgeTOAX0Yx3QTP1WbywzQ7TDKLhuHQWb + jaNx4ehQRDkPws7dy9BuZTgmWqVgkW0CFpyJw+xTsZhyPBZD98eiy9YYtF53C13XBWH+zmNwOrNUXW6m + erF+oPBiSGNiuRJJ9x2OjbPrTdLSTwvNxqzYvaDhNpm/YtwYheqg64hWkajk4HlJZHDQOVffp4DRzpNx + 4fQI+J0cggjHcYjgub1tu6JT8ALMDFuLQdxaBExDc5qqioslitl3gumJZjA5Ug8WpzrCTp0TJ+IHNy6B + OH/GyjVddUSr6EwRy2xkED3WW4+XgVlkhnqfURRfxzijfQ2cxxCKL0bxYCaQ5/KiATwFXotIPXDLaRy8 + 7PYi4noMHv30HM+fxeNJ/Hz8xkyQ7lsbqW7tEO88FEEnJ+D4kS+wdvcGzNhohd5rAmGxLhIzraKx8ORd + zDgciSkHIzFx/22M2XcbI/fcwrBdtzBw+y1mhltosioSdZdfwbD19rA98RXriDE0l6wc5Pl1Zr3nNBL3 + HFjwOvZ9MtqibLZWB5qNWuz+vP7SVM8RiHafpBf8L+GjxRAcmFim9VjO5ck+c/HQZx5uuU+Gi/tobHQd + iq88xmCE2zA0Z/HTkSL1O/sZ2jHKGrgORjl7C5gfagRlZw1SE8quWqQ2qYlc3DY61hIr7Hoi2Hkkknmt + VBpBhI/m1CLXVsUR8fXCx1B0FU+dAaI9puIeBb9HYf/acsC0oPD3KPw951Hqs4mxYuXZVGRfh9Qh8oGN + w/ENCLt8E1evXUN6+gM8/xOIj49DdAjrGbf6cDkyCwOWWaHDVxfQf+NNDN0Rh/F7ojBtP0U/cBsTd1/H + 6O3XMHzrVQzadBX9Nkag97oIdF9zBV1WX0aH78LR+ttwNF8ejlpfhqHs55dRaVEYJqw/ifN2s5DiPgz3 + HIfjjt0QMljdxjgORsQRi4R2dYpW19LSGM3GzHw7ocawFLchrGAnIopRF+UygQM0nvsT1cHVDTjTNEnz + nqsKv8DWEn2YPgf4LcTgwCXo67eAzEd3RmIbRnUtu9745HR7FDjcBMr2qlC2VIeyjQbYLtAEO2iCHbIl + 2/nejmow31sLHY+1gpPDYKTRBDGMTIns1/DUw30x7F3WIn8xJmuciOMoRhIjX0ztMY3w+TIwRQdT7kWH + xQgO9EcMBX/6/BliYmMRFh6Oqzei4enpjaO7F6P6VA/0//425uy/idm7rmHS9giM3XwFIzZdxrB14ei/ + Jgy9vguDxTcX0enrULRdFooWi8+j8aJzqL8wBLU+C0G1+cGoNFdHlfkhqDT/PErNpSmW+ML28HwuO/sh + 0lbEH4zbNoNw9VR/XD3eB+4b2/rUKlcor5amBjQbjenS8KN6kda970u03xPhXcarRLtNZoSx8vWk8Iw0 + IZ77CR4z0OtYF/T2/RwzgtdgjN+X6OM+FR0YUQ1t+6HiyS4odrQF8u6tC5NtlaFsIBtpgM3VCIVW4b4Y + YivNsFVvDANbq6LAjhqwcRqBdG+uu40FNyLGc7pqUFVUJwqvbt8Ahb/Lwu8eTRLjLiJnFl8vPElk7RB6 + eha8fYNx+14Urt28iZ9++glPfnnCTHAD3t7euGC/AIPmbEfjeeGYvjkcw1ZfwGDSf2Uoenx1Hm0WBqLB + bH/Umu6HqlN8UHmqDypyK5Sf6qtSYaofyk/zR4XpAag4g8w8i0qzAlUqzgnCJzMvoMlCLwSemIh7dgNw + 9eQAXDzSF+cP9WWdMQA3TvfH2hn1//7/MqZ2uYIFzu/rHBLrxgFixAv3KHyUx3REU/DMPOC8f9B2AOpZ + D8RIn8/RxWEMmp8ZiBrHu6LE/mbIt602TDZWgvI9WVtRxzoaYH0Vot9uoBmEjdwXY2yiGTZlMsjGirA4 + 3AbxMr/LvbgTbmMECh9Nw91zGo87jmOMGJ0lkSzQBDG4nKuDxaIBih7NwlaI5arguuMEuDvZ4nZkLNLS + UvHs2e+4GxWNiKuXEXLpBpzP7EUMl31Nxx1Eg+mB6PdVMCwWnUXL2b6oPdET5Ue6ovRwV5Qc7oJPRrqh + zGh3lB3jgXJjyThPfDreC59OIBO9UH6SDypMJlNoClJBb4wK02mMGWdRckow1qxfgmtW3RFyoDfOHeyN + 84f7IPRIb9IDl4/3eNK3den2WvoKmo0GdsyruzrBlfMLB/OuC9O/+zSKP8MIRpmee+SR11wsP9EDlY92 + Q5PjfVH5UHt8tLMBzNZS8JXloHxDvisPZZVA8VeTNRWIbA2mEIPQDMI67msZhG2f7qqDm5xqYim+3Fe0 + wKiNYrF4x3Es7lDQVwIzujMibXocRqrbe5xSoih2Rmh2FXmPBajUP66j4WGzHZev30ViQiKe/P47nj1/ + jpT0dJy7GAFXBytcOjUCSS4D0XPaNhTq7YIao13w6RAHlOpvh48H2KPUIEeUHuyE0kOcUGaoM8oMIzRD + 2RGuOka5odxowV01xafjyHidMcrTGOUneqvmKDfOBR+PcMS3K2Yh/EAHBO+1wLkDXWkCcqgrM0FXXDne + A7Zr2wSVKJSrgJbGrzUYGNDm4xZRNn2f3GWVe9dVBoOCy2C7Zc0PnP/XHe2FfBur4aMd9ZBrHQVd/gkp + A2VFWZ0BvvmURYWelTSCCvfFGN/RDKo5uBVzaBqERlhTHg12NsQ9ihSriq+L2ns0aaQ9RbUfiTsk0p5i + Z8Ftvi/cYfqXT+eiJLO5GsO2TMjHtUE2SxEUegWxcYn48eef8OeLP/DgwUPcvh0Jd+/zOHuMWYlLvDSf + 0Ti8YwEKtT+CwhanUKL3GXzch/S1QUlLG5TqZ6caojQNUXqgA3HEJ4MJTSHG+CSzMZg1xBhlR3E73IHG + OYPSQ61RauARHFwzEBf3ddCJT87TACJ+qJ6rJ3ti9qAqs7R0fq1BKFHIzNxhdUvvWKmW3aYRRriK7Gtz + h8S7z0YI59sPviwNZUkJUgrKMu5/RfG/ogmEr/WIKZazfTlNsUIwNgi3WRlkNVlWCqP3tkU6a45ot6kU + b6o6PUXaZS367VfohFfF109pKhRdxyRNYrjMCjs9nfO+H6Kj4vDw4UM8/+MP/Prbr7gXFYXAc1fgdGIz + M45uKolynoAUrsu/Wf4l8rfag8Idj6FEdxqhhzU+7nEKH/fkthe3vU+jJI1RksYoZWlLMhmD2eITZosy + zCClB57GJ/2O0zxWNNFR5O96CL0mfkXRJfItOAV0RYiIr0cygWyvHO+J4P1d71Qrnf+13xTM8MLAmK5l + hsRy7Sqi33Xl4GaTKJLKZdiOw71RcgEFnVEMyvSiUOZ8BOWLkjSEGEPPUmaGpdwu43aZmINbQTWIGMPI + IGIAdQrhdnFJfLCsLLxsR3ItTFMyO0nKv03x38YtuxFkOG6J+BTpLoW/68JVQgZYOGbiHpeDN+xGwcv5 + OG7djUFaehqeP33Kuf8ZEpISER5xHfa2JxFhq1teypQpyJIzgWv1td98ho/brId5k134sOMRfGxxEsW7 + 6ijRjXQnBlOoxiDMGCX72KNkPxtmjZMo2fMwinffj48s9qBQ253I13YruoxcDNcdPXHxYGcKLAbQG0G/ + f+FwV0RQ/JuneiHOyRILR9ZYnFnrDC+Ejz/Ilc9tc8egWK5zJarvMLqyS6R+m8KC8BYH98TxgfhiWwe0 + W1oduafQBDM+hLKIRviSfMHs8KXA/cXcLhZjcCsspfhiDDGEZBA5dh7Pn1UEZZdVxIkTg5DMGuQOBbvN + QvOWKm5WiOgjcFOwHc7jWRdwdXCHUS3n6+BrLdTjpPgdAV/79bh89TaSkpPx5MkTPOeyT7LAjZt34Ozq + jZDTs9VPDCMpfCSnTQN3nMdx1TAGrgenoOuQJchffw1y19+CIq334sMOx1C880kU63yCHEeJLjSCGKPb + GRSnIYp3t0LxTnvwQavNMGuwHnkafI8PW3yDDgPmY83S4Qjd3xkXDnVGEAUPpuCqCYgIf+VET1y37oUb + RLaRtn1wdnenqEol81Y01juD+MKormUHxXKdLuJHMrr+DneIZI8E9pHCefoWB3L/4Z6o9xnT+LiCzAjM + DAs5RSz8mIbQoxpCzKA3yFweM/kDKBM/QIEZxdH66xpYs6crbjC1JrPgjHSeSGFHUVQRNiuG/wUjP5LT + k0FwOV/HhCyRLBHtMgLBp+cj+Hw44ln0/fbrz2rk//zzE9zlEtA3MAye1t/gnuMwVfDbjgIzUibkix7y + N/9jm6egQ/+FKFhnOUyqraaom/BB890o0uYgirQ7jKLtDqFwqx0o0HQ98tZfBbPqK1Ck4UIMGjYGW5b2 + gNeOdrh+uBVunmiDiCNtEXa4HYL2dqH4XWgGCm/VA9dPUXwjrrEwv3LMApGnumJc93KfG+udQfwP8pjm + OrmytbN87h3pwoh2oaB/C57rxNRpPwYe1kPQfHcHNNpaFxdthmDsivowGUYTjCaTi0CZqmcapwp5LQYZ + kR8FJhTHmJWNsHN/dwQzymWZ9yPn/DhOM7cZZTc5Bdy00RJd0Ituo4fRH8n5PrvCq+/z2Gjnkbh4ehJ8 + vbwQHZOAHx8/xtPnT/H770+RRDNcCL8OJ5v9nF4YMDTXbQdt8W9zGSrccR6LJI9RiHcdCfsdozFu3CRU + bjkHBWt8ibxVlyBv5YXIW34+8lWcgwKV56F0w5kYNWIEPDa0R6xNE1jvm4LFO45j4hYv9PrKAZaLtuDA + 5tGIONqZ83x3neDWFFxENwh/tCvCmSWEm1yOW33VNKhIXtOPNQ3QvHqRFldPWv5212UyBZxEZJsDnCdT + nEmcY8fghohjMxKXzwzHrl0dYbWvK+6yQo+hmPt3dUGr2RVQcEQRFBxWFIWGf8j9oig96WM0n1cZs9e0 + gPepIXD1nYv155dgjO9UtDnTFWOOdUQIhY9k3zfY780zvIaK7AvDXnFDj2SJSCe9qLKVFO0ocP819O/x + mGin4QizngBvdxdE3onFDz88VtP+86fPWPX/gGs3bsHNxZWFIYtER041DhSaz62D+/LaiFssQG/aDsX1 + 0/1xg3NyjH0PxNh2Updvp1d3w/rPumHDgi7Y8FlX7F5qAafVbRG8uw1uWLVG5LFW2LJqKiy+uo5uS86j + wQSuFAbZIF8Pd5To7wz/g0MQad0d11jtG7hyjMKzNrh0oJNKOLlCE5zf0+FJvQqFOmoaYM7Ayt/Gu7NS + dp6iCpkzJnMQGJkU/QajTgygM8EIRFH4e3aj9a+HI4ZRIWJctB3DrKAjjPtXOHB3KFQq1/O3ue13chhK + bGmjqwc+Y4ZYWBQbDnRGrO0o1QAGkbNCjKgTXRjPKHwThvTNudthBMJ4bTfHE7h26x4Ff4RnUvSRX379 + Vf3Qx8c/BIHWi3DPYYgqulxLB8VWBSesQW4w612z7selWC9cZURKVEYwWsMojs/W1vDe1Apnt7ZE0PYW + OLeL7G6FkJ1tEMxlXeCeTgjYQxH3tcWBb4egjMVR5Kp8EErVAzCrZUVOokrXnTh3pC8LPS73OO9HWHVn + tHfBpf064V/B15d5zTtnemJMt0+/NFcUswwG+DC/aVHr71qflc/6bzkyih05x2ZA2jSg+PL+DZvRuE5R + dIww2s/IDRpBjpcMc9c5I3fYJu23+b7s21sNwJQ1DdF3aTUM/7omNnP+i7AeihunhzGS3gCvc0tNxxOI + TuBbBmjSjIzLCGuFcBav9qf3s7q/Q/Ef4Omz50z7v+MpDZCUkoLzFyPgZbORqZ9FpUF0ezl3LG4wQ10/ + Q9FP9VMrcBFbEPEjyKUj3Sh8O7ivaw33Da2Z3tvAk1vBa0sH+G7vBL9dnUkXBOyygP+OLvDbSUEPtIfN + hn6YOXEmLAcswuDBC7B49lSc398Xt5kdI473QPgRC4RR7DCKnZnwQxbqMVH2fbFoZI3juRXlowwGqFo6 + X6Pzh3r+KKnyJgfuFYweHWzX4AYf/hoH/BojThMKoiJzMQfpJsVV+3V4O1E0QQJrint2YxDDVB7NyBeB + X/WpwXVmIFVYVfBM4hpxU2WsnnF8jtGcOoYg/IQlzhxdj3Nh19QPeER0g/g//fIzrt+6Az8vZ1yxocEc + mNZ5b5LZrp0exMq7r/rJ2xWrbiqq+Ce64zKjUtbjvjs6wm1ja7iub6WKr6MVPDe3gc/2DhSa4r+iM/xJ + 4J4uuHi4m9rH3dNdEGffBVE2zIL2nZHg0ImZjqn+aDdmlI64uI/sz4gY4jKnA/W+eD+3bXrh0LJm54vm + M61R0Fwxe2WAQe1LT7ptN1gV6AYH8BUcSGMMxrjBQZPBvnp6KNEWw9B+XVI2+1KFtee59uxLRfYzcpPt + N9VjiZjrNM3FqL9mzb6y4Crfv8rtDV7HILpBXF106iJUNSAR00rf6jFyDT7HNetBjNLesDvwFc6GXMbD + xz/iD33kGwyQmJiEwHNhCLb/hlPZQF5zAAXuTXFEIAt1oGVfBlrEDz/WTV2W+ezoBPdN7VThBTeBwnvQ + DN5b29MYnTLgTwMEs7K/eESqel1fshUT6PrXmeuKVU9cOsjqn9OFFpc4FRjuR3d+Ny4Le8B2TcvkEoXM + OubPpRRQxc+lKPmmWlbYGePCytpBotogUCb0prhO16sC6wc+SyjeDc7tNyi8Zn9GGMQxGECmiqun2Mcp + uUYWsFBUoQnl+FcRLeIyHavoxRbRbzBdG3PdZpQ6pVw5ORDXT/aB4965cPcNwX0WfH88/zNj9P/8My5f + vQVPJytcOtZLLbJUwfWiqwMtnOiGS4zI4H1d4L29I9w3d6DgbeC6jqIbkJS/pR2jviPNoUdSPyM+hMu5 + S6rwuv4MfWdG0r1E/IW97QkFN7Cngxr54UdpSI3zrp/qAY8tbZ+WLpJrcD4zpZhqgAK5lJJrptVxkW/B + XKcA1+1e54ZsbcdxsEdywIapRFCgzOjeY8TyuBt2jLYM/TBrGKF7PxM0wTUKI30IEa8xROWKymCdySQN + i8AyBxuwNYbvC3IcuW7LpRPv9fLxQSrXTvaF94HxcHRwQ0JiItLS7+PRo8f4/alE/1PVAAmMfi/fs/A/ + NhVXjnRQ0+5lA4z0KyTscFc1ZXtupfCbKPxGRv33jPq1LXV835JR35ZR30E1hwGJ+rO7O+Mi1/HSlwr7 + lWsYY2gLYyEcyqW1FvKe8bGZucqpwGd7+xc1y+SZRgOUVA1QvKBZtVPftrh523E0rlHkaxy0jFD4M6Nw + mQJcPjGEW4H7mVHfY2TyWO1+3k7E6RHsw3CNzAzOwFUpNim2ZKTrFFgbFqcquv2r1sNV0cOPDUS4laTx + gQg5PgqnT1ohKiaRa/2faIB0JCWlIJ1GkKr/VxJ2+QZcrDdRZFbljL5wWV9zQCVaQw9aIGB3J0YWRd/U + nki6bwNnLmedVjeHy9oWqvA+25jiWdD5MtJFeK9t7eHPJfJFFmjSTziRbVaE8bjQvR1xfld7nN9tBF+H + MvrDpPrXOM+YCGYBv50dXtYpn3cmDfCxkt9MMed80MJ+bauHsgR6TRQu0SJOyaBx0I9ThCwZzIjknMzj + X+sjW3AZqEalXOdNSLHFKptZ4pXIvKYOCq0Fhb8mxuL5IroK+5HscZlTgPXBLbhy/Z6a7n9mqpfov3// + AZJZ8YsZ4hOT4eLigsBDfMYjXFJxIEMPWMhHq4z29nCl6IKIL8I7rWmpCu/6fWtW8j0QemwoLpwchYvW + YxF2ehy3HCMaV757ePPMAApPI4kJmEFeQ4Tj9sK+TjrhNbjI94yPfRMRx7rDY3PbF7XK5ZlJ7T9W6IIi + 5YuZ92Pjs5ucF69yIA1EnGbUc7DDZeDewhVG1lWKcdVmbIY+tBCxM0AxJcJFlLehTi8UVTWaujWGmScD + jHgRns9wiaIbkOxxxXoI58PecDu6HEEXbqmp/vmff6if8//88y+qCWQJmJqehqDz4XA/upCVdnt1bS6R + 67KpLZwZ1S4S7cRFhGead6TwIr7PNhrkwAA4bO6OPYubYs30avh63Kf4euyn+GZCeWz7rC6s17ZDKMdO + vrNwldOQRHDYYS7ljGGRd35Pe5zb2Q7ndhnB19J+ke+/ds4bkOLRbm3zlzXKmM/k1K8aoHjdT/NM8tne + 7oVaeKkijWY0DudgDdIzWAPde+GM/gjO93JexBlG8ZnxjKoJZCLC9ci+EMH3rp6Ra+iIODMW4YyMMEbI + pWOGa2mjM9kI3bnSxytGZeCaoB6jqyPU85nuw47qvi4VdqQ397lm5jzrv6kpdi3qjri4BM6EwLM/nquf + 8z+hGX7+5Rf8+NPPiLwbA7tTeyl6J0Y4RV5P4TdQeM7vgjOFd6TwDquaq4gJfHZ2h+26zlgx/lPM6VcI + 03vnx5Qe+V9O7Frg2QQysVuB51N65Hs5o1d+zOtfBFvn1UYo7+/aSUtV0IsUSqaFUEZ2CMUOodiZCd3b + ST3GcGx2uXaiJ44sa/hH2Q9NJhU0N1ENUKzup3knch364oYUR4x6GWwZNBWjyHmF/j2J2ggOtAh/mant + ijXX4LbdEe/WFImeDZDg2RAJ3o0R71Wf+w1wy47r5NNiBDHLaNx26o9ozx5cojEFqkL/ZSyDcOp1eD8R + 7Duj2PI6c5sOmbLk/LAj/TigvXB+nwXOc8AusEC6oI+YC/s7Ye/s6visZ1Fs/6wN0hPvqCb44w9d9S8f + /qTf/wGu7p6w2TQQzt83p9gUXsQnzutaw4FzvD1FFxxWt2BbK1b0Fji8vCXm9i+MSd3zP7dsnj+iadU8 + h6uWMl/MqXYK660ppQqbTatV1nxZy+p5Dg9pmz9ySvd8WDyiJPx392Cl3pPTC1cDTO3BO9rqoOCGfWmX + 59ASNzvIh1Nrplb9pUgeZUih3KZqDVCsdrk8Ez02t3sha26JRImWsKMSNVkTfmIEo3s8wk+NozhDEOXY + Fj+FVMYfd2oB8c2BpLZAIkloBcTVASKL41loXiS41Wc2GI9bZ3rj5a3meHm1Cn71y4VEu9JcPvXX9y/X + 5/6xATSZLCfl84aRqgkyo3tPJ7zUEGFHBiB0f0+cYzUetKM9act9Lo9kvaznEqPfZmltfDW0ElaPr4m1 + I8pg+fCKCHU7QgO8wEsa4emT33Eu7Cqs93xO8Zupka6L9taq4HbfNVOx/04X9a7yiR7rgdOrWqviD2id + L6pSCfOvOchdCuQyqfFBHpMyhfOaliSlZFuI0cf2ckXzmbaqW9585ciOedO/HlsawXssELKjHYK2t32N + c1LpH/jrOS7I/tswem41uxzshqm9i98tmtek8wd5TIvIErBYrbK5J9p+1/TFZQ74RQrwRpiuw05wmjjd + H1FOLZHiUw9PLlbDi7sNgeQ+QMpwCj+QoncDolpT+HrA7UrA9TJ4fiEPfglQkOJRiumuOxKPV0XyHlMk + 7lSQuD8vly69cOHoIKZqEZ9LtFOcvymyFpJtrlD4KzRAOOf4UEZ6MJdSZ7e3w9mtbRCwtTXF51y5vzPO + cyAMXOK63XVtE6weWx4bJ9fF5sk18N346lg2vBwW9ikOq/UTcT89EVGJD5j698N+TVs4cvlmv6YVbCm2 + 7cqmpBn3Kf7qlqopXFkLCLIKWD+jMro3Mo/4ML/paIpcmQIXIKZE0aJIXlNzGqFE2Q/NBg1rlzfu2JK6 + nOM74Oy2tq8I5DOdkyLQ6DlyxP4uNBZXD8yCTmubo1O9PO5M/7V47bwKd4pVLmk27uiSen9ePsY56AhF + ZhRpcoxrfev+SHariaeXqlJgRnpiTwo/hNthQGwvtnUA7jQBbtYErpUHIj4CwvLhRYgpfvRR8IO3gl+4 + feCdD3dO18XVw20Rsb8jHdoPoYcHq9eRuuIKxb9yiiKrW/2+QXgxBuf3sKOWOLfXAoEyUBTcQOC2Nghh + tJxnqlQRExBJgQE722DrxPLYM7shNk2phlVjK+Pb0VWxfEx1rBhTAwv7FsPykdVgvWsx7LcMYIQ31gn+ + rQivh+I7rm3FqUDEb6MWgMygCGKBuHjkJ4+LFzSZ/EFu008psJmR0BmEZ0ZQihi1F8hlmqdKSZOp2+dU + Vj/MkWcIpJGDd7IA3Kc3sf453ojRM4dwySjnG8YndG8XbKRBa5U1W0fdS/O6pkqh3CbFi+ZT+m+dXe1p + +NE+jMD+uMC58xWHdYRZcYnHqvmRX2kgpqVe9KFM9wOA6O4Unen+ViOKXgO4XA4vL1L48/nwMsgUT3wV + PHKj+O7cEtk+9lDwo6fsmyPFpTiibaqzQOEa+wQjXAR+hbwmJzk9neD0dKwvQg91Z7QzSvhQAVvkr2k6 + 4SXq1Wih0yXyVRg5gsyr8kXJA7Mr4uCcOtg9sw5Wji5P8SvhK6b/78ZW43RQCyvGVqdBKsP6y+oUvTFs + vhGawIYGEOw51ztx/nem+M7rW6up34erghBe48pRC0zp84k7ta1KYc2YARRzRZFPWpXCeUyVvKYm6j7f + V0oWzqXkz2Ui38FQ8popogNfK6W2zqp+I3Q3s5jexJmf4zVYy7w6RhDRWSec5ZRhGBchhEZw572O71bo + QYlCpkM4DRXmTCcXNi1aJK/S9asx5dIvHOjOCKQB9KKHHpKopPjHh3KuH4l0l48pNud0+a27GEvgHtP8 + bab56w3w8kpVvAwrA5wrCgTlwcsAEzxlpD9yVXDfWcFDDX5w0fGI/CimcDXBXZu2uHSSRaV89sD5X4rO + i6zc1S858mGDd/PhtumED9giW70J2BbEB9ccJCLzoc3yWtg5uRwOL2yMNRT/O/LVsPJYPqoitkxviO8n + 1sCOGbVx8svaFLsJzlB4A5L+Hb5vxVVAa50BCJfOCNzN1Coi8BqXDnfBsa+bhRfNZ1ZSIrvix3mVSb3L + K5N6llPWTK6pzBtYUZnYo5wyq18F5dTXTZRFQysrG6bVUtrUKqpmgra1i1b12tDyfrBU/hRSFTfTc2RF + EM0SyHpHguCvcdGPDdtC93XH91PLo2WNXA4FzU3rMPpzqQagA/MWyWvSYGL3DyOCdneh4P0ZKf044Jbq + fpiVzPlcGZzogd/8PmSaZ8TftcDLGy0pen28CKPwoZ/gxbnC+NPPHC+8TfE7xfzJiWnegeIT2b6G/es8 + JKn2xXhNuYfeHAALBPPhgjkYQUyL4mq/za1fI4DtMsdJFArqOUaE6NPivmmlsGd6ZWycWAkbxlXA6jGV + WQiWw77ZDbBjeh1mhvo4NKcaTi9vjNMUXTjD9C/zv6NU/US2bkz7fjs6vLqe8TXlM/qlY2qsm9q3gsJ7 + UsKPdFHC9rVXQra3UUJ3tlMu7GqnhBKKopzf1VY5v7Ot4r+5leKwsml+742t7EP4HMFM+VrPIfx1zc7q + uAQysgM4VWiNi+BP8S8d7Ytjy5tgVKe8jz8pYjaB2ai4iK8agM4z5XxQpkuDfI7u61viwqG+HCxJs7rI + DzsxDKHHRuOGVUs89aUBbrfDi0v18OeFKvgzqBSe+xbEr67m+MmR0WxHwW2JjYI0IlsVacuM8ft6HpD0 + M7noaFa9MhCSzshZVvPqA21qlRG2yXu64zhAnIO1OH/AAs6rGmDTiOLYPrk8Dsyqjm1Tq2PtuErYPa8O + ji1oypTfEIdmVsTJJfVweoVOfNtVLeDAud6ApHxJ93JvIXI9rWuyTaabs7s6HGNm+FR+4dtvS2vFd1Mr + xXejEfJaDw3QlAXruVd9ZtGvAYl2Mb3mmBhg9J+V70+cGACnDR0xy7IgGlYyP8zor8voN39lAPlPAXOT + ovXKm31/4Is6TJXyT4pY8FF8A+ePj8I1q9YUmnN6aFVV+D+8CuEnOxOknKTYp/RwP53bv4U1TUCSjptz + cMUAnRDIatif7uaAgQOlQ/aJtMtAiBhvI/RANzh8Uxcr+xfBkXmM8IV1aIKaODS3AQ7Or8u2+jgypwqO + fFZNTfc2+qi3p+iylZQvf72T+9Flo7ejP+4Rp4i9FGMg770S7/sDPYX5uj634yiiPaP4j8znayHRro6H + YRwMY2I0LiK8mCNkXxdcOz0Yzhs7Y96AwlyZ5L7EYO9K1C+CZDAAU0K+UoVNhi8ZUfrp+QM91ciX5Z6B + C8eG4yJrgfSjufDUiTjkwiOKlnyUKfs4hX8bVm8mXX9c0mEFN/aV4bzaGf7b2r16qL9oqT6sRL06KJx/ + s0Po/q44NK8yvulfECfmVMeBmVWY6mvj8Jya2DOjKvbPqIhdM8ow3TdXl3a2FN2O4jtxzvfayoJsFwU1 + CKHR/2vojz1LwSRK9ff/hPxoxHMRkxki63717RLJRv28hg/HxW8zg4KFoxwfzkJZPtM5tqIFZjLy+7XM + E1eikNkYTvdq5f+aAegKM9YBTQe3zX/dexuLGS7DLqjCy1aP1Uhc2tcEtzYquLuD4h9gyqZo94/pREw9 + kpEUkqzfJun3U8UwetJ4XjqR/Xj2FblNwdUdH6mFjI98Q2ZDy9cQd0sUyqCpyP7bkL+WHemKY59XxYr+ + H2DTmJLYPuETHJxVCdvGlcG2sSVwYG4F2K1sAVuKfoYGcFrXCt5bWUXzfDXLZOd6+mNUwfTCaz2DoDMx + M0rmfjP14c/lmxyr1Yfgvb4FxW+hE54Z8xKFl29LBx3oh7XTq2BKz7ywbJknulRhs+lcllY1Tv0ZDCBI + HdCwoumB3QtqIdxqgE70o4MzEHpspPpp0oUtZRC2Khcuf6fg9mYKuI+CUuD7jODUQ4TbNNkKbJf9NAqd + rt8X88TtpuhbFFxZq+Di2tw4v6Uy01s7PlRrwgfU471O97AyGBkGixX/2+FxLB6lgHRZ2RArLPNjuWUe + rB9UBGuHFMSm4SWwf1ZF2KxuA7s1LdUPfLyZPs/u1Iv+lmudzYSkXhHM6/vmGjRTt/J+AMU/u9MYoz70 + 0S5j4L2uhYqXAZ7vuVb6aaZGfuCOjurfNm7aDEOkw1icOzIQOxfWx6x+hTGhW250qZ/nXLECZsMZ+ZUo + /pv/cSgP+qBMUZNxMy2L/h64h8tBq0EU/HWCj49A6OmRCDtpiQt7+DCrSuPsUgWXaIabGxREbVUQS3ET + 9yhI2KUgZqeCO5v43noFEWsUXFihIGiZgsCvTBG4sgiCNlZDwDZG3MZ2fEgOHgX34sOrW+K7iXMaU/6r + AcoG/kQ9ntHvR1G8N/A+mVXOLK6JneNKYNekkqz8K8H660bqX/M8t8iXNCTiObXIMlPfT5ZQNB0yFbEw + 43wbIv8yd09XhO7tjgv7e+Aip1L5O0QYVzPhh/twidiXqbkfLp9gcX20N5e2vbjS6o5QIvO1LCcDtreD + P5eWfptY1RtxdhsNuZPLvb1d2Vdf9Uux8hsNd5wnINx6BBw3d8W6mdUwo28hjO9qjiHt8/xQr7z5Xmra + QT52pvjqN4C1eLUj6YFpomGnermCDi2pD/lm7PkjgzIxhAXiYBZ7H+CxpwmSHUoheGdbeK2qB/clxeDx + eV64zTSFxxwTOM9T4DrXBG5z+fqzXPD+Ii/cFxeD78py8F9Xkw/VkgJ1gO/WTjrhGX0ZoPh+FEYGWQyQ + E9SI2t6e6bE1vJjSdX2yQGJk+W9igbSdS0oOZgDFU0Uk8omZVl8ZoejcBu1hFhRhmSnlc5Pgfb3hu70r + XDZ2gsP37eG4vgOcuO+yqTNcN3eB+7bu8N/PpTWX1JdOjYT6rWhn+Uepun/OLr+5JL92pv66mvwYFVF/ + eU1+gsdlHOT3DSIddN99CDk6BC5be+Dg182xamplzGZhO6l7HoztQuHb5klvWiW3dfGCpuOY0etyai+c + ec7PTIYXhXKblqxYwvQLSSH+O+nkYzTBYZ0RzlH4kEMDEMxVQsSWCojZmAtxW8wQtKEW3L9vA0+K6Lm2 + KYXjnLSpGZ3bBH4bCQsdf5pE1vABTKf+u3TfdvWnQBKZnmtbwFNS2/eyJXwt7f6MBhlsfw56TvFjNMt9 + eK7R96nv10v65ftqZsh0zhvhvfvzXkL2dmMxbIng/X1hR6G3z6+FFePKYu6AopjauwCm9MqPyT3zvcYU + ge9N61MQ0xmlMr5zeM6XI0tj8chSWDmpPNZMq4w104VKfzGtEkWuiCWjS2PB0BIs6AqznwKYKIJbmGF0 + 51wY2j7PjxYN81ysXS7Xlo8KmA6mhg1Z1H9C4fMYa5sVGV7ISYVzmzbvXM8sbPu8Grh0dCDOHehLx/fg + EqQzUxSjaouIzciSAeV85LG2pU5EDrYP05UIG8AI8xc4R8nrjLC6lz5EFBFIzjXANh+JUkmFAlcCOYLn + +HDKyNCn2i/nXk4BMjXkvF8uSXfL3+gt4bnVAlvn1sJng4phUo+8GGeRiyKYY0SH3E8Gtc2d3K9l7kgu + ty52a5T7gg7zV1i2yH2L798Z1CZ3wpC2udOGtc/94/AO5s9GdDT/Y1Qn85ejOuVSGanH8Fpt62j+J499 + Mrht7nS5Rqd65oFNqpgfr1rKbDmjfQwF78j1fRVG/IfUUP2EL7u81qDLAmYLJ3bP99JxXTuuZy0YUa3h + x0rTm4WHx5rmKu4UT5B9EU4G2I+D9TaM+zBGne+ZLbTOyS6SOTL2y4JJphIWl1rHvxV1mSZf2OyJzXNq + MIILMfLMMbJT7mc9m+a52rSKuVX1T3J9XaKQ6WhGX8+P8pt2pAjttPiQ7/H9TsUKmFoUK2jatXghU0sy + pnQRszlVSuZamhVVS+VaVu4js89FaJ7XR67Bub05Ba/GKbss+y5O0fMTk8xaZoeMDS91WYAXaNSmppn3 + klElEbS3hxr5nhxI99UivBF87cmCTVKubsA00A+mL+dztY9M58tWTPHXoOcQ6ZvbDH2r/XIqYQ3wr/Sr + S/0W+GpMGUa6GQa3yZ3WvJq5VZmiZpM58G0LMOoowifc/4jkI7mLcPw0kfd0mOuR4z9ikVaW413mTcgx + PLY4yU9yUyPBhKh/ScygYQ7RaHwpHwx9WKqw6YgBrXM92DqvJg3QBa6rm+ngABv2PRlxviIA8dHA8J43 + 07rbWv15cr6+D3e2yXtv6uNNqOdwOnFnBtL1rbuvf6VfwzmSjWRZunN+Dc6zZk+bVct1qkRB0/6MvMoy + Phz4vMYi/Dd5XcPs83qjLguY8kHL1Shjtn58tzw4sqQRK+hOcF3VFC6rmsGNAkp0ySCJAFnC98Ukrjwn + Mx7qfK87RvPct8HzvDnfy70Y9+vOOd/7X+zXi88m/Uj9sHxMaVQrbbKF0V5b/oTKsXknRDfmNQ1zgGaj + wI7zMf00aVPLzHN6nwKwWSmfSLVTI9mL0eXNwXojFMGdadnlu2aqaVRknxHqQVNonpNNRCgRyZWp/lX/ + 3Mr15D2tc7KDFw0l2cTQp3wItXDIJ3cKmitNmXrNMw/8u4KWftlFs9EAHV+UxU3vHk1Mo+YP/BBu6zsi + kMs4ibwsoTlkICUyXb5jxjBC0rMsxeQYzXOzA881ZBXjvj247Ptb/co5xEPMKn2u/KtPb5ph7cRqQR/k + MSlFA2gO/ruAlnbZRbPRGGaBkmU/NJvev5Xpo8UsCn12sCjkktBzU0sK3SojIg4LOhlIp5VN4PxdE3Ur + qJmDAy7HqGQ+NzuIUBtawoniGPoV5M/YOe5Xf7zHRgpPYxr6kns23LcLpzzbb5o8ql4mf80C5orm4L8L + aOmWXTQbjeEFzLk0rFyxhOlXg9uaPpEPLny2dWdhSBNw8ERwTw6o4LG+BZxlIL/NiJt80KM/Rj3+76D2 + 35LiUPx/pe9Xx7ZUi0ZVeKP+DDgzE7gxA5zd0Qaz+lf4Iq/J/6gBBF4kb8HcplWqf2K2dnBbk2dfjigF + r600AZdIEkEysDJYjhw4x290A6huZRDlE7nMIvwNJMqlP+P+ZTWhdezbkFrB0Jfcs9rfq3tn+me/YjY5 + 1mdLa9itah5ZrXT+j1gLvDb47wJammUXzUYteKE8OhOYqiaYN+gj9bPvwN3d1PTusKIxB1CHA5EBdmdG + EINI2v5XkH4kUg39C85MzznqW3+spHvjfoyR98RomfsNZBaYO7DiXPkyZ+bBfxfQ0iu7aDZmBS+mM0Fp + s7WD2pj8Lp9rH1/OyntjZwrUTDWBIHO0GwfSnYP3LyORz/7UvhmhgiOj1I2m0Dw+CyQTOdKUxv04rNAh + ZpL3RfjM54kBPIn9N03i65UvWDZ/rnfPBFpaZRfNxjfBC+YpaG5atWIJs6/7tTL9ST4n2D6nNrw3dmFl + 3opGaMzBbK5G7T+BzMUOyxtlQOZu9w3ax78Gj3Ph8Q4rMvYhSNS7MnupfWn1xza5lpzruboplg2r/H0+ + M/V7lK+J8N9ES6fsotn4NnjRPCwMq5X50Gwel4jxIzuZYsXYcozKLji7qzvcZY1OE7hyrpVM8Hdx4mrC + 7uvGsF+uQ/aduEbXOlYTRrVkDznP0I9h/639SJ2Q6VzWCD+3qlG4bn6aILMI/020NMoumo3ZgRfO+0Fu + 0wrFC5oObVfHNHRoewWz+xeF9co26p9LfbZ2gqt8qMIqXbY5gsI5r27OgW8Eu68EirCMUcv07Zqd/ni+ + C7eS5l+dr9KIQjZi383UY1QynSemdWFWsOfUoDu3EWzV8xrDk1lh74J6VsULman/siezEP8ttPTJLpqN + 2YUXNyucx7R44bym7RtUNLMa0Fp5OrpLLnw/vRp8d/ZUvyjhKf+Gfm0zFZ14b0cEkKiTgTeIIAKKKXRi + vX7OX0jKp4AUzJameSUi9+1pIGf2nXUfzBjMOrY0nhyvnsN+pE0MJe/7bWn9cmDbku3fpYJQS5vsotmY + E3gDJpwTP2BdUOfTYqZfdm9iEj+knYKZ/Yrg6NctcO5Af64UenJOlZ9MaUZ0P5nyJiT6DAIYkAJORNA6 + 3hjpXzXP0oznS5/qMVn1wXYpLm2WNlSRPhzlI2H9e4bj5JPMvZ/XdypRKJdS+B3JAlq6ZBfNxpyivxF1 + SihWwHRwkypmTv1bKc+GdTDB4lGfwGF9Z1w4PBBnd/fg/NoaTvIBjJiB0ZgZB67HbZZRBAMiBqNQ69jM + SJ8SvaqIRn2wgtc8/hViGmaHMzxPso4D5361nVkh87EypXltavmiR9Pibd6VLKClSXbRbMwpRjdjxumg + eCFz0yblPjRd2LGeydWBbRSM7JwLKyZWgNuW7gg7OgRBe3vL/9EKjrIm5xLMiQIIjky1ZyjAaYpmQF7L + cYZjsobic34/TRGNz7ej+PJPojXPYbv0bcPzznzdEA7yqaC+/bVjjZCPkpeOrrpH/kHnu7Ai0NIku2g2 + 5hSNm5K/JMoXGbpUL2O6jdNC0sDWCsZY5MbKyZXgsll+EWSY+s/PvLd2VCPLYVUTit0A1kvrw3oZt8LS + BrD7lnMwxXXMAkM2sWUEy/HG50qb4X2tcyXSRXy5hs5kf6F1vAHJAie+ahRTuoh5iXehGNTSJLtoNuYU + rZsiUhsU5nKxxof5TQfU/dT0UK+mJg/ECJIRlo0rB5vvO+EijXD5+HAE7JB/vtUM1ksa4OSX9XDqy/o0 + REN9lngDfF/St5xnjK0s2+TcN5xvzzlfTPC24zIjqwhun7WoXrR1gXfggyEtTbKLZmNO0bopI3LRCB+K + EbhkHFznU5PD3RqbJLFGwJB2Jpgz8CPs/bIx/LhqCD86CBcOWMJHvl5NM9hTHHumZfuVjVWhHDhdZBbD + njXDqSX1cWoxM8fiBupW0nnm4/5Z5GPuVujWtPgMPqLWM/9H0dIku2g25hStm9JA6oOiXC2oGaFGGdNd + nRuY3LFsqbzk8hGjOT18zaxwfEVLhOyzxA3rUbhxehTO6T9TkB9dtP+Oq4NvJGWzqleN0UQnOrOFyhf1 + WQM0oFma6Azzb0DuQQzgs7Uz2tUtuD2/mSLfz9N63v8YWppkF83GnKJ1U2/AzJARiuQz7Va+mOmS5tVM + fHo1U36kGSBF49iuefEta4UTK9vi/JGhuGU3AXecJiLi1AiEHOgDn21d4LKuFSO9EY4vqgurhXVgtaAO + TnxRD7aqORrrDEKx/ins2KfdSq4QmAFkNWO1vBnqlVeO0NDyNTGt5/yPoaVJdtFszClaN5UN5IeTCrFY + LEeayVera5Yx2dautklY7+bKb5YtFEhmGNnZHAtHlMKOhQ3hvKUHrliPhfzfSaJdJ+Om9TBcPGiJgO3d + 4LFOfpS5HQvKlrBnhNrRAPITL2dWcCVBbL4RuETUI+9pI+8Ro+OkL/n1T6/N8kMTA+C0vgsm9yqAaqWV + b2jkQpme6z+OlibZRbMxp2jdVA6QL1nK16aLcTArctuqVGHTcbXKmuxsXUs536Op8mOf5gr60hCSHUZ3 + zYMFw0tj49xazBCt4L+7F6eKEbjrOAFxHjMQ7zkD95wnqf8DC/kJW/m1k6B9vRCws5uaOTw3d1Rxk9/8 + +771K5zX6rbuG9pxidqex3Ti8fJzsD0puvxiySD47uqLXQsbYGy3PLBoqMSXKGTSgff7X/+uoJYm2UWz + Mado3dTfRDVD4TyqGSpw26pYQdNRlT82WdWwkuLYsZ5yq0cT5VcxhNCPheRgFpKjLfJg/tCP8d20atj1 + RSOcXN0ertt64uzBgQg/Jb8pPB7XbcbRFER+xPrMWFxXGYPr1qNxlfVGhPwQ1YkR6i+hXTg8hFPNIJzd + 2x8OjPZ9i5tg+YQKGNctv3rNnk2Vn8sXN5nPzCX/KEPrOf6jaGmSXTQbc4rWTf0DiBnkH1IU40CX/yC3 + af0P85layD98pCFW1q1gcrJVTeVcF0Yis8STXjQE6wgVqSUGMFsMbm+KYR3NMaZrPkztWxhzB5fAF6PK + cEr5BMsnVsTKyVVYa1TGN8KkyljBts+Hlca8wR9jcu8PMKJzbgyiwUR0TkvgNZ7zmqGli5jM4P1U4f3l + Mbrf/xpammQXzcaconVT/wbMWDTKv4wpQUN8qhaReU1bfljAtC9NMb5iCZMVrCH21CtvYte8mhLSvo5y + u3MDJbFrY+Vx9ybKM0btC/KSqCaRrWFfJdNr7r/geb/RYImcii7U/tTk6CdFTOcyK3UgZXk/8g9DtO7z + P46WJtlFszGnaN3UfwBDhiioN0UFmqJaIXPTeiIS37P8qIDpAPnbhBik3Ecmi5m2V1cpZbKlWmmTnWR7 + jTImu2uXMzlKjrHmOMi2HdX5XuWSJmvKfmgyh+cNp8H6sf+27Lsm+y3Dfgvqr611T/8VtDTJLpqNOUXr + pv6L5CL5mS0+oHBCISJ/spaaoiaNUoPpu7oB1TR69G3yfkUeX0J/vgj+zvwzMC20NMkumo3v+d9Bs/E9 + /ztoNr7nfwfNxvf8rwDl/wALZf6ZRmxttQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAACcAAAAwCAYAAACScGMWAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAs2SURBVFhHxVhpUFRXGg1lpVJTqfyYSqVSqck4/olB2WWRNY7YQY0KKjsCiuyyYyOCLAKiTcuq + IqgsAgJKyx4W0QBqq4AikAiKrMoq+6rQdN9vvvt4zlaZmgAup+pUP3iv7z31Lee7rz9ZDsLDw9dnZ2eX + FxQUPPrjzEPmIgXIa8hsZBYyE3kFmcEy6VH82ej4uLi4T9ntloaEhATe+Pi4BEH+RRHyNXISOYIcQHYj + nyOfIOuRD5C3kTeRpcgiZB7yOrKE+ftp3QkScepoDrvV0oBR+6K0tLRFIqkhMJIFMJsPMCkAGM0GGEwD + 6LkE0HEW4GkUQFM4LNQGwuwdHxitcIOBYkfozrWB59mW0JxuBk0pxvD4oiG059vhOunQUhNAToY4TNna + 2uix2y0NfD6f097eOgdj1wDgDrIeWYsUIquQFQDiYtwsD2AMBfenAnQmALTEADTw8NEQ/Jo/wC0fgHKv + xevpTHjZHE6O+5kuSEtLa7JbLQ2xsec/TU1NzZiZaSYwjhvDE5aNyIfI+8jbSCqwZFHgKEa3NxmgPR6g + GaNZfxLgXiDADW98xB2g+yz0tJ4E14Nqc4ry8vbsVktHaGj4GqFQOCgRVRCQ4ObwG5IKe4R8gKSRvAVA + ygDeFACMX12MXMd5FBaNjxxnojV17SCMXrEEUV0wDLXzSZC3tlhWek3Ut99+9xm71dIRExNjPzIyLIGh + KyjiHpKmtA5Jhd1F/oIsB5gvwjrMAXiFNdiViNrDmTS+zrWHsUxreHXZHGbKPWCq4zRJ4P9ElBXXFv1t + 9Xd/ZrdZOnx8Aj8XCATVmB8CkxgRJo01SCqSRowKuwEgwnqbxgYZysCmiMXbwSApdYc3uQ6MsP4UExjL + OQjzndGQk2RCtujIPpGR2fAlu83ywOPx1BsbGyfhzc+LIhhhVBRtAkzlP4Vdx45NwmzzAar9MMOe8CbP + EcapsGQTGEi3gNeNoVCZb0v27FDslVkvu7wG+HckJiZGTEz0S2AAi5uJFk0jK0pSiqlEYRPYwV3YmTSN + d44Bwfqay3eC8az9jLCXF/fCzF1faPjFnezbKz8rLyNjwS6/fNjZuX1RVlb2FGuLwFA6Kw6F0Y6k9UWL + n6axNW5R2N0AIBWHQVR4CCazD8BAqil0J+6GyRIX6Ko9Cu62qmLptdL+Cgrqq9gtlg/0Nr329uY5Jl0E + o0SFiVDUTC7AFNbXi4vYuJGLwoRoE1j8C8WuMI21NZRmDi8u7IFhgQ0MNwXDiaObJMoK32fKrN+w/M58 + i4CAE9Tb0mZm7hPG9amHzRcuppBOhDacBg2nsGnDMKCBQCp9McseMHvdHkYyLKEHJ8BAhgVM1geRlJid + REttrXDdOvlv2OVXhsDA46uFwupByWAqgQ40UprC0UyM1gUs+ggUFYq9gf6FqYTKI1hnnv9RZz1JhjBb + FwjlV62IrpZ0z/ffrZNhl145YmJOOY2O1kjm6oIIDF4GGEFhbedQEI4h6vRU1G0/dJJFYbTOptFkaTr7 + ko1xrh6B+gpXYmYgNy69dt02fX1LKXbplcHV1Ru9LbkaZq4REdoCk8bWM4uCUAyNFCPqJpexjIUiF5gR + 2KGfWcFgqhlM3/CAvqZg4mG/cU5eRtqDXfbdgMcLVmtqEkwNPTiGxY4z8Rl2I0aJWgQVQ0cRjZYEZ+QC + RoxOgAnszmH0suliZ5hq40PU8S1EbcP6yxoauss7n/0eysoapRISwngTY5mSzqsOiycKjB4VQlNHSSMl + RooKnNFoHdiZaQUT1+1gvj0SbuTsJ7o6Mo8UFZRXs8u+Gzg6uuO5La5l8NcTZCjTiREmLnFjRMxi6ug4 + ooU/h+5Pr6dzbJkmmED7ED+PhJdPwoAfaiXR0dbYZW9vtdrJYd8au4Oma/bsNvyKx0tbWd0FBnhyOp7H + zzVexXTlH8KIuWHaHHCsHoAJJPWwWYE9I3RaYIv/t2HuiRtOwOxQPHQ1hUBliT/JTnUcvnLJdiQ13mo8 + Okx/zNzwp3vbthkvP5KentxPU1P8M/qe8ImQbwTzBU7wGiM2nr0fvWsfU/BUCE0jFTl1zQZrDaOG9dZT + 7ABVlw2gLEEPCmI3QV6kDjwqtoGijD3koImcSHPjxhADA+vl198RruMaYRV/sOa6M2mKNFwsdBQzlGaB + bmKGBb8PU2jNiGEiiZ/0xEEboRunwdO4bTj3N8PDkzrQiQbcUOZAvOyVF5TkZM4oKqh9wW6zPIQGuToM + tEZK8sN2Q2/SPiY6I3g4HEgxZbyLnsdoBEcxgmMokn4O49+vUDi9351ogOfLXTBW4AD99cfICV8dibqy + TKaqqs7KRpbNAefPBZn+1Q2Vh0lFgD7WE9YUFjsdRfQs1pdkxAxyarJUEBVJSaNGva33khEODxzyaCXj + 2BTneXpkk5ZsuaKCyvIPk2/h6+OkXlcdNlmPDdBX4A0SnATi+8EwV+UL02XuTFqpOPpJBQ6hKMpXeN1P + I5tkDJNF6HFPT0FW4l7C2SR3X0lBaQ27/MoQFeEZ2996mognkkEiLgKJpBxZAkSSB6/QVB/yf2QiOIBR + ohzEFC8KNmPETRU6g+hFHBRnWZJdWxWalJTU/8ouvTKYmtp9HRLo2ZCeaCfJTnaW5F7xkgjSPRYKr3EX + JnrPkqoMM3x50mNSSKNHxdDPt9dT2NXizlgQljoRY32lZ8ob1N7dkHd3D15loG8qp6u7xURLU8tCS1Pb + RENdk8PlusQ+b+SRitPbsfgXG4A2B62vXkwjTeUEet1C62l4eMuDWBpv6FFVUdrELvv+EBkZverSRb+M + 2lI38jh2N2PEtHNpV/bgsZsevUewY8UtfPhVyCX2VmqjqipquuzX3y+4XDeZ+9WREzcTDMlgmjVMoa3Q + GqOn264EAxjARhA1hEHb42PgZq8xraaqbMJ+9f0iJaVUKirSL7zpvj8RRhoQais0ai/xdNsRvxNP53vg + zT1/aKs9Sg4f0n6juVHBfcuWnSt/L/gjcHJy+UtBXmjbrTQL0pZoykyCXvS5tnM7oB3Fzd70gk4U5ueh + M6+uqnRUW5vz7o5F/w8hx72tH9wKFBWd3IaGSw+QpvjKsAOexW6F8UJH6HscAIHeP4g0VBV5bm4B7+aE + +0dgbGz7WVKiX0WVwJbU8fWZudqJI6k56kcYvGoNL+5ySZjv38U6GgqXVFQ0VzYvl4IzZwRSdnZOCjdL + giYLo3eR3iRTpitbYvSg57IJdFV6EJ7/ZonWRsXcDUobV/ZTwlJhZ8ddFRHhG1GZ7yKpPLWdMdnWuO3Q + jW9SfdVeEBmoS3Q0FKtVVLQ/XMTewt7O9htBZlBH0QVD0nJu0TJeJhtBT4UrnA3j4CueQr2CvPK7mZdL + hZeX074HVcHi0tM/kZcXjaAv1QT6b7jBRf42sllT7pm8rKIc++iHxe7d1p9dSAi4WXHVktTH7oJh9LXp + 2z6Qdc6A/lzVJS+vup599MPD2dlBvTTPfzIveit5lbkfXguPQkm6BdnBkeuTk1X4MGPp9xAYeF4q5Lhb + 1C+FLqQ2cS/M1wbBvQIHsne7/LicrJyxlZXrh/Oy/waHs+fLjNRjXeVpRmSmJhia7/iQA6Zqr+VllczM + zZ0+njAKV1c368qSI6Jff3YgvU/CgXto85yqspKPhYXzxxVmY+PyeUJ88K1HVZ6k57dQcvLYTtEPWmo8 + DQ3dlf+OtlJ4eR1Wq7mdMNPTHEISo83Fels2x3I4O//E3v54yM8vlIqJCc8eH84iOZftJeamu3KUFNU+ + vjAKb2/vr4sK4p5XFHiJLc04xXo/cr5ib31ctLa2SnG5h788fco529xI23/rVs6HHeT/E5988g9YwvSa + K7m+GAAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAABfoSURBVGhD1VlnVFXXut1J7CFq7BpjTYzYRYo06R3p + 7dARxIIIShcRFekdEcUOYgMbEQQUFLFXpBc59K4iSBPbfN/eicklV+944433564xJmuzzj5rffPrCxgA + /9X44uJ/E/56SM+4xq9r6kR9yzs0t71DfesHev6M99zvDW3vUdf0BjV1Taipb0Z1QzNqG9pQ2/4add1v + UdvWg9rmTtS2dtH8CnWNTWhpf4lXnd1of9WFFy870PriFdraX+BlRxe6e/vR1dNLa/TOmz50dPfhVXc/ + Pf+NFyy6+vCiswellZXYvjtg+radexhP392DCTwtrKnD29voqFoP/hMPdDx3Qefzreis2IKuane8rnJB + S+F6DLyMp9dpDLQC/XXAh2oMFGWjK9QLaDuJ9y/S0V9xGp8acrjXaisqkJGahLyrx/Ds6S1UVFSiqqoa + OdkZiIgIQ3z8fjTW1+LMgVAkH92L1MRYXDm1D+mEzNP0TEhNiMT1i8fQ/3YAu4Mjpvn6BzFEZDCB/JKW + 6s6aMDxNZZCWIIDHFxkUZo7BtUQBlF4dgvRDDLITGBTcNWblwqfu5/jYUYSP/ffQetIA7Q6z8GbXMnRn + rUb7LWv0PwlFe3sn7Cy0sc5MHBE7DKGvLYn1tjrY5WGJTVZyWDxXAIsFZ+LZvetwU5wKC8k5MBebAYdV + P4O3dCqslkzGHq0ZCDKchv3O0ugma/mHRU/dGRDM+PgFDiZQXNHKL7gdi/Q4BrnJ45EWPwFZSdNxL2sB + CtKmgH9/GmL3fIOcDFtWfhqdhJfov30AdQbz0CiuiqcTV6DNSBzdRZvwkZ+AsspqKEjOh6ONAlYrCGGT + rSJCd6+Dr6sxZERnQ1dhAXjGOih+ehueOr9gl+YcOEjPhJPENIRoTsYh80m4ZDsJVzeOxn3/Fejp7cOe + sJipOwNDGJ89/yBQWNbCb+AfxPFDUxG+/WfscZuO7PNz4G0yEjMERiEldALy7k3Ek0d29Drw+G4AHhUG + ofNyAPIlRPDcZwbK10xG6dzFZA1poC4ORWVVEFk0DX6uOtiyVgnyMsuxzkgGHtbK8NusAztTWUjIKKHs + YS52KYxHsOoUBCpPwWnDcchZMwbP3QXwwv8HVLt+i2duc/8ksPfLBMoqWvj3Hh/CtsjJ2OU/G/vDf8Xd + XEHsWjMScoIjcHL3WDxIG47qIlPy+140lB9H4d0gvEmPQr6ZEO5kMXjdNBHFAtPQrDkbeHEABSVVWPDr + JGjK/oZAL0OknfREwj4HbLaRw5kj28HTEYOIyFLcv34NSpOHYaPgGJxRIm3bCuC8jQA6kubj2X4hnFs/ + Cq/85uBtHxEI/wqBovIWfmNRGHLPM4g+PRxeoaOwO+Jb3L0yDFcSvsNePwbuWxhk5mlh4G0bXr7MxceC + w+jOOITuWC/kbx6OfBMG5d+MQZenENAejQePC+kEBjNIuPnTR0CW/DvIWxuJcWtxfN8m2FuIQ0ZqKa5c + uojR9N6yEQxWT6ZzpBhYijHgyY2Gs8l0zBzHQHXZOPT09CAwgmLgSwSKy6r4T+4/xK2z3kBPFO5nh+BR + dijyb0SjtOwgLuQEI6c4APxXafR6H3r7i2n+c3ReBQ6dwBvvEGBfJFB9mLJUPlraXsHXLwDbdvghONAP + 0RFBuHRqP/bHhMLXxwdeXj6IiNqHhtpaRAX4Y8+eEHj7BmPnjlBs3xFCnwfB080fHp5+CAmLQ2/fWwSE + RVIQf4HA46el/E8YQM+nOvR9fIGegQ40v3qB+hctaCNB2ltfovJ5HV68eI3e3veoek51gN+E6po21DR1 + o/Y11YqeT1QPPqCqqR9tHe9ZauRur+jHn89/jS7CAKEPA+/auJXnNdVUU+rQ3tmCjrd0dnsT7dFKNYJq + DhFsaW3Bu/fv4R8a8WUCxUUt/Cf8UKQUMMirm4Tj10dD0+lbrDQYDhuj5Vgp9zOmLB+KjS7GSE+9DVXF + dTA12Q5LywDY2EVig8NerHXYD7sN+2FiEYG9B9g60Ie7cbrIjlBG8xk19N7aRWs9ePeuGQVPkhAVrYyW + ulzk3LjOuRqLRTLTMVFqBIbMZPDdT7RGbsWu/zBOAF1d3QiO/EoWqihv5Wfej0b4+SGIuzwT9sFjoeP0 + I1RMfoLTOlnI6C7AbJHv4eRpjjt5xVhrGwDPbcfhF3ABwVGZiPAIQmDgZQTH5NCcjCtpD2nbD8g+tAGp + YaZ4FK2HksM26Gx7TuvAs8JkpFx2o6d3uP0gFyOnMtgR4E4W5SP6SDCSziXgUtpF7D0YA8s1Zhg7YQze + vCECUV8J4traVv7pC7EQ1mIgojMGUqrz4LxBCrpaIjAxFYOiyhxMW8zAwcUcxc/q4bf7BOL3Z+BgXBoi + 3fdgn5cvMmP98CxhD/JCrVCWfggdZP7LCYG4nZ6AisK7OBkRjDRTFQTb8vAsxBNFSYF09Gucv5QKF1dn + 9L1pR1X5Q3RS+9He3ojW5nq8JleqLCmDjpkCOjo7EBzxNQL1rfzElFiM/ZXBGls1uDsYwUBTGga60li6 + agpExH7CzwuHwMGVh/rqLpw4cRf7fIKxy8UbURuUkR+tibJoE9wOMMS5ID3kXUvG+7fdqC+8gb6XjdT3 + 8HFhkxTMxo4CIzAJ9pMm4+jMaeAfjMbVm1exQvUnXM26gsJnD6Bttwj6nhNx6nwU/IO9EbY3EEomkuh4 + /frrBOoa2vj7j0Vg/AwGPlsssXmtHoz1FKj8r4SG8a9Qkp6D6WQBOydtdHcAD+41IMbTAQccF6M4ThHl + R41w88BWakUCUZ97BM2P0vHpwwe87++l7YFbhUexxWkiIsymYr3iTEiP+h5mdPxGWVncyr/N+XpWZh7t + b4WRggwkbBk8uPsAS8QXYsrSsRBTEcLrzs6vE6AOk3/8xCFMnzsWcnJCUFGRwCrZFbC0V8O163EUvOrQ + 2/QDdoRbUyMEXDidiKsRFnia6IiMU0GoL7iOuqJcNNw8hoY7KXhTzcbA3+N9zxvcuHEGj66Eo+qiHVLd + VeBOFdzb1g43H97GhNlj4LBtLYQNZ2Oh2iTYeakj8XgSBFfMxzThEZAyXkpWpDoQ/pUgfpJfyGcPGjw+ + /jmz41+fWQ7E4v95fKKg/0/jPVnULzj8y2m0qKSEX1n3AskZj5BztxzZudQGN3zCBUrZuQ0taK45j7ev + rtCrVeiinj7txD6k7A/GmRg/5BzejbsX49DY8AR15PNPM06hreohbt96AGVpPehpO8DK3gI2GxVhvF4N + ho5q2O7jgR3b1iPc/wiaGqsQGLKV2mtPRO3difgDu3EgzhfR8QHYG7mdCto6BPu5o496If+vFbLy59X8 + vJs3sMHKAoHuPnDzTcTqoy3wLwVCi4DIk6dxIUQJlbdicP/ObaxVXwk/OzWEO5sgJWwTUva6oTI/DYV3 + knE9NRbVT7NQcv8adBcaY94vChhCaXLcPAaTVzKYsHASNisnYruOEXysklBZVgBDY1E4bdajCmwNl22m + 8PV3wLZta+C4SRfKmqKwMVelZu4/tBJl1Q38O5dPwUl1NjaYmGC5zBoYbAqnUr4DPptd6CJxHDHGkrh1 + bBvysrNwKsobyZHuSApwxUHfjbiw1wshWy1wLMARAQ6GuJ16EHfuPYHQUm1YmLpCR9cIjrY2UJKww8Et + +5Dk6g49wUioylmiqOQe9HWXw9WFh6hwN2wLd8C6nVuxb992BPhvhqG+FNZRUunt76MY+AqBwoomfmvB + CWQFzcIJv1Wwll0OjcWLID5Pii4eatgloYBy4Ul4G7cLNdWVyEwKw8GdDvC318NFMve989HIOxGEOBcj + yk626KjNRSnFcaJHJB4mOOFhFLBWyxNrrfbgcmg2LkXHIdLrCjV1R5H/LA8+PuuxydkURpbysNhpAnU3 + K/ICM7g6mUNHXQzGhioUxL0IivhKED8ra+J3ViSg6PhsVCYtQZTtQjgpeCBpbQLCNN1wdc4ElMwdip7d + TuC/qEOIhxWyE0OxQWMl/Nfr4eHlo0gJ2op4VwPEeNiioYJi4VEtHEw3Y4u5M2zMXHHpwhnqsV6js7cT + 3f39ePfpDaWG93j34T0aGhtx//59xMX7Q9/PDXMtXOCwxQDGRoqQkl4IPS1Z7j4Q9DUXKqpq5udnRiLO + gsEZ++/w1N0c76KK0L3rOl56pKPW+RSSRg3FTZ4mqmpKsMfZCKEeZvBzX49TCftR9CgPWcnxCHZfi8MB + TniSdR4p6acwWegbiCjNxYHEaDqGctnHD3j7tp/ut33o6+vl8IEItFKz9oAI3LlzE9bOXiQZgzETfoCq + 8UqIKSwEb40GdaO9CPzalfJpYSl/oJe0U/+M7uvlwCvqIN/SJ32ENnrupzRX147+hnoM9L1BXfkzlOTf + pw6yBgMfPqK+sQFPCh7h6vVs5N3JRUlpAR7T77FHonA15zJt8sdgCfwT7BgYeIuCgny67F/D76kXqdGL + Quy+GFxOP4Ojx/cjIzsN/QPvKBbDxm/fHch47dwzmEBhcSm/te0l0rIzkfPwKq7du4yL11OQ8fA8rty+ + iHNZ55CceQ4PSx6x51G724bmtlbwq59Tu1tNM/vXhnI0NNWhsaUB9TS30+estj+PT58+ksCfBgn/gXL7 + p09/rJWVlVAP1IrO12wL/vfg86uQkZGB9Iw0nLt0TvjcxWTmTMrpwQRqapr4p1KOYsICukGJjcDEJdTa + ijCQW8Tge2ptmW8JwxnoWctzpqzmPyeNPea0VkQoKHiCysoyEqIINfTZy5etdHdopRa4gxPwPfXyrKv8 + E+/fv+OEZ+eSkiJ0dLxEJzVtr4kEi35qRdgzkpJOICw0FJlXf/e/kXeVuZqdPphAbU0z/1xWPKYuYyAr + Nw6LdSfgqMp0nOGtwly5ORCYMQzfjmdgbK1D/tuPJtJwdXUFamoqUV9fjcbGGm6thbTf2trEoa2tmVrg + 17T9fx6sZT4TeEWXKJbEZ/T19XAETp06ibCwMPyefjEg+0YmcyXr98EE6hpa+bEJURAV/BHnlIVgTFmo + ONIXcYGBVDFdoa0vC2YYA01tzb8IsMLX1T0fRKCZWmBWeFbz7wb6OG02NTejqLgEt+/eJTfIwOmzZ3Hy + 9Gnk5uWhs4v988wfo7S0mNN6VxfFIn2Pnd9SsBcVFRCBUwgP5wj4f5FAPRHYezQCCkI/46S/H7a4eODs + 2VNITTmI2AA3uKznYbWqDLa6OlEw9ZGLNJOgDaTlRrxobybNtZLG2unQV5zg/KpKuseGQtfAAKvk5bBK + ThbK6ipQXa0GWUUZyMjL0CxHitGl1BnPuVhzUwMGSOB3FNADA/0c2I6WjY2LFy8gJiYaaRmp/jm5XyBQ + U9vMP528HxPJ3+UVhan/2AAHJy3oURW0t9aHmooUJMWWwnWrI16TWzx8dA83b15H3q0buJl3Hbk3c3Aj + Nwd3bt/EkePHIE1C/zR9OmbOmIFf5szB/PnzISQkBHV1dazfuB5mlqbQ0dcmgtocsTX26yjrxOJ4wlEc + PnIQB+L3Y29sDM6dT8GhQweprfCEl6cX0jNT/W/dvc5cu54xmEBZRTU/Pz8PW91MqG+3ga+3I7URdnDa + aAdbSxNYmRnCxEgHB/ZFobyiHK7uLlDXVIWOnja0dVdDS2c1dPW1oKSqjPmLFmLq1KmYRcLPnj0bc4jA + b7/9hiVLlmD58uWQlpaGk7MTzK3MOBL6RnT3MDWCuMwqKCrLQ1VDGSpqSmQlabqpbYHtWhvMm/8rxaYM + 9h+MC7iUfp45mXxiMIGn+c8GtdODm+fBIyMrE5udHaGqrgw90qCegQ4MSAgtXS2IiotjBgnOYvz4CRg+ + fDgHAQEBTCeLiImJYdWqVVBWVsa27dtgYKwPPUNdGPH0YWFjCUVSgJGJPrffam0NeHl7YMPGdViybDGU + VZRgyDMNNuCZMJp6uoMJ8J+X8lOyn2O5RRJ4XglwD4mGwuZUKDtfgLLTOSg6JmOFzXH4HnmE9CupRGAT + aV2Tukh9DiamBlBSU4Gg4HxO+DFjxmDUqFGctm1sbMDj8bBgwQLOGpqamlBSUoK9vT2ctzpBW49clUhY + WZtTTOiRRbWIhAFnWQ8vd9ivt8PyFcugSvvLKquEiMvKMsvFxAYTqOaX8s9kV2Ge2Vnouh6Bk98uSG6+ + BgmnHIg7ZkHC4QIELU7A8/BTZFz5HQ6OG/4iYMwzhK6RLiSkpTB3zlxMmTIFQ4cO5fzd19eX4skL3t7e + cHd3x7x58yApKQlzc3NoaWnBZ4cP9Oi7+sZ6ZAVDmFE7r6KuBpM/Cbi4ucBu7RoICS/jLKCophYio6TE + iEpJDSbAryzmp95pgpxLJvR23oF+QCHMg24gOc4Zxw7uhtbOm1i1NQMByZVIT7tAgWj/FwETOni1jhZW + iAhzGh43bhxGjhwJQ0NDGFAW0tXV5cBaQUREhHOlDRtIAUTA08vzr1jgrLDGCnJKCpwb6dLaFrKQja0V + EVgORVpXUFX9g4C09GACzyuL+JmPX8LQ7wHWR5eSpi/CPigGGyUFsZ2nDfu4Quj63UdsRjP1Kuew1n4N + p6E/3McQaqs1sIwC9Ndff+UIsM0Y6zIrV66EsLAwREVFIU7xMX78eIwYMQIbN26EsbExtjhvgbWtNdS1 + 1KjGaBAZcy6DsXuzscW6qpW1BYRFhSCvIAd5FdUQeVU1ZqWMzGACFWUF1bnFb2AfW45tJxuxKToDjvFP + YLYnB5Yhd+ByohFr9pYgMa8LFy+cJa1YUgb6m4CKpjqWU5oUFBTEpEmTOAIsfvzxR0ycOJEDG8jsGhvU + Dg4OsLCw4AhYkoDKqopQ01ABz8yEqxmqlIX0ySKbHDdSyiXLia6AnLwsEVALEZGQYET+6ULlpQU1j2sH + 4H22EUFp7QjP6kFEVjcicvoQdrULAb+3wuNUHS49e4dzKadhbmnGpc3PBDS0NCFM7rFs2TLMmjXrLwJf + AkvGw8MDZmZm3MxmHAUlOSipKNJ+hpCWpaJHhFgrbHBYR/sbQ0RMGLKyq8iF1EJoD24MIvCsoPANzeil + zrmPOty+T9RNE/r/RB/l1Z4//2hwNjkZpmbGnI9+DmIdfR2IiK+E+EpxrFixAqNHj/43wT9DXl6eC27W + hby9t5Hw8qRdGS73r9bWosotQ9ZQhaaWOpeB2IwkJi5C6VcK5D5fJhASGaN16Ohxs6OJibxjicf/gQRe + YlISL+X8eeMLv1/WtbZfd3mNnRXnoywBFkaURiUov0tJSXEpkvX3YcOG/Zvwv/zyC10ffeDo6Ih169aR + K22E2EoRSEqJY7WWBmQV5En7CtBcrc7VARuKD9ZCYuKitLcEFNTVg2kfbgwi4LnTj9m+25/ZQVe1f4L9 + r6BfcBgzfsJEZtLUqWwO9mez0L8S4AJZUw2iFLQaGhowNaVWQUeHC+QJEyZg2rRpkJOTw44dOziwGWkH + pVDWr4VFVkCBAlRRRZWqryw0aB8tahp1qT5Y2VhwlhaXFIU0WWCxkFDUn/IPJsAKygrpHxrxbwgMj2LC + YuLY73zD/hBctCjRaetmmFvwYMbBmGBCcWFKDZoClXw58ExMuEzj6uoKNzc3rg74+/tzz2wNYGuDrq4O + li5bhFUyUpBTUICkjDRX3TWo4fuchdg92XQttUqSXE0Bc+fNSyQRhrIYRCA4ai8TFRfPxBw4RDj8N+IP + M7EHjzDxx0+wso8gTBwzdixPXUurm2dhDp6FGUwJPHNTLrDNqRBJycpTn0QpkQS1tbXlcr4DwY6e2err + 7u5KwmtjBeV21gJy5HKqGuqUdagn4hmRMkxhvcaSGjwb2K+zozpjzBU3IRHR8pGjvtclGWYRxg4isFpX + nzHkmTHG5paMyT/As7BizG1sWQKsBb4njCcsHTpsmOaw4cMthgwfvum7IUPcvxsyzG+kgECswOjRR36c + MPHaSgnJfgMjI8rj1lQ37LGWfN6USElQnCxcuuSj4KLFzdNnzrw37eef786YNevu3N9+e7ho2bL8ZcLC + hcJiYoXLhUWKRSUlShcsWXKN9nRgzyTMJEwgDBlE4P84hhHGEKYR5hAWEEQJCgQNgsU3333n8/0PP0R9 + L/BD5HdDhgbR2i6CN8GZYE3QI7DvKhFkCGKEJYT5hF8InwVmFcd6wLcEbvx/EPjaGEJgDxxHmESYTphL + YIVaTGAFZOeFBFZI9vMfCayAXJz9b8YgAv+dAPM/mDVPmL3NMaEAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAQFNJREFUeF7tXQV4 + Fde6DU5paemt0+IucQ8QA5LgBHd3l9IC1QsUqSAFWihQoJSiLW4huJMEd/fgEJwA+d9a+5yBYdiBE+D1 + 3d6X/X3rOzJyZvZav+09M8cptaW21JbaUltqS22pLbWlttSW2lJbakttqS21pbbUltpSW2pLbakttaW2 + 1JbaUltq+w9tf/zxx1TgL6AakMn+dWr7/9BA+JvAnXnz5gleicvAKKAkkMa+Wmr7b20gudX06dPl+vXr + cunSJdm+fbvMnz/fEMMRoA9Q0L56avtvayB3zdq1a+XWrVuPIT4+XjZv3ix//fWXIYZNQAfgbfumqe2f + 3kBmHiDp+PHjTwjAwM2bN+XYsWOyZs0amTZtGoWQCMwDagGZ7btKbf/EBgI/nzVrliJZR74V165dk/37 + 90t0dLThFRKAsUAwkJov/NMaSNsfExOjJftZuHz5suzYsUMWLFhgiOE40B8oat/9Ew3L0gH5gYpAV+Ar + +6LU9nc3dL4PIGfPntUSnBJwHxQSvQn3CcQBXYBiAL1DG2AYwNCxCHlF1NKlS1fhPUvPV+yHlNr+zoaO + /5HWqyP0ecFQwnyCSSUrC/xGEnBpzpw5hyGQA0eOHDmNSuMG18PrXSybD4QBRQAPoARQGqgAVAfqA2H2 + Q05tL6uhU9MD5+nCdUSakZCQoP3+WWBZefDgQVm2bJlMmTJF4c8//5S5c+eqsLFo0SKZOnUqxxx2AyuB + 5UA0hBMNT7IMpehyvC7Gd33sh53aHGnosDTAq8D7QAHAHQgEygO1gRbAGEDF8QsXLqgMn2WflUSST2ve + unWrnDhxQiWB1nUcwZUrV2TXrl0G6aq0XLdunRw6dOg+fj8Ry+9g3/fgGZLM22GbvTjOAfZTS23mho4Z + CdByYoH9wBngGkC3a8Tix0ArnDFjhirnmMmzk1etWqUIYc1v7nwDZ86ckd27dyshEDt37pTTp0/LjRs3 + tOs/C+fPn1eC4mATj2XJkiVKHBSjdd29e/fuw3F/Zz/l1GZu6JhNCxculNjYWNm2bZvqxH379tGqVN1+ + 6tQplZxdvHhRrl69+pAwWjWtkOUcP3M9vuc65s4nuC/ugzGbLp1egL9FIaxfv54EKUIdLSOt4G9v2rRJ + kCMoEVKMDBuGp8H7gzjPofZTfqJd+8EpHZAZeA141f71/4+GjonesGHDE536LJA0eoBnuXMKJi4uToUH + knTgwAElJi6jWJDQKfFxOb0HxaKzYkfA3zp69KgKC7NnzxbOS/A3t2zZEr/m1zYLrw1JcwW4DtwC0XeA + +0ASIBY8uD7Y6dqNIU6ngT3AOnyei+9/BQYDXwGdgcZAAXtX/jMbBDCbna/r0KchKipKkaZbZoZh1SSd + 5JMQbkfSSb7hMbicHmTjxo1qOUhTlcDz5gv0UPy9lStXqqRx5h+j5dqsD0TmpBGZm1ZkXjqR+elFFmQQ + WZhRZFEmkcWZba/8nuv96SQyHZgCTAImOCUljUt7//7odPfujExz5+ZQp0QI4CYQbu/Of16DACatWLFC + 24nJgWRhOxUidMvNoFXT3Z88eVK5f37HcLBnzx7l/kk2lzMscDkFYyynJZvzhecNETxe/kb04j8lavZo + 2bm4m9xeUVhkWdYXQ/RrIr8pD0J8aO/Sf04DiRmAP5cuXartuOTAzmSsfRYhXE7iWCaSSBLKRJCVApfR + ZTN+J7ecgqBwOLNozhfOnTv33GJgMsqQFLVgqqyd218uLfaxeYDnBTwIQsRdCKCTvVv/voYf9QUYjz4H + egOfAj2AbgBjVEegPpCW64PsXABLuMHAeuA2oMoqXWeZwSSNZNFSOVKXXLZvBtc3kju6ZHoMunZaPV09 + Xb6RDxjLjXzBWM7ykssZKhjfzfkEEz1OPZt/8+l4JBqKj7+3cf1KiZn1qVyZlk/kD7h5A5M1+N0EhgQ7 + 7o5QHmAr0ABoBAQD/3tzGth5WmAkkHRtaPoH14dluG/GtaEG0vP1wfQpE1naKbJZwpFwdrARk1lKPd5R + T8JI1Dggw/3o6n0rDLKtyR1f+Znfc7k1HyCpJNeaL3AcwFhuzSdIJkVk/HZKwO327d0pMbMHyvYxleXs + jx9Yk0ItkBg+BD4nXRuS9h7e0xvw8zEgwk7Zy23Ycc2EwWmSHoyCAscDE4CJwG82RSpQpVQt1Dz1j0mK + DFqkEYcN0P0yYzZ/pwO3o9U4KhgDtGCWlaw0SJaR3LHT6RmM5XTvdPPWfIDunm7fWM7an9sb52FdzvPh + efJYrcfiCC5ePCf7YmfL3jlN5Nr0921JoIFpwFSASaHhJczegP1PHsY5ye0flQjOAm8BL+4NuBOgJYg/ + jzKGSkuC65H7P+MHfwF+tf+4Qb5JANP+mJBswsZkiwMpxmcSoouvJIXrcmyeMdm63AqOJxhkcH8EvQa/ + J1GEObkjGJ/Ny/me3xnLuS8jXyCYL1iXc59cRkHweCkQ3fE5ggtH18ipZR3k+gxUD88SAMmnMYKLez/Z + BGD3DMQD4Gs7lc/XsIO6SDYeqMRj6au2EmWMk9wa9vBHFPj5oTCwnN5h69QmsDx9zKYr5YAO3zPmjh49 + WpVO1vXokpmk0f07EndJBq2ZVm9N3mi9usEg83JaOa2dy+k96CWMfIClIZcbIeZZy+m1eJ5GvpESHDm0 + R078GWIj3xAAyafXRf9ayear6neuyxKTXIEzOz/57HSmvF0bkm5f0p9pkuRAUZFDxUW9EnsKimzLLbLh + vUfCgDfggUEwD4Vx9ue8cmVNH7m1fZTcPv1o4IexlaTSZVIAzA9IjrkTDKxevVocqRhIhEGGdbCHZJiT + t2ctZ9w/fPiwmibmcr7ys5EPGPmEdbk13zCWM4lkMpl8vkDvd1NuX94vd04ukiMLWsuNydkfkm0YHF+V + 56U34LjB8tdtHGzJ+Qib4DliPxLZnofrMzf42E5nyhtc/wOJyiJysJgNhgCI/UUexz7UuDuR1fIg1r/7 + SBh0VWOd5OIveWTvtFayf/4Xsn/eF7J2fGu5sGuW3LyRgA4zrPvxMEBxMIGkpZm/14Gum51tTe5ogebk + jWSYkzcu5+8Yg0HW5M68nJ7Bmg9QdEY+we3pAShmYzCJy+lp6DGImzeRJ1w+KLfPbpKbxxZLQsx3cmn5 + J3J2blO5PDqHsmZ6U2XRtHoOHhlEx+UQ2ZrrEczEE1zOdWM+VAJAeGClMMVOZ8oaNuQYtW3wgdZPAVhJ + 14FCMGN3AdvB8OCozlVv2mpZxLfrkz6Q/b9Vlh1TWsmemV3l8NzucmpxLzm/5lu5vHeexMVslOnT/pBr + CRDIzccTSSvoxq3JmTm54zoc7EkueeP2zBcY443BoGctt+YLfL9zJ/OFNbJu7QrZt2WJnI0bK5dihkr8 + yn5yZF43OTK1npwf8aGy5qTR6F/G81nAkldEVv/rkQWbibbCSryBde/Y+NoM78E+h6eAoKLtlKasgfwc + SgAkzHD/OsIJK+k67C30JMzi2Ijsd8UbthiGWHb9d4jjd4hjUj3ZNbmR7J7STPZMby/75vSSg4v6ytGl + A+Tk+rFyZu9K2b99jWzbsvEh2SSDiZ6NjNUKu3fvBIFIDuFxbty49lhyR0EweaNAKBTug4NBu+OiZNvy + UbJz5c9yPGacXN4zWW4enCmXd02W4+tGyd6FfeXAlLpyfEKInB7rKfGjiyqc/rmwxI/IKVeGvfokyexP + ksxzZhgldCRboSPcDFq9MVrIvmS/zlQC2GanNGUN5LsoAdCdH3Z+eaSbwVwiOezKbzsJnjw7iyfIE1vz + lu0kOX4+G8fHBAlh5u74VyVhfA65+GsBuTCugJwfW1DOjyko534pBFIKgZRCcnJkITn1E98XllNjvEBc + aTk2PlROjPaQw7+UkNjfWsnG37tI7OSOsmtiXVhqdpXT3Bxqi79MvBJH4vcQ0lRoY5bO8XseC4+JFsz+ + ogWSFINgHawE62AlWQf2DUFhGQJguGDf4dgggGN2SlPWQD5HlmwnYwhAR7IVOqKt0BFuBj2Do6BQmHsY + YjE6jp1CV0pQPDwPWh5FRJLWvm0TE1/5mZ3G5VyP63M77sPoaO6XxPF3koOVZCuM43sajN97GgzSDfDY + DfIJng+PB6EWArhipzRlDeRHKgHwBygAHdkGdCRboSPaCh3BOpD0Z4GieBp25H02rATroCPaCh3RZuhI + tsJKugEKlYmfWQAUNo8NIQcc3rdTmrKGDZuhDExSJ6ATgI5kK3QkW6EjWAcdyVboiLZCR7QZVoJ1sBKs + g45oK3REm6Ej3AojJJrBUMTjhDBoxMBrdlodb9io+40f0yepTmES6CjxOpKt0BGsg45kK3QkW2El2Qor + wTroSLZCR7IVOqLN0JFshRHaGLKs5BPMB3jMEIJdADnstDresFG/2yMzJKlOZgmoI9uAjmQrdATrYCVY + Bx3JVuiItsJKshU6kq3QkWyFjmgrdESbYZBuxspsegGwmuLxIxewC8DFTqvj7ergDKPvjU5vIy85AVhJ + tkJHcHLQEW2GjmQrdCRbYSVZBx3RZuhItkJHshU6oq3QEU8YNb8OhgCQ0NoFEGin1fF2ecgrs5J+RYlD + os0C0BFthY5gHXREW6Ej2gwdyVZYCdZBR7QVOqLN0JFshY5kK3SEm8FKRUe8GTxerAvyORpYxU6r4+3y + 0Fc3qFqXcd8Y/38adATroCPZCh3RVuiINkNHshVWgnXQEW2GjmQrdCRbYSVZB5anRHKu3wweO37bfuVQ + EzutjrcrQ185oGaXniYAHcE66Ei2QkeyFTqizdCRbIWVYB10RFthJdkKHclW6Ei2wiDdgC7r18F+HLd/ + dLoNAXS10+p4uzo00zn5CwIwRv7+U0kndESboSPZCh3JVpgJTg46os3QkWyFlXQD1gGfp4HHgnNPHKkE + kPJb1BKGZLipphyNOQAdyTroiDZDR7IVOpKtsJKsg45oM3QkW2ElWAcd0VboiDZDR7gZLPmsAz5PA7dh + H4xRIWC4nVbHm5oK5hg3BcAwoCPbgI5oK3REm6Ej2QorwTroiLZCR7QZOpKt0JFshY5oM6wk68CEj3Ak + 7pvBbdgfE9WVQZPstDrWsEFWwDanb1QA/xukEzqizbASrIOOZCt0RJuhI9kKHclW6Ii2Qke0GQbpBhyN + +2bQY7BvpqgycJGdWscaNsipBMARJbMAdCRboSPZCh3RZlgJ1kFHshU6oq3QEW2GjmQrdCRboSPaCivx + BCd2dAQ/C8aM4J9qSjjGTq1jDeS7KgHwxykAI/nTEW6FjnAddMSbYSVcBx3pVuhI10FHvhU68s3QEa+D + jnwrSD6tmIM6jP0pBQXAfpyblgI4bKfWsQbyH00FUwDPIl9HsA5WknXQEW2GjmQrdATroIjNLUlb8smD + LQXk/pYikhhXVO7GFZfbsa5yO85d7sS64b23XI8Llaux5eRWrIfcjS0mD+Jw3nF2UehI1kFHtBlmyyfo + gXXkOgKOFLI/bVPCl+zUOtZAvm0qmB2UnAB0BOtgJVgHHdFW6Ig2Q0ewBjfjfEFkWbkSW14uxUXK6Q01 + 5Mi6ZrJ/bWfZtfZz2RQ9QNZED5fl0ZMkaulsWbpsvkRFL5TlK6Jk+eqleD9XNiwfLvvXdJDzG8LlTlwA + BOEiD2JxjC+DdAOc0dMR6yh4nQP7FnkcuEy0U+tYwwbNrg9Nl6Q6ngKwkm9AR7gOVsJ1sBKeHHTkm6Eh + 3cCVuHKyNOp3iV61WNZvWCWbN6+XuG0xsmvvDjl45JCcPHVczp47IxcuXpCrV6/IDV7AefuW3L1zR5LE + 1s6djZeDhw/I1m1bZPXqFRK9cpEsXTpddq3pKfdjESp1IiB05OtA8pn00fW/CLgP9ive05gBxx9ohZW7 + 3xyewTYVbBWAjmAdzOQmBx3BOuiItkJD+CPklmtw4SuWTVMEsz148EDuJyXhVSQp6YE8uH9f7t3ja6Ik + JibKnTu37Rd7XlfXCPLKZbZr1xLk9OlT6jJvXkcYGxenLhKdv2iOHFrbBiKAt3we0g3Qcq1kPg8MAWB/ + dgF8YKf32Q0r97vzEwRA189xAB3BOlgJ1kFHsA46kq3Qkv0krscFybJlf8iZs6cUiTdvXpOEhCsg8wos + /RLIvQBcNL3acOXKI1y6dEHu3r0j9yGQAwf2y+7dO2TLlhhZD/JXrVoJz7JUFkXNl5PraoNUB8g3k/6y + ySeYP7C/N75vCCDZZyA+0TgVfP8X+1QwBfC/YPlJ2/PJ/e1F5c72ALm5PUxubA+XG9tC5M42TyyD8LZj + PR3pOmhIN3BjS0lZvXyinDp1QpF//fo15d4TEq7akaCs+lngunxli48/I/v27ZHt27fIhg3rIK4o9byg + hYsWIkeYJ2c3VIYHsCeHOvJ1YNLGwZ6XBUMA2LddACXs9D67XRqSZfbDqWAOA+uItsJKshV2y76/rYic + jakhO9Z9I1HL5qDDmGQtwPv5Er1inkQvmyWrVkyWfet7yOXYMLm3tbCJbG5fWO0jaSv2qSH8EXLLzS3+ + snrZODlhJ/8WYvqNG7xsnNf5pxwUTxLCBl8PIw/gPYFxcZvV84EWL+bj4xbI/PlzJWr5fEnYGCBJMRCB + lWgzDMt/2eQbYL8jkbcLoKKd3mc3NRXMGw85BPw0AVhJtsJw5w+RT+I310LitACdtw1J1zG5CLd7DVZ4 + 6eJ5OXH8iOzes10lZytWRgF/ybENzRX597YWlTMba8jONb1kx+rP5PiGRnJni7si+gnycdK34nxk3bKf + 5PiJYzbyb9li+m0kdc8L3rl09+5ttb8TJ47K3r27ZevWOFm/fi0SwSiZN2+uzJ49VxYsnCfLl8+WGzH+ + yZP+v00+YTecG0PUY2Ua2ul9dlNTwbzenuRTBDryDeiI1wECeLC9oBxc30527Noqt2/Bouha4Y4Zb8+e + PS3Hjx+VQ4f2yp7dW2Xb1k2ycm20bF/TR53E0U1tZcXqRXL46CG4352yEiXZ6mW/ogxzeUIAd7Z4yqaV + w+XwkYOKrMTEe0jq7oC8u3j/YuA+2BhG9u/fAyFTsBtlxYplsmDBPJk5c6bMmD4D+cACWRk9Qe5uryiJ + e+rIrV2N5dLWxvB+LeTkptZyfFMHJI2fyPk11eXuqvyStApCWIXSj677ZYECQL/f/lE9nMrxp4moqeCZ + EIAxEfQCpJtBARyFRe+Cld+EK74BV0pcu3ZV3SN/Ch6BAti9a5sSwKo10bJtzTdw+UVly+oBEM42uQML + PBt/WrbviJFFS+fJlZgQWLsn4CW3QfztrX6o04egrNuviFLZPjL8lwmGAbZjxw6jEmAYiENJuFLd5Dpr + 1kyZPPl3+WPyZFm5Klo2xa6XTTEbUG5ukh07tshuiHcfhHPwyAHZtiMWQpkri5bMkfVRg+XUyki5tcoZ + goCQX4YYOI4Dvu6OUFPCX9rpfXZLGJL+pnqqFQXAPOAFSL+7zUOuby0tCdvCEdNDZfuqT2T9xlVy8NA+ + 2bN3p+zavV127NyCcmqTrNu0RlZxsGXZIlm8dK7MXzhLli4eKwfWdZIliyeoXGEt6vcVq6Nl2YrF6LgF + snHtZNm8boasXTdf1qxbKitWLZUDiM8vr5FslotJiniC79mYC9ADbNq0Qd0wyptQ9+/fi9CwS92DyEfV + 6BpLT6MdPHAIx74W57JI5i+eKwuXzJZNy4fKmZWVIARYsI5YR8FRSnI3Tk0JD7HT++z22FSwIQADOtI1 + oLWfjmkENzheFkfPlc2xsIKtsbCEzYibsbJt+2bZvmuL7IQ3oFXsP7AHLvuAnDh5XE7Fn5T4s2fkEkLD + pauX4W4vSwK8BHEFZVvC1atyA/X57TuI6Xc5UAPXjNqdAzb37L1LknTWa0NisuAYwCPcU25fBzZWBTEx + vOt4hdy7dxeCsN13SPA9PRtLy4sXiXPAeTvOoay8qPYRF8db1FfLsuhomTtvvkydNkUmTZoEQaDPVgyT + m6sQhjkq+DwwBDBJPZtwgp3epzesaJsK5owSBcBSUEOwFnarT9qeX87FVJUl0bPk0GGbK04CMQ8e3Fcw + OvEuyLvNu3uRYTM7v3Mb2TZeExIuI2G7phLEq6zDL19StfiFC2fVZ1uHnlWfbYhHDnFGzp2Lx35vg8gH + Klm7exeiQMwmSNAjJL4gHuUBsbF85hAfbnHjsTGEp4FjCleuXFb7iInZjPwhGvnDXPUklIkTJ8jo0WNk + 2NAhMnf+LNm1oqfcW41yUkfws8CkkwKYrqqAeXaKn96wom0qmCNJFAAHg3Rkm2Fy+cS97cVRe4+BS9yr + TvLw4YNQ+nqc7DqV4cfCG2zatA4xkepfDo8Qg0waVrBsMUqqFYiny5Do7VLZ9bp1KyU6GjX2wvlq6PX8 + +Xg5c+Y4AC9BTxF/CsSfUUkkcfu2TQCJiXeAR9asJ/J58fIEEBsbg4phmf35w1Nl/PhfZeTIH+W7b7+X + H374XpatWiR3V+fXE/wsGAKYraaEN9opfnoD+bapYE4nOioAA3YBJG53k4VRs+SacoNXcIJRMnfuLFm5 + cql63YoEj4pfvXq5REUtRifw4QwrlAg2bODjXVYjhu5Uj5jZs2eHirP79++CkPYrkg3iz54lTj8UwLlz + /1wBLFhAAUyTCRPGQwDDZdDAQfLtd9/LwkWz5c4ahGEaZErBMpODeAsyUAAH7BQ/vYF821QwR7EoAO5A + R7YBk+U/EoA7MvQFcO18AudJOYKM/MSJQ0iUbDhx4rCqo0+ePAzw1Yb4eFr2CTl9+vFXEk6yz5whHln+ + f6sAfvoJAhj0rXz//XeyALnAcwuA1xOQvyWvUADn7BQ/vYF821Qwa+rkBKAh3QwKYMnS+YjnNxRJhw/v + k2PHDiocPXpAiYDvbUKgKGxCOHHiCErBI+o9S0LCEMLp0yfU+1QBpAC8FZ78LVc3id62U/z0hhVtU8Ek + mgJ4WuavIZ/QCYDEGzDEYHgECoDkEydPPi4AG/n/zwWwtrBtoiilMASAfIBGDWSw05x8w0q2qWASTwGk + gHgD/3kCuKemfFPWkjTEG/iHCICX9FEAyOfsAnjXTnPyDSv1u/uzaSrYQdLNSNzm9rcKgJUBS8FLl86p + Tn1au66O6YwatNm4ebNEof6eMesv+WPKNJk1d66sWrPm4eSRud2/f++fKwAkg3YBFLLTnHzjVPCDsfap + YM4FmC3fQTH8XR7g3LlT6FA+G/Camlu4c+cm9nFSZvw5S/r0HyAtWreXStVqSMnSZSUgKES8SwaKh1+A + FPfwkkIublKomIvkL+Ys+YoUl/xFi+K1qBQs6ixF3DzEp0QpadmmnUQvX/5w6JfNJoS/WQDrwAMnjZ4H + FEBcDkMAfnaak2+Xh7wyM2m8aSrYQdLN+DsEwBG1pAd3IYJ4lJcrpH3XrorMd3PkwmsxcfHyFv/AklIq + NFiCy5YBQiUwNEhCy4RKuUrlJLJ6FalVt7rUqVdbGjSqKw0b15NGTepLw2YN8F0dKVsuTIp7esh7OXJL + Qez3j2nTIbBbijQjnPwjBEDutuU2BFDOTnPy7dKQLCsemwrWEJws7NOPLzMEkHSbAEj8CeW+Odp3+2aC + DBn+I6y7jLz9YU4pGRwiNWrXlHoN6kmTJo2lceNG0rRpI2nRqoW079hOunXrIp/0/kR6fNJdGjVtIBWr + lJcq1Spjm2pAdaleq5rUrFMDosA+GtaRJs2bYrs20qx1cwmvUF7eeOdd8fIvIbPnz1fEsXEoeMuWWFm3 + bpUaeeRVRmZwKNjA9etEgh22/0Fi27p1ixLwwoULZOZMCmDCyxcAuEEZeA8CqGunOfl2eWiWbeqBxCSf + XsDwACnwAoYHuIOEjEO2JNlGLHEYxJLgIyCVFn5UEXzqFGt+En5Skc7xA8Lm7hnnT8N6LsiD+3dkwaL5 + 4u4bILkLFZaISuVhsbUkOCRIPD08pBisP3++/JI3b17Jly+fFMhfQAoXLiyeXp5SukxpaVC/ofT+rLf0 + 699PmjRrJJUiKyohVKsZ+RiqwkPwtX6jetKuQ1uIoa0Eh0Fs2XNIm/Yd7WEhSc1r8DmE9ACXLp2HRzqH + Yz2rhMrjpnB5NdLxY8fQD0dgAEfl8KEDMIoDWHYG4lkrfBzukiUL1VTyb7/RA4wE+T/I4ME/yMIl8+TO + enDBeP48ICcIA/Yp4XZ2mpNvV4a+ckQ9/44JIAVgIdcRJMIDrFy7VI3Z79+/W7Zvj5Fdu/jvYFuA7bJ3 + zzY10rd//w51UcWBAwDWO3BgjxoC3k/s36Nm1fbt5Xe75dCh/bJvz05p26GDZM+dV4LKwOJhte5u7vLR + R9mBjxRy5colefLkkQIFCigULFhQCaBQwULqff78+cXV1VUiq0bKN/2/UUKoXb8WPEIF5QXMoAAia1SV + KtUrS6PGDaVLt47SrEUT+TBPXoQHb5kz+y+ZDfw+eZIsjVosCxcslAUL58vCRQvU5WF8v3jRIvV50eLF + WCdKlkVHyVJg5apVEEi8/PzzTzJs2FAZOmSYDIdHGzlihLL8/t/0k779+srCqDlydz240JHrCOiVkdDf + +0lNCX9mpzn5dnVopvPqAYwUABNBDcFa2N0/cXerq4yd8IvEbN4ka9eslrnz58iC+fNkNrLtWbP/lJl/ + zpRpU6fI1Gl/yOTfJ6sJkAlQ/vgJ4+TX8WNl3K/jZMzYMfLL6FEy+pfR+DwWnTNMPP1KScHizkjsqoiP + j7e8/8H7kj17dsmRI+dDiydIdKFChRSKIrmjVyBcXFwUihcvrpa5u7tL02ZNYXEjpMvHnaRMRGlFulUI + BD0CX9vBE3Tp1kk8/f2kQDFXad2utbRq01yatkDYadJQGiCXqN+wLkJRbYSTWlKTIaYWPQqEFFlZKlWt + IKXDSqtwQy9Sq1YN5YEaNmmAY2kiTZs3w34aS9u2baRXz14yc/aUF/MAdgHIOOUBvrfTnHxLGJLhunqW + ryGAFLp/4s4WV+n3zZcSGxcrAwf1hxVVkbr10SlIrurA2moj8aqDzqlVt4bUrlNTvdZE/K5Zp7qy6mo1 + 0el0xbC+mrUjYZ0VpYiLK7L4AKlQuYLkzZdXPvjgAxCfQ1m8QT6tm8TS4osUKaKIJki6m5ubAkn3QKgg + +N7Z2VkqlK8gQ2GFffr9W8ozQcTvWgVAKG8Astp2aC3dPu4q/kElJVehIlKpSjmQW1EqM5xEVnqIqtWI + ygqR8CJMPIkK+A0KhEGkfIVw8fHzEr8AH/Hw8hA3d2cpWqyIRESES5fOnZHnDJJbzAE4N/M84IguBfCH + mhIeZ6c5+ZYwOG2i+mcqCoAbaghOFnYPcCvWWb7s87nKcD//oreUCQu1dYqpQ6wwd5CB6jWrSmRkFZRo + Lkj2QqVCxXLK6kl+zpw5H5JvEG+4fcP1E/QAJJnke3p6ipeXl3r18fERX19fBS4PCQmRUfA4X/f5ElVC + RLKegN9XqloRImgjn/bqIe4+fuLs6QVBQ8BIJingZ6Eytq+PRPPe3USpVLm8lAwKkODQQCkZGCC+ft7i + 4lpMyoaXkY7tO0nf/l/K9TUvIABeFUQeZ6gqYLadZn3DCvw3S9sFhUwCHRGAnXQzrm0sKi3atkCCtFW+ + +voLKQeV6zriaagFb1Czdg3EWi8JQhlXvkKEvPveu/Lhhx8q4glaPYnnK0Xx9ttvy1tvvSXZsmWTf/3r + X+rze++9p3KD3LlzK8/g7e0tAQEB4ufnJ/7+/uo9QWEEBwcjnk+WL7/+XEqHh2oFQFAEDAkdu7RX4aCI + q4f4lQyECOjJni0CCqBeg7py89YtqVipopQyCcDPz0dc3ZwlPCJMunTtgoSzlVxdYRvNey4YArA9N3it + nWp9A/nZlAA4imQIIIXun7gEl1WxahX1Ny9f/zvlAmDcrIsw4VuqpLh7+0vVGpUlR84cKt6TeJJJq6eF + v//++/LGG28ovPnmm/LOO+8oMRAUC8OE4S0M0dD1BwUFSYkSJaRUqVISGBioXimOyMhqKj9p36WdlKsY + oRUAYYSJXp9/KvUa1ZfcBREKqlaSWg4KoD4EcPXKFXiAChBAiScEEFEuXLp3/1gqV6smF5ehXzmu/zzg + rC55RFi/McRpj51qfQP5totBOI9MAXAUSUNwsrB7gLMrCogHrIuPa//3v+FSUyiA2kiQItD5hd080MnV + kcEXUEQb5JNEZvq09Ndff10Rb1g716MI+J6CoQgYJozcwBAOXX9YWJiyeoqBIYDvmRt07tRZ5s2fi9BU + RcV8K/kGuIxjCr2/6CUlg4MgVl/lAZ7lBZQHQAg4f+GcVEIZqxNAufLh0qNHD/GGSM8ugRXryHUEvCiE + Alj6Kj1AvJ1qfQP5xZUAeC2ZowIwuX4D8Utzwy26ydbt2+BOU+YBVAfWqYbtUbfDCsqEhch777730IoZ + 3ykCw+rp6t99910lApxCssiYMaMSDnMBxnzmBiVLlpRqsLDSpUsrAZQpU0a95/ejR42W/oMGwEWXTzYf + ICoghnfp3lk6dG4vuYsURYJXQWojFOjOzQDzobpIAk+fOo39l9MKIDwiQj7++GMphnwlfhH40JHrCAwB + IKyD25voi+QbVvBXAiCRFABnBB0k/SHwgzzg4u6eErclRr74KmUCqI3YX7Z8BBIrb3RwpOT4MMfD+p7W + S8s3yGe8p+WnTZtWkZw1a1YpV66cdOvWTfr16yd9+vSRTp06KVKzZMmi1uF2dPVMBCmGsmXLSs2aNdVr + eHi48goUQ+3atWXxksVw73WQ3Vd6gngDDAW169VSoS4gMFjcfP2kHiod3bkZoADqoyo6euzIU0NA1+5d + xQX98EICoDenANa9QwHwoZHpFNm6hoXhSgDmqWCdAHQg+fyxTR9I/OIc4uzhJZtjNkMAvaU83LmuI6xQ + 1g+X7+rtI+VRMweU9FfWb8RuWj8tnkQb5OOwFRo0aCCjRo2SwYMHy6BBg+Sbb76R/v37q/dDhgyRn3/+ + WVm7sT4TPyaBFEPDhg2lenUIDyIoX768VKhQQeUH438dL0OG/aDGB3TkE/QOHCjq3qObNGneWAoWd1Hf + PS0XoADq1a8jBw8cVB6mVLDOA5SVLl26qDkN9qe6uud5QA/Ach7vyS3wFs5f37Cw5rUhaWxTwfQAjgqA + mabpR3nAxWFh6zesl88/7+WwAGoh9leuWlll1RxEyZM7j0riGMMZt+kJDPIZ53HIyqI/++wz6du3r3KZ + 3bt314LLKAh2aubMmdW2jPl098wBOnTooIgnKlasKKGhodK0aVNZuGg+6vyKSERtA0E6sCJo0KS+fPZF + T4jXGxYdJHWf4gWMELB7z278VjkJDC75mAA4FlA2DGVg587i6uXzYgKgUVIASAbtAkj+b+SwsPn1YemT + FPl8LgCHgpMDd0owTzAGi+yIX1lAeYDVa9fIZykQADutJEjxLRUoYbA6kk+Xb1i/kfCRfMZ0HLK0aNFC + kdu2bVuHwPDQqFEjtS33Q7IpgPr160ubNm1UCKlUqZISAr3E9OkzpPfnPdUAkY58wsgRvu77JcrHcCmG + 8FenbvLJoBIAPMC2bdtVDqETQBi8EUVJb8j+tPZximC/u8suAC9Ftq5hYRf1iHhuYAwEmUGyzaD1m+7J + MxC/LJ+K4Zzl6vnZJ2rkS9cRVjB2crsIxEV3d7eH1s/sndZPAZgTPsbxdu3aSZMmTaRxY84APhtctzMs + i9UB90GS6fYphF69ekmVKlWUAAiWh9/0+0YmT5n81HEBgpNKvXv3lPpNGkmeQoWRN1SGAPTnyRFCTkPH + xsWoEPCkAFzgAUpL+3btxQ2VBftT188Ow26odgGUVWTrGhZ+mTgKAqBL54b8lyszFme2YVEm2x8m8X/t + NIj/JbMU9/KUqKXLpGfPHg4JgNZSvVZVKe7hiQ6qKoUKF1LZPi2f4/h0+ySepZ2R9DFpo+XWqIGsOwVg + zGcZyH0whPA7ioAWR+9A669cubJKCCmaqGVLpWokSkLEelq7Dhzj79i1k3Tq2kHyFi4mgSFByVYDHPnk + OMf6DevU6KZOAKXLhEqbtm3ExQc5APpT188Og9PCyAVQBnI4uJYiW9cSBqf94cHYDI/cvDXDN2BP9pKD + SgK9vFQW/WnPjx0SADurnD37Z7zNl/fR2D5fST6t35z40UJJFN12SkAr58ifsZ8IlFxVq1aV5s2bqxyB + 1s/9UhR8v3TJUmnYtL4KA4z3OtCVt2jdTD7+pLsUdnEXLx8viQTRzGus50oBcE5k9ZrVaoQzMORJAZQp + W1patmr94jkAwTAAD27/J9HWOGd9uzIk0/ik39LZ/iLmiIvtv4Ks4LJnIH6Tiypf5i2YLz0+/VgqVn62 + AOrUqykhqMM5y8bx8Zy5cj60fo4B0APQ+l977bWHxLGMY4nHGJ4SkHDmFsZ+mPGz7KP1f/HFFxIZicwe + ImFYIPhP563btpIIlLMc/NGB08n1G9eXXp9/oryYB5JB5jG169Z84lyVAHC+0fAsKgRoBEAP0KJ5C1sO + gP7U9XOKgJD+YJSaEu6Jc9a3y0OyzFP/S8v4zzzAGv8Z83UewYL45fmhXC+ZM3e2soiKINTaCVYwAQwA + OT4lS0hE+bKSK2culflzJo/xnwkbXzNkyPCQOFYEjOGc2GE55wjo+ln+ZcqU6eF+mGPUqVNH6tatKwMG + DFAlIQVgeAH+0XWXrp2lbHhpNYqnA70cJ4R69f5U3EGaJ44pCMSSbOu5qhBQ1zbOwBAQFFLqMQG4e7hI + SGiwNG/W3CYA9Keunx0G+aNHH688wCCcs75dHpplnfq/X1YB3MBc6qXgeTfxUbnEGZ0988/pqj52WACB + pdT4f+myoaoE5JQuL94g8XT/fE2fPv1D4gh+x3U4svcs0JtwFNBIAA3wM8lnLjB06FCpVauWCgkEQ8b4 + iRPkk149lFvmyB3PxwoOdlVHHsP13P38xdPPV4JDAiW8XJknwoARAjjczBCgE0Bo6RBp3LSxLQlEf+r6 + 2WGQPyaCU1QOMBrnrG9XhmXZo/6smALgBowd3DglT8MEOBTsigOfOm0qavDO6vo7cwfowArAt2QgUEJC + kEAx++dcPsllNcDJHQ4IWQVA0DtwfYKJow5cxnLSnEMY4Hf16tVTlj9ixAjlDYwwQAGMGTMWNX5vCQ0L + UVPFzAWsCC8fJjVr1ZAeEIALQoA3PFNIaJCElA5S1zYQxrlyqrs2QgAvjtF7AFflARo0aizuPhAA+lPX + zw6DHNKg/1JVwAycs75dHfbKSZXtGwJ4DvIJHrAbstdJk3+XLt06SyXERzPZOtADlAgOQseVQFwPVtfy + UQCcnCHxjP8k0hwCzKAwODnEySB6CzP4HZfpxENw4ogjibT8n376SXkDjhrSAzAHmDjxNxXKgkFoOVis + DmHhZVUi271HV3Xxin/JAAktEwIBhCA8RDw2JqAEULeWTJs+DRWHzgO4qmscG9SvJ66+CAEvSwAwblQC + K3HO+pYwNONl9VwACoBx4znIJ5QHQAyc+NsE6YzSyCEBwCICS4eqCyzKIgTwGj7Gf9b6tF4mgswJjAGg + p4FlItcj4enSpdOuYwarDAqAxBsCoAcgWAVMBVG8FCwILj0soizcetgTINkNGzeQDh3bS8HirlIiEELG + eZTB92UROnhVlCECCqBOnZryx5TJyDHCJSj0SQEEBQXCKOraQsCLCoB5AAWAEv7GEKedOGd9SxiS/pa6 + r5wC4Ea6nTkA5QFw4LyWr1OXDg4JgNlyeLlwdbElky3jGj4mbswFKAC+mquAlwUmhRwbaNasmcoBGAIY + DugBKII5c+ZK4yaNUK+XUgLQgeJo1bqFNGneRPIXLa7GAcqElVbX/5UJD4WQKqhL33iuRggYP2G8LQRo + BBAcXFJq1a4DT/oSBMAxHQpg+ev0AKdwzvqWMDjtA/WUSZLPwSDdzhwAD5iWzAs6O3Vpr7JkK+FWqHmA + yEooobwR/0LEzdV2HR/rdQqB8ZtjAhQCDvWlgrGeHoAzh5w8YjJIAZB8vi6NWqJm/YJBFMVpBQkOLROk + vF1FVA70AGVRxvH78PAyChEVwrBf24AXBUAxjB07WiWBJN8sAA9PVwkMKoWcoiYE4PfiAqAnJ5+2J4df + xzk/2ZAcZAaYJCTdGJZObo9Il5Q4Kl1S0jjgtzRJ6l4B/osYqwT+ZTr/55/5AkMGH0jE0SYOOuAHecAe + KLdGjBqpbspwRAA1gTr1a0oxd2/kAqXEy9N24SY9AC2UAmC5xqt50qRJoyXyecBpYg4P0+1z+vjTTz9V + xDMfoPvn/MCChQslCMcUHByI/CTkCYQwNISHqfjvU8JfXSMYFhGqXL/yEAwTcPVVqlZS58qLXRkCfhr9 + kwoBTwrATUoFlpQa1avBkEw5ADN6TvHyii1etsdrNzkyy/924pXcfLIbH+/3u5MkTUwn98dmkLujMsrN + ERnlxrC0rACSAP6FTBqc++MNX74LyM0f08nN4enl+tB0kjA4jTF+rAD1PIT5ezO47MjAV1QVMHzEj9Ku + QxuHBEDUb1BbfEuAfF8/CfD3VQJg3c4ZO1YD9AAUhLWMexHQw5BkVgHjxo1TYuD1ARQAK4Bvv/tWfhkz + RlllKG8tQ4JqRSmII7JGJEJAcynm6iEBKGUV8bR+lIEkuVzFcCSU5R9e7cyQN3z4UCSQ5bQCKIkksmq1 + SHHH+R8d9Ar4eJwLA4qjIWmxHJwNyyDXhmaQhCEZAb4S6bkOiSe4zQ0gI8798YYv0wDXlKWbnztPC4/K + YlMarZ5lIj0A/1JuBsCBI/7B5ARgLJQ32klOfp9ZCWDI0MEQQGs1+6Uj3Ap2SgRcYlEXd3RGSfEGObx4 + kwLgsC9reXoAisCRZPBZYD7RsWNHZf2cJaQAGPc5KkgR8Aoh3sPQtl0b8fbzAklBT4CxnwJo166VRJSL + kMLObhIGyy8bQZSVCJSHPKcKIJqDRRwDUCEAIW/IkB8gDl0IgABKlZCqVSqrXOr4d5l5Y4fc/9nWvzIG + GAf8au/3iQBv5yMPsH4F8sh5APJDr0DvjW3AMW8Ry4rzf7JhwVDgvtqY5BrgxE8KED8uMw7cW74d/K20 + bd/KYQGoLLl2pBR291AdQOs3BGBcs8d8gCGB3gGH/EKg1bdq1UrF/MmTJ6vpYhLPJJCjgMwJ5s6ZIz6+ + CEulAlQSaIV/CT+EivLSvn1bcUb9T+8VXg7WH0brD4MXCZfytH6sw2SY3tB2v0NNGfT9ALU8uPSTAigB + D1CpciVbEjgaxkdOUgpDDATEYf8X0b9w7vqGhRmAzcC9O8OdHqrOCn7/NCgPgNg1cNAAuNeWDguA4CVh + pUA2h5IpAo7TGwLgLB3fc+iXcwAMCzjs5wKTO4Pw4cOHq+yfpFMU9AB0/1OmTJWv+3wlxZ2LqZhsRcmS + JcQ/wEdatmohlWGt+Yo6qzF8zgHwip4IuH5l/bB83tBC8gl6AXq7b77pq5aHWATg6eUmAcglylcor5Lp + YwMzcyLnuXFzqArNjP0JQHacf/INK2RN+N5pFKBiBl7vX/3OKfHKt073Lw9ykksDneTiACe50N9Jzn/j + JOf6OcnZvo8Q38dJdvSmB/CVfjjBlhAA5791ZOvAOfTKkVXUjJo/OqFUyVJqAofWz0u26K75mcKgIHg5 + d0qSQs4B0MLbt2+v9sWLSTjWzyqA3xMMAy1btpKoJUtATLD4wv2XhAd4HP7wDF7q0q8mTRtJQWcX8Q3w + t1l/RJhK/Moh8+cVPxwqrsS7kWEIJJ9gCPiqzxcqP+BooVUAJXDuEeXLIQfwky2fZpaTX8KwTDjxxeM4 + 9ZWTnP7a1v/kgbyQI3IF/u6BR5Ifgj5wrGFlXiFcHegA9APGYSeLgd3ARYCKepSMQDAQSeKFgWnu7fgs + cxKV+3Xff0vL1s3UCevI1oFhoG69GuIN63Jx8wTB/sr6afGMySzZmKhRDPyOZNGKOXOY3CghwWUMG7yA + hCDRjPtz586V1q1bq31QELR+jgJO+m2SfPxJV1WT87atALh6A/4lfBX5pRHrW6P29w0IkMJI/ngRB+/o + oQg4ocX4XgGun1cKG9bP+M/+4HnyaimGgCcFAPEHMJSEiQdC4LpOmeVwTyc59pmN/DP/VsZ3D8Z4F+Qy + u3/Ig50Lfh8PbMP7+fhuFJAb/fDyGnaYFngP4HMFI65+79Tk0rdOvc/0dxqx9tNXF3vAGr788nNp0app + igRA0DqYLTMX8PTxktBgjqbZrtrlK8li8sbYzaldEsbr9+rXr69EYdzzx6FkJoyc0SPJnOvneiSZJR9v + x2acZzigB6D757p9+/SVGUj+PL08UCV4IOfgDOIjeOO7QJSELZo1kZAypSV/MRcJQkLIjJ/ZfwQ8ALN7 + DvJwKpz3DRrWz/hP8Bx79OyukkSdAPzwO2XDyoonPN3WLzLLOZB9cZDT6SvfOW0BqfPQ578AfYD2QA2g + FFAQeN1O0d/aeKlxZoA//na+QkV8+YiVnp/1kmYtGqdYAATny8ugti5Q3FV8/b1VUsW4TLdPkHzeOEEC + KQDW7rRqjuaRbILlHeM8Ez16DQqkZcuW6urhiRMnqvcs90g+l9G7dO3aVWbMmIkMvBISzuKKEDMoCJZo + DRvURXJXQcV9ln0c7DHKPt7UwcSvvD3xI9gHtH5DALwRtmu3zmpdvQC8UWKGig9CXLBPnjLo1/eAbAD/ + /Cn5S7v/D1p6gAfFg+NB5syVL1+wN5I1XtfeoUNbFQPNs2GOgC6SVuJXKlCKqMzfVyVFFSpUVAM0xjAt + PQHvAeCVvySaF3UYhBK8pIvfk9jvv/8eid0UtT6Jp8s31qOIeEXQnNlzpHnLZlKwYH54D95E6qVAq+fd + u4FI/hrUr6PifP5ixcWnRIDN9WvKPlo/3T6t3yDfGAfg+bXv1BalIzxAmUcC4M2hnA5mFRAYHCQlQ0Ml + Z558pdGvvJr3Q+Bt4DXg2Y98+xsaR5Ro+W8AfARZDiB/zjx5gvxDQpJq1qkpX331uTRp1lBZgNEZOnC5 + FbxjmNfbFUN5VRgunSKoFmmbpydhBK2WZPJCz6+//loGDhwoP/zwg8rqf/zxRxk5cqSa4uUkD6/2IdkM + IXw13D6z//btOyAkzJA27VpLwUIFVSnm5Y0Q5O2uCPHwdFeXateuXQMlYSkpAMsn+WHhpeGdCHvZV8Fe + 9iHpM1s/YTWCNm1aSThyBXoAzggauUWpwFJKGD68eCU4+Ob72bPzQk7+6ZMhAl7b/ypA4/s/bRRAFuBN + 4H0gF1DwjWzZfNy8fWYwg23SlI9k6amezUMwsepGfNxVunTtBHSQzl07SsfO7dUzeQxw/KBN25bStl1L + kNISrjBQiSAAyVGN6raLOxm7DVAUFAKJZRjg5eIMA3yl+2fcN5Yb5PM7btu7dy/1kIpmzZpKoUIFxM0N + hHvweQIu4u7mqjL+ylUqqqTOxcNLhSU/VAKly4SoWUCO+XNOgOUfiSuH2K9EAM+nBM7b4u23vxsegAJo + 0rwRQkdZNY/AQSUKqAoEw+llH451+AUkFnF2/ipjpowB6FcX9i2QE6CxMdw+OaL3NzdDAA/dP1AAKJ4j + V67ybj4Bu919fZP8g4IlrDxOrHJFqQgLrlItEp0BC65dC26+jtRtUE/qN2ogjfmEjBZNpUXL5tIMaI76 + ugWy7Lbt26LWbi7O3j7qiV0+cJPVI6spF05SKQYDBtG0cr4yL+B6tHQSb9T59B4UCp/Fw8e0sBzLlSuH + ivs2AXhICSSyEchDKqIcK4GQVszNQ7wDSikxVEOpWg1WXaUaX0Fsdbj36pFSvQasHGA5S9SuXVM9BIMP + xOCzjFj/G2jctAEIryh8MBXnBspXqiglUO4W9/J54O7tv79gkSKfZciYkaWbN2AWAPv6P0IAbDwIxqR/ + AfxzQpYbfCChc7Y33wzx8PbuhVj5S1EX9xlFXd3mF3Fxiy7i7LoWiClU3Hlr4eLOu7B8PxLHg7kLFj6S + I1+BIznyFDhZoJjzpSIeHjdcvX3vefqXEL/AYAlFFRAcFi5uvgHi7uWpSqgGINXI7A1vYIjAIJ+v/Mxl + FAYTw4EDByAZ/Bk5SntFeLFiRcTX11tK8UKOkCAJKxsK1xwq3v5+UtzdSw3xunp6oRSllUcoK68USatm + XK8hNUEwH/rQGB6vaXOIuHVz5cE6dGyrpsS7du+MsrOTdOveRbr36AxP2EV69vpE3SYeWqasePj6i2/J + oKSiLm5ReQoW/PK1rFmrow+DAT7bzx0oAuQFOJDDvqbh/Z+HALa0AEXAmMRQQHWqXABg3HLPmDGj/6uv + vVYaJ1Uh6+tZq2V9/fW6QOOsWbO2wHdtsaxjlldf7fpKliw9Mr/ySq9MmTN/ljlLli/wfR+s0z9rtje+ + ff31bD+8ni3bsNezvfHjG/966/cibu43nL1Yn5dADK8ozZo2VvV9K2T2TZs0loYN4ebrN1CunpbOa/6Z + Awz6dqAMGNhfOrZvJ8FBgcrF+yDZ48hbKY48Aj7+EJivT5Kzl/c9d7+A225e3peLubpecHZ3v+ri6Xm7 + mLv7XQg5sbCzSyJfi7i4J+J4Eou5e95z9vS6hzBxz8XL64GLl3eSq7efuPnQnfsB/uKpXHsJvJZQrxB4 + km9gUEKBokVGvJ/9w8aZM2eugj5j0lcK8AFcgcJAHoAGRvLZ1/8RSaDRGApYmmQCDG/AnIBCYOJC9fJE + eFuSPxAIhALhQAWAJ03F86aFekAjoAXQFugIdAN6AL2Az4Ev06ZL9+X7H+aYU8jV40oRN0/1DL/SZcvA + 7dZScb8jykOWiT179pRPe/WCBXZHGGmlHlzBq3YLO7ty7D7J1cv7gbOH1/1i7l6JRd08bhfF/goVdz36 + Ua48y7O+8caY9BkyDEiXPn3fdOnS9QH+DXwNfElkzJTpK+Q7fd9+550BH2TP/t1HOXIMzpk717CceXIP + z50374958uYblitfnqE5c+ce/mGuXMPfy559eLa33hmePUfOkRDPr97+/lPyFijwOfZTIW3atBE4L7p7 + /sEjXT77y7D6j4B3ALp9Jt3/EZava4YQ6BHoolgdsGyhchm7KAaquThAt8YTpSBKAnR3VH4YwCdaVgYo + ijpAA6ApQFG0AdoD/Bu0TmnTpuv+era3BmfPnWd6jrz5Y3PlL3gC4SYBpN6ABSaggjhXsFjxo7nyFtjz + Qc5cMdlz5l39Ua7cSz7IkXPe+x9+9Oc7738w9a133pv0xpv/GguPMyJjpswD06RJw8epfQJ0B7oAFGEH + gL9LUfLmilZAS6A5wGNrDPC/+eoDPOaaQDWA4q4E8I8bywMkmufIc+U589zp5j0BxnmSTu/J/qIRMePn + 7J1BPPv4H9EMMdBVcZyAnoHJIgXBE6OqmS/wZJkzFAPYAW6AB0BxMPsNAjgQwo5jJ1YFKIzaAL0FxdEY + pDWHtbbPlPmV7llee+3TV7O+3vvV17J+hrDSC6T2RDL1Sfr0GXrAcrunSZuWHoXEdraDYiLJZoIptmYA + vZGZVP52JEBiKVIeEwVLb8ZyjZ6Nx0xiKW6SS1fO86EH5LnRup0Bks3EjlZOwhnfaekMpSSd/cb+Y5j9 + r2hmUVDRjGU8UQqDSmd5Q3Gw1mX4YFlJr0GB0GtQHOxEdipdJUMJ3SYFYngOhhSSQnJIFAkjcQwvJJGP + S6VwSCrB9wSXUVRWkrk/is8gl79JYZJUWi09GYVLAZNQVkEklDGbAuc5kFyeD8+L3pB5Eg2BoZJeksZB + shlCDcL/MZb+MhpPlidNcdDNsRMYRtgh7BgKhfGPHUaR0FLYqexoWhA7nhZFgZAUWpshEiZTtEi6WxJI + 10vBmMHvuIzrcF2SzG1pwSSaoiPR/A0mtlar5THRanmMPFaGPx43Rc5z4LnwnAieH8/TIPn/FdEv0ozO + MnIMc1gxvAeti6GFVkcLZHghWfQgFAnJo6XSm5jB77iM63BdbsNtSTKt2LBew3L5m/RcJJrHYpBqHGMq + qX9jM0RB6zI8BomhOGiRJIvWSe9BoZBAxlkD/ExwGdfhutyG2xok05KtRKe2/+BmWCHdrDm0GDDcsdkt + G+C6xnbGflJbavtva05O/wO+DtMdUWk1UAAAAABJRU5ErkJggg== + + + + 127, 17 + + + 285, 17 + + + 413, 17 + + + + AAABAAQAAAAAAAEAIADbTQAARgAAADAwAAABACAAqCUAACFOAAAgIAAAAQAgAKgQAADJcwAAEBAAAAEA + IABoBAAAcYQAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAATaJJREFUeNrtfXeAHFeR + fk/YnFdhlVbJirbkgIyzccKJYGODTTbmMDkc2ITfAUe4w+A7zgHMgeGAM/EOMA7nnIMcZCtYVrByTrta + abW7s3Hir+d99fWqn7Z3ZnZnZ0eaV39sbc90v379+tU39arqVfksQ4YMFSz5RrsDhgwZGj0yAGDIUAGT + AQBDhgqYDAAYMlTAZADAkKECJgMAhgwVMBkAMGSogMkAgCFDBUwGAAwZKmAyAGDIUAGTAQBDhgqYDAAY + MlTAZADAkKECJgMAhgwVMBkAMGSogMkAgCFDBUwGAAwZKmAyAGDIUAGTAYBRpj//+c//K/8WC/+j8IeT + fz70oQ/1jXYfDR27ZABglMkAgKHRJAMAo0S24NfJv/uSf6qqqkqSPBQK8ZRDwv8qnMDwUvKPDQyJ0X4G + Q0c/GQAYJTIAYCgfyADAKJENAJ9K8mAw+Mskv/zyy9Xn4XBY8d27dyu+a9cuxTs6OnjpNuF/PJzbgLBx + tJ/J0NFHBgBGiQwAGMoHMgAwSmQDwOIknzp16jlJ/pa3vGXQ89vb2xUnIBAgent7ecprwv8gXBkXbWA4 + MNrPaih/yQDAKJEBAEP5QAYAcky24M+Qf7ck/5x99tnqHYwbNy6jdhIJ2ABbWloUJzDs3btX8VgsFpFT + HxdOYPi/5B8bGHrTupGhY5oMAOSYDAAYyicyAJBjsgHg20leVlb2r0l+ySWXqM99vuy8img0qvi+fcq7 + 6ADD/v37eQqtiX8TTmPi88k/xr1YWGQAIMdkAMBQPpEBgByTDQAbknz27NlzkvyEE07IyX1pLNTdizQu + 2rRT+J+E0734ZobPF5B/udSZJ3y28Gpp9/s5eXBDg5IBgByTAQADAPlEBgByRLZgnCb/vpr8c+GFF6qD + 6urqUe0XA4x092JPTw9PWSGcRsQnhdNqSQGfL3ym8GDyT2lpqQIEhjq3tLQclO8/nPxjA4FzI0O5JwMA + OSIDAAYA8pEMAOSIbAD4aZLX1NR8MckvuOCC0e7SgET34oEDiB/S3YvRaJRGQrVZqaKioi3JJ02aFEvy + MWPGVMhz1iS5DQDq2F6CqBjnxx9/nADyU+G7hJdpvDQFV/5PG0CeGO0xO5rJAECOyACAAYB8JAMAI0y2 + 4AflXyVBCxYsUKrzrFmzhtVuJII4n6Kiopw8Ryym5NtqampSfOdO2AwPcy8qKi4udvUrEIBN0O/3K97e + 3q6AIx6P75NLWoTHD+fBYJDt+A7n9nMrILGXKCr02QaA7+RkAI5RMgAwwmQAwABAPpMBAA+yBZdjUy68 + SuOVKY7JTxd+Q/LPZZddpg4oUOvXr1ecgCCasydR8FevXq24rYIrbqveitfW1ipOARpp6utDxrI9e/Yo + rrsXCQgNDQ3kMXlOCrriAUEKcp9HZNTWrVvVgK1ater+JLcB4J9y8qDHKBkA8CADAOmRAYCjmwoGAGyB + /k/5l5E3XgJbqfGMxojzlgJoq7qKU0DPOussxZcuXar4wYPwik2ZMkVxe4mQ1n3a2pTtzTp06JCLkwgk + 9fX1rmOq4iNNnZ2dihMYyOlepPtz8uTJik+aNEnx0tLSQdvdsWOHCqR6/fXXH0xyGwC+lpMHOkbJAIAB + gBEhAwBHBxUSAKgAHFtFVgE548ePV59TULPFKWBU1R999FHFTznlFMUbGxsVb21tVbyrq0txqshUmb2I + 7rjKSuBTVRVwi0BDIGD7FET2q64OuUgJSFxCZGszUipivwgINCpyScR+ERA4Lhxf+7rNSW4DKNOmfzmT + +3fcajFUmdZTrpWUe7P6JqsrJwORJ2QAwACA4gYADAAc02QDwFNJPmPGjIuS/KSTThrR+9mqquKrVq1S + nEk/h2qco4Bv2KA0YKu7u1txAgYFmyp/eTlsl0wySsEjpypeUlLiuo48lSqeLeJzMbEJAY7HdCMSsIuK + ihRidK381etJflL7L8+UpjiwuCCe8Guf8zjVnFcdsvGwSzjztHPXlELYRMI6KJwp19q089o0/nLyjw0w + m3IysGmSAYARIgMAmT2XAYDRoUICAOU2slXwK5N80aJFI3q/F198UfGyMkS2Dvd+DNGlqk4AoEBT9afA + 8766YBMweD2NkLyeSxfdvUiAyZV7kf1obm5WnMDA/ib6IHeXlH1P8So/lhIWlzKZchlfS5YiDmfksxw6 + POocqxMSMb8CjnjUp46j0bg6MxYBENnNMUXb1ck/NhAwVduokgGAESIDAMMjAwC5oUICALWddeLEiR9J + 8tNPP314DXoQBeuJJ7BHhW4/qrBDpTVr1ihOAdYDf6gqc3svgYHuQhrZaDQkIFCwaSRkaTIdWAhAunuR + 98+VEZHjy23LB5pUblUr3gtAmFiKJdKskkcUL43vyUm/PInAsrdT/RNqcb5R1mAbCEa1gwYAskwGAEaW + DABkl455ALAFn+4eVShj3LhxSgU7++yzR+R+GzeiQtfWrVsVv/TSSxUfqoBQ8CjIVIEp6GyXgkjBZKCN + fj0FO93raaTTrydQ6O5FXk83Za6Agf1jMtSDTbC1lcfwHuYX34/+xVfmpD9HkLyHro3YzGQPqwpgsgHg + p8NoddhkACDLZADAAMCAVKgA0HGrsxnmMuE0o8RTHOuftwr/n+Qfe+DU57aAT5PPzxB+unZ8inDl1+JE + Pe+884b1XAywodGNgrJ8+XLFGeKabmivF1HgqPrTOMf033rgDwOLuB1XD/yhe5BGNl5PYKGKrV9Pweb9 + +dz6/XX3pG6EpHEye8T8JO6pzPfBxCZNe7crHmhGYNas8D2K18a2DN5surdP8/NwO77p67PekI9uFU43 + JZOzqjTt9jwf0TTtBgCGSAYADAAMel6hAoAt8HyQO4V/Vv0NBNWD2CrhoA+UOOJb5wWrvj7W8GvlF4om + iurki1JpVx1QldUnLicqA0yYlHOo9OabyJbNgBoKBN1WTPmVantvKuJ2YQp2qsAdpv/WA3+4bTeVe5DP + o1/v5V7kOLNfvF53L+rXjx071nV9rhKbEPj27YWchTY8jOdvUXE6VkMPNmmVR/YNofUjyWsFZM9zTGy/ + X/3Q+RJALPtzxoLvEP6Z5B8bCB4bifEwADBEMgBgACAdKkQAuEY9iM/3lySvLE+oe/hLtDt6cWvw7/8i + 2annzMOuXrrXKGh0h+m0ebPaQ+IY51iSa6hEtxqBZ+3atYpnC2B0IgDogsWlQKrEIHrgDwWbqjKNdl7u + QS55dPcgr+f9dWDh+/ByL/J6Gh1192Kuti93d6N/B7a/onhiD4yGk/sgd1VW08AXJobIva6XAKNe2ZJk + 41WzfMNt7GoAs7U0MAAwRDIAYAAAJw6Re11/tACALei8VqW6sgX+ZtWgz1Izx5dIqDdva5bqPMqlI5/u + rRveWzU0APirdbfip591vuLpBths375dcQrqO9/5Ttf3FDAayVK5r2hcomAwUGfu3LmKz5492xoOEago + ILpgOu9B3HkUbLrDSF6BOySm7tIDh0i6e1Bf0uhGQPaHxP6Se11Pzv5Q8Hl/AhsDmXJFXc0w6vZt/Qv6 + 3/p3xSsTskQYKgCQ09QtgcKC50fww5bGNIqr4rI2EHxvOM9nAEDIAIABgIHIAIAH2QDwwSS335MqIlkx + txhvjMacDtFhxHnX0+1+IJ24x0QHigCBQppdWXo9BmTO5xSfNy89NxtDR1esQKWrK664QnEmsXzuuecU + pwCfdtppg7bHhBZMi83tvwz8Ga67iwJFoKEKTZXaK/Am08QgXtfrRkACpH5/PbGI7p4kMPF6LkmGen2q + 7c8jRXQjBt/4vOKN0WfdJ1BAKZ5h4RRsDwGnYPP3ppL4xopxlTLxmShGjJihdbyBpbLJ2kDg4c8cnAwA + GAAY8HoDAG4yAKBRx+0B5Z+qnBpXZa59C+ejLRpt4nH3BXxicQdZLD4pE9MBDEmnEIU3yxLv1RHNdZej + BmXJguvBq7EU8I1Foo9EnTvhB1NPLVmyRHECAAWZKjfLddNNlYqWLVsm/URHhxtizIlO0gNvvBJ7pAq8 + Ge71fD79erod6YbUr6d7UHdPUsC9rqeAe7k39esJAPr903cvum1qvl78YPi6MC/2Igu5Nb7tQbyXbimV + JoId0QScP2jO74CTela+IGDxhJISa0Biw/xFlOfpeW5bWO73rSS3AeA/0nxQ93MO5aIkGQAAGQAwAJCk + ggOA9tt8ynxRvaAMEj9jhjaeHl6KRArvBb+PaCMrL9qigBAwZGlhCVAcjKMfLTUXK+6vaJB2wVoOQGWf + +1ZEJpdPh7uuL4w3V1rKNzZwiCmJSwcuKZj0c+rUqUMdUkUEIk7wdBN7eCUGoWDoiT0oGKkSg6QK3PG6 + XndPerkHdfcmn4NuVl7P++vuTV7PpZJuxDzxxIV4i30w2vnC4v7slX62oMBKVPbpRjrBi/c9hefs2iXj + jfaKKacVwqtEMKWfjkDzAi83ZrpyIEZRi8ZPtrtiG7YXt1rKOmkDwAetIZABAAMAGDcDAHhuAwCDU8et + TsEMZZWqOlk6Nm2au+O6zj5USjVQTuomD/+JDhydEIzOvomK7028VfG+ogmKB4vwIkvEplkiA15cISmx + xs5XfFunqvFpbRGBvewyGP+CQXlBvoEDklI/Lp43VeCNV+COnhhEd7OlCryh+9MrsQj7N9zrU7kX6Q48 + ePCA69gnkTJjyvEeaxMQ0KK4bM7qAu8JifW5C0u/ygPPg8ew5GPOUx8FmbxcBFhXzY/wY2f8YjM7n0tk + zl8CAPvz5jbFOvdZT6uvb7TePpRuGQAwAKC4AQDhBgAGJxsAGuVftZui6lQJTJHtr47gZ/rAmZ4/3HbY + Tx0wuOTgCxAV1+qMCBPgsAQ4EhBEvx8qqY88gAnkL4GgBIqhijuFRCoAIIE6FAUNhTGxemJQrevHojCG + HpLbn5gDKnN7u1vl7XePgVfLxEnIq25rcwsmBVUPvNETg1Al5/079q/DcLUDAAN+AYYKAGBVBSSspAgT + lkbEUDvcmd3tkva7HZuqSvogqMGo9CfWo72uuHyO91Eaw/PXlALYPQWZkk6u+5tJuZ5/XsQfNC2g6ogl + xiYBgJ3YVmwDwMlDuZ0BAAMArvYNAAyTCgAATpR/ceMzJRRXSjh5Rvpka4Cy1c5Qrydw8EXxWOf8noBC + 9yc5/Zui4TFgJBytkI8hgJFEqau7iQTTWLuP49rKi7w/+zX+SQQBWLGiGrledqWGIdgRHybYoVK4Q6N+ + AS7YfK3SKFTy8SGo1OWRvdp93NzxXtF4dgSXEx0rm3C67yiwOh/qJqF8mX9e7dAtrssR3YbkEtreuSWh + ItBsAJg+lNsbAMiUDAAobgCgcAHgfPlXxUJWnQtV1RI300C7F7I6QKPVTrb64dVuwkOCvc7T++P1vVe7 + egwqBcrrOBUnpfo+03EZ7rgOl3LVDn8YuOTUiao/lwISwNa5HshtA0CdNQQyAJDrfni1awBg4OcZ7rgO + lwwAuMkGgKvk33vVjc8XmyC3mVLlzfYAHa3t5Fu/8qUf+dbOaPWD59Po53U9l0ZilLUktD20pgcBeTdZ + Q6rZZgBgpNvJt37lSz/yrR0DAOmRDQD/oP7xB36dZFUXNKINBiqkAoB8eeHZbidf+3W0Cka+t5OtflDl + D4cHP49GUQZMSeh06HXHXagE0AaCzkxubwDAAMDR0Y98a6eAAeCmJPcXBX+c5BXnT0UbdE/o7ot8GWgj + 6EdHP/KtnZHqB93EnWnKK92fXGpLaHRoKevlWGoXmg0AuzLplgGA0W4vX9rJl37kWzsGANxkA8APkryo + tOibSV563jS0wU0KqQKB0h2goZIR9Ny0ky/9yLd20r2egk8gSEV0y0qINje3hV7ZzzNUBhwbAFZl0l0D + AEdbv/KlnXzpR761c6wDQNttRb9M8oqKxKeSPHguUnM5Rop0ASBfJmC+9utYaydf+jHa7Tgh4L2ZXacD + ADdXLd7LM85L/rEB4IVMmjUAkK/9OtbayZd+jHY7RzsAtN5edl+S19b0vkc1cOYcfEEjRbaNgNluJ9/6 + lS/9yLd28qUf2WqHIdiS3n3IpIXch57fzY6pAD0bAB7IpDkDAKPdTr70I9/ayZd+ZKudYwYA7qhQ1RPr + xnSdoT546zx8QRVlqEZA0rEq6NlqJ1/6YZ4ns3aYki5do58XEQAEULqe3xmWw08nuQ0Ad2fSnAGAo62d + fOmHeZ7M2jlWAODQHWUbk7x2Yg+qX540RAAwgn509CPf2smXfqTbDo19qUJ90yWtOGzvizvVDSIRS7nl + bQC4PZPmDADkazv50o98aydf+pFuO8caALTdUdKc5DVT+5AL7IT57hN0FccIem7ayZd+5Fs7o9UP/hB6 + JfgYKhEAJNda5MVtCgBsnFGh+TYAfCeT5gwAHCvt5Es/8q0dAwCDUsYA0H57kbJmVM9OYPfPnDnuARqu + EVCno3UC5Hs7+dKPfGsnW+4+Gv2y/QPIhCBMEPIaioSGOqxfqa9vsr6YSXMGAAq1nXzpR761YwBgcHKK + gs6X2lnHHed+8KG6OY6VCXCstpMv/cj356HKP1x3nxfpJcJWblOCFzpg/TnJbQD4aCbNGQDI137kWzv5 + 0o98f55jFQA6brWq+K/qx4mSnnj6dHCq/qmKgubLBMhWO/nSD/M8I9tOquu5ySdb7j4vkqKwTqkzKRIa + 2ms9luQ2AFyeSXMGAIzA5Gc/8q0dAwBIOWQTShGxKOgkKQyiA0C+vLhstZMv/ci3dvKlH6PVDud9T096 + 5w+X9BJhmwEAnTusZUledaNUrU2TDAAcbf3It3bypR+j1U4BAcBJ8u9KdSMWBR2HMtdOOnAOXL690Gy1 + l2/PlW/jk6128v25yGn0G6kENTrpJcJYJHRzXNVptwHguEyaMwAwWv3Jt3byrV/5/lwFCADny7/Pqhux + KChDE2n8GOpA5PsLP9r74dkevLkJKyCcx0jwEpfy4/w8npB63z4c+6SdhIWUcFEfbMWxBNxUxZaKHLdb + h5Es6OuTu9JYluUfjGyNV6rrqfKPlLvPi+j+oztw927FOteHVX5wGwDGZNKcAYCRbidf+uHZngGAIV1f + gADgLgp6wVR3R9IFgHx70fnWTpbHpzs+QfFIAiGkFNS4DxOpNwyB7otXy3l4nxHx+nb1QtUMW5XyOQpT + ROU8nz8o3QYgBAOSGi6AqRUNQ1Cq/Mp2bNUXbVC8LrhJ8epipMjyJZAmO2jh2G+lWWQ21+PN7b3ZDnlP + l/Qioc0A2NCqLjVg1TdZxZk0ZwAg39oxAKC4AQAPGkUAUEVBfQEUBa28QCsJxkCIdOlYB4JstTfE69vi + xyu+7OCHFfeVjFW8vBhGpGAAQBAoBi8R1bKkBO+zVD4vknTvATm/SJK/BuVzvySCCciSoEja4cTa34wy + 1h1dEOzOEAQ91IHSVuE4BCoRwfcTS1coPq/sXrRrZbiddqTeH+f3aAk+icl39SKhK9p5hnqBNhCk5Zc0 + AJDv/TIAkNvx9mrPAACKgtoTRiUeKD9PyoLTLeEFAPkmUMdsv/A6QnEUalnepnJEWvMXnKt4w/iJiscl + UCvhw/k+MfL5fPJ5HPen8c+PvV9WTOK74nE55gdWXD7HUSSCpWBdHQpYhEIdwiHg4TBU+x4xonUL7xPV + +lDHAcXnVT2q+PTSpxUP6PM5V++PS9tUZe9zRToAdMj4vnqAZyjrvA0A+9JpzgDAMdMvAwAjMu4GAOQ+ + UhS0uAxFQUvOm45rWRIs0yVAKhp1gTq6+tUZn674axT8E96m+MSGyYp3d0MAo1EIsMi/AwhxZxMXp0RC + O3aTz2PmxAVAKithJAwEsDTYuhUhq5EI5kmfzJfeHghYJAoBC/eBR8VtuKDiD4pPKX5J69cIj3u+CT6J + yXfpfpdApNBLTTzjhOQfGwDeTKc5AwDHSL8MAGR53A0AuIlFQSsrURQ0cI4UBaVKMtxAIC/KssA5AS0W + jFVRcWvFxM2V4JAk8DxB7H62in0dMmAS+JGIp75nDp6zK9Go+Iq2Tyo+c84Fik+ejM87OyH4sRgFX3/l + XAJk6zESrvtUVcFd1dQEjbS9vU3xvj6o/N3dshToRgqtaBTXx2SpESwCP7HivxRvKHqddxrWuHlSvgo+ + iS+KAMAioS/s4RnnJP/YAPBSWs2le18DAAYA0nsMAwAjSqMFAAdvL79f3bem50p1IYuCUiXJViKELLvN + YgkkTjgQUZqRtT98iuJNvQvk/IB7KHwJeSxpJw63T5EfqlZDidoLZY0vfkPxqsBOxYM+vdwz2osJ0PDY + n+iTo6GGkKKd7gSMessP3aD49LkXK94ogt8jAhXXBDJXxCVFRQWAtasL7r/9+6GqdndjHMISKNTZCd7T + g/P4GglcxeWYZ6eX/1DGfZeMxhCBWJ9nFPh8FXydWCacRUKf3clv3p38YwPAQ+k0YwDAAMCIkAGAEaZc + A4BTFLReioKeJiXBOLEyBYARD5DBhGnqW6T42u6PKd4wBkax2jqo/mXlCHUtDiCCkkYqTtiQBLB0dUKg + uro7pX3wGSUPKz6tDO6qqGRLb+lDIM7ByGzpLvpTU4SJ21CyWvES3yE+UFrP25NAaO/rbdcrPmX2OxSf + 2jgN3/dIYI0sUfz+3Ap+f3fRXxoBi4sBxLt2bZfxBaD2ivuPbkH9c+61KSoWr3MpPjit6t8Ur7B2WoNS + qnlytAk+qbbWddj17Hb1ADbufiLJbQD4QzrNGAAwADAiZABghCnXAOAUBZ0gRUFPkZJgHOChDuAIGQ3j + sulla9fbFe+phpFs9kx0n+4wqqo0OoXDdFOJeyqCiRgWo1VYgK5NgKEu8bLiJ1b9VvHtfZcLv0LxqY24 + X6QPE7xJVGB/BEBwWu0dipf4nVDOAakvgVDeNzquV3zs1MsUnzljlvQzKs/jNvblWPP3eh02AABgaQRs + bt4n4+kODOqSghrd4t7q6cH7YIBSZS0AtszfoviZ4+7BcxZhqRGNY8nVQ7mOYh5E4ljqcV5EIminOrFF + 8Zo4lnRFFt5D/xItR4k+MiUGAskL7n1+Wx+ey/q6eq6brJ+m04wBAAMAI0oGAEaIcg0ATlHQKVIU9ESo + uIfFgA7eQI7dg3zRO7sRCttV8yXFZ0ydKZe7r4+LykwA6O3tcfG+3j55TPB2ca/VWK8qvqDqT4qv6kBd + hmA9gGDO7LkYv1aVr8Fqbtmr+F7ZJHNG7W2Kl/g7pCcUXOmfD8+x8tD7FR87HSr/rBlzZPjjAz5PvhE3 + DRGYduxQGawOE3QAaxeXXF0cfwJCr4wOrp80pUHxsgrZjCahy8Ei2ZTkd292CvgAAIEiuK27OjHe+5r2 + yvUYvxofAGFq8WLF632bcR3dwbJdedSBgdvwJRAv/PwWNUB9fdaPktwGgH9JpxkDADzfAMCIkgGALFOu + AaD99iCKgh4Xx4jPEyMgrTTcJpljQQ8n6lw87sMLjklo6a6uUxXvKnmn4uPGYuJEBLD6Q2G5BMDnfVFM + yKio/n2Oii2hqhGcX+LHdsxpVasU3xZ6CwY2iGSp5eIGc+4Xi8p9cH1dBVRivw8qctjC5qoEA5VkWCdP + gZGPS5j8IQ1I5fdAX3rwNdIoyQCl7dsRIkwgmDABqeYYKpxIcKlGlRyCPGYMMl+NY1LaFMR+0WtN2rwJ + At/cAkAOMXAqgffll01SY4q2K97oh7F3jA9G3GJr8KXbiBELhDhFQregSGib9fMktwHgK+k0YwDAAMAw + yQDAqFDOAcCrKKgOADplGRDiCQh4UxjeyE3tCH3tlVyI9bWYEExgYckL9IsbzufHsU9SV/n9AeGS0kqO + gxLiXFQEQfQHmfgiIOMuA8+EGBxQbYZx4votqqDCxT1GSfEzIIluO5mxflHxgtIuN9skMg5FHlrAjHel + N06dzNotKsK4cZvwhg3rFe/tBQCcccZZciwqv4YkXOqQR6MEcv059anNgCiMc3095suKFcsVJwCFxfjb + 1cNQZQBCJIz5PXY8jG9jigFcJ/jvUrzc1zyk8R0yMS045+HKLWqihfZbf0xyGwCuT6cZAwAGAAa/ygCA + 4gULAEcUBT1ZDhsRcuoIfrZTJWnAwbTVLWGE8K5sR2DPcTNgjDxuJoxiCRrFNNU0pqVvdlRL7u0RgWLo + bFCSWsZiMtFimGgEhp4+prmWtNkJdyhxVMaDKbSiMfYnNtDjWZygvB8nfp0ELPn9xfI9A64CrutIuorb + T6PsD5R+BoNud+DmzUgO2tMDAVy0CEs2AkDW7p5giDfGrbYWS8Zly5Yq3ilGQQJBVxcDlBiYhPffK6HK + M2ZNV3xmBYzAcwN/xPNlmsJsqMREPCwSug5LmdAuhADbAPDudJoxAGAAIEdkACCrlEMAcBcFPU3qDjTA + mOa4/4ZbICHFUiFqQeV55eA/Kj5hitr1aM2eDWPk1q1w17S1IUCkX1UWFdtPgY7L+EG1b2/Hi2cCCwak + 8MUHg5LkUpYS48fjuVtb26T9qJzPzS0RaQ/9nSfG0miUgkt3mPsVcAmiu/NqarDpg6ozjZBsR6fRDvzx + pvwEgOXLVU1Nq6ODAODelNTZ2S2f47i7C+9RmrFOPhWbzM7xfVHxYqs1N8OpA8AWAEDnVvilq260zkin + GQMABgByRAYAsko5BAB3UdCzRPDFDZM1ANBJE4SIBePLU83fVfycMy+U8yCY/aocAkeqq+Em6ejAi2ts + hHtp714Ya6qq8H1vL15ofT1UbQJAIIA37HNUfPSnThIx8LxSeQFU3YuLaUSE8Y7bYfuNdnqIrm/A+/D7 + 6moDAFm5e5oA4CQrle3U3JzEzWGdIRz7ZH4sWIBQ7Asrv6F4iXXAygmxRBjT8u9A4ZXODRE1oDYAzEmn + GQMABgByRAYAsko5BIDz5V8UBT1vCo5YmojbgONZSszgQSxJ9fR+lZvUOu8sdKsjBJWLxptgMDBgs/3u + JKrgcdexTsEgVXJdMAc+1nn/cLgF2gDA0QkAXAKEQvyBwEDPX4hQ74vKv6Z4zgCA7j+6A/cgJVjn2p79 + SW4DQEM6zRgAMACQIzIAkFXKIQC4i4JeOM1943QBYJgBQQSAZ/f/q+LnnHm+4qFOTCSqaFTd+2/LF+8f + 8JgTs99YqJ9nub7XA1OONN55CXiqYwMASTIAkCYxHT9DgvfvR/9e71ADV32TxJSnIAMABgByRAYAsko5 + BAB3UdALp+Eauh9YECRTAc/w/HQBwO/3EgzfoMe6IPafl+r7VGm2DQCAjnEAqFB5OHIHAEzHTwCQ7eah + pY4bUg20DQSD7tM3AKANhQGAkSIDAFmlHAKAuyjo+VIWnG6IdF9UjpYAhQsAkhAjSCOnZ0zwMMkd6pzp + dQYAskSc5zTGS/HV0MvOpiRlBLQBYP9gzRgA0IbCAEAqMgCQpEICAOV3KylHUdDit2lFQfUXNUKpqSIJ + BAI92wI34LEGAP0psyzXcX39+GGNW6ck2WQKLAZGtba1yTE+b5ftuRHZ9FJWARtSvQQ+zZgB4y8Lj3hR + TBKeHJmizABAVkkHABYJXbyXZ6gYdBsANgzWjAEAbSgMABgASJIBACEWBa2qRlFQ/1lSFJTutnTLgpsl + gOuY3WTCkdJS2XTEQCXZvLR/P4w6ry7FRF0nCTR27titeHMLVL5D7UhNFRfVPCKh2bEoU5CxDLeo7rIp + KkY3aJxLDyYZxWlOMk1Jrlkl7t+TFi5U/P3Xvk/xC88/f8Dx6AcEtHvMAkCuQ4FJTA/OIqHP7eI3Zyb/ + 2ACwZLDLDQBoQ2EAwABAkgwACLXeXnYPBqz3veqCM7SioDoAjNQS4BgBAAp8fR1eXMsBCPi6dRDsvz3w + f4o//sRTinNicnNTeRk2f1SUox0mKAlIijOmxIoLADDFWYlsfy6VENKiYkmJJklU+42HmlFSgCjSC0E+ + eAj93bcfE71FAKqmGtupv/edf1b86ivfhfuWSJJTAQAaJw0AZImYHlwC8UJPb+c3Kn+8DQCPDna5AQBt + KAwAGABIkgEAoYO3l6tNQPVjus9XH+hFQbP8ohw6YjuwAECeGQGPDAX2y+dUqSFg9fWYcLEIVPG7fvs7 + xf9+PwR+/XpVec2aNxvJVic0oBRYsRhbi2V7sR6iHBD3YEmJcDkOloInpAQalwqtEjBCwCgqInD4tPbd + gMBNVsXFEGgCUI8kQNmzG6W+lrwGgZo9C+nLv/2tf1L8yne+0zVuTAraDwAQuFNPPU3xVADgVe5cf1/9 + 5H4fFbKUWbnydcXbZQnFTWUUeJYtZ3LQvAUAeW+dT2+LyuF1SW4DwP8MOo6p2jcAMPj3BgAMACTpmAWA + 1jvKVSKQunHdSAxyqhQFTVUSLMtLAX0JcN45F+GBu/DivAGAL94/6DEFt7+ABT93J9/Uy233P6akB5fT + aeyiavzYk1Dpv/29Hyp+qA2COG8OjKq1kqCkaR8ENdSOCdcrSyyWJos7qrQYE+U5AiKgFZKKrFbKR09s + QCKUqdPhviuXUlqbNwNwqNI77WibqXRiIRWOc5mkpqqprpF+4by1GyDYa9bAC/W+q96j+M/v/InrvJUr + V8j7g+C95S0orMIlQTTK95Vw3Z9ApR/HoqxMwoIvuFFckrpyxpeWYry3b0eJMqaKYyqwUIhAgPfQnxqs + V54f7cw7AUviC6voBjxo5ZS4KU/eW+8zm1kk9MYktwHg54NdbgDAAIC7HQMAGH8DAKBDd5SpEaqd1DND + fXCyFAVlCjBuBx5hYiDQy50qItlaMO9kxQ8eRKQjC0s4BUGcAhHixqJA+1gIhBOIhTrkdGdXr0wcmWD9 + mqVf+5wFPhjoImnAZVx+8nPlRbUeeOgRxWfPQkDNOFkSbNmIAhMtBxjC6QYwCqRTuISbQJxuatuYmQzV + cgsIVd6ZMwA4p552quu81WtR2qxLUqqVMNTbg/QCHQSmmkq8p/oxAKCODgjQ40+/oHidFOS4+Z//yTXc + DFhqkFJfkYgIts8NeP1LFXxON2Xc4nmSks3PpZh7NtAIO3cOBPf+++9TnG7ShABGIOgG2B4pEhsWQI7J + cy867UTFL6rE8xTnegnAlGCyVIw+v0khVE8PAvhsALh5sMsNABgAUNwAgAGAAantjhIlYTXT+/BmjhcA + YEBJqrLgmZLH0iEsAPCHNz6v+EnHY0XCIpKt7YcUD4gAsRhnwucuuBHTP4+4C3/w84SmWjIhiKNyCgAm + NCNZt0zku/+kvKeOkXKuqPrNuxGquXMXAjb6VW+3UU43culJStP9nMR+c1zKZeKcfAqA9K2nLlJ841Ys + DdasWat4dVX1gO17EQuw8P4Nkj6exszFr7ymeEcHBOrC886Q8ZYAJplXcVHlY1LAJaGVRGOhFV7nlAqL + ud9fXK6n6k5j7F/+/FfFP/CBaxVnMdhqCa0N+gVoCfjyXOWy5KmtQTuLzgAAvGs8qnHnfAmgAYC1ZJMS + iFCb9TP1PDdZXx3scgMABgAUNwBgAGBAar+9SOlw1XN9sJrMQhpkz5JgIxQI1BfDi/mPR69U/LLLrlD8 + qaeeUPzVpSjRVFqCAfFRNXVCW33uz6kyMumnI/gyJLwuThWXA+ZWfekO6pFNNFu2QbArq6Fyj5cJt27t + OpwnhSeoylN11wWZPNXnJL+j8rqXEPp1/a/Jva13aiPqv1x86cWKd4RgXF3yKiJJuSTwe9cec1F/2XXw + SZMmKl5WivfzylKkcd/bBIE5cd50aV+SurL/VmbuPq/PqeLX1GAe/fEP/6v4u951meIHDh50PV9YioHS + eMhjjtO8uXCHT5sFI+un33I3ns+fo8IgJCbmYZLQNzahSOg+S/mZbQD4xGCXGwAwAKC4AQADAANS+21+ + NXLVJ5ZDx5gqlcKo+me7KChJA5KeKNxptzwCALjiHeD3PwAjDicqjV18Ml/qR3QPiGcgiZvoDoyLm2r1 + BhjzJkxEAE+NhN4uX/66qx9FoqrpgqwDQdwjyaouyP2hwIEBuZ5oxGvJwACYsWPR//d/4P2KNzVjyfLq + UqjuZaVlA17vRbwvlx5TpiCtfLUEsDzx9GLFo7Jp6IQ5sDXHtCXYcIkAwIIwd//694pffQ3ck4ckNDko + SzECY0QCneiWbJgAIJs3C0vh8ZNh7PzyuX9TvDKYYwCgsZb8TbhfQzutB9Q432S9Z7DLDQDoA2IAQHED + AAUOAB23OhEwaiSqFuFBrYkT5dMslQVP8wWHeqE63vi7sxT//KdgDLz/AZWt3HpNJqgDACNEFHwuKdZt + 3q74GCktViGbbJYtQ4BLkYTw6u47HjtuQxlHCqJjxGSAixihdFWfAk1gYXssWVYlgsbvHfelx9KAglIp + ySZv+OQnFd+4CUuYl155WfHamtqMxk0P3GlsBBAEROV//OkXFa8RAZ3eiEQosbh7yTVU6n8ujMd//eo3 + ir///TACtne4Q6T5PqKi+tMNOEEAYP58AEBvGO/rlvc9g/6XhobVz4xJB4DNKJLbuSXxUpJX3WidM9jl + BgAyJAMABgCSVAgAwDes/GtVp0M1tCRQwxF8BgSNkPGP1NqJCf2xHyOA4+bvw+1y3/1wt7362sgCAOUk + KIFGW3ehFFO4F88/bRrGZflrUPljsglHV/l145++DZWkB/7oAKIDgZdA8zq6t8g5wfXrKWjcjDNlCkKI + P/D+axR/YQlU9q2bEUJLd2K6pIcSz5mDTUM7diLByctLAJwLj4exuUw2OcWzBABVAgD/eSciZD/6sY8o + 3iZLAAKqFwBMnAij3wnHIyHKpm0Yh99+Hu99TEWPlVPivGC5cCkS2rUhrBC78ivW8YNdbgAgTTIAYAAg + SYUEAGLts1SLVefiwZ0URCNVFpykvfDmQxCkd3wTQPS7XyHE9t57AQBLXoMbcKQAICATtr0Tm0W270YI + Mo1Wa1YilLZdQl/pNtONfRSAQ4cOuY5TGfH0JYD+Pe+nA44u6CxvXiPv0QmB9SihRoA695xzFX/7JdiE + 9ZvfQoVOOMk+3QCVitgvuuUINC8sxhKjqwsANGvmFNd1Q10KOEsAWWLccRs2JX3iHz6ueFtHu2tcvQBg + 0iTIwYITEAD03Mvo74Pfgfu3oSY3ofEO0R1MIN4Lo23n6q6mJLeXABMHu9wAQJpkAMAAQJIKCQAWyL+r + VUPnSzpoliLKFgCk+UKbWsAv/CpWJn/+/d2K33ff3xVfOkJGQEellkChNeugYk2aBCDyxfDCV698U/GS + UrfgF0uABo16FHwSJxwFyOu8dIn3a2zE+6IRkABCXl+PgiPjx8PYxoQYOiBR4Bhy/dGPfFTxg+0wmr38 + IpYExdpzp0tcasyejaUABe+hJ1QeGuuEWQDYysoy6f/QytA7IdCyHfo/brlN8U9/9gY8vwBdKgCYMGGy + 4gsXQDwefRb9fOoH+EGYUJfl0PhUpANACwQltLxNWSerb7IGFQgDACnIAIABgCQVIgCcKf8qHafqouk4 + orEh3bLgpKEaceTFNR2AanrxNzFhf/ebuxS/X5JoLls2MgAQELdfawc2+TQ1I2R0znFQTV97CSmwGEqs + u+UocEzFRaLAU2D4PQWQgnvOOfDizJ+PRCwUXJ534AC2n65di807r7zyiuJ0J1LVnyPbX3kd+zVOjLpM + INImBUP0pQAFiIDxcVGdf/+nuxXvDHW5njtdYn8IXPPnIsUWA4S6+wAQx8/CijQcGZrbmf2vLMcP2A9u + xi7ZL33pi3juDI2A82VT3NPPwX35+A+Uxp17AGBoNue9vL/QkhYKnHohNhAM+EttACAFGQAwAJCkQgSA + S+Xfx5J/qi5BssojioJm2/3H9ggwctx0CAJzyTexvfQ3v4Qb58GH7ld8+XK4jzJ1S3mRo8pKdzbKJp/J + UyZgnEXV2rIRbqDSMrgpdTffQdlkwgnIic72KcCkj3wEbikKvh4YxImpGxfZLgOAnnzyScXvvfdeV/tn + nXWWDKt7M9C8efNc96PxTzcqEiBu+ARU57YQgOvhR5HwhKnB0iUn0CmO+TlrJtx/B1sxbi+/CvfagvmY + f0z0kalbkONXUQ5B+f53kVruKzf9o+LtsvmJgUneSwC8//nzTlD8mRdVvM1hADBCofFepAMAi4S+uI9n + qLWqDQAD7lM2AOBBBgAMAChewACAyA+/7y9JVnXJLEay4AQWBMkWANCY6JFghABw8beggv7qZ3cq/sjD + Dyq+QtI7ZwsAKMC9vQCiTdsQqMIAlaWvYDsrN7HoobgUJBrXKKBst0UAhCr6F77wBcUpwLwuU7cXBZVL + hf37YZy666675HkA3OdLKS9OdALJQin5tW3btgHb5XNNm4bUZtdcq+rFWL+Q9gNFTME2eHJRnbgkoZtu + mhgxH3rsacWr5b1OmYIfgEiGSwHdCPjtb35H8W98HfkyOjpDrvejA0BvHwBg3Djcf958AMALL2HJ9dgP + IHA5BwD+UNE4zyKhz+/mGWrC2gCwZcDLvdo1AGAAYKB2DQAUDgCoRAK+YPC/VPuXzWb2SUtGaGgd1ic0 + jYgpjIlNrZhQl9wIgfnPn96u+OOPQfV8PcsAwNRcu/ZAgCLifqqpgKCvW4vUWbrKT97cjCSfupuPgs3A + lBtugCpNI1yXpBTLFjFtN5cav/89tsHS+Hf66acrHhLVkdt1aYTcIaGl7L8eyPTlL39F8ZWrloO/8Ybr + vukSgY5As3Ah3GyLX0SAV5OUIlsoiUPoDUwXIPtToUFV/sbXkMTzW98BD8mSJxUAjB+LJcAcMVYufhXG + 58d+jPGYUD9CgXGpiAlB5DlDTzjy/tbkHxsAlg10mQEADzIAYABA8QIGgC8neVFpkYqYKL3oODcApEoG + murFUOVP043Y1CpGwK9Dtb3z1n9X/LEnUftw9SoVr5TxxPMcTwGA1euhCk+ejKVHs2wCOnAANhWq/lTx + OyVUmEY0qvR6gM+iRUjCSQGkap2tBBgkChSXGvfcg9DpPXvwHDQKEoAoAFwKvPkmApz0BCUEsksvga14 + +nHTFf/t3QgRznS7MCkspdMWzgcA7JDQ1pclmejC4+HOLJFt1+kOVzQakfeBH4iv3gTV/3vf+67iHaFU + AIClE4FzziwYTV+Ssu2P3gKAmlCf4yUAicZ5Fgl9fDO/uST5xwaAJwe6zACABxkAMACgeAEDgLKSlFYU + fS/Ji06b6K5zLcYlT9LfDI9DYjzMcJyaZDvwxb+C8eW2HwEAnnlaeSmt1WvXKD5cAKDAMJ30hs1w/82S + 0lrr3kRiDJbq0gGgqalJ3kPc1R/980svheAwBVefXmY9y8R+bNyIpcurr0K1JjBcfDGSgRKIZs5EGnMC + Gd2ZXNLQmDhREsR8+Dq4L3/+M5WN2kpI4ZVMjYERAYDpM+D280ny1oceRcjtFEm5NnECBDHd0GAKNFOa + ffGLX1L85ptRbDaU0giI5x0zBvefPRtA9PJyLH0evwE/QBMqR6hYbiqS7ehcCnQu3qMmsC12H0pyGwD+ + OtBlBgD0ATEAoLgBgAIHgPbb/LcmeWV1QBUZ9J89031CphNWC+zJlJxAoG/DDfNjeXHPPouim2skFHa4 + ABAISKKOdqjyuyX097gZCAFdvQJA4/O7A3HoxqKg6Cm49ICft73tbYpT9Y5ku8CKRgQoqv7LlrltQpdd + hvTYXLKMGYMSXjQGbtkCo5K+zZjP/6UvQKB+/793YxwOtLrumy5xHCZOhLGNBTgeegwptypLcb/GKXgf + RdJ+PMVSkv1lwNbnPgO36y23oFhrp5QDZ6EWLwAYOxaCNmMG3MGvrYDxedTcgCTOe3kfPU9tCuM5LPVi + bAD45UCXGQDQyACAAYDDzy9YADh0e8l/J3nNmOj16sSzpCw4jYDpCnKWjFpNB3HfSz8HY8fN/wLjzQsv + PKf4unUAgNLS4QEAS3w174exrkPKjk8aB+PjG28AAEqK0Q9OcLrR6MZjgg6q0DQOkk4+GSW5KGjRkUqv + LkRg3LAB5br1QJ+zzz5bcboB2X8G/KxZg+fWNxOR6M589HG4ZXfs3OFqJ11iuzUCjFMbsf32wUcQEFQs + AD12DBKJ1NXVD9gfnRwAkG3LN3ziU4rfcQfcyR2dYgT0pbcEmDENP4hLVyERzGM/w/cTxgxtu3LWiAVZ + nnlTdciejt9PchsAbhnodAMAGhkAMABw+PkFCwCtt5erGNu6Cd3vUh8sOt51A89EIBT4LCcLpRvwsq9j + YvzLd76t+GJJSLF+PYxzVGGHSgwA2rEbgTwM9a2vhvto3RoY0Zj4g/fjdl4a8zjxGRCkq/hUrelu44TL + thtQD1BasWKFq58kbgYiMFHVP/FEpL7ikkHvJ4+vu+46xZe8itDYtW8OzShLQa6S0NYZUs78sSdhBPQz + 8rUCwEsASJWSzDEClqA/H7se25nvvBOpwToF6PUlDgGgLwwBr63F/WZOh5Fy2WoY/x77N7z/UXMDchs2 + f6CXbFBLgFCrdUeS2wDwjYEuMwBwxDgaAEiSAYBCB4A7ytU+x7rGbkSKLJAlAAEg7JH8kBM9yxPZMQLK + ZqDv/r+vKf7KEpQE27BhveJZA4BdMOrE5DkqSzHhtm6C6kxjEpcANP4xxFd3C3qp+FS5uRTIljGQE5mC + T4CiEVCnyZOhatM4yX5wW/LLkvwyrL13Asm1Ukps3XosxVZIYZRSGTcrzVRhBIByAYDjxB355LNIvOEX + t2CVlF4rkfZrJPDIyxioGwE//EG4LX/xC2wr7+ruco2bFwDU1eE9NUqJvDfWYN49evMobQcm0dhKIHhj + I4qE7rVUZJYNAJ8e6DIDABoZADAAcPj5BQsAh35SrmJAa2f2QfIlpZSj2nNCU9D14ywTAeAySQjyT1/F + JpSlr0Hl3LAZRRFLS4YHAAwB3rKjST6RCUlg2IHAIG46ohuMAsaJo7vdUhn5GGLKpQEplXtLJ73QB0N2 + dTekTgxIuuQSFTnqCPYFF1yg+Isvvuj6nP0iIFx9NbYFb9+JBCmvyFLASY+eZpFWAkB1JYx8049DUtDH + H4cbkEuvylKZ6NIstz+T9OSkbLdYCo184NoPKP7rX/9a8dRLADx3bS3ckpOnwDi6dj0A4JGbsdQbNQCg + 4BMI1sHYG9pmqdhvGwCuGegyAwAaGQAwAHD4+ypYAGj7SZma6TXzLOio06dzJMH18uAjXBqMAHD5tyAo + N/0jUjktX47EHFu2YPNDpm6nI8cR99m5By80LBOgugwDvHMHBJoTUV8C6Km/CADpqvY0ZrE4J5c0qYCg + P4EJVFW6HdN1LzY0AFgZEkzBZuKQxYthbNUBgO1fcw2KbK5ei+3ANBpmbASUkmp19QhRZsGQRwQAaqux + nbdMxp/Trry8RHiFfO6ejw4AiPv26qsAWL//3X9jvFIuAfDcXGpMmYQl02opxvmYkxY8TwCARUI3xZ5P + 8qobrfMHuswAwBHjaAAAz20AQPFCBYD2O4qVTlu9sKRO3oQlIwM+UklBPchZAogR8MYvfE7xFa/D2LR1 + K0JVhw0AEgi0R0KAQyFsjhlbA5VfBwCG/HKbb3/ACQR3+/btiofDwysZpRcLpQDq5cOHSrNmIbT1jDPO + cLV37rkoCUYAIMCQ+Lwf/iiMai8sfk7xtWtgDNRLpKUiAiWNkkwy+oQYAcfVCzCyXSeRCMansgbfBwPc + Luwen5IiCMgVV75H8T/+AQlSunrxnrlU8QKA6ir0Z9IU9G+dJIV99IejvASgG5Tzn0VC1/Uqf2zlV6yF + A11mAEAjAwAGAA5/rsIFgNuDKC20qBo6nKiIFstYj3Doqk7OEkCMgF/87CcVf2PVSsUZ2jpcAKBRr60N + oaF79sO4N3EsjFJ7dze5zuP9qHIzFJgFSnbt2uX6Pl/pzDNRB4ZAQGBjINAScbdSQClQFOzrJbDm3vuQ + cGTbdnGXZuiW5RJjrhidwzLPXnwFS4pJDXDD0VjLnx+fFGYpK8Z0LZNSYvGYO3SZRsDLLnmH4vfcg12y + 3AyUCgBqqmGkHd+AH8SNMu8eHW0jIEuEcbz3wY3dubJD/WLZS4ApA11mAOCIcTQAkCQDAIUOALf51YhV + n1LFutL4Is0kntkmAsA7voVtop+5ARNu7ZvYjLF9O1SeTLef6uQY02QibhV34LhaqJaHxNhn+dwqOVV8 + AgA/7xHA3LlzZ07HK1O68sorFacbkm41quJLl8LYSpWaSxCO12c+jc01P//VLzBOrdwWnd77YJnxuAjq + woUnKb5ly3bFN27F+502AQCQkPkesPyudnxBWQqU4X35Am6BLioGsF1yEYyd9953n+LdPd2udnQACEcw + HyrFPdnQgHm4aTsAftQDgZwitsIlAK1zfVghmw0AVQNe5tWeAQADAEkyAFBgANBxq0WdTXR9vBl/ECNp + axrqWGwsVpC1IIviMuAJKSAinztcbkVjRbpcVBsCwDslIcg/fBybT9ZJIpBduyBgwwUADggLXKx+c7vi + tTUYlj4pghlPsHvutN8sxEEVmm6wlSuxVMn2Zp/hEgOarr0Wbjyq4CxGSkBjKjE+F4GNAPHuK65Q/N// + /Ucyju6EKakoLqXBiooxzgtPROq3xS9j6dHTK4lCxkEAEzHJUCfbgznxuSQplXlAgXeKkMqEfZsEOD30 + wAOKd/f2uPpzJAAA4CsqACwN42CM3rILBTgeuVlzA+qb4rhkTptbA/JEDOMZj+C5Y1Gf67KE+FHj0TiR + kRNOTdDqmyzXBDQAoJEBAAMASSpkABgv/yqrBgWBAxyPuVVAn8eE9vL6ZDr/2U5LGIJ01d9hlLrhYx9W + fN16pK3evRsvYrgAQCqRibN5214ZaAnwkWSXvX04pkCQMzEI3WXV1WI8lPTWXptxRotOPfVUF2cCk4su + ukhxuv8IBBQwPucFF0KQGCJ7111ICuqkBU/X/SeCwpDkcWOwBHlpCVJu1ch27MoKCSyi+0+mecCHeZrg + sSVG2jIGDOF8vqdzzkIClEcee1zxnh53QRYvACgvQz/GjscP0Y49eK/3Xo2l6NgSvPdELL2JntCAi+5M + jhvlJZHgOOrt8gTc8DB55AV8MDWgNgC4/NEGADzIAIABAMULEAD4mdpFUjVBjAcTqz2eQFN19IQhutGQ + A8O4FV3V0T6X7NzWnhBUw3f9Bcah6z+M7aebNmPTwx55EXzBwyWqru0dmOg7d8HNU18L915fN150QFR/ + vUQYN9/QTcjv35DSWcMNDBouMdT44x//uKu/TPN9wglQwR988EHXc+ilwT7z2c8o/vTTSM66bAXcdSzD + nYoco6Lwhcdj6bF1G5Z028XtOlUz/lli/AswQ4gIToDTV+RIL2/O4zNPh9uTZdS7e1MZAQUA5LnG1qM/ + 2/diXjxwLd7rpIpeuZ90g/JMhZzc53Hsxa00zyMXr3OozZEsAkBooOYcMgAAMgBgAEDxQgMAkg0Ed8i/ + Kn+yDQQYei8Ne4RtW00CAJffhYjGD30Quxu3ySagvXsR+JAtAOCESUgCijUb4YYaKwEmEZkYPI8Czvtz + YnObMAODaGRjaq7Rog99SNWLcICA/bzqqqsU5/ZfAgMBkYVDpsvmsLfLUuEHP0Sadhrd0jX+MbBorLgd + p07FNtsXpBRYiYznmHr8DlG1pvHPb9EYiPb88g/TtuvvJxBAe6e+9S2KP/f0c4r3hMUI6OxuHxgAymQJ + UC8AsKsJxr9HPwEAyFlhkMTgn3cdgKpv4/XDSW4L/tUDnW4AwIMMABgAULyAAYCS9JLwU5J/iovhTgi4 + bYOp+ztMgGjqliXAX2EE/OB7MVG3b8NmjH3NUBWzBQAkqph7myEgHWL8YkqqRJzj4FYx6V7Ty4Ez0IaC + xSVBrui978U22PHjx7v6wVRgDJl95hkpxCEAwc9pJLzuuo8pvmETkrHe8zeEANcxYCwFJcSPGosDABYs + wHttboZArZXUa9MnYft3QNzIPtGZfX63seyIpYDfPTG5NONS5kS53+KXMb37elmcFefrABCJhuV6/ADQ + 6LmvBfPivqvh5h1fNjqlwdhvW+DjcszYc7WmsgFg70DXGQBIQQYADAAkqeAAgGQDQZU0+GP56FMy7j75 + nEUIeWO/8MDhHUuXez1YSy8A4LonYQR833uQrXyHBAC17AcABIPZBQACXF8YArBxC+5XV4X+BH1i/Au4 + U3ERCOjWohuQE4slwShQVLmzHSjECU/VnslHqfIzkIduwIceesjVTxLdmuMkAOaa9wFIfvhvCPzpkc00 + qUN/8XzhMAR/+nSo/DSuvbxspYwvjmtle6/jBhMW0Nx/lqPyy6EUJdW3IdNNPF+MjUuXYKnRI4U/9HTn + OgCUCgBUiZuz+SCMob85H/0eVzI4AKR6vRquHXHs9bm9wonKcbdwtd/ZFvxnB7ufAYAUZAAAZACgQAFA + JxsQFsi/c4VPFD7h8GP7QSfLcaNw2U9s1UkH/QO1n5BdIbYqox4oGscj7guVqDf6sSdPVsdXvvtydf6e + 3TDOtbQckIEYvEBEpuQYkWRTyeadMDb2deJF11QVy31L5cW4gYDGP6rGDASiO41LAgIGQ4aZSCTTNOFs + hwVHmOCDRMGfNAnFNZny6+GHH3Z9ryceYT+ueg+A5I01MGI+/ZQ7WaffN+BrdTb7MOVXlST6mDUTST9X + rkZAV3sXxrWxoY4vQMZVE3CxSTuhwE7osXtK0xipBwLNkfLeK5bjOXrDqQCAqd7wnNU1cIu3HAKA33ka + 3tuEcnEPc7OSximo9nFceADPZw1qNbW7FRbeKh81y3jsPpzbpEqA2YK/3UqDDACkGiADAK5+GAAocAAY + LtkAwjc2TrgLOOIJHMfilpqhfVHwre0VKlPFlxafeGmSv+vtcD/tbYJAHThwUAY4uwBAomDTGLZ2M4Cn + ogif15RDkANF7oAgChBV/gkT8Lj7mLBBEoXQaFhTA8Gg0ZCFRfS045yo3GzEtOKNjY2uz2mEpPuOAT7H + H49Sby+88ILiBCZex363tbUpfuYZCJyZdwJU51t+hLLanECpjK9RAZAyMSrOkYIfW3ZiO+2ufS2KTxbB + Ly2hO1UAwHH3QU40m99hbke3+4/vgcT5MU2WHqtXobQX3bOpAIBLnKoqAEBrF8b11xcuV3xSRa96cTYO + qV8kG5+apb970C9rn3SFeeebU3B1ni3QHdYIkAGANMkAgAEAPKcBgJEivkHOpOLD+XFz56tqjGPGjlX7 + Qy88HyWr9jfDuNbaCmPMSAEAieXDDxyEYO2Q9OH1shSokaSRDDjRJyAFbMYMqL6ceNzMxAlI4x2BQRew + /s0j4AQmAgdVdl6/aNEi1/1pdCRA0DjG+xOYZoqgniWbZ/70x98pvlVSYbF9L9KTpM4QwTsoKdc2bIVR + tWEMxq2qHOc5qb5k+PoDfPgFjnV3H4FAHx/ne3l/UyYhQ9Z6KezRm9IISAAIynMD8DvFmFnet1tlGHnu + tW2r5VZ9Gmfs9/Cyt2aZDABkSAYADADguQ0AZIsosZzhJQPxaccdp2bi+IkTlVvjnNPfqr6MyIvbvhMq + eaZpqDMeMG1i7dyDwJX2dqjKtbJdtU5CRWnrpBFLn6AsDsrCHNxko28r1tOAO4MngMfnptGR7j3yLVuQ + Nn3VqlWufugAxUQfNFpe8W4k+vi/h5E4Y/HzWDJwqaKPc0L6yVleKQAxtRHPuf8gljJbdwG462uhStdw + m6/TncE3+zjeP83dpxthnZBuGTc+9/gGSeixCePSJym/GKBEAIiIgIclKWh5OZYwAXE3x+X+O7fteDu4 + 5DCzX53wPo/j7FSBHSYZAMh0wAwAKG4AwABAtu5dkg6fOmOGmsmTp09XADClYay6/vi58Ebu2AUAaGuD + SuskLMkQCNI93wnMkAmwQQKEYrJppK4SE3/iBHhJmUJMFzinYIUIMLfjUgCpOnMJoAuu7ubi5zQybt2K + UGm9bDmfk+NElb+xEWWvL7jgPMWfegbbfJ95GvEklfJcvI+ezNMnksmAo/o6GD93y7bZ/Qfb5PmgQtdW + MsGHM7L4G3ADp+P+I4BaA6v++rHX+xxbjwCtbTuxlAn3hV3jwfGi25IhwBUCVK2tmGeBsjJlBdy2caMK + vGnau5cZX3TB1zm/H6UsooeP9uje2wCAZQDAAMDoUD4AAKtHDgoANeJHmzF7ztfUxX7/+5L8pONnq5Mm + SbFGPXCG23mdJObMT+KU0hLV2nILBJNU6uSo4nGWpOJ9QCtWI0FJRxtU+XoJaZ00cYrrqb1CfvuLWEpS + SxF8AoQu+DyfKitVeD3wxRl06TDHidfNnTtHOAD1+eefV/yll2AspPFQd29SECuq3NtkoxG0u7sJAVo9 + okqPqcN4VMjzcBT8AZ+rPUfgafxzBJ/pyAOuceC4Oqq/5V4S6ABZWQVVft9uAGUkRgCwXONdKtubwwIE + B0XwowmfeqCertDNSb5l4waVWcQGEm7C6U2Tj2pmGAMABgAUNwBgAGC07k0AoNtvUCBonDZN6ahjGiar + zUk+X0xFppSWlqn2qsQIxu2jAclfHqCRiBOEqbxoXApS5XQX/HCMd3IegaTfyITjIjEKRWUJsOR1CTDp + hkDWyuahxokI1CmW0FkKsFf5b13FJ09l9NKNX7wPBZ+BSccfj8AgqrYPPghj39q1CM2lsY/38fsxLizP + zVDmoPTzkKRQa+tEgAw3+Uwch3aCfgqs9IshvNq49ku0e7L4tFBfJ4JWA4BUQFsq/W9rxZKkpFwATk7v + 6MJ7aw9Bnts7u9ULKvIFVAaars42VVV025YtL6txDTuC76X68/Me7XMDAMINAAxABgDck8UAQHYpH9yA + xR7cCwjU97V1dcqKM3PWLLXbpaO7R0XWFAeKYD3zJdQbtd+/RJYkSg9vJ56IB2UAlORGEwnFE9GYmumx + BNJPOmW34zivtLxU6brBkqISuZ/iQUEMJyGIJAyh8a+tHYLhi2EeTBgHI9QYMUYVicrPkF19Oy4BSVdl + dUEnkLDfPI/bkgU/HQBYs0ZVj7ZefBHpvwkQTARSrKU9ZyBURPCqU/rb0xt19bukGP0dVyeCz+ScIsA8 + DmrA4hcgLg4SiItc3xOogzpQB9xLAic9to8JRNzAGQxgvFm8dZ8sVdpCzrZmdUGoo/0pPF+3Wgu17Nun + KtF0hkJSIy6luy+V6l+wRkCSAQDLAIABgNGhfAAA+sX0gKBUwOA6Li5GTSlbkJSA2i+6FJzn+9zXUeDl + frYABVNw1U+fSFTA71fX2UsKmZmYob64WK38fB7sZvH5gyrr5aSpU5W7yJ7YSjeukk0vY8fUCYcRrbQM + qjM30URkaRGNyWaguFvVpdGQobl0I1aKEZLAsFdKWa0WwWcoMENcg9JOwO9e8kSiEKBIHP9EY0jYbj+H + 6lAiGumRfqrP/TI+9nipcY/FUaoqHktIIhm6abW82E7oL9ZejhvQsRbyDEiyTxClf0mUcLXnGGkTfu0Y + PBbD85SWlSqEbj2w/w9JHmrrUNVQ21rht+zt7aWKT8HtS8F7PT7n9QUfCEQyAGAZADAAMDqUDwCg9yVd + QEgFFEUePOhxrPOAx+fFKdoLeLSjnouq6vgJk9TunJqx41Q2ThtIlE5eUYaVSo0EyLBMd41sPy0TAS8V + N5VjJJSZzQCWTgkl3rcfATh79sDd1dOLeWgLPIq+isTEpTJH3EntJn7QBCayvaRQgtAV6lCRM+1trSqG + tqe7+wDOT7j3Kfd7+MhdVs5AEFbasrIyLp1cPCAP5g84sb4YP9HlfQIJcR8WWYmYLNm4mUeAs6+Pm6LK + 1PXVtbVqYKukxtjBAweUSr97587X5ToU14zHdYH14n0ex/rnegmcvCADAAYADABYBgDykXRA0AWrKEOe + SvC9BFfn6bafqj08nB/7hiura1UkU2VttYoYsuf9THzvV7tWKsorlDUtIP42W0NWE9VWrZWARvr6lDWu + r6dPqeLhaLgLgxhQx35fvEfOR2op4bZgKwmJS37uaBS7YqIR5MiKRKJK9Y2E+xSi2PJN1TXmwb0EP57m + 9148loLH02xXv04XzEgKrgNAxONYL3aXX3XhhQwAGAAwAODmBgDynHRg0JcMXqp7Kj6o6m4dCUSpgCDT + 9iHYYlQMSJbRQEB4EBFNPu4+klxZcVtykzwWE1VY9uMmRKXncVxU80R/xJFHnem0BYjH+kT3EkwvIIin + OD+V4Cc82k3Vvkc5Wk9AiKbgevtHBRkAMABgaccGANzcAMBRSl5AoaviXp97fe8FPJkaFzO9ny/F95kW + nibpQJCuKp0uAKQrMF7A4aVKp+LpAli6wOV1/6OaDAAYADAAMPj9DQAUCPmGyL0AJltLkFRAlSkAeJGX + AOmfewmQfpyuiu2lcqcyLqbi1hDPKygyANBPBgDc3ABAAZABgOyTPqaplhjpLg0yXSKkUv11SqVKD9c4 + 6LVUiGrXDRg4NEA/DWWBDABknwwAgAwAHAVkAGD0yWspkUq19/o+FdcpU5VZF9RM3X1GgPOIDACMPhkA + MDRqZADg6CFfmse+NK/XKZHi81RGMyPYRyEZADh6yACAoayTAQBDhgqYDAAYMlTAZADAkKECJgMAhgwV + MBkAMGSogMkAgCFDBUwGAAwZKmAyAGDIUAGTAQBDhgqYDAAYMlTAZADAkKECJgMAhgwVMBkAMGSogOn/ + A9hgPQyFV99qAAAAAElFTkSuQmCCKAAAADAAAABgAAAAAQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAADAAAABEAAAAWAAAA + HAAAACQAAAAqAAAALAAAACwAAAAoAAAAJgAAACEAAAAWAAAACwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAKAAAAFAAAAB0AAAAmAAAALgAAADwAAABGAgAA + VBMUEWsmJCKMMTAtlyopJpEfHRqHDxANgQ4MC3sNDQpxAwMBYQAAAFYAAABOAAAASQICAUQGBQU9CAcF + NggIBjEGBgQrFRMRKQoKChYAAAAKAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAOEhAOGiQiHUkjIh5eHx4cbR4eGXkYFhSDHhwY + kiUlIZ0cGhagLy4q00xLSP9ZWln/Y2Jj/2tqaP9mZ2b/V1dW/zY2Nf8yMi//MzIw3CknIsMqKijHMzMx + yDg5Ncw/PzvRQ0RA0kdHRNNER0LUT1BL2z0+Oa0mJCBfDAoILAAAABoAAAAPAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAISkhCs2ZpaP9iZGL/YmRg + /2FlYf9gZGL/ZWdm/1dbVf87Ojj/UlJR/1hYWf9lZWX/amtr/2doaP9bW1v/ZGRm/3N1df84Ozz/LTAv + /z9AQP9BPz3/REdD/01RUP9OU1L/UldT/1dcWv9bXVz/X2Jh/0VJSP9HSEb/Pz860R0WDTAAAAATAAAA + AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZllK + /11hX/9QVFL/UVZU/1FWVP9TWFb/T1RQ/zMyLv9ISEn/XFpd/29wb/9ubm7/bGxs/3d3d/+JiYn/aWlp + /1ZWVv+DgoL/Nzo4/ywuL/8/QUD/P0E9/zs8Of9FSEf/SUtJ/0tPTf9NUU//XmJg/ztAPv8zNjX/Pzw4 + /zdAQHUAY7gGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIjwWACK8nAAh+6KAIjx + ngCP/7UAkP/IYFpT/1ZXUv9RVVP/UlZU/1JWVP9XXFv/OTk1/zo6O/9QUFD/WFhY/zk5Of8XFxf/Dg4O + /xgYGP9GRkb/iYmJ/3Fxcf9WVlb/gIGB/yYoKP8wNDP/RUZH/0REQP8+QkD/SEtJ/0pOTP9KTkz/ZWln + /zw+Pv8zNDL/Pjs2/xFmqP4Aj//oAITuzgCC6LgAg+mgAITrkgCI7msAAAAAAAAAAAAAAAAAmve7Aqf7 + /wCl/P8Aofz/AJ/7/wCd/P8AoP//XWFc/1lXUv9RVVP/UlZU/1RYV/9KTkj/NjUz/z09Pf9BQUH/Hx8f + /wAAAP8AAAD/AAAA/wAAAP8AAAD/NjY2/4eHh/9cXFz/a2pr/1pcW/80NzX/OT06/0xOTP8+Pjz/REdF + /0hKSv9HSkr/bXBt/zo+Pf8zMjH/RD04/w9ztP8Anv//AJb4/wCX+f8Amfj/AJn6/wCb+/8Ak/Z3AAAA + AACJ8AUDmfb/Bp/2/wKf+f8Bo/n/AqL5/wWl+/8Arv//ZWRg/1lYU/9RVVP/UlZU/1ZbWf9AQDz/MjIy + /zY2Nv8pKSn/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/2ZmZv9sbGz/UlFS/4iJh/8wMzP/PT8/ + /0pNS/9CQj7/P0JA/0VJR/9ITUv/dHd1/zo8PP8wMS7/RUE8/xaAs/8Frv//BKP6/wOh+f8Dnvr/A5z4 + /gKa9f8Aj/LBAAAAAAAAAAAZxfzzHc/+/xvM//0czv//Hc///x7U//8R3///a2pl/1lVUf9QVVP/UlZU + /1NYVv9BQj7/Kysq/y4uL/8LCwv/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/ysrK/99fX3/V1dX + /35/fv89QD3/QUZD/0lMTP9JSUX/PD8+/0RIRv9LT03/enx8/zc7O/8wMC7/SkJA/yObtv8d4v//HdH/ + /xzQ//8az///HM7//x7Q//8LqvmvAAAAAAAAAAAVx//rI9b+/x3O//8ayv//G8v//xrM//8N2P//bm1o + /1hWUv9QVFL/U1dV/1FUUv9DRUH/JSUm/yYmJv8GBgb/AAAA/w0NDf8bGxv/GBgY/xsbG/8NDQ3/AAAA + /xgYGP+CgoL/VFRU/3Z3dv9ITUn/RUlH/0dMSv9VWFP/Ozw7/0pPTf9KTkz/f4SB/zY6OP8vLy3/TkdC + /yGXtf8Y2P//G8v//xvL//8by///Hc7//x3T//8KrvqTAAAAAAAAAAASuv3jJ9n+/yPT//8g0f//IM7/ + /x7R//8R2v//dHNv/1lXU/9QVFL/U1dV/1FVVP9HS0X/ICEh/yMjI/8BAQH/DQ0N/0JCQv83Nzf/Nzc3 + /zc3N/9CQkL/AwMD/yMjI/90dHT/UVFR/3t8e/9ITUv/SU1L/0tQTv9aXFn/Ojw4/1RZV/9HTEn/h4mJ + /zU5N/8uLi3/UklH/yOXtP8c3v//H8///x/P//8fz///IdD//yHP//8Lqvp8AAAAAAAAAAATtPzWIdD/ + /xvM//8by///FsP//xPC//8Dyv//d3dz/1pYVP9QVFL/UlZU/1RYV/9JS0f/IiMj/yAgIP8GBgb/Hh4e + /25ubv9VVVX/VVVV/1VVVf9tbW3/ERER/0RERP9eXl7/SUlJ/46Ojf9ESUX/UFRR/1dcWf9PUEv/R0pH + /1VZV/9GSkj/j5GP/zQ4Nv8sLiz/VE1K/xqOtP8Sz///FcL//xXC//8Vwv//FML//xrG/v8MpvZnAAAA + AAAAAAASsPbPJtb+/yDR//8h0f//INH//x7O//8H0///fXx3/1pYVP9QVFL/UlZU/1VaWP9IR0P/NTY0 + /xsZG/8SEhL/BgYG/19fX/+Dg4P/fn5+/4ODg/9VVVX/FxcX/1JSUv9NTU3/VFVU/3+CgP9ITEn/UFRR + /1xhXv9GR0L/TlNQ/1NXVv9FSUf/lJeX/zM3Nf8sLSr/WVJN/x6Ts/8X2P//Gsr//xrK//8Zyv//G83/ + /x3I/P8NqPdSAAAAAAAAAAANqvfKJtb+/yHS//8fz///IND//x/R//8K0///gH96/1tXVf9QVFL/UlZU + /1NXVf9SV1T/QEE9/x0dHv8bGxv/DQ0N/wAAAP81NTX/VFRU/zQ0NP8LCwv/NjY2/0tLS/83NTf/hoiG + /0hPTP9QVFH/UFRR/1xfXP9ISUb/UVVU/1NXVf9DSEX/nJ+e/zE2M/8rLSn/XFRR/xiPsf8V1f//GMj/ + /xjI//8YyP//Gsv//xrH/P8Hy/8/AAAAAAAAAAAFpPfAJdX+/yHS//8h0f//IND//yDR//8O2P//kZGN + /05MSP9GSkj/SU1L/0lNS/9NUlD/RUZC/y0uLP8YFxj/Hh4e/xYWFv8HBwf/BQUF/xISEv8qKir/Ojo6 + /zAvMP9vbW7/ZGll/0xQTf9OU1D/W15b/05PTP9FSEf/T1RS/1BUUv9AREL/oqWl/y0yL/8mJiX/W1RQ + /yuixP8R0f//F8f//xfH//8Xx///GMn//xzJ/v8Aw/82AAAAAAAAAAAAwP+5Jtf+/yHS//8h0f//H8// + /x/Q//8L2f//pqmo/2xnZf9gZGH/X2Ng/11iX/9cX1z/XGBf/1JTUP8pKiX/FBMS/x0cHf8hISH/JCQk + /ygoKP8sLCz/MC8v/1daWf9obGr/S1BM/1FVUv9RVlP/SkxJ/zw+Ov9JT03/R0xJ/0ZLSP81ODj/oqOi + /ysxLv8uLCr/YVtX/0jC5/8Ly///Fsb//xbG//8Vxf//Gcr//xzJ/v8Auf8qAAAAAAAAAAAAtv+rKNj+ + /yHS//8h0f//IdH//x7Q//8Dzv//1tnW/+jm5P/e5OT/3+Xl/+Hj5f/h4+T/4uTl/+vt7f+srq3/SkpH + /xkaGf8UExL/Hh4f/yoqK/86Ozr/X2Ji/2JoZP9KT0z/Sk1K/z9BPv9JSUf/o6Oh/7/Bw//Nzs3/xcjH + /8TFxv+/wcH/29zc/5udnP+bmJf/kImE/1TO8v8Gxv//FcX//xXF//8UxP//F8n//x7K/f8AqP8gAAAA + AAAAAAAAr/+TKNr+/yHS//8h0f//IdH//x7P//8Bzv//19jX/+rn5v/c4uL/3+Tk/9/l5f/i5ub/4+np + /+br6//6/f3/6Ozr/7e5t/+KioX/YWBe/1FTTP9RUE3/PkE7/zMzLv85Ozb/UVFO/5qYlv/v8fD///// + /8/T0///////9vj4//f5+f/2+Pj//v7+/8DDw/+ko6L/kImG/1DK7/8Fxf//FMT//xTE//8Tw///Fsj/ + /x/L/P8Aov8YAAAAAAAAAAAApv96J9r//yHS//8h0f//IdH//yDR//8Bzv//1tbW/+bl4//b4OD/3eLi + /93j4//g4+P/4Obm/+Pn5//i5OT/6u3t/+/z9P/+/f7////+//r6+v/6+vn/7u3v/+Xk4//q6+j/+vv6 + ////////////9PPz/8XIyP/09vb/7O7u/+zu7v/r7e3/9/n5/7e3t/+fn57/j4eE/1DI7v8ExP//E8P/ + /xPD//8Swv//F8n//xzK/vkApP8PAAAAAAAAAAAAoP9lJdf//yPU//8g0P//IdH//yDR//8Ezv//3NnU + /+Lg3//O1NT/0dfX/9TY2P/V2dn/2d3d/9nd3f/f5OT/4ufn/+Ll5f/29/f///////////////////// + //////////////////39/f/7/v7/9PLy/8XIyP/09vb/7O7u/+zu7v/r7e3/9/n5/7e4uP+dnJv/joWB + /1PI7P8Dw///EsL//xLC//8Rwf//Fsj//xXE/vAApf8GAAAAAAAAAAAAof9OINP//yXW//8i0v//IdH/ + /yDR//8I0f//o8vR///m2//o3tn/2NvZ/9bZ2f/X2tr/5eXl/+bd2//r6en/8/Hx//rv6////Pn///z8 + //j4+P/4/Pz/+Pv7//r7+//6+fn/+Pn5//j5+f/7/Pz/8vPz/8fJyf/7/f3/8/Pz//Hu7P/w7u3//Pn4 + /7+5t/+pmZL/qJOM/zrI9/8Gwf//EcH//xHB//8QwP//Fcj+/xG//ucAAAAAAAAAAAAAAAAApP8+GMz/ + /ybX//8i0v//IND//yHR//8a0f//JM74/07L7f+QydP/6ePe/+Ph3v/W09H/xsnF/5LL2P/l2tL/0s3H + /5HT4v+o0Nn///jz///////9/Pz//fz8//z8/P/8/Pz//fz8//v8/P//////8vX1/8fJyf/U09P/3tbU + /+7v8P/17+3/+fLu/7u7uv+Otb7/R77o/wTB//8OwP//EMD//xDA//8Ov///GMj+/xC1/9kAAAAAAAAA + AAAAAAAJqP8rFsT//yja//8h0f//ItL//yLS//8i0v//G9H//wLS//9Rx+T/6ePg//fo5v/f1c//pcTI + /yHG8v+Z0+D/bsTZ/wDL//8AyP//f8nc///38f/9+vn/9vf3//b39//29/f/9vf3//b39///////3+Li + /7+/vv+7oZn/c7bG/yPL+v84xu//QcPp/xq++P8AwP//AML//w7A//8QwP//EMD//xDA//8PwP//GMj/ + /w6u984AAAAAAAAAAAAAAAAApP8QF7/9/ync//8j0///IdH//yLS//8i0v//IND//x/R//8a0P//Lcvz + /z3L7/83yu//Ic36/xPR//8TzP//Ec7//x3Q//8Xzv//C8v+/3zK2///9vD///v2///28//99vP/+PPy + //nz8v//+ff/39TR/9O4sP+Cvcz/EM3//wvL//8Nyf//DMn//xHJ//8Nv///Dr7//w+///8Pv///D7// + /w+///8Nvv//Gcn+/wyq9soAAAAAAAAAAAAAAAAAAAAAFbf5/ynd//8i0v//I9P//yHR//8i0v//ItL/ + /yLS//8e0f//GdL//xbQ//8X0P//GtD//x/Q//8f0f//Hs///x/P//8fz///F83//w/L//+Bytv/r9Pd + /7jZ4P/N4OP/2uHh/+fo5//d39//qsnR/3/B0f8ay/7/E8z//xvL//8by///Gsr//xnJ//8Zyf//Dr7/ + /w29//8Ovv//Dr7//w6+//8Mvf//GMr9/wSk+L4AAAAAAAAAAAAAAAAAAAAADrH5/yzg//8k1P//ItL/ + /yPT//8j0///IdH//yLS//8i0v//IND//yHR//8h0f//IdH//x/P//8g0P//IND//x7O//8fz///H8// + /xrP//8Kzf//CMz//wvH/P8TxfX/GcPx/yHD7/8gxPH/Dcr//wfO//8Wzf//Gsr//xvL//8by///Gcn/ + /xrK//8czP//Fsb//wu7//8MvP//Db3//w29//8Lu///HMz//wDA/68AAAAAAAAAAAAAAAAAAAAAB6r5 + /y/i//8j0///JNT//yTU//8i0v//I9P//yPT//8h0f//ItL//yLS//8g0P//IdH//yHR//8h0f//H8// + /yDQ//8g0P//Hs7//x/P//8fz///HM3//xvO//8az///Fs3//xXN//8Wzv//GMz//xvM//8czP//HMz/ + /xrK//8by///G8v//xnJ//8ayv//Gsr//xXF//8Kuv//Db3//w29//8LvP//Hs3//wC3/5YAAAAAAAAA + AAAAAAAAAAAABsn/8S7j//8l1f//I9P//yTU//8k1P//JNT//yLS//8j0///I9P//yPT//8i0v//ItL/ + /yLS//8g0P//IdH//yHR//8fz///IND//yDQ//8ezv//H8///x/P//8dzf//Hs7//x7O//8ezv//Hc3/ + /x3N//8dzf//G8v//xzM//8czP//Gsr//xvL//8by///HMz//xvL//8Pv///C7v//w29//8Ku///H9H+ + /wCp/3wAAAAAAAAAAAAAAAAAAAAACcP/2C7j//8m1v//JdX//yXV//8l1f//I9P//yTU//8k1P//JNT/ + /yLS//8j0///I9P//yHR//8i0v//ItL//yDQ//8h0f//IdH//yHR//8g0P//IND//yDQ//8fz///H8// + /x/P//8fz///Hs7//x7O//8ezv//Hc3//x3N//8dzf//HMz//xzM//8czP//Gsr//xzM//8czP//Dr7/ + /wy8//8Ku///INL//wCh/2kAAAAAAAAAAAAAAAAAAAAAB73/ui/l//8l1f//Jtb//ybW//8k1P//JdX/ + /yXV//8l1f//I9P//yTU//8k1P//JNX//yLU//8i1P//I9X//yDT//8f1P//INT//x7T//8f0///HdL/ + /x3S//8b0v//HdL//x7R//8e0P//H9H//x3P//8ez///Hs///x/P//8czP//Hc3//x3N//8by///HMz/ + /xzM//8czP//F8f//wm5//8Ku///Hc///wCj/1UAAAAAAAAAAAAAAAAAAAAABrr/pCzi//8n1///J9f/ + /yfX//8m1v//J9f//yfY//8k1///I9n//xrW//8X1f//FdL//xXR//8Pzf7/Dcv9/xDI//8Wy///FMj/ + /xLH+/8Ux///E8b+/xPD+v8fyfv/Fsj8/wnE//8Pyf//Dcn//wvI//8Ozf//Dsz//xHN//8W0f//G9H/ + /x7R//8dz///Hs7//x7O//8czP//Hs7//xDA//8Nvv//Fcr//wCk/0EAAAAAAAAAAAAAAAAAAAAABb7/ + kCfe//8s3v//LN7//yzf//8t4f//Gtj//wnL/v8Kxvz/EcH9/z/G8v8yv/j/Wb7p/3LA3v+Ez/H/hc/y + /5fN7f+hxuH/n8Lb/5/D3v+ixOH/o8Pa/6jE3P++zNf/osHa/4C/6P9+vuf/eb3l/2jC8P9bt+P/Ubrr + /za89v8mufH/Cbb9/wC8/f8Cwf//GM3//yHU//8i1f//ItT//x/Q//8Rw///Esb//wCl/y8AAAAAAAAA + AAAAAAAAAAAAB8H/ahvR//8l1f7/HMX8/w61/P8ApP3/IqXu/43T/P/A2+3/q77P/9XNzv/08vf/8OXl + /9HBvv////v///r2///27v/u49z/6dzW/+rd1//y5t//6t7Y/+jd1//u5eH/6d3Y/+ze1//w497/69zW + /+fa1//q3dn/4dbU/9jS1v/q6Oz/2+v4/8zl9v+Zzez/DqP4/wCl+v8JrP3/D7j7/xnE+/8Xy///Ebr9 + /wCn/wUAAAAAAAAAAAAAAAAAAAAAAAAAAACW85gAjvj/AJL5/wCX+/8AmP//v72+////9f/57ur/2dHN + //Lt6///+/j/7erp/7++vf/19PT/+/r6//f39//c3Nz/3t7e/9ra2v/X19f/4eHh/9ra2v/X19f/4uLh + /9ra2v/W1tX/3t3c/93b2v/h397/9fLx////+/////j///zx//bq6v+dyuj/B6H3/wCd/v8Amfz/AJf6 + /wCR+f8AlPboAJn0dQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/RMAZH1cQGS9WoAjv9qsaym + PsS7tlm1tbWf19fX///////6+vr/8vLy/8zMzP/h4eH/+vr6//v7+//o6Oj/09PT/9/f3//d3d3/19fX + /9/f3//b29v/09PT/9ra2v/j4+P/6+vr//j4+P////////77///w5v/H2dv/Wr/s/wak8v8Anvz/AKb8 + /wSp+v8Dq/7/AJD05ACS9U4Arv8NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACTk5MY5ubm//7+/v/5+fn//f39//Dw8P/T09P/9/f3//n5+f/09PT/3t7e + /9bW1v/b29v/3Nzc/9XV1f/e3t7/7e3t//f39//7+/v/+/v7//Hx8f/i3tv/s73C+iqs6f8Irfb/AK/8 + /wCz//8Bsv//A6/+/gar/+8CpPr5AJPzPwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIyMghx8fH09PT0+DX19fl29vb6uTk5Oy4uLj/5OTk + /9zc3P/+/v7/3d3d/9zc3P/Z2dn/5OTk//X19f///////f39//Pz8//e3t7/zs7O/8vLy//y7+7/4s7C + uAAAAAAAr/8SAK//GACv/xkAsv8OALL/BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACWlpY+4uLi//Dw8P/6+vr/8PDw/+7u7v/8/Pz///////n5+f/g4OD/x8fH/7q6uv/Jycn/t7e3 + w9jY2H7d3d2i6ebkeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAxsbG5//////5+fn/+/v7//n5+f/w8PD/1NTU+ry8vLDi4uI81NTU + C9jY2CXExMRn0NDQMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3t7ec/Ly8v/y8vL/39/f/8bGxsmnp6dnysrK + AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3d3dDbe3t+m+vr5j0tLS + FQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////////z9/////////P3////////8 + /f//AAH///z9/4AAAAD//P38AAAAAH/8/fwAAAAAP/z9/wAAAAB//P3AAAAAAAP8/YAAAAAAAfz9AAAA + AAAB/P2AAAAAAAH8/YAAAAAAAfz9gAAAAAAB/P2AAAAAAAH8/YAAAAAAAfz9gAAAAAAB/P2AAAAAAAH8 + /YAAAAAAAfz9gAAAAAAB/P2AAAAAAAH8/YAAAAAAAfz9gAAAAAAB/P2AAAAAAAP8/YAAAAAAA/z9gAAA + AAAD/P2AAAAAAAP8/cAAAAAAA/z9wAAAAAAD/P3AAAAAAAP8/cAAAAAAA/z9wAAAAAAD/P3AAAAAAAP8 + /cAAAAAAA/z9wAAAAAAD/P3AAAAAAAP8/eAAAAAAB/z98AAAAAAP/P3/wAAAAD/8/f/AAABB//z9//8A + AH///P3//4AD///8/f//gP////z9//+H/////P3////////8/f////////z9/////////P3////////8 + /SgAAAAgAAAAQAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAEAAAACAAAAA0AAAAUAAAAGQAAAB0AAAAcAAAA + FwAAABEAAAAKAAAABQAAAAMAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAGAQEBEAICAh0BAQEuAQEAPgEBAVMFBQVqHh4blTMyMbEzMS+uHh0b + qBMSEaEPDg2NBgYFdQcGBmsMCwphERAPWRMSEFIZGBVMEREPLAAAABMAAAAHAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCEfG01JSke7RUVCykBDP9NCQj/aPj864jg4NOxWVlX7YWFj + /WRlZf1lZWX8TE5N+zEzMPY1NTHvPj888EdKRvFNUU3xVFZU8VpdWvJERULmMDAspwkJCDUAAAALAAAA + AAAAAAAAAAAAAAAAAAAAAAAAjfIBAIzxCACM8Q8AYaclSU5LvF9gX/5VWlj/V1tZ/1hdWv88PTv/VVRV + /2hoaP9kZGT/b29v/3R0dP9kZGT/UlNU/zE0M/9AQT//QUNB/0dLSf9NUU//W19d/z9CQv89OzX8I0VZ + jABsvS0AjPEYAIvwDgCM8QUAAAAAAI3yCACX9bAAlfbWAJH04wCW+Oszcp74V1VO/1JWVP9TV1X/QUI/ + /z4+Pv9JSUn/FxcX/wcHB/8KCgr/TU1N/3R0dP9wcHD/Oj08/zk8PP9DRUL/REdF/0lMTP9eYmD/PUE/ + /zw0Kv8KdMP4AI728ACK7+oAjfHjAJH0xgCN8goAjfE+B6X4/QSo+/4Dqvv/Ba38/zmEp/9YVU7/UlZU + /1VZV/80NTP/NDQ0/xISEv8AAAD/AAAA/wAAAP8EBAT/b29v/1NTU/9oamn/Oj07/01QTv87PDn/RUhH + /2draf88QD7/PjMt/xOOy/8Gq/z/BaX6/wWj+v8Envj9AI3yPwWN8D4e0/7+G8v+/hvL//8X0///R5mt + /1hUT/9SVlT/UVRS/zIxL/8mJib/AgIC/wMDA/8JCQn/BgYG/wEBAf83Nzf/aGho/2psa/9BREL/Sk1N + /0JEQP9GS0n/bHBu/zs/Pf9ANC//I6rO/xrS//8azP//Gsv+/xvQ/v4AjfI1B4/uLCDR/v4h0f//Hc3/ + /xnS//9LnbD/WVRP/1JWVP9QU1H/MDEv/x4eHv8FBQX/Nzc3/zQ0NP81NTX/FxcX/zQ0NP9fX1//bm5t + /0hMSf9NUU//SEhF/05SUP9ydnT/Oj48/0Q4M/8jqcz/HdH//x3M//8ezf//HMz+/QCN8iIAjfEcHsn9 + /h7O//8cy///Ecr//0yctf9aVlD/UlZU/1RYWP80NDH/Gxsc/wkJCf9sbGz/ZWVl/2tra/8xMTH/Tk5O + /0ZGRv92d3X/TVFO/1xgXf9FRkP/UVVT/3h8ev85PTv/Rzs2/x2hzP8Wyf//F8b//xfG//8Ywvv+AI3y + EQCN8g4cx/v+ItP//yDQ//8a1f//UKK3/1pWUP9RVVP/U1dV/0ZIRP8eHR7/EBAQ/x8fH/9YWFj/QUFB + /yMjI/9HR0f/ZGNk/1ZcWP9QVFH/WlxZ/0pNSv9PU1L/foKA/zg8Ov9LPzn/HaLL/xjN//8YyP//GMn/ + /xbA+/0AjfICAI3yAhjB+/0h0///IdH//xnT//9ktsv/Vk9L/0pOTP9MUE7/S09M/y8wLP8XFxj/FhYW + /w8PD/8dHR3/MjEy/0RERP9pbWr/TlJP/1JXVP9AQT7/SU1L/0NHRf99gID/LzMx/0Y4Mv8ttd//Fcr/ + /xfH//8XyP//E9D99gAAAAAAAAAAF8/9+SLT//8h0f//FtD//3jN4//Iwr//u8C//7u/vv+7v77/vsC/ + /1pbWP8eHh3/Hh8e/yosK/9ERUT/W2Bc/0hNSv9ER0T/enp3/6Ciof+kqKf/oKOi/76/v/+DhIT/gXRt + /z7I8v8Qxf//FcX//xXG//8Vzf3tAAAAAAAAAAAZz/3xIdP//yHR//8V0P//ftPp/+zm4//e4+P/4ubm + /+To6P/o7Oz/7e/u/8HFw/+cnJr/iYmF/3+Bff9sbWn/fn97/8LCwP/39/f/3N7e//X29v/z9fX/9vf3 + /72+vv+Yi4b/PMby/w/E//8UxP//FMX//xXM/OQAAAAAAAAAABbN/Ogi0///IdH//xbR//+C0+b/5t7c + /9Xa2v/X3Nz/2t/f/93h4f/k5+f/6evr//v7+//8/Pz/+/v7//n6+v/7/Pz//Pz8//v7+//V19f/7vDw + /+zu7v/3+Pj/uLi4/5aGgP89xPD/DsP//xPD//8Uxf//Ecr82QAAAAAAAAAAEcj83SPV//8i0v//HNH/ + /0rN7f/O2t3/19nY/9ba2f/Y2dj/1dnZ/+3n5f/i5eT/9/n3//v6+v/6+/v/+vv7//r6+v/5+vr/+/v7 + /9XX1//u7ez/9O/t//f39//DubP/nJyZ/yLD+P8Owf//EcH//xTG//8NxPzKAAAAAAAAAAAQwvzSJdf/ + /yLS//8i0v//HNH+/xjN+/+/1dr/6OPg/8TJxf9Vx+P/rM7U/ybM9/9vz+n/9/n1//v5+P/5+Pj/+fj4 + //n5+f/09fT/xMG//6m2uP9q1fX/ftTt/0u+5v8cwPn/C8D+/xDA//8QwP//Fcf//wy6+7kAAAAAAAAA + AA+6+8Am2P//ItL//yLS//8h0f//HtH//yjO+P8+zvL/Lc72/xfP/f8Yzv3/Gs///xHN/f980eb/7/Dt + //Lu7f/08O//9vTx/+ng3v+6urf/Kcf1/w7L//8Pyv//Ecf//wy///8Pv///D7///w+///8Vx///CbX6 + qQAAAAAAAAAACrP6ryja//8j0///I9P//yLS//8i0v//H9H//x3R//8f0f//IND//yDQ//8fz///H8// + /xXN/f87zPL/Rs3y/1nN7P9p0ez/Tsru/yfK9/8Wy/7/G8v//xvL//8ayv//Fsb//w29//8Nvf//Db3/ + /xbI//8CrvqYAAAAAAAAAAADq/qeKtz//yTU//8k1P//I9P//yPT//8i0v//ItL//yHR//8h0f//IND/ + /yDQ//8fz///H8///xvP//8Yzv//Fs7//xTN//8Xzf//Gsz//xzM//8by///G8v//xrK//8ayv//FMT/ + /wy8//8Nvf//Fsn//wCi+oIAAAAAAAAAAAKi+Y0r3v//JdX//yXV//8k1P//JNT//yPT//8j0///ItL/ + /yLS//8i0v//IdH//yHR//8g0P//IND//x/P//8fz///Hs7//x7O//8dzf//Hc3//x3N//8czP//HMz/ + /xvL//8by///EcH//wy8//8YzP//AJP2agAAAAAAAAAAApX2cyvg//8m1v//Jtb//yXV//8l1f//JdX/ + /yLU//8i1f//HtP//x7T//8b0v//GtP//xnS//8Y0P//F9H//xfR//8Z0P//GtD//xvQ//8bzv//Hc7/ + /xzN//8dzf//HMz//xzM//8ayv//Crr//xXK//8AkvVWAAAAAAAAAAAAkfRdKN7//yrb//8p2///Jdn/ + /xfS/v8Yz/3/Kc76/y3I9/9GyfD/Ssr2/1fH8/9jxO3/X8Dp/2PC6/9qwef/ccXl/0a88f9Hv/L/N8H1 + /zHB8v8hw/n/FsX8/xDH/f8Xy/7/H9H//yDR//8Vxv//E8f//gCQ9D4AAAAAAAAAAAGO8Ssbyf32GMD8 + /wqz/f8eqfD/pt35/6vM3P/S1tz/6+3y/9rQz//2+Pf/9O7s/+jc2f/p3dn/6t7b/+fc2v/p3tz/593a + /+bb2f/g2Nj/3tnZ/9fb4f/d6/b/yuP0/zy19P8Fqfz/DLL9/xO7/f8Puvz2AI3yGQAAAAAAAAAAAI3y + AQCZ9U0Aj/fUAZX60lil0cTn3dPQ0s3L9vj4+P/39vX/xsXF//n5+f/39/f/2NjY/9zc3P/b29v/3d3d + /9nZ2f/c29v/4eDg/+3s7P/39/f/8/Xw/9Dj6/9hvO3/DKX3/wGh+/8Al/n5AJD3ygGd9UIAAAAAAAAA + AAAAAAAAAAAAAAAAAACN8gYAjfIHAI3yA6ampgfHx8fP9vb2/fT09P/i4uL/5ubm//b29v/m5ub/19fX + /9zc3P/d3d3/6enp//X19f/29vb/6Ojn/93U0fhBsOjjC6z35QOt/eUCrP3eBaz91gGb95sAjfIDAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMvLy0zS0tJ009PTgdHR0YvLy8vr6urq + /+/v7//m5ub/8vLy//f39//s7Oz50tLS+cTExPXc3Nzh6d7R1QCN8g8AjfIQAI3yEACO8wwAjfIIAI3y + AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AMjIyJH5+fn/+Pj4/+/v7/vf39/oycnJrLq6uknBwcFcycnJcKamphKqqqoUAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAp6enH9zc3OzNzc3AxsbGXampqRampqYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAp6enHaampgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//// + //8AAP/4AAAf8AAAD4AAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAYAAAAGAAAABgAAA + AYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAA+AAAAf+AAAP/+AD///gf///8/////// + //////8oAAAAEAAAACAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAQAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + BwYGBiMEBAQ6CAgHVR8fHokjIyKREREQgwoKCWcRERBcFhYVVgkJCC0AAAAHAAAAAAAAAAAAjPEHAHLG + KBQ0SnNTV1T6UVRS/UhIR/9PT0//Xl5e/1pbW/87PTz/R0pI/1RYVv88Pz34CC1JaQCJ7jMAi/AMCKP3 + lAmt+/8imtH/VFhW/0VHRf8mJib/AAAA/wYGBv9dXV3/TlFP/0VHRf9UWFb/PUA//xGb3v8Jqvr/Bp/3 + lhi9+5YczP//MbHX/1VYV/9AQkD/FBQU/zIyMv8oKCj/SkpK/1tdW/9LTkv/XWFf/0BDQv8etOL/Gsn/ + /xO5+5AVt/mHIdH//zi63P9VWVf/S05L/x0dHf88PDz/OTk5/1JSUv9WWlf/UlVS/2NnZf9CRUT/Hrbj + /xnJ//8StvqAFrr6eyHR//9Kze//q6+v/6mtrP+Ji4n/PDw7/z4/Pv9UV1T/eXt4/5yfnv+rraz/enx7 + /ynC8v8Wxv//ELL6bxKx+Goh0f//TdLz/9jd3f/Z3d3/3+Pj/+3v7//t7e3/6Ono//j5+f/j5eX/7vDw + /6Wmpv8pwvX/E8P//w6v+V8Qr/laI9P//yTR/f9w0+z/r9Xe/37S5/9u1/P/7vX2//f4+P/z9PT/s8nP + /37Z8/9Jvub/EcD+/xLC//8KpvhNCKH2SCXV//8j0///ItL//yHR//8g0P//H8///0XR9/9s1vP/b9Tw + /zHK9v8by///GMj//w6+//8Rwf//A573PQSZ9jgm1v//JdX//yTU//8j0///ItL//yHR//8g0P//H8// + /x/P//8ezv//Hc3//xzM//8Wxv//EcH//wCP9CsAjfImJtb+/yPS/v80zvr/VdL2/2nU8/900vD/c87s + /3fO6/9mzPD/Wsvx/0bL9/8myPz/G8r+/xTD/v8AjfIbAI3yAwSc93shnu2Z0dPUwfDw8P/l5eX/6enp + /9zc3P/c3Nz/4+Pj/+np6f+63+7/SLz2/wGh+/UDm/d2AI3yAQAAAAAAAAAAAAAAALu7uyTQ0NBwzc3N + pe/v7//p6en/4eHh69DQ0N3HyMmmApj1LwCX9i0AkPQXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AKmpqRPW1tanwcHBTKampgampqYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPx/rEHAA6xBAACs + QQAArEEAAKxBAACsQQAArEEAAKxBAACsQQAArEEAAKxBAACsQQAArEHgA6xB+D+sQf//rEE= + + + \ No newline at end of file diff --git a/Snap2HTML/frmMain_BackgroundWorker.cs b/Snap2HTML/frmMain_BackgroundWorker.cs new file mode 100644 index 0000000..e0a7573 --- /dev/null +++ b/Snap2HTML/frmMain_BackgroundWorker.cs @@ -0,0 +1,268 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using CommandLine.Utility; + +namespace Snap2HTML +{ + public partial class frmMain : Form + { + private void backgroundWorker_DoWork( object sender, DoWorkEventArgs e ) + { + backgroundWorker.ReportProgress( 0, "Reading folders..." ); + var sbDirArrays = new StringBuilder(); + int prevDepth = -100; + + // Get all folders + var dirs = new List(); + dirs.Insert( 0, txtRoot.Text ); + var skipHidden = ( chkHidden.CheckState == CheckState.Unchecked ); + var skipSystem = ( chkSystem.CheckState == CheckState.Unchecked ); + DirSearch( txtRoot.Text, dirs, skipHidden, skipSystem ); + dirs = SortDirList( dirs ); + + if( backgroundWorker.CancellationPending ) + { + backgroundWorker.ReportProgress( 0, "User cancelled" ); + return; + } + + int totDirs = 0; + dirs.Add( "*EOF*" ); + long totSize = 0; + int totFiles = 0; + var lineBreakSymbol = ""; // could set to \n to make html more readable at the expense of increased size + + // Get files in folders + for( int d = 0; d < dirs.Count; d++ ) + { + string currentDir = dirs[d]; + + try + { + int newDepth = currentDir.Split( System.IO.Path.DirectorySeparatorChar ).Length; + if( currentDir.Length < 64 && currentDir == System.IO.Path.GetPathRoot( currentDir ) ) newDepth--; // fix reading from rootfolder, <64 to avoid going over MAX_PATH + + prevDepth = newDepth; + + var sbCurrentDirArrays = new StringBuilder(); + + if( currentDir != "*EOF*" ) + { + bool no_problem = true; + + try + { + var files = new List( System.IO.Directory.GetFiles( currentDir, "*.*", System.IO.SearchOption.TopDirectoryOnly ) ); + files.Sort(); + int f = 0; + + string last_write_date = "-"; + last_write_date = System.IO.Directory.GetLastWriteTime( currentDir ).ToLocalTime().ToString(); + long dir_size = 0; + + sbCurrentDirArrays.Append( "D.p([" + lineBreakSymbol ); + var sDirWithForwardSlash = currentDir.Replace( @"\", "/" ); + sbCurrentDirArrays.Append( "\"" ).Append( MakeCleanJsString( sDirWithForwardSlash ) ).Append( "*" ).Append( dir_size ).Append( "*" ).Append( last_write_date ).Append( "\"," + lineBreakSymbol ); + f++; + long dirSize = 0; + foreach( string sFile in files ) + { + bool bInclude = true; + long fi_length = 0; + last_write_date = "-"; + try + { + System.IO.FileInfo fi = new System.IO.FileInfo( sFile ); + if( ( fi.Attributes & System.IO.FileAttributes.Hidden ) == System.IO.FileAttributes.Hidden && chkHidden.CheckState != CheckState.Checked ) bInclude = false; + if( ( fi.Attributes & System.IO.FileAttributes.System ) == System.IO.FileAttributes.System && chkSystem.CheckState != CheckState.Checked ) bInclude = false; + fi_length = fi.Length; + + try + { + last_write_date = fi.LastWriteTime.ToLocalTime().ToString(); + } + catch( Exception ex ) + { + Console.WriteLine( "{0} Exception caught.", ex ); + } + } + catch( Exception ex ) + { + Console.WriteLine( "{0} Exception caught.", ex ); + bInclude = false; + } + + if( bInclude ) + { + sbCurrentDirArrays.Append( "\"" ).Append( MakeCleanJsString( System.IO.Path.GetFileName( sFile ) ) ).Append( "*" ).Append( fi_length ).Append( "*" ).Append( last_write_date ).Append( "\"," + lineBreakSymbol ); + totSize += fi_length; + dirSize += fi_length; + totFiles++; + f++; + + if( totFiles % 9 == 0 ) + { + backgroundWorker.ReportProgress( 0, "Reading files... " + totFiles + " (" + sFile + ")" ); + } + + } + if( backgroundWorker.CancellationPending ) + { + backgroundWorker.ReportProgress( 0, "Operation Cancelled!" ); + return; + } + } + + // Add total dir size + sbCurrentDirArrays.Append( "" ).Append( dirSize ).Append( "," + lineBreakSymbol ); + + // Add subfolders + string subdirs = ""; + List lstSubDirs = new List( System.IO.Directory.GetDirectories( currentDir ) ); + lstSubDirs = SortDirList( lstSubDirs ); + foreach( string sTmp in lstSubDirs ) + { + int i = dirs.IndexOf( sTmp ); + if( i != -1 ) subdirs += i + "*"; + } + if( subdirs.EndsWith( "*" ) ) subdirs = subdirs.Remove( subdirs.Length - 1 ); + sbCurrentDirArrays.Append( "\"" ).Append( subdirs ).Append( "\"" + lineBreakSymbol ); // subdirs + sbCurrentDirArrays.Append( "])" ); + sbCurrentDirArrays.Append( "\n" ); + } + catch( Exception ex ) + { + Console.WriteLine( "{0} Exception caught.", ex ); + no_problem = false; + } + + if( no_problem == false ) // We need to keep folder even if error occurred for integrity + { + var sDirWithForwardSlash = currentDir.Replace( @"\", "/" ); + sbCurrentDirArrays = new StringBuilder(); + sbCurrentDirArrays.Append( "D.p([\"" ).Append( MakeCleanJsString( sDirWithForwardSlash ) ).Append( "*0*-\"," + lineBreakSymbol ); + sbCurrentDirArrays.Append( "0," + lineBreakSymbol ); // total dir size + sbCurrentDirArrays.Append( "\"\"" + lineBreakSymbol ); // subdirs + sbCurrentDirArrays.Append( "])\n" ); + no_problem = true; + } + + if( no_problem ) + { + sbDirArrays.Append( sbCurrentDirArrays.ToString() ); + totDirs++; + } + } + + } + catch( System.Exception ex ) + { + Console.WriteLine( "{0} exception caught: {1}", ex, ex.Message ); + } + + } + + // -- Generate Output -- + + backgroundWorker.ReportProgress( 0, "Generating HTML file..." ); + + // Read template + var sbContent = new StringBuilder(); + try + { + using( System.IO.StreamReader reader = new System.IO.StreamReader( System.IO.Path.GetDirectoryName( Application.ExecutablePath ) + System.IO.Path.DirectorySeparatorChar + "template.html" ) ) + { + sbContent.Append( reader.ReadToEnd() ); + } + } + catch( System.Exception ex ) + { + MessageBox.Show( "Failed to open 'Template.html' for reading...", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); + backgroundWorker.ReportProgress( 0, "An error occurred..." ); + return; + } + + // Build HTML + sbContent.Replace( "[DIR DATA]", sbDirArrays.ToString() ); + sbContent.Replace( "[TITLE]", txtTitle.Text ); + sbContent.Replace( "[APP LINK]", "http://www.rlvision.com" ); + sbContent.Replace( "[APP NAME]", Application.ProductName ); + sbContent.Replace( "[APP VER]", Application.ProductVersion.Split( '.' )[0] + "." + Application.ProductVersion.Split( '.' )[1] ); + sbContent.Replace( "[GEN TIME]", DateTime.Now.ToString( "t" ) ); + sbContent.Replace( "[GEN DATE]", DateTime.Now.ToString( "d" ) ); + sbContent.Replace( "[NUM FILES]", totFiles.ToString() ); + sbContent.Replace( "[NUM DIRS]", totDirs.ToString() ); + sbContent.Replace( "[TOT SIZE]", totSize.ToString() ); + if( chkLinkFiles.Checked ) + { + sbContent.Replace( "[LINK FILES]", "true" ); + sbContent.Replace( "[LINK ROOT]", txtLinkRoot.Text.Replace( @"\", "/" ) ); + sbContent.Replace( "[SOURCE ROOT]", txtRoot.Text.Replace( @"\", "/" ) ); + + string link_root = txtLinkRoot.Text.Replace( @"\", "/" ); + if( IsWildcardMatch( @"?:/*", link_root, false ) ) // "file://" is needed in the browser if path begins with drive letter, else it should not be used + { + sbContent.Replace( "[LINK PROTOCOL]", @"file://" ); + } + else + { + sbContent.Replace( "[LINK PROTOCOL]", "" ); + } + } + else + { + sbContent.Replace( "[LINK FILES]", "false" ); + sbContent.Replace( "[LINK PROTOCOL]", "" ); + sbContent.Replace( "[LINK ROOT]", "" ); + sbContent.Replace( "[SOURCE ROOT]", txtRoot.Text.Replace( @"\", "/" ) ); + } + + // Write output file + try + { + using( System.IO.StreamWriter writer = new System.IO.StreamWriter( saveFileDialog1.FileName ) ) + { + writer.Write( sbContent.ToString() ); + } + + if( chkOpenOutput.Checked == true ) + { + System.Diagnostics.Process.Start( saveFileDialog1.FileName ); + } + } + catch( System.Exception excpt ) + { + MessageBox.Show( "Failed to open file for writing:\n\n" + excpt, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); + backgroundWorker.ReportProgress( 0, "An error occurred..." ); + return; + } + + // Ready! + Cursor.Current = Cursors.Default; + backgroundWorker.ReportProgress( 100, "Ready!" ); + } + + private void backgroundWorker_ProgressChanged( object sender, ProgressChangedEventArgs e ) + { + toolStripStatusLabel1.Text = e.UserState.ToString(); + } + + private void backgroundWorker_RunWorkerCompleted( object sender, RunWorkerCompletedEventArgs e ) + { + Cursor.Current = Cursors.Default; + tabControl1.Enabled = true; + this.Text = "Snap2HTML"; + + // Quit when finished if automated via command line + if( outFile != "" ) + { + Application.Exit(); + } + } + } +} diff --git a/Snap2HTML/frmMain_Helpers.cs b/Snap2HTML/frmMain_Helpers.cs new file mode 100644 index 0000000..15e6d09 --- /dev/null +++ b/Snap2HTML/frmMain_Helpers.cs @@ -0,0 +1,155 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using CommandLine.Utility; +using System.IO; + +namespace Snap2HTML +{ + public partial class frmMain : Form + { + // Sets the root path input box and makes related gui parts ready to use + private void SetRootPath( string path, bool pathIsValid = true ) + { + if( pathIsValid ) + { + txtRoot.Text = path; + cmdCreate.Enabled = true; + toolStripStatusLabel1.Text = ""; + if( initDone ) + { + txtLinkRoot.Text = txtRoot.Text; + txtTitle.Text = "Snapshot of " + txtRoot.Text; + } + } + else + { + txtRoot.Text = ""; + cmdCreate.Enabled = false; + toolStripStatusLabel1.Text = ""; + if( initDone ) + { + txtLinkRoot.Text = txtRoot.Text; + txtTitle.Text = ""; + } + } + } + + // Recursive function to get all folders and subfolders of given path path + private void DirSearch( string sDir, List lstDirs, bool skipHidden, bool skipSystem ) + { + if( backgroundWorker.CancellationPending ) return; + + try + { + foreach( string d in System.IO.Directory.GetDirectories( sDir ) ) + { + bool includeThisFolder = true; + + if( d.ToUpper().EndsWith( "SYSTEM VOLUME INFORMATION" ) ) includeThisFolder = false; + + // exclude folders that have the system or hidden attr set (if required) + if( skipHidden || skipSystem ) + { + var attr = new DirectoryInfo( d ).Attributes; + + if( skipHidden ) + { + if( ( attr & FileAttributes.Hidden ) == FileAttributes.Hidden ) + { + includeThisFolder = false; + } + } + + if( skipSystem ) + { + if( ( attr & FileAttributes.System ) == FileAttributes.System ) + { + includeThisFolder = false; + } + } + } + + + if( includeThisFolder ) + { + lstDirs.Add( d ); + + if( lstDirs.Count % 9 == 0 ) // for performance don't update gui for each file + { + backgroundWorker.ReportProgress( 0, "Aquiring folders... " + lstDirs.Count + " (" + d + ")" ); + } + + DirSearch( d, lstDirs, skipHidden, skipSystem ); + } + } + } + catch( System.Exception ex ) + { + Console.WriteLine( "ERROR in DirSearch():" + ex.Message ); + } + } + + // Hack to sort folders correctly even if they have spaces/periods in them + private List SortDirList( List lstDirs ) + { + for( int n = 0; n < lstDirs.Count; n++ ) + { + lstDirs[n] = lstDirs[n].Replace( " ", "1|1" ); + lstDirs[n] = lstDirs[n].Replace( ".", "2|2" ); + } + lstDirs.Sort(); + for( int n = 0; n < lstDirs.Count; n++ ) + { + lstDirs[n] = lstDirs[n].Replace( "1|1", " " ); + lstDirs[n] = lstDirs[n].Replace( "2|2", "." ); + } + return lstDirs; + } + + // Replaces characters that may appear in filenames/paths that have special meaning to JavaScript + // Info on u2028/u2029: https://en.wikipedia.org/wiki/Newline#Unicode + private string MakeCleanJsString( string s ) + { + return s.Replace( "\\", "\\\\" ) + .Replace( "&", "&" ) + .Replace( "\u2028", "" ) + .Replace( "\u2029", "" ); + } + + // Test string for matches against a wildcard pattern. Use ? and * as wildcards. (Wrapper around RegEx) + private bool IsWildcardMatch( String wildcard, String text, bool casesensitive ) + { + System.Text.StringBuilder sb = new System.Text.StringBuilder( wildcard.Length + 10 ); + sb.Append( "^" ); + for( int i = 0; i < wildcard.Length; i++ ) + { + char c = wildcard[i]; + switch( c ) + { + case '*': + sb.Append( ".*" ); + break; + case '?': + sb.Append( "." ); + break; + default: + sb.Append( System.Text.RegularExpressions.Regex.Escape( wildcard[i].ToString() ) ); + break; + } + } + sb.Append( "$" ); + System.Text.RegularExpressions.Regex regex; + if( casesensitive ) + regex = new System.Text.RegularExpressions.Regex( sb.ToString(), System.Text.RegularExpressions.RegexOptions.None ); + else + regex = new System.Text.RegularExpressions.Regex( sb.ToString(), System.Text.RegularExpressions.RegexOptions.IgnoreCase ); + + return regex.IsMatch( text ); + } + } +} diff --git a/Snap2HTML/icon.ico b/Snap2HTML/icon.ico new file mode 100644 index 0000000000000000000000000000000000000000..b2510d41b689254f633b204556598fadcc66b93c GIT binary patch literal 35033 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 literal 0 HcmV?d00001 diff --git a/Snap2HTML/template.html b/Snap2HTML/template.html new file mode 100644 index 0000000..1e30421 --- /dev/null +++ b/Snap2HTML/template.html @@ -0,0 +1,1560 @@ + + + + + + + + + + [TITLE] + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + + +

[TITLE]

+
[NUM FILES] files in [NUM DIRS] folders ([TOT SIZE])
Generated [GEN DATE] [GEN TIME] by [APP NAME]
+ +
+ +
Loading...

(if nothing happens, make sure javascript is enabled and allowed to execute, or try another browser)

+ +
+ +
+ +
+
+
+ +
+ +
+ +
+ +
+
+
+ × Close + Show: + + + +
+
+ + + + + Columns: + + + + + +
+ +
+
+ + + \ No newline at end of file