diff --git a/AntMe.Online.Client/AntMe.Online.Client.csproj b/AntMe.Online.Client/AntMe.Online.Client.csproj new file mode 100644 index 0000000..7b4b5e1 --- /dev/null +++ b/AntMe.Online.Client/AntMe.Online.Client.csproj @@ -0,0 +1,105 @@ + + + + + Debug + AnyCPU + {43E44B6C-78F6-4515-88F2-C238B51886C5} + Library + Properties + AntMe.Online.Client + AntMe.Online.Client + v4.0 + 512 + SAK + SAK + SAK + SAK + + + true + ..\bin\ + DEBUG;TRACE + full + x86 + prompt + MinimumRecommendedRules.ruleset + ..\bin\AntMe.Online.Client.XML + + + ..\bin\ + TRACE + true + pdbonly + x86 + prompt + MinimumRecommendedRules.ruleset + ..\bin\AntMe.Online.Client.XML + + + true + + + AntMe.snk + + + + False + ..\packages\Newtonsoft.Json.6.0.7\lib\net40\Newtonsoft.Json.dll + + + + + + + + + + + + + + + + + + Form + + + LoginForm.cs + + + + True + True + Resources.resx + + + + + Component + + + + + LoginForm.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + + + + + + + \ No newline at end of file diff --git a/AntMe.Online.Client/AntMe.snk b/AntMe.Online.Client/AntMe.snk new file mode 100644 index 0000000..cdd75a4 Binary files /dev/null and b/AntMe.Online.Client/AntMe.snk differ diff --git a/AntMe.Online.Client/Configuration.cs b/AntMe.Online.Client/Configuration.cs new file mode 100644 index 0000000..782208b --- /dev/null +++ b/AntMe.Online.Client/Configuration.cs @@ -0,0 +1,63 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Online.Client +{ + /// + /// Konfigurationsklasse für den Online-Client + /// + [Serializable] + public sealed class Configuration + { + public Configuration() + { + ClientId = Guid.NewGuid(); + Roles = new List(); + Reset(); + } + + /// + /// Client ID, die pro Client Instanz im Idealfall nur ein mal erzeugt wird. + /// + public Guid ClientId { get; set; } + + /// + /// User Id des aktuell angemeldeten Users (oder Empty). + /// + public Guid UserId { get; set; } + + /// + /// Die Email-Adresse / Username des aktuellen Users. + /// + public string Email { get; set; } + + /// + /// Liste der verfügbaren Rollen für den aktuellen User. + /// + public List Roles { get; set; } + + /// + /// API Zugriffstoken des aktuell angemeldeten Users. + /// + public string AccessToken { get; set; } + + /// + /// Ablaufdatum des Access Tokens. + /// + public DateTime Expires { get; set; } + + /// + /// Setzt die Konfiguratin auf den Stand eines unangemeldeten Users zurück. + /// + internal void Reset() + { + UserId = Guid.Empty; + Email = string.Empty; + Roles.Clear(); + AccessToken = string.Empty; + Expires = DateTime.MinValue; + } + } +} diff --git a/AntMe.Online.Client/Connection.cs b/AntMe.Online.Client/Connection.cs new file mode 100644 index 0000000..bdbda02 --- /dev/null +++ b/AntMe.Online.Client/Connection.cs @@ -0,0 +1,349 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Net.Http; +using System.Net.Http.Headers; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using System.Xml.Serialization; + +namespace AntMe.Online.Client +{ + public sealed class Connection + { + private readonly string configPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "AntMe"; + private readonly string pluginGuid = "DB565C88-0E2C-450A-B5C7-3F7E6C363E39"; +#if DEBUG + private readonly Uri identityUri = new Uri("https://localhost:44303/"); + private readonly Uri apiUri = new Uri("http://localhost:13733/"); +#else + private readonly Uri identityUri = new Uri("https://service.antme.net/"); + private readonly Uri apiUri = new Uri("http://api.antme.net/"); +#endif + private readonly string clientVersion = "1.7"; + private readonly int timeout = 5000; + + #region Singleton + + private static Connection instance = null; + + /// + /// Gibt die zentrale Instanz des Connectors zurück. + /// + public static Connection Instance + { + get + { + if (instance == null) + instance = new Connection(); + return instance; + } + } + + #endregion + + private Configuration configuration = null; + + /// + /// Der aktuelle Status des Connectors. + /// + public ConnectionState State { get; private set; } + + /// + /// Gibt an, ob der Connector gerade beschäftigt ist. + /// + public bool IsBusy + { + get + { + return State == ConnectionState.LoggingIn; + } + } + + /// + /// Gibt an, ob der Connector einen gültigen Login hat. + /// + public bool IsLoggedIn + { + get + { + return !string.IsNullOrEmpty(configuration.AccessToken); + } + } + + /// + /// Gibt die User-Id des aktuell angemeldeten Users zurück. + /// + public Guid UserId + { + get + { + if (configuration != null) + return configuration.UserId; + return Guid.Empty; + } + } + + /// + /// Gibt den Usernamen des aktuellen Users zurück. + /// + public string Username + { + get + { + if (configuration != null && !string.IsNullOrEmpty(configuration.Email)) + return configuration.Email; + return string.Empty; + } + } + + /// + /// Liste der Rollen, in denen sich der aktuelle User befindet. + /// + public IEnumerable Roles + { + get + { + return configuration.Roles.AsEnumerable(); + } + } + + private Connection() + { + State = ConnectionState.Disconnected; + + // Load Config + LoadSettings(); + if (!string.IsNullOrEmpty(configuration.AccessToken)) + State = ConnectionState.Connected; + } + + /// + /// Öffnet eine Verbindung, falls notwendig. + /// + /// Window Handle des aufrufenden Fensters. + public void Open(IWin32Window owner) + { + if (!IsBusy && !IsLoggedIn) + PromptLogin(owner); + } + + /// + /// Beendet eine Verbindung und löscht vorhandene User-Infos. + /// + public void Close() + { + if (!IsBusy) + { + State = ConnectionState.Disconnected; + configuration.Reset(); + SaveSettings(); + } + } + + /// + /// Prüft nach eventuellen Versions-Updates. + /// + /// Aktuelle AntMe!-Version + /// URL zu einem Download oder null, falls die aktuelle Version installiert ist. + public Uri CheckForUpdates(Version version) + { + UpdateRequestModel request = new UpdateRequestModel() + { + ClientId = configuration.ClientId, + UserId = configuration.UserId, + AntMeVersion = version.ToString(), + OsVersion = Environment.OSVersion.Version.ToString() + }; + + using (var client = CreateClient()) + { + client.BaseAddress = identityUri; + StringContent content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json"); + Task t = client.PostAsync("/Application/Update", content); + + string result = Handle(t); + if (!string.IsNullOrEmpty(result)) + return new Uri(result); + return null; + } + } + + /// + /// Führt einen Get-Call zum API Server durch. + /// + /// Rückgabe-Datentyp + /// Relativer Pfad zur Methode + /// Rückgabe der Methode + internal T Get(string path) + { + using (var client = CreateClient()) + { + return Handle(client.GetAsync(path)); + } + } + + /// + /// Führt einen Post-Call zum API Server durch. + /// + /// Rückgabe-Datentyp + /// Request-Datentyp + /// Relativer Pfad + /// Request Inhalt + /// Antwort der Methode + internal T Post(string path, R request) + { + using (var client = CreateClient()) + { + StringContent content = new StringContent(JsonConvert.SerializeObject(request)); + Task t = client.PostAsync(path, content); + return Handle(t); + } + } + + #region Helper + + /// + /// Erstellt einen neuen HttpClient mit allen notwendigen Einstellungen. Muss disposed werden! + /// + /// Client Instanz + private HttpClient CreateClient() + { + var client = new HttpClient(); + + client.BaseAddress = apiUri; + client.DefaultRequestHeaders.Accept.Clear(); + client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); + + client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("AntMeClient", clientVersion)); + client.DefaultRequestHeaders.From = configuration.ClientId.ToString() + "@antme.net"; + + if (!string.IsNullOrEmpty(configuration.AccessToken)) + client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", configuration.AccessToken); + + return client; + } + + /// + /// Behandelt den erstellten Request-Task und wirft eventuelle Exceptions, setzt aber gleichzeitig den richtigen Connection-Status + /// + /// Rückgabe-Dtentyp + /// Request-Task + /// Methoden-Antwort + private T Handle(Task call) + { + try + { + call.Wait(timeout); + if (call.IsCompleted) + { + var result = call.Result; + if (result.IsSuccessStatusCode) + { + // Erfolg + var t2 = result.Content.ReadAsStringAsync(); + t2.Wait(timeout); + if (t2.IsCompleted) + { + return JsonConvert.DeserializeObject(t2.Result); + } + + State = ConnectionState.NoConnection; + throw new TimeoutException(); + } + else if ( + result.StatusCode == System.Net.HttpStatusCode.Forbidden || + result.StatusCode == System.Net.HttpStatusCode.Unauthorized) + { + State = ConnectionState.TokenInvalid; + throw new UnauthorizedAccessException(); + } + else + { + State = ConnectionState.NoConnection; + throw new HttpRequestException(); + } + } + } + catch (Exception ex) + { + State = ConnectionState.NoConnection; + throw; + } + + State = ConnectionState.NoConnection; + throw new TimeoutException(); + } + + /// + /// Zeigt den Login-Screen an und verarbeitet alle Rückgabe-Möglichkeiten + /// + /// Window-Handle des aufrufenden Fensters + private void PromptLogin(IWin32Window owner) + { + State = ConnectionState.LoggingIn; + using (LoginForm form = new LoginForm()) + { + switch (form.ShowDialog(owner)) + { + case DialogResult.OK: + configuration.AccessToken = form.Response.AccessToken; + configuration.UserId = form.Response.UserId; + configuration.Email = form.Response.Email; + configuration.Roles.Clear(); + configuration.Roles.AddRange(form.Response.Roles); + SaveSettings(); + State = ConnectionState.Connected; + break; + case DialogResult.Abort: + MessageBox.Show(owner, Properties.Resources.ErrorBody, Properties.Resources.ErrorTitle); + State = ConnectionState.NoConnection; + break; + case DialogResult.Cancel: + configuration.AccessToken = string.Empty; + SaveSettings(); + State = ConnectionState.Disconnected; + break; + } + } + } + + /// + /// Lädt die Connector Settings. + /// + private void LoadSettings() + { + string path = configPath + pluginGuid + ".conf"; + try + { + configuration = new Configuration(); + using (Stream file = File.OpenRead(path)) + { + XmlSerializer serializer = new XmlSerializer(typeof(Configuration)); + Configuration config = serializer.Deserialize(file) as Configuration; + if (config != null) + configuration = config; + } + } + catch (Exception) { } + } + + /// + /// Speichert die Connector-Settings. + /// + private void SaveSettings() + { + string path = configPath + pluginGuid + ".conf"; + using (Stream file = File.Open(path, FileMode.Create)) + { + XmlSerializer serializer = new XmlSerializer(typeof(Configuration)); + serializer.Serialize(file, configuration); + } + } + + #endregion + } +} diff --git a/AntMe.Online.Client/ConnectionState.cs b/AntMe.Online.Client/ConnectionState.cs new file mode 100644 index 0000000..2def73d --- /dev/null +++ b/AntMe.Online.Client/ConnectionState.cs @@ -0,0 +1,38 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Online.Client +{ + /// + /// Liste möglicher Connection States. + /// + public enum ConnectionState + { + /// + /// Connection noch nicht aufgebaut + /// + Disconnected, + + /// + /// Verbindungsversuch fehlgeschlagen + /// + NoConnection, + + /// + /// Vorhandener Token ist abgelaufen + /// + TokenInvalid, + + /// + /// User gibt gerade Zugangsdaten ein + /// + LoggingIn, + + /// + /// Verbindung aufgebaut + /// + Connected, + } +} diff --git a/AntMe.Online.Client/LoginForm.Designer.cs b/AntMe.Online.Client/LoginForm.Designer.cs new file mode 100644 index 0000000..dbe613f --- /dev/null +++ b/AntMe.Online.Client/LoginForm.Designer.cs @@ -0,0 +1,77 @@ +namespace AntMe.Online.Client +{ + partial class LoginForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + this.webBrowser = new AntMe.Online.Client.WebBrowserEx(); + this.CloseTimer = new System.Windows.Forms.Timer(this.components); + this.SuspendLayout(); + // + // webBrowser + // + this.webBrowser.AllowWebBrowserDrop = false; + this.webBrowser.Dock = System.Windows.Forms.DockStyle.Fill; + this.webBrowser.IsWebBrowserContextMenuEnabled = false; + this.webBrowser.Location = new System.Drawing.Point(0, 0); + this.webBrowser.MinimumSize = new System.Drawing.Size(20, 20); + this.webBrowser.Name = "webBrowser"; + this.webBrowser.ScriptErrorsSuppressed = true; + this.webBrowser.Size = new System.Drawing.Size(887, 633); + this.webBrowser.TabIndex = 0; + this.webBrowser.NavigateError += new AntMe.Online.Client.WebBrowserNavigateErrorEventHandler(this.webBrowser_NavigateError); + this.webBrowser.DocumentCompleted += new System.Windows.Forms.WebBrowserDocumentCompletedEventHandler(this.webBrowser_DocumentCompleted); + // + // CloseTimer + // + this.CloseTimer.Interval = 2000; + this.CloseTimer.Tick += new System.EventHandler(this.CloseTimer_Tick); + // + // LoginForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(887, 633); + this.Controls.Add(this.webBrowser); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.Name = "LoginForm"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "AntMe! Online Login"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.LoginForm_FormClosing); + this.ResumeLayout(false); + + } + + #endregion + + private WebBrowserEx webBrowser; + private System.Windows.Forms.Timer CloseTimer; + } +} \ No newline at end of file diff --git a/AntMe.Online.Client/LoginForm.cs b/AntMe.Online.Client/LoginForm.cs new file mode 100644 index 0000000..23e162f --- /dev/null +++ b/AntMe.Online.Client/LoginForm.cs @@ -0,0 +1,139 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace AntMe.Online.Client +{ + internal partial class LoginForm : Form + { + private string clientId = string.Empty; + + private string baseUrl = string.Empty; + + private string redirectUrl = string.Empty; + + public TokenResponse Response { get; private set; } + + public string ErrorMessage { get; private set; } + + public LoginForm() +#if DEBUG + : this("https://localhost:44303/identity", + "AntMeClient", "https://localhost:44303/Application/LoggedIn") +#else + : this("https://service.antme.net/identity", + "AntMeClient", "https://service.antme.net/Application/LoggedIn") +#endif + { + InitializeComponent(); + DialogResult = System.Windows.Forms.DialogResult.Cancel; + + webBrowser.Navigate(baseUrl + "/connect/authorize?client_id=" + clientId + + "&scope=openid email roles api&nonce=nonce&response_type=id_token token&redirect_uri=" + redirectUrl); + } + + public LoginForm(string baseUrl, string clientId, string redirectUrl) + { + this.baseUrl = baseUrl; + this.clientId = clientId; + this.redirectUrl = redirectUrl; + } + + private void webBrowser_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e) + { + if (e.Url.ToString().StartsWith(redirectUrl)) + { + var parts = e.Url.Fragment.Substring(1).Split('&'); + + var errorPart = parts.FirstOrDefault(p => p.StartsWith("error=")); + if (errorPart != null) + { + // Identity Server Error -> Close + DialogResult = System.Windows.Forms.DialogResult.Abort; + ErrorMessage = errorPart.Substring("error=".Length); + Close(); + return; + } + + // Success + var idtokenPart = parts.FirstOrDefault(p => p.StartsWith("id_token=")); + if (idtokenPart != null) + { + var accesstokenPart = parts.FirstOrDefault(p => p.StartsWith("access_token=")); + + Response = new TokenResponse(); + Response.IdToken = idtokenPart.Substring("id_token=".Length); + Response.AccessToken = accesstokenPart.Substring("access_token=".Length); + + var part = Encoding.UTF8.GetString(Decode(Response.IdToken.Split('.')[1])); + var jwt = JObject.Parse(part); + + Response.Email = (string)jwt["email"]; + Response.UserId = Guid.Parse((string)jwt["sub"]); + if (jwt["role"] is JArray) + { + foreach (var item in jwt["role"]) + { + Response.Roles.Add(item.ToString()); + } + } + else + { + string role = (string)jwt["role"]; + if (!string.IsNullOrEmpty(role)) + Response.Roles.Add(role); + } + + CloseTimer.Enabled = true; + return; + } + + // Fallback (Kein Token bekommen) + ErrorMessage = "No Access Token"; + DialogResult = System.Windows.Forms.DialogResult.Abort; + return; + } + } + + public static byte[] Decode(string arg) + { + string s = arg; + s = s.Replace('-', '+'); // 62nd char of encoding + s = s.Replace('_', '/'); // 63rd char of encoding + + switch (s.Length % 4) // Pad with trailing '='s + { + case 0: break; // No pad chars in this case + case 2: s += "=="; break; // Two pad chars + case 3: s += "="; break; // One pad char + default: throw new Exception("Illegal base64url string!"); + } + + return Convert.FromBase64String(s); // Standard base64 decoder + } + + private void webBrowser_NavigateError(object sender, WebBrowserNavigateErrorEventArgs e) + { + // Navigationsfehler -> Fenster mit fehler schließen + ErrorMessage = "Loading Error"; + DialogResult = System.Windows.Forms.DialogResult.Abort; + } + + private void LoginForm_FormClosing(object sender, FormClosingEventArgs e) + { + webBrowser.Stop(); + } + + private void CloseTimer_Tick(object sender, EventArgs e) + { + CloseTimer.Enabled = false; + DialogResult = System.Windows.Forms.DialogResult.OK; + } + } +} diff --git a/AntMe.Online.Client/LoginForm.resx b/AntMe.Online.Client/LoginForm.resx new file mode 100644 index 0000000..4eb20ea --- /dev/null +++ b/AntMe.Online.Client/LoginForm.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/AntMe.Online.Client/Properties/AssemblyInfo.cs b/AntMe.Online.Client/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..dc8156a --- /dev/null +++ b/AntMe.Online.Client/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 attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("AntMe! Online Connector")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("AntMe! GmbH")] +[assembly: AssemblyProduct("AntMe!")] +[assembly: AssemblyCopyright("Copyright © 2014 AntMe! GmbH")] +[assembly: AssemblyTrademark("AntMe!")] +[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("0b6b43b3-a47b-442d-a652-365c2c8be829")] + +// 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("1.7.1.6")] +[assembly: AssemblyFileVersion("1.7.1.6")] diff --git a/AntMe.Online.Client/Properties/Resources.Designer.cs b/AntMe.Online.Client/Properties/Resources.Designer.cs new file mode 100644 index 0000000..aafa755 --- /dev/null +++ b/AntMe.Online.Client/Properties/Resources.Designer.cs @@ -0,0 +1,81 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Online.Client.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("AntMe.Online.Client.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; + } + } + + /// + /// Looks up a localized string similar to There are some connection problems with the AntMe! Server. Please check your Internet Connection.. + /// + internal static string ErrorBody { + get { + return ResourceManager.GetString("ErrorBody", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Connection Problems. + /// + internal static string ErrorTitle { + get { + return ResourceManager.GetString("ErrorTitle", resourceCulture); + } + } + } +} diff --git a/AntMe.Online.Client/Properties/Resources.de.resx b/AntMe.Online.Client/Properties/Resources.de.resx new file mode 100644 index 0000000..e5f7c02 --- /dev/null +++ b/AntMe.Online.Client/Properties/Resources.de.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Leider konnte keine Verbindung zum AntMe! Online Server hergestellt werden. Bitte überprüfe deine Internet Verbindung. + + + Verbindungsprobleme + + \ No newline at end of file diff --git a/AntMe.Online.Client/Properties/Resources.resx b/AntMe.Online.Client/Properties/Resources.resx new file mode 100644 index 0000000..204ef49 --- /dev/null +++ b/AntMe.Online.Client/Properties/Resources.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + There are some connection problems with the AntMe! Server. Please check your Internet Connection. + + + Connection Problems + + \ No newline at end of file diff --git a/AntMe.Online.Client/TokenResponse.cs b/AntMe.Online.Client/TokenResponse.cs new file mode 100644 index 0000000..af99a48 --- /dev/null +++ b/AntMe.Online.Client/TokenResponse.cs @@ -0,0 +1,25 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Online.Client +{ + internal class TokenResponse + { + public TokenResponse() + { + Roles = new List(); + } + + public string IdToken { get; set; } + + public string AccessToken { get; set; } + + public Guid UserId { get; set; } + + public string Email { get; set; } + + public List Roles { get; set; } + } +} diff --git a/AntMe.Online.Client/UpdateRequestModel.cs b/AntMe.Online.Client/UpdateRequestModel.cs new file mode 100644 index 0000000..29d8436 --- /dev/null +++ b/AntMe.Online.Client/UpdateRequestModel.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Online.Client +{ + internal sealed class UpdateRequestModel + { + public Guid ClientId { get; set; } + + public Guid UserId { get; set; } + + public string AntMeVersion { get; set; } + + public string OsVersion { get; set; } + } +} diff --git a/AntMe.Online.Client/WebBrowserEx.cs b/AntMe.Online.Client/WebBrowserEx.cs new file mode 100644 index 0000000..f87d6dd --- /dev/null +++ b/AntMe.Online.Client/WebBrowserEx.cs @@ -0,0 +1,129 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Windows.Forms; + +namespace AntMe.Online.Client +{ + internal class WebBrowserEx : WebBrowser + { + private AxHost.ConnectionPointCookie cookie; + private WebBrowser2EventHelper helper; + + protected override void CreateSink() + { + base.CreateSink(); + + // Create an instance of the client that will handle the event + // and associate it with the underlying ActiveX control. + helper = new WebBrowser2EventHelper(this); + cookie = new AxHost.ConnectionPointCookie( + this.ActiveXInstance, helper, typeof(DWebBrowserEvents2)); + } + + protected override void DetachSink() + { + if (cookie != null) + { + cookie.Disconnect(); + cookie = null; + } + + base.DetachSink(); + } + + public event WebBrowserNavigateErrorEventHandler NavigateError; + + // Raises the NavigateError event. + protected virtual void OnNavigateError( + WebBrowserNavigateErrorEventArgs e) + { + if (this.NavigateError != null) + { + this.NavigateError(this, e); + } + } + + private class WebBrowser2EventHelper : + StandardOleMarshalObject, DWebBrowserEvents2 + { + private WebBrowserEx parent; + + public WebBrowser2EventHelper(WebBrowserEx parent) + { + this.parent = parent; + } + + public void NavigateError(object pDisp, ref object url, + ref object frame, ref object statusCode, ref bool cancel) + { + // Raise the NavigateError event. + this.parent.OnNavigateError( + new WebBrowserNavigateErrorEventArgs( + (String)url, (String)frame, (Int32)statusCode, cancel)); + } + } + } + + // Represents the method that will handle the WebBrowser2.NavigateError event. + internal delegate void WebBrowserNavigateErrorEventHandler(object sender, + WebBrowserNavigateErrorEventArgs e); + + // Provides data for the WebBrowser2.NavigateError event. + public class WebBrowserNavigateErrorEventArgs : EventArgs + { + private String urlValue; + private String frameValue; + private Int32 statusCodeValue; + private Boolean cancelValue; + + public WebBrowserNavigateErrorEventArgs( + String url, String frame, Int32 statusCode, Boolean cancel) + { + urlValue = url; + frameValue = frame; + statusCodeValue = statusCode; + cancelValue = cancel; + } + + public String Url + { + get { return urlValue; } + set { urlValue = value; } + } + + public String Frame + { + get { return frameValue; } + set { frameValue = value; } + } + + public Int32 StatusCode + { + get { return statusCodeValue; } + set { statusCodeValue = value; } + } + + public Boolean Cancel + { + get { return cancelValue; } + set { cancelValue = value; } + } + } + + // Imports the NavigateError method from the OLE DWebBrowserEvents2 + // interface. + [ComImport, Guid("34A715A0-6587-11D0-924A-0020AFC7AC4D"), + InterfaceType(ComInterfaceType.InterfaceIsIDispatch), + TypeLibType(TypeLibTypeFlags.FHidden)] + internal interface DWebBrowserEvents2 + { + [DispId(271)] + void NavigateError( + [In, MarshalAs(UnmanagedType.IDispatch)] object pDisp, + [In] ref object URL, [In] ref object frame, + [In] ref object statusCode, [In, Out] ref bool cancel); + } +} diff --git a/AntMe.Online.Client/packages.config b/AntMe.Online.Client/packages.config new file mode 100644 index 0000000..a98b0b7 --- /dev/null +++ b/AntMe.Online.Client/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/AntMe.sln b/AntMe.sln new file mode 100644 index 0000000..011722b --- /dev/null +++ b/AntMe.sln @@ -0,0 +1,74 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.25123.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharedComponents", "SharedComponents\SharedComponents.csproj", "{415F50C3-BD70-4634-B1F7-A15B42F0B0C6}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AntMe", "AntMe\AntMe.csproj", "{931D5011-AE62-420D-8503-F5441136876A}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DemoAmeisen", "DemoAmeisen\DemoAmeisen.csproj", "{B53ECAD8-961B-4179-BB46-993DA25DA6DF}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GdiPlusPlugin", "GdiPlusPlugin\GdiPlusPlugin.csproj", "{4083B1E6-5EB5-4E51-BB09-EEC4B489F355}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SimulationCore", "SimulationCore\SimulationCore.csproj", "{35753E72-07F3-4F18-916C-479850EC375F}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SimulationPlugin", "SimulationPlugin\SimulationPlugin.csproj", "{D622F308-35A9-4A86-8F2C-4E68CECA7C11}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XnaPlugin", "XnaPlugin\XnaPlugin\XnaPlugin.csproj", "{4FDD2B0D-C481-401E-A794-2111BF15F39E}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AntMe.Online.Client", "AntMe.Online.Client\AntMe.Online.Client.csproj", "{43E44B6C-78F6-4515-88F2-C238B51886C5}" +EndProject +Project("{930C7802-8A8C-48F9-8165-68863BCCD9DD}") = "Setup", "Setup\Setup.wixproj", "{EC7AA916-0218-436F-B4DC-510BDB769260}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XnaPluginContent", "XnaPlugin\XnaPluginContent\XnaPluginContent.contentproj", "{B09C7823-AFF3-45A4-AAAC-88821B464DEC}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {415F50C3-BD70-4634-B1F7-A15B42F0B0C6}.Debug|x86.ActiveCfg = Debug|x86 + {415F50C3-BD70-4634-B1F7-A15B42F0B0C6}.Debug|x86.Build.0 = Debug|x86 + {415F50C3-BD70-4634-B1F7-A15B42F0B0C6}.Release|x86.ActiveCfg = Release|x86 + {415F50C3-BD70-4634-B1F7-A15B42F0B0C6}.Release|x86.Build.0 = Release|x86 + {931D5011-AE62-420D-8503-F5441136876A}.Debug|x86.ActiveCfg = Debug|x86 + {931D5011-AE62-420D-8503-F5441136876A}.Debug|x86.Build.0 = Debug|x86 + {931D5011-AE62-420D-8503-F5441136876A}.Release|x86.ActiveCfg = Release|x86 + {931D5011-AE62-420D-8503-F5441136876A}.Release|x86.Build.0 = Release|x86 + {B53ECAD8-961B-4179-BB46-993DA25DA6DF}.Debug|x86.ActiveCfg = Debug|x86 + {B53ECAD8-961B-4179-BB46-993DA25DA6DF}.Debug|x86.Build.0 = Debug|x86 + {B53ECAD8-961B-4179-BB46-993DA25DA6DF}.Release|x86.ActiveCfg = Release|x86 + {B53ECAD8-961B-4179-BB46-993DA25DA6DF}.Release|x86.Build.0 = Release|x86 + {4083B1E6-5EB5-4E51-BB09-EEC4B489F355}.Debug|x86.ActiveCfg = Debug|x86 + {4083B1E6-5EB5-4E51-BB09-EEC4B489F355}.Debug|x86.Build.0 = Debug|x86 + {4083B1E6-5EB5-4E51-BB09-EEC4B489F355}.Release|x86.ActiveCfg = Release|x86 + {4083B1E6-5EB5-4E51-BB09-EEC4B489F355}.Release|x86.Build.0 = Release|x86 + {35753E72-07F3-4F18-916C-479850EC375F}.Debug|x86.ActiveCfg = Debug|x86 + {35753E72-07F3-4F18-916C-479850EC375F}.Debug|x86.Build.0 = Debug|x86 + {35753E72-07F3-4F18-916C-479850EC375F}.Release|x86.ActiveCfg = Release|x86 + {35753E72-07F3-4F18-916C-479850EC375F}.Release|x86.Build.0 = Release|x86 + {D622F308-35A9-4A86-8F2C-4E68CECA7C11}.Debug|x86.ActiveCfg = Debug|x86 + {D622F308-35A9-4A86-8F2C-4E68CECA7C11}.Debug|x86.Build.0 = Debug|x86 + {D622F308-35A9-4A86-8F2C-4E68CECA7C11}.Release|x86.ActiveCfg = Release|x86 + {D622F308-35A9-4A86-8F2C-4E68CECA7C11}.Release|x86.Build.0 = Release|x86 + {4FDD2B0D-C481-401E-A794-2111BF15F39E}.Debug|x86.ActiveCfg = Debug|x86 + {4FDD2B0D-C481-401E-A794-2111BF15F39E}.Debug|x86.Build.0 = Debug|x86 + {4FDD2B0D-C481-401E-A794-2111BF15F39E}.Release|x86.ActiveCfg = Release|x86 + {4FDD2B0D-C481-401E-A794-2111BF15F39E}.Release|x86.Build.0 = Release|x86 + {43E44B6C-78F6-4515-88F2-C238B51886C5}.Debug|x86.ActiveCfg = Debug|x86 + {43E44B6C-78F6-4515-88F2-C238B51886C5}.Debug|x86.Build.0 = Debug|x86 + {43E44B6C-78F6-4515-88F2-C238B51886C5}.Release|x86.ActiveCfg = Release|x86 + {43E44B6C-78F6-4515-88F2-C238B51886C5}.Release|x86.Build.0 = Release|x86 + {EC7AA916-0218-436F-B4DC-510BDB769260}.Debug|x86.ActiveCfg = Debug|x86 + {EC7AA916-0218-436F-B4DC-510BDB769260}.Debug|x86.Build.0 = Debug|x86 + {EC7AA916-0218-436F-B4DC-510BDB769260}.Release|x86.ActiveCfg = Release|x86 + {EC7AA916-0218-436F-B4DC-510BDB769260}.Release|x86.Build.0 = Release|x86 + {B09C7823-AFF3-45A4-AAAC-88821B464DEC}.Debug|x86.ActiveCfg = Debug|x86 + {B09C7823-AFF3-45A4-AAAC-88821B464DEC}.Release|x86.ActiveCfg = Release|x86 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/AntMe/AntMe.csproj b/AntMe/AntMe.csproj new file mode 100644 index 0000000..3eefaa4 --- /dev/null +++ b/AntMe/AntMe.csproj @@ -0,0 +1,315 @@ + + + + Debug + AnyCPU + 9.0.21022 + 2.0 + {931D5011-AE62-420D-8503-F5441136876A} + WinExe + Properties + AntMe.Gui + AntMe + AntMe.Gui.Program + true + antme.ico + SAK + SAK + SAK + SAK + + + + + 3.5 + false + v4.0 + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + true + + + + true + ..\bin\ + DEBUG;TRACE + full + x86 + + + true + GlobalSuppressions.cs + prompt + + + Migrated rules for AntMe.ruleset + true + + + ..\bin\ + TRACE + true + pdbonly + x86 + + + true + GlobalSuppressions.cs + prompt + + + Migrated rules for AntMe.ruleset + true + + + AntMe.snk + + + + + + + + + + + + + + Form + + + InfoBox.cs + + + + Form + + + Main.cs + + + + + Form + + + Plugins.cs + + + Form + + + ExceptionViewer.cs + + + + + Resources.resx + True + True + + + Settings.settings + True + True + + + True + True + Resource.de.resx + + + True + True + Resource.resx + + + Component + + + + + ExceptionViewer.cs + Designer + + + InfoBox.cs + Designer + + + InfoBox.cs + Designer + + + Main.cs + Designer + + + Designer + Main.cs + + + Plugins.cs + Designer + + + Plugins.cs + Designer + + + ExceptionViewer.cs + Designer + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + Designer + ResXFileCodeGenerator + Resource.de.Designer.cs + + + ResXFileCodeGenerator + Resource.Designer.cs + Designer + + + + + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + + + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + + + + + + + + + + + + + + + + {43e44b6c-78f6-4515-88f2-c238b51886c5} + AntMe.Online.Client + + + {415F50C3-BD70-4634-B1F7-A15B42F0B0C6} + SharedComponents + + + + + 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 + + + + + \ No newline at end of file diff --git a/AntMe/AntMe.snk b/AntMe/AntMe.snk new file mode 100644 index 0000000..cdd75a4 Binary files /dev/null and b/AntMe/AntMe.snk differ diff --git a/AntMe/App.config b/AntMe/App.config new file mode 100644 index 0000000..98ffe12 --- /dev/null +++ b/AntMe/App.config @@ -0,0 +1,33 @@ + + + + +
+ + +
+ + + + + + + + + 0, 0 + + + 0, 0 + + + Normal + + + 2008-01-01 + + + + + + + diff --git a/AntMe/Configuration.cs b/AntMe/Configuration.cs new file mode 100644 index 0000000..9b39356 --- /dev/null +++ b/AntMe/Configuration.cs @@ -0,0 +1,39 @@ +using System; +using System.Collections.Generic; +using System.Xml.Serialization; + +namespace AntMe.Gui +{ + /// + /// Holds all configuration-data for antme. + /// + [Serializable] + public sealed class Configuration + { + /// + /// List of known files, that containing plugins. + /// + public List knownPluginFiles = new List(); + + /// + /// Lists all active plugins. + /// + public List selectedPlugins = new List(); + + /// + /// Gives the limit for frame-rate. + /// + public float speedLimit; + + /// + /// Gives the state of frame-rate limiter. + /// + public bool speedLimitEnabled; + + /// + /// Indicated, if the configuration was loaded. + /// + [XmlIgnore] + public bool loaded; + } +} \ No newline at end of file diff --git a/AntMe/CustomStateItem.cs b/AntMe/CustomStateItem.cs new file mode 100644 index 0000000..5bd8798 --- /dev/null +++ b/AntMe/CustomStateItem.cs @@ -0,0 +1,26 @@ +using System; + +using AntMe.SharedComponents.Plugin; + +namespace AntMe.Gui { + /// + /// Holds information about custom states. + /// + internal sealed class CustomStateItem { + public readonly string Name; + public readonly string Type; + public readonly string Description; + + /// + /// Creates a new instance of custom state. + /// + /// Name of custom state + /// Type of custom state + /// Description of state-access + public CustomStateItem(string name, string type, string description) { + Name = name; + Type = type; + Description = description; + } + } +} \ No newline at end of file diff --git a/AntMe/ExceptionViewer.Designer.cs b/AntMe/ExceptionViewer.Designer.cs new file mode 100644 index 0000000..2153193 --- /dev/null +++ b/AntMe/ExceptionViewer.Designer.cs @@ -0,0 +1,146 @@ +namespace AntMe.Gui { + partial class ExceptionViewer + { + /// + /// 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(ExceptionViewer)); + this.okButton = new System.Windows.Forms.Button(); + this.exceptionListView = new System.Windows.Forms.ListView(); + this.descriptionColumn = new System.Windows.Forms.ColumnHeader(); + this.imageList = new System.Windows.Forms.ImageList(this.components); + this.eyecatcherPictureBox = new System.Windows.Forms.PictureBox(); + this.descriptionLabel = new System.Windows.Forms.Label(); + this.clipboardButton = new System.Windows.Forms.Button(); + ((System.ComponentModel.ISupportInitialize)(this.eyecatcherPictureBox)).BeginInit(); + this.SuspendLayout(); + // + // okButton + // + this.okButton.AccessibleDescription = null; + this.okButton.AccessibleName = null; + resources.ApplyResources(this.okButton, "okButton"); + this.okButton.BackgroundImage = null; + this.okButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.okButton.Font = null; + this.okButton.Name = "okButton"; + this.okButton.UseVisualStyleBackColor = true; + // + // exceptionListView + // + this.exceptionListView.AccessibleDescription = null; + this.exceptionListView.AccessibleName = null; + resources.ApplyResources(this.exceptionListView, "exceptionListView"); + this.exceptionListView.BackgroundImage = null; + this.exceptionListView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.descriptionColumn}); + this.exceptionListView.Font = null; + this.exceptionListView.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.Nonclickable; + this.exceptionListView.Name = "exceptionListView"; + this.exceptionListView.ShowItemToolTips = true; + this.exceptionListView.SmallImageList = this.imageList; + this.exceptionListView.UseCompatibleStateImageBehavior = false; + this.exceptionListView.View = System.Windows.Forms.View.Details; + // + // descriptionColumn + // + resources.ApplyResources(this.descriptionColumn, "descriptionColumn"); + // + // imageList + // + this.imageList.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList.ImageStream"))); + this.imageList.TransparentColor = System.Drawing.Color.Transparent; + this.imageList.Images.SetKeyName(0, "error"); + // + // eyecatcherPictureBox + // + this.eyecatcherPictureBox.AccessibleDescription = null; + this.eyecatcherPictureBox.AccessibleName = null; + resources.ApplyResources(this.eyecatcherPictureBox, "eyecatcherPictureBox"); + this.eyecatcherPictureBox.BackgroundImage = null; + this.eyecatcherPictureBox.Font = null; + this.eyecatcherPictureBox.Image = global::AntMe.Gui.Properties.Resources.error_48X48; + this.eyecatcherPictureBox.ImageLocation = null; + this.eyecatcherPictureBox.Name = "eyecatcherPictureBox"; + this.eyecatcherPictureBox.TabStop = false; + // + // descriptionLabel + // + this.descriptionLabel.AccessibleDescription = null; + this.descriptionLabel.AccessibleName = null; + resources.ApplyResources(this.descriptionLabel, "descriptionLabel"); + this.descriptionLabel.Font = null; + this.descriptionLabel.Name = "descriptionLabel"; + // + // clipboardButton + // + this.clipboardButton.AccessibleDescription = null; + this.clipboardButton.AccessibleName = null; + resources.ApplyResources(this.clipboardButton, "clipboardButton"); + this.clipboardButton.BackgroundImage = null; + this.clipboardButton.Font = null; + this.clipboardButton.Name = "clipboardButton"; + this.clipboardButton.UseVisualStyleBackColor = true; + this.clipboardButton.Click += new System.EventHandler(this.button1_Click); + // + // ExceptionViewer + // + this.AcceptButton = this.okButton; + this.AccessibleDescription = null; + this.AccessibleName = null; + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackgroundImage = null; + this.CancelButton = this.okButton; + this.Controls.Add(this.clipboardButton); + this.Controls.Add(this.descriptionLabel); + this.Controls.Add(this.eyecatcherPictureBox); + this.Controls.Add(this.exceptionListView); + this.Controls.Add(this.okButton); + this.Font = null; + this.Icon = null; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "ExceptionViewer"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + ((System.ComponentModel.ISupportInitialize)(this.eyecatcherPictureBox)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button okButton; + private System.Windows.Forms.ListView exceptionListView; + private System.Windows.Forms.PictureBox eyecatcherPictureBox; + private System.Windows.Forms.Label descriptionLabel; + private System.Windows.Forms.ColumnHeader descriptionColumn; + private System.Windows.Forms.ImageList imageList; + private System.Windows.Forms.Button clipboardButton; + } +} \ No newline at end of file diff --git a/AntMe/ExceptionViewer.cs b/AntMe/ExceptionViewer.cs new file mode 100644 index 0000000..be44dab --- /dev/null +++ b/AntMe/ExceptionViewer.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections.Generic; +using System.Windows.Forms; + +namespace AntMe.Gui { + internal sealed partial class ExceptionViewer : Form { + private readonly List exceptions; + + /// + /// Creates a new instance of ExceptionViewer with one single exception. + /// + /// Single Exception + public ExceptionViewer(Exception exception) { + exceptions = new List(1); + exceptions.Add(exception); + fill(); + } + + /// + /// Creates a new instance of ExceptionViewer with a list of exceptions. + /// + /// List of Exceptions + public ExceptionViewer(ICollection exceptions) { + this.exceptions = new List(exceptions.Count); + this.exceptions.AddRange(exceptions); + fill(); + } + + /// + /// Fills the list with the exception-information. + /// + private void fill() { + InitializeComponent(); + + foreach (Exception ex in exceptions) { + ListViewItem item = exceptionListView.Items.Add(ex.Message, "error"); + item.ToolTipText = ex.StackTrace; + item.Tag = ex; + + Exception inner = ex.InnerException; + while (inner != null) { + ListViewItem sub = exceptionListView.Items.Add(" - " + inner.Message); + sub.ToolTipText = inner.StackTrace; + sub.Tag = inner; + + inner = inner.InnerException; + } + } + } + + private void button1_Click(object sender, EventArgs e) { + // TODO: Need a good dump-method - XML is not the right way... :( + //XmlSerializer serializer = new XmlSerializer(exceptions.GetType()); + //MemoryStream temp = new MemoryStream(); + //serializer.Serialize(temp, exceptions); + + //Clipboard.SetText(new StreamReader(temp).ReadToEnd()); + } + } +} \ No newline at end of file diff --git a/AntMe/ExceptionViewer.de.resx b/AntMe/ExceptionViewer.de.resx new file mode 100644 index 0000000..92f18b8 --- /dev/null +++ b/AntMe/ExceptionViewer.de.resx @@ -0,0 +1,178 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Beschreibung + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAAAa + CAAAAk1TRnQBSQFMAwEBAAEEAQABBAEAARABAAEQAQAE/wEJAQAI/wFCAU0BNgEEBgABNgEEAgABKAMA + AUADAAEQAwABAQEAAQgGAAEEGAABgAIAAYADAAKAAQABgAMAAYABAAGAAQACgAIAA8ABAAHAAdwBwAEA + AfABygGmAQABMwUAATMBAAEzAQABMwEAAjMCAAMWAQADHAEAAyIBAAMpAQADVQEAA00BAANCAQADOQEA + AYABfAH/AQACUAH/AQABkwEAAdYBAAH/AewBzAEAAcYB1gHvAQAB1gLnAQABkAGpAa0CAAH/ATMDAAFm + AwABmQMAAcwCAAEzAwACMwIAATMBZgIAATMBmQIAATMBzAIAATMB/wIAAWYDAAFmATMCAAJmAgABZgGZ + AgABZgHMAgABZgH/AgABmQMAAZkBMwIAAZkBZgIAApkCAAGZAcwCAAGZAf8CAAHMAwABzAEzAgABzAFm + AgABzAGZAgACzAIAAcwB/wIAAf8BZgIAAf8BmQIAAf8BzAEAATMB/wIAAf8BAAEzAQABMwEAAWYBAAEz + AQABmQEAATMBAAHMAQABMwEAAf8BAAH/ATMCAAMzAQACMwFmAQACMwGZAQACMwHMAQACMwH/AQABMwFm + AgABMwFmATMBAAEzAmYBAAEzAWYBmQEAATMBZgHMAQABMwFmAf8BAAEzAZkCAAEzAZkBMwEAATMBmQFm + AQABMwKZAQABMwGZAcwBAAEzAZkB/wEAATMBzAIAATMBzAEzAQABMwHMAWYBAAEzAcwBmQEAATMCzAEA + ATMBzAH/AQABMwH/ATMBAAEzAf8BZgEAATMB/wGZAQABMwH/AcwBAAEzAv8BAAFmAwABZgEAATMBAAFm + AQABZgEAAWYBAAGZAQABZgEAAcwBAAFmAQAB/wEAAWYBMwIAAWYCMwEAAWYBMwFmAQABZgEzAZkBAAFm + ATMBzAEAAWYBMwH/AQACZgIAAmYBMwEAA2YBAAJmAZkBAAJmAcwBAAFmAZkCAAFmAZkBMwEAAWYBmQFm + AQABZgKZAQABZgGZAcwBAAFmAZkB/wEAAWYBzAIAAWYBzAEzAQABZgHMAZkBAAFmAswBAAFmAcwB/wEA + AWYB/wIAAWYB/wEzAQABZgH/AZkBAAFmAf8BzAEAAcwBAAH/AQAB/wEAAcwBAAKZAgABmQEzAZkBAAGZ + AQABmQEAAZkBAAHMAQABmQMAAZkCMwEAAZkBAAFmAQABmQEzAcwBAAGZAQAB/wEAAZkBZgIAAZkBZgEz + AQABmQEzAWYBAAGZAWYBmQEAAZkBZgHMAQABmQEzAf8BAAKZATMBAAKZAWYBAAOZAQACmQHMAQACmQH/ + AQABmQHMAgABmQHMATMBAAFmAcwBZgEAAZkBzAGZAQABmQLMAQABmQHMAf8BAAGZAf8CAAGZAf8BMwEA + AZkBzAFmAQABmQH/AZkBAAGZAf8BzAEAAZkC/wEAAcwDAAGZAQABMwEAAcwBAAFmAQABzAEAAZkBAAHM + AQABzAEAAZkBMwIAAcwCMwEAAcwBMwFmAQABzAEzAZkBAAHMATMBzAEAAcwBMwH/AQABzAFmAgABzAFm + ATMBAAGZAmYBAAHMAWYBmQEAAcwBZgHMAQABmQFmAf8BAAHMAZkCAAHMAZkBMwEAAcwBmQFmAQABzAKZ + AQABzAGZAcwBAAHMAZkB/wEAAswCAALMATMBAALMAWYBAALMAZkBAAPMAQACzAH/AQABzAH/AgABzAH/ + ATMBAAGZAf8BZgEAAcwB/wGZAQABzAH/AcwBAAHMAv8BAAHMAQABMwEAAf8BAAFmAQAB/wEAAZkBAAHM + ATMCAAH/AjMBAAH/ATMBZgEAAf8BMwGZAQAB/wEzAcwBAAH/ATMB/wEAAf8BZgIAAf8BZgEzAQABzAJm + AQAB/wFmAZkBAAH/AWYBzAEAAcwBZgH/AQAB/wGZAgAB/wGZATMBAAH/AZkBZgEAAf8CmQEAAf8BmQHM + AQAB/wGZAf8BAAH/AcwCAAH/AcwBMwEAAf8BzAFmAQAB/wHMAZkBAAH/AswBAAH/AcwB/wEAAv8BMwEA + AcwB/wFmAQAC/wGZAQAC/wHMAQACZgH/AQABZgH/AWYBAAFmAv8BAAH/AmYBAAH/AWYB/wEAAv8BZgEA + ASEBAAGlAQADXwEAA3cBAAOGAQADlgEAA8sBAAOyAQAD1wEAA90BAAPjAQAD6gEAA/EBAAP4AQAB8AH7 + Af8BAAGkAqABAAOAAwAB/wIAAf8DAAL/AQAB/wMAAf8BAAH/AQAC/wIAA/8CAAHtARIB6gltAWYBhjEA + AVkNOAFmMQABWQQ4AfsBDwGGAVkB+wQ4AWYxAAU4AfsBAAEKAVIE+wExAc8yAAQ4AfsCNwX7ARIzAAI4 + AfsBOAH7ATgBUQT7ATcBzzQAAjgC+wFRARQBNwP7ARI1AAI4AvsBSwFgAUsC+wE3Ac82AAE4AvsBQwFf + ARIC+wESNwABOAL7AQABXwEUAfsBNwHPOAABOAH7AQABCgESAfsBEjkAATgB+wE3ATEB+wE4Ac86AAE4 + AfsBXgH7AUo7AAE4AfsBXgH7Ac88AAE4AfsB7XcAAUIBTQE+BwABPgMAASgDAAFAAwABEAMAAQEBAAEB + BQABgBcAA/8BAAGAAQEHAAEBBwABAQcAAQEGAAGAAQMGAAGAAQMGAAHAAQcGAAHAAQcGAAHgAQ8GAAHg + AQ8GAAHwAR8GAAHwAR8GAAH4AT8GAAH4AT8GAAH8AX8GAAL/BgAL + + + + Während des letzten Vorgangs ist ein Fehler passiert der nun unten im Fenster aufgelistet wird. Solltest du mit der Fehlermeldung nichts anfangen können, kannst du die Fehlermeldung auch in die Zwischenablage kopieren und im Forum danach suchen. + + + + 172, 23 + + + In Zwischenablage kopieren + + + AntMe! - Probleme + + \ No newline at end of file diff --git a/AntMe/ExceptionViewer.resx b/AntMe/ExceptionViewer.resx new file mode 100644 index 0000000..a29ca66 --- /dev/null +++ b/AntMe/ExceptionViewer.resx @@ -0,0 +1,333 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + System.Windows.Forms.Form, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + 66, 12 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + Bottom, Left + + + 12, 85 + + + 400, 251 + + + exceptionListView + + + + 439 + + + 6, 13 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAAAa + CAAAAk1TRnQBSQFMAwEBAAEEAQABBAEAARABAAEQAQAE/wEJARAI/wFCAU0BNgEEBgABNgEEAgABKAMA + AUADAAEQAwABAQEAAQgGAAEEGAABgAIAAYADAAKAAQABgAMAAYABAAGAAQACgAIAA8ABAAHAAdwBwAEA + AfABygGmAQABMwUAATMBAAEzAQABMwEAAjMCAAMWAQADHAEAAyIBAAMpAQADVQEAA00BAANCAQADOQEA + AYABfAH/AQACUAH/AQABkwEAAdYBAAH/AewBzAEAAcYB1gHvAQAB1gLnAQABkAGpAa0CAAH/ATMDAAFm + AwABmQMAAcwCAAEzAwACMwIAATMBZgIAATMBmQIAATMBzAIAATMB/wIAAWYDAAFmATMCAAJmAgABZgGZ + AgABZgHMAgABZgH/AgABmQMAAZkBMwIAAZkBZgIAApkCAAGZAcwCAAGZAf8CAAHMAwABzAEzAgABzAFm + AgABzAGZAgACzAIAAcwB/wIAAf8BZgIAAf8BmQIAAf8BzAEAATMB/wIAAf8BAAEzAQABMwEAAWYBAAEz + AQABmQEAATMBAAHMAQABMwEAAf8BAAH/ATMCAAMzAQACMwFmAQACMwGZAQACMwHMAQACMwH/AQABMwFm + AgABMwFmATMBAAEzAmYBAAEzAWYBmQEAATMBZgHMAQABMwFmAf8BAAEzAZkCAAEzAZkBMwEAATMBmQFm + AQABMwKZAQABMwGZAcwBAAEzAZkB/wEAATMBzAIAATMBzAEzAQABMwHMAWYBAAEzAcwBmQEAATMCzAEA + ATMBzAH/AQABMwH/ATMBAAEzAf8BZgEAATMB/wGZAQABMwH/AcwBAAEzAv8BAAFmAwABZgEAATMBAAFm + AQABZgEAAWYBAAGZAQABZgEAAcwBAAFmAQAB/wEAAWYBMwIAAWYCMwEAAWYBMwFmAQABZgEzAZkBAAFm + ATMBzAEAAWYBMwH/AQACZgIAAmYBMwEAA2YBAAJmAZkBAAJmAcwBAAFmAZkCAAFmAZkBMwEAAWYBmQFm + AQABZgKZAQABZgGZAcwBAAFmAZkB/wEAAWYBzAIAAWYBzAEzAQABZgHMAZkBAAFmAswBAAFmAcwB/wEA + AWYB/wIAAWYB/wEzAQABZgH/AZkBAAFmAf8BzAEAAcwBAAH/AQAB/wEAAcwBAAKZAgABmQEzAZkBAAGZ + AQABmQEAAZkBAAHMAQABmQMAAZkCMwEAAZkBAAFmAQABmQEzAcwBAAGZAQAB/wEAAZkBZgIAAZkBZgEz + AQABmQEzAWYBAAGZAWYBmQEAAZkBZgHMAQABmQEzAf8BAAKZATMBAAKZAWYBAAOZAQACmQHMAQACmQH/ + AQABmQHMAgABmQHMATMBAAFmAcwBZgEAAZkBzAGZAQABmQLMAQABmQHMAf8BAAGZAf8CAAGZAf8BMwEA + AZkBzAFmAQABmQH/AZkBAAGZAf8BzAEAAZkC/wEAAcwDAAGZAQABMwEAAcwBAAFmAQABzAEAAZkBAAHM + AQABzAEAAZkBMwIAAcwCMwEAAcwBMwFmAQABzAEzAZkBAAHMATMBzAEAAcwBMwH/AQABzAFmAgABzAFm + ATMBAAGZAmYBAAHMAWYBmQEAAcwBZgHMAQABmQFmAf8BAAHMAZkCAAHMAZkBMwEAAcwBmQFmAQABzAKZ + AQABzAGZAcwBAAHMAZkB/wEAAswCAALMATMBAALMAWYBAALMAZkBAAPMAQACzAH/AQABzAH/AgABzAH/ + ATMBAAGZAf8BZgEAAcwB/wGZAQABzAH/AcwBAAHMAv8BAAHMAQABMwEAAf8BAAFmAQAB/wEAAZkBAAHM + ATMCAAH/AjMBAAH/ATMBZgEAAf8BMwGZAQAB/wEzAcwBAAH/ATMB/wEAAf8BZgIAAf8BZgEzAQABzAJm + AQAB/wFmAZkBAAH/AWYBzAEAAcwBZgH/AQAB/wGZAgAB/wGZATMBAAH/AZkBZgEAAf8CmQEAAf8BmQHM + AQAB/wGZAf8BAAH/AcwCAAH/AcwBMwEAAf8BzAFmAQAB/wHMAZkBAAH/AswBAAH/AcwB/wEAAv8BMwEA + AcwB/wFmAQAC/wGZAQAC/wHMAQACZgH/AQABZgH/AWYBAAFmAv8BAAH/AmYBAAH/AWYB/wEAAv8BZgEA + ASEBAAGlAQADXwEAA3cBAAOGAQADlgEAA8sBAAOyAQAD1wEAA90BAAPjAQAD6gEAA/EBAAP4AQAB8AH7 + Af8BAAGkAqABAAOAAwAB/wIAAf8DAAL/AQAB/wMAAf8BAAH/AQAC/wIAA/8CAAHtARIB6gltAWYBhjEA + AVkNOAFmMQABWQQ4AfsBDwGGAVkB+wQ4AWYxAAU4AfsBAAEKAVIE+wExAc8yAAQ4AfsCNwX7ARIzAAI4 + AfsBOAH7ATgBUQT7ATcBzzQAAjgC+wFRARQBNwP7ARI1AAI4AvsBSwFgAUsC+wE3Ac82AAE4AvsBQwFf + ARIC+wESNwABOAL7AQABXwEUAfsBNwHPOAABOAH7AQABCgESAfsBEjkAATgB+wE3ATEB+wE4Ac86AAE4 + AfsBXgH7AUo7AAE4AfsBXgH7Ac88AAE4AfsB7XcAAUIBTQE+BwABPgMAASgDAAFAAwABEAMAAQEBAAEB + BQABgBcAA/8BAAGAAQEHAAEBBwABAQcAAQEGAAGAAQMGAAGAAQMGAAHAAQcGAAHAAQcGAAHgAQ8GAAHg + AQ8GAAHwAR8GAAHwAR8GAAH4AT8GAAH4AT8GAAH8AX8GAAL/HAAL + + + + AntMe! - Problems + + + Top, Bottom, Left, Right + + + 48, 48 + + + 1 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + descriptionLabel + + + 2 + + + eyecatcherPictureBox + + + System.Windows.Forms.ListView, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Some problems occurred during the most recent operation. + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 0 + + + Description + + + 75, 23 + + + 1 + + + System.Windows.Forms.ImageList, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 4 + + + 3 + + + 2 + + + okButton + + + $this + + + descriptionColumn + + + 2 + + + 12, 12 + + + 409, 67 + + + 463, 160 + + + $this + + + 487, 286 + + + Bottom, Right + + + imageList + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + 3 + + + 114, 23 + + + CenterParent + + + clipboardButton + + + $this + + + 12, 251 + + + Copy to Clipboard + + + OK + + + $this + + + ExceptionViewer + + + $this + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 2 + + + True + + + 17, 17 + + \ No newline at end of file diff --git a/AntMe/InfoBox.Designer.cs b/AntMe/InfoBox.Designer.cs new file mode 100644 index 0000000..31803a9 --- /dev/null +++ b/AntMe/InfoBox.Designer.cs @@ -0,0 +1,378 @@ +namespace AntMe.Gui { + partial class InfoBox + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(InfoBox)); + this.logoPictureBox = new System.Windows.Forms.PictureBox(); + this.panel1 = new System.Windows.Forms.Panel(); + this.linkLabel2 = new System.Windows.Forms.LinkLabel(); + this.versionLabel = new System.Windows.Forms.Label(); + this.linkLabel1 = new System.Windows.Forms.LinkLabel(); + this.label1 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.panel2 = new System.Windows.Forms.Panel(); + this.panel3 = new System.Windows.Forms.Panel(); + this.panel4 = new System.Windows.Forms.Panel(); + this.label27 = new System.Windows.Forms.Label(); + this.label26 = new System.Windows.Forms.Label(); + this.label25 = new System.Windows.Forms.Label(); + this.label24 = new System.Windows.Forms.Label(); + this.label23 = new System.Windows.Forms.Label(); + this.label22 = new System.Windows.Forms.Label(); + this.label21 = new System.Windows.Forms.Label(); + this.label20 = new System.Windows.Forms.Label(); + this.label19 = new System.Windows.Forms.Label(); + this.label18 = new System.Windows.Forms.Label(); + this.label17 = new System.Windows.Forms.Label(); + this.label10 = new System.Windows.Forms.Label(); + this.label4 = new System.Windows.Forms.Label(); + this.label16 = new System.Windows.Forms.Label(); + this.label15 = new System.Windows.Forms.Label(); + this.label14 = new System.Windows.Forms.Label(); + this.label13 = new System.Windows.Forms.Label(); + this.label12 = new System.Windows.Forms.Label(); + this.label11 = new System.Windows.Forms.Label(); + this.label9 = new System.Windows.Forms.Label(); + this.label8 = new System.Windows.Forms.Label(); + this.label7 = new System.Windows.Forms.Label(); + this.okButton = new System.Windows.Forms.Button(); + this.label6 = new System.Windows.Forms.Label(); + this.label5 = new System.Windows.Forms.Label(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + ((System.ComponentModel.ISupportInitialize)(this.logoPictureBox)).BeginInit(); + this.panel1.SuspendLayout(); + this.panel2.SuspendLayout(); + this.panel3.SuspendLayout(); + this.panel4.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.SuspendLayout(); + // + // logoPictureBox + // + resources.ApplyResources(this.logoPictureBox, "logoPictureBox"); + this.logoPictureBox.BackColor = System.Drawing.SystemColors.Window; + this.logoPictureBox.Name = "logoPictureBox"; + this.logoPictureBox.TabStop = false; + // + // panel1 + // + resources.ApplyResources(this.panel1, "panel1"); + this.panel1.BackColor = System.Drawing.Color.White; + this.panel1.Controls.Add(this.linkLabel2); + this.panel1.Controls.Add(this.versionLabel); + this.panel1.Controls.Add(this.linkLabel1); + this.panel1.Controls.Add(this.logoPictureBox); + this.panel1.Controls.Add(this.label1); + this.panel1.Controls.Add(this.label2); + this.panel1.Controls.Add(this.label3); + this.panel1.Name = "panel1"; + // + // linkLabel2 + // + resources.ApplyResources(this.linkLabel2, "linkLabel2"); + this.linkLabel2.Name = "linkLabel2"; + this.linkLabel2.TabStop = true; + this.linkLabel2.Tag = ""; + this.linkLabel2.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel2_LinkClicked); + // + // versionLabel + // + resources.ApplyResources(this.versionLabel, "versionLabel"); + this.versionLabel.Name = "versionLabel"; + // + // linkLabel1 + // + resources.ApplyResources(this.linkLabel1, "linkLabel1"); + this.linkLabel1.Name = "linkLabel1"; + this.linkLabel1.TabStop = true; + this.linkLabel1.Tag = ""; + this.linkLabel1.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel1_LinkClicked); + // + // label1 + // + resources.ApplyResources(this.label1, "label1"); + this.label1.Name = "label1"; + // + // label2 + // + resources.ApplyResources(this.label2, "label2"); + this.label2.Name = "label2"; + // + // label3 + // + resources.ApplyResources(this.label3, "label3"); + this.label3.Name = "label3"; + // + // panel2 + // + resources.ApplyResources(this.panel2, "panel2"); + this.panel2.BackColor = System.Drawing.Color.White; + this.panel2.Controls.Add(this.panel3); + this.panel2.Controls.Add(this.okButton); + this.panel2.Controls.Add(this.label6); + this.panel2.Controls.Add(this.label5); + this.panel2.Controls.Add(this.pictureBox1); + this.panel2.Name = "panel2"; + // + // panel3 + // + resources.ApplyResources(this.panel3, "panel3"); + this.panel3.BackColor = System.Drawing.SystemColors.Control; + this.panel3.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.panel3.Controls.Add(this.panel4); + this.panel3.Name = "panel3"; + // + // panel4 + // + resources.ApplyResources(this.panel4, "panel4"); + this.panel4.Controls.Add(this.label27); + this.panel4.Controls.Add(this.label26); + this.panel4.Controls.Add(this.label25); + this.panel4.Controls.Add(this.label24); + this.panel4.Controls.Add(this.label23); + this.panel4.Controls.Add(this.label22); + this.panel4.Controls.Add(this.label21); + this.panel4.Controls.Add(this.label20); + this.panel4.Controls.Add(this.label19); + this.panel4.Controls.Add(this.label18); + this.panel4.Controls.Add(this.label17); + this.panel4.Controls.Add(this.label10); + this.panel4.Controls.Add(this.label4); + this.panel4.Controls.Add(this.label16); + this.panel4.Controls.Add(this.label15); + this.panel4.Controls.Add(this.label14); + this.panel4.Controls.Add(this.label13); + this.panel4.Controls.Add(this.label12); + this.panel4.Controls.Add(this.label11); + this.panel4.Controls.Add(this.label9); + this.panel4.Controls.Add(this.label8); + this.panel4.Controls.Add(this.label7); + this.panel4.Name = "panel4"; + // + // label27 + // + resources.ApplyResources(this.label27, "label27"); + this.label27.Name = "label27"; + // + // label26 + // + resources.ApplyResources(this.label26, "label26"); + this.label26.Name = "label26"; + // + // label25 + // + resources.ApplyResources(this.label25, "label25"); + this.label25.Name = "label25"; + // + // label24 + // + resources.ApplyResources(this.label24, "label24"); + this.label24.Name = "label24"; + // + // label23 + // + resources.ApplyResources(this.label23, "label23"); + this.label23.Name = "label23"; + // + // label22 + // + resources.ApplyResources(this.label22, "label22"); + this.label22.Name = "label22"; + // + // label21 + // + resources.ApplyResources(this.label21, "label21"); + this.label21.Name = "label21"; + // + // label20 + // + resources.ApplyResources(this.label20, "label20"); + this.label20.Name = "label20"; + // + // label19 + // + resources.ApplyResources(this.label19, "label19"); + this.label19.Name = "label19"; + // + // label18 + // + resources.ApplyResources(this.label18, "label18"); + this.label18.Name = "label18"; + // + // label17 + // + resources.ApplyResources(this.label17, "label17"); + this.label17.Name = "label17"; + // + // label10 + // + resources.ApplyResources(this.label10, "label10"); + this.label10.Name = "label10"; + // + // label4 + // + resources.ApplyResources(this.label4, "label4"); + this.label4.Name = "label4"; + // + // label16 + // + resources.ApplyResources(this.label16, "label16"); + this.label16.Name = "label16"; + // + // label15 + // + resources.ApplyResources(this.label15, "label15"); + this.label15.Name = "label15"; + // + // label14 + // + resources.ApplyResources(this.label14, "label14"); + this.label14.Name = "label14"; + // + // label13 + // + resources.ApplyResources(this.label13, "label13"); + this.label13.Name = "label13"; + // + // label12 + // + resources.ApplyResources(this.label12, "label12"); + this.label12.Name = "label12"; + // + // label11 + // + resources.ApplyResources(this.label11, "label11"); + this.label11.Name = "label11"; + // + // label9 + // + resources.ApplyResources(this.label9, "label9"); + this.label9.Name = "label9"; + // + // label8 + // + resources.ApplyResources(this.label8, "label8"); + this.label8.Name = "label8"; + // + // label7 + // + resources.ApplyResources(this.label7, "label7"); + this.label7.Name = "label7"; + // + // okButton + // + resources.ApplyResources(this.okButton, "okButton"); + this.okButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.okButton.Name = "okButton"; + this.okButton.UseVisualStyleBackColor = true; + // + // label6 + // + resources.ApplyResources(this.label6, "label6"); + this.label6.Name = "label6"; + // + // label5 + // + resources.ApplyResources(this.label5, "label5"); + this.label5.Name = "label5"; + // + // pictureBox1 + // + resources.ApplyResources(this.pictureBox1, "pictureBox1"); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.TabStop = false; + // + // InfoBox + // + this.AcceptButton = this.okButton; + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.okButton; + this.Controls.Add(this.panel2); + this.Controls.Add(this.panel1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "InfoBox"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + ((System.ComponentModel.ISupportInitialize)(this.logoPictureBox)).EndInit(); + this.panel1.ResumeLayout(false); + this.panel1.PerformLayout(); + this.panel2.ResumeLayout(false); + this.panel2.PerformLayout(); + this.panel3.ResumeLayout(false); + this.panel4.ResumeLayout(false); + this.panel4.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.PictureBox logoPictureBox; + private System.Windows.Forms.Panel panel1; + private System.Windows.Forms.Panel panel2; + private System.Windows.Forms.PictureBox pictureBox1; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Button okButton; + private System.Windows.Forms.Panel panel3; + private System.Windows.Forms.Panel panel4; + private System.Windows.Forms.Label label16; + private System.Windows.Forms.Label label15; + private System.Windows.Forms.Label label14; + private System.Windows.Forms.Label label13; + private System.Windows.Forms.Label label12; + private System.Windows.Forms.Label label11; + private System.Windows.Forms.Label label9; + private System.Windows.Forms.Label label8; + private System.Windows.Forms.Label label7; + private System.Windows.Forms.Label label20; + private System.Windows.Forms.Label label19; + private System.Windows.Forms.Label label18; + private System.Windows.Forms.Label label17; + private System.Windows.Forms.Label label10; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.LinkLabel linkLabel1; + private System.Windows.Forms.Label versionLabel; + private System.Windows.Forms.Label label24; + private System.Windows.Forms.Label label23; + private System.Windows.Forms.Label label22; + private System.Windows.Forms.Label label21; + private System.Windows.Forms.Label label25; + private System.Windows.Forms.Label label27; + private System.Windows.Forms.Label label26; + private System.Windows.Forms.LinkLabel linkLabel2; + + } +} \ No newline at end of file diff --git a/AntMe/InfoBox.cs b/AntMe/InfoBox.cs new file mode 100644 index 0000000..eb47e47 --- /dev/null +++ b/AntMe/InfoBox.cs @@ -0,0 +1,108 @@ +using System; +using System.Diagnostics; +using System.IO; +using System.Reflection; +using System.Windows.Forms; + +namespace AntMe.Gui { + internal partial class InfoBox : Form { + public InfoBox() { + InitializeComponent(); + versionLabel.Text = AssemblyVersion; + } + + #region Assembly Attribute Accessors + + public string AssemblyTitle { + get { + // Get all Title attributes on this assembly + object[] attributes = + Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (AssemblyTitleAttribute), false); + // If there is at least one Title attribute + if (attributes.Length > 0) { + // Select the first one + AssemblyTitleAttribute titleAttribute = (AssemblyTitleAttribute) attributes[0]; + // If it is not an empty string, return it + if (titleAttribute.Title != "") { + return titleAttribute.Title; + } + } + // If there was no Title attribute, or if the Title attribute was the empty string, return the .exe name + return Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase); + } + } + + public string AssemblyVersion { + get { return Assembly.GetExecutingAssembly().GetName().Version.ToString(); } + } + + public string AssemblyDescription { + get { + // Get all Description attributes on this assembly + object[] attributes = + Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (AssemblyDescriptionAttribute), false); + // If there aren't any Description attributes, return an empty string + if (attributes.Length == 0) { + return ""; + } + // If there is a Description attribute, return its value + return ((AssemblyDescriptionAttribute) attributes[0]).Description; + } + } + + public string AssemblyProduct { + get { + // Get all Product attributes on this assembly + object[] attributes = + Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (AssemblyProductAttribute), false); + // If there aren't any Product attributes, return an empty string + if (attributes.Length == 0) { + return ""; + } + // If there is a Product attribute, return its value + return ((AssemblyProductAttribute) attributes[0]).Product; + } + } + + public string AssemblyCopyright { + get { + // Get all Copyright attributes on this assembly + object[] attributes = + Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (AssemblyCopyrightAttribute), false); + // If there aren't any Copyright attributes, return an empty string + if (attributes.Length == 0) { + return ""; + } + // If there is a Copyright attribute, return its value + return ((AssemblyCopyrightAttribute) attributes[0]).Copyright; + } + } + + public string AssemblyCompany { + get { + // Get all Company attributes on this assembly + object[] attributes = + Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (AssemblyCompanyAttribute), false); + // If there aren't any Company attributes, return an empty string + if (attributes.Length == 0) { + return ""; + } + // If there is a Company attribute, return its value + return ((AssemblyCompanyAttribute) attributes[0]).Company; + } + } + + #endregion + + private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) + { + Process.Start("https://service.antme.net/License1"); + } + + private void linkLabel2_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) + { + Process.Start("http://www.antme.net"); + } + + } +} \ No newline at end of file diff --git a/AntMe/InfoBox.de.resx b/AntMe/InfoBox.de.resx new file mode 100644 index 0000000..26ce44d --- /dev/null +++ b/AntMe/InfoBox.de.resx @@ -0,0 +1,1284 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAAUYAAACwCAYAAABza8dAAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAACXBIWXMAAAsHAAALBwG2cwvAAACsfUlE + QVR4Xu39B5RUVbP/D7/rv5jpHnNOKCYkiAhIEAMKigKKipgQM4qIEkQJCiJIlCBmMSMCCipGzAmQPDMw + 5JxzTpJ87v3VW586vfs5czg9iSF5u9baa6a7T9ih9ndX2rX/f5KkJCUpSUnKRklgTFKSkpSkACWBMUlJ + SlKSApQExiQlKUlJClASGJOUpCQlKUBJYExSkpKUpAAlgTFJSUpSkgKUBMYkJSlJSQpQEhiTlKQkJSlA + SWBMUpKSlKQAJYExSUkqBPp//+//Wfnf//1f+Z//+R8r/O++T9LhRUlgTFKS9oEAva0Z42T9L9/Kul+/ + ldU/fiUrvx8uq3/5TjavXSN///237Nq1S/755x8DyiQdHpQExiQlqQAEIO5ev0YWtnlEJpc+RjLOS5VJ + Z2opmioZ52rRz1l31ZSF4/+SNWvWyJYtW2T37t0mSSYlyEOfksCYpCTlkwC27dMzZfr15STjfA8MJ2qZ + elmazKiWJunnRGTSGQqO/HZ9BcnKzJDFixfLxo0bDRyTkuOhT0lgTFKS8km7Vq2QrGrFDfgmnqoAWCIq + q9pFZMegiOz8JCLrukRkykUKjipBcs0vndrI+PHjZdGiRbJ582ZTq5NS46FNSWD8lxITj+J3BiQdAvtO + /2zdLLPuqO6B4mmqLpePyOZXUmXP5ymy48MU+VvLP1+myIaeCoxnRyS9WKr8eHM1+eqrryQjI0NWrVol + O3bsSPb/IU5JYPyXERNu57LFsm7E57L6m09l1ddDZMXwQbL8s4Gy+q/fZevWrTYxk/au/BN9taxPR7Mf + AooZpaKy+Y2o/POFAuL7Wj7wyo4BKbJLgXL2jVGZoBLl99VKy7vvviu//fabzJ8/3+yN9H2SDl1KAuO/ + iJi4qwf1l8mVippEk47t64RUmXS6p9IxoWe987IsX75cNmzYYAD5n//8JwmOeaSdK5aaowUpcNJZUVnX + PaKSYpE4IMaLguTuYSmyrFmaTFAA/aHyOfJyrxdNapw2bZqsX7/e1OkkHbqUBMZ/CQFuqz583QPAc1Jl + wkmpMrVKROY9GJGp1aOeLexcBctyp8jE336RuXPnytq1aw0ck9JL7kT/Lu76tPXvhFNSZXEjBcWApOgH + xl2fpsia56Iy6YyI/FH6ROn9bFv55JNPTJ1evXq1SexJOnQpCYz/AmLSbhz5s2QUjxr4TTghIvMfisrf + o1Ryma6q3cRUmXO3gqOCJRP7x5YPy8iRI2XOnDkmOTJJk1JjzvSfPbtlxs1VzQOdVS4ifw9IlZ0fh4Ci + A8YhKbLxRV2IdJGaeF5U+j75hAwYMEDGjRsnK1assNjGJBU+wcfY0RmvPdrHu3ThdwU+R1JHS3K29kSU + BMZ/AZmX9IrzTFUef1yqzHsgKrum6MQdV0S2/66TdGIR2fpLVCaXiZp6/WOtijJ06FDzlC5btsyCkJMh + JDnTrvVrVfK+0CTvxbro7P4sBBB9BdDc+laKTL5QwVFV797Nmsh7770no0ePliVLliQdMIVM9OV/9uyR + tcMHydwmt8uMO2rI9Nuvkem38leLfp7/chczY2Dj3blzZ47RAUlgPMyJgV3U4QlPxTshVWbUisrOSYCi + TtA/tPypEuNIlRynpMjc+9Nkwomp8nPVc+Wt11+XH3/80aRGQkhYRZOUmLbOmiaTKxSVSWdFZG1XBUZV + lcMA0ZUdA3RR+iAiWZWiMuGsVOnR9BHp37+//Pnnnxa2s3379iQwFhLRj1smjJKZ9S63ecBChLljYtGI + TCoWkYmnR0xy57esl7rIggULLOieMUgEjklgPIyJAd3450+el/T0VMksFZUt30dkV4ZOzhgourJ7ShFZ + 0U3V6ZMj8tvFp0nfri/I559/LlOmTJF169bJHl1tkxRO9PP60b/KxHOOlPQLIrLptVTZ9YkHgInKjg8V + GD9UYKySJhPPTJEejz0sb7zxhnmmmZjbtm1LAmMhkI3NN5+qNnScAR/RAoDhnJujsuq5qGzomyYL7/UC + 7tPP1t8rFZVRX34u06dPj4dOhdnYk8B4GBNMseiZxwwYcbas6BGRPVN1Yqr67AdFCmC5/iOPaUZecIL0 + ad1KBg0aJBMnTjQGSdq8EhNmhkU9nzX74pSyEdn2jkrkg7RfQwDRyvuqSg9MkS1vRXTCIrWkSvcmjeR1 + ldJ//fVXC9lJAuO+E/23edxIySx5lGdGOjlVpl0elY29I7L781SLDNg9tIjs+SpF5jfwQqe47quObeT3 + 33+P29jDhIIkMB7GxEo3s8G1ukqmyPTrouZk2TFKJ2YAFJEed01Mkc3fRCSjZETGFjtS+jV9WD744AMZ + M2aM2RlZOZMUTrvWrZYpl55l0siMah4oEqsYCooUc74UkY29cL6oGqeSSo8kMBY6/bNtq0y//mLPjKSg + OKtWVP7+WEFxaGx8iBh4zxuLLW9EJaOE8r+OxYfNHjEb+6RJk8wRhr0xOBZJYDyMabcyxtSaZVVajMiS + 9mmye7IyQhAU/cD4rTJG6Yj8ddZR0uexRvLOO++Yd5p9vDhgkhN1b6JPVg3q75krTonI4kZRk0RCAdEV + nZBMzjUdIjJRVbgxFxwlXZ5oYqo0wJhUpfed6LsVb/XyxkUlwelXAIqpsmuw1//ZxuNDBcqBes2VhE+l + yOuNGhrv52TvTQLjYUx/r1gqmRXPsli5tW9HZFe6MkFCYCwim0dEJPPCNAPGXk0eNGcAKsXChQuTzoAE + ZFL5bVebpJFxQVQ2vxaVnR+HBHUHCl7rBQ0jpr6NKF9UOrR+Wt56661kfxcS/WfnDplx06XmaEk/NyKb + +qmkSKRAEBRjZeeQFJl9nS5UKvW/fP8d8tprr8nPP/8s8+bNs91gwaiMJDAexrRh7B+SXvw4ST8/IhuH + 6Wo5SZkgDBi1AJobP/WYaOzZR0qvxvfLm2++mZRgcqGtUyZKeqmjzMs59/Y02YW0mGDyubJLVe1tH0Rk + SoWoSYzDLispHTp0sG2Bo0aNSobrFALtXLtKJlc8w6TFBXertvR5+Fi4Qlzp7Os858xL994mL7/8svzw + ww/xqIwkMP5LiEm17s8fZaJKf5PLRmTrjxHZOUGZIAQUKbszU2R1P0/t+Kv40dJTVenDHRip7//+5z/y + z+5dslsliF07/rZCIK8L5kXi47qCtI17FnVs4Xkzi0ZkfbfUXMN0KLuGFpFVz6bJhNMjtgvprTpXSqdO + neSjjz5KBngXEm2dPV0yi6d5WzO76YL1iUrxOSxYOwanyoxrVZU+PVX63lNf+vXrJ99//73Mnj3bgDHo + mU4C42FKTNp1I3+WicWOkaxLorLt11TZOV6ZIAQUKdgfl3XQCX5SRH4ue6o81+bwVe2o555NG2TVB6/K + rHtqyYzbr/aCeG+vLtNvqyYzGt0iy37+zjyOAD4g5AAyP7Rj2WKZUqWoSRnTq+rCM0j7eKD2Z8jE8xe2 + A869SdVolTLHlThSnnvoXunRo4cZ/DMzMy2GLrklsODEOK798SvJUDWaELXNb+jYDExs3iDrERJ8VkUF + xrNSFBhv+3cBIx1CA5AEcLHDXDA9hf/5Li/bff4NRPtW//GDTCp2tGRenCZbVGLcNUGZIwQU8VTvnpwq + 8x+LmqPms0uLS/v27Q9L5wt1/HvuDLMvYXhPP8uTggm8nkRALwli9fuMMsfJ9G8+N7WV3Q4uXi2vbeS6 + VR/397ZYnpwqS5vEbFghE89fzBv6YapMvUTrcmaqfFnpbHnqqadsIn777bcyc+ZMS1ibDKgvODG/5z/X + zPp3auWI9XfCKAGVIncOKSLrexAdoBK8jme/hvVNlQYYD2tVGiYlY/Lizk/KjFuvkGk3VJRptStLVq2K + klXnEpl6QyWZ17ujBSrTSCZBTtt9/g3EQK5RVXrS2ceYKr3lR5VmEqjSO0ZrGZ8q065Jk4kqxQy4poJ0 + 7NhRPvzww3i4TljIwqFIbH+0EI3iCoiqFmEzXXS/qlM9I7Kmc5pMr6ZtJJuQguNfd9eWcWPHmoE9v3vC + 6d9ZDWoa8Frg/FtRlRhzVtdsEuo1G3p7YTqo0S/ecp0tQm+//bZJ585sEZyISco7scChGbAgzqlNcmDt + e3JhJhgToggWP+jthhl/wZHS/ZEH5JVXXrGdXyRTYYvgYQeMMPLG30Z452qc76XQmnhiTELQwkSHAZkI + WX06G+Pltt3n30AGjNov2BinlEuVrT/rpAwDRjzSk1Jk/YeeBJNxToq8W/sK6dKliwwePNhiuQjwPhxU + O9q8oMV98R0OUy6OysY+EdkzXNuok8NSgH2kKlNlVZmKpsrIaiXki2FDza6H5AggBVWmRLRj8QLJuPAY + 5S9Vi2+N7Y3OCRQpNgmLyFLSjemknVA8Ku0aPSBdu3a1vp4wYULcvvhvXrT3N/2jmuHU6qWtj5c+4sUt + ho6Hlh0fKW8MSZEZV7E1MFV+KH+GtH+qlYVO/fLLLxZTelh6pf/5e7uXRl6Bj90d06pFZXnXiKwfqGVI + mix4NJZSS8FxQpWzZOSIb3Pd7vNvIAZy/WQ8pqdY4OrmL1MtVjEMGNknvaBxxPZSI2l1u+9O6dmzp3z2 + 2WfxLYEsIocyASQbfv3OWxwV9DJLeqEz/3wRk+K0bH9PwfGLFFneQqVGBc7R5U6Rt/v1lREjRpgKi9SY + l3byruX9e3tq9BkqiXaK5Grcd2XX0FSZW897/w8XnyatW7aQvn37ytdff218mczFuO+0fekiyaxczBxi + q9qnaZ+HjwUFaXFDLxUKYtnU36x1eTYz0mEZx0hlVw9515MQFBRn3ZSmKqGuEDrRAYFdGUVkz4wUmfeQ + S6kVkS+fb2v7UbEdYMvB7vhvXJ1p06ZlSySj0jmSrpLguvfD4xixL+4YowuKrphI29+WLyptnmy5l83r + UF9A8D7bkQIskLoQrmobkg9R/2eXw4YenkYxtuTR0uf55/KdB5HFePoNFc1eydEFFiCskod/woWVHTgA + BmhfV9G+VvAeUK2sPPPMM+bkcjtewqSTJOWd4PsNf/0mk84/yswoG3pHE+5bZ8x2DkmVGTV0oVKemaj4 + 8MLd9eWFF16Qjz/+2LJLJZLgD2lghIFmNbzO7Dzp56mE8G1s8ru9wEhDGSmy+StdDc7zmHHQg3ea9489 + wDT63xovRps2L14oGRWLWYD3mjd15UzXiekHRtRoVa83fRlRSVH7SPuxb90a8uyzz1pwtwvVORwm65b0 + MZJe+mhj8JnX6GT4NNzgTvD15td0kVSJ8q/zj5Zuz7SN50EkczmTIDciMUdmiSPN6bLgLl2IiV1MZMPy + FVS2za+qNHsBwJwqr914lYXp8H7/1st/Iz8eKKLvlr7S1eb65IsisrV/quxkt0twPHSRJLZxSeOojD9Z + +V8X1B/KnSZPN28mvXv3li+//FKmTp2aMIHKIQ2Mm8b+qSqTMqiqgPPui8ruLJ0MI7XRvsm/Y3QR2TlB + J0utqEzSSfPJjVdmM3T/W1doGOTvbdtkSs3yyiQKjP3DgZEwnZUvs2KqKn1uVJ6/905bMQcOHBgHi0N9 + stpk6NXeS/p6RlRV27SEHmJL3vC2TpqyEQXGY6RL29bxPIhLly61tuZE9q6XOnnHF6j6taEXIBz+rmDh + ug09dIHWe8edkyZd7rlDunfvngzTKURCs5n9cD0zVWA33MG+9aA0j+agUuSG3qjPnkCQrsD4wm03mhrt + hIKczt85ZIERBl30QitjMoym6z7QlTtTG62TPdvk18LkX/hwRCbqCv9x7armiseuRIzSpk2b/pV2Rvpn + +/q1MvmyEiadrP0wRJUmD2NmqixsGjWH1S9lTpJ2TZvYijl8+HDJyso6LFKO2WR45Fbjg2mXRWXHx4nj + Cfl+81sRySyDxHiMdG79lNmT/DtOcqL/UZV99gM3eu+qlmZHou74SBeckHcFC04AAruxff1y4SnS9onH + zb74zTffmH0xGaaz72QJg6+5yDzMC++OSfOBcTCHiy5SM2sSnoaJLVXev+piadGihdnWMa04jTJRNMYh + C4xkzphavZRJgdOr62QYp9LiX9pw/8SnxJwLSzuoRAQwXn+pTXwOHoIZMbj/W5lx88wsybzoNNuZsVFX + ziAw7hijRfttRk1v0RhWtbi0bdvWsrz89NNPFqoQFtx6qNHuLZtl+k2XmpSwWBfAHPfEDlRV+k32hHuq + dH6BceeKZTK5wqk28RY9FJt4Cd4VLFy7FMfP6REZUf7MeF/79+T+GxfpA0mbJ0+0HS/08ap2qjngeAmM + D6C4rpvy/BkqLercGFH+dHn80ca2LRNpkfFAaGKhSuQIO2SBcdOkMZ7TRSWdJR20AxT8wqRFB4xLnvOA + ceB1VeTFF180iQgbwr/VC8gqt+6PH2Ti2UeZV3rTcJUYA15pdsJs/T5VQULVuzNS5R1dNJ577jl5//33 + 4yn2D4fA7r+XL5Uplc+0fcdrn0/1vJA5AePrUcksrcBYPBwYE7WX75e+/ILZoyYWVS2lSywhbX6AsYlO + SAXwryueIx0O0yD6Q5Xou5Uf9zeTSvr5Udn4UjQ0m85OBcbZN6m0qIvbxOIR6VSvtgXZI72TnDk9PV1W + rlxpvJDIzHZIAiMdsASbkqI9TpeNn0d0kqs6kwgYVZVe8qx2RAwYEZe/+OKLuKr4rwXGMb/LpHOOVakx + lrk7EMeIBLnmHW/lnHBOVLo2rG8xdUOGDDms4he3zp8jmecfYUHTG3tqO4coLyQCxo9VlX5NJcZSAGO4 + Kp0InJDmptetbDYpDrza/p5qKXnwRlv5UPtbgXFhA89rPqRaGXn++eezOX5Q25JUcDKTyoN1zfEy9dKo + /P2Rjo/fKaY8gfNt0+sRFRailhHpu/JnyBNPPGF2dcaCVGP4HrAtgguJeOGQBEZSCk295kJTo1EDd45P + NXuZf9LHSwAYB9SsbMDoT9v/bwXGld8MVUkwTbKuSJPtI7WfxmV3vmCTtX45KVX+vPAEebrZE9k8coeD + NE071+sCAChmlo6oNJjzvliSyG7sk6pSX0T+uuAY6ZQPYNw8YZTn+VY+WtAgD3kXfQUPuaW2wmyhfDu4 + +sU2GcmSfjgtQocybZ8704Lu49ECQZOK/s93K1opz+sYIPm/eNO10qZNG9vpQnia80QzFon4ADokgXGT + TgTCJcafoGr0U6kGfP4Jn604YCRBwv8hYEQFWPreK9bm6ToZd4z1bIr+vuE4g3n3pVmM5zeVihmDkIfO + vxXqULd52QIw9EOV4lK8ZBnva1tz2BeLNLm2W1QmFYtagtjOT7fKk42R95iWUixFJp4VkXU90mR3gvi4 + sLJjYIpsJ4bxMi+Dy1s3XGUe6U8//TTukT7UnVyHMjE+q4hpPjfVzEJrn1NcCI4PUvtQ5fm6qiEpMI4q + fZy0erRxPArjr7/+Mh4goDs3vj/kgJEOWPbmi6bOcD7JxsGqOuWQZ9DZGJd1/L8FjAzsgk5P2uo5WxkB + NTqbc0olbBwvM2tHTPL+qEa5eE7Aw8nmxQKwoFNLA5sZOOEGqfbgnwz+AjB+osDYKU0mnRmR38qeLM+3 + a2PA6D+2NIws8Wm9K8w+OC2WDTovmXRcseNS+0fNG86pgL0b1Ps/wYcHiuCDhZ1amBrNVtBt76nmEDjX + G21h23v87sU0D76shNkWX3rpJdt5NG3aNNOS8rLp45ADRib8nMfusMk87eo0+fsv7YCAJJStxIBx6XOe + 5/X/CjDiaZ/Xrom1ed69UdmVnprtvBf+3/5bqmRV0gVGmeSVm2pI586dLeLfv2f3UCfaOe2Wy2xP/Pz6 + ugDgePFNhmwFVUp/XxZzgHxbsZh07NA+1zhGJsmG33/wtgDqe5Y0jsiefHijKUzKTa9yrkhUxp8dke4P + NDCzhdsK+G+OjjgQ9I+qvjPuqG5mitk3pIUG+OONXttVx54cCjoGvepdb8IAC+Mff/xh6fXyul/+kAPG + nevWSFa1Enb+8fzHtANyUqMpMVV6cTtVGf8PASOMMvP+G63Ni55UYPT3k/bJzrFFbKcQHmmClXveXc9y + Ag4bNkwmT54sa9euPSxUu7+XLpLJl3jhM0sfVfUpN2DEAXK35wAZccmZ0um5Dnbo19ixYxM6QADG+W0e + 8Zx956SajZJdLHkGRpNUdVKyOBeNyPjiR0r7x5vYtksXT3s4hEUdyrTNzvU+zcZ1SdNw+69FBTRVHNBr + RpU8Vp5t9ICZM4hbdHbevCbwOKSAkQqv/+U7SwjBTo3VryYO6o4XB4xP/d8Cxj0A4711TJUmnCkIjJgf + CPpGpRynE7XDow9Lnz59DisJBn5Y9/0XKskp4Gg71nbSCZGL3Y8kDvPqKy+oxPjhtRVtSx72JaRkQjTC + pOT/7NktU68uYUHdM2tEbX9tXrYAxksMkJc/EVEAj8iYEkdLh5Ytcj1XJEl5I/hg5YA3bOHCvLahp+KC + SofZFi7siypFziVMR4HxuwpFs+XBnDFjRo5xi0E6pIARxpn35AMm4WSWTJWt36bu5WndqzhgfPr/FjDu + UMl6yvWXyCQCXVWFy3bIPn2iC8ryHmk2Uf+48ATp0KKZeeb851wc6hIME2Jx7+dkUtEUmVwmKlv6kxNR + 2+cHJV9Btdqhkt7Ma72zVl67+Zp4eBKxa2FJJHjHxtG/2l5y+mrp42kKconDgUJLDBgXcPiVSrbDq55n + ySMIJs7pJLok5Y3MzozZiMS0FTwb846AfZGwqu3vp8qUcggDqTL4itLxnAAFyYN5SAEj27GmXlPa7Emz + btRJMEk7IQiEweKAseX/LWDcvnSxTL7sfMuss4EtUOx6ccCoBQlyUQsv69C3lxST9m3bxI8ygEnCJiqf + g+Vg0n9275IZd9Qw1YjtXUhyOcUV7hhQxJwz06+Kmuey/03V9zIfBHmBNi58rplKIyletpaXIjmCb6Ky + kzNFrtP+VqmTRMAE0qPC4wlNJo/YN/pn5w6ZXucS0wLm3aJaQ9CcgilDF8R1XXC6eFm6X61bPds5O86M + ktcxOKSAceuMKV4cmU7mZSQKmKwrt2+yJyoGjM2VKRUY/68EeG+ZN0syLz7VJvPGT2K5GP3ASKjOA95i + MbjaRTZRnRMC7yweaSTGPX9vl+3zZ8tWfd7mOTNk08ypsnWll1gC6Yq+47qDMam3ZE2SjFLHmBSGQyRR + 4ghXDBg/VmAki7cC40t33iS9evXKcRfU7s0bZWqN0jJBJ92MqxUUB3vSR9jzE5UdH+p7B0ZkxpVpJt2+ + eeNV8RhG9uQ621aSCkZ/L1vsxS/qArmsORK99rtfoo9J7Avv8yT2cRccIc80bmQ4QM7RgtjUDxlgZOKt + /XaYZwBn5R6qEkKCVP3ZChLjFJ8qff2l/3qJkb7aOHmCmRxIr7XpK1WlMTk4YBxZxCTIefccEQdGdmFw + lAESzMKsTFk+fLAsaN/U8g5OqVJMMsp7ZXLlM2VKjQtl3sdvW+wdKjeTGnvkgQRH3rVqyLueXQmpuLuC + f9CuFCjZgTFFetx3Z9yu6mxMfvOB8dxXQywYHFvt0kcTgK++EzUdScVAM1CHHRSVVGfU8CTVPgrILqvO + gXJ00RbURNoHv1N4J4X/GT+3wFEOF7IxGvG5F794dkTWvxjbBujvfx13wqumXa79rwvTVxWLydNPP232 + xe+++65A5+wcMsDIoC7q3d7CdLKqRmT7KFWbcgrTcSUAjJ9Uvzi+UvybgXHDlEkW60myhM3fRWTX2AAw + ZqbInJjESMLWNxvdLZ+1aynjGlwvGZecZvvQCZpGOrcMJMUjkllCGUslJ3YMZFxaTLLSJ5l9DEcN4JhX + +0xhEO+a3+pBMxVkXaL88AFqtLbRNyGCJQ6MV3nA+OJ9d1gMG5Nj1qxZe2Va4h1zm97lLTAKjpte1n4M + ce4YGCowYn8k3+JeEqUCJarcnFqppkp30/ciqbLDyMXO7Q8edGC4VRdJnBOLXnxW5jRvqOUema1/Zz3e + QOb37ijLRgw3YHAnJlKXwwUcqefCLk/Z4phVIcYH/jAd6/sisumliG0fZiF9I5al26UfdKdg5od/Dxlg + 3JqRKVmVi+skVQa7LVV2qsTDIU57AWGwxIBxyTMRb4dH1fOle7duh11YSn4IZlnz63e2OmZdnibb/oxY + XspsfTJZJaDn02TcUbF8dDr5KUg0HhhGJOOCiMy+KSLLO5OEIlU2/xCVWfUiBo4TLj5JRnw+zLy5BIOz + S+ZAerF3b9sqWVecKxNPVX64NS3HxBGuGDAOVGDUPqFvAEZ3GlxYyMyOlcsls+yJZruaVStNdhIbp2px + 8LlIkUsfj8rolIiqcrFQEV9dduj/2D9nXad9p8DIe0lYsD8zpMMDWzPGyfwW90pmyaMskgPwQN10BXNC + /Dykh26RhdOyTAvAQ46ZpLDrtD+IOk6vd7m1Z04dXbjQGgL7oxmPFa10/p+mRbXNzrEs3ZgyCnrOziEB + jDbRB3wkmWceLRNOVJB7WlUaBbuE+6P9xUAgRVb21E45JVV+vfhU6fl8x3ynsz+cCGZZQK5K7GLX6mQe + u3e/sAtm+++pMvMWlQKL6UpajMQKqTL18ojMuSsqy7up9PO1Mtokb8vlrklF5J/pRWTjF3rtORH5q9SJ + 8v4br5m0hdSD5H0g+3HjmD9Mqp1wakRWPKVglIsaTSGBwJZ3IzK5HMCYKr3vvzOhJx6eW/3ZRwYaAOPK + tmmhKazY/bKVZ5aJyvhjUmRRIwXpIDACph9FVJXzALmXvhc1LqdziwtK1Pt/VOJb9lInybjoOFMxqT82 + Us5Nnn+7gneTiCx5JCLTSel/uueltb68+TKZMmG82ZiRnhnPA6kFFITIvzjlivPNAbfk4ZAAfwVJgHHR + vREDz18uOkXaNn1sryzd+ZXYDxlgXP3d5942QGXodR/qRMgtftEVvQZ72tp3vHvHljhK+rR5Kr7DI1Hs + 2uFK9BWSzuTKRU1Nnn1LRHYGHC+uX3aMUQlqfKps/Cwq6wdHZMu3qfL3qFTZlaFgmFlEdo7Ta5xUbten + yLafU2TKRREZdf4J0rtLZwt1wYFwIPuRNi545jFTi5BqyZYT3P4VVnYNUhB7WxcArT9gEAaMDgj4O/uh + myzJr7fFLERVN2mkiB2uNeFkJBKdnNghA8BIUostyn+Ty+qiwnbAHAB5X4h+2TZ9ssy+/wbPFKL9g210 + WtWorHwmTdV9r25WVMpFAgbw08/HW+uB4+9P3G/zAvWSeqFN8dxDlTapVJxx4Yl2hg9bPW2B9I0RajXJ + O2bVitr4DLriwr1yjhYkJ8AhAYxUev5zzU3Nm1LJUw3ZuZFtoicqOqFJSbZhqKqMygCoDr1aNLVQCf85 + G/8GsomRNck7bL54qow/OiKLkaZU4tsLGGN9w1EQuyZ6zhjyMxoQcm3I9TtV8tz2Y4pMvihVRp53vLzw + 7DPZ+vFApc0iSfG02hWM0WdUj3mK/XalBAXw3P6OAntZb5Hs/cBdBlBh5wdvmzFFMsqeYMAy/7YY2AWe + R0orO0wpdvQmUsvyx3RRCQPG/lHtN5XOFRh7PdQw4XsLSoz9uq+GyGTswyrlIh0BFotVMvx7sNYJIATY + qRflPeqvWsDXRWRdV62XagHUbfxFJ8pXHw+wxY4xzUtChYNFtHn1159qvb2tlpt0gbQdSb4xsv3sH8aO + zNUxeqvWZYWSc/SQAMZdmzZI1uXnqASUInPvZ3ubSjZhEz1B2amSEfkIJ1+cJhk6+H2bPGSGV4Jr9zVZ + AvfB1DAPxXn3KHxf0Ofmlzglb/krXWXyhcdKJmrRcSnKLKoOf6f9pYAX1i/x4oAwlz4FODd+oQtMiYiM + PP9Y6dSubb7OSyks2jo1QzLLnmSTP+4pzsNOFHOK6HXTKnsSUiLJjTFb2qejd+Sugu/qDipFh8XGfeKl + MDP7rEpnBoxNQ4ARFf5NBUaOUzjvaOnctLHtenESy77ueqG+a4a8K5kljvBU4pMU/MtFFfBS7Sxti7v0 + 1SdeYiD5z1cpsqSR53nn/uEP3raXieRA8XF+iD5bRIC/CkxTq+gCMCA1NHEETrN01Swm6jj1ua1OaM7R + /LbvkADGHWtXeQOuA7dKGTHPanSseMkTIjKVlE9npMhbd9W1A7X9R1bmt2O4ftu0TFk18C1Z8cGrluJr + ybv9ZPHbfWTFT9+YFMBqi3q5v0NZAMWFbR6JqU8pCooqWVdJk/WDVFoksDukTwpSdk0oIusHYpNUVbrE + wQFG+nGl9rk5ilTK2UB4RkB9SlRs5wuB1jV0kuhkcsCI5OYHRjLpzLy9ul2TVSEq2z9QqXRQuNNlySNR + 2xFjtrwzIrLq2Vh9HBDpXybnltdUlS4ZO4DriSamyuV0oHteif5YBoirlMg+7vEnpcrs2mlW5zzt0NHf + LSWaSpCYSFD1f690lnykmgCp2Ig6yGtihQNNxNhOv/VK0xxm19Yx+kQFpoDmwFisbsvYaN+cnyZd7m+Q + LXa1oFEpBx0YGfhFXZ6yiZCpjLX1G10VQpwJORZVF7GXzcQrqKv6sGsr5OiNzImozx6VYBc938JULYuf + 0mdyxIKtuCo5pJc8UqY2v1cWL1xoHQ9A7q8QCAztC55uZKDIyokzYkHzqPw9VtWKTJ0Y+VhAciuYJDZ9 + pmpL8aiMLH5wgBEAmd+uiUl8Uy5R0FI1KS/2RYp5pdn5crW3JTBMlYYP/l4wRzLKHGfjufD+IxQAdcIF + n6VgAshOq6bP0vE37+75UdnQl22JPkDSv6h3G/rq7wpeZA0HGN3C7LaiFYQ3DBT7dfYWREBReXDubQrM + Q1Ep8wCKruh1gPzC+xTktc2TLkiTD55uFj+ky6XiOtRo+8J5knHR8V6Av0q8e5k76HuV9DkUi2tGlT5W + 2jVvli15R0EPwzvowPgfHZBp119sAzbrZmW6icqkefFGBwpS5vwHtIOUeX6rcJr0efHFAh2ItWvVCtt+ + ZMxI+IOu0FMqR2VuwzSZeYNn1AfE+X3cq70scBjHBOCYk+TI9xQmPgNF4X+K+y1IfMexoQaK+l7AYmW/ + iOyZVoDFIw+FgHp20TAJR5Y4zoCR/I3OVnMggHHP1i3KD+UMjObVBwT2Bq1EJXscY6q8+GCDvSRGxmh5 + /95eeEuxiKzvoSBD7GIAZPhufY80s+NlFEvxgBE71yvKo6o6x681YCwi63rqtXjzzz9Kuikwuu2XLoYu + bHxzIq5fM/jtuKTIgrgIM5OCg9nV8gqKsWLt6an8e7ZKjcq/Hzeoa+Es7tD5/GyXOxBEXTb+9ZsnmJwZ + kXVdwiMTcLzMJGu6SpXDq5wr7dq1kzfffHOfz0w/6MC4ffY0ySx3sgHa0o5sA9QGh0za3CQj9gYvfV5X + RAUyPNOvtHnSsicTspPX83zpwHmP1DMgIvQHj+jyriqdjdLVKlNV/GkpsuJF7Fcec/1yT13LngL48o5g + rBT/79m43g72WvvT17Lm529ktf5d+cOXsvL74bJuyiSTJgAc6hcE1r/nzpDJZY71ArFPUzXu5Yj8MzPW + 5kKUFK387i0ua15VJlPVcXSpY6XzM+0OuMS4KX2sF0KjwLiy1d72vJyKX2JEun7tzrqmOfhtjLu2bLb4 + SBaZqZV0bAcEAoZjhdCdBXeotAgfsEiqpkBiky2ve9Jk/FqAUSfsuhf0nQqiv114krzQquU+JZDg2nXD + B3k2xZikuPhBBYYvdEHM53ZFV3ZwHEQsxhNH0tDaVa2Ov/32W1yqLYhktb+IPlgx9AObZ5MvSrNog+CR + FjjHtg+ImdCKpshrda7M5nhxPJufvnd0UIGRCps9CWmIw82H6OodtJkBACpBEtdoTgadwNl+jxXSbK0b + rB2kz5mkQNL/oQZ2+A15+JxHNacO4jcM3Cad6aQij+Gmz5HOPDUdOyaq5u6pKtnW83aU/HpFCRk04EOz + 1SAZsDrBXDzr7/mzZVHnJ+0oTnaVGLjpJJtwgj5fVzcmf2aJNJnWtIEsmZxhKjn3A5BOmlzy4rO2YnLP + olZpsmeW1qMA0nSeCsA4NUXmEg+mi8uv5U6R59s/a8DoEiHsb680/bb0lS7WZlKNbVT1lBCcPAOjeZFT + ZFYNbwzfu7lGNrWKQOtVwwbYGKOhLLpH+S0EeHHibOXQ/tLeAji+eFTGnRNNCIyA95p2CuYKON+VP0s6 + qqTtP04hP84/rlv3+UDjDfph/AmR+PkmYdsR81y0b3YP885KYdH5vPrF8S1zbldQXrWqA0Hw/6KurW0c + LXP7YF3AAm3CC2/hWRcTp5sq3RvUky5duhTKYW8HFRhRo+0gdR0otgH+PVJXRAUh/4S18JLRqbK8S5ps + GKSrBuAYIi3x/bZfI2aXQqx+964bbUV0mXtzW7X3bN4o02uX92LDyAXZPyp7FCiyAbG+F4Be2h5gjMiP + lc6W1/r2ied7w1bDQKwe1F+mVClq4EcIAUCD/XTG9RGZe2eKSizYrRTAddBNGql+oUxNn2STiMmL5Ll7 + x9+WI5D7s6pEZbtKrZaCrbAlxdjz9kxXdXCg1ussj8mGXl5KOnbsaPurXZLX/R3HyIJAlmZWf2LzCJrO + izfaX1xOPnhgyHWVsu1AYXxmN7pZ25ei6mlUgVfV4sC+WwM6lRZXP6MLRGwB+6hqCfnz/GMsZf62/sQ7 + Zr8eO9fa9mgSqTKiXNFskrYzQeQFGLlmg2oV7GRJBxRPVH651TMnGBgXFBQpMQAnZyR9M7TaRfFti4kS + bBxMAqRn3HaV2Q4Jp7KogUD7LRrgDZIxK8/qvO1y3112dHJhJJA5qMD496L5nhFcJSLsg6ZG+yUigAgV + +dmojPn/IpJ1qQeeYVsFvcPlU2RGTU8NHnJ9FXn11Vf38kgmog2/jVCQ0smgdZmndUFS9B8VYEXrQ9Ya + EugCWN9VPkd6dHnBkgWgsq+YM0vmt344rnoRUjOlYtRMBFtGKLBN0PbgcR+TKit6R1VVVwmXyafXj2x8 + p9l7UGsAxzW/f+9JNpgYtP17gfS+FgBRn4cU/o9Kous/icrksp40ARi8VO/6A37K3c4VS2VyxdNMmltw + TyyLim8i5FpiIDW/oS5c2q/fVj1fevXsGZ/8y8aNlszyJ9tkIyDYACdEjd6lktUcBSTChX4tc6K0u/0m + GXv2EZJFjK0dxrW3jZHkBuwY+r7cmQWO/9y5ZKFMqewtqHif59zCVkhCVPR9+wKKFIARwI95cAFGUrL5 + cwocSg4YtoROqXqWjZWFbAWBUf9nUdv8Uor11+jzj5KOTR+N741nISyo4wU6aMDI6rji3X6mLgBkq1/d + e7cLALj9z1SZUl6BSK/Bzrb2PV09/ElZ3bUKYnxvDhhlKiZFH10R85KxmrqsIZBUVXo6efPwVNkd8g4+ + 75xISAsqFvakk6V7h/aWIXrsgLdl8jVlDMyQBFG1FzRWCQP7ZJbe53aZaD35+88MVf0/RjrTZ+HkUSnh + m34vGjhil5r/sqqUCq6A9eavkBa992erzz4UpE/AdtuvqbKkjTepHUhzFq87atW/+u7PicMYrP5M1dxz + dbHQ/lj7Ak6R7DalXAuTX8GU9PaA2g+Vi0nPrl1t8nNS35xXu5vNjm1yq9orv4Wo0bsGqXr2DodaedsK + B1xRRlo8/JBMLBY1yX3bB4FTCvV+ywWowIjzxQGjM+PkVdL+X53Acx+9zVsMlddn1kyz8BSzqwXqWKBC + 3yi4rGhN+1PlkyvLHPAMQPmhrTOzJPOiE83xsua5EF6gPZ9g29X2nJVqR+U+3/zxQsuaftCAESSfXreK + TYIpFXQl/k0Z7i9tvJu82LwUKFe/hjNAJyyeOQU8pK/Qc2AUNJAulz3vAePoUsdLv2fbxgc+p+MrbVJy + RvOpKTKTZAITVJIY5auL7x2cxrfpU89LObrEcdKtzdPy9cN3SXrpYwxU2euNmrayV8w+mYNddI+C49IO + ERl/vLZPF4if6lxqQI70OeOlF6zdM+t4kuZe0mt+i9YdQCbukX7a/F2qLG7Fbg3tr+M9cGY3DaDY7v6G + ZsQmSJ5YPJgsPyFPBSFzfLW416QZO+z+fSQlrbd/MuRWACkdm1VtPDPF72VPlh6dOprNacJfo2VyzbIG + dlm60G5XFT2YBZqCLW/Fkyot6iLMGL94c03p+PD9MlHvm3ZZqqr3ep1fvTdgLKLA6HmlAcYu7Z/NdtB+ + bsAI/60a8IaBIpIuWws5BS/MWx5WiKMEnK2/El0PkCgwLm8dtYXh0wAw5jQ/DgZtzpok6SWOlfTiUdn4 + skr3YSYPXdiWtWSsUuXHcmfIc62f3udoAEcHBRip7OaMcZJZ6ihPjX40BnY+ALGtbBmq8typapGqkx7o + qJp7v16r0lwiNXfNuzrweI1V2nq9aSOT5lxIQiIGZVKu/GqISqUpMqu+AuMkBemRiYFx/WBPVR59wbHy + 9VWelGghFcelytSrdSC/UNVXpUSro96z13Niz+L0Q/YyTyPjtILgpOIR+bhbJ9sxkd61nQG8tRdJel+c + LtR7kpbMVNk4NCrzHkmz0BNzBKn0ACj/fuHx8t7V5aX5o40tJTxhLkiLHAlA32EnK+jqmxfawzbAmy8z + VX7ujSplh5wCl2sxkNLx6abtUilibImjpfuz7SyL85jXenvAo5I8h2XZbpoAiPA+1LOZ1Tz74l+ljpGn + Gz8srzzUwAB1hgKj212T7Z2fKjB20TEsFpERCoxdn2sfzxyd22mMzAWy5HCOui3++t41urjv/tx7tr9+ + 2Yr+Rn0Bh23vRmTjSwSqxxaTsPv0O65drqDvgLFbt27Zzr3e36aSvBJ9sjErXSadd5xqi+FHpVJwnM1v + 4JlNvq50tnRUSZ3wMv8Z4ocdMCIdAC6TzojI+o+UEQJnR7O/d8u3umqXVIaLOSmQoKbXUNAaowwQzNUI + 0Kh6SMaYzNKqGurEeOeeenk6RxlJaPmXgw2cZt8ZlZ0cRep/tu8d1GutqsB4v2FkpCw8ziQZWKAqnAVe + 41lPBIj+glQ8uYis7OclKQD8v6tV2SScP595wgLLp9fW+qgEWyBgjIEvqvyGwRGZdZtKUjp5AUT6hz4d + Weo4eaPmpdLmofvt8CDSwaOOoH5iI8PmibSYUwA731Pox2ABTBPd56dt82bJ5HKnmqS2rFkB7Iuxgj1u + 0yvathLaznMj0qd5E+OBMQ1qmUMjnegHleZ3DQ6oqPo/oLixry6qKvmx0H1a9QLrk3cbNTBJduZVOkH9 + HunYfdQVrzSLzPflikqXDnkHRuJmp9W8yMYCZ8v8mAc62ztCikmIg7C/qdR/sUqrqupPvTQiW9/UuZHA + k2/A2EKBROsZBoyHisQIv6z+/gtdjNJkRlWdi9rn2SIBtACUpJibVtWz9w++qqwlY/abMPYliuKgAOOO + ZYtlyqVnWl7AGdcok6K6+g+L14L3d9lz3iQed/4R8l2FM2TsmUdYGM3WETr4Krn5r6cgoe0YzW4Fr7OG + XVcxT3tWmcAeMKrEeCsSo9YngcQI+G78HIk0asCIhMOKtaJ7VHbP0HphC0ygOocVkyrHqqR5hSc1Tihx + hLzf5XkZ8bSXXYbEGJu/VlWCDDr5eK7VdayW8QrYeCJ1AUJlN5VZJ+EvF50kbyogPtnoIZv8MBUeXJwG + eHGRstnOllOSWhh41+qVsl6ZePl7L8sy2zr5six+t5+sHvWr7TRhMXIhSIkAku83jPvTWygVuNb11PZi + UwqZ3EhsOQU489vm/l6GHbzr/R6+R97u86JMKn+KjlWKzLhWJXC2lgXvBeAUkBY/rJJ0THrvcPdtlvB0 + +F21bYxnXa+8wQmCwftURV3ZWvsYYKxQTLrEJMbcNBXaveCph2w8cDhNvTR20H+IdBQvsfdtfSciM6tH + DUx5L578cUeTmkv5MAGwAozuzG1sjIcqMMJrS/r3sXoaMOqYB4ERk8n6rjrGZ3rj/GadKy1UZ/BgnceF + 4Cw84MAIM6xREDK1QYFxRXfPOZFtUitYICXNqKWDqAzzc9mTpX39G2ybGjbJdR+m7h3vSFEwiO+A0Wf/ + XPFMm+zOAYO3N8wBY8D4xSADU/bZ7lSJNMzzbQUg09+m14jK2KgypA7Myt6psmc6oBy4No+FRWBFD6/O + qLWD764rA7q/4E0Y/W5OQ2V2vORIyXmRRLVgimDx4N5xR6UY8/C8b8qfKT1vqinNH2sirVu3NgkRTx6A + iPeWoGQ8uP7QoTBQs3Ec/I5kXXGeSbqWMg5AQbrXz5TpvTqaV5ZQEAAykdTJd8s5HlOfQQow8h+GOR3M + GzwgVbbr+GcLmfFfo9/jIMmqjPMkRV65/3b56HEFH+1XwrCWt4p6h+kH71O1lODwaVeioaTIjxefKi1a + tLCEBN/dW9cWwFk3qPQeBNUYUC1teoQBFGFO/iNbEwEjbd48fpT1E2o6C+DGfjoXhmob/c/3F941TBfm + VyLWT4Ap7RpX/AgZWfpYA3Q82TvZIRJihiCOkXNRaMuwKy+M2xgPNWCE32Y3vtUDRhVyGJcgMNLnloNR + 2zyxeFR6NKyfLXP/vjqTDjgwshrMbdbQmAGVd8sPOBeUGdyE17+7VOqyLC/nqXqpUsQH1S6SJk2ayJ9l + TlZ1OiIruqlEgd0tAAYOGFfoSgKgIH293PapbIMftorEgZGBqKn1UUkrJ5BDKtz8TdR22mwcqsyMB5vf + 8ghawWLvUzCedqXHtN9cfZH07dVLxlQs6kmlKhUsaqqS9WRtX17eRT/odatVpRx/nDd5kIBevbaKPN74 + kbjKTIAvqgdbJwFEGArVGaZiJ0QiSY/PK9/ua0CLyokNeHI5lWBU2sZeShvMzKCTffzH71sAMSt4om2T + vGPGXdcYsNjCFDS0Uz7UflJQmnNzmkyvFjU1KswGSZC3ty0QW1qqvHFHHfmqTlXjt8loG2+rRBZiyEdC + 3dDH884jub5Vs4rl9aOPfr7/FmuTxdMBOv57tRAitOB+VVH1mqEKOP6DsBLlsWQezL6vjgEjSSqw/e3J + ya6o3/P7xpcwFXkCA/2PbfipO+vLu9dUtPfPqXeE1ZF+8N9vwe9az3l3ePX8+JoKh6xXmrCtKZefZ6A3 + t56Xg9HfHlvESBbCnngd428vOUuebvWkjZU/a/q+BKwfcGAkI2+mqjUTTla1VQcJB0s2tZVJrQCwpGOa + TFBAMJWmQX158skn5bdLipoDZn7jmEPCDwaxe8kQs26gMg57XHVyvndf/Vx3wBgwDlcRXDsZ58n20To5 + /UcFBIu+h5jJXZOLeCruvjhGKPo8nDWLUccU0P8se4p0e76jDG7xqDE/7Rh/QqrMrKtq9XcKxFOLyE68 + 5npf6PO00IcLGuukw8GiffhinaukadOmdt4xYThIiEjSBCEjIeLFY+HA3JBISoT4bvXH/eOgOOGEiMxv + FLWwH5w77HVf2DQmzeg1f95Y1fat+rdNBtXynevWxOMLSQhg9sUAQABmG/soPyjA0RdrCeEApIJAAgDo + 9zhwCNn5GROMggfPnl+fZyu/BUCDgvq5VNVMrpukC3KXu+rZ4sEOlr9uvsyetYjYSgWXve7V+i56QPtC + F9ZhqqLmtvuCPlzz+UDrH0CKnR2o92FAb0XbyDvW91KeLuEtntw7svTx0qbBbdKsWTP5QoUHvl/8kD4r + TCL+SHlGF4wZ7CPXeva/8eq9jpY9VIBx45jf7fwWnEQr2+0dVsW2yK1v6QJRBl9CirxZ6zLjazzS/oxa + 8HBB6YACIwzBSYDGEDpxVvZWRgXgfBN8x586gDq5Zt6oqpAONLawFs2esF0YP9YsZ+oaDgm8uX4giN+v + 6qbbATPp9BT55IbLcz1024AxpkpnXR6RbQSRB2yeoSUHYMpX0edY4Pib1Dkio0oeL91aP2Ur4FeN77Yt + hfQZIIc3mbNcaH/wyFRXCDUiqzcedhxWn15aXB577DFjHp7JsQ/sCAIQcUoFtyOGASLE96Riy7joBAXr + FAPFBU8oWEzV+sdsqyQY3jkpRabV8CTHCaWOlmG9u5tECsM6R46fNo75zTL6YAdd0z7EvggwKHAte0yf + p+2hLFEwDgNQChLcIlUZx+t1puYjMauKv6aj8hvAFrjH7Jac2aLaAgD4y8WnSJvHm9rOEABu7M2Xe6Dz + iL4zBBgBooX3e4A17IoLTf12R2uEaSlkb5p6dUmTTJF4iNkMe66VWNs36FyxnIN6Pbzwoy6ere+5S1q1 + aiVd2z8rf1QuZnVfpouh9UvgOYS7bH0rVaaU8RaX/jfXOCRP04THVurCS1QB/oQt/XWx9aeE0/6w8Kiu + Xgww2tALd94SN184AWhfPNLQAQVGAMm80dpo4ue2/ayN9nuXAQid0Ju/BAiUEfS6AdXKSps2bUzK+ebh + O7172Zql94aBFyowzpPZt+pEU+lrRNXzDAz8e0KDKwmfV3z1iQHjtCsVcHHi5AUYC6vQ7gnK/MOiOpEj + MvbcI6VHs8es3hjxhz/zpIypcLpNCOo47riITLs2Kpu+DQdHDsZicZmlahXA2PeGq019ZqIzYZEScUYh + JaDe5gaIjhi/OffW8tQ/VdFJKszecRtDVwf9S+C452nXSaxS5Rd31rYJCFAgQSE1unfxd/m7/WzlN9OK + Lg5B54OpgSpRufT1lLkK+rZNzHedK4DM8qcU5PQ6Jg7P9o4vUE0g5KRBvLio2KiogMaHV18cT49Paq6J + 9arZgrXqaW3vp9nvR8pDcp17i0rJCkzvX181R9sd7V39yXvWh+O1f+aoZMvullBpEVDUZ295TaWjEl67 + 4YFvy58pLR70ogh41we9usu4cqeb53xV23Dwx4ttSXe1PwiI7tvglvi5KO4kw31RPQuL4LGF3drYOJA5 + fYcCera+oU8U+Jc19RYizpBu9+gjthUQHiss6feAAuOe7dviKcbm3KpMigMloIbiiODUOgsp0UnV47Yb + TVpE6vuul5dgAIfHhgGJJSZTxdtpx6naPerCE+SV9u1yNMoCCmvGj5KJ5x4n06t5gHuggXGHSlpsG8QO + hqOkb6N7LJaQCYbK++UH78qP9a9RtTjNm1RHqVSmar9thQzWVft0V3qqzFO1FMn8lbrVLWCbsBVUDbZI + YoPJKyBCXLPxz59sYsKQ7Pdma2PY3nWSbWz7Q6WTSh6QDa9Z0d7tss34pXbeP7fZ3SYJme1wkE6GAEgQ + WrO1f1QliDTzqnM0KtEMOwaH76UGqNZ2U+mbQ8BUKptwaorMvilNdpLCLAAYFMBnVQcFNpVYOWWu2+03 + xs/hJvvMxPrVLTZ21bPYuwLAqEBrZ0pf47X1nRuuim+1C5uktHfWnddovVJk0rm6uPVTCTkst6J+pt3E + KGap9gPoxkHx/nvt3GQkPsxEP775sqr/XoC5JfYN8egTLL6uuydljbzgOGn/eJNs2+fgB+p2sIk6zHmi + gfXlvPosGl5fZOsXBUbMIl5g92nS5umnbK4U5uFjBxQYNyn4pJc82pwJyzrq6ktQt29CIe1ZUHc9D9R+ + K3OCtG3S2BgAlebXLz6TSRef7KnhPfT+gBpuRT9jf8RzzaozSUGmf6OGdjiWP3zCDwZ04uoxf1hAKafo + sY1vrzjJghbqF6xjSKHt2xVMphKXpfV+s8FNNtg4RghYRcpj4D/r9ryMLq/SIyv/KRFZ954uEIEYUEKA + +G7u7dqPKjG+deNVcfXO7xDICyA6YsuaHcLEe0+NyNp3VDKZrBMwQQgRkQYLH1XmNam9uLwSmIROOtmx + aoVkVbvAswHeqc9EDQyAHRLQqmdRtT0JlMgEO2ua3TGBVFQUpCNLLkAMrPbleO2nVbpQhjlOKLxz3m2e + 2WF0qWOk9WNNjOewvxGLmFG/hu18Wf2c9nXgGaTzwtmD7Y6J+sYtNXNMZMCxDelsbNB3sR97F6E1QVDU + QtjRjiERmVE9zWyqLIY/q/r8+EMPGijyDlRHFrqJXZ/xog60vZtfV4mbOMbA8wD/lQrsmCt+vOgU08L8 + oWyFcS5NYdA/uljPbHidLb6LHlKtAH7w9Q+LpvW3LqKM7Qc1KsTPkC5omrcwOmDASEWXvtLVVnxLMfap + MkUg5AbpA+dCRild2bTRA1SlcQNosXVjxkg69h4FxoUEAQOsYcCoz9n6C55S7TydTINvusqM6Ik6DmBc + +eUQz8ZYVVUuDuMaoxPO/9z8Fq2H7d6ZoGptHpPKEqI0q66CmTLFR1pncgnSbnafACjYBGnDV317yIQS + RxkwruqjEx5Ptb8fRhax7+YpY9FXQ66psM/2JA6oItsP4EEdbfdRIqeT1gXJf1UvD5hHVD5HXuzWda/3 + MwZmc8aJo6CyqnWIfQxVVYFx3i0KstoWpCYv9Cgim15SoFIQDAKLgQqeaV1kxqQpH5RRyZJdIYGQD7tW + 1fYtb6qkXsqT1L+uVMzCmFiUSFc2OSNdMi6/wCbh2ue1LmzTC9zPjpOpFSMyXkGnd4N6e6morq9p7/yn + G3mefL12XRftx8DzrGh7dn+uwHB/NA6KY0ocbY4W1GfGElDEbj5tcqZMvrqU8fm0y1Ti1nZnS3IRK0i6 + K9p6UvGvZU4ye3N+sk8dKNqtWmVWjdLmeFmB6YLwJd/4EsCPSWQKR+QqlvSpd33cvugPqN/XthwwYPzP + rp2WRoiJMvVqb/dKtvOQmUwKdEs76cqLGq3M0LNeLVOj8aACCHg2pzxcz54xM5btO2xPMxKTOXDqelLA + 8Ksuskw7iY6z9AMjEiOJK3buiyoNOKuaTxtZAOz8ZtT+nLzX3KPS8pz7tM4qZX1S8xJTdbBxWWaYZcvM + PocDA8l3TM1y2jZiKPHsax/4gVGLeaUfV2BSMPmGLDPdu+9TOqbdW7dIVvULVcVRMH55b2k/W6Etuuit + +0ClX2XeUaVPkF7PttvLU4uEsqh7OzO0423FlmZA55vQxK9tV6mYlF9M/j9LHyejih9j5pS1nfX6EHsa + n5HslrdUKbNYmkmLlv3Zf03sOoB4eXPPoQMAkey0Q4cOcdV/VtZkyah8trVjXSd9bhAYVTrj6NUpFXTB + V/7pd9fNFjvLuJGKzi8dk6MT7zsLH6BtIBaMx6TuqL1d6TsvdIg4vS63XC8tW7a0oGzUZ1R8nj+r81O2 + +wrJfGHDmMQd7A8ttH9Faw8Yv6p4jplWgkmIDwVg3Dp/jmSWjSWP6BRbOFx76JshRcz8gLNuwtnaL/fc + YXZW510P2nQLSgcMGDeN/dMYj3Cbxe5Aff9kUtDYMVYZBluNMo6pNI82NnsNdjakJqS96c8/6Ul2lVJN + 9QyVxpiY+vzFLT2Q+aPsydK3a5f4ATnB3HMA4wqVXIhjdFsOCxqszbtxPmz6KiLTa6rEeqaWc8gEroMc + pvr77uP3eU20/VrnwbWqmOSBKk2dnaMEUMeTPKn+VToZIhZLyRnR2Z6r/9si87wnMX5X6WxLj7YvoRk7 + N2+UyZeVstjSTZ+rtB9Q37MV2qK/rx2gYKGgN7rkcdKzzdN7bZP7xy2Wp3s7UvAMB6UdgHJdNwX4sxQo + zo1Ij9rV5LNLzjWJizOTEzlgTB1XUN3SX6V/VMsQW6Tn1EmRWderNKo8N6rUsdLmkUYGPpgdAPG5f/ws + 6WVOVikvKht66rMCwG3AaIf8R21nFscp4DQLnjkC6Cx/80UzRRBovqK5zoGQHSq2ywNpl/3aOnbpKiH3 + vf5yefzxx+O2dkwqU3QcyRZEQlskXbQwk6DDYkC1GDA+pfygktiwy0ublAXA5mXb4oEi+mjtz9+YRE0k + xuaXdX77HXEAo443GXVYqDhGonOj+6RPnz55yqKVHzogwEiDF7/QylQmvMobdQJkc5zEJhKJaFFZYJ6P + r7gwrtLACKiSq1evlgXDBpo6zkrK+SSh+5IBBsJfYmn6J6na1e/plgljy2Dc5Z+8p4Csk+RGnaCJsuvk + oQCKG5Q58XBaeA1q0ykpliWEI14TJdq1OiswLlHmZfUfWuNiU5n8Uh51BtCZbFPqXWHXLeuo6mcQcPV/ + pMjVr+AQiMgvF58mPZ/3sszQfvrR3/680A6OuK2GiqMq7+s6qXORGHHAbFQAJefkyBJe+BGSv/+s720L + VDoo6dnbFj2c5gGFX9rR/9npYWnE9JoxJY+Wxo0ekuFVLzDjPDaovVRvfwH4QrzQrgAim9+KSmbMdEMS + Dex3ABsmDCbaopG/Skapk3T8IrKR814CwAhwb36F+EJt57nHyPOPP2o8G9RO9mzdrP1XXPmbc6+jKgVj + C9S6+dvrnke+T11MmQtoTu9fXU5euf0Gee/xRvJVx9Yy5vmnZPJdNU3QYB6MO077gqMP6L+QBYCCnZa8 + hggdn11WMlsQelis5cEgcGLlZwMMI6aUjci2t72FIls7dLxX2fbLiPxW6kTp2KxpPO+q/8CzfaUDAoz/ + bNsiUy4r5iVFUIlwx7jU7GoloJCloNBWwUQlSpih05232ArJ+Q04H5CSAIQVE8dIetlTVBJSiUFXcAMF + /6SMPQ81fcvXnoqWoStq//tvt4lJmv6g6kBHLujV3gBsFluqUNHD9krnULC3Ec+3RicauyeQ1DJRcfAi + IyUoSC4na0pQUnaFPtC2LCVz9IkRGaHqW9jOBOpMkPqMx+4wyXL58wmAUReade9joI7IuBJHm8SGHSa3 + /buJaMemjTLl6pLmFCORb67ASEIPlZpxgACMXZ96MltWa6TfFQPfsr7BU7q+e0yNDgDjrqGpMvdWBUbl + nW8uOcuC1L+6opQB4+xautCoxLeXOprHwiRb2VqfrWBvERD168RVTNRo4l6XjR8tk0qepKp8mrdVMeDY + QNVbT4yhSrMcndo1dqa0Pycg/LXm84/MPkqIDqf17bUIxIptfRug2ka1NBl7jC6qp6XYYkQZf4YudAoI + 9lnbD48hfc4n8cngcBuqK0haC+71vNtfXFYiHoSOJlaQhXJ/kJlW+na09s3Q9nv20uztYMwWc0Y2/FCh + mDwbC+x2ccqFZSvd78BIJTf8+ZOJ/IDDkmdU/QEcfBMZtXUHe6Nr68CrZEBIQsvmzeKeQRcPBphtXLNa + MutUNlBY+IQ+C1AIsd1Zcoa/UmVqLKHExzddFY+MDwZ6w7gLe3XwgPEOZTJLIrH3M0ML7dBCPB9ZuWFc + l/D1i4pnS/vb6srP5U41QJl1o04sQDfMfskzVMpd1RsJU9X/i06S7p2ejwcK+5mXv3M7P2l9sPhplZpC + gBHJdJNOPurBtsp+TR7c65Cg/BBAOu3umiatE4O69SediDl47nFebf1eryUruAJfr8cfMc+hy3QEYMx6 + 4AZTiXBc/M3+58AkMOnnI5wKnvQ0oEZ5C2j+5OarzUOdVaGAeRsp+mzskHNu8MBiZOnjpO2jj9hiRGIF + l25t6ddDZUKxIyTrkjTbgx18lwFjHwXG8yIy8vxj5YXmTe2UOv8hU7s2b5QZN1Y06c6cRq+qpgPAhgAj + 3+Fg2NpfpcBGaTLzujSZfnWazLhS/16hf/V/Ps+qEZGFd2Bn1WdpOwgbCn0exUwGupDcoKq08ibbAXML + Qj8YxDyc+9SD3qJXO2Za8UnALID096w62g4dM/al+22l+5pqzE8HBBgX92znqb+qTm4arswVyIyDWr2Z + FGN4Bs9IkbevrWQBtqy8iMguNgmJCUabev8NBgqzbouBWAJ7IOnDZt/u2dm+qlYqYaA3NokFAKNeN7vh + EeZxDXteWHGS4sq+ntpKOw0UK50jjz/cyBIRfHJ9ZVOhkF43fa11DskMRCGl2RpVsYiZG3PBMdKjQ3sL + MwqqO/TD3I7NPWBsEQKMWugTguAnK3igmrx/e+34DqCCeCF594IPXrO2ocKvIFwKqTFBuA7gv+0nVRvL + 6bjr+3s/+oAtTHhBsRWzwE258nwDpXn1Yk4U/2TWghqMOjWlrPeMV+tWt1yRA5rq5CmGAT5mh0pgV8up + sK1sGwdelfH6h6M3nenGhRVhi1766QcmwWQpeJO8Yi9gVCl3A6nKFBh/KXmy1s/z9roICPh1xfuvxvtt + 3q0qbXNQvu8ZexUDR086MnBAcmJvOIWECvoZCZHfE4Ug+YstOAN0ganqRWm8c0O1UG3kYBNmolkP3Wxm + k4X3KH8FeII+2a6L05QK2g4dk/euqyKdO3c2TSinhB0Fof0OjNhWpt9YySYx5zKHARkTbOVLunKfotKF + qiTd76gbNw77VV+AjL+zAAWdUFOvVGYdrc9L4EHmyNOFj6ukqtLamFLHyButW1rgrT+hBODgASOqdKrM + fzAmhYY8L6xgU0RSpO4MFhOALXgkayDUiJX5Y7K76MRhYizvFfW8yCHPAjA3DGWSRWVU8eMSZoKGgRww + znmQ56XuDYxIvDizrlMmUnXs0+sq7mWLyU/cGhNnzYK5kk76LpWske69qIDs742/X8dk648KPOU94Hmx + 8QPZJKmVOOPKnGCLyQqVevcCRgUHQIeTAjGtTDg3Kp3vb2C2sQ96dpPxpY73UpSRUIQAaf+9uRWerZLH + 2k7Kb2fogqzP73PztXHpA6kWUKOPluhigAQzQ3kNNXev9Ff6nA1IjMq3v5Q6xWLq/CcEblm/TqbfUMn6 + gFyQ5HvMC5g56c/i9ggiJ16Swv9Wsl+XUyFT+RaVUjMv0Hqq1Pry7Tfsc/jW/iDqMO0G1QYJ1Wm592KJ + TXgjZgvsr8VUC6pfO546rbAl3/0OjJsmjpb0C440NXop25VCvNFIPHPv9uyLIy88Xto99qgFsLrdA34Q + 4+9CbFPaMSYxfKmTk326AWCg8NxVyojOCfJnhdNl6AsdjPGZnKhzDAaTHmDEC7iwabgEtlfR3wH09QN0 + chXFlvdfSfGJRx42iRdvGcA2/OOPZAKHPGk9Fj6OFznkeVosa49KlMRxjlP1rXfzJnuFVEBxYDw5RWbf + RTzo3sBIsVhGBXoAFIk5URhJXohrkbKzHr3dJvkkvLTD8E4rKAXfrZ9RpTezk+cibY8B4/22xQ5TBra3 + RZ9+qGq055TaYLs/9D7fJGDCE8O2ihMZFbxGqwT93KMP27bGQe/0l4llTzJ1Gs90cDdKroVnf8b+Zk+N + xqnz1GNNsnmjkdBJlbag57MGjHYGC0d4BuyZgBxhJXjff7nwJAXXDmaycAv6yu+/9KIxlLfm3ap1NQdJ + Puu7LyW2CKzr5HlyWWS6PnC3RTwUtid3X2nHWtUirrjAgunXPOf1rb8dtkOpjWdfHV/8COnU6L79dtLh + fgVGgGz5Oy954QTFIpZFOuhFJtxm648R2zCOGvpVpbNNpUG6CdviQ8NXjhulYIuKHDHgs1RcIcDghfKo + ZKkqxLgjFbiUKSaWPEp+ffw+Y368o6g6AM68F5+NA6MdsxDyvHhh4o9XVey3VFUVFRj1PkBxSNULpOmj + jQ0UASEmGaorYv7Ee2qbRDpbValEoS7WFz+g3unAn5kmvZs8mM0u5zKQ0weL3ulrtsyZ16sUzsIQ8jzC + eJa208mvC84fCiQvdu2SbatafpgI6RL1e+7QjyxsxqRfcmmGOWHon3FFZNOX7PGNykSVlHqoxIhphDNk + kFjnvtTZVNSpVVTqVzUvzE7IrpDFjfR+Ba+fLj5NOjzZ0lTdz1QFHFethIHaksdiKlceJCdX7GB+5UUc + HOReHF75HAucdt5ot3AgoS/o8YxNRNKdmaMn6AzQd68wB05Efitzkjwfi7slmQES48z76phjBzvrerQF + fUZ+6rrPBWBUlXtpU0w9pCk7QZ5p2cI2DxTmFrrCoC2zpklm+TNMsl7fXfsqCIw4Xh5U3tN59OtFJ0nr + p1rtt3bsV2BkMs1v9aCpmFOVCf8eo5M4eOCVSpBLOnjSIoGqfW6pGVdpnDfafyQBDd+oK0NmjdJ2j0l4 + iYCMCToxRSdoVNXuqJeb0AzgKpk+epdkpKcbOLJizu3RzgNGJlouwIj6yDVz79NnHuMB7ohyp8vjDz9k + 6jOSIqCIpEfIBhNkag9P8pjOHt8xKuGFOYx8QD7+9Ki8/OBdpn4GPW6s7kuHKUCpxEU857bf9F5/v8YK + EuMaVaHYwjdRVdE3mj5kNkuAOr/bArkOaX3logWSXr2M9T2nIFpfBduifWdecZWmkS6JY+zc4gmTGAHG + 2bNmybQHbzJgm1071cAiKInx2RwGtZU39Lrhlc81D6Ttmf/uOxl/29U2QRbcqRMoP8AIUFiQsKrQ57N3 + OFXeuq5qfFuZ2wnCgkl7ZzW5w4A5UToviw/kQCYFxu8rnBlPr4/5Y94v30t66aNt3GddF5WdnGNzIEGR + EgPGeZyNou34UheBdrpwv/HGG9lSdOXHrLI/CP7aOHmCZJQ+2TRBbw959nYYP9TRdmh/Dr2sZDzVmN/R + VVjt2K/AyIH602qVN1VufhNtaABwyALz97hUmVbdSzE2uuQx8rSqNH7PoHM6uAlMwxnIrAfragd5ti6e + kdP2NJw7SFWLnvSMthb7pRLUiM+Gmo0F4JrVtbVJQQub5wC07nkqia37KOZs0WeNuvA4ad3wzngGG8Ig + AHVURsR7VrIFw4eYdDL1ijTZ/qeCY4htzmylCpqWsktB+t361+0V+kH7WRxWj/3TJjUOqy1f64IzVvsy + UGdsli5kCVV/yE3V8nQGTiICkJGksmKhQnNux/nFOGZ/r/VRRhFZ8xYSWURGlT5eOrVoFrcxzpo4XiZf + Xdom6sIGCq4AWyD+zgzt76XaiYE4DD68tmJ8FxQTetITDT3AuVbbnk/nixemo4sF46fSXPe7bonH9fmN + +JhYZj7sZZJe9mh4Oi++W/IIYTOpMiyWvdsFsk99pL63t1zfs6aDLgC0M3D//i47VG33UqopTynvD6he + fr95cveFeP/q7z6zsSZ7Fkc3+EOjkPItM/slupipQPDO9VXj/OCPjS2sduxXYNyUPtYCfJnkK/voBPDv + 0IhNnvWDFKzOUgbVSf529Uv28gwyEZ3KR6MBheVDP5TMS87wJNErVBX7K7ETwIq+C2DcM4tksFofZeK/ + FBg/fP1Vk2Cws0zv3MqTGB/PGRgBYBxItt1QwQHpkySweJ+xUTEp8EiiLgKKTDDKijF/mPSUWTaWtTxE + wjNgjDlM6LNBtauGqgqUtZMnyqTzj1Bgjlof4tEO1pltjcSMTq/pqfs/Vyomb7zU1xwwYVsjcyP6H6l1 + 9ksvWNtno14q+IYBo7Pv0tcjKpwlz7VtE/fWzvz2C0kv7q38xBGGAQ7SwvoXdRErps9Q1arvrbXMkcWi + g/0us9fz5unH07pDJdOw5LOJiqlkJJbVumEXbNe0SXx/M7Yq54wwYFRwA1BWttrbS0oB7Bao5sCzPr/s + AvOSIpWP/ewTybj4JGvjtEu1fniSc4gz3F/FjojVvplaMdUWx/61r7BFwGkOh9Kul1XfDDW78dTKRAAo + /7r+Qur9RIWRbjhdvMWs1x114/wQtmljX2m/ASMNXdixubfbBW/cUGUMdn3EJo+FuSgALX7Sc46MPy8q + nRvcmi2o2yV8cGCwedJfMrf5PQZGrMTj0lJU9Y2pcwmALF70dxI6bP7K22c56sITpV83z+YGg2R1bOEB + Y+McVGlUfwX31S/rZFU1jjp8ryo0QcfUG28k2UoAdCYXDIeEh6S1SoHR+uI87YtPI5boIvgOwB0VdC5q + jwLPsKsvCt3uxDM3zp8jGZXOsom3mp0oYXbWWB8vYjeNqr5jSh0nr3Z4psCH6DOmtImwHYAWyRYJ186i + 8b9X64GJZHE7fa9e903FYvJ8+2fj5pFpb/U1SRvvO8d+7nVinxZACPshAcx/qSbxTJNHTBp3R7pOZweU + LqaTy+hC85YuNCFZdsIKNkIyfM+OZfgeckWpbKFhLGhuwdhJQtm6Vc35s/IZBXCAMVDPXcrX8+88wp71 + Uc1KFjiN5DnuuSe9wH79fnmrNNmTIKB7fxfMFJv7eQs4/dXvthuyherg2MwPD+wvgqdXfjPMFiEyFVlo + ErGZsXaYs6yhZ19kJxtnfcMPibb57ivtN2D8H63k9LqVzUHAqX1IQ37JwvIIIs1c7Ukz5FVr9XhTCyMA + rFxS080L58vqYQNk1n21JaPscTahCJbmkHgyVNt+aSQt/8QMKzpZbTfGcM/rO7LU8dJdJysSHpN1codm + cedLImCkDTvHa51VfTOb6Hmp0u2W603KxXCPxAGzUW/EeieNMegb5s3W+p9sq/a691WtwgETAmSECi3G + ZnVSRH5V0O3TpbP1RzArzdY1q2TK9RWszss7JVgc9DN2xvUfah8X1dVW+65/4/tyTMGWG/H+Re+8ZMA9 + 83pvF5NJur73AvCo2HM4X0Tr9/llJaRTzPaGtDe5yR3WD5yKh+MlTNpD/cMTzDZNDqbybw9lkZgz4ksD + HgvZwVCPPSoPwGMquvZHViXU/FRTyfw2bVRLZ2L4mz4mWQfA+GxM5Q+8w/Za11EJX/n87RuqmdbASXUT + a1U0L/CUcpz3nHfgLuxCnVeSmxTPfmxvsduDfyh5pJkrK77+1APGK5WvLG7TawMqNRmMssp7ZpXvKpwp + 7Vo9GeeH/eFA2m/AuCVrkmXJmKjS4CJdMW23i2/yoILZMaTnalEV0x/UTWOzBr0vM1vcZ+fD2Gqn1yBZ + woCcy7Kitz5zooJiglCdvYpeY/t3PyFuDWA8QV5Q9Q7pFIN7Zvsn/guMCcJ1kMo2DNK6nKkDpPX5rPK5 + 0uyJJ0xKIMgUm40L6oXZHOAYkBGKcJ1OstMjsvpVnchhe7x5h/bT6pe8lXH8eUfI680aexMtFuTtgAzg + nXbfjQY8Cx5J9YAxaGelzWNTZJulYNN+1olK0lgX6F0QgzXAOPe5WAwlWbQnZl/wKIwJGYo455iFccC1 + FeM2vDG//yYZlYuaJDWvPupp6t5g87EuYK/i0daxOjtFPrr64mzOEeytS9InSCY7inQirWqrCw3qeB6A + 0VT0nlEzQUzSZ6OiM36hfbxujS4+l9hYr+0UsxEG3rFDnzcT04e28/3al3lJT/q/4TldcA657X/vZb/v + gBRdcOiX+Q1ZYBA+Tpe2eQQU2k/ht2BxvxUm8VwHjNMvT7MdT8Rt0g6zCbNVVvsYNfq1WpfH40XdhoH8 + bljIjfYLMFLB1cMHefFuxXRF/1iBAFXPN2GZyGSGMRXvgiOl9YP3ScfnOsjQti1k7M2XmWcK0R/mQkJE + ZZp3X0TWvqsdNlaBQAHEEj2EgEto0euYxOve18mqwDbywhOkc5vWJikAEhnPPu45XxLledQCYHLcKwA6 + /rw06XT7TXEwxybKCoxI73cWQfy/fetWmXpnTZ1ACowKfKGqL3VUSYvdQWwdQ+J45976oXu8mbyz2jxq + ADrzJnbTaL+ESc48U9815zatt7ZvXMmj5I1uL2QLS8mPCsK1sx66yYCR8eDZQfuu7WT6JlUyS3or/Ku3 + XBuPERz37uu20FHvFS10HINgo/8zEVa00PrqZEYq73FH3fgOB5wa9MPqpUsk66aqNlmWP6H9mRdg1N8B + ChfyMfGCNOn8wN1xFT2Yks0BIwHFG3ooDwczYyvwcFqdSbanp8hr9a83jef7x+4xaTb9LO5TQEWa9dfD + dz8SLL/zbMJT8HITv8n/fEfSCiQmrrM8kwR8I2H7pWzqFNJ2PPvYNqdf5jkdsYG6PIzBSAeIvyySWydP + kNWfDZCVwz6UFUM/kOVD3pXlqrVh18YBiEQN/zmzjp/XC0oGjKT+U36ZUiEiW99ToUfbTVt3krCXEwFP + S7GY02ceuj9usvDbSQujHo72CzDSWfPaPGLSQpZKDdtHxiQ7N3lUsrEUY9fhjU6RPy48Xt6//lIZybkm + xT1biEmHKl1xtsnybmm2NxfAYiJmO2MkrwWAUClt1VuoFan6TgXGdm3DgTFMYsRep98vaOapuSPKn2Gn + s2EAZoDcITwwDYMcpL+3bJapd9QwUF3SKTH4mlPmr1Q7tgBmfqvhLdk2yTsJD/Cd/0ZPk1SmVE6Tbb+r + ujZO7w08j3fwrvi51QpKQ+6sky2QOT9MtVvbwe4EnrWEfdq0IyCpMkbrVPUB2Meec6R0ub+BgQ8mgYkt + H7DxtT3DL2f3PFrRiQ8okCACYPyz9PHSuuljdr/bqYFdDECf3tRLgb/koRgw+p+ToPA+ziqmb38te3KO + sXDbFRizalVSrSYqG3qpdBw8ggBgVA1iZnWAMVVevPc2A8ZR11zkmQouiVh7grGPPIPvkJa360K9vk9U + 1nSOyqqnVTJqmSpLlceWP5kma/W7Db0UJPqnqsSpZaD2F5mp9D4WFNpsfwFSrRvg6d61XSXUXZ+qhtTb + A2gkrXd0jmEL58iGoCeXsl21vDn319EF7UjPTKFgzxhY5nT9TObxrLtqysIxI20MAEn40EmR+0I8Y+UP + X8rEYkfIFFWZSeVGe9g+ufo5QNHbofR5lfMs+sOdFx9MBlxYtF+Acec6VRurFrPJw46WbIkedKK6lFQw + HDZD63T9awOhgMgKTSD02veillyCzDs7yKgdAiR5Lnov0tiat7G3pcro0sdJ59ZPW/gKoJOp6qGp0k0S + OF+0/kz4+Y3SrF2fXFbC7F5MKictYq9hgMKYZCfn3ThgfD4xMFIsYS3qzykp8sbdN2dzDLitfLxn8eB3 + LV0W0jX9iaQW9jxCebb8GJXMi7S/i6bIj5cXNzXED7ZhYB5Gfy9fKlOuLGWL3spXQtrBAqLfLemg9T85 + Ir9eeKK0bdHcbLBfDR8uk26oZCs/wdV2vktwJ4lKSGTU5mAsVP8PqpePZ3F3qbzYgUOdZ7Z6yICRs5I5 + M3mH7zl7FQUjU9Ff0wlmKnqqvHl9Vdt77SQot4ec/oW2Lpgrk6ucbYfhb+ibABhVIptZTSeuAmPPe2+X + Pi90lnEVTtOxi8iCO3RMMBX46xG7jxCjJY9GZHJZ5oHHk7TFCmCkQGA7VfQ3zgGaqlLUVFUxZ9U5Qubf + HrHD5pc0TZMVrRRUVfPiFEEAdIeqoBzFivq++wudfzd7HnMWxC4Nb4tL7v6sOvDrxpE/S+bFJxn40JaJ + qlXh8Z9dU99bSeuH+Qhe09/Try4tWRPGmT3WBcK7Pisocf+6rAxJv+h04eCvLa+nyj+fK9irRE5mcupE + GzrfeYslEvbzLwCdV/7NKxU6MNLJ63/62utgBZCV3T1JLz559C8TdfM3uoqdH5XxR3tgiHSYdVma2SM3 + fe6paNxngcsJEhXkq/BeBY4NOhGxGXFa2kuPPmAdTFxc+lONPGB8LLHEaMBIaIa2621dff2Znp2dIxGD + wICzWt5vpoElHKqUCBj1PXbK4W3KDHrtq3fdZKASlGjM0z3hL8lQyZeJtKpfbAEKPo+Ct3uyAsiDWnft + 6zGljpX+zz1ToBV3c1a6vvNkc3qsVxVnL1sp/aTfzb1HgVH76btLzpJ27dpZQPGP778t6Rez15rMMboA + IeX5VUItSEC2DVD5AWcRqcBcvJpzjtDPpF6b1foRmzAzrlGQte16yiu+Z2UrCmj27Ge0X89QYNTxf/6e + O7Kp6OxH9587vmlapqSXPM4iCUgUsZeDx0mMNTyJsftDDeXtZo1lImnn9B2rdXEwU4G/HlqsHh2iMg4n + ovJcerEUGXfekfJLmZPMsUCfkUNzVIlj5a/zjpJxRakzYKlFxxqgs8Jn+klBCyFj8oUKIlUjMufGqCx+ + 2MvMA+DS1h/0eU+1ejIuafkX8i0TR0vGRcfbnKU+nDu0pktU/v5YpTYFWcCfI15dFnWu+6lvN1Nj4Xt4 + cl8lNubN+qkZklHudAVg79iH//lZ+eQB5VmtE21guy1hcUjlLnl1fjWevFKhAyMNnKcAYHuZdWUmrb+p + eAEQQLVeo2rt3IYKRo8jHarKPUpBdIr+NqGIZ7cKA46CFn0WKjgn8WVe5NkvP6h/vampSGOT7r7OA0YC + vHMCxkc8iXFQ9YtD48ESDRDAOFvVdZwlix6PLRb+58cKjgx2wMyo4U0EgNF/mpvLCkTZtHaNTK5e0sBu + gUofVu+QZ9IW3re2v07YU722f35TNS+sJAYIeQmO5ffV331ukhyJeLeMUOmETEG+vrL6/0W0gU5mrf/A + GuXM62sLSPsW9m7Lv9hTgUZV5iDQAJYLG+pkUIkLc0e7Rx+OZ3H3JwqgLHi9p6nEqKzbTSL0PStY9NnY + FxfcrWChoPJ7mROlTUxFx77ovP4udIW2bpo2WTJKn2C20s1hqcIARmyM1wKMKdKl8QMyqOHNnmTFUbDK + 38GM2qi6tJsthvDbRJVG361WVto1qC/NHm9qiXKRYumzru3aSq8WTeXlhxVw77xB3r6tlrxf92r55NpL + ZPhlJeXryufJD+XPlD9LnygTzk3zbPpInk4FRspSQAHIetevbc8MSlq7NqyTaddcGLf7zrjWA0TGweyZ + FBUm9gwvomq9p+URdvblIw0MYF0Uhn9BKQhx75Y1q2TyFedbO7Iqq7R6QzQetziu+BHSQfuIvmHOEhbn + tId9BeUwKnRg3IUaXaWoAkCKzCTpq0o/iQAO1ZbJzKQFdGwnTIJrC6UouBFAPYOMM8o4n9aqbHuycURM + uKeWAd7CJxNIc3ovdV3YTBlIr/tcGTM/Oe2YcLPbNbHJQOxmIonRgEUXjRkEZSuwfHBjNVvlqaMLeAcU + YSTUyakP6UTU66Zzjo62LVGgO2C7XX/D5ovENv6CI+W9Hl3jp8Sx6ucWtsE7l733skkNbFu05wYODWPx + Id3ZlIsVAM9MkVdvvNoWEEJ1xjasYxPX8igqSASBzHMWpMi0y7WOOqndvvlgwD/1ZDIsxViv0gWpwzgX + OqcdMOa4GIgjQqUeffZnVS+Iq+hhAe+0dc2vI8x7zcFL296N7h1y4wfG01Kkx313yLc1LrZx4/B+HCfO + 5ueKl6FH63G5px4Oq3KeNG7c2PJMsmuGsUa1R0LGFshfwAwwgFfRHohtBdBZMHo831FebPOU9G32qLzd + sJ4MuvFKGVTrUhl4fRUZeF1lGaCaTe+7bzVQ5F7svC7XJPbwhW0eiUuK07ROgKJJxkEvui4Iuz797yLw + 2c1XWd386dX2RZ2mv6lPVv1qBtKYEQBqA3b9/Nb1VW3RINSIRZIIAtrAgr4v701EhQqMNG7Fe694Ha1q + wvJER5z6ik1kAGt/AqIrBm6qUjY6wtS8r68oYYz42bBhMv726ibNLeuSWM1FVV3WSRlar/up3Blxe40D + xpwCZT1gfMzunf9IVJ+lC0bg+a5YHsm7lAGVMb64snRo3Bl9DVPMea2HTt4U22HEOTOhDhiKtgdpfKmq + cIRQMUZf1r3SEgHnVSUBNOYTqqOLyqy6MZsmY+d7BxIkIU2s9JOUqbvcc7tN4E8GfiQTqp5jkgyH01uY + jn/iadmhEhnnlpCiDZvz29dViduTguYK+mB1+jhJv/BU76D+N7Q+BIoHnumKBTq/zCTTeqlE8k7NKgnj + FyH+rmSLml5LIl3i6IL20Dgw1lTpT4Gxz9315JcqZ1v/LGkU7ilnMdj2PlsdtY90gelX+wo75IpFFqma + WFgkOpwjOPT4S/3YSgmAs0AgqSHlMnbwH1oLIEU4E/vRAUB4BvAkSxVACrACKDyL/dEsMCsG9o+DkJ3l + 82p4nV0hXGkuRxsrXw6qc1mhxxHCf8smjpWMvi/ID880l0+a3CvvNrxFXmlY38JzaA9xx/QPi7mTFnPi + 2YJSoQLjbhXLp9cubysyWZ6RHPy7XQ6FAugtaaOgo8D4S4UzpKdO2sEfDZAJKsLD0GteD7GbxQp7vZe/ + qJNA1dGfy54e35IEMOaWHp4BnNP2UQPGuQ+kmYMl9PgEwEXfs7Clp7L/WPEs6dm9e2juPN639M+fPTVI + n7vixQSOo1hButtKRiASfeqkHFvmePng5b426ZgsOHZykhr/o++dfmcNrZd3NCtSfrZ3AL76fgvD0voQ + WvHsE0293Tt9e8ik4niaI7Jc22a2N/8E1P/5bllz1GhPxexw/93ZYgz9iS+YhBvmzpL08sXszJawEwb9 + xex6dlaIF2rVtcGtoVvK3CQDfFd9/4XY4f5XqbSIdKtAmO25PolxvD739Vuvk5EXnWo2P+IeLR1aEBgV + /De/ogB9gdZFF4+ud9Q18EdK5AAteImxwGOMiYO/gDaqL2BAkmUWSHZ7oMZyPaYcAJTFg331PAfwZFcI + AMqiimaA2QTJmMxK6ydPlIyLTjCJDLMFThyLt0wAinwPMM6/VcdGx+djlUgLO1Ac4YHnALTwJKAPoAPA + /GWs3BZeBBHU9/0hLUKFBoww1PofYrnnjotlXsnSDk2g2h2sgtS3qpcOrk7c8ecfIf1aPi4DXlP1UFVL + AH1df70mETDqvWte0xVWr/up7BnxoOW87NUEzBa82s3eO+fuI+wdiYARKXulghyeTWLtXmr7VOieUBhx + 3ZJFklEJ04VKmber1ETSWr8UF3y2jsnS9lEZf7wnNX52940GuiTvBdxzkhp36sI3ueLppg3Y6YQhILxT + JWFzvJycIiMuOVPatvFU4ZF3XhfbEultA9zrICibeNqGG/XeU1MsrdSTKkkx+cLy7TEhNsyaJhnli5rn + Np7Syz+ZXVEA49lzb6VPdUEse7I81aK5ATYTO8wBxfNXjogB43VeLsa/PwhIpH5gPCMib9S9WhcDnDWJ + tzoC3utfVKn1nIiMPe9Iaf/IQyZRkzQFgAMEWaDQBpj4FCRZVFW+R0oCPKgvAMeYsWAAoEjUBL/7wZPY + TP4HEHk29yF1L+jwhDdXlW/oF86xJrTIX9dsJQCM791YzSS4wtySx2JH3eBx6gzYA/RIpThIAXbMKfzO + dU5z2h9UqMC4qFsbM66TxHTjMCQvZYwQgDmYxQKohyko6Epp4SB33iBvvtxP0s9PM4bmHOhd48PrjYS0 + 7l1tn6pXv5c4QXq0bW2ifV4OmIJplnz0pqeG1km1vdLBHSNW9L2ooxsHqTp5luc9HVS/pqlKwSBvGAkD + +rTH7zbbHTtFtn6rUjoqboJ+tzySHHlQxouTJJnGgFf7SW6hD7xv3YjPrT5sL2SboanSvvdYBMHoVJl2 + pfbl6Sl2Rgsq0PtdOsqkC48129t0tofixAhIX+xy2KZ9yxY6bJMfXlXWgufxZgcPlnL12aQSY2alsyzl + FzsjwjzA9myd8Ns/iFpmFhJPEGoVfDag4283/68irk6BcWYtBfJPAMbAswPA+HadK2Ts+UdbCI4d2xqy + DZCQn9XPKfifGZXfS58gbWO5EZHy/DZU/4TnfzfeFH6Hn5CwWCThO3gCsKCP/OCJhsFfVF1+59qdWzbL + jFsu94Kpy3tn2VgoUqCuwYLTyFRp5eGX7qxrwFiYSWJpI21iEUAiJAMUUjISJFI0vE97aAfv8vdRYVOh + ASMDNvO2arqaKCPdpGoWWaUTSS77UpiIWmw/rk5ywMocOFpIB2YJDRKAAgUnBF5TAqgZ4C+rXyyvPd9e + Jpx9hJ0NTDr+vZIixApS3gaVPAj1GXXecdKr5RMGWC5YltU9ETGQi997xVbbWTfrpCErTSJpGsDUQuYg + wOSHqueGAgSMwYSYN+hdk8YsPIqTEwPbL7MV7KxT2Y8d8fJTqtQw7O66pnK5pAJhUiOfFz7fwuxRHHDF + eS7Zdtpon9ui84Vnx8Oz2O+Wmpaf8I8aZT2VjZMdW8XsWP5JhzSik259N2/RwQvZ+9ZaCYORXX22b90i + k68tY306v35E9gwPPNc9+5Mi+myV0lTFpb04hFwIUKLUW/Tv0vdetv6fcwOxgd6zsj0bYCSOUVXtsUWj + Mrwqx6OmytQqSF/KRwHwp/CcNR20Lrq4jChXNDSnYLDv80LcQ0HS9YOnK3x2PPP30kWSefHJZu+1RL+f + a92CbQsp5JOcVStNOCqj3x03FroqDVF/6stcoi8AdAoLF4DIQhBcOPYHFRow7ly3RjLLa2ejZnWIyh4m + Zw4Ale/Cs35nMhaR3ZOLGCCyG2btW/o+VQ0Xt06TFX2jtmvEMncnePcOLbun6EQic4vWdVSZE+WjBnVl + /FlpMqVyVLb95iW8CLvXJj5ZqUsqqJwVlVcaNTSDuTPeByeXnxjMxR+86h0he32al0MSCSvkPRTU1IXN + Il7c4YXHyesd2++l9vEuGGX1/LmScVUJs0nO4agDPPyJQFf7BVAm1CajhCc1jy95tAzs3dP2nTqpMcjk + TKoZd1xtKvsstiCqtJjtHfpcFqc1b+qkP0375+yoPPfQffJWkwc9lU3bPa1KRP72JQeIF52UgOXyJxTc + 9bpx5x8hHR68Nx6m4z+jx0/09/QHbjRHDZsCOP9lzxfap0xyN9Hf02frxF8Uy8yCPbbjAw3NcebOCvEH + OjuivYswfSgwzgUYg6FFFFM9tV2VVS1W/vm5/Gkmhdn5MGE2SS0A49pnPan7p7KnSofYnt8wB9D+oo1/ + /eZpTNpnBIZbSFEuwLiD4Pg34H2V6M9OsXOuMUX4j8qgzwqDaD+F5/kLoOl+299UKMBIRVcOfsckKRIs + rFfmD6pZBSqx+y2rjT4PSYhsOqtej8qcu6Pm4IFxAQTOYh5/bMSkVcAxEbjZBCaJan9sWV5M1q8Vz5QJ + RdO8w7VG6b0JQAUJdctP+t7yCqqqvr38UANb7VFDczt5D6BZ8v4rpr5mVVUA/gMPcvh7KOylXvO2SrWq + omGLerVl01BHAc9FdZry4E22CyazdJps+UGBK4dnu8zpOHjGH6dSVPFUGVHnUpMaAQqeHzRsI2VMqaL9 + dFLE0phZtIH/mfSrgvmyF7TOCp5flz/LUoWNKn+6SYAEIq/tpNIJJ+QFJiGSFV7qebd7atq3Fc6S1qpi + 4l0Nhun4Ccl2fuwEPosdLK7veF4lRwVHy+Wn78EBsvUd7ZcLVY3WReCncqdJ6ydbxkOgEp1/w0Sc/0Ir + q898TvYLAUZU9K3vR2SKqujjikXlxwqne153Tj3ket+1rgCM67rq4lEsImOKHyU9WzU3z7j/XJ/9OfF5 + 9rJ3+5lkPuXiqGwn90BOtsVY2fM5Wy89pxoL3csN6oXG1/5bqFCAkQk0t8ntNjE5A2Xbr9rZCdTRPJUY + IHLQEhN4x/hU2fBxxBw6Uyrq4JzqSVLE77G1a2Tp42XCBd7B9uOOSNWJG1MnEwAzoEn2lyx9Fis8wMCA + z6yrgEIyhgTAaEcPKHBOq0YdUuWtBjdZeAQqbm4p4mGa5d8MMxUqs1TEkiwk2sJHQarb+r23Zeyvs46W + Ps0ezaa2uwnE+wDk2a/39LzTJ0RkWWcFoCkKQDnsGAI4t/2mIK/Px9mRrvcOb/qAtQWbDmCBvYd3UNZ8 + O1QlBQUuBbjVCtiWBMP3PPJr4pya/1iaSeKfVi0hw666yKsTkqwuWLs/UxUzZNIZiA2MyDRVSVnoBlQv + F0924Fcxg31L/dauXCGZ9a6092APZCHhnJgdn6TKP1/qs4dGZHZtHS+kRdTo2lfEtwG6Z4eNGxL5rEfr + GzAuuE/rHhLG4gGj8vwluigXS5MfVWLkPYv0esvE47vWFTvp7iUVIKiv9ucbD951QCVG+HBOs7s9yVb7 + m507YfX0F+JDt+niMrm0Arrex3ba55o1NadaWAzov4EKBRj/2bVTptWuYBNgtq762BcTHjWQh2KB3wps + nDW95Lk0mX4NRvMYGCr4IoFMKJ4mX1Q5V/rUrSGtHm0sPRrWV5XwKM+grOC8/XdVqROBc0xiWtxKGfp4 + lSYuAFBUYrlbwYoJn6DuJrmq1DizjjKITph369U05nB7eHNiDr5fM2G0TCp9okoLqbKePa0BcPEXSxc2 + KiJZl0dlVNGjpFfThy1OzR/P50ALyWnF7JmSXu5kWyzIfwnwGcAnWBz43o5+fdHrA9TR8SWOkq86P2Pg + yzsADLNPKQDN0YXPwrDMvqh1137wP8/rG51sdbxQqLEljrTJz3hYnGH/xCoboTDkSJxaWe/Vd7xxQ7X4 + 8bkuOUeYJIWUR5/PzUyXcfW8wGDagS1zRo00S8bgUoIBiqN0Qj/d+OF44g+3YwnpOPhs2j37sTtsAVz0 + MMAYIukqMG5TiZEF1g+MCwllAhgTtJW0/UhrOII+rlvNjnzA65poAShMwuRlkQWnpMi827SenyowhtTT + XwjjWaRtGq/aAv3Yv2aVbHvMD0S9DzQVCjBumZYpmRefYlLXsheUiZDWfJMm16KT1GyHmUVM6tgwRNWX + +3QQLlCGU8DCuG7OBf38zSVnSb861SzGjd0CeD2JdWP/5Kd31/XUNr1+9atajxxi+pjYW77V5xLwq2DL + ZFrWMWrvD7veClJRhgLovSo5aVvfvuXauDoRPMQ/SDDNxmWLJfOKkirVpMqaVxUocniXeY9V8ibTyGgF + xp6PNYqr7TCiX21nEiPhZT35oOc11raQ8zGn9lMATmIm5z0UkXFHe+Ax4cLjZMRrfS3omzg6M4BPn6yL + xxGW/m3OHVpvAD0gVQPEtt1SpWGTwh1Icd7Jc6reYuAPmXQUYvvYuTLlIq1H0aj0bHBL/NwfVPsw+yJE + nwKYhKtkTJokfzzawMaTdgDi45UP+GtSa3F9br1aJom6NHGo0Ym8qUijs3QxoP7Ln9C+DAM6nC8DkbzS + ZGzR/wLj4kdy8JB/RHv1nqt1EVDA/uHSc6SfqvV+k8H+krzor/mtH/bGmdjFpwBwBfyQerpC4o0tqiGQ + 3HnSWSl2vtFTDz9koWrsMc9p4TqcaZ+Bkc5Y/dUnZsQnNmvDJwouxAH6Jk3CgjNltCe9cXj72nejMru+ + t5fXSYdM9N/LnCADr7xQOja41TaRk5SAgcH4y6rF6s9Wp+H935AJZVStRvojiFqBJ6FaHAMFbJXjj0rx + kiIM0ntyqTv3LHgiBow3XxO3VeXG1PQTIDOlzqU6WSOy6uWcQZh6rFf1kn3FY845Sl5s8mC2A+t5lmNE + GB6gXPD7T5Je8kgDsBl1cJCo5J7I1kpR0CShBxmMMCNMILZRQeSvS4rKT6/3tYBymH7OM009wGXBeUUn + PfUOAC71XfOGXsNebL3WmSfm36Gg8oXWI8QR4Qqq2qa+es95ERl7dpp0f6BBPH4xpyQXtJ/v8Vgi4RLn + NqJ7R/nmjutk6E3VZHDty2TgdVXk45qVpNc93u4JxovAYXe8Kf0WNmZxYFSJcdnDyqNhO0IAxli4ztgz + fMD4cAxI/dfGitlT9Vm2H1z7B5B6r+lDtovF72QqbJDheUt7tbf3AcioxYRHBbdlZivaXjtS4H6VFqmr + 8kb/ayrF037hDCRUhxCa/VHng0n7DIxMygWEcWhnZ3GIzZ8xr7Bv0oQVrjHJ8i8mm6o8tVlBPXUZ6ZBB + 4DyVPjdcLa0fftAGgy1cSIaErrBaMTAABXGEhJpMUtVoXL0rTc2dqioojpSEddGJjYS67kN2mOhk1ndu + wu6nanzo9bHCVr75j3kOBoDRdnXEspXkBoy2F7ROZQUYlU67e8Ad9g4K4LNUJVjME6NKHStdmj+eUGLk + L4y5ZtUqybjvBltYzNnx4d62wL2K9gO2TnJmora742AnlD5Gfu/6rKQPfM+yUZMSjo3921W93yv+kr7U + BWMhuSoZP3JqnqWT76KobI3l1ctJXTNPbexA+DHnHy3PP9Y4z+cFw3+0nb6nX+AFFirCfNhbDMC6bXEs + LIAi3neeS4hJognN97Ob3mX27GWNU8MlRupObN8NWu/TFBgrxFRpIgMSAKOBDaFJ3b2Fn7H6rVIx+TC2 + NdGZSQpTaqR9qwb1t3E1oYOwqadDwqb8RetJmJOlaVNpG2cNp3g++XAjC3Ui8z1mHZyOLnzs30T7DIz/ + kGfwRp3sChRzbtdJoJJDIinNFcJtANBlqmKR1ABgmnBiig3apAsi8tUlxaTbLbWkZdPHbKM/qaFQWfHe + sbJi8GXFZ7XC6YGdiJUW6WZKzw4mvSJ9kL7Mgp1D6kCxhA0TMPpHLKZv3Qc5O21MlVbAmnufgri2t78C + IxPPD4xB76afsGVlXV/BJC8Oq08IjE5l15UaR8b3FYrGbTpBG6MjZ2+bOeQD884CUHPvxZyQGv4Of1HJ + HYlv6y/aFzU8cEQNBuAmlTjSFqnxR6XKko4xM0lI/+wYF5HpNXUCnZriqa5ITo3SPBU6B1CkkGh1SRMF + VV3Qfi17irTVMWfxY/tXbk4tiEkJkGHKQApktwcgA7AidbptcY5vAEX4BfUv0YTevWuXTLvlMlOlV7CF + MWR7H4UzX+bUSZWxp6fJD0iM2gZiKhMCI8W88Cl21jT9RD9/fu8tFvpS2BIYZy8t6dbGxgSBA9PU4gd1 + wWT7X1jdXKGOOnbztC3wIKD6xrVV4tIiO15yins93GmfgXH7wrmSUeY4M7gv66DAkpNdSyc8E2t1/6hM + vkSZQsHIbECqeo0vfoR8VuU86XZrbWnevLmpyxjJWfXZXQL4AArYnHB0AIIwEJMGwIGRAIuFqk5mlD7W + bCirVD3LycFhkk5WiixqHpFx0RSZUUuBdFLMaRM6+VNkmwL61CoRk5DfvrlGNmDMLcgVBpp2Z02TaFe9 + qO+mrwLvsKILyw7bQaJAo+/5+OqyJi2zSicK6+B/+oFFIv368uatZz/uFpWCLXQn0Zi4or9ziiIZeuaT + +v9ED1wJ5h2Xpqp5raiXvSfo0OI+Dhn7OioZJbSc7S1weLDJPm2B0WETz1c4tW9ObCvgV5XPjp/n4RaB + vHhqneQIPzBZuQ8ARBUP2xZH/zFWiZ67S3/Pql7aA0aOeE0EjENSVNuJyBgFxh/tDBr9zBbCIbogBa6N + F6Qx2xqIJKbaivbZhFJHy9DunezMbyRf2pFT/fJC/2zbIvOb3O5JijjXdI7OuxNpVscxmBDDX7R+LFbr + e0Qs3tKk2otONGmRgH0nLbp6/tukRWifgdESl+pKxACvG6idPkkZKMEkBISWdVVAVFHeHCq6io0pcZS8 + c1U5aXdvA7MfIhlheEdiwHaIUZqtcKykiO0E4yIZwdjYgRgUmIeCvWn92rWSUb2UrXKLWubs4LBJreC0 + sg8OC5Vy9J75D6WatxbnRzDcBZDd+Im2tZgyi0qlb91ybVyVzkuQKxN3VsuHzA63vFuCummd7KCwoUwY + VWN00Xj9hmrxhKr+3I9Bck6Yaa+/aH1LFp3FLXSx0vYkGpNshXdj4tA+WdOfUxijMvXKNJnfSFXo3/BE + h4ytfub6lS96dlfqa5EBeK8Dh6aHFWxunKI3ldApVdcGXFMhvuPFGfbDvMZhxDWACX2DDRYJEhB02+L4 + zOLJ77mBDsA4tWZZ2y2zpmMM4EOAcQenGV6fZhLjcFWJXS5BvOy5xQcitS24J03GneA5jEZXOEO++vC9 + bGnBHH/nh7h+z5ZNMu+Rep7Uj3NReQ7b565hulAGA+z9RdvI4fYA+3RdmFms4KXeN1a3tF9obkjh7oiJ + wpJsDzXaJ2CkQ1aP+NyzJ5WPypafdSKEHUEQmzxr3kV1UGkr5ilEZW7d8E6TEAFE7IfY0bADEQKDMR3A + YZV30qGfqYMDAhNxzdTYYU1z7srFmaL1QtqxbX6kutJ24ICY/7AyNUcqINH9EWuPFgBzMaeVKYCOKXmM + dG78YL6CXGGi2S3uVwCJyFKyOycARqTqZZ2895CRpvP9DWwXCGYE1BeSB7AoBAmpiQVj6dzZkl6pqPUz + gc1bdVzsQP7gu8KKvt8cUxk6OcilOUbv1QXBbLX0Q+B6uxbzQoP/qlwY96dfhlSSyyTUAnDieCERBAus + O7UvLGlGXsjxBeMAn7BYuMJnBzRB3gkSfMbRqSyC67toHyTI3OOAcbxKlkOrni/jSeR6PufZaNtzWRTM + 9jpQNYPLdF4ovzInRl5RXH74dIgJAggBTt3Prb6OuO7vOdNl5i2X2fNYpHAskrkc1djAOgTg/YXrljzi + CTCM5zfli8oTTzxhizMhVM4W+m+VFqF9AkYm4sJubbzYuWsUTFTVCosBZFJt+4NAWM82x4B9eEUZafpo + Y1uFUJkxjLP9iwBjUkyhBiEtoJ6yyjM5cmMQfoORZrZ/XNKVIabqird9tNYrB5un/faXXnsVe0C9iY0K + yV7qdR8pMylIAa5sccTxMKWSSjYKON+XP13atG6913ksOTEKYDa7xX2eZNo4TYF27/5iyyL2xVm3sYik + 2pnKT7d60gA4p50aEO03qVmlo6yu7Ux6oy2LnorKnmn67JCxya3kdg9hT4QVTS6vEuOpLBhHq1oZlemX + J9j+5y+obMNSZFVbBVUWS+37Tg82tAWSjD/BU/sOJP29YZ1Muexck7bWPaftTCAxmvOlNhJZqkqMZ1us + JEcOrCQZcU5pvCj6G4C75fWILmBe/zE3xl56tvzxck9T/10mGXiH+ZaI/23st22VZS+/YHGKxsdoZfqX + Peh7vgh5f7DExoNMRZZPUwUF7n/uzlss6QYxu/Dgv9UT7ad9AkZAYNqNFU06Q2IItefFJKDFT0c8j6cO + /JcqKTZp0sQcK2ToYBVCQgQQARjUCCZ/UF3OCzFYCz54zaQPS775ma7cqpqGSTtWsHuqZLiohQKRggiq + hwEK0tqZUcuduF4ln41kL66rqkXMBPB+jUv2soUFHSJBoi2zmt9jajgHU239SQGL1Gyo7NRPC8c6bP2J + iaLMqZPy/eoV4okGCALOyw4bs7VmpsukimfY4VcZ50dl8zeqRtEPYX2wDwWpd9Wrnibw1/lHyeCqxWX0 + OUdb3JsFdSeQtCio0ah2s+lXBZNfcLy09A7Oykts6P6krfNV6i5xlGci6qJ9lyD7jKXiul2BXUGNE+w4 + r4W2zK6l9yjP5LrdzsCoiGzsF7XjIsafoOOl/DfpgqiMvfUqyfz4PVk80zuWNyggUOCDXWtWyQrl+alX + lzTexLs/XvmXzDmbeisofq51B6BzAmktll1cpVzOjXEg/d5VF5uJC/MWeTExb2Djpi4HY1wOFO0TMG5f + OE8yy51kILK0TarZ67IBkP7vhXakSlYlL/B3XIkjTX1GUgQUsSMSgsLqCCBiP8SmhJSQ0wqZiLhv5aSx + kn7BEaaeLCdhqAJzQmDUgkQI8LEjBdCaqIAKU+DAmHhSitmZSAHmJErsos82esAkXZglL2e+QNRtwUud + 7dkwHlvgtnyn9VMV3Y510Lr8MzNFlmOHBaQV3HvdWju+CyQsy0yQ+J7Jw4o+ueUDBvQTjk+Refd70m9O + /VCQYrGgDfGeR+Sni0+W7jdUl3EXHGlAsehBlYq/9AAwbCLimUU6wZaKGWPIFaWzLQIuXjPRIrC/iD5c + P/InS7KQrgC18eWoqsWJgLGILG7iAeNXFYvJwOrlrC0c9Lb5FQB173vCCpIaJ+PNVE3FbPCnKUDq+MNv + 6dUvlCkdW8qCX0bImlUrbY5sW7dG1vz0jSzs/KQCYgnvOuVfYiNJn7fg3qjtyuEI1dwA0cr7RUyqXMx+ + 6JhaT7hcs8aPxBPpkuwWTQ6hhUU+v3PzcKICAyOdsvqLj72dJkUjsvZ9ZYKgPU8nIVLk2ndjdkW99h2V + gLApAip4m11MGROZCQ947EuHs4ptXLlCJl9TxtR2DpqnXjmq0wrebGOcdZNnJ5uoTP3h5aVkWOXz5M8L + T5A/S3llVJnj5acKZ0j3hvXNS4yDCMkGUGdFz03l4/c1s6ZLRoXTjPF4FzkUl3dPkx3jI7JHQXGjgoXb + PTKq9LHyTONGploSwO7CIwC+nIg+QKpcMH2qTKpyluclLhaRzZ/jpdeJUhjgqM/AQcVpjxx6xjs+rXqB + mUf+uvC4OF8sb6VS8XDtX7YD2gT0CvY1Ar9nX58Wl8LzuwjsLzLe5lgDldinlAdgEpsEAPcVbXRhOCMi + 35Y/U16sX8dACoBaeJ+2nQSwIfftVbRPdiuI7hqSKquejcgMtsGejSSu/ahzB7V2UunjJePqUjKlXjWZ + cnVpmUQOURZyXbAtWPz8iCy4U8dZVXPshOxayRsokiRCF6meKrmbEKDPVOGgvarQnLlDeI4/wQhjcqAX + qwNNBQZGOsYCu09P8fIY/hye0cXU1Kd1gFWiGFv8SGnzwD2mgiIVoD5jMwMUkbacirAvRL2QMqa3aWxg + nFUlzTLyJDwLhcLeaa3nmjcUGGGwc1Xdr3CWPPbgA9K86WOW6aV9m9by/DPtzGOKWkHyCMAKBxHOId6Z + m2rB76z2s74eJhOrnmtgAAAS8E384Jy7vTOETTLV34ZcVjJ+YJMLds6LakkfAp6A6ORXe3gTVSXQ2fV1 + 8ZocyXk3TF6LAiPOqIWPx6RbrS/71p988kkZfEsN+2wT7PSILNR2cbA8kxXJiIJ0suxRJCPPwP8jx3s+ + /pgFY7tFACdTbovA/iDjbZXEAJwZ1bW/BicOb7FsOapqY5Mbff7R0uneO+XniroYadtZ4OyQrpx2l/iL + AhTvQT3HK4w0veieqKU1A/RIkEGdrKiEagfhF1feqRaVxY+kecc7qFrOImRSeh5BkesZHxYBU6F1PN6q + UTEuwBANgcPFBXPn5tH/N1CBgfGfnTtkxm1XmX1x1q0KipOUeQI7IvjMtrRZt3pOly8rni0tWzQ3CQhH + y/446YsB43nzB71jqyneTsvKnZN3WgtOBjLrTK+tzKGSHCroRzUqmNGZ3H0YnlEnyHCDxxQjNFINNr+c + dlD4iTYSgsEe5Ak/fi9/3naNrvoeMLDA8F4mFKDC+cLtHn0kzpiELLktbHnpq7jUOHuWTFIpg216LE5L + 2uGIUSkmpA/yXBQUSd22+UsmkYKC9jMZjp5SadFOo+vdW36od7W1w+y1yiOcSYxqjXS1TMF0di1dANj5 + gbqo1/W8+TpTo5HC/RlbwpxM+5t454zbrzb1mOBtwC+RrZA4RjvDRQEKqe7VW2pK/ztUatQ2mdR4r5cG + LU8g5UrsWuya2GD//ihVNvVLlZXPRmV5c+0/Vd2XalndQb9/RYH741Rz9JgXPJ/vIWqA7OQzr/WkU+qN + Cv2EqtCMJTzPeBB1gVaUFz7PC/EMeJS+RpPiua6gpvMdv8PrBwOECwyMm8aPkszi3s4MdrCY/SowgSzE + Y2SqHcvISvTuNRX/e/i6djYS0P5gfjp3+ahfJb30Cba6rn5NGSeneEYKan86oTuoMMrkZ6bI2JJHS5+W + T5jHnFAZPOYEWBNGgvqMwwVmwSaamxQHMcDUDRsNTiaCeb/o10s+u7++DKl/rXx0S3X58IYr5fX6teTZ + Vi1tPziMibpOoHJ+PIHuXdyT9dZLxvCALk4StmDipS6oSm0LXqZKUzfpZIrtr3659hUm3RLXyal17Iz4 + oeXDMu6iEz3gJ5YOSUeleCfxAIpk4IEvkDRZMFl02NaX17Ou9wftWL5EplQ9R+sYMZubbQdMYCcFWACm + GWRb17Z9WuNiad+urYy56CQzLyBJbuyt80Ol5HyBFiV2PRIn4IwHnLr4CzbM+BEK+Xw+YL/ni1RZ0NBL + 1sI4jSlxtLS7+3YbS5xgjCMqNIk6GI+88HlOxHhumz5ZVvTvLXMfv0tmPXCDzHywrpYbZfq9tWxf/pLP + BsqaWTMsyoN35tcBWxhUIGCkgsvf7vvfgVex3ySywERjDy47LzJLeirjS/WuPyA2JIB2w6qVknl1GVPl + VumKniswxgqAQUZwpCtsou/ed5ttRQTIUe9wCMAkAA4SWX5NAFwLkHI/UhGSIAGzSKKozNhzABckVL5j + mxhAjCcQdT0/iwjvQsJE0pz4xD0xyVTLOSTMUHDMa+C3vyAtZqXIip5p5vnMODdFflYQaKUSBnFu1Jm+ + wnuJ+vXdu2/Jdw1vlK+vqySf1yhvORopQ6uVkYHXXCK977rZpHLME9zLNsCDaeDnfZxtw8Hy2NvWdErz + gDEEWFwB9JAMAdJhV5YxZ8Wg++pbfxMgTZzijo8jucZ0Hsiy86MiZvtd9rgKNyxSZ6fIeBV0XqhXyxYp + 4mZxLMKfLmYR3tuX8fifXTtlSY92klnq6P8ulthQyZFgf7Ueiin8lln1bJn9xeB4hApzZl/fnx8qEDAy + 4ea1vM8mGZ5VzlAJqtEUEjJsUDEd7+64s9Kk67137OVIgPkLmxC/t2xYL5Orl7U6rnpNV+y8AKNOerOT + Etd4qUqNei/2MkJy8JICZEiIbhVjoPIr6nMt/cczeBZMxy4CQARAAQjZSYNNkTAg+olDgbAt5lVadMS1 + 3MN7ZqqEO+b2GmYiMGntAjIhqZo3/b9t36s/ggVbrI7pZtKLldT+wcalEl/nerXNSE/iB+qOhIGJAamY + XRy0BXMAwM8WSiYdQEghMoFtn/xO+4lddAZ++ulAE+O5oF0TMw9YHsm3Iv91HIUVldJQY9lPjcQ47Ioy + Zod+WRe4kZedZ/3DArLwXpU8iSXMr9S4H4pJmip9LmmkAoCCku2L13r2u/5ysyuiqbDtD55nkcqrqSgR + cd+ejetljkqEvAeTA2BMWNDCB6OyvGVUljwalXk3Ryzrj3nkAc7yp8qkr7+wc44QJA4kTxQIGPf8vV2y + qhVXqSpF5j+qKyqJCkImFlLkugGeYfr3C06QZ5o3iwcquzRd+ZGA8koMxDaAUSVGwG2lqo55lRhpB8Hc + 8+7XATo5RYbUucxUf9TovARx54WoH8+A2ViJWSAAP4AXZxRqOgyJsRuQ4J1cW5D3cg8MZTkLR/4hY9hH + rcyJJzj9fJWI+qvkqOAYumPJX/Q3tgTuTE+VmXX+q0LjifYb6TE1UG/AmPFFK6A9SB4425COMUtgY6bg + 7eSEPBYGF7KFZLyv0QkFJWIC7QgHlV5m1ybcRRf9BGq0Ff0NiXH+XQqMeg8SI1oR5pfPuneSiRccacCD + h35NZ7zUes/BAEfeSV0VxDe/GpGZ13iORpPQdByJV2R3C6CO+YbFjEBueBNpLS927UTEefOz7qjugaIu + puDB0scilj0chxwhRWYa0LptfdtLMsy85fqfnnzEeApwhJ/2BaDzQwUCxo1//W7GZktf1FtBJ0EIiB8Y + fyx1iqlMeT0KYF9puwLjlOoXmnqzoi/b73LwSvuLtgMQBfBxGH1c61JTb3PbdVIQYoB5Fuo4Ki/2Vp7P + Co2ESP/4YzoLQryD+3kW4Dvu159ldM1yHpMq8006IyKLWqXJ32OUSXVBwC5soU2Mp6+wpZCUa3PvP8Lz + QuuK/suFJ0qrB++37ZwsHkwm+ghQpE0wMe1itUedB+yZbEjB5B7kLxIigdxIznihuf5ggSLvXPvtMGsb + wLjqae0T1OgcgAyHx/b3UyWrvCdBf3ZlaZO4ML9YWrzm3mFg9HVmqahs6KNSuqqwedmaV2hF34MaDwit + aKUS4rme6kq9KITQAYouBA2pn/FhkWI8WFwLOh7/q/fOf4IEwro4oGGUiMq67p5Daid98J5XP1cIdifD + ORsgcJ5+9uBtpmFiTnKO2gPBG/kGRiq1oG1jz3taIiKbvyYURhsVAjIGjO8pMJ4VkZ8uPNXCdMLS8+8P + 2qWAMk1Vx4knRWRxWwVvgs/zsiVOQWCnXjv3IQ8YB15fxdS9wjxYPEj0AcAHAwKUrjiG3Nc+4n5ACtBl + QRr94/cyqnYlY1ZzyByXKlMvi8rKfoTyeABJf5EQBHOIqduj2Hse9Y5cPRdpU1XoW+tYGirUY6RAogxw + mviTH/DXASRgT/8BgEgiFECTeiElAqa0e1/bW1Divcv79zEpil0oW99KHL/oCirpOnJJ6qTHmfROnSvN + RMDGBVTRkb//JmPreH0NMCClr1R+RHI0p8l+Bsft+nxMAUi+CwjEV0HBmUB+KXOSvFDPy2aFpAgoItE7 + mzaL6b4sUty35tP3vYWhqL6zeNRCkPYMT+wsQjpHcpx3kxeaNOCOG8yURd5VJ0zBU/ub8g2M/6OMO/3W + Kww0OPvEjtEMsS9SDBjf/y8wsiKxkqJWOcfL/iIm2YyHb7FQkTmx7Yp52ius1+yalCqzbsGTniIDa1ay + 2DpUvoO5d3dfCeClT5BGMQmM1gn7S6PbZEKJozzGVSZEA8C2yqFjeK43fhGVTV+pxN2DPeIqZeBs0WvT + tfSuc5VtFXOB+ix2MC5Sb3Ay8b8DfX7DPusKnwtzEdgXoo+WvfOS2bhm18oldVisEHNIfkMkMPaJt2/c + yBZSpBy86yymE0d8I+Oq/Xe7HtcuuFvnDgHd7EwJeW5hFdT8be/pXL1GFzXG7xwvW87Ay0tL80ZeAmiS + dqA+IykCikj3mG/2BRSh/+zZLdOuK2tOTOyvq9srKOYSumRHP2i/zLpG71GefOeWa812jbnlQG4RzTcw + 7tq4XqaqimoxcWTsCAnTcQVpY/0nukKp6D7y/OOle+tW5nl0HmnUxP1FSClznmtuE34qCQ0UvBMBeLwg + Lar0u93OWvFWuXdvqPavAEYIhgIckdoMHEePlq9f7Ss/3Hi5TCh9tLdH91RlSJ1A9BvSDYVF0AJ/dUIx + +XvXrWGgiMrIudpsFfMH6h9McNsXon+WvN3XgGv+3ZyHkjswEgM4q45qF9o/X1Y627a6MpFdiBUgQyTD + uN9+kT9vv9b60OVGJK3Xhj46h1RCsq2DAMa+SpCxZ7CFEZWdnJgEbrtFjbjZV6+rKk2bNrXQOX+uAtRn + JEVAkUVrX8dxS/oYlbyPtv6cp4IGqnxonX0F6XbLG0SyKG7oItL/Fi9Lvv/8ahbS/U35BsYt0ydLRplT + vG2A7yZInRUrHjB6Ksaoc4+Vnk82O2DAyMAu/vQDYf8zOxAsYStxlSH1jBdsadqe9R/qoMQSdL50503G + PKgY+0uVPlAEoztwRHJEwkOqQVL4+MVu8uk9t8h31UrJrxWKyk9lz1Ap/3SvlD1Nfqxwhu0D7tDofotx + I+gdUGQlx6t+MD3JhUUeMPbxgPH2aO7AqGrf9gF4V1UrKpoi/a+rYuYipC/2/9O/8AvFTBi6EP3Q/CGZ + UFKldF2E8MxOOicq8+7wvN+mXudyDESOBUBkq6U+Z9sHEVn0gNbrbE8lBZDJ/NP15utNdUZ7IySMA8fY + lovjCwcdqipzZ19t//Dayo/e9EL6tA6o0JbsN6zevoKEyzZSU/nPi0ife+rHbfz7+7AwP+ULGGnsmu8+ + V9U4auEeG4eriqrgFwoyWlCzUcUySkZl5DnHSg8FxgN1uDjgtXLCX7ZK4oBZ/bqCOE6iQPLZbIVMOyoB + L2rr7X4ZWfJY6fjow3t50g/nye8HR9QSJBqAjYmM+sf4vNazu/Tp3El6tH9Wuj37jHRp20Ze0L/EKWI/ + Y0K58BrudUb6fVW9DjYhiSx660Wzwc2sprydkyqtIISUt1ElMpdQmH3SLqEwW0Wxt9IvCAAsRHhWMSN9 + 26ebjKp6joEVoWy2Z14lpCWNI7L1nVRPglQQwbFjGW9y8IrjxLEA8Fjw95Y3U2XpY2m2TZcDrFwoDjkV + n763gcUoIumzJZfFnnq6cBhsw4U1hmaWeKOngfI0NLaPc7fXUliMZnH+ky4af5Q5QZ5p0TzP5/8UJuUL + GP9XGWf+M4+Zh42zWnI7+IoA781feinvR517nHRr+US2w8X3JzDSeesXzZeMsieaKjj7rpzVfgp7iDnc + f3otz/HylapGbq8yIFBY4TqHAsG4SAY4PXCCINGgSmErRA3EmYIDATWLbNr8ZcITYsPvLG6oNkgZBzO8 + pjCJcV38zktmEyOSYkMvvNK6mOI5DU5iBUYAbMEduvCqhMkC/MIDd2eL03V7vd1CBDiiVpON6evPP5Mv + m9wro8ud6qm4BDsrz7FXft7tabLq2TSTIi2khVAWlaR2D0uVXfY3VgBQBRKy6KzuEJG5db34UpO2CHfR + 544udYy8eW0VafZYE4sKoX5obUj6xJu6GFnqRz0LawytL9940QCO+MTduaVgY6EZXEQ29WOLrApeOgZD + Lytp6j6hT3lJuVeYlC9gJMaLFEcM4JzbY7tdcnBo4Nnk3BUY568SKjE2b5rNK52XszwKSnQenZjV8HrJ + UHGetGEbh8S2LiaQGskWs+Vb7wxd8hi+f23FfOdcPJyIdiAlMSlYickYTRuRjJnYeJmRKNjFQkHtZjLx + OxOqsKWMg01M5lXjRnpahko6JNu1fcgctu+X2pjEn6TI1v4KRGQWOjNVfip3mrR5smWoo4C+4S8gST8j + FNC/hK19+uZr8uXddWXshSfYe1E9UbEnnK7PLhWRGVdGZP5tEVn6aFSWPnGEqpkRWfVUqpWlTaMy99Y0 + L/mDAiEgZBKiPmdUyWNkQLWy8ux9d5uDhdhKJH22XOLhxSyEpF9YqnOQaO+i17pbnWZdq9I3+81zOmfG + vNGpMvcWz5GFlNun3vXmLQfIkbT3t5bpp3wB46axf0p6qaNNmlrRTUGGEBji3EJAxry7GSl2TjTXc1B3 + 56eeNJBhjzATa38CI8+lE+d9/I51Mqrx9BoRSxRh9aaO/rpjX9T6rnkNICfWS1Wj2280tQPJKa85Fw9H + oj0OIJH+MBcgRSINog5iD6bQfr5H8uE6Jw39W/qDtmzeuEEm31TV4xmdoDhISOCAdOZ2jOxRaW3PV97B + UjaJFYheurF6PBwNswRB7iyifsDxS+nYZFENsbfjWBj0Sl8Z+sDt8n210pa2bcL5R5jzAYAGXNg2Z/8r + YNpfLbb3XH+z8BvlV/KEfn7p+dKzXi1p27iR7Ubi8CpsdIALtmQWODYSMI770/xhZonXe9ouFzIDWeYf + 7TsWlb1AEelb+3R9V20PIU26OPyhCwXZllzCGRZk6gzPHQjKMzDSeau//tSkLwJVyQjNYe2hwKjfIX1t + HKYAQ7JPXcWGX3pePFwHNWx/q9IQnbh68SLJuKGyJwWclCozbtC6j4jaPmHzUrv6qxS5Z2oRWdRSGe4E + JNyjpM1jj5rjBY80trTD2SOdF2IsAAfaSN8BlBRsZBT+53t+/zcBoiOAC7CY98PXKgAc4/EMUpjy8Nyb + onZa4Nruqnm8mGoH5uOAZAH9o/Tx0vqRRha6lFviYj4DGvA+CwzzAOkNjcTtmX+jZ3d5o+VjMuCOOjLs + ukoy7Jry8nXV4vJdpXPkW0rFs+XrSufKEJUIB19VVgbVKCdv1a0uzz38gIEhe7VdRiieRwwuDhZ4mPex + 8DGe+3MMaePyrxXQLvDC3ubcGJVdKhHu+EgxIwCOFqLzic7NGrrQqBBl0mLdGqb6Y8bCY84iggTOcw8E + 5Q8Yv/tMVUzPvrjtT1UzEiV/VbDZPSVVFliuPi9uquftdbMZpg+E9EUn0pkzv/xU0ksc4TE6YQs6WIvb + ROXv0SoJqGrN0Qecdb1tZESmVFRm11WLo1xhMvbxHmjDb5IODsGL8CTSXObgD+OxhyzsqLeoq9geicvF + hgco8vtrta+wSQyvYH/F9groJVpEeQ98xCKD9IgtEgkT4LLEG/oMDoRjvzJB1zj/CBnrrsDbtUsXeaFz + J9NkKMQgAoLsPyfQHjBEK0Nl5jk8j+di20TicpI+i8D+nHu0b+PypZJR5Sybd9g95zdMMxtp/JgIAPI9 + FUi+KCKrn08z8wGSL4fkkQeVtoEXLooFDbOwVf5ElGdgpEIrvxpiOyWmlI/I1l8V/cMSniItjlOQ+S0i + ky+OGgP9etHJ0qrZE3slkGCA9idRZ1Zm1MGJr/SQcRWLGiOjerCDY+plETv2c/O3EdkwLOqd6cKKpQP5 + eq3LbeUlJAXV/99mX0xSOAFmLIAAyehffpbvnnxEvq9VSX6pUkz+KHOy/FbqZPml5Enye5mTLJv7GzdU + swUU4EJaZBIjlcEruS2ifoDE1gdAYmLChkvyDTQr7JBERKC1oFICeLwH8w6Fz4Ao8wqJk0Uc6RP7MM+B + b5lrPB/QR1g4EDzM3OOds959xVtczlFwxDehkiMB5yQqBiA5j2Zrf8WUcooVZ3hCVMfb6mZbaAglIuQJ + M8SBmn/5AsbVv46Q9OJHmHqx+uWIl7YqxJFBEoYVPVVaVNUVD9/LCjIHQyymE2F0VAc8yn9+NVx+fOg2 + mVAylvYIgzVAeAHqvkoB2i6+x1bTQdUSQlNgOnYDIEXsbwk3SQef4HPGGbMJDhRABkAivKXfC52kZ4dn + pdszbaVr29bmGEBqQ6JDssFzyj1MYsAur7zCdQ4gAVT4FX4DYAmlAeBQtxEosLXBj64AoHzHbwSUM7cA + Q+zDSK08j+ceKEB0xLsQStAMJ3VsZYBnkuMpCoJlVCB5UgWStyKytltUsioqVsTm3heVzoknJQH4WWhw + uuRloSlMyhcwblwwVzJVNAZAsipHZPso73B6s9PFbHXY7fBWz6wVMbWVnRLtHrw3nocR7xIDfqDEYt6B + PYVVExUH5h3Wr7eMuPFyGXPRCTLugqPkr2JHyphzj7TEtD+XO01evOMms4cSJsAKDGPCrIlUoyT9e8iB + FJMaCY4FFZshkhtSG9IafIztjsLkRVJzQdIAGrxdkEns3g2fAc48B6kL3gOo4WEiB3iHK3zme+oKICPt + AiLcz3Pg/wMJiH5CwqPugPWf3Z+T8RefHNfYMEtg0jLTBM4jBUUcLm3vbxg/+oQQOeYeAH8gpUUoXzbG + 7du2yfRYwlPE4hnXqUr9gweOZF9hLzL/rx+kjS8aseDVoVWLS6tWrWxbDwzkttXlZ0XdF+IdrJYwGQzE + io6KQl0+fOM16f9sa3mpVTPp1ayJdGveVDrooCAFIN26/a4HY8VK0sEjxzMsqExsTDEAJLyLlIaNHEmG + AmjyPTF28Bd8AiDtK29zPwWeoy48E3Bg3oQVfuMarj+YYOgn6sICA4Bj5/xx8ED5sf418nuVYvJL+TPl + p4vOkJ8u1qLCyNeVz5HnHrrXQJGQJ84Vp6+ROHnGgRCi/JQvYKSCi8f/ZecVg/zmQSoRkYXNorL+U8+Z + walxJK/FE5VePFU63VXPbHUYhAljwHbDKnggQYa6w1zUn1UVVQPVg/oAkKTix1vOVi7qiVpEaAOMf6Dz + wCXp0CAHSgAOfIMkxoLOJA+GMCGt8TvXFQYo/luIfqA/cPjQZ8w5pMDB7/SXN3r1lN6dnpfu7Z+Vrs+0 + k86qUeJAwtnE5gI0S7CCfj0YfZovYAQcYI4pn3wkExT1kRwRgwlvIRV8VpWoZJT04qwAzm/LF7VkAy4W + CXsIjHUwbHW8D0anDQAzKggdj+2GVR/vHfYkHC1IBEgBLuGqC21I0v89gm+QVlhYncQGP7gCL/Mdk/dQ + kdQOJaI/HDiyiGDOQmPDqQImIIS4XVXs2+Z7t02RuUf/HmhpEcozMEKAA6CCxDXm++/kp8fukd8vO18m + XHCkt42qaIrFOQKYP5Q7XZ5/4G4zUBP06jJgH8hYpDBioHg/HU5bAHoGDLsn7cIriCSAWsRqxXVcn2T4 + JCWpYOTAEXMW8405BkDiNEIoAQjdriq+Zy5iVzyYAkm+gJEGsjqC5ETPI10NG/CBfNChrbzz2IPy2sP3 + SL8H7pLeWjq28jaru+SXNBpP2cGwF4QRbXGqEuDHoGEfolDHpBSQpCQVHrn5xrxCegT4ED4QSlCz+YsW + B7a4WEuuP1hzL1/ACFFZgAPkRwIE7RF/iaci5g8gxHHBX0RkbHVcgzR2sOwFuRH1CZYkJSlJhU/MLTAE + HAD8EEqCJgkHiAdzHuYbGKksqiWNwSmB2Iv4S0ApEiTHX5K4lLAYbAl4owBFrqXxh4K0mKQkJSlJOVG+ + gRFyqA/Co3oi/qImYzsgbAFJkr+AJuKxs9UdTNE4SUlKUpLySgUCRkcOIJ2dDpDEoUHOQv7yme+Ttrok + JSlJhxPtEzD6CdCjAICuuO+SgJikJCXpcKJCA8YkJSlJSfq3UBIYk5SkJCUpQElgTFKSkpSkACWBMUlJ + SlKSApQExiQlKUlJCtAhAYw7p0+X7WPGxMv+IJ67Z9my2KeCE3U92PQ/W7ZYe/hbENqXfs5vP1LHwu6z + fan//qZge/elnocCrxWE4I/CmGsHkw4aMG789FNZcPPNknXSSaFl7tVXy4r27UM7eMv338vi++6LfQon + 7lv39tvZ3pHbPbnR6l697Dm5MaxrW14pLxOAa+gP+sW1h/b5ifpRwog60X53LyUvdcxLP1I3vgsDauoz + /bzzYp8KTnmtfyLeWNasWcK+CRLtKOjEdnWkT6gz/xcEHPPKaxDjQ7vd+NMvrri+ovCZ+nHtvhJtgx/D + yL3ncKaDAowwin/AmOxOCqAwuP5JwAD4J537LUhcw4A58GBCMiFgBJhnX1cxnsdzeUci4h2u3nlhaurH + tWHMyrPoi1kVKtg1/KUv6CPaEwQi6gdT+olr3f3uGfSfmzRhdcxvP7pJzN8g7Qs4QPmtfxhvuDrkFaDd + +1z/Ugc+0/bcyNXLjR3/F6TtiXiN5/I86sLz3fv8he8objGAZ3ie65uwcYLoS/c8rue6RDzsrgtrm+Pp + w5kOmsTIwDLoMCGdHEYwgRtMJqljVDcojvwThcL/QYbaV3KTi5JopYTcJKLAIDkR7XPXOmblO+rvlwx5 + Tl4mF9f6+9JfZ54RZPIwUClIP9IfXM9YBsn1R17qH6T81h9y9fcTfeuek1t7/O90dXb3JwIUP/F+B8Du + vvy23V+HIK85wAwW+j4RiDlyYxHWDv87g4VnB/vN8WcYj7t2H8500G2MdGBOQAMBolznBtQxhyO3wodN + nsIi9w4YgpKIkKq4jjq6CZKIHOhTXNscWHIv3/E5L0S7uc8Bo/85eZ2YBe1HP5gG73Njl19wKEj9Ia7n + Pj85iYnv6fNExMLr+sBfZzfR3RjlRLzHjYEb3/zyZE685iRFgIrnOrBz78yJgvPIkeMd3kWd+Z3nwsv0 + nZ8vHPGZQnuD5Np9ONMhAYx5YTiuc4Pv/x9yE3N/kQM7GMMxV1CNdURb+N2twMGV1pGfofnr7wP3fX7I + Pc89x9UjTEVPRAXtR3cfkyQoQbh6OJDJKxWk/hD3BPuOzxTqxu+JFhv3TtceV2f3PX9zIgcw8AgE0IQB + R06UH16D/HyUG4WNhVsMKDm9x/Wd42f+d4tNkMdd/x3OdFgAo2M4N+n4388IwYFggGEqGJPv87tiB4nn + wwRMKMeIiSYsq6Vb5WG2RBIKz+R39zz/dcH28V63cieaaO45ri/dBOMe+iIRGPipoP3o7uPd1M8/wcIm + Y16oIPWHuMffdxB1ov94Br/zvCBRZ65jHPjdf51rQ258yju4ztU1rC65EdfnldegMP5JRGFjkdfxoX/8 + 7XH/u+InPvP74UwHFRjdoOY2KG5iuuv438+kbiD43a1sFO4LmwT5IVdH//v4zCSAYGDe4UCDujgmdUwX + nNTumf7V189c7jO/u7ZReG6iSeKe6foI4lrXdxT/xA/WCSpoP/I7xYGL6xsorxMvjPJbf4jr/GMF8Z2r + P20EbIPkHyvXl+45eW0D9aO+jrjHLeZ5oeB7IT4n4jUo7J5E5NrhyI1XXuroB0b3P/Vy7/fzpeOjw5kO + eWB0E9TPHHz2M4IfPNzETDRx8kvu/TADxF8nuVHce93E439Xt7C6Qtzvn0DBz+6ZFCcxufcnIkCU68P6 + knrAuPSLv694dhhDU/LTj1zPvRB15bObvMHJWBDKa/3D+jvIY2H95O4L8pj77NqUE5+657rFjvbzOTj2 + OVF+eQ1y7cvLe9zzHeXEM0FyfcDf4DtZrKinqzdj5PjhcKVDFhjpZCct+Fc0d49jQIhBgHEYqJwABGbl + GjdwuU16N0GoR3BSUviOerj6826+97fH1c1RGDO65zrifxjN38Yw8oMF13Nfbm1yxL2uf917XF3z2488 + w4EIxHcO6LnO3zbazXeu3u5arqH4+yonCqt/GG9wnf/9tIt3OKkegr/4zt9m7qFukHsu9Q4j7nMA5ii3 + e4KUX15zlJ/38Ezq6YjPeelvxpvr3Ji6d7pFyfWp4wGe6/rucKVDEhj57Ca6HxShsHsYlOB1jhhUBsw9 + j2udOpbT5GfQuZZ7XOEZPMtNtrB6870fnNxK6yYrzwgyDc909zlJwz+5/cS73UTmOp7HZ57J5/yQm9Cu + PgXtRz77JybtcM/ie3+9uMfVm/fymWtccZMtLxSsfxhv8Eyu8ZOrA/V0gMR1fgIE3H28h2u4L4zc+NEX + jlxdgs+FeCfXunGj5JfXHOX0niC5dzniPv/nMOL51I0CD7jvgnVy9YRvg+85HOmQAkYY0DEZA+FnNEdh + g8JnP2PwHAbIL4nA1PmZdG7CUw/q5JjCEYwbZEZ3j5/cxHMAwP/+ukPuPuoX1j6ewb28k9+oE5PKXyf3 + 7PwQ/cSzHBNzf3770dU3COR85nuez99g/xUGBesf1nfUNzhJXd3od37jGTzLT9zHNe571wfB69yznDTl + yI2p60/G0L+wUNw4UtznvPKaI9fmRL/7ibb6+4L7gn3jJ8dT1CuM12iTn/ztoBzOdFCBEaIjYSImm2Ma + mCzRRApjfj4zWAwUg8OguAFy3+eXHMMHJ7wj3hNkKpg6jNGCgBYkP3P720dxE5TCc6hPcHJCjlnzSvSv + q5frS/7Pbz/66xskVyf33MKksPqH1QVeCr6bdnCda1/YGLu6u2c5fmCMHTnw4zlBfnX3M37+hcXxgH9x + KQivOXJtzkv/8gz/c1y9/HWHt6iH61uuD/Kba1sYcT2/UfzjcLjRIQGMwQmYEzlG8DMWn91Auv8TMVle + CWbkWWEgBPF86usn3hvGwEwmV7ecwIV73f/+9rjvcyLHrInq64jfXX2o/772o6tvouv4nt/zMnHzQjnV + P8gbDgDD3u1AgTaGketP/72ub7jX/U8dwhZxd78r3JOojwrCa45cm/PSv/AR9XBEP7n68RvFfc5p7F3b + wngZcu3JjWcPZTokgJHCoCTqaD85RmAlduSYHOZhFS8MYvL53xEkN+ncpHD1CmPgsDr7yf3u+oBn8Bnm + zCtzOWZN1H4mAQzrns3/wYlYkH50dU80MV17/ABWEMpL/YP97PokrN9z6y/3u79dfimVv/yWCMwcyORl + DPPLa35ybc7LeLk6+Z9Dv7pxp1CPRIDoyPVNonbxTMYpL/P5UKWDDowMln8VywvBBP7BZQAYzERMuj+I + dzlGcp+pV26TIIwceLhJyDPyCyS8P6eJ6mf8RAxbkH5kHHKaJIVFeak/5OcNrqNPcro+EdH/+9Iu6kBd + 8tOXiYhnuLaHUU7j7idXp30lngG/FkbbDlU66MB4OBMg4gfoQ5moa2FN1INBh3v995UOJ177N1ASGJOU + pCQlKUBJYExSkpKUpAAlgTFJSUpSkgKUBMYkJSlJSQpQEhiTlKQkJSlASWBMUpKSlKRsJPL/BygdsEvv + QNuiAAAAAElFTkSuQmCC + + + + 99, 13 + + + Lizenzbedingungen + + + 121, 13 + + + Akademische Grüße an: + + + 67, 13 + + + Mitwirkende: + + + + iVBORw0KGgoAAAANSUhEUgAAAIoAAAC5CAYAAAD3aadnAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAACXBIWXMAAAsHAAALBwG2cwvAAABcmklE + QVR4Xu3dB5heRfUG8N3N7tIJgYTQO0hTqvSaAKH3ItKRpoIiICAgKIiIIEiX3pUmoCjoX1ERC713aYII + oiA91Mz//Gb3LF+WTbKpJJh5nvN87d773Tvzznvec2bu3KYyuUwuvSiTgTK59KpMBsrk0qsyGSiTS6/K + ZKBMLr0qk4HSUIYNG1Y++OCDau+99161999/v372G/tfLZOB0lmAADAuueSSctlll5U333yz2ltvvVXe + fvvt8u6771bQjC5gcvsEYCPoRuc4H3eZDJQoGgxILr744jLTTDOV9vb2sv7665ef/vSn5aWXXiqvvPJK + ef3118vQoUN7DRi/JTP985//LM8991wFnWMAnu8TNJNC+Z8HiobS8D//+c/LlFNOWZqamspnP/vZMv/8 + 89f3K6+8crnuuuvKv//97woYLDOyhvaZ+f2pp54q+++/fxk4cGCZd955yy9/+cvy8ssvl1dffbUe5513 + 3qnbTQpg+Z8GigbS2E888USZbbbZKjDWXHPN8uCDD5YHHnignHjiiWWeeeap33/uc58rd911V2WY1157 + rbJDY0OnOR7WOe2008qss85a901raWmpru2FF16ox8FSCbqJHSz/80DRqBtvvHFtyDnmmKP89a9/Lfff + f3+59957y3333VfBcfDBB1e2mX766cspp5xSXnzxxfLf//63q6EdQ2MzLmbLLbcszc3NXcc87LDDys9+ + 9rOy0EIL1e8vuuiiut1//vOfSQYs/7NA0ShczlVXXdXVqOedd14FyT333FMNqzzyyCPlscceKzfddFNZ + Z5116nYbbrhhZR0Nne4Iw9x9991l0UUXrduwHXbYofz5z3+ugHO83//+92WBBRYoffr0qXpoUgLL/zRQ + NPASSyxRG3XbbbetwEiQAMLf/va38vTTT5dnnnmmGs1x9NFHV7E7yyyzlGuuuaa6EY199dVXlwEDBtRj + cTlnnnlmPR5mymN6/4c//KEyS2tra7n00ksnGbD8TwJFQ2gQLgCbaOC//OUvXT0fSB5//PHy7LPPViAQ + sv/6179qowLMb3/72/LpT3+67vvd73636o5pp522goQQvv7664djJu8feuihLnb605/+VD71qU9VZvnx + j388SYDlfxYo2GTJJZesjbvvvvt26RIsACQaL4WrBhSp+Aw4//jHP8qjjz5adttttwqWtra2ehwR0s03 + 31zuvPPOqm0SdMlMgMeA7ZZbbqlgmVSY5X8OKCqfNvnVr35VG7l///6VTQCFAYDGBAq6g1BlGg+4aBJi + 1jYSc1NMMUUFCbBwRTQJEABLI+iwktCYee8722Ez+15++eUfAUvmayaG8j8JFGHtRhttVBv4q1/9am3Q + dA90CDejsQAkcyUZ9gIPsNxxxx1l9tlnr8fADDPPPHNZbLHFKjsAC0YBOuwDdG+88UZNtjHH9t3zzz9f + tQ23BTAirmQy2zjPnnI1H0f5nwOKitfLp5pqqsoG//d//1dBAixchIYS+urRjY2UYNF4XEdGNxJpN954 + Y7ngggvK1FNPXWacccbKDtyO/AxXxW2lO2GOATgAIWt74YUX1mMRuXRSgsU2jWD9OMsnAigqMRsyG6O7 + oXGmkY499tjaMGuvvXZlEUB5+OGHK5twK3qzfRobpxEo8iT2BzQAwSCimbPOOqvmWrALNwQoWAMDYRLH + dIw8jwQL1jnkkEPqMdddd92qZwCIm8Jg3c/l4yiTNFASICpSzxVRMNGFBiBEU4zSF6kxMiQ+7rjjurSJ + /egOjZNs0ljyf4THmXc56qijqguiNYCF6xAW+61v377l29/+dmUfrqw7WLwCi3OjWfw3kNj38MMPr2Bx + TY37fZxgmWSBotJUOEDsuuuuZc455ywzzDBDpf5+/fqVxRdfvIaqm266afnyl79cU+p//OMf67iNsFTP + 95noFO2k29EwGtCxs2G8YgFJt4xwhgwZUvezP7DQJNwG0H3+85+v2wCUsZ6eGj3BApTAjMluvfXWOi40 + zTTT1Ojp73//ewWZ3z9ucTtJAiVBIkIwNqNBsASXsN5661X9QGACjvBToxlnkYYX5fjs9YQTTqgDdRqa + 69H7AS+jHQ3jf7zSGUsvvXTd1wjzb37zmwoOQAEQLMbVcF8Eav6vczvjjDOqLuJOgCX1SiNYfM9NEdf2 + W2211epxnVO6w+4AnpBlkgNKgkRDomoNscsuu9RK5T7kLW677bZqN9xwQ/nJT35Sjj/++LL33nuXQYMG + dY0QM+DBQPIf3/zmN2uiLIWkXsxVYQDA+c53vtPlcr7xjW90MQnRKrrRoFiD+S4BybCdJBvWAgbHbmx0 + YPEf/jeTgGyTTTapAHRs7inF7WSg9KJkxX7ta1+rlbnddtvVyuQGNJwGNObCgAdw/K6no/YcJTbfhPuY + brrpukBDnC677LJ1EJA41ZM1nuNgJ9uJTBKI/svxuRYNCQCYAVg+85nPdAHFee6xxx71nLCObYHQdbge + BgD25w4zN2M/rqs72+V+E7JMUkBJkBiJVYkrrLBClzYAkpGZBtVbAYJb+MUvflF7t4G6733ve5WduJRs + IKHuWmutVc4+++yy0047dTX6kUceWcUr0AEnlwIYqSOSGbBB7sOwijCahiFcUwslULg3+z755JN129wP + aLAisOR+/mdCu6BJBigqReUQeCqSy/j1r39dw9vbb7+9R3A0Wg7oqXzJLW5GDsVYC00hUXbOOeeU/fbb + b7gRYMDK9wsvvHAVtHo9sGh0bAIYKVIxAz2TWiMN+I455pi6HxeEVQAjBSoDAMdaaaWVhtsXO8keY0bg + plcmtAuapICicrbYYotaeUJPFd4TKBoN3dMuQtcMP5lsaCMIGBbhmkREjd+n0R377LNPBahwGFC4hAyp + NTqw0BKmEXTfXwTGpdmPFsJC2eB5fZJ9m2+++XD7AZk5LVwd10XET2gXNEkARWVohHQ5RKnK5nZ6Akda + JtPkJYSdWfF0iV4rslhjjTW6bNVVV63fGSyUnjddIKOXxkZbZJFFqo7BZBqOlkmhyTQiN7HUUksNt68R + ZyPPGhwTJcCysTU8NsrwutFMzRRpJchsl65rQpRJBigaQm6EqBTS0hw9gYNpCCxChwCVipayT0EKEBkh + qfhGk8q3P/fyu9/9rg78/eAHP6gjzKKjueeeux4DYJZZZpk68Umj52BeRklAQMesuOKKXY0933zzVaA4 + R1qEm2kEis7gOrFl7pPm/0RejkkXpevijidEmeiBohL1NLkIlbXnnnvWRu4OjrQcjDPfNUNUDUqH5LQC + uReahVuyD2Ck5TGEuDlNgJB0TNtzYeeff35XaE4rmY+S6X9iE2AyL2JfIJPnIYoB0HFsn9omG9urxs+x + n0bzXyInGsk5pVaZUO5nkgCKCllwwQVrb6YNMhRuNG5Aw9IteqSKVcGbbbZZF3hMQ/QdMWzuK9fU/Tgj + swQQUcmAURZVJvjKK6/sioDoDEABBC4IWOyPDbxqaN83Dj7mtfoMcI2RVhqgYDnMZ3yI+0mNM77LRA2U + ZBPRiIY/4IADamM0Nl5a9v6cTKRiJdk0KNfw9a9/vabus9JtIxGXjZiGVQCiuzVuw3zHfXzrW9+qx5Nf + kXbPpBrXAyxcBFA4b+eCDZ0PMGTiLRvaq8/2s4/By+WWW65qJXcDADdGSaDYbjJQoqgAPUy+RK8Vbaik + 7o2Wkc3OO+9cAUCAAoHvNI5h/wRIGtAIVxMoWMq2mAfTdDfHYsAIlPYBFjkcjel/sYDvCNwcCGRAAxgA + xIAHG3SPXLz6LBlnG8fxP0SsaxcxYSXnaTigMWoa32WiBgpxh2o16lZbbVUbMXVEms96drobICE+9WCN + BgCiJY0o60qnbL311jVvQrjaRsVLseuxn99xx7LS6quXlUMErxK2WuiZQYMHV6YyWmz6ADeXINSY9gM+ + bogWAubMpHKbGt6rhmXe0yYamdtpbGifdQ5A4sZch+M5Tx0CUDESIDVmd8d3mWiBkr3r0EMPrQAw+qth + GkHCUD1msA1AYRLfJaA0arKFymZYBEiwge9NkJ5NNBPH0OCtYVOHtYc1spDf2yN6kngza5/A1sMJUwOG + zsG4E8EL1BoaKDQ8UDCuxatr6w4SJa8bkIAFE3FDwMG8BxKAc9xM2I3vMlEDRWWJUORA+ObuIlYjy6y6 + fULyrDtIGq1Re/isl/rOHYAaeLoAwufDjgw7o9NOCDssbK+wDcIWCgOiBI79FgiRbZBQIg5QCWWDkXo/ + Vuk+W667dS/5PbDYD9C4L+zEHC/BN6HYRJlogaJi+WGZUnmPpN9seIzAZ2uYUYGk0TCMY2nIITK10djL + RaP/IOygMGDZIeyYsEvCfhx2UdjFYWeHHR22S9giYY1M03eGGbrEMoaTcueeMAItouf3tiRY7IN9gEKn + Yd5jpREx0vgqEy1QVIScg8o3MakRBBoZu+SYiEG93oCE2Q/ghqy3Xm3gQbH/EWGf1uAN1ha2bBjAJEjO + Cju/8/M5YYeGDQ6bMqxxX24pw9hM1Y9J70/AMKBIa/x+QpWJEigqQE/KJNv3v//96vOzsQlIs9Y0ityC + ntvINiOyjI42M5YSx10j9v9G2PSdDbx62NfDDgzbO2yxsGnCtgw7L+yCsDM7DXAuDAOa74QB3BRhjkN4 + G3T0n5lYa3Q/k2KZaIGCXo3RAIpMpRCV26BLcnKPydGEaYarIzNsY9+v7rtvBclS0aA/CVuys3G5nEvD + uBkA4HaA4Gth/cPoE5rF7wkWhmUAyPbc0rxh5rnQTqYwOL/MogL/pAqWiRYo/LHBMZOUiUM0zm2IKAzY + SUAZsu/NXBQA45pMfQSwgdGYPwy7LGybMO4DALDEuWEA4jM3c2XYj8IWDCN4id1GZmkEDD3z7bD5Bgyo + 52gQ0FQGrPJxjPiOyzJRAkWvkyNYZZVVhkvbczmZ2jZYp7cCQU/gSPO73IMBwhmjAbmHb4YBgwYGjjTg + ACDswi0tHIZ5dgojdlcJmznspDCASpAAks+YCCutHOYcgdIKCIR3ZlK5oAkV0o7LMtECRRgoLS4ri01o + FODQAPQJrdETMLobt4R1lu8cxf1CmMZsZIJkkp3DuBnbdTd5FYD5ahgXZB+CFrvQL8AnjPb93GG5nyUy + MJ/zzbwKFzQZKOOgoGdJJUBxywVGoFFMMzAXhHAlTHsCRnfjcr5+4IFVl+jpej1wJFCYxt4vrDlM484Z + tnXYV8K4nNUGDy4Lds5646YAAyMRwpuFcTnrhPUJo2mw1jbbbVdDd3NzTS1wvhJmOQdFZ5iUykQLFGCQ + Etcjc4BMQxGyOT4zKiNesVDbVFOVWWLfk8M0ciNIGJcjN+L4K4QB0k/DsM+X99679n6Ry1c6pzcuHUa8 + inZ8BjKhsvdzhHE5F19ySU35myRlthv3iVWMAXGro5NXmRjKRAsUolXG9Ytf/GJ1OyY+y9ICSW/yJV0u + pzPXsn8YFqAnugOFuzgxDDvQIrY7LmyjJZcsbzU0KMBcdsUVZdrQOsAie0vHLBpGGAuR/VdGajmyvP32 + 23dNrO4+BXJSKRMlUFQiv24GutsyZDol3tzlRxj2BIzuxuUcfsQR1eUQod3D2u4GLABCd3BPW8Z+x518 + cucZfVg07qabbVYBACAbhrWEARbtwu0ACuaT1redCI2YdotHTzPbJoUy0QNFlEOr8PWouzdsoufeGLpg + xoEDS9/OBkyXQ7QKe5nvAKQRMNyO35aMxr4qwvLuxblZ3gIAWCbrpP2vCvts5+cjDj+83urhvSEGrtN8 + Fe6QqJ2QI7/jokyUQJFs43oAxaRi9/uavNRbbWJofvc99qiNtGMYPYEpsArQ0BbyHd8Py7yJ3xMoAPTp + AMrlwQLdixC9p1n6XJEEnqTbAmHb77rrcPNg3HJB1HKJNJdQ2XVOBspYlEagqGSJq95GOiKka66+ukwd + jTlP7KvxRTWnhg0JmyFMwk1jyonMH7Z5GKELLMkoSwRQrv71rzvP6MOC1brf5tEvzOgygGUSb8kIxw/4 + +tfr7yKiJUJvGZLAlIAsqpuQk6PHtkwSQNltt916PeiH2jfedNO6n5xHpuWFxrOHCXkN9BGvsqwYRzgs + sQYkwAIoxnk+E0J4pz33LNvsvHPZKyKeiy69tPwmWKH7QsNGn4HR/v5rnzBCvDVMFETzrBdmsNCIN51l + ZFxOZVJxPxM9UAjD3rodbGKSc2uEw5hCo2tArkav5264B3mPPcLkSugKrHNw2Olh3JDfAMDEpQFhs4bZ + vymYpGXqqUtTJ4DTAI3WSf1jNDpzMoAp1N4+zIQna8cBvJxKzlWZDJQxLICiIueaa646V9ac0d6M6XAL + uwb7ZANpdD1cxvRTYRpSr9fDJcZsJxsLPHQMwAAXpsFGIplkGaEwJpJbEUURyQkUI8zfCgNK/wkUvl8z + zH+xA8LkVERDcioYclJyPxMlUEQWBtFEF8QsdhnVCLGxIA0wcM45a3JND2eAslvY4mF6u4anJTT6tGFc + w6phXBGwABPTuBkVMWDxGRAYUbxrGB0EFMJiQtZv2Em6H0PlfkeFmbdibi/3g/0a780Z24KVRmTjoky0 + QEHLFsWxHprh+lExCjY57vjja95Ej9ZgGAI4pNqxgEYDFA3vN1MCMAchihU2CTPgl4CxTU+WYLMdpvly + mEHEY8MaAZX/4ztimXh2K6oR5Yx+xvbeHPthJGBzHGyc5rscgBxbwEyUQHGBxkSM7Yh4AGFkEQ+fT8MM + WnfdqitkVxsbWjYWY+RnpiG3DVsx7JEwrsOA4FRhMrQaFhBSpDbu22hAgH0agdHTNgAIKJJwOamJex3T + MDkbX13pRKeeemq9kd2wARA6buPcWmAaG7BMtEBxoW6tMM3ATHeupTtA0kQR7kdum3baGr1o3MaGSp3R + +J3PAIRVgORfYTeG7R4miYZh1gojTIEOENJ1NR4nbWRgwjD+T1hupQIZZtckJzOmWVrb20/m2piYkB3I + BwSjLhKi2bCH+brqcVzMg5kogYIu9Ybdd9+9pu7duqlSewIJUynHfO971e0Id9PtjMowwSFhpgX8POzp + sEfDAIa7kmsxvYAOMUdF9KTBHZ/2SQAASXfzPWBhJdsRwXSMR754iJR8ypgCxbYYwj1GokIj3HuGSSAa + nJwyvsMwji8LzL35j7ERzRMlUFyQXkDEWoHAbDGMkTd1dQcKfbJ954Qm80I0UE/A6Mk0pMjHrHrJsr+F + 3R8GMHeEAdNOTc1lrj6tpb2lTwWVBBpdAjhcClCkCE47JQxTAa4xIeEy0JtLk+M+YwMU7gqbcLXfDRO5 + Of99w4DHTWnctbGlxpvFxrRMtEBReSox78KT5HIHoIQaPZKA8fpQfF518OB6z40ZahquJ1CMyBIss4V9 + LwxIHgy7O+yhMOD5a4DkmGn6lcH9Zi0zTTl1ZS9RjEyvnA2gAYREndfuE6CsUun+Z3coNuZSRkej2IZp + cB1JVOh/MRYWk1zcIgwgrXfr7kfzeHLEOv8nbXTKRAkUF+GiVKLIwCRrPlhPMbXQ/A4VwOUIM013nD8q + TUPTHSMSlSMzYOFuHEMU9Muwx8MA5q6we8IeDma5cYaB5ei5Fyvr95+5LNV3+vKp0EUzTzllmWGKKUp7 + a2tpiUbSUH3b28ucU01VBsQroLjlROLQeiqiuN5OOchG1XkARL2ICC2loT4MP3CFdJlwXHJQpGhyt/wT + VjFnF6ukuPV/jjU6EdFECxQXgi5doOTUySef3DUYpyHMTXHTF1+vd/abbbZ6bw7toHf1BIZRmX1FO27b + IDxFRTK3WOWxMKDhlq7oP3c5ap5Pl61mnqVsOKB/2WTAgLJR2Hr9+5chM81U1g3bMD5vPXBgWTSEpnM2 + UVyyjdtxzo0JN9faU2MlQDQst2uQMddaARJZ4+PDuBznv3yYujFUoDMZvTZqraNZv87+ucoC0PhvwMv/ + HxlgegWUPEhPNr6KCnIRepzEFJeDtrsvy2m6ofto+gdQNC6QaPDuIOit0RfYRbSD1kVAZr25tRTLPBD2 + UOiVH8+5WDl27sXLlgGWDQIsgLJxGNBsGj1603gFmhk6l/ZyD/UVV1xRJzCJ4BpHkF1r96JuNaCci4WW + ZahzMBJAVguTOeZuTMoSvfnNOnQZLXpvn7Spor6svMCFd19VARiTYXoqIwRKAsHOTtgFoS3mfdKXixwf + gMmK8n8qFE0Di+wrGh/RgnxYJWfZj46o7W6onO8HGAOKUvYyucBjdPhLU/ct+826YNl94FxltWjENcMG + hXm/tJHrcEdTdTYscHteoWiHQCe+c0pk9ubGkvX+ox/9qK7OQHsR0SuFEdFGwtPdGCbIcaVGM5lKhtr0 + B7rFdE2i17kPDMAsv/zyNWpSr7RgY86lp/b8CFBslCcKEHqAtLO1R2QV3VOr4fT0pK6RIXFsimM6cff4 + JFhUMhGrd26zzTZdCwwzI7bWTOsfdM99GATELqNKmo3I7ANs6ZKMCmssiTMTqf1nnxC5mK01rC2sT1ie + D7N44Omnn161SbKJm9ddj4bpqd50Pq4Ji8wUxzg8zLmIwFiG5K5r0zDnQ1u5mc1UCkMWOovIyzbO336A + jy1diwHRBaabriYAaZhc2Mc59dSewwHFj9k4Hi+yVtDU8tErtg4zdrFKVMJ0Id78hroSiUmfPV302JTG + 80mwyAsIK2UjsYteahE8c2uPOOKIqgM8NcNiwjOGmAQYuRKVpBdyLWMCGo2jsh2DWKYNuCMjzYYH9OBG + gFhKTCiMSYDaQjhCYgDQKCNjE9/npCdi9fKw7gI9Ix2NTsR6L0Smqdy0ZoQcyO3X/XrVgW2E+f5DJled + ckUjWkb9I0Bxkt8O8bNOgMLAGUSqHObP0djcc81VBWQuFjO+p/XleUE7YLogPl7UQ9VjOZEEfy49Ludi + 8RyhdV3GPACzRJy3pJcGdk16lorM3tmTqWS/2y7rwHuRlRFm0x8JSFMQ0L9pEfTBXnvtVc4999wqKD22 + 33kRsMJ6rJhs0pM28Z1OQawDX45KNza08zAoya3IIAvJTfI2uLlV2JfC7Jc3qiXA8/xdO3DRdFjYYgCi + sNRNPZ1bF1A0Bspx2+Ua4RezIlVYohCynWDfABEqzRjdwZNVxldxfo4P7VxesguwckfS+HoGAOu5GkYe + Ad3LKRC8wkbi1CoFbs/Q2CpM70x6Zt67Xtetx9rOTevoWuMIQdP1eAiDeSYEp8gCgxDdAAKwRoq5SvrK + 3YKijhFFOtkhcmGgnKaQbcC0ieU5NLL/J7Tpj+3CzIsBVil9iThuS9YWgNxoT9/QKVyyXI/9uUZAdo55 + Qz2gjhQoTtKwvp5CTeetDU5WhXE/n2prK3vuvnuN0TVKzirv6eDjuiRYkl3QJMCgcoDVIySx0CiKl2MB + HgISYNzj86UvfakONFp3dspwqdjAXBWClalUI8GfCVPx/H/jyksawqx6t7t+4QtfqEtuJDi4GEwmoZbr + rempzoerdq4ZYbiORqB4r6MCOKEOCOociBMk2sFKC9iLEaYAjSmwPZH7qYh0rO6N1ayxC8Q6COao5x+W + iwEZdHXu6RYzUzxKoGAFAnH1QDNGgWSvfDwF7eAmOhO1tIEeq6eohMz8udishLRxXRyzETAq3/9rCBf6 + 4vPPlueffrA8/WTHAn30jIqwapNGtM6avAyxyCUZyzGglmDAEsBAZ3AlVk2wMpP17QGDW3HfjocZYFZ1 + 4bjWRKGbdCAgVfEAbG6N89MAzrk7SBTfCVX9n3MwsYqOSJBoC26QLuJm3DBPsGJ5v+nUgIT9Fujbtxx4 + 4IFVRHt8neiJbrOqpmmlrkdeB0gAm9vWoTxnYER3Mg4HFBu44HlnnLHG6ISR0dTuC8VAbOYE/EGjaqZX + VAjQjKhSxlVpBIz/A5i/3fv78sqVS5fXfzJ7efXqT5eXbxhSXvrFoPL8teuUZ3+5W7ni5L2q6FVZCwaj + 6JF6LZdqesLS8Z0Vniw9+sPjjixnn/m98qMzT61ZVSIec5humcyhkmkk4MAegInVzIkFkMxTZCdyzt3r + w2fXYIkvLseNZBpftNMY4RCfM4YZIU/xbO4N95liV8cGoIHBLK4z3SAwS/Yx741gJ/PJbNN72eFHKmb9 + ACh6pFWZ0TAX1Ei7nkphzGLgwIE1Owj9Vlrk54gvK0TrbY7RmMgZ32DRAAQuNvz07FOX/57VWt48o638 + 55i28vyBHfbqKW1l2KWtZfuVOpJPRoZ1Bg2gkrla/n+uPn2qj5+9X5/yyMkzlrcu61deunTm8vRFi5fb + L9mh/N9Vp1fBjD24NGKaSOWCsYcOo1dm5tP1A4Hz7KkO8vzdysGtcXWAYXDPqk9my10dBsQ+cx1GiBmQ + mDuT10FbMeDiutwLBSQAkU8E4Q4ZhqVLsC037dwNDTjnPN/G8hHXg76tR+KmK3NWZQElmZzkDjvuWF6K + SlBB3A6avTcY5Rch2hZceMlogNh2kUVqulmPSuHWE0LHRXFMIMRoHasytpS9tl0tGnea8uxureW2Odur + /XXm9vLsHn3KB9fMWDZabb4Ker0zIwKvRJ75J9kpTvti3/Luca3l0Q3ayz/2aSv/PaGtvH52e3njgunK + k5etW2767XWVRYAEgxDWKppu0uEa2XRE157nD1zcnP811/eKsLyRjCAV4nORPhPTzjlB4T2Q0I8iHqAR + smMcuS/sweUmoLUNl8icN12Xa+KOrK0+Imb1BBcNaR6f5kRNTl59gQXKM9H43cutt99bFl58hTJoqaby + 8+P6lNn6t9RcRqp8lccVJe2Oq+JYjgkkmdY/9UcXlGFvP1beuWzq8tQOzeWWge3ljnkDLHO0l3/uG5d6 + 49Llz3/8dWmbYqq6Pd0lAiJmM7s52xzzlFNP/HZ57+fzl8c3bCp/nbG93Dpre7lnifby6olt5Z2LojEH + NdWpDzQLLaLC0/UmSJzfqK4365zw5HIAgi4RxYiqpOEt+6HDemyM86Nd5EtSuzBA0UaugUzAOra1LCo2 + wSBcC1A4T4zPGsd9uoO7exkOKDayg8YVdhJrRkT7h4D9XfiyxvJBHOvAQ79XZuo7ZTl0x6by9h+D2u9t + K5ut3lyfS5Mnx+85kXHJKo4DJHqHCEalyJk4/LCnLi9vXdhU/r5rW23g2+duL3cu0F7+862m8t4ftynO + 4MijvlP3abS55p03fPq3yvP/frWUFy8vr5/YVO7+dGvd/7bZ28vDg9rLexf2Kc+dN29ZY43VS98Z+tXG + pXVcq0bIJ2w06pERFb9pGGl0rhBzi1qwG3EtSpERJ0YN7p100knVxRuiMEGJq6RHMj8CMI5BDqh/a9vR + UlykTp85rwRFWmrJPN8RnXMXUJQ8+Ry1Jcz0nCMDmY0H+PWNt0dlrV02Wam53BWNMuz26Gk3t5VyW1v5 + 8VF9qpZBeag5Y3MnBYhjW/Ic+XQ97kOQdJzfe49dWN46v6k8sXUAZbYAylzBBou3l1d+EEC59+i6zQeB + cnftGWU1skrY6RwdxxhW3v3jxuWfX2mqbqsyUgDlH19uDQA2l/f/dmF5P/Z/8smn6uRvYOE2ZFJdKzZu + pPHspdlT0zQMcOXNZIYHrgmTD/GZvqD3sLPAQaRGb/i+v9Hzzm3NbOM2JdmwkBl08kZErDwOoY3dnVd2 + 2O7nkjay8hGgOEhqFcP4u+++W9dBbrzpnrLjjruUzQdNUa4+OgDy1z6l3NJW3vh9h70bYPnPr9rKPLM2 + 10k6BJSkXOO67Y0nObrFPipetGUZDPkGIV7jsd577Lzy5tlN5eG122oDczsPrBj64oxo5Keu7NyqoziX + 7mXY60+WoVfMUJ7YqqkDaMEody3UXl7+XlNon4Fl2NAXO7fs2D9Xp+QaDCXoXFyujpa0DjQsezDjji21 + bl+5G+7EBHB5HWG7qYwaG+NIiIlO1CeGwDLWjdFRDBrSjxkFmfVmPx3V9skmI0v09aYMBxTFQTQoOt1g + g43KE0+/WK669say4/ZblL22nKZceWRTeeem2C3Y460/fAgSrueDv4T7ie9336Sljk7yj0IvwolvTNpz + /FFRXfdiOxcpHAUSiwBileH3D0F+y77lzbOaykODO5iAPbRmS3nzwinKBy/d2bndiMt7T15a3jy3qTwy + pLXc2gm0+5dvL6+fGu71V0M6t/qw+H+dQiNhF6Jaoksm+KCDDqo6ARMIp6USUjj+8Ic/rNubCSfVLh+y + bpjjEKGYxH6uUbSiHmXNzSMGBAEHljFlwP97WqvciKSiEJiA9X/qvnEMp6fO0ZvSI1Agfq3wveuts0o5 + ZO+Vyg++0lLuDxFX7mku5Y628mYABEjYe38O+1Nbefiy1nL9ia2l3N1WbjqjtczQd5qKbs/L4Td3jIgp + xW0CprfobgSJByn1DBIlzv0ve5bXTmoq9y7T4XYqUNYIoFwAKHd1bjeiEp3kzoPKqz9sKvctG/uKmoJV + HtsgrjlY6t3bD+ncbvjiPLgy2V4NndY4F4RhHWl+0zddh20MDchXyZlIRWAJmoQr09G4DkwlCnUMo9ML + zj9/ZRlmGy6GeY9tazTauThiuhxtmmw+JuUjrkeDoC0n1XeGprJpKPw9tgyUb9lSTjygT3nxhnAxAY43 + schNbeXiI/qUX57QWu66oLVsv25LKXe2lddubCtLLdJcjyFqEtPrPdQ9GsQuOTN8VGDJc0K56W56Boky + rLz9m7XKy8c2lbsW6XAbBO0TW7eUoZcCyj2d242oxP6/HVxe/m5TuTPcze3zdADlmS906JP3nhjedTUW + 58PN5tiSBJ1H3+6www71QQpeTRSXa5LQAxLheIa4RKr6kj31RLF0He7VUXciGdvLq8wen2WI0x0BBtaR + F8EizqNRL2VG2DmOrK5HVj4CFOHeaoFecxrcMuk2BeYkp2xuKhtFVPPeLe3l4B1bymXfaS3rh6B97Iq2 + ctY3+pT+fZvKLhu0lB02bilzzNQhtsyJcDedG60klPjcRDrdkkjvqTifBInHvumRIwZJlPdDyf/iM+Vf + hzTVRmaA8uTn+kRDt5T3n/tt54Y9l2FvPFuG/nTm8sLBsX+ALIXsc/vE/hfF/i/8qXPL3hfXlj258VnI + c4WdFkabYBWhrVDYY+hEK66Tu/EcQ53NBCpRDjOgZ7kvDJtJP+1GH6lbqXi6MHUSbaKe1WWeywjrcARl + OKA4iAhi8QjN8qQysWPQSVg2U4DlhlNay3orNpcDPt9SVvp0c9l1o5YyS//m0tqnqXxxq5by6fmau27+ + Fu6J84V+ZlaZwwn1cg+iIRdBr3QvjSARRbnB20DkyC5w2CuPhhDtW579cnPVF3fM1+l61movb5zVXN59 + 4ITOLXsu7z93Y3nrkgitv9DSIWQDaMDy4qFNcdwQsgGkMS16tWQkkGAHaXYhrrDWchzcFhfTGK0QolyO + lL55sTK2hhtMK8hRX0AxdIBFBB/CYi4fE2Emv6tnDC6aTRZPwPS2dAElG8afzx0awLwNlJhJHScJOAak + 5pk3gBDMMUVbqP2pO3qIHvHdL7aUy49rLasFmMT29sn9XeCSU05ZQz5U2Riy+d/GkueCWjGJuZ+jAony + /jPXR89vKk9uG0I0GroCJXTG/Su0l9fOiKjlZ0tV1hlRefeBH1Yh++hGnaF1AKXmYI4KoFw5axn21gud + W45++dPNN1fXoq5yFShm6oLvhNrYhIB13ToThnBLxtrxu85qqEHHmy/MAyO4J9vSPfJJXJTBTcMARsb7 + hAGgR/VyUY0Mk2DpbfkIUIRRG220UVkm/syYgYtxcswI5dLTN5U1g03aAyQusNFuOa+17Ll5S43tXViC + BKPUuachatEqPz6i2xXyPFwYJnFcQnFUIFHee/CH5Y0QnRnxAModWCEa+6VjQmecF6zy0OmdWw9fhr35 + XEQ1K5fXTmsq9ywVIAkhXIGyYAAlIr2hP52/DHv7pc6tR68498O++c16LcbQ1AczEOm+IJ1BQk2CkyA1 + DgMkdIYHZmIU9aktjPEIh03Icp+xaQQAIjzm3q2awKUZRXb7CfmwaPwuEuOWcrpDo27pTfkIUPRwjQjJ + ZnZL5JgXgSGMQ2yxetDyBW1xcsODZKvBLeXdCI/XWLK5pplVRDKRfU0XNKBoBFZlSMZxP06a//T/eQ6A + lCBBp727mIh4/rxTeeV4GdUASjR0BQpWCXZ4fKv2MvTi5vLmpf3LB6E1hr3zahn26uPBQtdFSL1Xefvq + WSsbPfPFtgqSqk+Cje4N0IiChv567c7/Gf3i/FdaZZV6PfSIBlcnkma+I3bVC/2mg5iEBSSmMpjWsWls + I3xWnyYi2Qe48uHdJi9xZQlAHdwAp/cGFM1K1J7q3ABgY/Ktd3XbTaPQCmgJRVHQJuaY9jh7nNDSoVtm + bm0p1wmBH2gvvz+9I8pZc+nm8o2dWsorv20r7/+1rSz3meY6eyzTytyX+Sw5VUGeAb1S6U7afyUVOnHJ + JK7GtuZQ9PZCyrAPghGWLy8e1lQbuVonUCqrxOs/vhoh/YXR6JdPV4b+bN4y9KqZImyOcw8gvHBgU3l4 + nQBJiNiqTQAsgHLfZ8NtnRr7/Gqdzj8a/aLhLdOl15uiSLvp7SYQmSjmmrFJTiDCJuaQSLzJtpqRxu2Y + XqBe0gzWemwMtlHP6eq9Jli0g4gK86RLywQcvdJb9/MRMWtnvZxbcIGWvJToEdrOMsssZfet+pRHrw6w + 3Nleyj2dqftbImT+U0dOZdAqLXWE0whoimA9xzS8rhHQAIsJP44vjS23QmipHDcwjTZIogx77YmaUX1m + 9+YP3U6DaXz2yLoRxXy1ufzza03l6Z2ayyPrtXa5mrpfA8AqUJYNoJwCKGPOKFjRNdEO3IKe3hgOY5Nr + r722JsmEve4k4E7kVXQ6A4UbhyVARD3WdQEEoFPPDCgABkjMUeEJjCjTj3RKujUuKAOJMQKKhtGzHcCB + uAZIXz60xRIzzFAWChoU1s0zbfjIVVvKPRcHYG7vSMDJzkrGfXfvjoY24UlPMIvcZ+7IBVDsPhsRxSxE + LbDw0Sn2PMhpdECivPfUFeXN85vKI+u39giUagECv1Wb48P36Wq6bz8ugOI6Mm/idgod6IthGs86/5lc + AxRzejJn4rYQekTjA4T3Uv1u9kohLJJ0o7zcivo2L5YGAiTzenP5MPkbK0KYR5NAycfCjDFQ7MgFSPny + ZcuEmjaJJsUsChQRmS8xXb+mcuOpAZbO8R6s8s/r2sr8c354b8u0IX7nX6C5DucL8eyfvlkWErMAhgri + cqS2Rxckcebl3dv2La+e2FTuXbptOH3SZZ0gEc3QLF7r+wBDCtfuYOktUPj7ERWsKX/kek0ywiaWA8ss + rZn60vvyIuoA6xKkAGJbdZ7BBBcuYrIKpRvCpP8ty5F1zTAyYMw333yVmYwkC7ul+2k/ORcEkK6nt3U9 + HFCUBAuB6WCfXWaZuvQlNuBGhLkuwIWIjKafqan8/WcdbueN3wWrhE65+8LQL+u1lK3XaSl3XtRarjq+ + tdKoQS9U6RhuBHdh8iMEm/f8qHh/tMt7b5W3f7FI+VcmyhoaOxucPbJWS7imlvLs7q3lya3byiND2sr9 + y7WXe0L83jF/J2ga9q9AWSaAcvLIgWLWvCgEM+hgjSXdDtPzJS+914AGNHUULoFWwdaSk+qW1mDqnRGs + 9qP1zM7DGD6bjoCZTE91B6VbV7GzYwOhcwJECTzjd93nOI8xUBQ7pwsiao3VQLBsLd+H9iSL+FsnftCu + feogIVZ5PWxYRD8f3Nph3NHzv2grA2fu8Mv2ATjH0Dty1DNNUoouGp3y/vO/K0MvaSlPbd+nskU2dE3h + z2KaQVt57ktN1TUNvTQsopu3zo3PZzaV14MtREovfaep/GPv1hoO3x4AqUAJBnpknfYacg+9YcRAIRJN + xnb+Zry7Gc0MQMEBbeB7d/IJWd0uQuthTisOSK4Z4DP2w3VkEi7NZ1GLY3ApdIeO6jeh78zhrhdddNGq + I6UR5GLIBREUV5NjPyKedPNjMpLcI1CURmErOjGba9a4QBe8UZiL7lo/dcHm8sqNbWXoTR1gYTlw6P2w + AMzOG3boD7RrJjmwqASzudzT67c0Lojv7m155/YDyuunN5X7V+xggQQJV/L4ZgGE45rK279corz/7M8D + VL8v7z15eXn3/uPLO7fuX96+cZPy9vUrRwQ0Z4Atop+D+tQoKcXtYxu1lzfPC6BcP3KNIi+h58pXuAZu + xMy7jOBMijaTjmsQTerxOTqcT+Eg+BvZBCCwkOiIELb2i98zqtHZsDR2XjA0HyYxdwVACGN6RHYXQLgb + TAIkAofRHUkeIVAgzcH4X0PjQjbhm/SwLOD04S74U/e6Ljt/c3nx/zqmGiRQGo3gveyo1i6xKnto4jal + Lj8AOADIPaUAU9EofVRl2NB/l7evmbv869CO8R3g8Hrnp9rLCwdEA18+Q3nvviPLsPd60hEqqsOGvfWv + AM4B5a0LmsI9hSAOsUvDPIxRzho5ozQWlY+F3T/UfTSZ0SYSZdyCzKrbJ2gYzJy5ECDJ/JOoxW/uSAQK + whZIUi+KcghkMsA0A2DNObLaTChMawpOuBtMkiDpLZsoIwUKatJThK+mCJicC6XozD0jBNj0oTH22KRj + 1LgnkLD3Q7888dO2MqBfn0rFkmlUPxVv0FD4Z5aW3uM21rwLDliEiyMr7z16Tnnr/Obyt00b0vbBBA+t + 2lze+c2gMuzVh2OrbhXywYgeqjQswv1d65SCx7dsK7cObC/3ErM1j9I7oGRRfxqJSzBek0DRWQCFi1h9 + 9dXrNWIbN3Z1HzKhVwjYvLdZnQGEZUqJW248t5dTMajIlRnfwSJSHBgkJ3x3HxgcnTJSoDgg9KEqf+iP + uSFzHZwM2jRpZpYQtPcKlcPFvB6CtjtQgOivZ7eWmfoGGA4+uE7m4VdVHO2jJ4mIAEYlSGtnxapIaf+e + yrB3Xw+XslR56eimyiCVUQIot87WVp7atrmU56/q3LKjDHvrufL277coQ3+2TLxuV9657eDywX/u6Py1 + s7z7annnt0NqBHXXwgGUJTPqGfOEG/dtorrroU/cnAU8ro07cs3YVeNjCWzhs0y4dD2Ra+K1EXy6LteN + E0nqVHlz3lJLLTVcCCyZqe0awTG6AMkyQqAojWBBWS7YXBKCCGD4P6OcG2+0Uc3QvhWu5+2bPwQIzULM + 3nxma5lntgiL11yzztXQm1CvMSUXiFoJZTkBN13PHyAykyuBwuX1VN695zsdbLJFx0RqIKmuZ46W8vw3 + pooLeKy89sbQDj5559EA1TJ1rolM7JvndAraC6ct77/wl3q8rvLOv8sbF81Z7lk0OkAnUN759eDOH8es + GBV2PaI87sd7jQ8UtBqRCgh0SLoTt2DYTo7E5CauCICASeRoTA2QTOQS+Zjtpq5yeIQnGJ0QeGRlpEBR + EoVQ6U8htBEwZtpT/fPOO085ZKdwQfd0TGiSW2FnHtynzDZw2uo/jRxT+qnIqf1DDjmkrnGCklHr0ssv + X4/rP+khUURPIfP7L94a+qNvefGI5jrol2Ft1SfzN5X3L1u53HZrnNcCC5fl1xhc/vD9hcsbhzWVe6Lh + 3XpBezy1U3t5NULft66at3zw8oOdR47y1hPlvyfPEMdrLvcuHRrl9Oby0oUDyjuvffR2ld4U12JStEZn + GteyXwBBcwBKhs2+51LkUkSJvsMsOc2gMT1vMjZWkenWAU2DNMqeaXrtNDoh8MjKKIGSxZ9hF4Dx58kw + hBKawxAD+k9brj+htbwXALnpR61lt82mLKuuukq97UCamgtJRS6mR5FCN+l60cCAoGUXmAUwzf/sXj74 + zz3lrSvmKK9lpBOapLIJfRJRz0PLxWX9eZey9sZb1Ip2G8NULVG5c7WV+yXXwuiZWwa0l0fX61NeO6O5 + fPDCTZ1Hj2t94Zry/NebIrRurRrlnXNay4Ph3g7ce8fOLUav6N3uPnQuwmPpd1EfZhC5mLujk+gsEmgE + fa6WwDyOjg4BrEzCSXrSNaJIwYUoSlJN3ZrEZOLS6A78jaz0GihZ/CmTIwAYJ4NdgEWDLzr/NGX3rWcv + W22+ftUiJgmL6zPpYzDQ6DTX5b4cEYILlUe4O3pCb8rbvxpUBebDQwIYDXkTBgAvbtNabjx1zdLcNl0d + eieYVfhibc3lrtjmrvk7tsU+t87aEqw0ZcS3j3QePdjq0e+Wp7drqkCSmX3nnLby+IlWhm4u3/7O9zu3 + 6n057bTTKhBkUqUVMgQGEgJetCfyESmZY2xiOjctKWeuMcYVHmMPGXHgcJO6Y7out/XmFIWczJ6Drdrp + YwFKlmSYDKGBRcNnAumGG66v98tgBJOhJKAyZONahNzYyH0odIiUM8b5S4hkABxReenx35c3L+5Tntun + petOwEag3BWM8tK+U5Y1l5uqVqSex6/TPrMGUG6L7e9OoIS7unuRtvLKSeEub1yrvHvXt8u7959Q3rlx + cHl03ebhgPKPUyNqm6ZDM8m29raoo+UiGtGgNEeu4AgkIhoNDiSSdAZFM6Oq4eVE1InpBjQbF6NDqStL + VgwePLjOxXVrh7pWx9hE0DEu3Y4yxkBREixOSIyebghjcCvYg4sx6zzv0c3bFWzPr6r4pFgPTmoO+1Qw + jCXLibHG8kbg589nDOq4HWPQ8C6H3R321KLt5ZurdgxMus2ST18obGBrczklXMl9DdtXoMT2/zkqorUz + mzryJRe11EzsfcsF28wSQInXN89qK/8NsOyx6eJ1IpFzHlXYnkXjWbxYUjEf5oBRuoNEgpHg5T4yo0r7 + cSVesbHvbSPtD0SM3tMxzWPpPsWUTJgogKI4EfRGT2h8lIcxACZviDbZN7OC2CdzM3pIF0jCLGAjXV1X + fY7Klc7XU7L85Q+/LI8c31xeO65PTbXfFa7j3mCH+8MeC0H7QLzuM6C15hwMzxtuQNmrLNFUbo4GfzAi + IxqmWmdCLXMvAOGmsce3aavzUmr0FFrm7sXayysntpV/n91WTj5kiwoQ80SAxYQj1z2yst9++9VrMxCK + 2ZJJaBXfE/lAgkFcK1BkRhU76GBefRbN6HzAZztmuMP2OqfJTph9XGqTLGMNFMUJZVQkuYMxoBpovPrs + 5P3uAmwLTHlvC7NMOHEnDKQpTDj2vUEv0dK/XxlaTvrqsnWc5pkdQ7BGQ2vg38zdVq6Ys60cMbC1rDB1 + cwWGoXggsWLSauusVl46d77y/NZN5dkvNpXn9ws7oKU8s1uf8kSA4tF128oDK3XMjcUggANElXFqBNVe + Xj4mgBKM8v39N6p6Qy7IYjvAImlGOPZUXPtsc8xRr8MEI0Mepgtk9pnbzUlLXDYAAIQOpn50LiztVcIT + W+h4Ik0AMqFaYs13tlffWc/jSptkGSdAUZJZAMGJoj6GPXwGDm7Kdl6F2UY6VTYtYV0yI8uSSSY+JYCY + bTZYd0j5y5HtpVzQpzwSuuGAvq1lqalayoJ9msriEdHIWEpGAYieK1PZ1NxWzjv5oFJumKOUS6Yo71+3 + YHn7iv7lrYub67RH9yhzY29E9GRg8IGVAyQN4rgCxXzb77aV1y5sK9eduGm9X4eGyFtJnZtR254KIe/a + 3CYqnDVvOEEihwQkOTAo+jMlQdSnwbNzqSev2Do7INZIAHnN7TMDOy5dTpZxBhTFySUQGi2/z5NPoBBq + Ktp4kcaVRHJLiDEkSbhGsCwyWzTmha3l9QPby+em/XBylPVAMJDQke+XY6ADAE9YPMU0EalsFy7qxtAU + H7wZ//5KKW/eV4Y9d31598GTy7v3fqe8fdMO5e2fzlJHkN1nnPNZKlDCxb18bFsAq6385Zwtum715Cby + Ph3zPzRaY3GtGMPvrs9j5LqDhN4g9oGEe8EKObKbzKvzeWW0YHZC9QcYXn32vX2SSbKux1UZp0DpbXEx + eoCZX/IGOU9FNJDJJGM/htEt5W0ZiH6tTWXBOZrL0gM7BhYNKubcFvsQrfZPAxzi0RTCRZqCeaafuay8 + +uDyrRNOKfc88nTnmWQJNnz6mjL04nBPu/fp0C3zfmgvfrMtIi1A2ayLAdx8JbllhBjYzSBrLFxCTlgy + VpPjV24uTyYBEu4mp4QmSHpihGz87HzqMK2nzjiuywQHigtREYSXW0RRswdDomUZSmIvRR8gZM4hgUPw + cjE5LtIIju4GRBJbgId1rDM7l6TW1FOXQRtvUq6++LhSXr41z6y886fdqht6eFDHfT1Y5baIrP7xlWCU + S9rKg+esUCMN4T5RSVzKD9FaroVmyGLWHmAYQcY4CRJ6q1GTpLsZH5HKuCwfC1BQqJFnlccIUGaeqFS2 + WxqksI1/AAPgAA2hm5O2uzNIT2b0lWbBLkBoX+9FHXXubnNL2WHV9vL6Q+d2nNtb/ypDr5m/vHRU5yBj + hM+A8lwnUB4++7MVKELX+pygAAaXkSsTuB0lhxsM0Lk2YzCmPBoIlJ22v8SYMbIRgeR/HijJJgYFVayK + xBAa3rwLn4XGZnJ5ZbKQ1nw1gGYcRCOPikkYFnFPkrvqCNt1w+RVDDz67dowzOT+pHO+0KeUf19ez/GD + 539X3jh/unLfZ1s6wmhA2bcDKE+cs2i58orLu1YxEp1gRm4mgU+3mIiUdxOYpCRfRADLeeSURFELdwMk + dMbEDBJlggKFLxVKWsVJJdIferjZ5ISn3IIhdy6jTkAO+9ZSLeW8/fuU/VfoU+bp01JzJB42DVw9ASQN + 4ziuFLkZYJJuxCRNZJKU1H7eTLXL8k3lxd/s3HmWw8qb1yxf7lu6Y8UlQHlqh/YKlH+dO7D89LILKqPI + WwhXXY8Gl3WWLXW8NKPE1rMlWvP2T+7K8IX95JIwSeY8JlaQKBMMKMkmxjOwiXAWIKS0Ta1UsQbL3NnG + 9fi8R4S9rx/RWsq1beWlIe3l4gEdk7CFz7TLyNyPgTPMwd04pv8BHIxkEM6QPrBwQVhls03X75iO8P6L + 5dUzZit3LdwxUbveZbh5B1CeP2eWcuVPLqisgFEyd+HWB++BIWe1Wa7LXB2uRoQkc9q4ZgkXlbd1phid + mMsEAYpKUBl8MiGJPUQ6BKv7b4XCQmKNz7zHLj9brKW8f3lb+feRbVVYPhi2Vd8OSjd/hVAdEViIXckt + mV5jLNZIE0oDJ/AYoud+bOt4c863QJ0UWd55sLx45NQBkuZy+7ydQNmqAyivnDtN+fklx1UxK12ekYoc + BxeCYegVCwvTIVLuOc4FWNxUJsXotInd3TSWCQYUlcJfaxT5j4xuPL3cd261JDhN3HED1OCwJyJUff+a + tvLktm3lllnby33zt5e/RON9ZqoOfWOYPaOa7oDxHWbicvLeF6O0Qm1MIrchze/Vb5/bbvsORnnpl+Uf + Xwq3M3trDY25nofXbi9vnt9WXj+3rfzi4qMrCLgaQjTdh5wGEACLDpFjXUbHffZ9goSrmRRYpLFMEKCo + FL1JmEgX6O1M44p20D+tAjj0h4Y7pF9zGXq6wbq2eqM4vXA7Vgmw3DxPe1lz2o58Cv0hX2JfbOSVOZ5I + iZkI5K5F4TF9Yr+1PtNUvrJea/nWV4aUP9/405qPqOf6xOnlSQv9zdrBYnUNt5XcshHnEmD53QX71NAW + ADQ+oHAhGAIIgAHTcDG0iFfpd+4JmBIkk1oZ70BJNpE/0EB6uQY1AYde8F3e1I5lcr2Qi4ZEJBJs8vxB + bR1jL9G7a7Y0zCDgPWGHDWgti07ZUmYJjUHzuBPPsUQzbiOx4tPaTX3Kxn2mC+HcXgb1G1AWmnOu0A77 + lQ+e+3X54K07objzTKPEub77l+3KI4M7VoRMoDwQIfQbwSaAcvP5u1TNgTEsa871ZNocWHKsC2Ck2r36 + LLLx+6TGJFkmCFBUpDvp3N0mtyGTChgZEpvMAzi+c1diU2s01OGtZdgVbeVvm7V/OB+2wUxAemSB9nJn + vP54zrZy0IA+ZfcZ+5RBAZxtPtNSvr9Ln/KdrZvLCXvPV2647LByw3XnlPsfubf8942IMDrPrbF88N/7 + y7s3rVteOqa53L1Yx6oG/scIspvYXz21rbxxQbjA87aqSTZuRXhMm7g+AMBKGKMxze410+uTKkiU8Q4U + laNCLdJHD2ANLgcwRC9yJZJiXJHvzEpfcsHm8vZF0TDhergdjdUdKGkAY3oB0LB7Y9un12svJXp/CaCV + n4ZdPU0pv5i9lOuXLh/ctFV599YDynuPXVw+ePG2MuyN58r7j51Whl42Q3n+a03lniWCwcLN5fGN99z1 + qfby3+PbypsXtpX7zl295kOMz3AtGAMYEgTMewyT1vjbpFrGK1BUjIpy/6tUvbsCaQcJM6ziNgQsQ3zm + GA+xechW4XaubisvHNzZaPN+2HC9smhc9xM/PLi9PBFC+J/7tpZ/f6u5rl7tjsI6A//CljL0x1OUt6+d + rbx6cnP52yYd4XDeTppWgbJwAOUHHUB5+Nzl6qCgcFeijXtJoDSWBMakDI7GMt6BgnLdTe/uwEymAYWc + htUOrQmX4zZe1+vTVP4Q4fCwKzuiHTdhaazaiCze52BdlzU0bFcDB7OIWLit1Dh3Lx76ZsX28uj6wTq7 + 0D8t5bl9msp9y7TW7eqxux8r9vP9vw5rK29d3Fb+cc68ddRb8kx2VU6Ei+kOlE9aGe9AERHstNNOdfTU + 2A0wYA6DfFhGip0rAhRJsuPmbS7/CbcxNOyhNTvAYc3XauEC6qoD0fCNRnhq6Grxvn4vSmoAV30Fntze + drFNbvsRgDSY34nqzM5efdl5NY0v7M3Z7pjzk1zGK1D0Mr2tPtsuQIBNAAJQ3DoKKNyP75gR3hvXbinv + /iT0yTltVRe8/L1OOzbs+23lP8E2/9z3Q3t+/7by92CHJ7YMBtomxO/GbeXBiFIsS24+bF2YOICisRuB + BDTAMyJGajTbP/e1AMqlbeXVc6YqP7/0xDrFQBItFyycDJSxKICiEq17YmCuO1DcuyIDK0uLabijR74c + +uTatvJB0Pz7P24t713WWob+JCxeNRQbGkAa+uMw7ztNb6+vIYLfPC9C2bPayisnBNhCW3Abzx/QASir + Ezy4SoeGqezEPXWyS4+uJ8zvT27fXo//2rlTll9efFRNumV2VvjLxX6Sy3gFinBRQsokafcYcy30SWqU + vGfWwnf1xqbmpnLn5/qUO77Rp9wbDPL4cVOUp78/Rflv2Mthr53emfgKtnnrYsDptABUfb2ktbwJKCE6 + 34xQtr6GVRCFVaCJpmL/V08OdjqqLTRK/M+mwUDLhWuLqAlwWCNoKlB26ACK7OzvLtynpufz1k1AkSP5 + pAjXnsp4BQo6lpACFCO3xnWSVTCIUBhQJNlq2BxAuSjE7Jfj9TMzTl02nH1AOXTWmcpDYffNNlN5cOEZ + y8NL9isPL9GvPLF23/LE+tOXZz4/bXlur2nKvw6Yqrx01JTllROnKK//KAAVGgdw3g4QeZbgewEs4Hkj + 2MZv3hOnFTzxKgNsEvWzX4zIZlCAJtgGQLgnwHl0w/aIlGK72P+P5+/WY9JtMlDGsDQCxcBfzgURDkuz + 5yPfrWcLPJiGsJWU23yqacvKMw0ox8zYvzwadk/Y3X0HlLum77Rph7e7Z4htBvQv98/bAahHV5ih/H2j + 6cvfdp623LTf1OWR70wZoXF7B0CShYAnQAM8XrEN1sBCJlQ/+fnQOaFxbpkp3NXqHeM9tr3z3A16TLpN + BsoYFkDhesz8AggrCgFIAsXEIt8TtW6xkJn1G9Ds0rdvWW3AgHJC//7lsbB7RmUzBZCAKQBTATXdgPLw + NAPKuVMPKCvE5wMG9i9/W2jG8tgqAaAtpyvP7zN1eenoAE9oGczzVuigNwM42AYYsAwdROf8LVwTgczt + +f3+c1btSrq587Ex6fZJLeMdKMRsrmNmlhkXAwxcj9s980Yod+5LxmGV05qby9b9+pVBAZRLAgSPdAdF + Lw3AzghbIUC0X7/+5QEACva5M8ADSPcEeB5avF95cr3pyz/Dfb187BQdLitAU/VOJ8sAzYuHdzwS1+9P + n7vwcEk3dz9OBspYFGIWUNz3AgxCYa4FGIAFMHK1Q6xi/VUTjE7s06dsNNNMZUg08k/DHg7rCQijMkA5 + O2ylsAPCHgzr+h0DBXiqGwOcANC9oYMeWbpfeWbb6areqUI4XFR9JYLpmxCzz5wzX7nyip/UpJs5s27V + MBjoej+pZbwDRR7FAi/AYBqjNH66GEDJaQVMUk4u5aTW1rJuNOamYb8LG66BR8MeDTs5DFC+HjbS4yRw + gmkwzj0zx/6hc1746tRVwBLFwm5AeensGcq1l51ZckqkXMonPek2XoGCilGyWV452RiD0CeYhYmCTBFI + sHj/tamnLmuF2/l8NOBtYQ80Nmgv7d4wTHRo2IphowRKN6N3qlAOxnlkqX7luYOmKm/TMuF6Xj57uvKz + S0+q1yXpZr7JJz3pNl6Bkil8aW5JN0Cw2pDn52ETrCJ/4taMvDNwigDU2tFQ64TtFHZTGBcyuqySQDks + bEyA0mXBNA8GYE7qF8J4p2nL0M4Q+7cXH1yXwcqkmzmwn+Sk23gHikSUENnSDskaFoQBENENsHBFJhv5 + bbYppywbB5sAy1phW4YdF/anMKL2vrAeG7SbjTOghD0UdmBEUyv3m7X86ai5y9DLpy+/ueTQ4YDySc/O + jnegZOSjUvP5MoSrydHmyAIKwHBBJi0tPf30FSjYZOuwNcNWCNsk7EdhAMB6atBGsw1gHR42tkCxHzG8 + ev9Zy34brV7OPGyHctmPL+oRKJ/UXMp4BYqSgtZwvAcpJqtYItQN6TV1HwYop7W0lA0j2tkogPKraJhb + wi4N+1bYxmGfDTs+rDdREKDQNvuH9UrMdloC8f5O819PhR0cNmhAuMRgli0/3bEUVuNs/MlAGcui4mQt + uR/3veQDEpgZ8thEtpYd7Pl3AZJdolHuDkP5Ihcm+jk67OdhvRG3XNSdYY61StiBYY7X07aNBhy2uyvs + 1rDrw04K2ypsUNh6YZvOOWc5/8wzK1DcqzNZo4yDku5H+CiM3HzzzbuAwtxvXNP6zc1lyxlnLKsGUACi + e5INGwAMkABR4289GaBobEBZNWzfzu9G5rYA5IKwvcK2DdssDDgADUB2DNsobP2BA8tJRx89mVHGdckw + 2ZiI+27zeYFpljrfL9hknfiegP1J2JhmY9MagbJ62A5hQm2M0dP2zH9ybdhj7zCh9YlhssO/Cfu/MOCR + CDy28yYvI8iWHvukjyBPEKCoPL2NqBUqu2k7hS3z2NXBwSaAInfy17CRNWhvDFAwz65hgLJ92KiAwm4P + AzAMhmGAh2EzrmznMBHZ8UccUUeQAd/AYPdJ1p+0MsGAQtTKqdAqbgbLRfDYotNMUyOdNaIBjgnTKD01 + 4ugYQGh07sJxRwaUdGuAwbXZJkWt3736HmC+GDbY65Ah5ZAddyxXX3ppnRIp6YZV6DGu1jV/kgAzQYCi + qDQVaEzEzHWjrnIrAwIk60ekI2UvskHvIxOdo9IZaRr/t2HCajpjREABgMvCTg+7ISwzwckkzPn4T79z + YdyjhOC6Ae7N5p67/Oioo+oCfNgSWPLm808SWCYoUNAyPy5CIGz1xG2XXrpsEJWu18tVCEdHBATfo/9s + yJG5EUChK4BvREABOp+xxHJhmGLzMPrkyDDs9r0wSTtaBzhWCwOUz4WlXtkgAHP0XntVsLgurMkNcbef + FFc0wYCiqDAuKIXtL3/yk7JxRBDYRFQhFJWz0MgasbHhfWbfCPtymPwK0Iwovd8boKRhHoKVcAXW7cK2 + CQMCoGAGKOmdI8LODxM6Xx22fliC5fCddqqrMImCXJ/80ScFLBMUKIoKwyov/ec/Ze9Bg2pFawi9GLVf + F2Z8B3vQDRgmQUKcHhIm3F05jP44JezmsO6A6Q4ULuOOsJ6AYlv/5RjcjP+x7Y1hv+40/2FbTGY75/Vk + GNAAObAnWHKRHTemf1LA8rEARcXd9POf14oFFBWN8rkgFb5FGHfw/TDASVcDLN7/LEzGFQCk940HCWuN + B2lwDd8IFC5FyPuHMPt3BwoDTPskKFkeB3gAI0GSGkp0Bty7h4mEXItr+maIXKPKudTFJwEsHwtQRAZf + 33DDWrHViNlOAxpUrnGN8wDPPmFXhmWDsQSMRBrdIE0PDAkYvf33YYCSjfiLsGzkRnMswMBkQmOgYb7P + aEgExTWeGSadv0eYsagNw5yja2Dr9etXbf+NNy5/vummLrBIOGJSrlcdTGqA+Vg0yj1/+lPtecZ1hkw/ + fVk7bN2wwVNOWVZvby9rxuuQGWaojYthMAchqYGk8jUeF5Isc3GY/AaXBDQa0IQlQCI4AUVjGj/qDhTH + MKa0XxgdYp/USYBzYdg3wwxSAsWgOOfV4txWnmqqsuoUU5R1+vatY1MbzjxzWSsA4r/WnXPOsu7ss5dv + 7rFHzdxaIyUfFpEiV1Q0KTHMBAOKClEx2OR7X/hCGTzttGX5qPDdoudd8MMflpuvu67ccMkl5fyjjy6H + brVVHU9ZvbW1DO4MnzGNyIiLOitMb2d6Pnegx/8gTGMCDDYCGIwCbFjqijBs1AgS+oPWsR+BzD3RHUQt + F4jZ2Hrc5IwzlkFTT102i3Pbf8iQcuKXvlS+EZpknWWXLeustFLZ78tfLldfcUUd/7nh+uvrgyd32333 + +swdK2GKirCLqI87ypzLpACY8Q4UFZBMojcdf8wxZfmo+EVnm60ss8wyZevPf75su8MO5XPbbVe+fvDB + 5Yqrry4PP/JIeSx8/M/OOKPsueKKZdU+fWoDYRjMgmFEPwQndtHo6Sa4h6+GAYrt0r35fF6YbYhVr9iJ + u5K5NWgooqmfgxlWD6ZYN4CBLYYEUJeO/184wP2DQw8t/46o5u2hQ8tJp55a5l1wwbLqGmuUn4XmysZ+ + 6OGHy8mnnFK22Wabjkf/Blt65J0HjVsA0GpNckkYBmC4pIk97zJegeKi9RaV4F7dFVZYoUwXDLF1MMZl + V11V7n/ggfq0UzPaDzvssPqgIk+7WuhTnyq7BW3f+Mc/lpejB/76ggvKrksvXQYH3W8QjZfs8oUw7gSj + YJZkCW5JAi2TbYDi9dthKU6FynuEOQ63tE6w2wrh8lYKFhsSQNlk7rnLKnPMUWYN9zJ1S8cyYIcecUS9 + ppeDEbYPcPvODfimUChS+dapy5Wq55133rL//vt3PUPRAxckGa1gbWVra8AlYCb2vMt4A0qChIjbZ599 + 6pKhVoScIyp/+QAMUFgL3xOsPPmKL5d78GpBX4+79VycLbbcstwR330Qve77cZx14rv1oiHWi16OJeiK + a8IawUK3+Cw/skcY10E7yKUkC2EQesbQwQZxzE1DU3wlwvXz4r8fvOWWcn24wrXXXbdrmGHtddap10Rr + OG/f7bXXXl2NasHhfOy+Jc89qsWtHPk7N+PaPOELmFzb2muvXQcVJelcu6w1dpkYwTJegOIiuRo9ZrXV + Vivzzz9/2XfffevCvCrG8LyZ+Z6Z5znAKlfFbRmgsJyEIgdhKU5P3DLa/O2jjipHfve7ZY7YbnCwzpDp + pivrEMK0QzQ43QIcQJIaBCAkxnIEebcwGgXbZES1fDDcKvPNV35x5ZXDNc770VgeE5OPzPfcYuzneX8+ + W2rM9tL1Bx10UNdT4nUAdxDmsYTJnq1oRQdsqaMMHDiwbsusR4ttGqMjoMroaGIp4xwoCRJrq6oElWGl + ag9VdH+PJ5Za+M/9MESdiAAlq3iL+ZrYZFt+XCEA87mDOZN/ow02KIftvHPZYeGFK2CwBbEqNOZ26BVA + wTDAQpgSuFzVRWGE6/oBsLWi51tRYfZwEVeFNupeLglxnUB2DY3TI1Jr0CG5XLsngmEGhUsBECyTv4/I + 5pprrjqpKxcrNso+sYFlnAIlQYJiibeeKiUbfNZZZy1bb711fT6eirEfNvnc5z5XHyLtaRV0C7Gnx9k+ + j7F6iMfjg23ODttqkUXKhg26JXUIsGAP7ifHZADExCNR0CbR6HOHJnE8AMAYNEJjsUJ14/82GuA0/uZa + aDHFdXjK6IgAgj0909mDEzy+BRvNGZHUtddeW9eFmxjBMs6A4mL4ViOo3Z8VODLzKLiVIrTklvI41nHl + ssxZ8Sg2D0LKpcOZSt1tt93KV0Morr/eemWRcA9yMusFYLgUYMEsj4fJvfiOewImINk0gLFCRDUmeTue + 5+pwewDZWKw9l65nZEaTmGNDv5x00kldLNTdAAerYo5sfK+eQqrzYBbCtxEsE4tmGadAody5CWLPAxXN + Umcqgh/3m8roqRI9QNqDGNPlqHRCt6dtGV+/2GKLlbbOhyfNIucSIpduGRxAkOLnijAJgGSYLNxdO0A1 + TacbS1tooYWq6AYW+sicGezWuM2IDIgxiMnjjROyGs0DFdRFTw3uO7oNi6ofD41KsGRG9+MGyzgBigtA + u0eF4MQE3EX34kKZIXjhsLCSuOteoVY+EAUpbtm0ZEb3bXqymUIg/vFXvyoHBvusPe20VbfURFnYDsst + VzPBxKvPswaL9XQMOQ/gtJa9177BOj1tN7oGgPTYyIo6VC/cEMA1Pug6V7ye5IECAG7UXmKJJYZ7CtbI + in0IPg+b9sDnxor1+BLZTM/A4c8bfxuRyYIqBOicwRbCZwyydwjj40NUbhBAqqFwnOOIej3rH/uItDyF + tKffR9dETr1tYNthYoL+K1/5StV6oiECWXT1ceqVsQaKE8cmZ5xxRs19jG6xP6r3POEx7cFcXQrRCy++ + uM7B3SwE7zf32qvr6eRfCbd3eOiDI444ovZaS3GMjpYaE/PUrzFpWOclWsrVEuRZ6JWPk1XGCVCo81T5 + nsczJsVxzHgTGvdU6SMybMSfZ8FQGENPPuuss2oiTGQl/CSSjz322LrfnnvuWd3gVltt9ZFjjgtbccUV + u6Kg3hTbeoo6103Yivw8oJILsvxXsgom/jjKWAPFiRNdIhEVBCx7771356+jXwAmQ8buld/diEiPpM9i + 3913372OrQAMkFhCi9YRipoxT1iLctaLaCn3Eak0JsHG1rgOofWoCpGqc3CbnkGY4XS+YlmL9TQufDw6 + 4BuXZayBwm96do1Gk4F1kUy4KXIZk6LxPF94ZFrC/7ldwrZZvMdsBLGkHiYBEpGUysY8sqt0iB6rp+Z+ + tIBxmbnnnrvH/xsdI9JNh+QuGEEKpBYHlCsBgG233bau8JCgYBKUQCMd4LPkZD5tLN3PJAuUpEx0qRL0 + 4sx5qHT6YEwuTuN5qmdjRaYRmlxJI0gUWVz/ve6669bz4Gqk0425qGi9EliEwo5zwAEHdO7ZURyPXvK/ + 7mgcUT6kNyYhl+l6eZaerkNHWC4iMreuOFehsHMg5P0uCdj9JrOPS6eMFVCcsBOXglcRerjCHQg1Xazv + +evLLrtslCFi9+L4enlj5WoAuY6eKktancsS3uZjZ/VGvZse0SMBYY899ug6t+OOO65z7+FLulTXcvrp + p9coBHg0rA4gMuJu00U6Vlrj+QIbW2WVVeoTTGm40047rTKF8Nf/NOoO1yWfZF86q/tDpLirSRIoThzN + qyB6IItGOfzww7tS+X5XwQYHb7jhhtpwIyt6F9WPorPSN9hgg+GEa2PR2/RgIbpJQs4lV20UhudEIcfF + MpJbeV56sBu4RlayQbEjwMttAJ3eriG7GzcjYkn3k/s3gqKnok7lcDA01+Np6wStBOAkDRSVn4ySafgs + fjeCrGc0jovohXqZkVaNdMwxx1RBySSn1lprrbp99k5ZTWAcWQVhHttjFdFCUnb2ROepkWWPNbB8C62S + 54QdzBHJQb2Ps6y//vpVkBsWwJ55HTrDJA0USSKVLdvaU7EdYcsdbLfddiMcaGs0KX2RCY2j946scDF0 + Cxdne5qJy8gVG7EIkOjNKlqFYxA6J594zgBN/oI7GhXjjY+ChTAo7WL238S0Bss4AQoAqGg9lOgaWdFY + erRwVZ5DXgPVyp/svPPOdZ4Kv0x8joqmFZRsfIQrERInm2QKvDH/4HwbWcW+tqu3tg74cApBAsbxRuWS + xrboBMaAZKENkPp/7hO7jgjwH0cZJxqFezHtz0WizdG9GI2YNjqFVpCVNcJ7yCGH1BwJbXLzzTfXoYR8 + lk72QuY/nLPvsRww3XXXXbVRDFpiskbAAJARXxGdMHdsCzfo/+goM91EYCmIgR2jcLM6HwAl4AEbwKUj + Po4y1kDRCCiRzsjKFR2MaQ6lt8XdeMsuu2wVfbvttlt1OQbVzAXJMRLuA+M1jpF49dn3RCahi1kcD8sJ + jeUxGvUL05jE8jrrrFMTivIdNI3rlvORGPPfzOgvd3jKKadUxjzyyCPrfBWTswh6riXBweRd1JkZfY4l + /4MViW75H+yqU3xc+kQZa6BgD70TRUt25cULH/WK8VH0RtEUwSfczB7In4s4THLOSMf5da/cBEsyi95K + A8jDEI7o3vFkeSUR85oaTUP31nraX34FGwIdFwwg/pNuAjJ6BUgytMcmPV3LhCpjBRRFhafPl7MwCSkr + A7sYfBMN8bFjW4TLQmTHFaWYAQc0nvEHJCpXOOy/sAUgpDbpXnznN4zo/LGivAkm4rYABkugf8xBhBO+ + hLhcjgFMbIYdejK/SeUDNMagOzCKKE8iTUQDHAQrt0eXAYjMsfuCpAEwSYLEeY6uax6XZayBosI1iIZx + YS5ST0xhxvQqPQj9EpvGN+zTm8I/q1SUDyAaQOb11FNPrRXN3bgVBEgwQq5R0t3l9FT8xvRU22MXDQNo + 3JEeTU/Ix3ApGpNbMPPNOXEradLy3FCj+V5ESDsJx1071nDOtJTQV+INIJ2/jgboWAQjuo5kkhEBfkKV + cQIUF+KCVDJh64L5ercjNK4CmaABIrkRkY4ci0nIJj2lqWSju8Jd7sU+AEKTEK30iJ6IpukBvV8FN4Jk + dGjadhqiO2AwjCjOsWkYbo2O4Zr0fixGS2hwIGISZCw/+802mAkonC9gYA7HU1cAqUNw3wkQblNnyuv4 + OEGijDVQlASLixOOAgvWUKkaFW0bqEPXPfls33U336NwiTnzZgHKsbgxVK3i9XQMppI1KsE3uiDJko2R + 7igBo9E0HrbklrgEDev6/LcBUUBlGl6UwrxnvsdKBDawCXWNPdFRjgcczl29Of/MILuGj5tFGss4A0pW + cIIFfaqQ9PV6GV9vVJnQNXoLEJii0XxnGoApkEJFeRXslL5c79SjNYIGA8rG+2HGBCSNpREwjuWY2JJr + xTL+S8MCjkb2/1hHo6dxW42fbaM+7MOtiQhpOqGy4yY41N/EBpAs4wQoSiNYGsWhSktxiAFQNjqWlyBC + DRby3ZiCH2fe+44W4M+5GDQPcACiVzquSlfZSdPjuoITNLROsoxr83+AqZFdZ5pzYQCV7/M3bGEfCTbH + kAR0zt3BMS7Pf1yWcQYUJS80e6KKwS4aVM8iNtEvagYaUQy/nb6+0XwHVMAhn4DiMQiA0CKO28gi47sX + 5rX5H8Dxn0xDM40+Isttcp9GUIzPcx6XZZwCJUtWqMrRczSo3pW+XmOnrwccgo4PbzTf0QHpz9F3+nLH + c1zHnxh6Yv7/yGxSL+MFKEpWkIbUi/R8lD0iX8+HN5rvmW34c/SdDAIgGfp+EhphUijjDSiNJRt0ZL6e + D2803/nNNunPu9P25DLhygQBSpZsYKbBG339iMw2k8Hx8ZcJCpTJZdItk4EyufSqTAbK5NKrMhkok0sv + Sin/DxPfB4/w1TD2AAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/AntMe/InfoBox.resx b/AntMe/InfoBox.resx new file mode 100644 index 0000000..ffa5864 --- /dev/null +++ b/AntMe/InfoBox.resx @@ -0,0 +1,2354 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + NoControl + + + + 14 + + + Christoph Hopperdietz, Philipp Endres, Tim Schnelle, Johannes Ferstl, Andy Dunkel, Christian Rudat, Tobias Stephan, Michael Lang, Sebastian Eberle, Christoph Keller + + + 12 + + + + 11, 80 + + + 2 + + + Immo Landwerth + + + 70, 13 + + + Creators: + + + 3 + + + License Agreement + + + panel1 + + + 21, 73 + + + OK + + + label15 + + + 473, 398 + + + 16 + + + Christoph Pohl + + + Top + + + 49, 13 + + + 17 + + + 289, 12 + + + 277, 372 + + + True + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + NoControl + + + 111, 165 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + AntMe! + + + panel2 + + + 162, 32 + + + 63, 13 + + + 46, 13 + + + 10 + + + NoControl + + + True + + + 19 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + CenterParent + + + True + + + panel4 + + + 21, 56 + + + 75, 13 + + + label20 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 94, 13 + + + panel1 + + + 27 + + + panel4 + + + 2 + + + Community Lead: + + + label10 + + + Academic greets to: + + + label21 + + + panel4 + + + NoControl + + + 0 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 18 + + + True + + + NoControl + + + 108, 12 + + + label11 + + + versionLabel + + + 0 + + + Special thanks to: + + + label26 + + + NoControl + + + 88, 13 + + + 12 + + + panel2 + + + Dominik Bösl + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 11, 12 + + + panel4 + + + True + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + NoControl + + + NoControl + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + True + + + label27 + + + 42, 13 + + + 5 + + + StretchImage + + + 4 + + + label6 + + + 6, 13 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 8 + + + label17 + + + linkLabel2 + + + panel1 + + + panel4 + + + 69, 13 + + + 17 + + + panel1 + + + 21, 39 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Credits: + + + 111, 148 + + + 83, 13 + + + System.Windows.Forms.Form, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + panel4 + + + panel4 + + + 88, 13 + + + 108, 29 + + + 153, 188 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + label22 + + + 14 + + + True + + + 174, 66 + + + panel4 + + + panel4 + + + System.Windows.Forms.LinkLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + True + + + 9 + + + label12 + + + Sebastian Loers + + + True + + + 11, 63 + + + 15 + + + Program Manager: + + + 18 + + + label23 + + + panel4 + + + 11, 46 + + + panel1 + + + NoControl + + + 3 + + + NoControl + + + 47, 13 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + label8 + + + label13 + + + True + + + 25 + + + 14 + + + True + + + 11, 97 + + + label9 + + + panel2 + + + label18 + + + 64, 39 + + + 2 + + + 172, 98 + + + True + + + 0, 0 + + + 6 + + + 24 + + + 26 + + + NoControl + + + panel4 + + + panel4 + + + True + + + 98, 13 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + label19 + + + 2 + + + 0, 13 + + + panel2 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 473, 301 + + + Maike Reiner + + + okButton + + + NoControl + + + 73, 22 + + + panel4 + + + panel4 + + + True + + + 11, 296 + + + NoControl + + + 13, 279 + + + 153, 13 + + + 162, 17 + + + 11 + + + 14 + + + label2 + + + 13, 211 + + + panel4 + + + 15 + + + panel4 + + + 80, 13 + + + 0, 0, 0, 0 + + + 92, 13 + + + True + + + 7 + + + 4 + + + 20 + + + 47, 13 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Version + + + panel4 + + + True + + + NoControl + + + NoControl + + + panel2 + + + 6 + + + 3 + + + True + + + 13 + + + Wolfgang Gallo + + + NoControl + + + 386, 266 + + + panel3 + + + 0, 97 + + + 23 + + + 1 + + + 0 + + + Bottom, Right + + + 10 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + pictureBox1 + + + True + + + 42, 13 + + + System.Windows.Forms.LinkLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 1 + + + 473, 97 + + + 11, 131 + + + 0 + + + 12 + + + 7 + + + 21, 22 + + + NoControl + + + 13 + + + 1 + + + panel3 + + + panel4 + + + panel1 + + + Top, Bottom, Left, Right + + + 101, 13 + + + InfoBox + + + 261, 68 + + + panel4 + + + 0 + + + 11, 114 + + + Uwe Baumann + + + NoControl + + + 13 + + + True + + + 261, 68 + + + Stefan Vidal + + + True + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 75, 23 + + + True + + + 5 + + + panel4 + + + Product Manager: + + + panel1 + + + 299, 228 + + + True + + + 94, 13 + + + 5 + + + 16 + + + True + + + True + + + Fill + + + + iVBORw0KGgoAAAANSUhEUgAAAUYAAACwCAYAAABza8dAAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAACXBIWXMAAAsBAAALAQE2cE9bAACsfUlE + QVR4Xu39B5RUVbP/D7/rv5jpHnNOKCYkiAhIEAMKigKKipgQM4qIEkQJCiJIlCBmMSMCCipGzAmQPDMw + 5JxzTpJ87v3VW586vfs5czg9iSF5u9baa6a7T9ih9ndX2rX/f5KkJCUpSUnKRklgTFKSkpSkACWBMUlJ + SlKSApQExiQlKUlJClASGJOUpCQlKUBJYExSkpKUpAAlgTFJSUpSkgKUBMYkJSlJSQpQEhiTlKQkJSlA + SWBMUpKSlKQAJYExSUkqBPp//+//Wfnf//1f+Z//+R8r/O++T9LhRUlgTFKS9oEAva0Z42T9L9/Kul+/ + ldU/fiUrvx8uq3/5TjavXSN///237Nq1S/755x8DyiQdHpQExiQlqQAEIO5ev0YWtnlEJpc+RjLOS5VJ + Z2opmioZ52rRz1l31ZSF4/+SNWvWyJYtW2T37t0mSSYlyEOfksCYpCTlkwC27dMzZfr15STjfA8MJ2qZ + elmazKiWJunnRGTSGQqO/HZ9BcnKzJDFixfLxo0bDRyTkuOhT0lgTFKS8km7Vq2QrGrFDfgmnqoAWCIq + q9pFZMegiOz8JCLrukRkykUKjipBcs0vndrI+PHjZdGiRbJ582ZTq5NS46FNSWD8lxITj+J3BiQdAvtO + /2zdLLPuqO6B4mmqLpePyOZXUmXP5ymy48MU+VvLP1+myIaeCoxnRyS9WKr8eHM1+eqrryQjI0NWrVol + O3bsSPb/IU5JYPyXERNu57LFsm7E57L6m09l1ddDZMXwQbL8s4Gy+q/fZevWrTYxk/au/BN9taxPR7Mf + AooZpaKy+Y2o/POFAuL7Wj7wyo4BKbJLgXL2jVGZoBLl99VKy7vvviu//fabzJ8/3+yN9H2SDl1KAuO/ + iJi4qwf1l8mVippEk47t64RUmXS6p9IxoWe987IsX75cNmzYYAD5n//8JwmOeaSdK5aaowUpcNJZUVnX + PaKSYpE4IMaLguTuYSmyrFmaTFAA/aHyOfJyrxdNapw2bZqsX7/e1OkkHbqUBMZ/CQFuqz583QPAc1Jl + wkmpMrVKROY9GJGp1aOeLexcBctyp8jE336RuXPnytq1aw0ck9JL7kT/Lu76tPXvhFNSZXEjBcWApOgH + xl2fpsia56Iy6YyI/FH6ROn9bFv55JNPTJ1evXq1SexJOnQpCYz/AmLSbhz5s2QUjxr4TTghIvMfisrf + o1Ryma6q3cRUmXO3gqOCJRP7x5YPy8iRI2XOnDkmOTJJk1JjzvSfPbtlxs1VzQOdVS4ifw9IlZ0fh4Ci + A8YhKbLxRV2IdJGaeF5U+j75hAwYMEDGjRsnK1assNjGJBU+wcfY0RmvPdrHu3ThdwU+R1JHS3K29kSU + BMZ/AZmX9IrzTFUef1yqzHsgKrum6MQdV0S2/66TdGIR2fpLVCaXiZp6/WOtijJ06FDzlC5btsyCkJMh + JDnTrvVrVfK+0CTvxbro7P4sBBB9BdDc+laKTL5QwVFV797Nmsh7770no0ePliVLliQdMIVM9OV/9uyR + tcMHydwmt8uMO2rI9Nuvkem38leLfp7/chczY2Dj3blzZ47RAUlgPMyJgV3U4QlPxTshVWbUisrOSYCi + TtA/tPypEuNIlRynpMjc+9Nkwomp8nPVc+Wt11+XH3/80aRGQkhYRZOUmLbOmiaTKxSVSWdFZG1XBUZV + lcMA0ZUdA3RR+iAiWZWiMuGsVOnR9BHp37+//Pnnnxa2s3379iQwFhLRj1smjJKZ9S63ecBChLljYtGI + TCoWkYmnR0xy57esl7rIggULLOieMUgEjklgPIyJAd3450+el/T0VMksFZUt30dkV4ZOzhgourJ7ShFZ + 0U3V6ZMj8tvFp0nfri/I559/LlOmTJF169bJHl1tkxRO9PP60b/KxHOOlPQLIrLptVTZ9YkHgInKjg8V + GD9UYKySJhPPTJEejz0sb7zxhnmmmZjbtm1LAmMhkI3NN5+qNnScAR/RAoDhnJujsuq5qGzomyYL7/UC + 7tPP1t8rFZVRX34u06dPj4dOhdnYk8B4GBNMseiZxwwYcbas6BGRPVN1Yqr67AdFCmC5/iOPaUZecIL0 + ad1KBg0aJBMnTjQGSdq8EhNmhkU9nzX74pSyEdn2jkrkg7RfQwDRyvuqSg9MkS1vRXTCIrWkSvcmjeR1 + ldJ//fVXC9lJAuO+E/23edxIySx5lGdGOjlVpl0elY29I7L781SLDNg9tIjs+SpF5jfwQqe47quObeT3 + 33+P29jDhIIkMB7GxEo3s8G1ukqmyPTrouZk2TFKJ2YAFJEed01Mkc3fRCSjZETGFjtS+jV9WD744AMZ + M2aM2RlZOZMUTrvWrZYpl55l0siMah4oEqsYCooUc74UkY29cL6oGqeSSo8kMBY6/bNtq0y//mLPjKSg + OKtWVP7+WEFxaGx8iBh4zxuLLW9EJaOE8r+OxYfNHjEb+6RJk8wRhr0xOBZJYDyMabcyxtSaZVVajMiS + 9mmye7IyQhAU/cD4rTJG6Yj8ddZR0uexRvLOO++Yd5p9vDhgkhN1b6JPVg3q75krTonI4kZRk0RCAdEV + nZBMzjUdIjJRVbgxFxwlXZ5oYqo0wJhUpfed6LsVb/XyxkUlwelXAIqpsmuw1//ZxuNDBcqBes2VhE+l + yOuNGhrv52TvTQLjYUx/r1gqmRXPsli5tW9HZFe6MkFCYCwim0dEJPPCNAPGXk0eNGcAKsXChQuTzoAE + ZFL5bVebpJFxQVQ2vxaVnR+HBHUHCl7rBQ0jpr6NKF9UOrR+Wt56661kfxcS/WfnDplx06XmaEk/NyKb + +qmkSKRAEBRjZeeQFJl9nS5UKvW/fP8d8tprr8nPP/8s8+bNs91gwaiMJDAexrRh7B+SXvw4ST8/IhuH + 6Wo5SZkgDBi1AJobP/WYaOzZR0qvxvfLm2++mZRgcqGtUyZKeqmjzMs59/Y02YW0mGDyubJLVe1tH0Rk + SoWoSYzDLispHTp0sG2Bo0aNSobrFALtXLtKJlc8w6TFBXertvR5+Fi4Qlzp7Os858xL994mL7/8svzw + ww/xqIwkMP5LiEm17s8fZaJKf5PLRmTrjxHZOUGZIAQUKbszU2R1P0/t+Kv40dJTVenDHRip7//+5z/y + z+5dslsliF07/rZCIK8L5kXi47qCtI17FnVs4Xkzi0ZkfbfUXMN0KLuGFpFVz6bJhNMjtgvprTpXSqdO + neSjjz5KBngXEm2dPV0yi6d5WzO76YL1iUrxOSxYOwanyoxrVZU+PVX63lNf+vXrJ99//73Mnj3bgDHo + mU4C42FKTNp1I3+WicWOkaxLorLt11TZOV6ZIAQUKdgfl3XQCX5SRH4ue6o81+bwVe2o555NG2TVB6/K + rHtqyYzbr/aCeG+vLtNvqyYzGt0iy37+zjyOAD4g5AAyP7Rj2WKZUqWoSRnTq+rCM0j7eKD2Z8jE8xe2 + A869SdVolTLHlThSnnvoXunRo4cZ/DMzMy2GLrklsODEOK798SvJUDWaELXNb+jYDExs3iDrERJ8VkUF + xrNSFBhv+3cBIx1CA5AEcLHDXDA9hf/5Li/bff4NRPtW//GDTCp2tGRenCZbVGLcNUGZIwQU8VTvnpwq + 8x+LmqPms0uLS/v27Q9L5wt1/HvuDLMvYXhPP8uTggm8nkRALwli9fuMMsfJ9G8+N7WV3Q4uXi2vbeS6 + VR/397ZYnpwqS5vEbFghE89fzBv6YapMvUTrcmaqfFnpbHnqqadsIn777bcyc+ZMS1ibDKgvODG/5z/X + zPp3auWI9XfCKAGVIncOKSLrexAdoBK8jme/hvVNlQYYD2tVGiYlY/Lizk/KjFuvkGk3VJRptStLVq2K + klXnEpl6QyWZ17ujBSrTSCZBTtt9/g3EQK5RVXrS2ceYKr3lR5VmEqjSO0ZrGZ8q065Jk4kqxQy4poJ0 + 7NhRPvzww3i4TljIwqFIbH+0EI3iCoiqFmEzXXS/qlM9I7Kmc5pMr6ZtJJuQguNfd9eWcWPHmoE9v3vC + 6d9ZDWoa8Frg/FtRlRhzVtdsEuo1G3p7YTqo0S/ecp0tQm+//bZJ585sEZyISco7scChGbAgzqlNcmDt + e3JhJhgToggWP+jthhl/wZHS/ZEH5JVXXrGdXyRTYYvgYQeMMPLG30Z452qc76XQmnhiTELQwkSHAZkI + WX06G+Pltt3n30AGjNov2BinlEuVrT/rpAwDRjzSk1Jk/YeeBJNxToq8W/sK6dKliwwePNhiuQjwPhxU + O9q8oMV98R0OUy6OysY+EdkzXNuok8NSgH2kKlNlVZmKpsrIaiXki2FDza6H5AggBVWmRLRj8QLJuPAY + 5S9Vi2+N7Y3OCRQpNgmLyFLSjemknVA8Ku0aPSBdu3a1vp4wYULcvvhvXrT3N/2jmuHU6qWtj5c+4sUt + ho6Hlh0fKW8MSZEZV7E1MFV+KH+GtH+qlYVO/fLLLxZTelh6pf/5e7uXRl6Bj90d06pFZXnXiKwfqGVI + mix4NJZSS8FxQpWzZOSIb3Pd7vNvIAZy/WQ8pqdY4OrmL1MtVjEMGNknvaBxxPZSI2l1u+9O6dmzp3z2 + 2WfxLYEsIocyASQbfv3OWxwV9DJLeqEz/3wRk+K0bH9PwfGLFFneQqVGBc7R5U6Rt/v1lREjRpgKi9SY + l3byruX9e3tq9BkqiXaK5Grcd2XX0FSZW897/w8XnyatW7aQvn37ytdff218mczFuO+0fekiyaxczBxi + q9qnaZ+HjwUFaXFDLxUKYtnU36x1eTYz0mEZx0hlVw9515MQFBRn3ZSmKqGuEDrRAYFdGUVkz4wUmfeQ + S6kVkS+fb2v7UbEdYMvB7vhvXJ1p06ZlSySj0jmSrpLguvfD4xixL+4YowuKrphI29+WLyptnmy5l83r + UF9A8D7bkQIskLoQrmobkg9R/2eXw4YenkYxtuTR0uf55/KdB5HFePoNFc1eydEFFiCskod/woWVHTgA + BmhfV9G+VvAeUK2sPPPMM+bkcjtewqSTJOWd4PsNf/0mk84/yswoG3pHE+5bZ8x2DkmVGTV0oVKemaj4 + 8MLd9eWFF16Qjz/+2LJLJZLgD2lghIFmNbzO7Dzp56mE8G1s8ru9wEhDGSmy+StdDc7zmHHQg3ea9489 + wDT63xovRps2L14oGRWLWYD3mjd15UzXiekHRtRoVa83fRlRSVH7SPuxb90a8uyzz1pwtwvVORwm65b0 + MZJe+mhj8JnX6GT4NNzgTvD15td0kVSJ8q/zj5Zuz7SN50EkczmTIDciMUdmiSPN6bLgLl2IiV1MZMPy + FVS2za+qNHsBwJwqr914lYXp8H7/1st/Iz8eKKLvlr7S1eb65IsisrV/quxkt0twPHSRJLZxSeOojD9Z + +V8X1B/KnSZPN28mvXv3li+//FKmTp2aMIHKIQ2Mm8b+qSqTMqiqgPPui8ruLJ0MI7XRvsm/Y3QR2TlB + J0utqEzSSfPJjVdmM3T/W1doGOTvbdtkSs3yyiQKjP3DgZEwnZUvs2KqKn1uVJ6/905bMQcOHBgHi0N9 + stpk6NXeS/p6RlRV27SEHmJL3vC2TpqyEQXGY6RL29bxPIhLly61tuZE9q6XOnnHF6j6taEXIBz+rmDh + ug09dIHWe8edkyZd7rlDunfvngzTKURCs5n9cD0zVWA33MG+9aA0j+agUuSG3qjPnkCQrsD4wm03mhrt + hIKczt85ZIERBl30QitjMoym6z7QlTtTG62TPdvk18LkX/hwRCbqCv9x7armiseuRIzSpk2b/pV2Rvpn + +/q1MvmyEiadrP0wRJUmD2NmqixsGjWH1S9lTpJ2TZvYijl8+HDJyso6LFKO2WR45Fbjg2mXRWXHx4nj + Cfl+81sRySyDxHiMdG79lNmT/DtOcqL/UZV99gM3eu+qlmZHou74SBeckHcFC04AAruxff1y4SnS9onH + zb74zTffmH0xGaaz72QJg6+5yDzMC++OSfOBcTCHiy5SM2sSnoaJLVXev+piadGihdnWMa04jTJRNMYh + C4xkzphavZRJgdOr62QYp9LiX9pw/8SnxJwLSzuoRAQwXn+pTXwOHoIZMbj/W5lx88wsybzoNNuZsVFX + ziAw7hijRfttRk1v0RhWtbi0bdvWsrz89NNPFqoQFtx6qNHuLZtl+k2XmpSwWBfAHPfEDlRV+k32hHuq + dH6BceeKZTK5wqk28RY9FJt4Cd4VLFy7FMfP6REZUf7MeF/79+T+GxfpA0mbJ0+0HS/08ap2qjngeAmM + D6C4rpvy/BkqLercGFH+dHn80ca2LRNpkfFAaGKhSuQIO2SBcdOkMZ7TRSWdJR20AxT8wqRFB4xLnvOA + ceB1VeTFF180iQgbwr/VC8gqt+6PH2Ti2UeZV3rTcJUYA15pdsJs/T5VQULVuzNS5R1dNJ577jl5//33 + 4yn2D4fA7r+XL5Uplc+0fcdrn0/1vJA5AePrUcksrcBYPBwYE7WX75e+/ILZoyYWVS2lSywhbX6AsYlO + SAXwryueIx0O0yD6Q5Xou5Uf9zeTSvr5Udn4UjQ0m85OBcbZN6m0qIvbxOIR6VSvtgXZI72TnDk9PV1W + rlxpvJDIzHZIAiMdsASbkqI9TpeNn0d0kqs6kwgYVZVe8qx2RAwYEZe/+OKLuKr4rwXGMb/LpHOOVakx + lrk7EMeIBLnmHW/lnHBOVLo2rG8xdUOGDDms4he3zp8jmecfYUHTG3tqO4coLyQCxo9VlX5NJcZSAGO4 + Kp0InJDmptetbDYpDrza/p5qKXnwRlv5UPtbgXFhA89rPqRaGXn++eezOX5Q25JUcDKTyoN1zfEy9dKo + /P2Rjo/fKaY8gfNt0+sRFRailhHpu/JnyBNPPGF2dcaCVGP4HrAtgguJeOGQBEZSCk295kJTo1EDd45P + NXuZf9LHSwAYB9SsbMDoT9v/bwXGld8MVUkwTbKuSJPtI7WfxmV3vmCTtX45KVX+vPAEebrZE9k8coeD + NE071+sCAChmlo6oNJjzvliSyG7sk6pSX0T+uuAY6ZQPYNw8YZTn+VY+WtAgD3kXfQUPuaW2wmyhfDu4 + +sU2GcmSfjgtQocybZ8704Lu49ECQZOK/s93K1opz+sYIPm/eNO10qZNG9vpQnia80QzFon4ADokgXGT + TgTCJcafoGr0U6kGfP4Jn604YCRBwv8hYEQFWPreK9bm6ToZd4z1bIr+vuE4g3n3pVmM5zeVihmDkIfO + vxXqULd52QIw9EOV4lK8ZBnva1tz2BeLNLm2W1QmFYtagtjOT7fKk42R95iWUixFJp4VkXU90mR3gvi4 + sLJjYIpsJ4bxMi+Dy1s3XGUe6U8//TTukT7UnVyHMjE+q4hpPjfVzEJrn1NcCI4PUvtQ5fm6qiEpMI4q + fZy0erRxPArjr7/+Mh4goDs3vj/kgJEOWPbmi6bOcD7JxsGqOuWQZ9DZGJd1/L8FjAzsgk5P2uo5WxkB + NTqbc0olbBwvM2tHTPL+qEa5eE7Aw8nmxQKwoFNLA5sZOOEGqfbgnwz+AjB+osDYKU0mnRmR38qeLM+3 + a2PA6D+2NIws8Wm9K8w+OC2WDTovmXRcseNS+0fNG86pgL0b1Ps/wYcHiuCDhZ1amBrNVtBt76nmEDjX + G21h23v87sU0D76shNkWX3rpJdt5NG3aNNOS8rLp45ADRib8nMfusMk87eo0+fsv7YCAJJStxIBx6XOe + 5/X/CjDiaZ/Xrom1ed69UdmVnprtvBf+3/5bqmRV0gVGmeSVm2pI586dLeLfv2f3UCfaOe2Wy2xP/Pz6 + ugDgePFNhmwFVUp/XxZzgHxbsZh07NA+1zhGJsmG33/wtgDqe5Y0jsiefHijKUzKTa9yrkhUxp8dke4P + NDCzhdsK+G+OjjgQ9I+qvjPuqG5mitk3pIUG+OONXttVx54cCjoGvepdb8IAC+Mff/xh6fXyul/+kAPG + nevWSFa1Enb+8fzHtANyUqMpMVV6cTtVGf8PASOMMvP+G63Ni55UYPT3k/bJzrFFbKcQHmmClXveXc9y + Ag4bNkwmT54sa9euPSxUu7+XLpLJl3jhM0sfVfUpN2DEAXK35wAZccmZ0um5Dnbo19ixYxM6QADG+W0e + 8Zx956SajZJdLHkGRpNUdVKyOBeNyPjiR0r7x5vYtksXT3s4hEUdyrTNzvU+zcZ1SdNw+69FBTRVHNBr + RpU8Vp5t9ICZM4hbdHbevCbwOKSAkQqv/+U7SwjBTo3VryYO6o4XB4xP/d8Cxj0A4711TJUmnCkIjJgf + CPpGpRynE7XDow9Lnz59DisJBn5Y9/0XKskp4Gg71nbSCZGL3Y8kDvPqKy+oxPjhtRVtSx72JaRkQjTC + pOT/7NktU68uYUHdM2tEbX9tXrYAxksMkJc/EVEAj8iYEkdLh5Ytcj1XJEl5I/hg5YA3bOHCvLahp+KC + SofZFi7siypFziVMR4HxuwpFs+XBnDFjRo5xi0E6pIARxpn35AMm4WSWTJWt36bu5WndqzhgfPr/FjDu + UMl6yvWXyCQCXVWFy3bIPn2iC8ryHmk2Uf+48ATp0KKZeeb851wc6hIME2Jx7+dkUtEUmVwmKlv6kxNR + 2+cHJV9Btdqhkt7Ma72zVl67+Zp4eBKxa2FJJHjHxtG/2l5y+mrp42kKconDgUJLDBgXcPiVSrbDq55n + ySMIJs7pJLok5Y3MzozZiMS0FTwb846AfZGwqu3vp8qUcggDqTL4itLxnAAFyYN5SAEj27GmXlPa7Emz + btRJMEk7IQiEweKAseX/LWDcvnSxTL7sfMuss4EtUOx6ccCoBQlyUQsv69C3lxST9m3bxI8ygEnCJiqf + g+Vg0n9275IZd9Qw1YjtXUhyOcUV7hhQxJwz06+Kmuey/03V9zIfBHmBNi58rplKIyletpaXIjmCb6Ky + kzNFrtP+VqmTRMAE0qPC4wlNJo/YN/pn5w6ZXucS0wLm3aJaQ9CcgilDF8R1XXC6eFm6X61bPds5O86M + ktcxOKSAceuMKV4cmU7mZSQKmKwrt2+yJyoGjM2VKRUY/68EeG+ZN0syLz7VJvPGT2K5GP3ASKjOA95i + MbjaRTZRnRMC7yweaSTGPX9vl+3zZ8tWfd7mOTNk08ypsnWll1gC6Yq+47qDMam3ZE2SjFLHmBSGQyRR + 4ghXDBg/VmAki7cC40t33iS9evXKcRfU7s0bZWqN0jJBJ92MqxUUB3vSR9jzE5UdH+p7B0ZkxpVpJt2+ + eeNV8RhG9uQ621aSCkZ/L1vsxS/qArmsORK99rtfoo9J7Avv8yT2cRccIc80bmQ4QM7RgtjUDxlgZOKt + /XaYZwBn5R6qEkKCVP3ZChLjFJ8qff2l/3qJkb7aOHmCmRxIr7XpK1WlMTk4YBxZxCTIefccEQdGdmFw + lAESzMKsTFk+fLAsaN/U8g5OqVJMMsp7ZXLlM2VKjQtl3sdvW+wdKjeTGnvkgQRH3rVqyLueXQmpuLuC + f9CuFCjZgTFFetx3Z9yu6mxMfvOB8dxXQywYHFvt0kcTgK++EzUdScVAM1CHHRSVVGfU8CTVPgrILqvO + gXJ00RbURNoHv1N4J4X/GT+3wFEOF7IxGvG5F794dkTWvxjbBujvfx13wqumXa79rwvTVxWLydNPP232 + xe+++65A5+wcMsDIoC7q3d7CdLKqRmT7KFWbcgrTcSUAjJ9Uvzi+UvybgXHDlEkW60myhM3fRWTX2AAw + ZqbInJjESMLWNxvdLZ+1aynjGlwvGZecZvvQCZpGOrcMJMUjkllCGUslJ3YMZFxaTLLSJ5l9DEcN4JhX + +0xhEO+a3+pBMxVkXaL88AFqtLbRNyGCJQ6MV3nA+OJ9d1gMG5Nj1qxZe2Va4h1zm97lLTAKjpte1n4M + ce4YGCowYn8k3+JeEqUCJarcnFqppkp30/ciqbLDyMXO7Q8edGC4VRdJnBOLXnxW5jRvqOUema1/Zz3e + QOb37ijLRgw3YHAnJlKXwwUcqefCLk/Z4phVIcYH/jAd6/sisumliG0fZiF9I5al26UfdKdg5od/Dxlg + 3JqRKVmVi+skVQa7LVV2qsTDIU57AWGwxIBxyTMRb4dH1fOle7duh11YSn4IZlnz63e2OmZdnibb/oxY + XspsfTJZJaDn02TcUbF8dDr5KUg0HhhGJOOCiMy+KSLLO5OEIlU2/xCVWfUiBo4TLj5JRnw+zLy5BIOz + S+ZAerF3b9sqWVecKxNPVX64NS3HxBGuGDAOVGDUPqFvAEZ3GlxYyMyOlcsls+yJZruaVStNdhIbp2px + 8LlIkUsfj8rolIiqcrFQEV9dduj/2D9nXad9p8DIe0lYsD8zpMMDWzPGyfwW90pmyaMskgPwQN10BXNC + /Dykh26RhdOyTAvAQ46ZpLDrtD+IOk6vd7m1Z04dXbjQGgL7oxmPFa10/p+mRbXNzrEs3ZgyCnrOziEB + jDbRB3wkmWceLRNOVJB7WlUaBbuE+6P9xUAgRVb21E45JVV+vfhU6fl8x3ynsz+cCGZZQK5K7GLX6mQe + u3e/sAtm+++pMvMWlQKL6UpajMQKqTL18ojMuSsqy7up9PO1Mtokb8vlrklF5J/pRWTjF3rtORH5q9SJ + 8v4br5m0hdSD5H0g+3HjmD9Mqp1wakRWPKVglIsaTSGBwJZ3IzK5HMCYKr3vvzOhJx6eW/3ZRwYaAOPK + tmmhKazY/bKVZ5aJyvhjUmRRIwXpIDACph9FVJXzALmXvhc1LqdziwtK1Pt/VOJb9lInybjoOFMxqT82 + Us5Nnn+7gneTiCx5JCLTSel/uueltb68+TKZMmG82ZiRnhnPA6kFFITIvzjlivPNAbfk4ZAAfwVJgHHR + vREDz18uOkXaNn1sryzd+ZXYDxlgXP3d5942QGXodR/qRMgtftEVvQZ72tp3vHvHljhK+rR5Kr7DI1Hs + 2uFK9BWSzuTKRU1Nnn1LRHYGHC+uX3aMUQlqfKps/Cwq6wdHZMu3qfL3qFTZlaFgmFlEdo7Ta5xUbten + yLafU2TKRREZdf4J0rtLZwt1wYFwIPuRNi545jFTi5BqyZYT3P4VVnYNUhB7WxcArT9gEAaMDgj4O/uh + myzJr7fFLERVN2mkiB2uNeFkJBKdnNghA8BIUostyn+Ty+qiwnbAHAB5X4h+2TZ9ssy+/wbPFKL9g210 + WtWorHwmTdV9r25WVMpFAgbw08/HW+uB4+9P3G/zAvWSeqFN8dxDlTapVJxx4Yl2hg9bPW2B9I0RajXJ + O2bVitr4DLriwr1yjhYkJ8AhAYxUev5zzU3Nm1LJUw3ZuZFtoicqOqFJSbZhqKqMygCoDr1aNLVQCf85 + G/8GsomRNck7bL54qow/OiKLkaZU4tsLGGN9w1EQuyZ6zhjyMxoQcm3I9TtV8tz2Y4pMvihVRp53vLzw + 7DPZ+vFApc0iSfG02hWM0WdUj3mK/XalBAXw3P6OAntZb5Hs/cBdBlBh5wdvmzFFMsqeYMAy/7YY2AWe + R0orO0wpdvQmUsvyx3RRCQPG/lHtN5XOFRh7PdQw4XsLSoz9uq+GyGTswyrlIh0BFotVMvx7sNYJIATY + qRflPeqvWsDXRWRdV62XagHUbfxFJ8pXHw+wxY4xzUtChYNFtHn1159qvb2tlpt0gbQdSb4xsv3sH8aO + zNUxeqvWZYWSc/SQAMZdmzZI1uXnqASUInPvZ3ubSjZhEz1B2amSEfkIJ1+cJhk6+H2bPGSGV4Jr9zVZ + AvfB1DAPxXn3KHxf0Ofmlzglb/krXWXyhcdKJmrRcSnKLKoOf6f9pYAX1i/x4oAwlz4FODd+oQtMiYiM + PP9Y6dSubb7OSyks2jo1QzLLnmSTP+4pzsNOFHOK6HXTKnsSUiLJjTFb2qejd+Sugu/qDipFh8XGfeKl + MDP7rEpnBoxNQ4ARFf5NBUaOUzjvaOnctLHtenESy77ueqG+a4a8K5kljvBU4pMU/MtFFfBS7Sxti7v0 + 1SdeYiD5z1cpsqSR53nn/uEP3raXieRA8XF+iD5bRIC/CkxTq+gCMCA1NHEETrN01Swm6jj1ua1OaM7R + /LbvkADGHWtXeQOuA7dKGTHPanSseMkTIjKVlE9npMhbd9W1A7X9R1bmt2O4ftu0TFk18C1Z8cGrluJr + ybv9ZPHbfWTFT9+YFMBqi3q5v0NZAMWFbR6JqU8pCooqWVdJk/WDVFoksDukTwpSdk0oIusHYpNUVbrE + wQFG+nGl9rk5ilTK2UB4RkB9SlRs5wuB1jV0kuhkcsCI5OYHRjLpzLy9ul2TVSEq2z9QqXRQuNNlySNR + 2xFjtrwzIrLq2Vh9HBDpXybnltdUlS4ZO4DriSamyuV0oHteif5YBoirlMg+7vEnpcrs2mlW5zzt0NHf + LSWaSpCYSFD1f690lnykmgCp2Ig6yGtihQNNxNhOv/VK0xxm19Yx+kQFpoDmwFisbsvYaN+cnyZd7m+Q + LXa1oFEpBx0YGfhFXZ6yiZCpjLX1G10VQpwJORZVF7GXzcQrqKv6sGsr5OiNzImozx6VYBc938JULYuf + 0mdyxIKtuCo5pJc8UqY2v1cWL1xoHQ9A7q8QCAztC55uZKDIyokzYkHzqPw9VtWKTJ0Y+VhAciuYJDZ9 + pmpL8aiMLH5wgBEAmd+uiUl8Uy5R0FI1KS/2RYp5pdn5crW3JTBMlYYP/l4wRzLKHGfjufD+IxQAdcIF + n6VgAshOq6bP0vE37+75UdnQl22JPkDSv6h3G/rq7wpeZA0HGN3C7LaiFYQ3DBT7dfYWREBReXDubQrM + Q1Ep8wCKruh1gPzC+xTktc2TLkiTD55uFj+ky6XiOtRo+8J5knHR8V6Av0q8e5k76HuV9DkUi2tGlT5W + 2jVvli15R0EPwzvowPgfHZBp119sAzbrZmW6icqkefFGBwpS5vwHtIOUeX6rcJr0efHFAh2ItWvVCtt+ + ZMxI+IOu0FMqR2VuwzSZeYNn1AfE+X3cq70scBjHBOCYk+TI9xQmPgNF4X+K+y1IfMexoQaK+l7AYmW/ + iOyZVoDFIw+FgHp20TAJR5Y4zoCR/I3OVnMggHHP1i3KD+UMjObVBwT2Bq1EJXscY6q8+GCDvSRGxmh5 + /95eeEuxiKzvoSBD7GIAZPhufY80s+NlFEvxgBE71yvKo6o6x681YCwi63rqtXjzzz9Kuikwuu2XLoYu + bHxzIq5fM/jtuKTIgrgIM5OCg9nV8gqKsWLt6an8e7ZKjcq/Hzeoa+Es7tD5/GyXOxBEXTb+9ZsnmJwZ + kXVdwiMTcLzMJGu6SpXDq5wr7dq1kzfffHOfz0w/6MC4ffY0ySx3sgHa0o5sA9QGh0za3CQj9gYvfV5X + RAUyPNOvtHnSsicTspPX83zpwHmP1DMgIvQHj+jyriqdjdLVKlNV/GkpsuJF7Fcec/1yT13LngL48o5g + rBT/79m43g72WvvT17Lm529ktf5d+cOXsvL74bJuyiSTJgAc6hcE1r/nzpDJZY71ArFPUzXu5Yj8MzPW + 5kKUFK387i0ua15VJlPVcXSpY6XzM+0OuMS4KX2sF0KjwLiy1d72vJyKX2JEun7tzrqmOfhtjLu2bLb4 + SBaZqZV0bAcEAoZjhdCdBXeotAgfsEiqpkBiky2ve9Jk/FqAUSfsuhf0nQqiv114krzQquU+JZDg2nXD + B3k2xZikuPhBBYYvdEHM53ZFV3ZwHEQsxhNH0tDaVa2Ov/32W1yqLYhktb+IPlgx9AObZ5MvSrNog+CR + FjjHtg+ImdCKpshrda7M5nhxPJufvnd0UIGRCps9CWmIw82H6OodtJkBACpBEtdoTgadwNl+jxXSbK0b + rB2kz5mkQNL/oQZ2+A15+JxHNacO4jcM3Cad6aQij+Gmz5HOPDUdOyaq5u6pKtnW83aU/HpFCRk04EOz + 1SAZsDrBXDzr7/mzZVHnJ+0oTnaVGLjpJJtwgj5fVzcmf2aJNJnWtIEsmZxhKjn3A5BOmlzy4rO2YnLP + olZpsmeW1qMA0nSeCsA4NUXmEg+mi8uv5U6R59s/a8DoEiHsb680/bb0lS7WZlKNbVT1lBCcPAOjeZFT + ZFYNbwzfu7lGNrWKQOtVwwbYGKOhLLpH+S0EeHHibOXQ/tLeAji+eFTGnRNNCIyA95p2CuYKON+VP0s6 + qqTtP04hP84/rlv3+UDjDfph/AmR+PkmYdsR81y0b3YP885KYdH5vPrF8S1zbldQXrWqA0Hw/6KurW0c + LXP7YF3AAm3CC2/hWRcTp5sq3RvUky5duhTKYW8HFRhRo+0gdR0otgH+PVJXRAUh/4S18JLRqbK8S5ps + GKSrBuAYIi3x/bZfI2aXQqx+964bbUV0mXtzW7X3bN4o02uX92LDyAXZPyp7FCiyAbG+F4Be2h5gjMiP + lc6W1/r2ied7w1bDQKwe1F+mVClq4EcIAUCD/XTG9RGZe2eKSizYrRTAddBNGql+oUxNn2STiMmL5Ll7 + x9+WI5D7s6pEZbtKrZaCrbAlxdjz9kxXdXCg1ussj8mGXl5KOnbsaPurXZLX/R3HyIJAlmZWf2LzCJrO + izfaX1xOPnhgyHWVsu1AYXxmN7pZ25ei6mlUgVfV4sC+WwM6lRZXP6MLRGwB+6hqCfnz/GMsZf62/sQ7 + Zr8eO9fa9mgSqTKiXNFskrYzQeQFGLlmg2oV7GRJBxRPVH651TMnGBgXFBQpMQAnZyR9M7TaRfFti4kS + bBxMAqRn3HaV2Q4Jp7KogUD7LRrgDZIxK8/qvO1y3112dHJhJJA5qMD496L5nhFcJSLsg6ZG+yUigAgV + +dmojPn/IpJ1qQeeYVsFvcPlU2RGTU8NHnJ9FXn11Vf38kgmog2/jVCQ0smgdZmndUFS9B8VYEXrQ9Ya + EugCWN9VPkd6dHnBkgWgsq+YM0vmt344rnoRUjOlYtRMBFtGKLBN0PbgcR+TKit6R1VVVwmXyafXj2x8 + p9l7UGsAxzW/f+9JNpgYtP17gfS+FgBRn4cU/o9Kous/icrksp40ARi8VO/6A37K3c4VS2VyxdNMmltw + TyyLim8i5FpiIDW/oS5c2q/fVj1fevXsGZ/8y8aNlszyJ9tkIyDYACdEjd6lktUcBSTChX4tc6K0u/0m + GXv2EZJFjK0dxrW3jZHkBuwY+r7cmQWO/9y5ZKFMqewtqHif59zCVkhCVPR9+wKKFIARwI95cAFGUrL5 + cwocSg4YtoROqXqWjZWFbAWBUf9nUdv8Uor11+jzj5KOTR+N741nISyo4wU6aMDI6rji3X6mLgBkq1/d + e7cLALj9z1SZUl6BSK/Bzrb2PV09/ElZ3bUKYnxvDhhlKiZFH10R85KxmrqsIZBUVXo6efPwVNkd8g4+ + 75xISAsqFvakk6V7h/aWIXrsgLdl8jVlDMyQBFG1FzRWCQP7ZJbe53aZaD35+88MVf0/RjrTZ+HkUSnh + m34vGjhil5r/sqqUCq6A9eavkBa992erzz4UpE/AdtuvqbKkjTepHUhzFq87atW/+u7PicMYrP5M1dxz + dbHQ/lj7Ak6R7DalXAuTX8GU9PaA2g+Vi0nPrl1t8nNS35xXu5vNjm1yq9orv4Wo0bsGqXr2DodaedsK + B1xRRlo8/JBMLBY1yX3bB4FTCvV+ywWowIjzxQGjM+PkVdL+X53Acx+9zVsMlddn1kyz8BSzqwXqWKBC + 3yi4rGhN+1PlkyvLHPAMQPmhrTOzJPOiE83xsua5EF6gPZ9g29X2nJVqR+U+3/zxQsuaftCAESSfXreK + TYIpFXQl/k0Z7i9tvJu82LwUKFe/hjNAJyyeOQU8pK/Qc2AUNJAulz3vAePoUsdLv2fbxgc+p+MrbVJy + RvOpKTKTZAITVJIY5auL7x2cxrfpU89LObrEcdKtzdPy9cN3SXrpYwxU2euNmrayV8w+mYNddI+C49IO + ERl/vLZPF4if6lxqQI70OeOlF6zdM+t4kuZe0mt+i9YdQCbukX7a/F2qLG7Fbg3tr+M9cGY3DaDY7v6G + ZsQmSJ5YPJgsPyFPBSFzfLW416QZO+z+fSQlrbd/MuRWACkdm1VtPDPF72VPlh6dOprNacJfo2VyzbIG + dlm60G5XFT2YBZqCLW/Fkyot6iLMGL94c03p+PD9MlHvm3ZZqqr3ep1fvTdgLKLA6HmlAcYu7Z/NdtB+ + bsAI/60a8IaBIpIuWws5BS/MWx5WiKMEnK2/El0PkCgwLm8dtYXh0wAw5jQ/DgZtzpok6SWOlfTiUdn4 + skr3YSYPXdiWtWSsUuXHcmfIc62f3udoAEcHBRip7OaMcZJZ6ihPjX40BnY+ALGtbBmq8typapGqkx7o + qJp7v16r0lwiNXfNuzrweI1V2nq9aSOT5lxIQiIGZVKu/GqISqUpMqu+AuMkBemRiYFx/WBPVR59wbHy + 9VWelGghFcelytSrdSC/UNVXpUSro96z13Niz+L0Q/YyTyPjtILgpOIR+bhbJ9sxkd61nQG8tRdJel+c + LtR7kpbMVNk4NCrzHkmz0BNzBKn0ACj/fuHx8t7V5aX5o40tJTxhLkiLHAlA32EnK+jqmxfawzbAmy8z + VX7ujSplh5wCl2sxkNLx6abtUilibImjpfuz7SyL85jXenvAo5I8h2XZbpoAiPA+1LOZ1Tz74l+ljpGn + Gz8srzzUwAB1hgKj212T7Z2fKjB20TEsFpERCoxdn2sfzxyd22mMzAWy5HCOui3++t41urjv/tx7tr9+ + 2Yr+Rn0Bh23vRmTjSwSqxxaTsPv0O65drqDvgLFbt27Zzr3e36aSvBJ9sjErXSadd5xqi+FHpVJwnM1v + 4JlNvq50tnRUSZ3wMv8Z4ocdMCIdAC6TzojI+o+UEQJnR7O/d8u3umqXVIaLOSmQoKbXUNAaowwQzNUI + 0Kh6SMaYzNKqGurEeOeeenk6RxlJaPmXgw2cZt8ZlZ0cRep/tu8d1GutqsB4v2FkpCw8ziQZWKAqnAVe + 41lPBIj+glQ8uYis7OclKQD8v6tV2SScP595wgLLp9fW+qgEWyBgjIEvqvyGwRGZdZtKUjp5AUT6hz4d + Weo4eaPmpdLmofvt8CDSwaOOoH5iI8PmibSYUwA731Pox2ABTBPd56dt82bJ5HKnmqS2rFkB7Iuxgj1u + 0yvathLaznMj0qd5E+OBMQ1qmUMjnegHleZ3DQ6oqPo/oLixry6qKvmx0H1a9QLrk3cbNTBJduZVOkH9 + HunYfdQVrzSLzPflikqXDnkHRuJmp9W8yMYCZ8v8mAc62ztCikmIg7C/qdR/sUqrqupPvTQiW9/UuZHA + k2/A2EKBROsZBoyHisQIv6z+/gtdjNJkRlWdi9rn2SIBtACUpJibVtWz9w++qqwlY/abMPYliuKgAOOO + ZYtlyqVnWl7AGdcok6K6+g+L14L3d9lz3iQed/4R8l2FM2TsmUdYGM3WETr4Krn5r6cgoe0YzW4Fr7OG + XVcxT3tWmcAeMKrEeCsSo9YngcQI+G78HIk0asCIhMOKtaJ7VHbP0HphC0ygOocVkyrHqqR5hSc1Tihx + hLzf5XkZ8bSXXYbEGJu/VlWCDDr5eK7VdayW8QrYeCJ1AUJlN5VZJ+EvF50kbyogPtnoIZv8MBUeXJwG + eHGRstnOllOSWhh41+qVsl6ZePl7L8sy2zr5six+t5+sHvWr7TRhMXIhSIkAku83jPvTWygVuNb11PZi + UwqZ3EhsOQU489vm/l6GHbzr/R6+R97u86JMKn+KjlWKzLhWJXC2lgXvBeAUkBY/rJJ0THrvcPdtlvB0 + +F21bYxnXa+8wQmCwftURV3ZWvsYYKxQTLrEJMbcNBXaveCph2w8cDhNvTR20H+IdBQvsfdtfSciM6tH + DUx5L578cUeTmkv5MAGwAozuzG1sjIcqMMJrS/r3sXoaMOqYB4ERk8n6rjrGZ3rj/GadKy1UZ/BgnceF + 4Cw84MAIM6xREDK1QYFxRXfPOZFtUitYICXNqKWDqAzzc9mTpX39G2ybGjbJdR+m7h3vSFEwiO+A0Wf/ + XPFMm+zOAYO3N8wBY8D4xSADU/bZ7lSJNMzzbQUg09+m14jK2KgypA7Myt6psmc6oBy4No+FRWBFD6/O + qLWD764rA7q/4E0Y/W5OQ2V2vORIyXmRRLVgimDx4N5xR6UY8/C8b8qfKT1vqinNH2sirVu3NgkRTx6A + iPeWoGQ8uP7QoTBQs3Ec/I5kXXGeSbqWMg5AQbrXz5TpvTqaV5ZQEAAykdTJd8s5HlOfQQow8h+GOR3M + GzwgVbbr+GcLmfFfo9/jIMmqjPMkRV65/3b56HEFH+1XwrCWt4p6h+kH71O1lODwaVeioaTIjxefKi1a + tLCEBN/dW9cWwFk3qPQeBNUYUC1teoQBFGFO/iNbEwEjbd48fpT1E2o6C+DGfjoXhmob/c/3F941TBfm + VyLWT4Ap7RpX/AgZWfpYA3Q82TvZIRJihiCOkXNRaMuwKy+M2xgPNWCE32Y3vtUDRhVyGJcgMNLnloNR + 2zyxeFR6NKyfLXP/vjqTDjgwshrMbdbQmAGVd8sPOBeUGdyE17+7VOqyLC/nqXqpUsQH1S6SJk2ayJ9l + TlZ1OiIruqlEgd0tAAYOGFfoSgKgIH293PapbIMftorEgZGBqKn1UUkrJ5BDKtz8TdR22mwcqsyMB5vf + 8ghawWLvUzCedqXHtN9cfZH07dVLxlQs6kmlKhUsaqqS9WRtX17eRT/odatVpRx/nDd5kIBevbaKPN74 + kbjKTIAvqgdbJwFEGArVGaZiJ0QiSY/PK9/ua0CLyokNeHI5lWBU2sZeShvMzKCTffzH71sAMSt4om2T + vGPGXdcYsNjCFDS0Uz7UflJQmnNzmkyvFjU1KswGSZC3ty0QW1qqvHFHHfmqTlXjt8loG2+rRBZiyEdC + 3dDH884jub5Vs4rl9aOPfr7/FmuTxdMBOv57tRAitOB+VVH1mqEKOP6DsBLlsWQezL6vjgEjSSqw/e3J + ya6o3/P7xpcwFXkCA/2PbfipO+vLu9dUtPfPqXeE1ZF+8N9vwe9az3l3ePX8+JoKh6xXmrCtKZefZ6A3 + t56Xg9HfHlvESBbCnngd428vOUuebvWkjZU/a/q+BKwfcGAkI2+mqjUTTla1VQcJB0s2tZVJrQCwpGOa + TFBAMJWmQX158skn5bdLipoDZn7jmEPCDwaxe8kQs26gMg57XHVyvndf/Vx3wBgwDlcRXDsZ58n20To5 + /UcFBIu+h5jJXZOLeCruvjhGKPo8nDWLUccU0P8se4p0e76jDG7xqDE/7Rh/QqrMrKtq9XcKxFOLyE68 + 5npf6PO00IcLGuukw8GiffhinaukadOmdt4xYThIiEjSBCEjIeLFY+HA3JBISoT4bvXH/eOgOOGEiMxv + FLWwH5w77HVf2DQmzeg1f95Y1fat+rdNBtXynevWxOMLSQhg9sUAQABmG/soPyjA0RdrCeEApIJAAgDo + 9zhwCNn5GROMggfPnl+fZyu/BUCDgvq5VNVMrpukC3KXu+rZ4sEOlr9uvsyetYjYSgWXve7V+i56QPtC + F9ZhqqLmtvuCPlzz+UDrH0CKnR2o92FAb0XbyDvW91KeLuEtntw7svTx0qbBbdKsWTP5QoUHvl/8kD4r + TCL+SHlGF4wZ7CPXeva/8eq9jpY9VIBx45jf7fwWnEQr2+0dVsW2yK1v6QJRBl9CirxZ6zLjazzS/oxa + 8HBB6YACIwzBSYDGEDpxVvZWRgXgfBN8x586gDq5Zt6oqpAONLawFs2esF0YP9YsZ+oaDgm8uX4giN+v + 6qbbATPp9BT55IbLcz1024AxpkpnXR6RbQSRB2yeoSUHYMpX0edY4Pib1Dkio0oeL91aP2Ur4FeN77Yt + hfQZIIc3mbNcaH/wyFRXCDUiqzcedhxWn15aXB577DFjHp7JsQ/sCAIQcUoFtyOGASLE96Riy7joBAXr + FAPFBU8oWEzV+sdsqyQY3jkpRabV8CTHCaWOlmG9u5tECsM6R46fNo75zTL6YAdd0z7EvggwKHAte0yf + p+2hLFEwDgNQChLcIlUZx+t1puYjMauKv6aj8hvAFrjH7Jac2aLaAgD4y8WnSJvHm9rOEABu7M2Xe6Dz + iL4zBBgBooX3e4A17IoLTf12R2uEaSlkb5p6dUmTTJF4iNkMe66VWNs36FyxnIN6Pbzwoy6ere+5S1q1 + aiVd2z8rf1QuZnVfpouh9UvgOYS7bH0rVaaU8RaX/jfXOCRP04THVurCS1QB/oQt/XWx9aeE0/6w8Kiu + Xgww2tALd94SN184AWhfPNLQAQVGAMm80dpo4ue2/ayN9nuXAQid0Ju/BAiUEfS6AdXKSps2bUzK+ebh + O7172Zql94aBFyowzpPZt+pEU+lrRNXzDAz8e0KDKwmfV3z1iQHjtCsVcHHi5AUYC6vQ7gnK/MOiOpEj + MvbcI6VHs8es3hjxhz/zpIypcLpNCOo47riITLs2Kpu+DQdHDsZicZmlahXA2PeGq019ZqIzYZEScUYh + JaDe5gaIjhi/OffW8tQ/VdFJKszecRtDVwf9S+C452nXSaxS5Rd31rYJCFAgQSE1unfxd/m7/WzlN9OK + Lg5B54OpgSpRufT1lLkK+rZNzHedK4DM8qcU5PQ6Jg7P9o4vUE0g5KRBvLio2KiogMaHV18cT49Paq6J + 9arZgrXqaW3vp9nvR8pDcp17i0rJCkzvX181R9sd7V39yXvWh+O1f+aoZMvullBpEVDUZ295TaWjEl67 + 4YFvy58pLR70ogh41we9usu4cqeb53xV23Dwx4ttSXe1PwiI7tvglvi5KO4kw31RPQuL4LGF3drYOJA5 + fYcCera+oU8U+Jc19RYizpBu9+gjthUQHiss6feAAuOe7dviKcbm3KpMigMloIbiiODUOgsp0UnV47Yb + TVpE6vuul5dgAIfHhgGJJSZTxdtpx6naPerCE+SV9u1yNMoCCmvGj5KJ5x4n06t5gHuggXGHSlpsG8QO + hqOkb6N7LJaQCYbK++UH78qP9a9RtTjNm1RHqVSmar9thQzWVft0V3qqzFO1FMn8lbrVLWCbsBVUDbZI + YoPJKyBCXLPxz59sYsKQ7Pdma2PY3nWSbWz7Q6WTSh6QDa9Z0d7tss34pXbeP7fZ3SYJme1wkE6GAEgQ + WrO1f1QliDTzqnM0KtEMOwaH76UGqNZ2U+mbQ8BUKptwaorMvilNdpLCLAAYFMBnVQcFNpVYOWWu2+03 + xs/hJvvMxPrVLTZ21bPYuwLAqEBrZ0pf47X1nRuuim+1C5uktHfWnddovVJk0rm6uPVTCTkst6J+pt3E + KGap9gPoxkHx/nvt3GQkPsxEP775sqr/XoC5JfYN8egTLL6uuydljbzgOGn/eJNs2+fgB+p2sIk6zHmi + gfXlvPosGl5fZOsXBUbMIl5g92nS5umnbK4U5uFjBxQYNyn4pJc82pwJyzrq6ktQt29CIe1ZUHc9D9R+ + K3OCtG3S2BgAlebXLz6TSRef7KnhPfT+gBpuRT9jf8RzzaozSUGmf6OGdjiWP3zCDwZ04uoxf1hAKafo + sY1vrzjJghbqF6xjSKHt2xVMphKXpfV+s8FNNtg4RghYRcpj4D/r9ryMLq/SIyv/KRFZ954uEIEYUEKA + +G7u7dqPKjG+deNVcfXO7xDICyA6YsuaHcLEe0+NyNp3VDKZrBMwQQgRkQYLH1XmNam9uLwSmIROOtmx + aoVkVbvAswHeqc9EDQyAHRLQqmdRtT0JlMgEO2ua3TGBVFQUpCNLLkAMrPbleO2nVbpQhjlOKLxz3m2e + 2WF0qWOk9WNNjOewvxGLmFG/hu18Wf2c9nXgGaTzwtmD7Y6J+sYtNXNMZMCxDelsbNB3sR97F6E1QVDU + QtjRjiERmVE9zWyqLIY/q/r8+EMPGijyDlRHFrqJXZ/xog60vZtfV4mbOMbA8wD/lQrsmCt+vOgU08L8 + oWyFcS5NYdA/uljPbHidLb6LHlKtAH7w9Q+LpvW3LqKM7Qc1KsTPkC5omrcwOmDASEWXvtLVVnxLMfap + MkUg5AbpA+dCRild2bTRA1SlcQNosXVjxkg69h4FxoUEAQOsYcCoz9n6C55S7TydTINvusqM6Ik6DmBc + +eUQz8ZYVVUuDuMaoxPO/9z8Fq2H7d6ZoGptHpPKEqI0q66CmTLFR1pncgnSbnafACjYBGnDV317yIQS + RxkwruqjEx5Ptb8fRhax7+YpY9FXQ66psM/2JA6oItsP4EEdbfdRIqeT1gXJf1UvD5hHVD5HXuzWda/3 + MwZmc8aJo6CyqnWIfQxVVYFx3i0KstoWpCYv9Cgim15SoFIQDAKLgQqeaV1kxqQpH5RRyZJdIYGQD7tW + 1fYtb6qkXsqT1L+uVMzCmFiUSFc2OSNdMi6/wCbh2ue1LmzTC9zPjpOpFSMyXkGnd4N6e6morq9p7/yn + G3mefL12XRftx8DzrGh7dn+uwHB/NA6KY0ocbY4W1GfGElDEbj5tcqZMvrqU8fm0y1Ti1nZnS3IRK0i6 + K9p6UvGvZU4ye3N+sk8dKNqtWmVWjdLmeFmB6YLwJd/4EsCPSWQKR+QqlvSpd33cvugPqN/XthwwYPzP + rp2WRoiJMvVqb/dKtvOQmUwKdEs76cqLGq3M0LNeLVOj8aACCHg2pzxcz54xM5btO2xPMxKTOXDqelLA + 8Ksuskw7iY6z9AMjEiOJK3buiyoNOKuaTxtZAOz8ZtT+nLzX3KPS8pz7tM4qZX1S8xJTdbBxWWaYZcvM + PocDA8l3TM1y2jZiKPHsax/4gVGLeaUfV2BSMPmGLDPdu+9TOqbdW7dIVvULVcVRMH55b2k/W6Etuuit + +0ClX2XeUaVPkF7PttvLU4uEsqh7OzO0423FlmZA55vQxK9tV6mYlF9M/j9LHyejih9j5pS1nfX6EHsa + n5HslrdUKbNYmkmLlv3Zf03sOoB4eXPPoQMAkey0Q4cOcdV/VtZkyah8trVjXSd9bhAYVTrj6NUpFXTB + V/7pd9fNFjvLuJGKzi8dk6MT7zsLH6BtIBaMx6TuqL1d6TsvdIg4vS63XC8tW7a0oGzUZ1R8nj+r81O2 + +wrJfGHDmMQd7A8ttH9Faw8Yv6p4jplWgkmIDwVg3Dp/jmSWjSWP6BRbOFx76JshRcz8gLNuwtnaL/fc + YXZW510P2nQLSgcMGDeN/dMYj3Cbxe5Aff9kUtDYMVYZBluNMo6pNI82NnsNdjakJqS96c8/6Ul2lVJN + 9QyVxpiY+vzFLT2Q+aPsydK3a5f4ATnB3HMA4wqVXIhjdFsOCxqszbtxPmz6KiLTa6rEeqaWc8gEroMc + pvr77uP3eU20/VrnwbWqmOSBKk2dnaMEUMeTPKn+VToZIhZLyRnR2Z6r/9si87wnMX5X6WxLj7YvoRk7 + N2+UyZeVstjSTZ+rtB9Q37MV2qK/rx2gYKGgN7rkcdKzzdN7bZP7xy2Wp3s7UvAMB6UdgHJdNwX4sxQo + zo1Ij9rV5LNLzjWJizOTEzlgTB1XUN3SX6V/VMsQW6Tn1EmRWderNKo8N6rUsdLmkUYGPpgdAPG5f/ws + 6WVOVikvKht66rMCwG3AaIf8R21nFscp4DQLnjkC6Cx/80UzRRBovqK5zoGQHSq2ywNpl/3aOnbpKiH3 + vf5yefzxx+O2dkwqU3QcyRZEQlskXbQwk6DDYkC1GDA+pfygktiwy0ublAXA5mXb4oEi+mjtz9+YRE0k + xuaXdX77HXEAo443GXVYqDhGonOj+6RPnz55yqKVHzogwEiDF7/QylQmvMobdQJkc5zEJhKJaFFZYJ6P + r7gwrtLACKiSq1evlgXDBpo6zkrK+SSh+5IBBsJfYmn6J6na1e/plgljy2Dc5Z+8p4Csk+RGnaCJsuvk + oQCKG5Q58XBaeA1q0ykpliWEI14TJdq1OiswLlHmZfUfWuNiU5n8Uh51BtCZbFPqXWHXLeuo6mcQcPV/ + pMjVr+AQiMgvF58mPZ/3sszQfvrR3/680A6OuK2GiqMq7+s6qXORGHHAbFQAJefkyBJe+BGSv/+s720L + VDoo6dnbFj2c5gGFX9rR/9npYWnE9JoxJY+Wxo0ekuFVLzDjPDaovVRvfwH4QrzQrgAim9+KSmbMdEMS + Dex3ABsmDCbaopG/Skapk3T8IrKR814CwAhwb36F+EJt57nHyPOPP2o8G9RO9mzdrP1XXPmbc6+jKgVj + C9S6+dvrnke+T11MmQtoTu9fXU5euf0Gee/xRvJVx9Yy5vmnZPJdNU3QYB6MO077gqMP6L+QBYCCnZa8 + hggdn11WMlsQelis5cEgcGLlZwMMI6aUjci2t72FIls7dLxX2fbLiPxW6kTp2KxpPO+q/8CzfaUDAoz/ + bNsiUy4r5iVFUIlwx7jU7GoloJCloNBWwUQlSpih05232ArJ+Q04H5CSAIQVE8dIetlTVBJSiUFXcAMF + /6SMPQ81fcvXnoqWoStq//tvt4lJmv6g6kBHLujV3gBsFluqUNHD9krnULC3Ec+3RicauyeQ1DJRcfAi + IyUoSC4na0pQUnaFPtC2LCVz9IkRGaHqW9jOBOpMkPqMx+4wyXL58wmAUReade9joI7IuBJHm8SGHSa3 + /buJaMemjTLl6pLmFCORb67ASEIPlZpxgACMXZ96MltWa6TfFQPfsr7BU7q+e0yNDgDjrqGpMvdWBUbl + nW8uOcuC1L+6opQB4+xautCoxLeXOprHwiRb2VqfrWBvERD168RVTNRo4l6XjR8tk0qepKp8mrdVMeDY + QNVbT4yhSrMcndo1dqa0Pycg/LXm84/MPkqIDqf17bUIxIptfRug2ka1NBl7jC6qp6XYYkQZf4YudAoI + 9lnbD48hfc4n8cngcBuqK0haC+71vNtfXFYiHoSOJlaQhXJ/kJlW+na09s3Q9nv20uztYMwWc0Y2/FCh + mDwbC+x2ccqFZSvd78BIJTf8+ZOJ/IDDkmdU/QEcfBMZtXUHe6Nr68CrZEBIQsvmzeKeQRcPBphtXLNa + MutUNlBY+IQ+C1AIsd1Zcoa/UmVqLKHExzddFY+MDwZ6w7gLe3XwgPEOZTJLIrH3M0ML7dBCPB9ZuWFc + l/D1i4pnS/vb6srP5U41QJl1o04sQDfMfskzVMpd1RsJU9X/i06S7p2ejwcK+5mXv3M7P2l9sPhplZpC + gBHJdJNOPurBtsp+TR7c65Cg/BBAOu3umiatE4O69SediDl47nFebf1eryUruAJfr8cfMc+hy3QEYMx6 + 4AZTiXBc/M3+58AkMOnnI5wKnvQ0oEZ5C2j+5OarzUOdVaGAeRsp+mzskHNu8MBiZOnjpO2jj9hiRGIF + l25t6ddDZUKxIyTrkjTbgx18lwFjHwXG8yIy8vxj5YXmTe2UOv8hU7s2b5QZN1Y06c6cRq+qpgPAhgAj + 3+Fg2NpfpcBGaTLzujSZfnWazLhS/16hf/V/Ps+qEZGFd2Bn1WdpOwgbCn0exUwGupDcoKq08ibbAXML + Qj8YxDyc+9SD3qJXO2Za8UnALID096w62g4dM/al+22l+5pqzE8HBBgX92znqb+qTm4arswVyIyDWr2Z + FGN4Bs9IkbevrWQBtqy8iMguNgmJCUabev8NBgqzbouBWAJ7IOnDZt/u2dm+qlYqYaA3NokFAKNeN7vh + EeZxDXteWHGS4sq+ntpKOw0UK50jjz/cyBIRfHJ9ZVOhkF43fa11DskMRCGl2RpVsYiZG3PBMdKjQ3sL + MwqqO/TD3I7NPWBsEQKMWugTguAnK3igmrx/e+34DqCCeCF594IPXrO2ocKvIFwKqTFBuA7gv+0nVRvL + 6bjr+3s/+oAtTHhBsRWzwE258nwDpXn1Yk4U/2TWghqMOjWlrPeMV+tWt1yRA5rq5CmGAT5mh0pgV8up + sK1sGwdelfH6h6M3nenGhRVhi1766QcmwWQpeJO8Yi9gVCl3A6nKFBh/KXmy1s/z9roICPh1xfuvxvtt + 3q0qbXNQvu8ZexUDR086MnBAcmJvOIWECvoZCZHfE4Ug+YstOAN0ganqRWm8c0O1UG3kYBNmolkP3Wxm + k4X3KH8FeII+2a6L05QK2g4dk/euqyKdO3c2TSinhB0Fof0OjNhWpt9YySYx5zKHARkTbOVLunKfotKF + qiTd76gbNw77VV+AjL+zAAWdUFOvVGYdrc9L4EHmyNOFj6ukqtLamFLHyButW1rgrT+hBODgASOqdKrM + fzAmhYY8L6xgU0RSpO4MFhOALXgkayDUiJX5Y7K76MRhYizvFfW8yCHPAjA3DGWSRWVU8eMSZoKGgRww + znmQ56XuDYxIvDizrlMmUnXs0+sq7mWLyU/cGhNnzYK5kk76LpWske69qIDs742/X8dk648KPOU94Hmx + 8QPZJKmVOOPKnGCLyQqVevcCRgUHQIeTAjGtTDg3Kp3vb2C2sQ96dpPxpY73UpSRUIQAaf+9uRWerZLH + 2k7Kb2fogqzP73PztXHpA6kWUKOPluhigAQzQ3kNNXev9Ff6nA1IjMq3v5Q6xWLq/CcEblm/TqbfUMn6 + gFyQ5HvMC5g56c/i9ggiJ16Swv9Wsl+XUyFT+RaVUjMv0Hqq1Pry7Tfsc/jW/iDqMO0G1QYJ1Wm592KJ + TXgjZgvsr8VUC6pfO546rbAl3/0OjJsmjpb0C440NXop25VCvNFIPHPv9uyLIy88Xto99qgFsLrdA34Q + 4+9CbFPaMSYxfKmTk326AWCg8NxVyojOCfJnhdNl6AsdjPGZnKhzDAaTHmDEC7iwabgEtlfR3wH09QN0 + chXFlvdfSfGJRx42iRdvGcA2/OOPZAKHPGk9Fj6OFznkeVosa49KlMRxjlP1rXfzJnuFVEBxYDw5RWbf + RTzo3sBIsVhGBXoAFIk5URhJXohrkbKzHr3dJvkkvLTD8E4rKAXfrZ9RpTezk+cibY8B4/22xQ5TBra3 + RZ9+qGq055TaYLs/9D7fJGDCE8O2ihMZFbxGqwT93KMP27bGQe/0l4llTzJ1Gs90cDdKroVnf8b+Zk+N + xqnz1GNNsnmjkdBJlbag57MGjHYGC0d4BuyZgBxhJXjff7nwJAXXDmaycAv6yu+/9KIxlLfm3ap1NQdJ + Puu7LyW2CKzr5HlyWWS6PnC3RTwUtid3X2nHWtUirrjAgunXPOf1rb8dtkOpjWdfHV/8COnU6L79dtLh + fgVGgGz5Oy954QTFIpZFOuhFJtxm648R2zCOGvpVpbNNpUG6CdviQ8NXjhulYIuKHDHgs1RcIcDghfKo + ZKkqxLgjFbiUKSaWPEp+ffw+Y368o6g6AM68F5+NA6MdsxDyvHhh4o9XVey3VFUVFRj1PkBxSNULpOmj + jQ0UASEmGaorYv7Ee2qbRDpbValEoS7WFz+g3unAn5kmvZs8mM0u5zKQ0weL3ulrtsyZ16sUzsIQ8jzC + eJa208mvC84fCiQvdu2SbatafpgI6RL1e+7QjyxsxqRfcmmGOWHon3FFZNOX7PGNykSVlHqoxIhphDNk + kFjnvtTZVNSpVVTqVzUvzE7IrpDFjfR+Ba+fLj5NOjzZ0lTdz1QFHFethIHaksdiKlceJCdX7GB+5UUc + HOReHF75HAucdt5ot3AgoS/o8YxNRNKdmaMn6AzQd68wB05Efitzkjwfi7slmQES48z76phjBzvrerQF + fUZ+6rrPBWBUlXtpU0w9pCk7QZ5p2cI2DxTmFrrCoC2zpklm+TNMsl7fXfsqCIw4Xh5U3tN59OtFJ0nr + p1rtt3bsV2BkMs1v9aCpmFOVCf8eo5M4eOCVSpBLOnjSIoGqfW6pGVdpnDfafyQBDd+oK0NmjdJ2j0l4 + iYCMCToxRSdoVNXuqJeb0AzgKpk+epdkpKcbOLJizu3RzgNGJlouwIj6yDVz79NnHuMB7ohyp8vjDz9k + 6jOSIqCIpEfIBhNkag9P8pjOHt8xKuGFOYx8QD7+9Ki8/OBdpn4GPW6s7kuHKUCpxEU857bf9F5/v8YK + EuMaVaHYwjdRVdE3mj5kNkuAOr/bArkOaX3logWSXr2M9T2nIFpfBduifWdecZWmkS6JY+zc4gmTGAHG + 2bNmybQHbzJgm1071cAiKInx2RwGtZU39Lrhlc81D6Ttmf/uOxl/29U2QRbcqRMoP8AIUFiQsKrQ57N3 + OFXeuq5qfFuZ2wnCgkl7ZzW5w4A5UToviw/kQCYFxu8rnBlPr4/5Y94v30t66aNt3GddF5WdnGNzIEGR + EgPGeZyNou34UheBdrpwv/HGG9lSdOXHrLI/CP7aOHmCZJQ+2TRBbw959nYYP9TRdmh/Dr2sZDzVmN/R + VVjt2K/AyIH602qVN1VufhNtaABwyALz97hUmVbdSzE2uuQx8rSqNH7PoHM6uAlMwxnIrAfragd5ti6e + kdP2NJw7SFWLnvSMthb7pRLUiM+Gmo0F4JrVtbVJQQub5wC07nkqia37KOZs0WeNuvA4ad3wzngGG8Ig + AHVURsR7VrIFw4eYdDL1ijTZ/qeCY4htzmylCpqWsktB+t361+0V+kH7WRxWj/3TJjUOqy1f64IzVvsy + UGdsli5kCVV/yE3V8nQGTiICkJGksmKhQnNux/nFOGZ/r/VRRhFZ8xYSWURGlT5eOrVoFrcxzpo4XiZf + Xdom6sIGCq4AWyD+zgzt76XaiYE4DD68tmJ8FxQTetITDT3AuVbbnk/nixemo4sF46fSXPe7bonH9fmN + +JhYZj7sZZJe9mh4Oi++W/IIYTOpMiyWvdsFsk99pL63t1zfs6aDLgC0M3D//i47VG33UqopTynvD6he + fr95cveFeP/q7z6zsSZ7Fkc3+EOjkPItM/slupipQPDO9VXj/OCPjS2sduxXYNyUPtYCfJnkK/voBPDv + 0IhNnvWDFKzOUgbVSf529Uv28gwyEZ3KR6MBheVDP5TMS87wJNErVBX7K7ETwIq+C2DcM4tksFofZeK/ + FBg/fP1Vk2Cws0zv3MqTGB/PGRgBYBxItt1QwQHpkySweJ+xUTEp8EiiLgKKTDDKijF/mPSUWTaWtTxE + wjNgjDlM6LNBtauGqgqUtZMnyqTzj1Bgjlof4tEO1pltjcSMTq/pqfs/Vyomb7zU1xwwYVsjcyP6H6l1 + 9ksvWNtno14q+IYBo7Pv0tcjKpwlz7VtE/fWzvz2C0kv7q38xBGGAQ7SwvoXdRErps9Q1arvrbXMkcWi + g/0us9fz5unH07pDJdOw5LOJiqlkJJbVumEXbNe0SXx/M7Yq54wwYFRwA1BWttrbS0oB7Bao5sCzPr/s + AvOSIpWP/ewTybj4JGvjtEu1fniSc4gz3F/FjojVvplaMdUWx/61r7BFwGkOh9Kul1XfDDW78dTKRAAo + /7r+Qur9RIWRbjhdvMWs1x114/wQtmljX2m/ASMNXdixubfbBW/cUGUMdn3EJo+FuSgALX7Sc46MPy8q + nRvcmi2o2yV8cGCwedJfMrf5PQZGrMTj0lJU9Y2pcwmALF70dxI6bP7K22c56sITpV83z+YGg2R1bOEB + Y+McVGlUfwX31S/rZFU1jjp8ryo0QcfUG28k2UoAdCYXDIeEh6S1SoHR+uI87YtPI5boIvgOwB0VdC5q + jwLPsKsvCt3uxDM3zp8jGZXOsom3mp0oYXbWWB8vYjeNqr5jSh0nr3Z4psCH6DOmtImwHYAWyRYJ186i + 8b9X64GJZHE7fa9e903FYvJ8+2fj5pFpb/U1SRvvO8d+7nVinxZACPshAcx/qSbxTJNHTBp3R7pOZweU + LqaTy+hC85YuNCFZdsIKNkIyfM+OZfgeckWpbKFhLGhuwdhJQtm6Vc35s/IZBXCAMVDPXcrX8+88wp71 + Uc1KFjiN5DnuuSe9wH79fnmrNNmTIKB7fxfMFJv7eQs4/dXvthuyherg2MwPD+wvgqdXfjPMFiEyFVlo + ErGZsXaYs6yhZ19kJxtnfcMPibb57ivtN2D8H63k9LqVzUHAqX1IQ37JwvIIIs1c7Ukz5FVr9XhTCyMA + rFxS080L58vqYQNk1n21JaPscTahCJbmkHgyVNt+aSQt/8QMKzpZbTfGcM/rO7LU8dJdJysSHpN1codm + cedLImCkDTvHa51VfTOb6Hmp0u2W603KxXCPxAGzUW/EeieNMegb5s3W+p9sq/a691WtwgETAmSECi3G + ZnVSRH5V0O3TpbP1RzArzdY1q2TK9RWszss7JVgc9DN2xvUfah8X1dVW+65/4/tyTMGWG/H+Re+8ZMA9 + 83pvF5NJur73AvCo2HM4X0Tr9/llJaRTzPaGtDe5yR3WD5yKh+MlTNpD/cMTzDZNDqbybw9lkZgz4ksD + HgvZwVCPPSoPwGMquvZHViXU/FRTyfw2bVRLZ2L4mz4mWQfA+GxM5Q+8w/Za11EJX/n87RuqmdbASXUT + a1U0L/CUcpz3nHfgLuxCnVeSmxTPfmxvsduDfyh5pJkrK77+1APGK5WvLG7TawMqNRmMssp7ZpXvKpwp + 7Vo9GeeH/eFA2m/AuCVrkmXJmKjS4CJdMW23i2/yoILZMaTnalEV0x/UTWOzBr0vM1vcZ+fD2Gqn1yBZ + woCcy7Kitz5zooJiglCdvYpeY/t3PyFuDWA8QV5Q9Q7pFIN7Zvsn/guMCcJ1kMo2DNK6nKkDpPX5rPK5 + 0uyJJ0xKIMgUm40L6oXZHOAYkBGKcJ1OstMjsvpVnchhe7x5h/bT6pe8lXH8eUfI680aexMtFuTtgAzg + nXbfjQY8Cx5J9YAxaGelzWNTZJulYNN+1olK0lgX6F0QgzXAOPe5WAwlWbQnZl/wKIwJGYo455iFccC1 + FeM2vDG//yYZlYuaJDWvPupp6t5g87EuYK/i0daxOjtFPrr64mzOEeytS9InSCY7inQirWqrCw3qeB6A + 0VT0nlEzQUzSZ6OiM36hfbxujS4+l9hYr+0UsxEG3rFDnzcT04e28/3al3lJT/q/4TldcA657X/vZb/v + gBRdcOiX+Q1ZYBA+Tpe2eQQU2k/ht2BxvxUm8VwHjNMvT7MdT8Rt0g6zCbNVVvsYNfq1WpfH40XdhoH8 + bljIjfYLMFLB1cMHefFuxXRF/1iBAFXPN2GZyGSGMRXvgiOl9YP3ScfnOsjQti1k7M2XmWcK0R/mQkJE + ZZp3X0TWvqsdNlaBQAHEEj2EgEto0euYxOve18mqwDbywhOkc5vWJikAEhnPPu45XxLledQCYHLcKwA6 + /rw06XT7TXEwxybKCoxI73cWQfy/fetWmXpnTZ1ACowKfKGqL3VUSYvdQWwdQ+J45976oXu8mbyz2jxq + ADrzJnbTaL+ESc48U9815zatt7ZvXMmj5I1uL2QLS8mPCsK1sx66yYCR8eDZQfuu7WT6JlUyS3or/Ku3 + XBuPERz37uu20FHvFS10HINgo/8zEVa00PrqZEYq73FH3fgOB5wa9MPqpUsk66aqNlmWP6H9mRdg1N8B + ChfyMfGCNOn8wN1xFT2Yks0BIwHFG3ooDwczYyvwcFqdSbanp8hr9a83jef7x+4xaTb9LO5TQEWa9dfD + dz8SLL/zbMJT8HITv8n/fEfSCiQmrrM8kwR8I2H7pWzqFNJ2PPvYNqdf5jkdsYG6PIzBSAeIvyySWydP + kNWfDZCVwz6UFUM/kOVD3pXlqrVh18YBiEQN/zmzjp/XC0oGjKT+U36ZUiEiW99ToUfbTVt3krCXEwFP + S7GY02ceuj9usvDbSQujHo72CzDSWfPaPGLSQpZKDdtHxiQ7N3lUsrEUY9fhjU6RPy48Xt6//lIZybkm + xT1biEmHKl1xtsnybmm2NxfAYiJmO2MkrwWAUClt1VuoFan6TgXGdm3DgTFMYsRep98vaOapuSPKn2Gn + s2EAZoDcITwwDYMcpL+3bJapd9QwUF3SKTH4mlPmr1Q7tgBmfqvhLdk2yTsJD/Cd/0ZPk1SmVE6Tbb+r + ujZO7w08j3fwrvi51QpKQ+6sky2QOT9MtVvbwe4EnrWEfdq0IyCpMkbrVPUB2Meec6R0ub+BgQ8mgYkt + H7DxtT3DL2f3PFrRiQ8okCACYPyz9PHSuuljdr/bqYFdDECf3tRLgb/koRgw+p+ToPA+ziqmb38te3KO + sXDbFRizalVSrSYqG3qpdBw8ggBgVA1iZnWAMVVevPc2A8ZR11zkmQouiVh7grGPPIPvkJa360K9vk9U + 1nSOyqqnVTJqmSpLlceWP5kma/W7Db0UJPqnqsSpZaD2F5mp9D4WFNpsfwFSrRvg6d61XSXUXZ+qhtTb + A2gkrXd0jmEL58iGoCeXsl21vDn319EF7UjPTKFgzxhY5nT9TObxrLtqysIxI20MAEn40EmR+0I8Y+UP + X8rEYkfIFFWZSeVGe9g+ufo5QNHbofR5lfMs+sOdFx9MBlxYtF+Acec6VRurFrPJw46WbIkedKK6lFQw + HDZD63T9awOhgMgKTSD02veillyCzDs7yKgdAiR5Lnov0tiat7G3pcro0sdJ59ZPW/gKoJOp6qGp0k0S + OF+0/kz4+Y3SrF2fXFbC7F5MKictYq9hgMKYZCfn3ThgfD4xMFIsYS3qzykp8sbdN2dzDLitfLxn8eB3 + LV0W0jX9iaQW9jxCebb8GJXMi7S/i6bIj5cXNzXED7ZhYB5Gfy9fKlOuLGWL3spXQtrBAqLfLemg9T85 + Ir9eeKK0bdHcbLBfDR8uk26oZCs/wdV2vktwJ4lKSGTU5mAsVP8PqpePZ3F3qbzYgUOdZ7Z6yICRs5I5 + M3mH7zl7FQUjU9Ff0wlmKnqqvHl9Vdt77SQot4ec/oW2Lpgrk6ucbYfhb+ibABhVIptZTSeuAmPPe2+X + Pi90lnEVTtOxi8iCO3RMMBX46xG7jxCjJY9GZHJZ5oHHk7TFCmCkQGA7VfQ3zgGaqlLUVFUxZ9U5Qubf + HrHD5pc0TZMVrRRUVfPiFEEAdIeqoBzFivq++wudfzd7HnMWxC4Nb4tL7v6sOvDrxpE/S+bFJxn40JaJ + qlXh8Z9dU99bSeuH+Qhe09/Try4tWRPGmT3WBcK7Pisocf+6rAxJv+h04eCvLa+nyj+fK9irRE5mcupE + GzrfeYslEvbzLwCdV/7NKxU6MNLJ63/62utgBZCV3T1JLz559C8TdfM3uoqdH5XxR3tgiHSYdVma2SM3 + fe6paNxngcsJEhXkq/BeBY4NOhGxGXFa2kuPPmAdTFxc+lONPGB8LLHEaMBIaIa2621dff2Znp2dIxGD + wICzWt5vpoElHKqUCBj1PXbK4W3KDHrtq3fdZKASlGjM0z3hL8lQyZeJtKpfbAEKPo+Ct3uyAsiDWnft + 6zGljpX+zz1ToBV3c1a6vvNkc3qsVxVnL1sp/aTfzb1HgVH76btLzpJ27dpZQPGP778t6Rez15rMMboA + IeX5VUItSEC2DVD5AWcRqcBcvJpzjtDPpF6b1foRmzAzrlGQte16yiu+Z2UrCmj27Ge0X89QYNTxf/6e + O7Kp6OxH9587vmlapqSXPM4iCUgUsZeDx0mMNTyJsftDDeXtZo1lImnn9B2rdXEwU4G/HlqsHh2iMg4n + ovJcerEUGXfekfJLmZPMsUCfkUNzVIlj5a/zjpJxRakzYKlFxxqgs8Jn+klBCyFj8oUKIlUjMufGqCx+ + 2MvMA+DS1h/0eU+1ejIuafkX8i0TR0vGRcfbnKU+nDu0pktU/v5YpTYFWcCfI15dFnWu+6lvN1Nj4Xt4 + cl8lNubN+qkZklHudAVg79iH//lZ+eQB5VmtE21guy1hcUjlLnl1fjWevFKhAyMNnKcAYHuZdWUmrb+p + eAEQQLVeo2rt3IYKRo8jHarKPUpBdIr+NqGIZ7cKA46CFn0WKjgn8WVe5NkvP6h/vampSGOT7r7OA0YC + vHMCxkc8iXFQ9YtD48ESDRDAOFvVdZwlix6PLRb+58cKjgx2wMyo4U0EgNF/mpvLCkTZtHaNTK5e0sBu + gUofVu+QZ9IW3re2v07YU722f35TNS+sJAYIeQmO5ffV331ukhyJeLeMUOmETEG+vrL6/0W0gU5mrf/A + GuXM62sLSPsW9m7Lv9hTgUZV5iDQAJYLG+pkUIkLc0e7Rx+OZ3H3JwqgLHi9p6nEqKzbTSL0PStY9NnY + FxfcrWChoPJ7mROlTUxFx77ovP4udIW2bpo2WTJKn2C20s1hqcIARmyM1wKMKdKl8QMyqOHNnmTFUbDK + 38GM2qi6tJsthvDbRJVG361WVto1qC/NHm9qiXKRYumzru3aSq8WTeXlhxVw77xB3r6tlrxf92r55NpL + ZPhlJeXryufJD+XPlD9LnygTzk3zbPpInk4FRspSQAHIetevbc8MSlq7NqyTaddcGLf7zrjWA0TGweyZ + FBUm9gwvomq9p+URdvblIw0MYF0Uhn9BKQhx75Y1q2TyFedbO7Iqq7R6QzQetziu+BHSQfuIvmHOEhbn + tId9BeUwKnRg3IUaXaWoAkCKzCTpq0o/iQAO1ZbJzKQFdGwnTIJrC6UouBFAPYOMM8o4n9aqbHuycURM + uKeWAd7CJxNIc3ovdV3YTBlIr/tcGTM/Oe2YcLPbNbHJQOxmIonRgEUXjRkEZSuwfHBjNVvlqaMLeAcU + YSTUyakP6UTU66Zzjo62LVGgO2C7XX/D5ovENv6CI+W9Hl3jp8Sx6ucWtsE7l733skkNbFu05wYODWPx + Id3ZlIsVAM9MkVdvvNoWEEJ1xjasYxPX8igqSASBzHMWpMi0y7WOOqndvvlgwD/1ZDIsxViv0gWpwzgX + OqcdMOa4GIgjQqUeffZnVS+Iq+hhAe+0dc2vI8x7zcFL296N7h1y4wfG01Kkx313yLc1LrZx4/B+HCfO + 5ueKl6FH63G5px4Oq3KeNG7c2PJMsmuGsUa1R0LGFshfwAwwgFfRHohtBdBZMHo831FebPOU9G32qLzd + sJ4MuvFKGVTrUhl4fRUZeF1lGaCaTe+7bzVQ5F7svC7XJPbwhW0eiUuK07ROgKJJxkEvui4Iuz797yLw + 2c1XWd386dX2RZ2mv6lPVv1qBtKYEQBqA3b9/Nb1VW3RINSIRZIIAtrAgr4v701EhQqMNG7Fe694Ha1q + wvJER5z6ik1kAGt/AqIrBm6qUjY6wtS8r68oYYz42bBhMv726ibNLeuSWM1FVV3WSRlar/up3Blxe40D + xpwCZT1gfMzunf9IVJ+lC0bg+a5YHsm7lAGVMb64snRo3Bl9DVPMea2HTt4U22HEOTOhDhiKtgdpfKmq + cIRQMUZf1r3SEgHnVSUBNOYTqqOLyqy6MZsmY+d7BxIkIU2s9JOUqbvcc7tN4E8GfiQTqp5jkgyH01uY + jn/iadmhEhnnlpCiDZvz29dViduTguYK+mB1+jhJv/BU76D+N7Q+BIoHnumKBTq/zCTTeqlE8k7NKgnj + FyH+rmSLml5LIl3i6IL20Dgw1lTpT4Gxz9315JcqZ1v/LGkU7ilnMdj2PlsdtY90gelX+wo75IpFFqma + WFgkOpwjOPT4S/3YSgmAs0AgqSHlMnbwH1oLIEU4E/vRAUB4BvAkSxVACrACKDyL/dEsMCsG9o+DkJ3l + 82p4nV0hXGkuRxsrXw6qc1mhxxHCf8smjpWMvi/ID880l0+a3CvvNrxFXmlY38JzaA9xx/QPi7mTFnPi + 2YJSoQLjbhXLp9cubysyWZ6RHPy7XQ6FAugtaaOgo8D4S4UzpKdO2sEfDZAJKsLD0GteD7GbxQp7vZe/ + qJNA1dGfy54e35IEMOaWHp4BnNP2UQPGuQ+kmYMl9PgEwEXfs7Clp7L/WPEs6dm9e2juPN639M+fPTVI + n7vixQSOo1hButtKRiASfeqkHFvmePng5b426ZgsOHZykhr/o++dfmcNrZd3NCtSfrZ3AL76fgvD0voQ + WvHsE0293Tt9e8ik4niaI7Jc22a2N/8E1P/5bllz1GhPxexw/93ZYgz9iS+YhBvmzpL08sXszJawEwb9 + xex6dlaIF2rVtcGtoVvK3CQDfFd9/4XY4f5XqbSIdKtAmO25PolxvD739Vuvk5EXnWo2P+IeLR1aEBgV + /De/ogB9gdZFF4+ud9Q18EdK5AAteImxwGOMiYO/gDaqL2BAkmUWSHZ7oMZyPaYcAJTFg331PAfwZFcI + AMqiimaA2QTJmMxK6ydPlIyLTjCJDLMFThyLt0wAinwPMM6/VcdGx+djlUgLO1Ac4YHnALTwJKAPoAPA + /GWs3BZeBBHU9/0hLUKFBoww1PofYrnnjotlXsnSDk2g2h2sgtS3qpcOrk7c8ecfIf1aPi4DXlP1UFVL + AH1df70mETDqvWte0xVWr/up7BnxoOW87NUEzBa82s3eO+fuI+wdiYARKXulghyeTWLtXmr7VOieUBhx + 3ZJFklEJ04VKmber1ETSWr8UF3y2jsnS9lEZf7wnNX52940GuiTvBdxzkhp36sI3ueLppg3Y6YQhILxT + JWFzvJycIiMuOVPatvFU4ZF3XhfbEultA9zrICibeNqGG/XeU1MsrdSTKkkx+cLy7TEhNsyaJhnli5rn + Np7Syz+ZXVEA49lzb6VPdUEse7I81aK5ATYTO8wBxfNXjogB43VeLsa/PwhIpH5gPCMib9S9WhcDnDWJ + tzoC3utfVKn1nIiMPe9Iaf/IQyZRkzQFgAMEWaDQBpj4FCRZVFW+R0oCPKgvAMeYsWAAoEjUBL/7wZPY + TP4HEHk29yF1L+jwhDdXlW/oF86xJrTIX9dsJQCM791YzSS4wtySx2JH3eBx6gzYA/RIpThIAXbMKfzO + dU5z2h9UqMC4qFsbM66TxHTjMCQvZYwQgDmYxQKohyko6Epp4SB33iBvvtxP0s9PM4bmHOhd48PrjYS0 + 7l1tn6pXv5c4QXq0bW2ifV4OmIJplnz0pqeG1km1vdLBHSNW9L2ooxsHqTp5luc9HVS/pqlKwSBvGAkD + +rTH7zbbHTtFtn6rUjoqboJ+tzySHHlQxouTJJnGgFf7SW6hD7xv3YjPrT5sL2SboanSvvdYBMHoVJl2 + pfbl6Sl2Rgsq0PtdOsqkC48129t0tofixAhIX+xy2KZ9yxY6bJMfXlXWgufxZgcPlnL12aQSY2alsyzl + FzsjwjzA9myd8Ns/iFpmFhJPEGoVfDag4283/68irk6BcWYtBfJPAMbAswPA+HadK2Ts+UdbCI4d2xqy + DZCQn9XPKfifGZXfS58gbWO5EZHy/DZU/4TnfzfeFH6Hn5CwWCThO3gCsKCP/OCJhsFfVF1+59qdWzbL + jFsu94Kpy3tn2VgoUqCuwYLTyFRp5eGX7qxrwFiYSWJpI21iEUAiJAMUUjISJFI0vE97aAfv8vdRYVOh + ASMDNvO2arqaKCPdpGoWWaUTSS77UpiIWmw/rk5ywMocOFpIB2YJDRKAAgUnBF5TAqgZ4C+rXyyvPd9e + Jpx9hJ0NTDr+vZIixApS3gaVPAj1GXXecdKr5RMGWC5YltU9ETGQi997xVbbWTfrpCErTSJpGsDUQuYg + wOSHqueGAgSMwYSYN+hdk8YsPIqTEwPbL7MV7KxT2Y8d8fJTqtQw7O66pnK5pAJhUiOfFz7fwuxRHHDF + eS7Zdtpon9ui84Vnx8Oz2O+Wmpaf8I8aZT2VjZMdW8XsWP5JhzSik259N2/RwQvZ+9ZaCYORXX22b90i + k68tY306v35E9gwPPNc9+5Mi+myV0lTFpb04hFwIUKLUW/Tv0vdetv6fcwOxgd6zsj0bYCSOUVXtsUWj + Mrwqx6OmytQqSF/KRwHwp/CcNR20Lrq4jChXNDSnYLDv80LcQ0HS9YOnK3x2PPP30kWSefHJZu+1RL+f + a92CbQsp5JOcVStNOCqj3x03FroqDVF/6stcoi8AdAoLF4DIQhBcOPYHFRow7ly3RjLLa2ejZnWIyh4m + Zw4Ale/Cs35nMhaR3ZOLGCCyG2btW/o+VQ0Xt06TFX2jtmvEMncnePcOLbun6EQic4vWdVSZE+WjBnVl + /FlpMqVyVLb95iW8CLvXJj5ZqUsqqJwVlVcaNTSDuTPeByeXnxjMxR+86h0he32al0MSCSvkPRTU1IXN + Il7c4YXHyesd2++l9vEuGGX1/LmScVUJs0nO4agDPPyJQFf7BVAm1CajhCc1jy95tAzs3dP2nTqpMcjk + TKoZd1xtKvsstiCqtJjtHfpcFqc1b+qkP0375+yoPPfQffJWkwc9lU3bPa1KRP72JQeIF52UgOXyJxTc + 9bpx5x8hHR68Nx6m4z+jx0/09/QHbjRHDZsCOP9lzxfap0xyN9Hf02frxF8Uy8yCPbbjAw3NcebOCvEH + OjuivYswfSgwzgUYg6FFFFM9tV2VVS1W/vm5/Gkmhdn5MGE2SS0A49pnPan7p7KnSofYnt8wB9D+oo1/ + /eZpTNpnBIZbSFEuwLiD4Pg34H2V6M9OsXOuMUX4j8qgzwqDaD+F5/kLoOl+299UKMBIRVcOfsckKRIs + rFfmD6pZBSqx+y2rjT4PSYhsOqtej8qcu6Pm4IFxAQTOYh5/bMSkVcAxEbjZBCaJan9sWV5M1q8Vz5QJ + RdO8w7VG6b0JQAUJdctP+t7yCqqqvr38UANb7VFDczt5D6BZ8v4rpr5mVVUA/gMPcvh7KOylXvO2SrWq + omGLerVl01BHAc9FdZry4E22CyazdJps+UGBK4dnu8zpOHjGH6dSVPFUGVHnUpMaAQqeHzRsI2VMqaL9 + dFLE0phZtIH/mfSrgvmyF7TOCp5flz/LUoWNKn+6SYAEIq/tpNIJJ+QFJiGSFV7qebd7atq3Fc6S1qpi + 4l0Nhun4Ccl2fuwEPosdLK7veF4lRwVHy+Wn78EBsvUd7ZcLVY3WReCncqdJ6ydbxkOgEp1/w0Sc/0Ir + q898TvYLAUZU9K3vR2SKqujjikXlxwqne153Tj3ket+1rgCM67rq4lEsImOKHyU9WzU3z7j/XJ/9OfF5 + 9rJ3+5lkPuXiqGwn90BOtsVY2fM5Wy89pxoL3csN6oXG1/5bqFCAkQk0t8ntNjE5A2Xbr9rZCdTRPJUY + IHLQEhN4x/hU2fBxxBw6Uyrq4JzqSVLE77G1a2Tp42XCBd7B9uOOSNWJG1MnEwAzoEn2lyx9Fis8wMCA + z6yrgEIyhgTAaEcPKHBOq0YdUuWtBjdZeAQqbm4p4mGa5d8MMxUqs1TEkiwk2sJHQarb+r23Zeyvs46W + Ps0ezaa2uwnE+wDk2a/39LzTJ0RkWWcFoCkKQDnsGAI4t/2mIK/Px9mRrvcOb/qAtQWbDmCBvYd3UNZ8 + O1QlBQUuBbjVCtiWBMP3PPJr4pya/1iaSeKfVi0hw666yKsTkqwuWLs/UxUzZNIZiA2MyDRVSVnoBlQv + F0924Fcxg31L/dauXCGZ9a6092APZCHhnJgdn6TKP1/qs4dGZHZtHS+kRdTo2lfEtwG6Z4eNGxL5rEfr + GzAuuE/rHhLG4gGj8vwluigXS5MfVWLkPYv0esvE47vWFTvp7iUVIKiv9ucbD951QCVG+HBOs7s9yVb7 + m507YfX0F+JDt+niMrm0Arrex3ba55o1NadaWAzov4EKBRj/2bVTptWuYBNgtq762BcTHjWQh2KB3wps + nDW95Lk0mX4NRvMYGCr4IoFMKJ4mX1Q5V/rUrSGtHm0sPRrWV5XwKM+grOC8/XdVqROBc0xiWtxKGfp4 + lSYuAFBUYrlbwYoJn6DuJrmq1DizjjKITph369U05nB7eHNiDr5fM2G0TCp9okoLqbKePa0BcPEXSxc2 + KiJZl0dlVNGjpFfThy1OzR/P50ALyWnF7JmSXu5kWyzIfwnwGcAnWBz43o5+fdHrA9TR8SWOkq86P2Pg + yzsADLNPKQDN0YXPwrDMvqh1137wP8/rG51sdbxQqLEljrTJz3hYnGH/xCoboTDkSJxaWe/Vd7xxQ7X4 + 8bkuOUeYJIWUR5/PzUyXcfW8wGDagS1zRo00S8bgUoIBiqN0Qj/d+OF44g+3YwnpOPhs2j37sTtsAVz0 + MMAYIukqMG5TiZEF1g+MCwllAhgTtJW0/UhrOII+rlvNjnzA65poAShMwuRlkQWnpMi827SenyowhtTT + XwjjWaRtGq/aAv3Yv2aVbHvMD0S9DzQVCjBumZYpmRefYlLXsheUiZDWfJMm16KT1GyHmUVM6tgwRNWX + +3QQLlCGU8DCuG7OBf38zSVnSb861SzGjd0CeD2JdWP/5Kd31/XUNr1+9atajxxi+pjYW77V5xLwq2DL + ZFrWMWrvD7veClJRhgLovSo5aVvfvuXauDoRPMQ/SDDNxmWLJfOKkirVpMqaVxUocniXeY9V8ibTyGgF + xp6PNYqr7TCiX21nEiPhZT35oOc11raQ8zGn9lMATmIm5z0UkXFHe+Ax4cLjZMRrfS3omzg6M4BPn6yL + xxGW/m3OHVpvAD0gVQPEtt1SpWGTwh1Icd7Jc6reYuAPmXQUYvvYuTLlIq1H0aj0bHBL/NwfVPsw+yJE + nwKYhKtkTJokfzzawMaTdgDi45UP+GtSa3F9br1aJom6NHGo0Ym8qUijs3QxoP7Ln9C+DAM6nC8DkbzS + ZGzR/wLj4kdy8JB/RHv1nqt1EVDA/uHSc6SfqvV+k8H+krzor/mtH/bGmdjFpwBwBfyQerpC4o0tqiGQ + 3HnSWSl2vtFTDz9koWrsMc9p4TqcaZ+Bkc5Y/dUnZsQnNmvDJwouxAH6Jk3CgjNltCe9cXj72nejMru+ + t5fXSYdM9N/LnCADr7xQOja41TaRk5SAgcH4y6rF6s9Wp+H935AJZVStRvojiFqBJ6FaHAMFbJXjj0rx + kiIM0ntyqTv3LHgiBow3XxO3VeXG1PQTIDOlzqU6WSOy6uWcQZh6rFf1kn3FY845Sl5s8mC2A+t5lmNE + GB6gXPD7T5Je8kgDsBl1cJCo5J7I1kpR0CShBxmMMCNMILZRQeSvS4rKT6/3tYBymH7OM009wGXBeUUn + PfUOAC71XfOGXsNebL3WmSfm36Gg8oXWI8QR4Qqq2qa+es95ERl7dpp0f6BBPH4xpyQXtJ/v8Vgi4RLn + NqJ7R/nmjutk6E3VZHDty2TgdVXk45qVpNc93u4JxovAYXe8Kf0WNmZxYFSJcdnDyqNhO0IAxli4ztgz + fMD4cAxI/dfGitlT9Vm2H1z7B5B6r+lDtovF72QqbJDheUt7tbf3AcioxYRHBbdlZivaXjtS4H6VFqmr + 8kb/ayrF037hDCRUhxCa/VHng0n7DIxMygWEcWhnZ3GIzZ8xr7Bv0oQVrjHJ8i8mm6o8tVlBPXUZ6ZBB + 4DyVPjdcLa0fftAGgy1cSIaErrBaMTAABXGEhJpMUtVoXL0rTc2dqioojpSEddGJjYS67kN2mOhk1ndu + wu6nanzo9bHCVr75j3kOBoDRdnXEspXkBoy2F7ROZQUYlU67e8Ad9g4K4LNUJVjME6NKHStdmj+eUGLk + L4y5ZtUqybjvBltYzNnx4d62wL2K9gO2TnJmora742AnlD5Gfu/6rKQPfM+yUZMSjo3921W93yv+kr7U + BWMhuSoZP3JqnqWT76KobI3l1ctJXTNPbexA+DHnHy3PP9Y4z+cFw3+0nb6nX+AFFirCfNhbDMC6bXEs + LIAi3neeS4hJognN97Ob3mX27GWNU8MlRupObN8NWu/TFBgrxFRpIgMSAKOBDaFJ3b2Fn7H6rVIx+TC2 + NdGZSQpTaqR9qwb1t3E1oYOwqadDwqb8RetJmJOlaVNpG2cNp3g++XAjC3Ui8z1mHZyOLnzs30T7DIz/ + kGfwRp3sChRzbtdJoJJDIinNFcJtANBlqmKR1ABgmnBiig3apAsi8tUlxaTbLbWkZdPHbKM/qaFQWfHe + sbJi8GXFZ7XC6YGdiJUW6WZKzw4mvSJ9kL7Mgp1D6kCxhA0TMPpHLKZv3Qc5O21MlVbAmnufgri2t78C + IxPPD4xB76afsGVlXV/BJC8Oq08IjE5l15UaR8b3FYrGbTpBG6MjZ2+bOeQD884CUHPvxZyQGv4Of1HJ + HYlv6y/aFzU8cEQNBuAmlTjSFqnxR6XKko4xM0lI/+wYF5HpNXUCnZriqa5ITo3SPBU6B1CkkGh1SRMF + VV3Qfi17irTVMWfxY/tXbk4tiEkJkGHKQApktwcgA7AidbptcY5vAEX4BfUv0YTevWuXTLvlMlOlV7CF + MWR7H4UzX+bUSZWxp6fJD0iM2gZiKhMCI8W88Cl21jT9RD9/fu8tFvpS2BIYZy8t6dbGxgSBA9PU4gd1 + wWT7X1jdXKGOOnbztC3wIKD6xrVV4tIiO15yins93GmfgXH7wrmSUeY4M7gv66DAkpNdSyc8E2t1/6hM + vkSZQsHIbECqeo0vfoR8VuU86XZrbWnevLmpyxjJWfXZXQL4AArYnHB0AIIwEJMGwIGRAIuFqk5mlD7W + bCirVD3LycFhkk5WiixqHpFx0RSZUUuBdFLMaRM6+VNkmwL61CoRk5DfvrlGNmDMLcgVBpp2Z02TaFe9 + qO+mrwLvsKILyw7bQaJAo+/5+OqyJi2zSicK6+B/+oFFIv368uatZz/uFpWCLXQn0Zi4or9ziiIZeuaT + +v9ED1wJ5h2Xpqp5raiXvSfo0OI+Dhn7OioZJbSc7S1weLDJPm2B0WETz1c4tW9ObCvgV5XPjp/n4RaB + vHhqneQIPzBZuQ8ARBUP2xZH/zFWiZ67S3/Pql7aA0aOeE0EjENSVNuJyBgFxh/tDBr9zBbCIbogBa6N + F6Qx2xqIJKbaivbZhFJHy9DunezMbyRf2pFT/fJC/2zbIvOb3O5JijjXdI7OuxNpVscxmBDDX7R+LFbr + e0Qs3tKk2otONGmRgH0nLbp6/tukRWifgdESl+pKxACvG6idPkkZKMEkBISWdVVAVFHeHCq6io0pcZS8 + c1U5aXdvA7MfIhlheEdiwHaIUZqtcKykiO0E4yIZwdjYgRgUmIeCvWn92rWSUb2UrXKLWubs4LBJreC0 + sg8OC5Vy9J75D6WatxbnRzDcBZDd+Im2tZgyi0qlb91ybVyVzkuQKxN3VsuHzA63vFuCummd7KCwoUwY + VWN00Xj9hmrxhKr+3I9Bck6Yaa+/aH1LFp3FLXSx0vYkGpNshXdj4tA+WdOfUxijMvXKNJnfSFXo3/BE + h4ytfub6lS96dlfqa5EBeK8Dh6aHFWxunKI3ldApVdcGXFMhvuPFGfbDvMZhxDWACX2DDRYJEhB02+L4 + zOLJ77mBDsA4tWZZ2y2zpmMM4EOAcQenGV6fZhLjcFWJXS5BvOy5xQcitS24J03GneA5jEZXOEO++vC9 + bGnBHH/nh7h+z5ZNMu+Rep7Uj3NReQ7b565hulAGA+z9RdvI4fYA+3RdmFms4KXeN1a3tF9obkjh7oiJ + wpJsDzXaJ2CkQ1aP+NyzJ5WPypafdSKEHUEQmzxr3kV1UGkr5ilEZW7d8E6TEAFE7IfY0bADEQKDMR3A + YZV30qGfqYMDAhNxzdTYYU1z7srFmaL1QtqxbX6kutJ24ICY/7AyNUcqINH9EWuPFgBzMaeVKYCOKXmM + dG78YL6CXGGi2S3uVwCJyFKyOycARqTqZZ2895CRpvP9DWwXCGYE1BeSB7AoBAmpiQVj6dzZkl6pqPUz + gc1bdVzsQP7gu8KKvt8cUxk6OcilOUbv1QXBbLX0Q+B6uxbzQoP/qlwY96dfhlSSyyTUAnDieCERBAus + O7UvLGlGXsjxBeMAn7BYuMJnBzRB3gkSfMbRqSyC67toHyTI3OOAcbxKlkOrni/jSeR6PufZaNtzWRTM + 9jpQNYPLdF4ovzInRl5RXH74dIgJAggBTt3Prb6OuO7vOdNl5i2X2fNYpHAskrkc1djAOgTg/YXrljzi + CTCM5zfli8oTTzxhizMhVM4W+m+VFqF9AkYm4sJubbzYuWsUTFTVCosBZFJt+4NAWM82x4B9eEUZafpo + Y1uFUJkxjLP9iwBjUkyhBiEtoJ6yyjM5cmMQfoORZrZ/XNKVIabqird9tNYrB5un/faXXnsVe0C9iY0K + yV7qdR8pMylIAa5sccTxMKWSSjYKON+XP13atG6913ksOTEKYDa7xX2eZNo4TYF27/5iyyL2xVm3sYik + 2pnKT7d60gA4p50aEO03qVmlo6yu7Ux6oy2LnorKnmn67JCxya3kdg9hT4QVTS6vEuOpLBhHq1oZlemX + J9j+5y+obMNSZFVbBVUWS+37Tg82tAWSjD/BU/sOJP29YZ1Muexck7bWPaftTCAxmvOlNhJZqkqMZ1us + JEcOrCQZcU5pvCj6G4C75fWILmBe/zE3xl56tvzxck9T/10mGXiH+ZaI/23st22VZS+/YHGKxsdoZfqX + Peh7vgh5f7DExoNMRZZPUwUF7n/uzlss6QYxu/Dgv9UT7ad9AkZAYNqNFU06Q2IItefFJKDFT0c8j6cO + /JcqKTZp0sQcK2ToYBVCQgQQARjUCCZ/UF3OCzFYCz54zaQPS775ma7cqpqGSTtWsHuqZLiohQKRggiq + hwEK0tqZUcuduF4ln41kL66rqkXMBPB+jUv2soUFHSJBoi2zmt9jajgHU239SQGL1Gyo7NRPC8c6bP2J + iaLMqZPy/eoV4okGCALOyw4bs7VmpsukimfY4VcZ50dl8zeqRtEPYX2wDwWpd9Wrnibw1/lHyeCqxWX0 + OUdb3JsFdSeQtCio0ah2s+lXBZNfcLy09A7Oykts6P6krfNV6i5xlGci6qJ9lyD7jKXiul2BXUGNE+w4 + r4W2zK6l9yjP5LrdzsCoiGzsF7XjIsafoOOl/DfpgqiMvfUqyfz4PVk80zuWNyggUOCDXWtWyQrl+alX + lzTexLs/XvmXzDmbeisofq51B6BzAmktll1cpVzOjXEg/d5VF5uJC/MWeTExb2Djpi4HY1wOFO0TMG5f + OE8yy51kILK0TarZ67IBkP7vhXakSlYlL/B3XIkjTX1GUgQUsSMSgsLqCCBiP8SmhJSQ0wqZiLhv5aSx + kn7BEaaeLCdhqAJzQmDUgkQI8LEjBdCaqIAKU+DAmHhSitmZSAHmJErsos82esAkXZglL2e+QNRtwUud + 7dkwHlvgtnyn9VMV3Y510Lr8MzNFlmOHBaQV3HvdWju+CyQsy0yQ+J7Jw4o+ueUDBvQTjk+Refd70m9O + /VCQYrGgDfGeR+Sni0+W7jdUl3EXHGlAsehBlYq/9AAwbCLimUU6wZaKGWPIFaWzLQIuXjPRIrC/iD5c + P/InS7KQrgC18eWoqsWJgLGILG7iAeNXFYvJwOrlrC0c9Lb5FQB173vCCpIaJ+PNVE3FbPCnKUDq+MNv + 6dUvlCkdW8qCX0bImlUrbY5sW7dG1vz0jSzs/KQCYgnvOuVfYiNJn7fg3qjtyuEI1dwA0cr7RUyqXMx+ + 6JhaT7hcs8aPxBPpkuwWTQ6hhUU+v3PzcKICAyOdsvqLj72dJkUjsvZ9ZYKgPU8nIVLk2ndjdkW99h2V + gLApAip4m11MGROZCQ947EuHs4ptXLlCJl9TxtR2DpqnXjmq0wrebGOcdZNnJ5uoTP3h5aVkWOXz5M8L + T5A/S3llVJnj5acKZ0j3hvXNS4yDCMkGUGdFz03l4/c1s6ZLRoXTjPF4FzkUl3dPkx3jI7JHQXGjgoXb + PTKq9LHyTONGploSwO7CIwC+nIg+QKpcMH2qTKpyluclLhaRzZ/jpdeJUhjgqM/AQcVpjxx6xjs+rXqB + mUf+uvC4OF8sb6VS8XDtX7YD2gT0CvY1Ar9nX58Wl8LzuwjsLzLe5lgDldinlAdgEpsEAPcVbXRhOCMi + 35Y/U16sX8dACoBaeJ+2nQSwIfftVbRPdiuI7hqSKquejcgMtsGejSSu/ahzB7V2UunjJePqUjKlXjWZ + cnVpmUQOURZyXbAtWPz8iCy4U8dZVXPshOxayRsokiRCF6meKrmbEKDPVOGgvarQnLlDeI4/wQhjcqAX + qwNNBQZGOsYCu09P8fIY/hye0cXU1Kd1gFWiGFv8SGnzwD2mgiIVoD5jMwMUkbacirAvRL2QMqa3aWxg + nFUlzTLyJDwLhcLeaa3nmjcUGGGwc1Xdr3CWPPbgA9K86WOW6aV9m9by/DPtzGOKWkHyCMAKBxHOId6Z + m2rB76z2s74eJhOrnmtgAAAS8E384Jy7vTOETTLV34ZcVjJ+YJMLds6LakkfAp6A6ORXe3gTVSXQ2fV1 + 8ZocyXk3TF6LAiPOqIWPx6RbrS/71p988kkZfEsN+2wT7PSILNR2cbA8kxXJiIJ0suxRJCPPwP8jx3s+ + /pgFY7tFACdTbovA/iDjbZXEAJwZ1bW/BicOb7FsOapqY5Mbff7R0uneO+XniroYadtZ4OyQrpx2l/iL + AhTvQT3HK4w0veieqKU1A/RIkEGdrKiEagfhF1feqRaVxY+kecc7qFrOImRSeh5BkesZHxYBU6F1PN6q + UTEuwBANgcPFBXPn5tH/N1CBgfGfnTtkxm1XmX1x1q0KipOUeQI7IvjMtrRZt3pOly8rni0tWzQ3CQhH + y/446YsB43nzB71jqyneTsvKnZN3WgtOBjLrTK+tzKGSHCroRzUqmNGZ3H0YnlEnyHCDxxQjNFINNr+c + dlD4iTYSgsEe5Ak/fi9/3naNrvoeMLDA8F4mFKDC+cLtHn0kzpiELLktbHnpq7jUOHuWTFIpg216LE5L + 2uGIUSkmpA/yXBQUSd22+UsmkYKC9jMZjp5SadFOo+vdW36od7W1w+y1yiOcSYxqjXS1TMF0di1dANj5 + gbqo1/W8+TpTo5HC/RlbwpxM+5t454zbrzb1mOBtwC+RrZA4RjvDRQEKqe7VW2pK/ztUatQ2mdR4r5cG + LU8g5UrsWuya2GD//ihVNvVLlZXPRmV5c+0/Vd2XalndQb9/RYH741Rz9JgXPJ/vIWqA7OQzr/WkU+qN + Cv2EqtCMJTzPeBB1gVaUFz7PC/EMeJS+RpPiua6gpvMdv8PrBwOECwyMm8aPkszi3s4MdrCY/SowgSzE + Y2SqHcvISvTuNRX/e/i6djYS0P5gfjp3+ahfJb30Cba6rn5NGSeneEYKan86oTuoMMrkZ6bI2JJHS5+W + T5jHnFAZPOYEWBNGgvqMwwVmwSaamxQHMcDUDRsNTiaCeb/o10s+u7++DKl/rXx0S3X58IYr5fX6teTZ + Vi1tPziMibpOoHJ+PIHuXdyT9dZLxvCALk4StmDipS6oSm0LXqZKUzfpZIrtr3659hUm3RLXyal17Iz4 + oeXDMu6iEz3gJ5YOSUeleCfxAIpk4IEvkDRZMFl02NaX17Ou9wftWL5EplQ9R+sYMZubbQdMYCcFWACm + GWRb17Z9WuNiad+urYy56CQzLyBJbuyt80Ol5HyBFiV2PRIn4IwHnLr4CzbM+BEK+Xw+YL/ni1RZ0NBL + 1sI4jSlxtLS7+3YbS5xgjCMqNIk6GI+88HlOxHhumz5ZVvTvLXMfv0tmPXCDzHywrpYbZfq9tWxf/pLP + BsqaWTMsyoN35tcBWxhUIGCkgsvf7vvfgVex3ySywERjDy47LzJLeirjS/WuPyA2JIB2w6qVknl1GVPl + VumKniswxgqAQUZwpCtsou/ed5ttRQTIUe9wCMAkAA4SWX5NAFwLkHI/UhGSIAGzSKKozNhzABckVL5j + mxhAjCcQdT0/iwjvQsJE0pz4xD0xyVTLOSTMUHDMa+C3vyAtZqXIip5p5vnMODdFflYQaKUSBnFu1Jm+ + wnuJ+vXdu2/Jdw1vlK+vqySf1yhvORopQ6uVkYHXXCK977rZpHLME9zLNsCDaeDnfZxtw8Hy2NvWdErz + gDEEWFwB9JAMAdJhV5YxZ8Wg++pbfxMgTZzijo8jucZ0Hsiy86MiZvtd9rgKNyxSZ6fIeBV0XqhXyxYp + 4mZxLMKfLmYR3tuX8fifXTtlSY92klnq6P8ulthQyZFgf7Ueiin8lln1bJn9xeB4hApzZl/fnx8qEDAy + 4ea1vM8mGZ5VzlAJqtEUEjJsUDEd7+64s9Kk67137OVIgPkLmxC/t2xYL5Orl7U6rnpNV+y8AKNOerOT + Etd4qUqNei/2MkJy8JICZEiIbhVjoPIr6nMt/cczeBZMxy4CQARAAQjZSYNNkTAg+olDgbAt5lVadMS1 + 3MN7ZqqEO+b2GmYiMGntAjIhqZo3/b9t36s/ggVbrI7pZtKLldT+wcalEl/nerXNSE/iB+qOhIGJAamY + XRy0BXMAwM8WSiYdQEghMoFtn/xO+4lddAZ++ulAE+O5oF0TMw9YHsm3Iv91HIUVldJQY9lPjcQ47Ioy + Zod+WRe4kZedZ/3DArLwXpU8iSXMr9S4H4pJmip9LmmkAoCCku2L13r2u/5ysyuiqbDtD55nkcqrqSgR + cd+ejetljkqEvAeTA2BMWNDCB6OyvGVUljwalXk3Ryzrj3nkAc7yp8qkr7+wc44QJA4kTxQIGPf8vV2y + qhVXqSpF5j+qKyqJCkImFlLkugGeYfr3C06QZ5o3iwcquzRd+ZGA8koMxDaAUSVGwG2lqo55lRhpB8Hc + 8+7XATo5RYbUucxUf9TovARx54WoH8+A2ViJWSAAP4AXZxRqOgyJsRuQ4J1cW5D3cg8MZTkLR/4hY9hH + rcyJJzj9fJWI+qvkqOAYumPJX/Q3tgTuTE+VmXX+q0LjifYb6TE1UG/AmPFFK6A9SB4425COMUtgY6bg + 7eSEPBYGF7KFZLyv0QkFJWIC7QgHlV5m1ybcRRf9BGq0Ff0NiXH+XQqMeg8SI1oR5pfPuneSiRccacCD + h35NZ7zUes/BAEfeSV0VxDe/GpGZ13iORpPQdByJV2R3C6CO+YbFjEBueBNpLS927UTEefOz7qjugaIu + puDB0scilj0chxwhRWYa0LptfdtLMsy85fqfnnzEeApwhJ/2BaDzQwUCxo1//W7GZktf1FtBJ0EIiB8Y + fyx1iqlMeT0KYF9puwLjlOoXmnqzoi/b73LwSvuLtgMQBfBxGH1c61JTb3PbdVIQYoB5Fuo4Ki/2Vp7P + Co2ESP/4YzoLQryD+3kW4Dvu159ldM1yHpMq8006IyKLWqXJ32OUSXVBwC5soU2Mp6+wpZCUa3PvP8Lz + QuuK/suFJ0qrB++37ZwsHkwm+ghQpE0wMe1itUedB+yZbEjB5B7kLxIigdxIznihuf5ggSLvXPvtMGsb + wLjqae0T1OgcgAyHx/b3UyWrvCdBf3ZlaZO4ML9YWrzm3mFg9HVmqahs6KNSuqqwedmaV2hF34MaDwit + aKUS4rme6kq9KITQAYouBA2pn/FhkWI8WFwLOh7/q/fOf4IEwro4oGGUiMq67p5Daid98J5XP1cIdifD + ORsgcJ5+9uBtpmFiTnKO2gPBG/kGRiq1oG1jz3taIiKbvyYURhsVAjIGjO8pMJ4VkZ8uPNXCdMLS8+8P + 2qWAMk1Vx4knRWRxWwVvgs/zsiVOQWCnXjv3IQ8YB15fxdS9wjxYPEj0AcAHAwKUrjiG3Nc+4n5ACtBl + QRr94/cyqnYlY1ZzyByXKlMvi8rKfoTyeABJf5EQBHOIqduj2Hse9Y5cPRdpU1XoW+tYGirUY6RAogxw + mviTH/DXASRgT/8BgEgiFECTeiElAqa0e1/bW1Divcv79zEpil0oW99KHL/oCirpOnJJ6qTHmfROnSvN + RMDGBVTRkb//JmPreH0NMCClr1R+RHI0p8l+Bsft+nxMAUi+CwjEV0HBmUB+KXOSvFDPy2aFpAgoItE7 + mzaL6b4sUty35tP3vYWhqL6zeNRCkPYMT+wsQjpHcpx3kxeaNOCOG8yURd5VJ0zBU/ub8g2M/6OMO/3W + Kww0OPvEjtEMsS9SDBjf/y8wsiKxkqJWOcfL/iIm2YyHb7FQkTmx7Yp52ius1+yalCqzbsGTniIDa1ay + 2DpUvoO5d3dfCeClT5BGMQmM1gn7S6PbZEKJozzGVSZEA8C2yqFjeK43fhGVTV+pxN2DPeIqZeBs0WvT + tfSuc5VtFXOB+ix2MC5Sb3Ay8b8DfX7DPusKnwtzEdgXoo+WvfOS2bhm18oldVisEHNIfkMkMPaJt2/c + yBZSpBy86yymE0d8I+Oq/Xe7HtcuuFvnDgHd7EwJeW5hFdT8be/pXL1GFzXG7xwvW87Ay0tL80ZeAmiS + dqA+IykCikj3mG/2BRSh/+zZLdOuK2tOTOyvq9srKOYSumRHP2i/zLpG71GefOeWa812jbnlQG4RzTcw + 7tq4XqaqimoxcWTsCAnTcQVpY/0nukKp6D7y/OOle+tW5nl0HmnUxP1FSClznmtuE34qCQ0UvBMBeLwg + Lar0u93OWvFWuXdvqPavAEYIhgIckdoMHEePlq9f7Ss/3Hi5TCh9tLdH91RlSJ1A9BvSDYVF0AJ/dUIx + +XvXrWGgiMrIudpsFfMH6h9McNsXon+WvN3XgGv+3ZyHkjswEgM4q45qF9o/X1Y627a6MpFdiBUgQyTD + uN9+kT9vv9b60OVGJK3Xhj46h1RCsq2DAMa+SpCxZ7CFEZWdnJgEbrtFjbjZV6+rKk2bNrXQOX+uAtRn + JEVAkUVrX8dxS/oYlbyPtv6cp4IGqnxonX0F6XbLG0SyKG7oItL/Fi9Lvv/8ahbS/U35BsYt0ydLRplT + vG2A7yZInRUrHjB6Ksaoc4+Vnk82O2DAyMAu/vQDYf8zOxAsYStxlSH1jBdsadqe9R/qoMQSdL50503G + PKgY+0uVPlAEoztwRHJEwkOqQVL4+MVu8uk9t8h31UrJrxWKyk9lz1Ap/3SvlD1Nfqxwhu0D7tDofotx + I+gdUGQlx6t+MD3JhUUeMPbxgPH2aO7AqGrf9gF4V1UrKpoi/a+rYuYipC/2/9O/8AvFTBi6EP3Q/CGZ + UFKldF2E8MxOOicq8+7wvN+mXudyDESOBUBkq6U+Z9sHEVn0gNbrbE8lBZDJ/NP15utNdUZ7IySMA8fY + lovjCwcdqipzZ19t//Dayo/e9EL6tA6o0JbsN6zevoKEyzZSU/nPi0ife+rHbfz7+7AwP+ULGGnsmu8+ + V9U4auEeG4eriqrgFwoyWlCzUcUySkZl5DnHSg8FxgN1uDjgtXLCX7ZK4oBZ/bqCOE6iQPLZbIVMOyoB + L2rr7X4ZWfJY6fjow3t50g/nye8HR9QSJBqAjYmM+sf4vNazu/Tp3El6tH9Wuj37jHRp20Ze0L/EKWI/ + Y0K58BrudUb6fVW9DjYhiSx660Wzwc2sprydkyqtIISUt1ElMpdQmH3SLqEwW0Wxt9IvCAAsRHhWMSN9 + 26ebjKp6joEVoWy2Z14lpCWNI7L1nVRPglQQwbFjGW9y8IrjxLEA8Fjw95Y3U2XpY2m2TZcDrFwoDjkV + n763gcUoIumzJZfFnnq6cBhsw4U1hmaWeKOngfI0NLaPc7fXUliMZnH+ky4af5Q5QZ5p0TzP5/8UJuUL + GP9XGWf+M4+Zh42zWnI7+IoA781feinvR517nHRr+US2w8X3JzDSeesXzZeMsieaKjj7rpzVfgp7iDnc + f3otz/HylapGbq8yIFBY4TqHAsG4SAY4PXCCINGgSmErRA3EmYIDATWLbNr8ZcITYsPvLG6oNkgZBzO8 + pjCJcV38zktmEyOSYkMvvNK6mOI5DU5iBUYAbMEduvCqhMkC/MIDd2eL03V7vd1CBDiiVpON6evPP5Mv + m9wro8ud6qm4BDsrz7FXft7tabLq2TSTIi2khVAWlaR2D0uVXfY3VgBQBRKy6KzuEJG5db34UpO2CHfR + 544udYy8eW0VafZYE4sKoX5obUj6xJu6GFnqRz0LawytL9940QCO+MTduaVgY6EZXEQ29WOLrApeOgZD + Lytp6j6hT3lJuVeYlC9gJMaLFEcM4JzbY7tdcnBo4Nnk3BUY568SKjE2b5rNK52XszwKSnQenZjV8HrJ + UHGetGEbh8S2LiaQGskWs+Vb7wxd8hi+f23FfOdcPJyIdiAlMSlYickYTRuRjJnYeJmRKNjFQkHtZjLx + OxOqsKWMg01M5lXjRnpahko6JNu1fcgctu+X2pjEn6TI1v4KRGQWOjNVfip3mrR5smWoo4C+4S8gST8j + FNC/hK19+uZr8uXddWXshSfYe1E9UbEnnK7PLhWRGVdGZP5tEVn6aFSWPnGEqpkRWfVUqpWlTaMy99Y0 + L/mDAiEgZBKiPmdUyWNkQLWy8ux9d5uDhdhKJH22XOLhxSyEpF9YqnOQaO+i17pbnWZdq9I3+81zOmfG + vNGpMvcWz5GFlNun3vXmLQfIkbT3t5bpp3wB46axf0p6qaNNmlrRTUGGEBji3EJAxry7GSl2TjTXc1B3 + 56eeNJBhjzATa38CI8+lE+d9/I51Mqrx9BoRSxRh9aaO/rpjX9T6rnkNICfWS1Wj2280tQPJKa85Fw9H + oj0OIJH+MBcgRSINog5iD6bQfr5H8uE6Jw39W/qDtmzeuEEm31TV4xmdoDhISOCAdOZ2jOxRaW3PV97B + UjaJFYheurF6PBwNswRB7iyifsDxS+nYZFENsbfjWBj0Sl8Z+sDt8n210pa2bcL5R5jzAYAGXNg2Z/8r + YNpfLbb3XH+z8BvlV/KEfn7p+dKzXi1p27iR7Ubi8CpsdIALtmQWODYSMI770/xhZonXe9ouFzIDWeYf + 7TsWlb1AEelb+3R9V20PIU26OPyhCwXZllzCGRZk6gzPHQjKMzDSeau//tSkLwJVyQjNYe2hwKjfIX1t + HKYAQ7JPXcWGX3pePFwHNWx/q9IQnbh68SLJuKGyJwWclCozbtC6j4jaPmHzUrv6qxS5Z2oRWdRSGe4E + JNyjpM1jj5rjBY80trTD2SOdF2IsAAfaSN8BlBRsZBT+53t+/zcBoiOAC7CY98PXKgAc4/EMUpjy8Nyb + onZa4Nruqnm8mGoH5uOAZAH9o/Tx0vqRRha6lFviYj4DGvA+CwzzAOkNjcTtmX+jZ3d5o+VjMuCOOjLs + ukoy7Jry8nXV4vJdpXPkW0rFs+XrSufKEJUIB19VVgbVKCdv1a0uzz38gIEhe7VdRiieRwwuDhZ4mPex + 8DGe+3MMaePyrxXQLvDC3ubcGJVdKhHu+EgxIwCOFqLzic7NGrrQqBBl0mLdGqb6Y8bCY84iggTOcw8E + 5Q8Yv/tMVUzPvrjtT1UzEiV/VbDZPSVVFliuPi9uquftdbMZpg+E9EUn0pkzv/xU0ksc4TE6YQs6WIvb + ROXv0SoJqGrN0Qecdb1tZESmVFRm11WLo1xhMvbxHmjDb5IODsGL8CTSXObgD+OxhyzsqLeoq9geicvF + hgco8vtrta+wSQyvYH/F9groJVpEeQ98xCKD9IgtEgkT4LLEG/oMDoRjvzJB1zj/CBnrrsDbtUsXeaFz + J9NkKMQgAoLsPyfQHjBEK0Nl5jk8j+di20TicpI+i8D+nHu0b+PypZJR5Sybd9g95zdMMxtp/JgIAPI9 + FUi+KCKrn08z8wGSL4fkkQeVtoEXLooFDbOwVf5ElGdgpEIrvxpiOyWmlI/I1l8V/cMSniItjlOQ+S0i + ky+OGgP9etHJ0qrZE3slkGCA9idRZ1Zm1MGJr/SQcRWLGiOjerCDY+plETv2c/O3EdkwLOqd6cKKpQP5 + eq3LbeUlJAXV/99mX0xSOAFmLIAAyehffpbvnnxEvq9VSX6pUkz+KHOy/FbqZPml5Enye5mTLJv7GzdU + swUU4EJaZBIjlcEruS2ifoDE1gdAYmLChkvyDTQr7JBERKC1oFICeLwH8w6Fz4Ao8wqJk0Uc6RP7MM+B + b5lrPB/QR1g4EDzM3OOds959xVtczlFwxDehkiMB5yQqBiA5j2Zrf8WUcooVZ3hCVMfb6mZbaAglIuQJ + M8SBmn/5AsbVv46Q9OJHmHqx+uWIl7YqxJFBEoYVPVVaVNUVD9/LCjIHQyymE2F0VAc8yn9+NVx+fOg2 + mVAylvYIgzVAeAHqvkoB2i6+x1bTQdUSQlNgOnYDIEXsbwk3SQef4HPGGbMJDhRABkAivKXfC52kZ4dn + pdszbaVr29bmGEBqQ6JDssFzyj1MYsAur7zCdQ4gAVT4FX4DYAmlAeBQtxEosLXBj64AoHzHbwSUM7cA + Q+zDSK08j+ceKEB0xLsQStAMJ3VsZYBnkuMpCoJlVCB5UgWStyKytltUsioqVsTm3heVzoknJQH4WWhw + uuRloSlMyhcwblwwVzJVNAZAsipHZPso73B6s9PFbHXY7fBWz6wVMbWVnRLtHrw3nocR7xIDfqDEYt6B + PYVVExUH5h3Wr7eMuPFyGXPRCTLugqPkr2JHyphzj7TEtD+XO01evOMms4cSJsAKDGPCrIlUoyT9e8iB + FJMaCY4FFZshkhtSG9IafIztjsLkRVJzQdIAGrxdkEns3g2fAc48B6kL3gOo4WEiB3iHK3zme+oKICPt + AiLcz3Pg/wMJiH5CwqPugPWf3Z+T8RefHNfYMEtg0jLTBM4jBUUcLm3vbxg/+oQQOeYeAH8gpUUoXzbG + 7du2yfRYwlPE4hnXqUr9gweOZF9hLzL/rx+kjS8aseDVoVWLS6tWrWxbDwzkttXlZ0XdF+IdrJYwGQzE + io6KQl0+fOM16f9sa3mpVTPp1ayJdGveVDrooCAFIN26/a4HY8VK0sEjxzMsqExsTDEAJLyLlIaNHEmG + AmjyPTF28Bd8AiDtK29zPwWeoy48E3Bg3oQVfuMarj+YYOgn6sICA4Bj5/xx8ED5sf418nuVYvJL+TPl + p4vOkJ8u1qLCyNeVz5HnHrrXQJGQJ84Vp6+ROHnGgRCi/JQvYKSCi8f/ZecVg/zmQSoRkYXNorL+U8+Z + walxJK/FE5VePFU63VXPbHUYhAljwHbDKnggQYa6w1zUn1UVVQPVg/oAkKTix1vOVi7qiVpEaAOMf6Dz + wCXp0CAHSgAOfIMkxoLOJA+GMCGt8TvXFQYo/luIfqA/cPjQZ8w5pMDB7/SXN3r1lN6dnpfu7Z+Vrs+0 + k86qUeJAwtnE5gI0S7CCfj0YfZovYAQcYI4pn3wkExT1kRwRgwlvIRV8VpWoZJT04qwAzm/LF7VkAy4W + CXsIjHUwbHW8D0anDQAzKggdj+2GVR/vHfYkHC1IBEgBLuGqC21I0v89gm+QVlhYncQGP7gCL/Mdk/dQ + kdQOJaI/HDiyiGDOQmPDqQImIIS4XVXs2+Z7t02RuUf/HmhpEcozMEKAA6CCxDXm++/kp8fukd8vO18m + XHCkt42qaIrFOQKYP5Q7XZ5/4G4zUBP06jJgH8hYpDBioHg/HU5bAHoGDLsn7cIriCSAWsRqxXVcn2T4 + JCWpYOTAEXMW8405BkDiNEIoAQjdriq+Zy5iVzyYAkm+gJEGsjqC5ETPI10NG/CBfNChrbzz2IPy2sP3 + SL8H7pLeWjq28jaru+SXNBpP2cGwF4QRbXGqEuDHoGEfolDHpBSQpCQVHrn5xrxCegT4ED4QSlCz+YsW + B7a4WEuuP1hzL1/ACFFZgAPkRwIE7RF/iaci5g8gxHHBX0RkbHVcgzR2sOwFuRH1CZYkJSlJhU/MLTAE + HAD8EEqCJgkHiAdzHuYbGKksqiWNwSmB2Iv4S0ApEiTHX5K4lLAYbAl4owBFrqXxh4K0mKQkJSlJOVG+ + gRFyqA/Co3oi/qImYzsgbAFJkr+AJuKxs9UdTNE4SUlKUpLySgUCRkcOIJ2dDpDEoUHOQv7yme+Ttrok + JSlJhxPtEzD6CdCjAICuuO+SgJikJCXpcKJCA8YkJSlJSfq3UBIYk5SkJCUpQElgTFKSkpSkACWBMUlJ + SlKSApQExiQlKUlJCtAhAYw7p0+X7WPGxMv+IJ67Z9my2KeCE3U92PQ/W7ZYe/hbENqXfs5vP1LHwu6z + fan//qZge/elnocCrxWE4I/CmGsHkw4aMG789FNZcPPNknXSSaFl7tVXy4r27UM7eMv338vi++6LfQon + 7lv39tvZ3pHbPbnR6l697Dm5MaxrW14pLxOAa+gP+sW1h/b5ifpRwog60X53LyUvdcxLP1I3vgsDauoz + /bzzYp8KTnmtfyLeWNasWcK+CRLtKOjEdnWkT6gz/xcEHPPKaxDjQ7vd+NMvrri+ovCZ+nHtvhJtgx/D + yL3ncKaDAowwin/AmOxOCqAwuP5JwAD4J537LUhcw4A58GBCMiFgBJhnX1cxnsdzeUci4h2u3nlhaurH + tWHMyrPoi1kVKtg1/KUv6CPaEwQi6gdT+olr3f3uGfSfmzRhdcxvP7pJzN8g7Qs4QPmtfxhvuDrkFaDd + +1z/Ugc+0/bcyNXLjR3/F6TtiXiN5/I86sLz3fv8he8objGAZ3ie65uwcYLoS/c8rue6RDzsrgtrm+Pp + w5kOmsTIwDLoMCGdHEYwgRtMJqljVDcojvwThcL/QYbaV3KTi5JopYTcJKLAIDkR7XPXOmblO+rvlwx5 + Tl4mF9f6+9JfZ54RZPIwUClIP9IfXM9YBsn1R17qH6T81h9y9fcTfeuek1t7/O90dXb3JwIUP/F+B8Du + vvy23V+HIK85wAwW+j4RiDlyYxHWDv87g4VnB/vN8WcYj7t2H8500G2MdGBOQAMBolznBtQxhyO3wodN + nsIi9w4YgpKIkKq4jjq6CZKIHOhTXNscWHIv3/E5L0S7uc8Bo/85eZ2YBe1HP5gG73Njl19wKEj9Ia7n + Pj85iYnv6fNExMLr+sBfZzfR3RjlRLzHjYEb3/zyZE685iRFgIrnOrBz78yJgvPIkeMd3kWd+Z3nwsv0 + nZ8vHPGZQnuD5Np9ONMhAYx5YTiuc4Pv/x9yE3N/kQM7GMMxV1CNdURb+N2twMGV1pGfofnr7wP3fX7I + Pc89x9UjTEVPRAXtR3cfkyQoQbh6OJDJKxWk/hD3BPuOzxTqxu+JFhv3TtceV2f3PX9zIgcw8AgE0IQB + R06UH16D/HyUG4WNhVsMKDm9x/Wd42f+d4tNkMdd/x3OdFgAo2M4N+n4388IwYFggGEqGJPv87tiB4nn + wwRMKMeIiSYsq6Vb5WG2RBIKz+R39zz/dcH28V63cieaaO45ri/dBOMe+iIRGPipoP3o7uPd1M8/wcIm + Y16oIPWHuMffdxB1ov94Br/zvCBRZ65jHPjdf51rQ258yju4ztU1rC65EdfnldegMP5JRGFjkdfxoX/8 + 7XH/u+InPvP74UwHFRjdoOY2KG5iuuv438+kbiD43a1sFO4LmwT5IVdH//v4zCSAYGDe4UCDujgmdUwX + nNTumf7V189c7jO/u7ZReG6iSeKe6foI4lrXdxT/xA/WCSpoP/I7xYGL6xsorxMvjPJbf4jr/GMF8Z2r + P20EbIPkHyvXl+45eW0D9aO+jrjHLeZ5oeB7IT4n4jUo7J5E5NrhyI1XXuroB0b3P/Vy7/fzpeOjw5kO + eWB0E9TPHHz2M4IfPNzETDRx8kvu/TADxF8nuVHce93E439Xt7C6Qtzvn0DBz+6ZFCcxufcnIkCU68P6 + knrAuPSLv694dhhDU/LTj1zPvRB15bObvMHJWBDKa/3D+jvIY2H95O4L8pj77NqUE5+657rFjvbzOTj2 + OVF+eQ1y7cvLe9zzHeXEM0FyfcDf4DtZrKinqzdj5PjhcKVDFhjpZCct+Fc0d49jQIhBgHEYqJwABGbl + GjdwuU16N0GoR3BSUviOerj6826+97fH1c1RGDO65zrifxjN38Yw8oMF13Nfbm1yxL2uf917XF3z2488 + w4EIxHcO6LnO3zbazXeu3u5arqH4+yonCqt/GG9wnf/9tIt3OKkegr/4zt9m7qFukHsu9Q4j7nMA5ii3 + e4KUX15zlJ/38Ezq6YjPeelvxpvr3Ji6d7pFyfWp4wGe6/rucKVDEhj57Ca6HxShsHsYlOB1jhhUBsw9 + j2udOpbT5GfQuZZ7XOEZPMtNtrB6870fnNxK6yYrzwgyDc909zlJwz+5/cS73UTmOp7HZ57J5/yQm9Cu + PgXtRz77JybtcM/ie3+9uMfVm/fymWtccZMtLxSsfxhv8Eyu8ZOrA/V0gMR1fgIE3H28h2u4L4zc+NEX + jlxdgs+FeCfXunGj5JfXHOX0niC5dzniPv/nMOL51I0CD7jvgnVy9YRvg+85HOmQAkYY0DEZA+FnNEdh + g8JnP2PwHAbIL4nA1PmZdG7CUw/q5JjCEYwbZEZ3j5/cxHMAwP/+ukPuPuoX1j6ewb28k9+oE5PKXyf3 + 7PwQ/cSzHBNzf3770dU3COR85nuez99g/xUGBesf1nfUNzhJXd3od37jGTzLT9zHNe571wfB69yznDTl + yI2p60/G0L+wUNw4UtznvPKaI9fmRL/7ibb6+4L7gn3jJ8dT1CuM12iTn/ztoBzOdFCBEaIjYSImm2Ma + mCzRRApjfj4zWAwUg8OguAFy3+eXHMMHJ7wj3hNkKpg6jNGCgBYkP3P720dxE5TCc6hPcHJCjlnzSvSv + q5frS/7Pbz/66xskVyf33MKksPqH1QVeCr6bdnCda1/YGLu6u2c5fmCMHTnw4zlBfnX3M37+hcXxgH9x + KQivOXJtzkv/8gz/c1y9/HWHt6iH61uuD/Kba1sYcT2/UfzjcLjRIQGMwQmYEzlG8DMWn91Auv8TMVle + CWbkWWEgBPF86usn3hvGwEwmV7ecwIV73f/+9rjvcyLHrInq64jfXX2o/772o6tvouv4nt/zMnHzQjnV + P8gbDgDD3u1AgTaGketP/72ub7jX/U8dwhZxd78r3JOojwrCa45cm/PSv/AR9XBEP7n68RvFfc5p7F3b + wngZcu3JjWcPZTokgJHCoCTqaD85RmAlduSYHOZhFS8MYvL53xEkN+ncpHD1CmPgsDr7yf3u+oBn8Bnm + zCtzOWZN1H4mAQzrns3/wYlYkH50dU80MV17/ABWEMpL/YP97PokrN9z6y/3u79dfimVv/yWCMwcyORl + DPPLa35ybc7LeLk6+Z9Dv7pxp1CPRIDoyPVNonbxTMYpL/P5UKWDDowMln8VywvBBP7BZQAYzERMuj+I + dzlGcp+pV26TIIwceLhJyDPyCyS8P6eJ6mf8RAxbkH5kHHKaJIVFeak/5OcNrqNPcro+EdH/+9Iu6kBd + 8tOXiYhnuLaHUU7j7idXp30lngG/FkbbDlU66MB4OBMg4gfoQ5moa2FN1INBh3v995UOJ177N1ASGJOU + pCQlKUBJYExSkpKUpAAlgTFJSUpSkgKUBMYkJSlJSQpQEhiTlKQkJSlASWBMUpKSlKRsJPL/BygdsEvv + QNuiAAAAAElFTkSuQmCC + + + + 0 + + + NoControl + + + NoControl + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + label7 + + + 4 + + + 11 + + + NoControl + + + 21 + + + panel2 + + + label1 + + + True + + + 111, 97 + + + 9 + + + logoPictureBox + + + System.Windows.Forms.Panel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 21 + + + Testing: + + + NoControl + + + 20 + + + © AntMe! GmbH, Tom Wendel + + + $this + + + True + + + $this + + + 19 + + + NoControl + + + True + + + 8 + + + Patric Boscolo + + + 1 + + + System.Windows.Forms.Panel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 85, 13 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 78, 13 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 92, 13 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + panel4 + + + label25 + + + 13 + + + NoControl + + + 111, 80 + + + 111, 63 + + + 6 + + + panel1 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + True + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 15 + + + Top, Right + + + Thomas Wendel + + + Microsoft Sans Serif, 8.25pt, style=Bold + + + NoControl + + + label4 + + + 22 + + + 3, 32 + + + System.Windows.Forms.Panel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 11, 148 + + + AntMe! - Infos + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + label5 + + + Prof. Dr. Andreas Judt (BA Ravensburg) +Dr. Matthias Utesch (HS München) +Prof. Dr. Johannes Heigert (HS München) +Prof. Dr. Thomas Fuchß (HS Karlsruhe) + + + System.Windows.Forms.Panel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + label16 + + + panel4 + + + Art Director: + + + label3 + + + panel4 + + + Website + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 108, 46 + + + 8 + + + Relation Manager: + + + 0, 0 + + + + iVBORw0KGgoAAAANSUhEUgAAAIoAAAC5CAYAAAD3aadnAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAACXBIWXMAAAsBAAALAQE2cE9bAABcmklE + QVR4Xu3dB5heRfUG8N3N7tIJgYTQO0hTqvSaAKH3ItKRpoIiICAgKIiIIEiX3pUmoCjoX1ERC713aYII + oiA91Mz//Gb3LF+WTbKpJJh5nvN87d773Tvzznvec2bu3KYyuUwuvSiTgTK59KpMBsrk0qsyGSiTS6/K + ZKBMLr0qk4HSUIYNG1Y++OCDau+99161999/v372G/tfLZOB0lmAADAuueSSctlll5U333yz2ltvvVXe + fvvt8u6771bQjC5gcvsEYCPoRuc4H3eZDJQoGgxILr744jLTTDOV9vb2sv7665ef/vSn5aWXXiqvvPJK + ef3118vQoUN7DRi/JTP985//LM8991wFnWMAnu8TNJNC+Z8HiobS8D//+c/LlFNOWZqamspnP/vZMv/8 + 89f3K6+8crnuuuvKv//97woYLDOyhvaZ+f2pp54q+++/fxk4cGCZd955yy9/+cvy8ssvl1dffbUe5513 + 3qnbTQpg+Z8GigbS2E888USZbbbZKjDWXHPN8uCDD5YHHnignHjiiWWeeeap33/uc58rd911V2WY1157 + rbJDY0OnOR7WOe2008qss85a901raWmpru2FF16ox8FSCbqJHSz/80DRqBtvvHFtyDnmmKP89a9/Lfff + f3+59957y3333VfBcfDBB1e2mX766cspp5xSXnzxxfLf//63q6EdQ2MzLmbLLbcszc3NXcc87LDDys9+ + 9rOy0EIL1e8vuuiiut1//vOfSQYs/7NA0ShczlVXXdXVqOedd14FyT333FMNqzzyyCPlscceKzfddFNZ + Z5116nYbbrhhZR0Nne4Iw9x9991l0UUXrduwHXbYofz5z3+ugHO83//+92WBBRYoffr0qXpoUgLL/zRQ + NPASSyxRG3XbbbetwEiQAMLf/va38vTTT5dnnnmmGs1x9NFHV7E7yyyzlGuuuaa6EY199dVXlwEDBtRj + cTlnnnlmPR5mymN6/4c//KEyS2tra7n00ksnGbD8TwJFQ2gQLgCbaOC//OUvXT0fSB5//PHy7LPPViAQ + sv/6179qowLMb3/72/LpT3+67vvd73636o5pp522goQQvv7664djJu8feuihLnb605/+VD71qU9VZvnx + j388SYDlfxYo2GTJJZesjbvvvvt26RIsACQaL4WrBhSp+Aw4//jHP8qjjz5adttttwqWtra2ehwR0s03 + 31zuvPPOqm0SdMlMgMeA7ZZbbqlgmVSY5X8OKCqfNvnVr35VG7l///6VTQCFAYDGBAq6g1BlGg+4aBJi + 1jYSc1NMMUUFCbBwRTQJEABLI+iwktCYee8722Ez+15++eUfAUvmayaG8j8JFGHtRhttVBv4q1/9am3Q + dA90CDejsQAkcyUZ9gIPsNxxxx1l9tlnr8fADDPPPHNZbLHFKjsAC0YBOuwDdG+88UZNtjHH9t3zzz9f + tQ23BTAirmQy2zjPnnI1H0f5nwOKitfLp5pqqsoG//d//1dBAixchIYS+urRjY2UYNF4XEdGNxJpN954 + Y7ngggvK1FNPXWacccbKDtyO/AxXxW2lO2GOATgAIWt74YUX1mMRuXRSgsU2jWD9OMsnAigqMRsyG6O7 + oXGmkY499tjaMGuvvXZlEUB5+OGHK5twK3qzfRobpxEo8iT2BzQAwSCimbPOOqvmWrALNwQoWAMDYRLH + dIw8jwQL1jnkkEPqMdddd92qZwCIm8Jg3c/l4yiTNFASICpSzxVRMNGFBiBEU4zSF6kxMiQ+7rjjurSJ + /egOjZNs0ljyf4THmXc56qijqguiNYCF6xAW+61v377l29/+dmUfrqw7WLwCi3OjWfw3kNj38MMPr2Bx + TY37fZxgmWSBotJUOEDsuuuuZc455ywzzDBDpf5+/fqVxRdfvIaqm266afnyl79cU+p//OMf67iNsFTP + 95noFO2k29EwGtCxs2G8YgFJt4xwhgwZUvezP7DQJNwG0H3+85+v2wCUsZ6eGj3BApTAjMluvfXWOi40 + zTTT1Ojp73//ewWZ3z9ucTtJAiVBIkIwNqNBsASXsN5661X9QGACjvBToxlnkYYX5fjs9YQTTqgDdRqa + 69H7AS+jHQ3jf7zSGUsvvXTd1wjzb37zmwoOQAEQLMbVcF8Eav6vczvjjDOqLuJOgCX1SiNYfM9NEdf2 + W2211epxnVO6w+4AnpBlkgNKgkRDomoNscsuu9RK5T7kLW677bZqN9xwQ/nJT35Sjj/++LL33nuXQYMG + dY0QM+DBQPIf3/zmN2uiLIWkXsxVYQDA+c53vtPlcr7xjW90MQnRKrrRoFiD+S4BybCdJBvWAgbHbmx0 + YPEf/jeTgGyTTTapAHRs7inF7WSg9KJkxX7ta1+rlbnddtvVyuQGNJwGNObCgAdw/K6no/YcJTbfhPuY + brrpukBDnC677LJ1EJA41ZM1nuNgJ9uJTBKI/svxuRYNCQCYAVg+85nPdAHFee6xxx71nLCObYHQdbge + BgD25w4zN2M/rqs72+V+E7JMUkBJkBiJVYkrrLBClzYAkpGZBtVbAYJb+MUvflF7t4G6733ve5WduJRs + IKHuWmutVc4+++yy0047dTX6kUceWcUr0AEnlwIYqSOSGbBB7sOwijCahiFcUwslULg3+z755JN129wP + aLAisOR+/mdCu6BJBigqReUQeCqSy/j1r39dw9vbb7+9R3A0Wg7oqXzJLW5GDsVYC00hUXbOOeeU/fbb + b7gRYMDK9wsvvHAVtHo9sGh0bAIYKVIxAz2TWiMN+I455pi6HxeEVQAjBSoDAMdaaaWVhtsXO8keY0bg + plcmtAuapICicrbYYotaeUJPFd4TKBoN3dMuQtcMP5lsaCMIGBbhmkREjd+n0R377LNPBahwGFC4hAyp + NTqw0BKmEXTfXwTGpdmPFsJC2eB5fZJ9m2+++XD7AZk5LVwd10XET2gXNEkARWVohHQ5RKnK5nZ6Akda + JtPkJYSdWfF0iV4rslhjjTW6bNVVV63fGSyUnjddIKOXxkZbZJFFqo7BZBqOlkmhyTQiN7HUUksNt68R + ZyPPGhwTJcCysTU8NsrwutFMzRRpJchsl65rQpRJBigaQm6EqBTS0hw9gYNpCCxChwCVipayT0EKEBkh + qfhGk8q3P/fyu9/9rg78/eAHP6gjzKKjueeeux4DYJZZZpk68Umj52BeRklAQMesuOKKXY0933zzVaA4 + R1qEm2kEis7gOrFl7pPm/0RejkkXpevijidEmeiBohL1NLkIlbXnnnvWRu4OjrQcjDPfNUNUDUqH5LQC + uReahVuyD2Ck5TGEuDlNgJB0TNtzYeeff35XaE4rmY+S6X9iE2AyL2JfIJPnIYoB0HFsn9omG9urxs+x + n0bzXyInGsk5pVaZUO5nkgCKCllwwQVrb6YNMhRuNG5Aw9IteqSKVcGbbbZZF3hMQ/QdMWzuK9fU/Tgj + swQQUcmAURZVJvjKK6/sioDoDEABBC4IWOyPDbxqaN83Dj7mtfoMcI2RVhqgYDnMZ3yI+0mNM77LRA2U + ZBPRiIY/4IADamM0Nl5a9v6cTKRiJdk0KNfw9a9/vabus9JtIxGXjZiGVQCiuzVuw3zHfXzrW9+qx5Nf + kXbPpBrXAyxcBFA4b+eCDZ0PMGTiLRvaq8/2s4/By+WWW65qJXcDADdGSaDYbjJQoqgAPUy+RK8Vbaik + 7o2Wkc3OO+9cAUCAAoHvNI5h/wRIGtAIVxMoWMq2mAfTdDfHYsAIlPYBFjkcjel/sYDvCNwcCGRAAxgA + xIAHG3SPXLz6LBlnG8fxP0SsaxcxYSXnaTigMWoa32WiBgpxh2o16lZbbVUbMXVEms96drobICE+9WCN + BgCiJY0o60qnbL311jVvQrjaRsVLseuxn99xx7LS6quXlUMErxK2WuiZQYMHV6YyWmz6ADeXINSY9gM+ + bogWAubMpHKbGt6rhmXe0yYamdtpbGifdQ5A4sZch+M5Tx0CUDESIDVmd8d3mWiBkr3r0EMPrQAw+qth + GkHCUD1msA1AYRLfJaA0arKFymZYBEiwge9NkJ5NNBPH0OCtYVOHtYc1spDf2yN6kngza5/A1sMJUwOG + zsG4E8EL1BoaKDQ8UDCuxatr6w4SJa8bkIAFE3FDwMG8BxKAc9xM2I3vMlEDRWWJUORA+ObuIlYjy6y6 + fULyrDtIGq1Re/isl/rOHYAaeLoAwufDjgw7o9NOCDssbK+wDcIWCgOiBI79FgiRbZBQIg5QCWWDkXo/ + Vuk+W667dS/5PbDYD9C4L+zEHC/BN6HYRJlogaJi+WGZUnmPpN9seIzAZ2uYUYGk0TCMY2nIITK10djL + RaP/IOygMGDZIeyYsEvCfhx2UdjFYWeHHR22S9giYY1M03eGGbrEMoaTcueeMAItouf3tiRY7IN9gEKn + Yd5jpREx0vgqEy1QVIScg8o3MakRBBoZu+SYiEG93oCE2Q/ghqy3Xm3gQbH/EWGf1uAN1ha2bBjAJEjO + Cju/8/M5YYeGDQ6bMqxxX24pw9hM1Y9J70/AMKBIa/x+QpWJEigqQE/KJNv3v//96vOzsQlIs9Y0ityC + ntvINiOyjI42M5YSx10j9v9G2PSdDbx62NfDDgzbO2yxsGnCtgw7L+yCsDM7DXAuDAOa74QB3BRhjkN4 + G3T0n5lYa3Q/k2KZaIGCXo3RAIpMpRCV26BLcnKPydGEaYarIzNsY9+v7rtvBclS0aA/CVuys3G5nEvD + uBkA4HaA4Gth/cPoE5rF7wkWhmUAyPbc0rxh5rnQTqYwOL/MogL/pAqWiRYo/LHBMZOUiUM0zm2IKAzY + SUAZsu/NXBQA45pMfQSwgdGYPwy7LGybMO4DALDEuWEA4jM3c2XYj8IWDCN4id1GZmkEDD3z7bD5Bgyo + 52gQ0FQGrPJxjPiOyzJRAkWvkyNYZZVVhkvbczmZ2jZYp7cCQU/gSPO73IMBwhmjAbmHb4YBgwYGjjTg + ACDswi0tHIZ5dgojdlcJmznspDCASpAAks+YCCutHOYcgdIKCIR3ZlK5oAkV0o7LMtECRRgoLS4ri01o + FODQAPQJrdETMLobt4R1lu8cxf1CmMZsZIJkkp3DuBnbdTd5FYD5ahgXZB+CFrvQL8AnjPb93GG5nyUy + MJ/zzbwKFzQZKOOgoGdJJUBxywVGoFFMMzAXhHAlTHsCRnfjcr5+4IFVl+jpej1wJFCYxt4vrDlM484Z + tnXYV8K4nNUGDy4Lds5646YAAyMRwpuFcTnrhPUJo2mw1jbbbVdDd3NzTS1wvhJmOQdFZ5iUykQLFGCQ + Etcjc4BMQxGyOT4zKiNesVDbVFOVWWLfk8M0ciNIGJcjN+L4K4QB0k/DsM+X99679n6Ry1c6pzcuHUa8 + inZ8BjKhsvdzhHE5F19ySU35myRlthv3iVWMAXGro5NXmRjKRAsUolXG9Ytf/GJ1OyY+y9ICSW/yJV0u + pzPXsn8YFqAnugOFuzgxDDvQIrY7LmyjJZcsbzU0KMBcdsUVZdrQOsAie0vHLBpGGAuR/VdGajmyvP32 + 23dNrO4+BXJSKRMlUFQiv24GutsyZDol3tzlRxj2BIzuxuUcfsQR1eUQod3D2u4GLABCd3BPW8Z+x518 + cucZfVg07qabbVYBACAbhrWEARbtwu0ACuaT1redCI2YdotHTzPbJoUy0QNFlEOr8PWouzdsoufeGLpg + xoEDS9/OBkyXQ7QKe5nvAKQRMNyO35aMxr4qwvLuxblZ3gIAWCbrpP2vCvts5+cjDj+83urhvSEGrtN8 + Fe6QqJ2QI7/jokyUQJFs43oAxaRi9/uavNRbbWJofvc99qiNtGMYPYEpsArQ0BbyHd8Py7yJ3xMoAPTp + AMrlwQLdixC9p1n6XJEEnqTbAmHb77rrcPNg3HJB1HKJNJdQ2XVOBspYlEagqGSJq95GOiKka66+ukwd + jTlP7KvxRTWnhg0JmyFMwk1jyonMH7Z5GKELLMkoSwRQrv71rzvP6MOC1brf5tEvzOgygGUSb8kIxw/4 + +tfr7yKiJUJvGZLAlIAsqpuQk6PHtkwSQNltt916PeiH2jfedNO6n5xHpuWFxrOHCXkN9BGvsqwYRzgs + sQYkwAIoxnk+E0J4pz33LNvsvHPZKyKeiy69tPwmWKH7QsNGn4HR/v5rnzBCvDVMFETzrBdmsNCIN51l + ZFxOZVJxPxM9UAjD3rodbGKSc2uEw5hCo2tArkav5264B3mPPcLkSugKrHNw2Olh3JDfAMDEpQFhs4bZ + vymYpGXqqUtTJ4DTAI3WSf1jNDpzMoAp1N4+zIQna8cBvJxKzlWZDJQxLICiIueaa646V9ac0d6M6XAL + uwb7ZANpdD1cxvRTYRpSr9fDJcZsJxsLPHQMwAAXpsFGIplkGaEwJpJbEUURyQkUI8zfCgNK/wkUvl8z + zH+xA8LkVERDcioYclJyPxMlUEQWBtFEF8QsdhnVCLGxIA0wcM45a3JND2eAslvY4mF6u4anJTT6tGFc + w6phXBGwABPTuBkVMWDxGRAYUbxrGB0EFMJiQtZv2Em6H0PlfkeFmbdibi/3g/0a780Z24KVRmTjoky0 + QEHLFsWxHprh+lExCjY57vjja95Ej9ZgGAI4pNqxgEYDFA3vN1MCMAchihU2CTPgl4CxTU+WYLMdpvly + mEHEY8MaAZX/4ztimXh2K6oR5Yx+xvbeHPthJGBzHGyc5rscgBxbwEyUQHGBxkSM7Yh4AGFkEQ+fT8MM + WnfdqitkVxsbWjYWY+RnpiG3DVsx7JEwrsOA4FRhMrQaFhBSpDbu22hAgH0agdHTNgAIKJJwOamJex3T + MDkbX13pRKeeemq9kd2wARA6buPcWmAaG7BMtEBxoW6tMM3ATHeupTtA0kQR7kdum3baGr1o3MaGSp3R + +J3PAIRVgORfYTeG7R4miYZh1gojTIEOENJ1NR4nbWRgwjD+T1hupQIZZtckJzOmWVrb20/m2piYkB3I + BwSjLhKi2bCH+brqcVzMg5kogYIu9Ybdd9+9pu7duqlSewIJUynHfO971e0Id9PtjMowwSFhpgX8POzp + sEfDAIa7kmsxvYAOMUdF9KTBHZ/2SQAASXfzPWBhJdsRwXSMR754iJR8ypgCxbYYwj1GokIj3HuGSSAa + nJwyvsMwji8LzL35j7ERzRMlUFyQXkDEWoHAbDGMkTd1dQcKfbJ954Qm80I0UE/A6Mk0pMjHrHrJsr+F + 3R8GMHeEAdNOTc1lrj6tpb2lTwWVBBpdAjhcClCkCE47JQxTAa4xIeEy0JtLk+M+YwMU7gqbcLXfDRO5 + Of99w4DHTWnctbGlxpvFxrRMtEBReSox78KT5HIHoIQaPZKA8fpQfF518OB6z40ZahquJ1CMyBIss4V9 + LwxIHgy7O+yhMOD5a4DkmGn6lcH9Zi0zTTl1ZS9RjEyvnA2gAYREndfuE6CsUun+Z3coNuZSRkej2IZp + cB1JVOh/MRYWk1zcIgwgrXfr7kfzeHLEOv8nbXTKRAkUF+GiVKLIwCRrPlhPMbXQ/A4VwOUIM013nD8q + TUPTHSMSlSMzYOFuHEMU9Muwx8MA5q6we8IeDma5cYaB5ei5Fyvr95+5LNV3+vKp0EUzTzllmWGKKUp7 + a2tpiUbSUH3b28ucU01VBsQroLjlROLQeiqiuN5OOchG1XkARL2ICC2loT4MP3CFdJlwXHJQpGhyt/wT + VjFnF6ukuPV/jjU6EdFECxQXgi5doOTUySef3DUYpyHMTXHTF1+vd/abbbZ6bw7toHf1BIZRmX1FO27b + IDxFRTK3WOWxMKDhlq7oP3c5ap5Pl61mnqVsOKB/2WTAgLJR2Hr9+5chM81U1g3bMD5vPXBgWTSEpnM2 + UVyyjdtxzo0JN9faU2MlQDQst2uQMddaARJZ4+PDuBznv3yYujFUoDMZvTZqraNZv87+ucoC0PhvwMv/ + HxlgegWUPEhPNr6KCnIRepzEFJeDtrsvy2m6ofto+gdQNC6QaPDuIOit0RfYRbSD1kVAZr25tRTLPBD2 + UOiVH8+5WDl27sXLlgGWDQIsgLJxGNBsGj1603gFmhk6l/ZyD/UVV1xRJzCJ4BpHkF1r96JuNaCci4WW + ZahzMBJAVguTOeZuTMoSvfnNOnQZLXpvn7Spor6svMCFd19VARiTYXoqIwRKAsHOTtgFoS3mfdKXixwf + gMmK8n8qFE0Di+wrGh/RgnxYJWfZj46o7W6onO8HGAOKUvYyucBjdPhLU/ct+826YNl94FxltWjENcMG + hXm/tJHrcEdTdTYscHteoWiHQCe+c0pk9ubGkvX+ox/9qK7OQHsR0SuFEdFGwtPdGCbIcaVGM5lKhtr0 + B7rFdE2i17kPDMAsv/zyNWpSr7RgY86lp/b8CFBslCcKEHqAtLO1R2QV3VOr4fT0pK6RIXFsimM6cff4 + JFhUMhGrd26zzTZdCwwzI7bWTOsfdM99GATELqNKmo3I7ANs6ZKMCmssiTMTqf1nnxC5mK01rC2sT1ie + D7N44Omnn161SbKJm9ddj4bpqd50Pq4Ji8wUxzg8zLmIwFiG5K5r0zDnQ1u5mc1UCkMWOovIyzbO336A + jy1diwHRBaabriYAaZhc2Mc59dSewwHFj9k4Hi+yVtDU8tErtg4zdrFKVMJ0Id78hroSiUmfPV302JTG + 80mwyAsIK2UjsYteahE8c2uPOOKIqgM8NcNiwjOGmAQYuRKVpBdyLWMCGo2jsh2DWKYNuCMjzYYH9OBG + gFhKTCiMSYDaQjhCYgDQKCNjE9/npCdi9fKw7gI9Ix2NTsR6L0Smqdy0ZoQcyO3X/XrVgW2E+f5DJled + ckUjWkb9I0Bxkt8O8bNOgMLAGUSqHObP0djcc81VBWQuFjO+p/XleUE7YLogPl7UQ9VjOZEEfy49Ludi + 8RyhdV3GPACzRJy3pJcGdk16lorM3tmTqWS/2y7rwHuRlRFm0x8JSFMQ0L9pEfTBXnvtVc4999wqKD22 + 33kRsMJ6rJhs0pM28Z1OQawDX45KNza08zAoya3IIAvJTfI2uLlV2JfC7Jc3qiXA8/xdO3DRdFjYYgCi + sNRNPZ1bF1A0Bspx2+Ua4RezIlVYohCynWDfABEqzRjdwZNVxldxfo4P7VxesguwckfS+HoGAOu5GkYe + Ad3LKRC8wkbi1CoFbs/Q2CpM70x6Zt67Xtetx9rOTevoWuMIQdP1eAiDeSYEp8gCgxDdAAKwRoq5SvrK + 3YKijhFFOtkhcmGgnKaQbcC0ieU5NLL/J7Tpj+3CzIsBVil9iThuS9YWgNxoT9/QKVyyXI/9uUZAdo55 + Qz2gjhQoTtKwvp5CTeetDU5WhXE/n2prK3vuvnuN0TVKzirv6eDjuiRYkl3QJMCgcoDVIySx0CiKl2MB + HgISYNzj86UvfakONFp3dspwqdjAXBWClalUI8GfCVPx/H/jyksawqx6t7t+4QtfqEtuJDi4GEwmoZbr + rempzoerdq4ZYbiORqB4r6MCOKEOCOociBMk2sFKC9iLEaYAjSmwPZH7qYh0rO6N1ayxC8Q6COao5x+W + iwEZdHXu6RYzUzxKoGAFAnH1QDNGgWSvfDwF7eAmOhO1tIEeq6eohMz8udishLRxXRyzETAq3/9rCBf6 + 4vPPlueffrA8/WTHAn30jIqwapNGtM6avAyxyCUZyzGglmDAEsBAZ3AlVk2wMpP17QGDW3HfjocZYFZ1 + 4bjWRKGbdCAgVfEAbG6N89MAzrk7SBTfCVX9n3MwsYqOSJBoC26QLuJm3DBPsGJ5v+nUgIT9Fujbtxx4 + 4IFVRHt8neiJbrOqpmmlrkdeB0gAm9vWoTxnYER3Mg4HFBu44HlnnLHG6ISR0dTuC8VAbOYE/EGjaqZX + VAjQjKhSxlVpBIz/A5i/3fv78sqVS5fXfzJ7efXqT5eXbxhSXvrFoPL8teuUZ3+5W7ni5L2q6FVZCwaj + 6JF6LZdqesLS8Z0Vniw9+sPjjixnn/m98qMzT61ZVSIec5humcyhkmkk4MAegInVzIkFkMxTZCdyzt3r + w2fXYIkvLseNZBpftNMY4RCfM4YZIU/xbO4N95liV8cGoIHBLK4z3SAwS/Yx741gJ/PJbNN72eFHKmb9 + ACh6pFWZ0TAX1Ei7nkphzGLgwIE1Owj9Vlrk54gvK0TrbY7RmMgZ32DRAAQuNvz07FOX/57VWt48o638 + 55i28vyBHfbqKW1l2KWtZfuVOpJPRoZ1Bg2gkrla/n+uPn2qj5+9X5/yyMkzlrcu61deunTm8vRFi5fb + L9mh/N9Vp1fBjD24NGKaSOWCsYcOo1dm5tP1A4Hz7KkO8vzdysGtcXWAYXDPqk9my10dBsQ+cx1GiBmQ + mDuT10FbMeDiutwLBSQAkU8E4Q4ZhqVLsC037dwNDTjnPN/G8hHXg76tR+KmK3NWZQElmZzkDjvuWF6K + SlBB3A6avTcY5Rch2hZceMlogNh2kUVqulmPSuHWE0LHRXFMIMRoHasytpS9tl0tGnea8uxureW2Odur + /XXm9vLsHn3KB9fMWDZabb4Ker0zIwKvRJ75J9kpTvti3/Luca3l0Q3ayz/2aSv/PaGtvH52e3njgunK + k5etW2767XWVRYAEgxDWKppu0uEa2XRE157nD1zcnP811/eKsLyRjCAV4nORPhPTzjlB4T2Q0I8iHqAR + smMcuS/sweUmoLUNl8icN12Xa+KOrK0+Imb1BBcNaR6f5kRNTl59gQXKM9H43cutt99bFl58hTJoqaby + 8+P6lNn6t9RcRqp8lccVJe2Oq+JYjgkkmdY/9UcXlGFvP1beuWzq8tQOzeWWge3ljnkDLHO0l3/uG5d6 + 49Llz3/8dWmbYqq6Pd0lAiJmM7s52xzzlFNP/HZ57+fzl8c3bCp/nbG93Dpre7lnifby6olt5Z2LojEH + NdWpDzQLLaLC0/UmSJzfqK4365zw5HIAgi4RxYiqpOEt+6HDemyM86Nd5EtSuzBA0UaugUzAOra1LCo2 + wSBcC1A4T4zPGsd9uoO7exkOKDayg8YVdhJrRkT7h4D9XfiyxvJBHOvAQ79XZuo7ZTl0x6by9h+D2u9t + K5ut3lyfS5Mnx+85kXHJKo4DJHqHCEalyJk4/LCnLi9vXdhU/r5rW23g2+duL3cu0F7+862m8t4ftynO + 4MijvlP3abS55p03fPq3yvP/frWUFy8vr5/YVO7+dGvd/7bZ28vDg9rLexf2Kc+dN29ZY43VS98Z+tXG + pXVcq0bIJ2w06pERFb9pGGl0rhBzi1qwG3EtSpERJ0YN7p100knVxRuiMEGJq6RHMj8CMI5BDqh/a9vR + UlykTp85rwRFWmrJPN8RnXMXUJQ8+Ry1Jcz0nCMDmY0H+PWNt0dlrV02Wam53BWNMuz26Gk3t5VyW1v5 + 8VF9qpZBeag5Y3MnBYhjW/Ic+XQ97kOQdJzfe49dWN46v6k8sXUAZbYAylzBBou3l1d+EEC59+i6zQeB + cnftGWU1skrY6RwdxxhW3v3jxuWfX2mqbqsyUgDlH19uDQA2l/f/dmF5P/Z/8smn6uRvYOE2ZFJdKzZu + pPHspdlT0zQMcOXNZIYHrgmTD/GZvqD3sLPAQaRGb/i+v9Hzzm3NbOM2JdmwkBl08kZErDwOoY3dnVd2 + 2O7nkjay8hGgOEhqFcP4u+++W9dBbrzpnrLjjruUzQdNUa4+OgDy1z6l3NJW3vh9h70bYPnPr9rKPLM2 + 10k6BJSkXOO67Y0nObrFPipetGUZDPkGIV7jsd577Lzy5tlN5eG122oDczsPrBj64oxo5Keu7NyqoziX + 7mXY60+WoVfMUJ7YqqkDaMEody3UXl7+XlNon4Fl2NAXO7fs2D9Xp+QaDCXoXFyujpa0DjQsezDjji21 + bl+5G+7EBHB5HWG7qYwaG+NIiIlO1CeGwDLWjdFRDBrSjxkFmfVmPx3V9skmI0v09aYMBxTFQTQoOt1g + g43KE0+/WK669say4/ZblL22nKZceWRTeeem2C3Y460/fAgSrueDv4T7ie9336Sljk7yj0IvwolvTNpz + /FFRXfdiOxcpHAUSiwBileH3D0F+y77lzbOaykODO5iAPbRmS3nzwinKBy/d2bndiMt7T15a3jy3qTwy + pLXc2gm0+5dvL6+fGu71V0M6t/qw+H+dQiNhF6Jaoksm+KCDDqo6ARMIp6USUjj+8Ic/rNubCSfVLh+y + bpjjEKGYxH6uUbSiHmXNzSMGBAEHljFlwP97WqvciKSiEJiA9X/qvnEMp6fO0ZvSI1Agfq3wveuts0o5 + ZO+Vyg++0lLuDxFX7mku5Y628mYABEjYe38O+1Nbefiy1nL9ia2l3N1WbjqjtczQd5qKbs/L4Td3jIgp + xW0CprfobgSJByn1DBIlzv0ve5bXTmoq9y7T4XYqUNYIoFwAKHd1bjeiEp3kzoPKqz9sKvctG/uKmoJV + HtsgrjlY6t3bD+ncbvjiPLgy2V4NndY4F4RhHWl+0zddh20MDchXyZlIRWAJmoQr09G4DkwlCnUMo9ML + zj9/ZRlmGy6GeY9tazTauThiuhxtmmw+JuUjrkeDoC0n1XeGprJpKPw9tgyUb9lSTjygT3nxhnAxAY43 + schNbeXiI/qUX57QWu66oLVsv25LKXe2lddubCtLLdJcjyFqEtPrPdQ9GsQuOTN8VGDJc0K56W56Boky + rLz9m7XKy8c2lbsW6XAbBO0TW7eUoZcCyj2d242oxP6/HVxe/m5TuTPcze3zdADlmS906JP3nhjedTUW + 58PN5tiSBJ1H3+6www71QQpeTRSXa5LQAxLheIa4RKr6kj31RLF0He7VUXciGdvLq8wen2WI0x0BBtaR + F8EizqNRL2VG2DmOrK5HVj4CFOHeaoFecxrcMuk2BeYkp2xuKhtFVPPeLe3l4B1bymXfaS3rh6B97Iq2 + ctY3+pT+fZvKLhu0lB02bilzzNQhtsyJcDedG60klPjcRDrdkkjvqTifBInHvumRIwZJlPdDyf/iM+Vf + hzTVRmaA8uTn+kRDt5T3n/tt54Y9l2FvPFuG/nTm8sLBsX+ALIXsc/vE/hfF/i/8qXPL3hfXlj258VnI + c4WdFkabYBWhrVDYY+hEK66Tu/EcQ53NBCpRDjOgZ7kvDJtJP+1GH6lbqXi6MHUSbaKe1WWeywjrcARl + OKA4iAhi8QjN8qQysWPQSVg2U4DlhlNay3orNpcDPt9SVvp0c9l1o5YyS//m0tqnqXxxq5by6fmau27+ + Fu6J84V+ZlaZwwn1cg+iIRdBr3QvjSARRbnB20DkyC5w2CuPhhDtW579cnPVF3fM1+l61movb5zVXN59 + 4ITOLXsu7z93Y3nrkgitv9DSIWQDaMDy4qFNcdwQsgGkMS16tWQkkGAHaXYhrrDWchzcFhfTGK0QolyO + lL55sTK2hhtMK8hRX0AxdIBFBB/CYi4fE2Emv6tnDC6aTRZPwPS2dAElG8afzx0awLwNlJhJHScJOAak + 5pk3gBDMMUVbqP2pO3qIHvHdL7aUy49rLasFmMT29sn9XeCSU05ZQz5U2Riy+d/GkueCWjGJuZ+jAony + /jPXR89vKk9uG0I0GroCJXTG/Su0l9fOiKjlZ0tV1hlRefeBH1Yh++hGnaF1AKXmYI4KoFw5axn21gud + W45++dPNN1fXoq5yFShm6oLvhNrYhIB13ToThnBLxtrxu85qqEHHmy/MAyO4J9vSPfJJXJTBTcMARsb7 + hAGgR/VyUY0Mk2DpbfkIUIRRG220UVkm/syYgYtxcswI5dLTN5U1g03aAyQusNFuOa+17Ll5S43tXViC + BKPUuachatEqPz6i2xXyPFwYJnFcQnFUIFHee/CH5Y0QnRnxAModWCEa+6VjQmecF6zy0OmdWw9fhr35 + XEQ1K5fXTmsq9ywVIAkhXIGyYAAlIr2hP52/DHv7pc6tR68498O++c16LcbQ1AczEOm+IJ1BQk2CkyA1 + DgMkdIYHZmIU9aktjPEIh03Icp+xaQQAIjzm3q2awKUZRXb7CfmwaPwuEuOWcrpDo27pTfkIUPRwjQjJ + ZnZL5JgXgSGMQ2yxetDyBW1xcsODZKvBLeXdCI/XWLK5pplVRDKRfU0XNKBoBFZlSMZxP06a//T/eQ6A + lCBBp727mIh4/rxTeeV4GdUASjR0BQpWCXZ4fKv2MvTi5vLmpf3LB6E1hr3zahn26uPBQtdFSL1Xefvq + WSsbPfPFtgqSqk+Cje4N0IiChv567c7/Gf3i/FdaZZV6PfSIBlcnkma+I3bVC/2mg5iEBSSmMpjWsWls + I3xWnyYi2Qe48uHdJi9xZQlAHdwAp/cGFM1K1J7q3ABgY/Ktd3XbTaPQCmgJRVHQJuaY9jh7nNDSoVtm + bm0p1wmBH2gvvz+9I8pZc+nm8o2dWsorv20r7/+1rSz3meY6eyzTytyX+Sw5VUGeAb1S6U7afyUVOnHJ + JK7GtuZQ9PZCyrAPghGWLy8e1lQbuVonUCqrxOs/vhoh/YXR6JdPV4b+bN4y9KqZImyOcw8gvHBgU3l4 + nQBJiNiqTQAsgHLfZ8NtnRr7/Gqdzj8a/aLhLdOl15uiSLvp7SYQmSjmmrFJTiDCJuaQSLzJtpqRxu2Y + XqBe0gzWemwMtlHP6eq9Jli0g4gK86RLywQcvdJb9/MRMWtnvZxbcIGWvJToEdrOMsssZfet+pRHrw6w + 3Nleyj2dqftbImT+U0dOZdAqLXWE0whoimA9xzS8rhHQAIsJP44vjS23QmipHDcwjTZIogx77YmaUX1m + 9+YP3U6DaXz2yLoRxXy1ufzza03l6Z2ayyPrtXa5mrpfA8AqUJYNoJwCKGPOKFjRNdEO3IKe3hgOY5Nr + r722JsmEve4k4E7kVXQ6A4UbhyVARD3WdQEEoFPPDCgABkjMUeEJjCjTj3RKujUuKAOJMQKKhtGzHcCB + uAZIXz60xRIzzFAWChoU1s0zbfjIVVvKPRcHYG7vSMDJzkrGfXfvjoY24UlPMIvcZ+7IBVDsPhsRxSxE + LbDw0Sn2PMhpdECivPfUFeXN85vKI+u39giUagECv1Wb48P36Wq6bz8ugOI6Mm/idgod6IthGs86/5lc + AxRzejJn4rYQekTjA4T3Uv1u9kohLJJ0o7zcivo2L5YGAiTzenP5MPkbK0KYR5NAycfCjDFQ7MgFSPny + ZcuEmjaJJsUsChQRmS8xXb+mcuOpAZbO8R6s8s/r2sr8c354b8u0IX7nX6C5DucL8eyfvlkWErMAhgri + cqS2Rxckcebl3dv2La+e2FTuXbptOH3SZZ0gEc3QLF7r+wBDCtfuYOktUPj7ERWsKX/kek0ywiaWA8ss + rZn60vvyIuoA6xKkAGJbdZ7BBBcuYrIKpRvCpP8ty5F1zTAyYMw333yVmYwkC7ul+2k/ORcEkK6nt3U9 + HFCUBAuB6WCfXWaZuvQlNuBGhLkuwIWIjKafqan8/WcdbueN3wWrhE65+8LQL+u1lK3XaSl3XtRarjq+ + tdKoQS9U6RhuBHdh8iMEm/f8qHh/tMt7b5W3f7FI+VcmyhoaOxucPbJWS7imlvLs7q3lya3byiND2sr9 + y7WXe0L83jF/J2ga9q9AWSaAcvLIgWLWvCgEM+hgjSXdDtPzJS+914AGNHUULoFWwdaSk+qW1mDqnRGs + 9qP1zM7DGD6bjoCZTE91B6VbV7GzYwOhcwJECTzjd93nOI8xUBQ7pwsiao3VQLBsLd+H9iSL+FsnftCu + feogIVZ5PWxYRD8f3Nph3NHzv2grA2fu8Mv2ATjH0Dty1DNNUoouGp3y/vO/K0MvaSlPbd+nskU2dE3h + z2KaQVt57ktN1TUNvTQsopu3zo3PZzaV14MtREovfaep/GPv1hoO3x4AqUAJBnpknfYacg+9YcRAIRJN + xnb+Zry7Gc0MQMEBbeB7d/IJWd0uQuthTisOSK4Z4DP2w3VkEi7NZ1GLY3ApdIeO6jeh78zhrhdddNGq + I6UR5GLIBREUV5NjPyKedPNjMpLcI1CURmErOjGba9a4QBe8UZiL7lo/dcHm8sqNbWXoTR1gYTlw6P2w + AMzOG3boD7RrJjmwqASzudzT67c0Lojv7m155/YDyuunN5X7V+xggQQJV/L4ZgGE45rK279corz/7M8D + VL8v7z15eXn3/uPLO7fuX96+cZPy9vUrRwQ0Z4Atop+D+tQoKcXtYxu1lzfPC6BcP3KNIi+h58pXuAZu + xMy7jOBMijaTjmsQTerxOTqcT+Eg+BvZBCCwkOiIELb2i98zqtHZsDR2XjA0HyYxdwVACGN6RHYXQLgb + TAIkAofRHUkeIVAgzcH4X0PjQjbhm/SwLOD04S74U/e6Ljt/c3nx/zqmGiRQGo3gveyo1i6xKnto4jal + Lj8AOADIPaUAU9EofVRl2NB/l7evmbv869CO8R3g8Hrnp9rLCwdEA18+Q3nvviPLsPd60hEqqsOGvfWv + AM4B5a0LmsI9hSAOsUvDPIxRzho5ozQWlY+F3T/UfTSZ0SYSZdyCzKrbJ2gYzJy5ECDJ/JOoxW/uSAQK + whZIUi+KcghkMsA0A2DNObLaTChMawpOuBtMkiDpLZsoIwUKatJThK+mCJicC6XozD0jBNj0oTH22KRj + 1LgnkLD3Q7888dO2MqBfn0rFkmlUPxVv0FD4Z5aW3uM21rwLDliEiyMr7z16Tnnr/Obyt00b0vbBBA+t + 2lze+c2gMuzVh2OrbhXywYgeqjQswv1d65SCx7dsK7cObC/3ErM1j9I7oGRRfxqJSzBek0DRWQCFi1h9 + 9dXrNWIbN3Z1HzKhVwjYvLdZnQGEZUqJW248t5dTMajIlRnfwSJSHBgkJ3x3HxgcnTJSoDgg9KEqf+iP + uSFzHZwM2jRpZpYQtPcKlcPFvB6CtjtQgOivZ7eWmfoGGA4+uE7m4VdVHO2jJ4mIAEYlSGtnxapIaf+e + yrB3Xw+XslR56eimyiCVUQIot87WVp7atrmU56/q3LKjDHvrufL277coQ3+2TLxuV9657eDywX/u6Py1 + s7z7annnt0NqBHXXwgGUJTPqGfOEG/dtorrroU/cnAU8ro07cs3YVeNjCWzhs0y4dD2Ra+K1EXy6LteN + E0nqVHlz3lJLLTVcCCyZqe0awTG6AMkyQqAojWBBWS7YXBKCCGD4P6OcG2+0Uc3QvhWu5+2bPwQIzULM + 3nxma5lntgiL11yzztXQm1CvMSUXiFoJZTkBN13PHyAykyuBwuX1VN695zsdbLJFx0RqIKmuZ46W8vw3 + pooLeKy89sbQDj5559EA1TJ1rolM7JvndAraC6ct77/wl3q8rvLOv8sbF81Z7lk0OkAnUN759eDOH8es + GBV2PaI87sd7jQ8UtBqRCgh0SLoTt2DYTo7E5CauCICASeRoTA2QTOQS+Zjtpq5yeIQnGJ0QeGRlpEBR + EoVQ6U8htBEwZtpT/fPOO085ZKdwQfd0TGiSW2FnHtynzDZw2uo/jRxT+qnIqf1DDjmkrnGCklHr0ssv + X4/rP+khUURPIfP7L94a+qNvefGI5jrol2Ft1SfzN5X3L1u53HZrnNcCC5fl1xhc/vD9hcsbhzWVe6Lh + 3XpBezy1U3t5NULft66at3zw8oOdR47y1hPlvyfPEMdrLvcuHRrl9Oby0oUDyjuvffR2ld4U12JStEZn + GteyXwBBcwBKhs2+51LkUkSJvsMsOc2gMT1vMjZWkenWAU2DNMqeaXrtNDoh8MjKKIGSxZ9hF4Dx58kw + hBKawxAD+k9brj+htbwXALnpR61lt82mLKuuukq97UCamgtJRS6mR5FCN+l60cCAoGUXmAUwzf/sXj74 + zz3lrSvmKK9lpBOapLIJfRJRz0PLxWX9eZey9sZb1Ip2G8NULVG5c7WV+yXXwuiZWwa0l0fX61NeO6O5 + fPDCTZ1Hj2t94Zry/NebIrRurRrlnXNay4Ph3g7ce8fOLUav6N3uPnQuwmPpd1EfZhC5mLujk+gsEmgE + fa6WwDyOjg4BrEzCSXrSNaJIwYUoSlJN3ZrEZOLS6A78jaz0GihZ/CmTIwAYJ4NdgEWDLzr/NGX3rWcv + W22+ftUiJgmL6zPpYzDQ6DTX5b4cEYILlUe4O3pCb8rbvxpUBebDQwIYDXkTBgAvbtNabjx1zdLcNl0d + eieYVfhibc3lrtjmrvk7tsU+t87aEqw0ZcS3j3QePdjq0e+Wp7drqkCSmX3nnLby+IlWhm4u3/7O9zu3 + 6n057bTTKhBkUqUVMgQGEgJetCfyESmZY2xiOjctKWeuMcYVHmMPGXHgcJO6Y7out/XmFIWczJ6Drdrp + YwFKlmSYDKGBRcNnAumGG66v98tgBJOhJKAyZONahNzYyH0odIiUM8b5S4hkABxReenx35c3L+5Tntun + petOwEag3BWM8tK+U5Y1l5uqVqSex6/TPrMGUG6L7e9OoIS7unuRtvLKSeEub1yrvHvXt8u7959Q3rlx + cHl03ebhgPKPUyNqm6ZDM8m29raoo+UiGtGgNEeu4AgkIhoNDiSSdAZFM6Oq4eVE1InpBjQbF6NDqStL + VgwePLjOxXVrh7pWx9hE0DEu3Y4yxkBREixOSIyebghjcCvYg4sx6zzv0c3bFWzPr6r4pFgPTmoO+1Qw + jCXLibHG8kbg589nDOq4HWPQ8C6H3R321KLt5ZurdgxMus2ST18obGBrczklXMl9DdtXoMT2/zkqorUz + mzryJRe11EzsfcsF28wSQInXN89qK/8NsOyx6eJ1IpFzHlXYnkXjWbxYUjEf5oBRuoNEgpHg5T4yo0r7 + cSVesbHvbSPtD0SM3tMxzWPpPsWUTJgogKI4EfRGT2h8lIcxACZviDbZN7OC2CdzM3pIF0jCLGAjXV1X + fY7Klc7XU7L85Q+/LI8c31xeO65PTbXfFa7j3mCH+8MeC0H7QLzuM6C15hwMzxtuQNmrLNFUbo4GfzAi + IxqmWmdCLXMvAOGmsce3aavzUmr0FFrm7sXayysntpV/n91WTj5kiwoQ80SAxYQj1z2yst9++9VrMxCK + 2ZJJaBXfE/lAgkFcK1BkRhU76GBefRbN6HzAZztmuMP2OqfJTph9XGqTLGMNFMUJZVQkuYMxoBpovPrs + 5P3uAmwLTHlvC7NMOHEnDKQpTDj2vUEv0dK/XxlaTvrqsnWc5pkdQ7BGQ2vg38zdVq6Ys60cMbC1rDB1 + cwWGoXggsWLSauusVl46d77y/NZN5dkvNpXn9ws7oKU8s1uf8kSA4tF128oDK3XMjcUggANElXFqBNVe + Xj4mgBKM8v39N6p6Qy7IYjvAImlGOPZUXPtsc8xRr8MEI0Mepgtk9pnbzUlLXDYAAIQOpn50LiztVcIT + W+h4Ik0AMqFaYs13tlffWc/jSptkGSdAUZJZAMGJoj6GPXwGDm7Kdl6F2UY6VTYtYV0yI8uSSSY+JYCY + bTZYd0j5y5HtpVzQpzwSuuGAvq1lqalayoJ9msriEdHIWEpGAYieK1PZ1NxWzjv5oFJumKOUS6Yo71+3 + YHn7iv7lrYub67RH9yhzY29E9GRg8IGVAyQN4rgCxXzb77aV1y5sK9eduGm9X4eGyFtJnZtR254KIe/a + 3CYqnDVvOEEihwQkOTAo+jMlQdSnwbNzqSev2Do7INZIAHnN7TMDOy5dTpZxBhTFySUQGi2/z5NPoBBq + Ktp4kcaVRHJLiDEkSbhGsCwyWzTmha3l9QPby+em/XBylPVAMJDQke+XY6ADAE9YPMU0EalsFy7qxtAU + H7wZ//5KKW/eV4Y9d31598GTy7v3fqe8fdMO5e2fzlJHkN1nnPNZKlDCxb18bFsAq6385Zwtum715Cby + Ph3zPzRaY3GtGMPvrs9j5LqDhN4g9oGEe8EKObKbzKvzeWW0YHZC9QcYXn32vX2SSbKux1UZp0DpbXEx + eoCZX/IGOU9FNJDJJGM/htEt5W0ZiH6tTWXBOZrL0gM7BhYNKubcFvsQrfZPAxzi0RTCRZqCeaafuay8 + +uDyrRNOKfc88nTnmWQJNnz6mjL04nBPu/fp0C3zfmgvfrMtIi1A2ayLAdx8JbllhBjYzSBrLFxCTlgy + VpPjV24uTyYBEu4mp4QmSHpihGz87HzqMK2nzjiuywQHigtREYSXW0RRswdDomUZSmIvRR8gZM4hgUPw + cjE5LtIIju4GRBJbgId1rDM7l6TW1FOXQRtvUq6++LhSXr41z6y886fdqht6eFDHfT1Y5baIrP7xlWCU + S9rKg+esUCMN4T5RSVzKD9FaroVmyGLWHmAYQcY4CRJ6q1GTpLsZH5HKuCwfC1BQqJFnlccIUGaeqFS2 + WxqksI1/AAPgAA2hm5O2uzNIT2b0lWbBLkBoX+9FHXXubnNL2WHV9vL6Q+d2nNtb/ypDr5m/vHRU5yBj + hM+A8lwnUB4++7MVKELX+pygAAaXkSsTuB0lhxsM0Lk2YzCmPBoIlJ22v8SYMbIRgeR/HijJJgYFVayK + xBAa3rwLn4XGZnJ5ZbKQ1nw1gGYcRCOPikkYFnFPkrvqCNt1w+RVDDz67dowzOT+pHO+0KeUf19ez/GD + 539X3jh/unLfZ1s6wmhA2bcDKE+cs2i58orLu1YxEp1gRm4mgU+3mIiUdxOYpCRfRADLeeSURFELdwMk + dMbEDBJlggKFLxVKWsVJJdIferjZ5ISn3IIhdy6jTkAO+9ZSLeW8/fuU/VfoU+bp01JzJB42DVw9ASQN + 4ziuFLkZYJJuxCRNZJKU1H7eTLXL8k3lxd/s3HmWw8qb1yxf7lu6Y8UlQHlqh/YKlH+dO7D89LILKqPI + WwhXXY8Gl3WWLXW8NKPE1rMlWvP2T+7K8IX95JIwSeY8JlaQKBMMKMkmxjOwiXAWIKS0Ta1UsQbL3NnG + 9fi8R4S9rx/RWsq1beWlIe3l4gEdk7CFz7TLyNyPgTPMwd04pv8BHIxkEM6QPrBwQVhls03X75iO8P6L + 5dUzZit3LdwxUbveZbh5B1CeP2eWcuVPLqisgFEyd+HWB++BIWe1Wa7LXB2uRoQkc9q4ZgkXlbd1phid + mMsEAYpKUBl8MiGJPUQ6BKv7b4XCQmKNz7zHLj9brKW8f3lb+feRbVVYPhi2Vd8OSjd/hVAdEViIXckt + mV5jLNZIE0oDJ/AYoud+bOt4c863QJ0UWd55sLx45NQBkuZy+7ydQNmqAyivnDtN+fklx1UxK12ekYoc + BxeCYegVCwvTIVLuOc4FWNxUJsXotInd3TSWCQYUlcJfaxT5j4xuPL3cd261JDhN3HED1OCwJyJUff+a + tvLktm3lllnby33zt5e/RON9ZqoOfWOYPaOa7oDxHWbicvLeF6O0Qm1MIrchze/Vb5/bbvsORnnpl+Uf + Xwq3M3trDY25nofXbi9vnt9WXj+3rfzi4qMrCLgaQjTdh5wGEACLDpFjXUbHffZ9goSrmRRYpLFMEKCo + FL1JmEgX6O1M44p20D+tAjj0h4Y7pF9zGXq6wbq2eqM4vXA7Vgmw3DxPe1lz2o58Cv0hX2JfbOSVOZ5I + iZkI5K5F4TF9Yr+1PtNUvrJea/nWV4aUP9/405qPqOf6xOnlSQv9zdrBYnUNt5XcshHnEmD53QX71NAW + ADQ+oHAhGAIIgAHTcDG0iFfpd+4JmBIkk1oZ70BJNpE/0EB6uQY1AYde8F3e1I5lcr2Qi4ZEJBJs8vxB + bR1jL9G7a7Y0zCDgPWGHDWgti07ZUmYJjUHzuBPPsUQzbiOx4tPaTX3Kxn2mC+HcXgb1G1AWmnOu0A77 + lQ+e+3X54K07objzTKPEub77l+3KI4M7VoRMoDwQIfQbwSaAcvP5u1TNgTEsa871ZNocWHKsC2Ck2r36 + LLLx+6TGJFkmCFBUpDvp3N0mtyGTChgZEpvMAzi+c1diU2s01OGtZdgVbeVvm7V/OB+2wUxAemSB9nJn + vP54zrZy0IA+ZfcZ+5RBAZxtPtNSvr9Ln/KdrZvLCXvPV2647LByw3XnlPsfubf8942IMDrPrbF88N/7 + y7s3rVteOqa53L1Yx6oG/scIspvYXz21rbxxQbjA87aqSTZuRXhMm7g+AMBKGKMxze410+uTKkiU8Q4U + laNCLdJHD2ANLgcwRC9yJZJiXJHvzEpfcsHm8vZF0TDhergdjdUdKGkAY3oB0LB7Y9un12svJXp/CaCV + n4ZdPU0pv5i9lOuXLh/ctFV599YDynuPXVw+ePG2MuyN58r7j51Whl42Q3n+a03lniWCwcLN5fGN99z1 + qfby3+PbypsXtpX7zl295kOMz3AtGAMYEgTMewyT1vjbpFrGK1BUjIpy/6tUvbsCaQcJM6ziNgQsQ3zm + GA+xechW4XaubisvHNzZaPN+2HC9smhc9xM/PLi9PBFC+J/7tpZ/f6u5rl7tjsI6A//CljL0x1OUt6+d + rbx6cnP52yYd4XDeTppWgbJwAOUHHUB5+Nzl6qCgcFeijXtJoDSWBMakDI7GMt6BgnLdTe/uwEymAYWc + htUOrQmX4zZe1+vTVP4Q4fCwKzuiHTdhaazaiCze52BdlzU0bFcDB7OIWLit1Dh3Lx76ZsX28uj6wTq7 + 0D8t5bl9msp9y7TW7eqxux8r9vP9vw5rK29d3Fb+cc68ddRb8kx2VU6Ei+kOlE9aGe9AERHstNNOdfTU + 2A0wYA6DfFhGip0rAhRJsuPmbS7/CbcxNOyhNTvAYc3XauEC6qoD0fCNRnhq6Grxvn4vSmoAV30Fntze + drFNbvsRgDSY34nqzM5efdl5NY0v7M3Z7pjzk1zGK1D0Mr2tPtsuQIBNAAJQ3DoKKNyP75gR3hvXbinv + /iT0yTltVRe8/L1OOzbs+23lP8E2/9z3Q3t+/7by92CHJ7YMBtomxO/GbeXBiFIsS24+bF2YOICisRuB + BDTAMyJGajTbP/e1AMqlbeXVc6YqP7/0xDrFQBItFyycDJSxKICiEq17YmCuO1DcuyIDK0uLabijR74c + +uTatvJB0Pz7P24t713WWob+JCxeNRQbGkAa+uMw7ztNb6+vIYLfPC9C2bPayisnBNhCW3Abzx/QASir + Ezy4SoeGqezEPXWyS4+uJ8zvT27fXo//2rlTll9efFRNumV2VvjLxX6Sy3gFinBRQsokafcYcy30SWqU + vGfWwnf1xqbmpnLn5/qUO77Rp9wbDPL4cVOUp78/Rflv2Mthr53emfgKtnnrYsDptABUfb2ktbwJKCE6 + 34xQtr6GVRCFVaCJpmL/V08OdjqqLTRK/M+mwUDLhWuLqAlwWCNoKlB26ACK7OzvLtynpufz1k1AkSP5 + pAjXnsp4BQo6lpACFCO3xnWSVTCIUBhQJNlq2BxAuSjE7Jfj9TMzTl02nH1AOXTWmcpDYffNNlN5cOEZ + y8NL9isPL9GvPLF23/LE+tOXZz4/bXlur2nKvw6Yqrx01JTllROnKK//KAAVGgdw3g4QeZbgewEs4Hkj + 2MZv3hOnFTzxKgNsEvWzX4zIZlCAJtgGQLgnwHl0w/aIlGK72P+P5+/WY9JtMlDGsDQCxcBfzgURDkuz + 5yPfrWcLPJiGsJWU23yqacvKMw0ox8zYvzwadk/Y3X0HlLum77Rph7e7Z4htBvQv98/bAahHV5ih/H2j + 6cvfdp623LTf1OWR70wZoXF7B0CShYAnQAM8XrEN1sBCJlQ/+fnQOaFxbpkp3NXqHeM9tr3z3A16TLpN + BsoYFkDhesz8AggrCgFIAsXEIt8TtW6xkJn1G9Ds0rdvWW3AgHJC//7lsbB7RmUzBZCAKQBTATXdgPLw + NAPKuVMPKCvE5wMG9i9/W2jG8tgqAaAtpyvP7zN1eenoAE9oGczzVuigNwM42AYYsAwdROf8LVwTgczt + +f3+c1btSrq587Ex6fZJLeMdKMRsrmNmlhkXAwxcj9s980Yod+5LxmGV05qby9b9+pVBAZRLAgSPdAdF + Lw3AzghbIUC0X7/+5QEACva5M8ADSPcEeB5avF95cr3pyz/Dfb187BQdLitAU/VOJ8sAzYuHdzwS1+9P + n7vwcEk3dz9OBspYFGIWUNz3AgxCYa4FGIAFMHK1Q6xi/VUTjE7s06dsNNNMZUg08k/DHg7rCQijMkA5 + O2ylsAPCHgzr+h0DBXiqGwOcANC9oYMeWbpfeWbb6areqUI4XFR9JYLpmxCzz5wzX7nyip/UpJs5s27V + MBjoej+pZbwDRR7FAi/AYBqjNH66GEDJaQVMUk4u5aTW1rJuNOamYb8LG66BR8MeDTs5DFC+HjbS4yRw + gmkwzj0zx/6hc1746tRVwBLFwm5AeensGcq1l51ZckqkXMonPek2XoGCilGyWV452RiD0CeYhYmCTBFI + sHj/tamnLmuF2/l8NOBtYQ80Nmgv7d4wTHRo2IphowRKN6N3qlAOxnlkqX7luYOmKm/TMuF6Xj57uvKz + S0+q1yXpZr7JJz3pNl6Bkil8aW5JN0Cw2pDn52ETrCJ/4taMvDNwigDU2tFQ64TtFHZTGBcyuqySQDks + bEyA0mXBNA8GYE7qF8J4p2nL0M4Q+7cXH1yXwcqkmzmwn+Sk23gHikSUENnSDskaFoQBENENsHBFJhv5 + bbYppywbB5sAy1phW4YdF/anMKL2vrAeG7SbjTOghD0UdmBEUyv3m7X86ai5y9DLpy+/ueTQ4YDySc/O + jnegZOSjUvP5MoSrydHmyAIKwHBBJi0tPf30FSjYZOuwNcNWCNsk7EdhAMB6atBGsw1gHR42tkCxHzG8 + ev9Zy34brV7OPGyHctmPL+oRKJ/UXMp4BYqSgtZwvAcpJqtYItQN6TV1HwYop7W0lA0j2tkogPKraJhb + wi4N+1bYxmGfDTs+rDdREKDQNvuH9UrMdloC8f5O819PhR0cNmhAuMRgli0/3bEUVuNs/MlAGcui4mQt + uR/3veQDEpgZ8thEtpYd7Pl3AZJdolHuDkP5Ihcm+jk67OdhvRG3XNSdYY61StiBYY7X07aNBhy2uyvs + 1rDrw04K2ypsUNh6YZvOOWc5/8wzK1DcqzNZo4yDku5H+CiM3HzzzbuAwtxvXNP6zc1lyxlnLKsGUACi + e5INGwAMkABR4289GaBobEBZNWzfzu9G5rYA5IKwvcK2DdssDDgADUB2DNsobP2BA8tJRx89mVHGdckw + 2ZiI+27zeYFpljrfL9hknfiegP1J2JhmY9MagbJ62A5hQm2M0dP2zH9ybdhj7zCh9YlhssO/Cfu/MOCR + CDy28yYvI8iWHvukjyBPEKCoPL2NqBUqu2k7hS3z2NXBwSaAInfy17CRNWhvDFAwz65hgLJ92KiAwm4P + AzAMhmGAh2EzrmznMBHZ8UccUUeQAd/AYPdJ1p+0MsGAQtTKqdAqbgbLRfDYotNMUyOdNaIBjgnTKD01 + 4ugYQGh07sJxRwaUdGuAwbXZJkWt3736HmC+GDbY65Ah5ZAddyxXX3ppnRIp6YZV6DGu1jV/kgAzQYCi + qDQVaEzEzHWjrnIrAwIk60ekI2UvskHvIxOdo9IZaRr/t2HCajpjREABgMvCTg+7ISwzwckkzPn4T79z + YdyjhOC6Ae7N5p67/Oioo+oCfNgSWPLm808SWCYoUNAyPy5CIGz1xG2XXrpsEJWu18tVCEdHBATfo/9s + yJG5EUChK4BvREABOp+xxHJhmGLzMPrkyDDs9r0wSTtaBzhWCwOUz4WlXtkgAHP0XntVsLgurMkNcbef + FFc0wYCiqDAuKIXtL3/yk7JxRBDYRFQhFJWz0MgasbHhfWbfCPtymPwK0Iwovd8boKRhHoKVcAXW7cK2 + CQMCoGAGKOmdI8LODxM6Xx22fliC5fCddqqrMImCXJ/80ScFLBMUKIoKwyov/ec/Ze9Bg2pFawi9GLVf + F2Z8B3vQDRgmQUKcHhIm3F05jP44JezmsO6A6Q4ULuOOsJ6AYlv/5RjcjP+x7Y1hv+40/2FbTGY75/Vk + GNAAObAnWHKRHTemf1LA8rEARcXd9POf14oFFBWN8rkgFb5FGHfw/TDASVcDLN7/LEzGFQCk940HCWuN + B2lwDd8IFC5FyPuHMPt3BwoDTPskKFkeB3gAI0GSGkp0Bty7h4mEXItr+maIXKPKudTFJwEsHwtQRAZf + 33DDWrHViNlOAxpUrnGN8wDPPmFXhmWDsQSMRBrdIE0PDAkYvf33YYCSjfiLsGzkRnMswMBkQmOgYb7P + aEgExTWeGSadv0eYsagNw5yja2Dr9etXbf+NNy5/vummLrBIOGJSrlcdTGqA+Vg0yj1/+lPtecZ1hkw/ + fVk7bN2wwVNOWVZvby9rxuuQGWaojYthMAchqYGk8jUeF5Isc3GY/AaXBDQa0IQlQCI4AUVjGj/qDhTH + MKa0XxgdYp/USYBzYdg3wwxSAsWgOOfV4txWnmqqsuoUU5R1+vatY1MbzjxzWSsA4r/WnXPOsu7ss5dv + 7rFHzdxaIyUfFpEiV1Q0KTHMBAOKClEx2OR7X/hCGTzttGX5qPDdoudd8MMflpuvu67ccMkl5fyjjy6H + brVVHU9ZvbW1DO4MnzGNyIiLOitMb2d6Pnegx/8gTGMCDDYCGIwCbFjqijBs1AgS+oPWsR+BzD3RHUQt + F4jZ2Hrc5IwzlkFTT102i3Pbf8iQcuKXvlS+EZpknWWXLeustFLZ78tfLldfcUUd/7nh+uvrgyd32333 + +swdK2GKirCLqI87ypzLpACY8Q4UFZBMojcdf8wxZfmo+EVnm60ss8wyZevPf75su8MO5XPbbVe+fvDB + 5Yqrry4PP/JIeSx8/M/OOKPsueKKZdU+fWoDYRjMgmFEPwQndtHo6Sa4h6+GAYrt0r35fF6YbYhVr9iJ + u5K5NWgooqmfgxlWD6ZYN4CBLYYEUJeO/184wP2DQw8t/46o5u2hQ8tJp55a5l1wwbLqGmuUn4XmysZ+ + 6OGHy8mnnFK22Wabjkf/Blt65J0HjVsA0GpNckkYBmC4pIk97zJegeKi9RaV4F7dFVZYoUwXDLF1MMZl + V11V7n/ggfq0UzPaDzvssPqgIk+7WuhTnyq7BW3f+Mc/lpejB/76ggvKrksvXQYH3W8QjZfs8oUw7gSj + YJZkCW5JAi2TbYDi9dthKU6FynuEOQ63tE6w2wrh8lYKFhsSQNlk7rnLKnPMUWYN9zJ1S8cyYIcecUS9 + ppeDEbYPcPvODfimUChS+dapy5Wq55133rL//vt3PUPRAxckGa1gbWVra8AlYCb2vMt4A0qChIjbZ599 + 6pKhVoScIyp/+QAMUFgL3xOsPPmKL5d78GpBX4+79VycLbbcstwR330Qve77cZx14rv1oiHWi16OJeiK + a8IawUK3+Cw/skcY10E7yKUkC2EQesbQwQZxzE1DU3wlwvXz4r8fvOWWcn24wrXXXbdrmGHtddap10Rr + OG/f7bXXXl2NasHhfOy+Jc89qsWtHPk7N+PaPOELmFzb2muvXQcVJelcu6w1dpkYwTJegOIiuRo9ZrXV + Vivzzz9/2XfffevCvCrG8LyZ+Z6Z5znAKlfFbRmgsJyEIgdhKU5P3DLa/O2jjipHfve7ZY7YbnCwzpDp + pivrEMK0QzQ43QIcQJIaBCAkxnIEebcwGgXbZES1fDDcKvPNV35x5ZXDNc770VgeE5OPzPfcYuzneX8+ + W2rM9tL1Bx10UNdT4nUAdxDmsYTJnq1oRQdsqaMMHDiwbsusR4ttGqMjoMroaGIp4xwoCRJrq6oElWGl + ag9VdH+PJ5Za+M/9MESdiAAlq3iL+ZrYZFt+XCEA87mDOZN/ow02KIftvHPZYeGFK2CwBbEqNOZ26BVA + wTDAQpgSuFzVRWGE6/oBsLWi51tRYfZwEVeFNupeLglxnUB2DY3TI1Jr0CG5XLsngmEGhUsBECyTv4/I + 5pprrjqpKxcrNso+sYFlnAIlQYJiibeeKiUbfNZZZy1bb711fT6eirEfNvnc5z5XHyLtaRV0C7Gnx9k+ + j7F6iMfjg23ODttqkUXKhg26JXUIsGAP7ifHZADExCNR0CbR6HOHJnE8AMAYNEJjsUJ14/82GuA0/uZa + aDHFdXjK6IgAgj0909mDEzy+BRvNGZHUtddeW9eFmxjBMs6A4mL4ViOo3Z8VODLzKLiVIrTklvI41nHl + ssxZ8Sg2D0LKpcOZSt1tt93KV0Morr/eemWRcA9yMusFYLgUYMEsj4fJvfiOewImINk0gLFCRDUmeTue + 5+pwewDZWKw9l65nZEaTmGNDv5x00kldLNTdAAerYo5sfK+eQqrzYBbCtxEsE4tmGadAody5CWLPAxXN + Umcqgh/3m8roqRI9QNqDGNPlqHRCt6dtGV+/2GKLlbbOhyfNIucSIpduGRxAkOLnijAJgGSYLNxdO0A1 + TacbS1tooYWq6AYW+sicGezWuM2IDIgxiMnjjROyGs0DFdRFTw3uO7oNi6ofD41KsGRG9+MGyzgBigtA + u0eF4MQE3EX34kKZIXjhsLCSuOteoVY+EAUpbtm0ZEb3bXqymUIg/vFXvyoHBvusPe20VbfURFnYDsst + VzPBxKvPswaL9XQMOQ/gtJa9177BOj1tN7oGgPTYyIo6VC/cEMA1Pug6V7ye5IECAG7UXmKJJYZ7CtbI + in0IPg+b9sDnxor1+BLZTM/A4c8bfxuRyYIqBOicwRbCZwyydwjj40NUbhBAqqFwnOOIej3rH/uItDyF + tKffR9dETr1tYNthYoL+K1/5StV6oiECWXT1ceqVsQaKE8cmZ5xxRs19jG6xP6r3POEx7cFcXQrRCy++ + uM7B3SwE7zf32qvr6eRfCbd3eOiDI444ovZaS3GMjpYaE/PUrzFpWOclWsrVEuRZ6JWPk1XGCVCo81T5 + nsczJsVxzHgTGvdU6SMybMSfZ8FQGENPPuuss2oiTGQl/CSSjz322LrfnnvuWd3gVltt9ZFjjgtbccUV + u6Kg3hTbeoo6103Yivw8oJILsvxXsgom/jjKWAPFiRNdIhEVBCx7771356+jXwAmQ8buld/diEiPpM9i + 3913372OrQAMkFhCi9YRipoxT1iLctaLaCn3Eak0JsHG1rgOofWoCpGqc3CbnkGY4XS+YlmL9TQufDw6 + 4BuXZayBwm96do1Gk4F1kUy4KXIZk6LxPF94ZFrC/7ldwrZZvMdsBLGkHiYBEpGUysY8sqt0iB6rp+Z+ + tIBxmbnnnrvH/xsdI9JNh+QuGEEKpBYHlCsBgG233bau8JCgYBKUQCMd4LPkZD5tLN3PJAuUpEx0qRL0 + 4sx5qHT6YEwuTuN5qmdjRaYRmlxJI0gUWVz/ve6669bz4Gqk0425qGi9EliEwo5zwAEHdO7ZURyPXvK/ + 7mgcUT6kNyYhl+l6eZaerkNHWC4iMreuOFehsHMg5P0uCdj9JrOPS6eMFVCcsBOXglcRerjCHQg1Xazv + +evLLrtslCFi9+L4enlj5WoAuY6eKktancsS3uZjZ/VGvZse0SMBYY899ug6t+OOO65z7+FLulTXcvrp + p9coBHg0rA4gMuJu00U6Vlrj+QIbW2WVVeoTTGm40047rTKF8Nf/NOoO1yWfZF86q/tDpLirSRIoThzN + qyB6IItGOfzww7tS+X5XwQYHb7jhhtpwIyt6F9WPorPSN9hgg+GEa2PR2/RgIbpJQs4lV20UhudEIcfF + MpJbeV56sBu4RlayQbEjwMttAJ3eriG7GzcjYkn3k/s3gqKnok7lcDA01+Np6wStBOAkDRSVn4ySafgs + fjeCrGc0jovohXqZkVaNdMwxx1RBySSn1lprrbp99k5ZTWAcWQVhHttjFdFCUnb2ROepkWWPNbB8C62S + 54QdzBHJQb2Ps6y//vpVkBsWwJ55HTrDJA0USSKVLdvaU7EdYcsdbLfddiMcaGs0KX2RCY2j946scDF0 + Cxdne5qJy8gVG7EIkOjNKlqFYxA6J594zgBN/oI7GhXjjY+ChTAo7WL238S0Bss4AQoAqGg9lOgaWdFY + erRwVZ5DXgPVyp/svPPOdZ4Kv0x8joqmFZRsfIQrERInm2QKvDH/4HwbWcW+tqu3tg74cApBAsbxRuWS + xrboBMaAZKENkPp/7hO7jgjwH0cZJxqFezHtz0WizdG9GI2YNjqFVpCVNcJ7yCGH1BwJbXLzzTfXoYR8 + lk72QuY/nLPvsRww3XXXXbVRDFpiskbAAJARXxGdMHdsCzfo/+goM91EYCmIgR2jcLM6HwAl4AEbwKUj + Po4y1kDRCCiRzsjKFR2MaQ6lt8XdeMsuu2wVfbvttlt1OQbVzAXJMRLuA+M1jpF49dn3RCahi1kcD8sJ + jeUxGvUL05jE8jrrrFMTivIdNI3rlvORGPPfzOgvd3jKKadUxjzyyCPrfBWTswh6riXBweRd1JkZfY4l + /4MViW75H+yqU3xc+kQZa6BgD70TRUt25cULH/WK8VH0RtEUwSfczB7In4s4THLOSMf5da/cBEsyi95K + A8jDEI7o3vFkeSUR85oaTUP31nraX34FGwIdFwwg/pNuAjJ6BUgytMcmPV3LhCpjBRRFhafPl7MwCSkr + A7sYfBMN8bFjW4TLQmTHFaWYAQc0nvEHJCpXOOy/sAUgpDbpXnznN4zo/LGivAkm4rYABkugf8xBhBO+ + hLhcjgFMbIYdejK/SeUDNMagOzCKKE8iTUQDHAQrt0eXAYjMsfuCpAEwSYLEeY6uax6XZayBosI1iIZx + YS5ST0xhxvQqPQj9EpvGN+zTm8I/q1SUDyAaQOb11FNPrRXN3bgVBEgwQq5R0t3l9FT8xvRU22MXDQNo + 3JEeTU/Ix3ApGpNbMPPNOXEradLy3FCj+V5ESDsJx1071nDOtJTQV+INIJ2/jgboWAQjuo5kkhEBfkKV + cQIUF+KCVDJh64L5ercjNK4CmaABIrkRkY4ci0nIJj2lqWSju8Jd7sU+AEKTEK30iJ6IpukBvV8FN4Jk + dGjadhqiO2AwjCjOsWkYbo2O4Zr0fixGS2hwIGISZCw/+802mAkonC9gYA7HU1cAqUNw3wkQblNnyuv4 + OEGijDVQlASLixOOAgvWUKkaFW0bqEPXPfls33U336NwiTnzZgHKsbgxVK3i9XQMppI1KsE3uiDJko2R + 7igBo9E0HrbklrgEDev6/LcBUUBlGl6UwrxnvsdKBDawCXWNPdFRjgcczl29Of/MILuGj5tFGss4A0pW + cIIFfaqQ9PV6GV9vVJnQNXoLEJii0XxnGoApkEJFeRXslL5c79SjNYIGA8rG+2HGBCSNpREwjuWY2JJr + xTL+S8MCjkb2/1hHo6dxW42fbaM+7MOtiQhpOqGy4yY41N/EBpAs4wQoSiNYGsWhSktxiAFQNjqWlyBC + DRby3ZiCH2fe+44W4M+5GDQPcACiVzquSlfZSdPjuoITNLROsoxr83+AqZFdZ5pzYQCV7/M3bGEfCTbH + kAR0zt3BMS7Pf1yWcQYUJS80e6KKwS4aVM8iNtEvagYaUQy/nb6+0XwHVMAhn4DiMQiA0CKO28gi47sX + 5rX5H8Dxn0xDM40+Isttcp9GUIzPcx6XZZwCJUtWqMrRczSo3pW+XmOnrwccgo4PbzTf0QHpz9F3+nLH + c1zHnxh6Yv7/yGxSL+MFKEpWkIbUi/R8lD0iX8+HN5rvmW34c/SdDAIgGfp+EhphUijjDSiNJRt0ZL6e + D2803/nNNunPu9P25DLhygQBSpZsYKbBG339iMw2k8Hx8ZcJCpTJZdItk4EyufSqTAbK5NKrMhkok0sv + Sin/DxPfB4/w1TD2AAAAAElFTkSuQmCC + + + + 13, 194 + + + linkLabel1 + + + 45, 13 + + + 3 + + + NoControl + + + 111, 114 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + NoControl + + + 3D-Designer: + + + label24 + + + 77, 13 + + + 68, 13 + + + 0 + + + 28 + + + True + + + [version] + + + 64, 13 + + + 6 + + + 111, 131 + + + 1 + + + label14 + + + True + + + de + + \ No newline at end of file diff --git a/AntMe/Main.Designer.cs b/AntMe/Main.Designer.cs new file mode 100644 index 0000000..294252f --- /dev/null +++ b/AntMe/Main.Designer.cs @@ -0,0 +1,668 @@ +namespace AntMe.Gui { + partial class Main + { + /// + /// 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(Main)); + this.menuStrip = new System.Windows.Forms.MenuStrip(); + this.programMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.pauseMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.group1MenuItem = new System.Windows.Forms.ToolStripSeparator(); + this.closeMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.settingsMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.pluginSettingsMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speedMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speedMaxMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed100fpmMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed80fpmMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed50fpmMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed30fpmMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed22fpmMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed15fpmMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed8fpmMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed2fpmMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.languageMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.germanMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.englishMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.updateMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.helpMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.tutorialsMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.forumMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.websiteMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.classDescriptionMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.group2MenuItem = new System.Windows.Forms.ToolStripSeparator(); + this.infoBoxMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.statusStrip = new System.Windows.Forms.StatusStrip(); + this.stateLabelBarItem = new System.Windows.Forms.ToolStripStatusLabel(); + this.progressBarItem = new System.Windows.Forms.ToolStripProgressBar(); + this.stepCounterBarItem = new System.Windows.Forms.ToolStripStatusLabel(); + this.fpsBarItem = new System.Windows.Forms.ToolStripStatusLabel(); + this.toolStrip = new System.Windows.Forms.ToolStrip(); + this.startToolItem = new System.Windows.Forms.ToolStripButton(); + this.stopToolItem = new System.Windows.Forms.ToolStripButton(); + this.pauseToolItem = new System.Windows.Forms.ToolStripButton(); + this.group1ToolItem = new System.Windows.Forms.ToolStripSeparator(); + this.sourceLabelToolItem = new System.Windows.Forms.ToolStripLabel(); + this.producerComboBoxToolItem = new System.Windows.Forms.ToolStripComboBox(); + this.group2ToolItem = new System.Windows.Forms.ToolStripSeparator(); + this.speedLabelToolItem = new System.Windows.Forms.ToolStripLabel(); + this.speedDropDownToolItem = new System.Windows.Forms.ToolStripDropDownButton(); + this.speedMaxToolItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed100fpmToolItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed80fpmToolItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed50fpmToolItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed30fpmToolItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed22fpmToolItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed15fpmToolItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed8fpmToolItem = new System.Windows.Forms.ToolStripMenuItem(); + this.speed2fpmToolItem = new System.Windows.Forms.ToolStripMenuItem(); + this.slowerToolItem = new System.Windows.Forms.ToolStripButton(); + this.fasterToolItem = new System.Windows.Forms.ToolStripButton(); + this.onlineButton = new System.Windows.Forms.ToolStripDropDownButton(); + this.profileButton = new System.Windows.Forms.ToolStripMenuItem(); + this.logoutButton = new System.Windows.Forms.ToolStripMenuItem(); + this.loginButton = new System.Windows.Forms.ToolStripButton(); + this.versionButton = new System.Windows.Forms.ToolStripButton(); + this.tabControl = new System.Windows.Forms.TabControl(); + this.welcomeTab = new System.Windows.Forms.TabPage(); + this.infoWebBrowser = new AntMe.Gui.WebBrowserEx(); + this.timer = new System.Windows.Forms.Timer(this.components); + this.menuStrip.SuspendLayout(); + this.statusStrip.SuspendLayout(); + this.toolStrip.SuspendLayout(); + this.tabControl.SuspendLayout(); + this.welcomeTab.SuspendLayout(); + this.SuspendLayout(); + // + // menuStrip + // + resources.ApplyResources(this.menuStrip, "menuStrip"); + this.menuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.programMenuItem, + this.settingsMenuItem, + this.helpMenuItem}); + this.menuStrip.Name = "menuStrip"; + // + // programMenuItem + // + resources.ApplyResources(this.programMenuItem, "programMenuItem"); + this.programMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startMenuItem, + this.stopMenuItem, + this.pauseMenuItem, + this.group1MenuItem, + this.closeMenuItem}); + this.programMenuItem.Name = "programMenuItem"; + // + // startMenuItem + // + resources.ApplyResources(this.startMenuItem, "startMenuItem"); + this.startMenuItem.Image = global::AntMe.Gui.Properties.Resources.play; + this.startMenuItem.Name = "startMenuItem"; + this.startMenuItem.Click += new System.EventHandler(this.start); + // + // stopMenuItem + // + resources.ApplyResources(this.stopMenuItem, "stopMenuItem"); + this.stopMenuItem.Image = global::AntMe.Gui.Properties.Resources.stop; + this.stopMenuItem.Name = "stopMenuItem"; + this.stopMenuItem.Click += new System.EventHandler(this.stop); + // + // pauseMenuItem + // + resources.ApplyResources(this.pauseMenuItem, "pauseMenuItem"); + this.pauseMenuItem.Image = global::AntMe.Gui.Properties.Resources.pause; + this.pauseMenuItem.Name = "pauseMenuItem"; + this.pauseMenuItem.Click += new System.EventHandler(this.pause); + // + // group1MenuItem + // + resources.ApplyResources(this.group1MenuItem, "group1MenuItem"); + this.group1MenuItem.Name = "group1MenuItem"; + // + // closeMenuItem + // + resources.ApplyResources(this.closeMenuItem, "closeMenuItem"); + this.closeMenuItem.Name = "closeMenuItem"; + this.closeMenuItem.Click += new System.EventHandler(this.button_close); + // + // settingsMenuItem + // + resources.ApplyResources(this.settingsMenuItem, "settingsMenuItem"); + this.settingsMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.pluginSettingsMenuItem, + this.speedMenuItem, + this.languageMenuItem, + this.updateMenuItem}); + this.settingsMenuItem.Name = "settingsMenuItem"; + // + // pluginSettingsMenuItem + // + resources.ApplyResources(this.pluginSettingsMenuItem, "pluginSettingsMenuItem"); + this.pluginSettingsMenuItem.Name = "pluginSettingsMenuItem"; + this.pluginSettingsMenuItem.Click += new System.EventHandler(this.button_plugins); + // + // speedMenuItem + // + resources.ApplyResources(this.speedMenuItem, "speedMenuItem"); + this.speedMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.speedMaxMenuItem, + this.speed100fpmMenuItem, + this.speed80fpmMenuItem, + this.speed50fpmMenuItem, + this.speed30fpmMenuItem, + this.speed22fpmMenuItem, + this.speed15fpmMenuItem, + this.speed8fpmMenuItem, + this.speed2fpmMenuItem}); + this.speedMenuItem.Image = global::AntMe.Gui.Properties.Resources.speed; + this.speedMenuItem.Name = "speedMenuItem"; + // + // speedMaxMenuItem + // + resources.ApplyResources(this.speedMaxMenuItem, "speedMaxMenuItem"); + this.speedMaxMenuItem.Name = "speedMaxMenuItem"; + this.speedMaxMenuItem.Click += new System.EventHandler(this.button_limitSetToMax); + // + // speed100fpmMenuItem + // + resources.ApplyResources(this.speed100fpmMenuItem, "speed100fpmMenuItem"); + this.speed100fpmMenuItem.Name = "speed100fpmMenuItem"; + this.speed100fpmMenuItem.Click += new System.EventHandler(this.button_limitSetTo100); + // + // speed80fpmMenuItem + // + resources.ApplyResources(this.speed80fpmMenuItem, "speed80fpmMenuItem"); + this.speed80fpmMenuItem.Name = "speed80fpmMenuItem"; + this.speed80fpmMenuItem.Click += new System.EventHandler(this.button_limitSetTo80); + // + // speed50fpmMenuItem + // + resources.ApplyResources(this.speed50fpmMenuItem, "speed50fpmMenuItem"); + this.speed50fpmMenuItem.Name = "speed50fpmMenuItem"; + this.speed50fpmMenuItem.Click += new System.EventHandler(this.button_limitSetTo50); + // + // speed30fpmMenuItem + // + resources.ApplyResources(this.speed30fpmMenuItem, "speed30fpmMenuItem"); + this.speed30fpmMenuItem.Name = "speed30fpmMenuItem"; + this.speed30fpmMenuItem.Click += new System.EventHandler(this.button_limitSetTo30); + // + // speed22fpmMenuItem + // + resources.ApplyResources(this.speed22fpmMenuItem, "speed22fpmMenuItem"); + this.speed22fpmMenuItem.Name = "speed22fpmMenuItem"; + this.speed22fpmMenuItem.Click += new System.EventHandler(this.button_limitSetTo22); + // + // speed15fpmMenuItem + // + resources.ApplyResources(this.speed15fpmMenuItem, "speed15fpmMenuItem"); + this.speed15fpmMenuItem.Name = "speed15fpmMenuItem"; + this.speed15fpmMenuItem.Click += new System.EventHandler(this.button_limitSetTo15); + // + // speed8fpmMenuItem + // + resources.ApplyResources(this.speed8fpmMenuItem, "speed8fpmMenuItem"); + this.speed8fpmMenuItem.Name = "speed8fpmMenuItem"; + this.speed8fpmMenuItem.Click += new System.EventHandler(this.button_limitSetTo8); + // + // speed2fpmMenuItem + // + resources.ApplyResources(this.speed2fpmMenuItem, "speed2fpmMenuItem"); + this.speed2fpmMenuItem.Name = "speed2fpmMenuItem"; + this.speed2fpmMenuItem.Click += new System.EventHandler(this.button_limitSetTo2); + // + // languageMenuItem + // + resources.ApplyResources(this.languageMenuItem, "languageMenuItem"); + this.languageMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.germanMenuItem, + this.englishMenuItem}); + this.languageMenuItem.Name = "languageMenuItem"; + // + // germanMenuItem + // + resources.ApplyResources(this.germanMenuItem, "germanMenuItem"); + this.germanMenuItem.Name = "germanMenuItem"; + this.germanMenuItem.Click += new System.EventHandler(this.button_german); + // + // englishMenuItem + // + resources.ApplyResources(this.englishMenuItem, "englishMenuItem"); + this.englishMenuItem.Name = "englishMenuItem"; + this.englishMenuItem.Click += new System.EventHandler(this.button_english); + // + // updateMenuItem + // + resources.ApplyResources(this.updateMenuItem, "updateMenuItem"); + this.updateMenuItem.Name = "updateMenuItem"; + this.updateMenuItem.Click += new System.EventHandler(this.button_switchAutoupdate); + // + // helpMenuItem + // + resources.ApplyResources(this.helpMenuItem, "helpMenuItem"); + this.helpMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.tutorialsMenuItem, + this.forumMenuItem, + this.websiteMenuItem, + this.classDescriptionMenuItem, + this.group2MenuItem, + this.infoBoxMenuItem}); + this.helpMenuItem.Name = "helpMenuItem"; + // + // tutorialsMenuItem + // + resources.ApplyResources(this.tutorialsMenuItem, "tutorialsMenuItem"); + this.tutorialsMenuItem.Name = "tutorialsMenuItem"; + this.tutorialsMenuItem.Click += new System.EventHandler(this.button_tutorials); + // + // forumMenuItem + // + resources.ApplyResources(this.forumMenuItem, "forumMenuItem"); + this.forumMenuItem.Name = "forumMenuItem"; + this.forumMenuItem.Click += new System.EventHandler(this.button_forum); + // + // websiteMenuItem + // + resources.ApplyResources(this.websiteMenuItem, "websiteMenuItem"); + this.websiteMenuItem.Name = "websiteMenuItem"; + this.websiteMenuItem.Click += new System.EventHandler(this.button_website); + // + // classDescriptionMenuItem + // + resources.ApplyResources(this.classDescriptionMenuItem, "classDescriptionMenuItem"); + this.classDescriptionMenuItem.Name = "classDescriptionMenuItem"; + this.classDescriptionMenuItem.Click += new System.EventHandler(this.button_classDescription); + // + // group2MenuItem + // + resources.ApplyResources(this.group2MenuItem, "group2MenuItem"); + this.group2MenuItem.Name = "group2MenuItem"; + // + // infoBoxMenuItem + // + resources.ApplyResources(this.infoBoxMenuItem, "infoBoxMenuItem"); + this.infoBoxMenuItem.Name = "infoBoxMenuItem"; + this.infoBoxMenuItem.Click += new System.EventHandler(this.button_info); + // + // statusStrip + // + resources.ApplyResources(this.statusStrip, "statusStrip"); + this.statusStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.stateLabelBarItem, + this.progressBarItem, + this.stepCounterBarItem, + this.fpsBarItem}); + this.statusStrip.Name = "statusStrip"; + // + // stateLabelBarItem + // + resources.ApplyResources(this.stateLabelBarItem, "stateLabelBarItem"); + this.stateLabelBarItem.Name = "stateLabelBarItem"; + this.stateLabelBarItem.Overflow = System.Windows.Forms.ToolStripItemOverflow.Never; + // + // progressBarItem + // + resources.ApplyResources(this.progressBarItem, "progressBarItem"); + this.progressBarItem.Name = "progressBarItem"; + this.progressBarItem.Style = System.Windows.Forms.ProgressBarStyle.Continuous; + // + // stepCounterBarItem + // + resources.ApplyResources(this.stepCounterBarItem, "stepCounterBarItem"); + this.stepCounterBarItem.Name = "stepCounterBarItem"; + // + // fpsBarItem + // + resources.ApplyResources(this.fpsBarItem, "fpsBarItem"); + this.fpsBarItem.Name = "fpsBarItem"; + this.fpsBarItem.Spring = true; + // + // toolStrip + // + resources.ApplyResources(this.toolStrip, "toolStrip"); + this.toolStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startToolItem, + this.stopToolItem, + this.pauseToolItem, + this.group1ToolItem, + this.sourceLabelToolItem, + this.producerComboBoxToolItem, + this.group2ToolItem, + this.speedLabelToolItem, + this.speedDropDownToolItem, + this.slowerToolItem, + this.fasterToolItem, + this.onlineButton, + this.loginButton, + this.versionButton}); + this.toolStrip.Name = "toolStrip"; + // + // startToolItem + // + resources.ApplyResources(this.startToolItem, "startToolItem"); + this.startToolItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.startToolItem.Image = global::AntMe.Gui.Properties.Resources.play; + this.startToolItem.Name = "startToolItem"; + this.startToolItem.Click += new System.EventHandler(this.start); + // + // stopToolItem + // + resources.ApplyResources(this.stopToolItem, "stopToolItem"); + this.stopToolItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.stopToolItem.Image = global::AntMe.Gui.Properties.Resources.stop; + this.stopToolItem.Name = "stopToolItem"; + this.stopToolItem.Click += new System.EventHandler(this.stop); + // + // pauseToolItem + // + resources.ApplyResources(this.pauseToolItem, "pauseToolItem"); + this.pauseToolItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.pauseToolItem.Image = global::AntMe.Gui.Properties.Resources.pause; + this.pauseToolItem.Name = "pauseToolItem"; + this.pauseToolItem.Click += new System.EventHandler(this.pause); + // + // group1ToolItem + // + resources.ApplyResources(this.group1ToolItem, "group1ToolItem"); + this.group1ToolItem.Name = "group1ToolItem"; + // + // sourceLabelToolItem + // + resources.ApplyResources(this.sourceLabelToolItem, "sourceLabelToolItem"); + this.sourceLabelToolItem.Name = "sourceLabelToolItem"; + // + // producerComboBoxToolItem + // + resources.ApplyResources(this.producerComboBoxToolItem, "producerComboBoxToolItem"); + this.producerComboBoxToolItem.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.producerComboBoxToolItem.Name = "producerComboBoxToolItem"; + this.producerComboBoxToolItem.SelectedIndexChanged += new System.EventHandler(this.combo_producer); + // + // group2ToolItem + // + resources.ApplyResources(this.group2ToolItem, "group2ToolItem"); + this.group2ToolItem.Name = "group2ToolItem"; + // + // speedLabelToolItem + // + resources.ApplyResources(this.speedLabelToolItem, "speedLabelToolItem"); + this.speedLabelToolItem.Name = "speedLabelToolItem"; + // + // speedDropDownToolItem + // + resources.ApplyResources(this.speedDropDownToolItem, "speedDropDownToolItem"); + this.speedDropDownToolItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.speedMaxToolItem, + this.speed100fpmToolItem, + this.speed80fpmToolItem, + this.speed50fpmToolItem, + this.speed30fpmToolItem, + this.speed22fpmToolItem, + this.speed15fpmToolItem, + this.speed8fpmToolItem, + this.speed2fpmToolItem}); + this.speedDropDownToolItem.Image = global::AntMe.Gui.Properties.Resources.speed; + this.speedDropDownToolItem.Name = "speedDropDownToolItem"; + // + // speedMaxToolItem + // + resources.ApplyResources(this.speedMaxToolItem, "speedMaxToolItem"); + this.speedMaxToolItem.Name = "speedMaxToolItem"; + this.speedMaxToolItem.Click += new System.EventHandler(this.button_limitSetToMax); + // + // speed100fpmToolItem + // + resources.ApplyResources(this.speed100fpmToolItem, "speed100fpmToolItem"); + this.speed100fpmToolItem.Name = "speed100fpmToolItem"; + this.speed100fpmToolItem.Click += new System.EventHandler(this.button_limitSetTo100); + // + // speed80fpmToolItem + // + resources.ApplyResources(this.speed80fpmToolItem, "speed80fpmToolItem"); + this.speed80fpmToolItem.Name = "speed80fpmToolItem"; + this.speed80fpmToolItem.Click += new System.EventHandler(this.button_limitSetTo80); + // + // speed50fpmToolItem + // + resources.ApplyResources(this.speed50fpmToolItem, "speed50fpmToolItem"); + this.speed50fpmToolItem.Name = "speed50fpmToolItem"; + this.speed50fpmToolItem.Click += new System.EventHandler(this.button_limitSetTo50); + // + // speed30fpmToolItem + // + resources.ApplyResources(this.speed30fpmToolItem, "speed30fpmToolItem"); + this.speed30fpmToolItem.Name = "speed30fpmToolItem"; + this.speed30fpmToolItem.Click += new System.EventHandler(this.button_limitSetTo30); + // + // speed22fpmToolItem + // + resources.ApplyResources(this.speed22fpmToolItem, "speed22fpmToolItem"); + this.speed22fpmToolItem.Name = "speed22fpmToolItem"; + this.speed22fpmToolItem.Click += new System.EventHandler(this.button_limitSetTo22); + // + // speed15fpmToolItem + // + resources.ApplyResources(this.speed15fpmToolItem, "speed15fpmToolItem"); + this.speed15fpmToolItem.Name = "speed15fpmToolItem"; + this.speed15fpmToolItem.Click += new System.EventHandler(this.button_limitSetTo15); + // + // speed8fpmToolItem + // + resources.ApplyResources(this.speed8fpmToolItem, "speed8fpmToolItem"); + this.speed8fpmToolItem.Name = "speed8fpmToolItem"; + this.speed8fpmToolItem.Click += new System.EventHandler(this.button_limitSetTo8); + // + // speed2fpmToolItem + // + resources.ApplyResources(this.speed2fpmToolItem, "speed2fpmToolItem"); + this.speed2fpmToolItem.Name = "speed2fpmToolItem"; + this.speed2fpmToolItem.Click += new System.EventHandler(this.button_limitSetTo2); + // + // slowerToolItem + // + resources.ApplyResources(this.slowerToolItem, "slowerToolItem"); + this.slowerToolItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.slowerToolItem.Image = global::AntMe.Gui.Properties.Resources.downarrow; + this.slowerToolItem.Name = "slowerToolItem"; + this.slowerToolItem.Click += new System.EventHandler(this.button_limitSlower); + // + // fasterToolItem + // + resources.ApplyResources(this.fasterToolItem, "fasterToolItem"); + this.fasterToolItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.fasterToolItem.Image = global::AntMe.Gui.Properties.Resources.uparrow; + this.fasterToolItem.Name = "fasterToolItem"; + this.fasterToolItem.Click += new System.EventHandler(this.button_limitFaster); + // + // onlineButton + // + resources.ApplyResources(this.onlineButton, "onlineButton"); + this.onlineButton.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right; + this.onlineButton.AutoToolTip = false; + this.onlineButton.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.profileButton, + this.logoutButton}); + this.onlineButton.Image = global::AntMe.Gui.Properties.Resources.online; + this.onlineButton.Name = "onlineButton"; + // + // profileButton + // + resources.ApplyResources(this.profileButton, "profileButton"); + this.profileButton.Name = "profileButton"; + this.profileButton.Click += new System.EventHandler(this.profileButton_Click); + // + // logoutButton + // + resources.ApplyResources(this.logoutButton, "logoutButton"); + this.logoutButton.Name = "logoutButton"; + this.logoutButton.Click += new System.EventHandler(this.logoutButton_Click); + // + // loginButton + // + resources.ApplyResources(this.loginButton, "loginButton"); + this.loginButton.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right; + this.loginButton.Image = global::AntMe.Gui.Properties.Resources.offline; + this.loginButton.Name = "loginButton"; + this.loginButton.Click += new System.EventHandler(this.loginButton_Click); + // + // versionButton + // + resources.ApplyResources(this.versionButton, "versionButton"); + this.versionButton.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right; + this.versionButton.AutoToolTip = false; + this.versionButton.Image = global::AntMe.Gui.Properties.Resources.warning; + this.versionButton.Name = "versionButton"; + this.versionButton.Click += new System.EventHandler(this.versionButton_Click); + // + // tabControl + // + resources.ApplyResources(this.tabControl, "tabControl"); + this.tabControl.Controls.Add(this.welcomeTab); + this.tabControl.Name = "tabControl"; + this.tabControl.SelectedIndex = 0; + this.tabControl.Selecting += new System.Windows.Forms.TabControlCancelEventHandler(this.tab_select); + // + // welcomeTab + // + resources.ApplyResources(this.welcomeTab, "welcomeTab"); + this.welcomeTab.Controls.Add(this.infoWebBrowser); + this.welcomeTab.Name = "welcomeTab"; + this.welcomeTab.UseVisualStyleBackColor = true; + // + // infoWebBrowser + // + resources.ApplyResources(this.infoWebBrowser, "infoWebBrowser"); + this.infoWebBrowser.IsWebBrowserContextMenuEnabled = false; + this.infoWebBrowser.Name = "infoWebBrowser"; + this.infoWebBrowser.ScriptErrorsSuppressed = true; + this.infoWebBrowser.WebBrowserShortcutsEnabled = false; + this.infoWebBrowser.NavigateError += new AntMe.Gui.WebBrowserNavigateErrorEventHandler(this.infoWebBrowser_NavigateError); + // + // timer + // + this.timer.Tick += new System.EventHandler(this.timer_tick); + // + // Main + // + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.tabControl); + this.Controls.Add(this.toolStrip); + this.Controls.Add(this.statusStrip); + this.Controls.Add(this.menuStrip); + this.MainMenuStrip = this.menuStrip; + this.Name = "Main"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.form_close); + this.Shown += new System.EventHandler(this.form_shown); + this.Move += new System.EventHandler(this.form_resize); + this.Resize += new System.EventHandler(this.form_resize); + this.menuStrip.ResumeLayout(false); + this.menuStrip.PerformLayout(); + this.statusStrip.ResumeLayout(false); + this.statusStrip.PerformLayout(); + this.toolStrip.ResumeLayout(false); + this.toolStrip.PerformLayout(); + this.tabControl.ResumeLayout(false); + this.welcomeTab.ResumeLayout(false); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.MenuStrip menuStrip; + private System.Windows.Forms.StatusStrip statusStrip; + private System.Windows.Forms.ToolStrip toolStrip; + private System.Windows.Forms.ToolStripMenuItem programMenuItem; + private System.Windows.Forms.ToolStripMenuItem helpMenuItem; + private System.Windows.Forms.ToolStripButton startToolItem; + private System.Windows.Forms.ToolStripButton stopToolItem; + private System.Windows.Forms.ToolStripButton pauseToolItem; + private System.Windows.Forms.TabControl tabControl; + private System.Windows.Forms.TabPage welcomeTab; + private System.Windows.Forms.ToolStripMenuItem startMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopMenuItem; + private System.Windows.Forms.ToolStripMenuItem pauseMenuItem; + private System.Windows.Forms.ToolStripSeparator group1MenuItem; + private System.Windows.Forms.ToolStripMenuItem closeMenuItem; + private System.Windows.Forms.ToolStripMenuItem tutorialsMenuItem; + private System.Windows.Forms.ToolStripMenuItem forumMenuItem; + private System.Windows.Forms.ToolStripMenuItem websiteMenuItem; + private System.Windows.Forms.ToolStripMenuItem classDescriptionMenuItem; + private System.Windows.Forms.ToolStripSeparator group2MenuItem; + private System.Windows.Forms.ToolStripMenuItem infoBoxMenuItem; + private WebBrowserEx infoWebBrowser; + private System.Windows.Forms.ToolStripComboBox producerComboBoxToolItem; + private System.Windows.Forms.ToolStripLabel sourceLabelToolItem; + private System.Windows.Forms.ToolStripSeparator group1ToolItem; + private System.Windows.Forms.Timer timer; + private System.Windows.Forms.ToolStripStatusLabel stateLabelBarItem; + private System.Windows.Forms.ToolStripProgressBar progressBarItem; + private System.Windows.Forms.ToolStripStatusLabel stepCounterBarItem; + private System.Windows.Forms.ToolStripStatusLabel fpsBarItem; + private System.Windows.Forms.ToolStripSeparator group2ToolItem; + private System.Windows.Forms.ToolStripMenuItem speedMenuItem; + private System.Windows.Forms.ToolStripDropDownButton speedDropDownToolItem; + private System.Windows.Forms.ToolStripMenuItem speedMaxToolItem; + private System.Windows.Forms.ToolStripMenuItem speed100fpmToolItem; + private System.Windows.Forms.ToolStripMenuItem speed15fpmToolItem; + private System.Windows.Forms.ToolStripButton slowerToolItem; + private System.Windows.Forms.ToolStripButton fasterToolItem; + private System.Windows.Forms.ToolStripMenuItem speedMaxMenuItem; + private System.Windows.Forms.ToolStripMenuItem speed100fpmMenuItem; + private System.Windows.Forms.ToolStripMenuItem speed80fpmMenuItem; + private System.Windows.Forms.ToolStripMenuItem speed50fpmMenuItem; + private System.Windows.Forms.ToolStripMenuItem speed80fpmToolItem; + private System.Windows.Forms.ToolStripMenuItem speed50fpmToolItem; + private System.Windows.Forms.ToolStripMenuItem speed30fpmToolItem; + private System.Windows.Forms.ToolStripMenuItem speed22fpmToolItem; + private System.Windows.Forms.ToolStripMenuItem speed8fpmToolItem; + private System.Windows.Forms.ToolStripMenuItem speed2fpmToolItem; + private System.Windows.Forms.ToolStripLabel speedLabelToolItem; + private System.Windows.Forms.ToolStripMenuItem speed30fpmMenuItem; + private System.Windows.Forms.ToolStripMenuItem speed22fpmMenuItem; + private System.Windows.Forms.ToolStripMenuItem speed15fpmMenuItem; + private System.Windows.Forms.ToolStripMenuItem speed8fpmMenuItem; + private System.Windows.Forms.ToolStripMenuItem speed2fpmMenuItem; + private System.Windows.Forms.ToolStripMenuItem settingsMenuItem; + private System.Windows.Forms.ToolStripMenuItem pluginSettingsMenuItem; + private System.Windows.Forms.ToolStripMenuItem languageMenuItem; + private System.Windows.Forms.ToolStripMenuItem germanMenuItem; + private System.Windows.Forms.ToolStripMenuItem englishMenuItem; + private System.Windows.Forms.ToolStripMenuItem updateMenuItem; + private System.Windows.Forms.ToolStripDropDownButton onlineButton; + private System.Windows.Forms.ToolStripMenuItem profileButton; + private System.Windows.Forms.ToolStripMenuItem logoutButton; + private System.Windows.Forms.ToolStripButton loginButton; + private System.Windows.Forms.ToolStripButton versionButton; + } +} \ No newline at end of file diff --git a/AntMe/Main.cs b/AntMe/Main.cs new file mode 100644 index 0000000..e3d48e6 --- /dev/null +++ b/AntMe/Main.cs @@ -0,0 +1,724 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Threading; +using System.Windows.Forms; + +using AntMe.Gui.Properties; +using AntMe.SharedComponents.Plugin; +using System.Reflection; +using AntMe.Online.Client; +using System.Diagnostics; +using System.Drawing; +using System.Threading.Tasks; + +namespace AntMe.Gui +{ + internal sealed partial class Main : Form + { + #region Variablen + + private readonly PluginManager manager; + + private PluginItem activeProducer; + private readonly List activeConsumers = new List(); + private bool ignoreTimerEvents = false; + private readonly bool initPhase = false; + private bool restart = false; + private readonly bool directstart = false; + private string updateUrl = string.Empty; + + #endregion + + #region Konstruktor und Initialisierung + + public Main(string[] parameter) + { + initPhase = true; + + InitializeComponent(); + onlineButton.Tag = ConnectionState.Connected; + CreateHandle(); + + // check Language-buttons + switch (Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName) + { + case "de": + germanMenuItem.Checked = true; + break; + default: + englishMenuItem.Checked = true; + break; + } + + // Load welcomepage + try + { + // Localize + string lan = Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName; + infoWebBrowser.Navigate("http://antmeservice.azurewebsites.net/Application/StartPage?culture=" + lan); + } + catch { } + + manager = new PluginManager(); + + try + { + manager.LoadSettings(); + } + catch (Exception ex) + { + ExceptionViewer problems = new ExceptionViewer(ex); + problems.ShowDialog(this); + } + + // Set Window-Position + WindowState = Settings.Default.windowState; + Location = Settings.Default.windowPosition; + Size = Settings.Default.windowSize; + + manager.SearchForPlugins(); + timer.Enabled = true; + + // Forward startparameter + foreach (PluginItem plugin in manager.ProducerPlugins) + { + plugin.Producer.StartupParameter(parameter); + } + foreach (PluginItem plugin in manager.ConsumerPlugins) + { + plugin.Consumer.StartupParameter(parameter); + } + + foreach (string p in parameter) + { + if (p.ToUpper() == "/START") + { + directstart = true; + } + } + + initPhase = false; + + // Prüfe auf Updates + Task t = new Task(BackgroundUpdateCheck); + t.Start(); + } + + #endregion + + #region Frontend- und Interaktionshandling + + /// + /// Make updates based on manager-settings + /// + private void updatePanel() + { + + if (ignoreTimerEvents) + { + return; + } + + ignoreTimerEvents = true; + + // Controlling-Buttons + startMenuItem.Enabled = manager.CanStart; + startToolItem.Enabled = manager.CanStart; + pauseToolItem.Enabled = manager.CanPause; + pauseMenuItem.Enabled = manager.CanPause; + stopToolItem.Enabled = manager.CanStop; + stopMenuItem.Enabled = manager.CanStop; + + if (manager.FrameLimiterEnabled) + { + if ((int)Math.Round(manager.FrameLimit) <= 100) + { + fasterToolItem.Enabled = true; + } + else + { + fasterToolItem.Enabled = false; + } + if ((int)Math.Round(manager.FrameLimit) > 1) + { + slowerToolItem.Enabled = true; + } + else + { + slowerToolItem.Enabled = false; + } + + speedDropDownToolItem.Text = string.Format(Resource.MainFramesPerSecond, manager.FrameLimit); + } + else + { + slowerToolItem.Enabled = false; + fasterToolItem.Enabled = false; + speedDropDownToolItem.Text = Resource.MainSpeedMaximal; + } + + // producer-list + List producerList = new List(manager.ProducerPlugins); + for (int i = 0; i < producerComboBoxToolItem.Items.Count; i++) + { + PluginItem item = (PluginItem)producerComboBoxToolItem.Items[i]; + if (!producerList.Contains(item)) + { + producerComboBoxToolItem.Items.Remove(item); + i--; + } + } + foreach (PluginItem item in producerList) + { + if (!producerComboBoxToolItem.Items.Contains(item)) + { + producerComboBoxToolItem.Items.Add(item); + } + } + + // manage tabs + if (activeProducer != manager.ActiveProducerPlugin) + { + // Update Combobox + producerComboBoxToolItem.SelectedItem = manager.ActiveProducerPlugin; + + // remove old tab + if (activeProducer != null) + { + if (activeProducer.Producer.Control != null) + { + tabControl.TabPages.RemoveAt(1); + } + activeProducer = null; + } + + // add new tab + if (manager.ActiveProducerPlugin != null) + { + if (manager.ActiveProducerPlugin.Producer.Control != null) + { + TabPage page = new TabPage(manager.ActiveProducerPlugin.Name); + page.Controls.Add(manager.ActiveProducerPlugin.Producer.Control); + tabControl.TabPages.Insert(1, page); + manager.ActiveProducerPlugin.Producer.Control.Dock = DockStyle.Fill; + } + activeProducer = manager.ActiveProducerPlugin; + } + } + + // synchronize Consumer + List newActiveConsumers = new List(manager.ActiveConsumerPlugins); + for (int i = activeConsumers.Count - 1; i >= 0; i--) + { + // Kick the old tab + if (!newActiveConsumers.Contains(activeConsumers[i])) + { + if (tabControl.TabPages.ContainsKey(activeConsumers[i].Guid.ToString())) + { + tabControl.TabPages.RemoveByKey(activeConsumers[i].Guid.ToString()); + } + activeConsumers.Remove(activeConsumers[i]); + } + } + foreach (PluginItem plugin in newActiveConsumers) + { + //Create new, if needed + if (!activeConsumers.Contains(plugin)) + { + // Create Tab and place control + if (plugin.Consumer.Control != null) + { + tabControl.TabPages.Add(plugin.Guid.ToString(), plugin.Name); + tabControl.TabPages[plugin.Guid.ToString()].Controls.Add(plugin.Consumer.Control); + plugin.Consumer.Control.Dock = DockStyle.Fill; + } + activeConsumers.Add(plugin); + } + } + + // popup exceptions + if (manager.Exceptions.Count > 0) + { + ExceptionViewer problems = new ExceptionViewer(manager.Exceptions); + problems.ShowDialog(this); + manager.Exceptions.Clear(); + } + + // StatusBar-information + stateLabelBarItem.Text = string.Empty; + switch (manager.State) + { + case PluginState.NotReady: + stateLabelBarItem.Text = Resource.MainStateNotReady; + break; + case PluginState.Paused: + stateLabelBarItem.Text = Resource.MainStatePaused; + break; + case PluginState.Ready: + stateLabelBarItem.Text = Resource.MainStateReady; + break; + case PluginState.Running: + stateLabelBarItem.Text = Resource.MainStateRunning; + break; + } + + if (manager.State == PluginState.Running || manager.State == PluginState.Paused) + { + progressBarItem.Maximum = manager.TotalRounds; + progressBarItem.Value = manager.CurrentRound; + stepCounterBarItem.Text = string.Format(Resource.MainStateRoundIndicator, manager.CurrentRound, manager.TotalRounds); + progressBarItem.Visible = true; + stepCounterBarItem.Visible = true; + } + else + { + progressBarItem.Visible = false; + stepCounterBarItem.Visible = false; + } + + if (manager.State == PluginState.Running) + { + fpsBarItem.Text = manager.FrameRate.ToString(Resource.MainStateFramesPerSecond); + fpsBarItem.Visible = true; + } + else + { + fpsBarItem.Visible = false; + } + + // Online Connector + onlineButton.Text = Connection.Instance.Username; + onlineButton.Visible = Connection.Instance.IsLoggedIn; + onlineButton.Enabled = !Connection.Instance.IsBusy; + if ((ConnectionState)onlineButton.Tag != Connection.Instance.State) + { + switch (Connection.Instance.State) + { + case ConnectionState.NoConnection: + onlineButton .Image = Properties.Resources.connection; + onlineButton.ToolTipText = Resource.UpdateNoConnection; + break; + case ConnectionState.TokenInvalid: + onlineButton.Image = Properties.Resources.warning; + onlineButton.ToolTipText = Resource.UpdateTokenInvalid; + break; + default: + onlineButton.Image = Properties.Resources.online; + onlineButton.ToolTipText = string.Empty; + break; + } + onlineButton.Tag = Connection.Instance.State; + } + + loginButton.Visible = !Connection.Instance.IsLoggedIn; + loginButton.Enabled = !Connection.Instance.IsBusy; + + versionButton.Visible = !string.IsNullOrEmpty(Properties.Settings.Default.updateLink); + + ignoreTimerEvents = false; + } + + #endregion + + #region Formularfunktionen + + #region form + + private void form_shown(object sender, EventArgs e) + { + updatePanel(); + + if (manager.Exceptions.Count > 0) + { + ExceptionViewer problems = new ExceptionViewer(manager.Exceptions); + problems.ShowDialog(this); + manager.Exceptions.Clear(); + } + + // force a direkt start, if manager is ready + if (manager.CanStart && directstart) + { + start(sender, e); + } + } + + private void form_close(object sender, FormClosingEventArgs e) + { + if (manager.CanStop) + { + manager.Stop(); + } + + // Alle Plugin-Einstellungen absichern + Settings.Default.Save(); + manager.SaveSettings(); + + // show possible problems + if (manager.Exceptions != null && manager.Exceptions.Count > 0) + { + ExceptionViewer form = new ExceptionViewer(manager.Exceptions); + manager.Exceptions.Clear(); + form.ShowDialog(this); + } + } + + private void form_resize(object sender, EventArgs e) + { + if (initPhase) + { + return; + } + + if (WindowState == FormWindowState.Normal) + { + Settings.Default.windowPosition = Location; + Settings.Default.windowSize = Size; + } + + if (WindowState != FormWindowState.Minimized) + { + Settings.Default.windowState = WindowState; + } + } + + #endregion + + #region tab + + private void tab_select(object sender, TabControlCancelEventArgs e) + { + if (e.TabPage.Tag != null) + { + manager.SetVisiblePlugin(((PluginItem)e.TabPage.Tag).Guid); + } + else + { + manager.SetVisiblePlugin(new Guid()); + } + } + + #endregion + + #region buttons + + private void button_close(object sender, EventArgs e) + { + Close(); + } + + private void button_website(object sender, EventArgs e) + { + Help.ShowHelp(this, Resource.MainWebsiteLink); + } + + private void button_plugins(object sender, EventArgs e) + { + ignoreTimerEvents = true; + Plugins pluginForm = new Plugins(manager); + pluginForm.ShowDialog(this); + ignoreTimerEvents = false; + updatePanel(); + } + + private void button_tutorials(object sender, EventArgs e) + { + // Es wurde Hilfe angefordert. Hier wird geprüft ob eine Hilfe verfügbar ist + if (File.Exists(Resource.MainTutorialPath)) + { + Help.ShowHelp(this, Resource.MainTutorialPath); + } + else + { + MessageBox.Show( + this, + Resource.MainMessageBoxNoTutorialMessage, + Resource.MainMessageBoxNoTutorialTitle, + MessageBoxButtons.OK, + MessageBoxIcon.Error, + MessageBoxDefaultButton.Button1); + } + } + + private void button_classDescription(object sender, EventArgs e) + { + // Klassen-Browser soll angezeigt werden + if (File.Exists(Resource.MainClassDescriptionPath)) + { + Help.ShowHelp(this, Resource.MainClassDescriptionPath); + } + else + { + MessageBox.Show( + this, + Resource.MainMessageBoxNoClassdescriptionMessage, + Resource.MainMessageBoxNoClassdescriptionTitle, + MessageBoxButtons.OK, + MessageBoxIcon.Error, + MessageBoxDefaultButton.Button1); + } + } + + private void button_info(object sender, EventArgs e) + { + InfoBox infoBox = new InfoBox(); + infoBox.ShowDialog(this); + } + + private void button_forum(object sender, EventArgs e) + { + Help.ShowHelp(this, Resource.MainForumLink); + } + + private void button_limitSetTo2(object sender, EventArgs e) + { + manager.SetSpeedLimit(true, 2.0f); + } + + private void button_limitSetTo8(object sender, EventArgs e) + { + manager.SetSpeedLimit(true, 8.0f); + } + + private void button_limitSetTo15(object sender, EventArgs e) + { + manager.SetSpeedLimit(true, 15.0f); + } + + private void button_limitSetTo22(object sender, EventArgs e) + { + manager.SetSpeedLimit(true, 22.5f); + } + + private void button_limitSetTo30(object sender, EventArgs e) + { + manager.SetSpeedLimit(true, 30.0f); + } + + private void button_limitSetTo50(object sender, EventArgs e) + { + manager.SetSpeedLimit(true, 50.0f); + } + + private void button_limitSetTo80(object sender, EventArgs e) + { + manager.SetSpeedLimit(true, 80.0f); + } + + private void button_limitSetTo100(object sender, EventArgs e) + { + manager.SetSpeedLimit(true, 100.0f); + } + + private void button_limitSetToMax(object sender, EventArgs e) + { + manager.SetSpeedLimit(false, 0.0f); + } + + private void button_limitFaster(object sender, EventArgs e) + { + if (manager.FrameLimiterEnabled) + { + if ((int)Math.Round(manager.FrameLimit) < 100) + { + manager.SetSpeedLimit(true, (int)Math.Round(manager.FrameLimit) + 1); + } + else + { + manager.SetSpeedLimit(false, 0.0f); + } + } + } + + private void button_limitSlower(object sender, EventArgs e) + { + if (manager.FrameLimiterEnabled && (int)Math.Round(manager.FrameLimit) > 1) + { + manager.SetSpeedLimit(true, (int)Math.Round(manager.FrameLimit) - 1); + } + } + + private void button_german(object sender, EventArgs e) + { + Settings.Default.culture = "de"; + Settings.Default.Save(); + restart = true; + Close(); + } + + private void button_english(object sender, EventArgs e) + { + Settings.Default.culture = "en"; + Settings.Default.Save(); + restart = true; + Close(); + } + + private void button_switchAutoupdate(object sender, EventArgs e) + { + try + { + Uri download = Connection.Instance.CheckForUpdates( + Assembly.GetExecutingAssembly().GetName().Version); + + if (download != null) + { + if (MessageBox.Show(this, Resource.UpdateNewerMessage, + Resource.UpdateTitle, MessageBoxButtons.YesNo, MessageBoxIcon.Information) == System.Windows.Forms.DialogResult.Yes) + { + Process.Start(download.ToString()); + } + } + else + { + MessageBox.Show(this, Resource.UpdateNewestMessage, Resource.UpdateTitle, + MessageBoxButtons.OK, MessageBoxIcon.Information); + } + } + catch (Exception) + { + MessageBox.Show(this, Resource.UpdateErrorMessage, Resource.UpdateTitle, + MessageBoxButtons.OK, MessageBoxIcon.Warning); + } + } + + #endregion + + #region combos + + private void combo_producer(object sender, EventArgs e) + { + if (ignoreTimerEvents) + { + return; + } + + ignoreTimerEvents = true; + if (producerComboBoxToolItem.SelectedItem != null) + { + PluginItem plugin = (PluginItem)producerComboBoxToolItem.SelectedItem; + manager.ActivateProducer(plugin.Guid); + } + else + { + manager.ActivateProducer(new Guid()); + } + updatePanel(); + ignoreTimerEvents = false; + } + + #endregion + + #region timer + + private void timer_tick(object sender, EventArgs e) + { + if (!ignoreTimerEvents) + { + updatePanel(); + } + } + + #endregion + + #endregion + + #region Managersteuerung + + private void start(object sender, EventArgs e) + { + if (manager.CanStart) + { + manager.Start(); + + // Aktives Eingangsplugin anzeigen + if (activeProducer.Producer.Control != null) + { + tabControl.SelectedIndex = 1; + } + } + } + + private void stop(object sender, EventArgs e) + { + if (manager.CanStop) + { + manager.Stop(); + } + } + + private void pause(object sender, EventArgs e) + { + if (manager.CanPause) + { + manager.Pause(); + } + } + + #endregion + + public bool Restart + { + get { return restart; } + } + + + private void logoutButton_Click(object sender, EventArgs e) + { + if (Connection.Instance.IsLoggedIn) + Connection.Instance.Close(); + } + + private void profileButton_Click(object sender, EventArgs e) + { + Process.Start("http://service.antme.net"); + } + + private void loginButton_Click(object sender, EventArgs e) + { + if (!Connection.Instance.IsLoggedIn) + Connection.Instance.Open(this); + } + + private void BackgroundUpdateCheck() + { + // Check every day + if (Properties.Settings.Default.lastUpdateCheck < DateTime.Now.Date) + { + try + { + Uri download = Connection.Instance.CheckForUpdates( + Assembly.GetExecutingAssembly().GetName().Version); + + if (download != null) + Properties.Settings.Default.updateLink = download.ToString(); + else + Properties.Settings.Default.updateLink = string.Empty; + } + catch (Exception) {} + + Properties.Settings.Default.lastUpdateCheck = DateTime.Now.Date; + Properties.Settings.Default.Save(); + } + } + + private void infoWebBrowser_NavigateError(object sender, WebBrowserNavigateErrorEventArgs e) + { + infoWebBrowser.Navigate("file://" + Application.StartupPath + Resource.MainWelcomePagePath); + } + + private void versionButton_Click(object sender, EventArgs e) + { + if (MessageBox.Show(this, Resource.UpdateNewerMessage, Resource.UpdateTitle, + MessageBoxButtons.YesNo, MessageBoxIcon.Information) == System.Windows.Forms.DialogResult.Yes) + { + // Open Link + Process.Start(Properties.Settings.Default.updateLink); + + // Clear Update Link + Properties.Settings.Default.updateLink = string.Empty; + Properties.Settings.Default.Save(); + } + } + } +} \ No newline at end of file diff --git a/AntMe/Main.de.resx b/AntMe/Main.de.resx new file mode 100644 index 0000000..74a6f91 --- /dev/null +++ b/AntMe/Main.de.resx @@ -0,0 +1,4259 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + 76, 20 + + + Programm + + + 90, 20 + + + Einstellungen + + + Hilfe + + + 125, 22 + + + 125, 22 + + + Stopp + + + 125, 22 + + + 122, 6 + + + 125, 22 + + + Schließen + + + 161, 22 + + + 161, 22 + + + Geschwindigkeit + + + 161, 22 + + + Sprache + + + 118, 22 + + + Deutsch + + + 118, 22 + + + Englisch + + + 161, 22 + + + Updates suchen + + + 185, 22 + + + 185, 22 + + + 185, 22 + + + 185, 22 + + + Klassenbeschreibung + + + 182, 6 + + + 185, 22 + + + Ãœber AntMe!... + + + Stopp + + + 44, 22 + + + Quelle: + + + 97, 22 + + + Geschwindigkeit: + + + Langsamer + + + Schneller + + + 180, 22 + + + Konto Einstellungen + + + 180, 22 + + + Abmelden + + + 82, 22 + + + Anmelden + + + Melde dich hier mit deinem AntMe! Online Konto an + + + 97, 22 + + + Neue Version + + + Willkommen + + + + AAABABAAgIAAAAEACAAoTAAABgEAAEBAAAABAAgAKBYAAC5NAAAwMAAAAQAIAKgOAABWYwAAICAAAAEA + CACoCAAA/nEAABAQAAABAAgAaAUAAKZ6AACAgAAAAQAYACjIAAAOgAAAQEAAAAEAGAAoMgAANkgBADAw + AAABABgAqBwAAF56AQAgIAAAAQAYAKgMAAAGlwEAEBAAAAEAGABoAwAArqMBAAAAAAABACAAHHoAABan + AQCAgAAAAQAgACgIAQAyIQIAQEAAAAEAIAAoQgAAWikDADAwAAABACAAqCUAAIJrAwAgIAAAAQAgAKgQ + AAAqkQMAEBAAAAEAIABoBAAA0qEDACgAAACAAAAAAAEAAAEACAAAAAAAAEAAAAAAAAAAAAAAAAEAAAAB + AAAAAAAAPz9fABkZZQAWFm0AGBhqAA8PegAUFHMAHBxzABISewAfH3oAISFjACoqYgAtLW0ANDRjAD4+ + YAAyMmoAOztsACYmcQArK3MAIiJ9ACwsewA0NHUAPDx0ADw8fABBQWQASUllAENDbQBMTG8AU1NnAFRU + bABcXGsARERzAEtLcwBHR30ATU1/AFZWcQBZWXIAVVV+AFpafwBmZmYAYGBpAGtrawBnZ3IAZ2d4AHJy + cgBycn8Ae3t7AA4OhAAODowAEhKDABkZhAAREYsAGhqLAA0NkwAGBp4ADAybABERkwAbG5IAEBCZABAQ + nQAWFp0AGxuaACQkhAAtLYIAIyOMACwsiwAyMoQAOzuFADMziwA7O4wAJCSSACsrkQAiIpsALCycADQ0 + lAA9PZIAMzOcADw8mwA4OJ8APj6dAAYGpgALC6IABgaqAAkJqQAMDKkACgqtAAwMrQAQEKEAFRWiABAQ + pQAVFaUAGhqkABAQqQAVFaoAFRWtABoaqwAFBbMACQmxAAwMsQAJCbUADAy0AAUFugAKCrkAEhKyABsb + swAUFLwAGRm5AB0duQAYGL0AHh69ACQkpAAoKKEALy+hACwspAAiIqsAKSmtADMzogA6OqQAMTGsADo6 + rAAjI7MAKyu0ACMjvAArK7sAMTG0ADo6tAAzM7sAOzu8AEJChwBKSoUARESLAElJiwBcXIIAU1OMAFxc + igBDQ5EATEyTAENDmwBOTpoAVFSTAFpakgBTU54AXFyYAGFhhQBra4UAYmKKAGxsiwB3d4MAeHiEAHFx + iAB+fooAY2OTAGtrkwBiYpsAbGyaAHNzlQB7e5IAdHSaAEFBpABKSqQAQUGsAEpKrABXV6QAW1uiAFVV + qQBZWawARESyAEpKtQBERLwAS0u7AFFRswBVVbwAXFy+AGdnoQBqaqEAZGSuAGtrqgB2dqEAcHClAH9/ + ogBycqwAe3uoAH5+qQB9fawAYWGxAGRksgBiYrUAa2u2AGNjvQBpabwAdXW1AHR0ugB9fbgAFBTAABsb + wwAcHMkAJCTDACsrwgAlJckALCzKADQ0wwA8PMIAMzPKADw8ygA8PNAAQ0PDAEtLxABDQ8sAS0vLAFRU + wwBcXMIAU1PMAFpaywBERNIAS0vRAFNT0QBbW9MAWlraAGJiwwBqasEAZGTKAG5uzQB2dsMAdHTLAHt7 + ygBgYNMAYWHVAGVl1gBoaNIAYmLaAGtr2QBzc9EAfHzSAHFx2gB2dtgAcHDdAHl52gBoaOEAcnLiAH19 + 4wCCgpkAgICjAICArQCAgLgAjY3JAJSUzwCEhNUAiIjVAICA2wCIiNkAgYHjAISE6ACQkOQAAAAAAAAA + AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFy6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrXFm3AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtkWXAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRZ + O7IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA4lxZTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAZFk7sgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKXFlOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRcO4kAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+lxcOwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7 + jQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAADXXFk5AAAAAAAAAAAAAAAAAAAAAAD2pwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABkXDuZAAAAAAAAAAAAAAAAAAAAAFw7TgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRcO0YAAAAAAAAAAAAAAAAAAAAAXDs4nAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA72RZOJkAAAAAAAAAAAAAAAAAAABcOziMAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7SgAAAAAAAAAAAAAAAAAAAFw7 + OIIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXXFk4mwAAAAAAAAAA + AAAAAAAAXFk4QgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTuH + AAAAAAAAAAAAAAAAAABcWThBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAGlcOzmWAAAAAAAAAAAAAAAAAGRZNTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAA62Q7OIsAAAAAAAAAAAAAAAAAXFk4NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7QAAAAAAAAAAAAAAAAOxhWTU0AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKXDs4lwAAAAAAAAAAAAAA7FxQODQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACbgRcSEgwSGiQsLC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTVFAAAAAAAAAAAAAADrZFk1NAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAACiMjExMQcGBgMDAwoQJCwuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRcOzSSAAAAAAAAAAAA + AOxcWTUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAPTQwMTExMTExBwYDAwMCDR4sLgAAAAAAAAAAAAAAAAAAAAAAAAAA12E7NYIA + AAAAAAAAAAAA7GFZNUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAHI7NTU0MDAxMTExMTEDAwMCAhgpLAAAAAAAAAAAAAAAAAAAAAAA + AAAAYVk7OS4AAAAAAAAAAADsYVk1QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+Wzs7NjU1OzU7NTU0LzExAwMCAgsdLC4AAAAAAAAA + AAAAAAAAAAAAAABpXDs0hQAAAAAAAAAAAOxhWTVBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+XhcUDY2NjY2Njs2OzYwNDExBwYDAgoZ + KS4AAAAAAAAAAAAAAAAAAAAAAOJkOzVBLgAAAAAAAAAA7GRZNUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQeGdcUlJZUFBQNjY2OzY7 + NTA0MQMDAgIYKS4AAAAAAAAAAAAAAAAAAAAAAGRZNTSQAAAAAAAAAADsXFI4QQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGtraVJhUlJQ + UFBQUFBQNjY7NjAwMQYDAgINKSwAAAAAAAAAAAAAAAAAAAAAxFk7MIAAAAAAAAAAAOtkWTWIAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + wmtpYWFSUlBQUFBQUFBQUDY7NjU0MTECAgINKS4AAAAAAAAAAAAAAAAAAADmWTs0MgAAAAAAAAAA7FxZ + NYgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADCwmlhZVJSUlBQUFBQUFBQUFA7NjUwMQYDAgINKS4AAAAAAAAAAAAAAAAAAABcNjQ0AAAA + AAAAAADsYVk1iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAMLCwmVhYVJSUFBQUFBQUFBQUDY2NjU1MTEDAgIZKQAAAAAAAAAAAAAAAAAA + AFk2MDAAAAAAAAAAAOxcXDWLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1cLCZWFhUlJSUFBQUFBQUFBQUFA7NjUwMQYDAgIcLAAAAAAA + AAAAAAAAAAAAWTswQAAAAAAAAAAA7GRZNZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiwsJmZWFhUlBQUFBQUFBQUFBQUFBQOzswMQYD + AgoeLAAAAAAAAAAAAAAAANFQNTRFAAAAAAAAAADsXFk1lwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDwsJlYWFSUlJQUFBQUFBQUFBQ + UFA2OzYwMQYDAgspLgAAAAAAAAAAAAAAXDs1MJcAAAAAAAAAAOxcWTWXAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfCwmZlYVJSUlBQ + UFBQUFBQUFBQUFA2OzU0MQYDAhgpAAAAAAAAAAAAAABZOzU0AAAAAAAAAAAA61xQNIIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7cPC + wWVhYVJSUlBQUFBQUFBQUFBQUFA2OzYxMQMCAh4uAAAAAP8AAAAAqFk1NUQAAAAAAAAAAADsXFk1gQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAw8PCZmVhYVJSUFBQUFBQUFBQUFBQUFA2NTUxMQMCDSkAAAAAAAAAAABcNjU4lwAAAAAAAAAA + AOxkWTVDLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADtw8LCZWVhUlJSUFBQUFBQUFBQUFBQUDY7NTAxBwMCHS4AAAAAAAAA6Fk7NTkA + AAAAAAAAAAAA7FxZND4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDw8LBZWFhUlJSUFBQUFBQUFBQUFBQUFA7NS8xAwILKQAAAAAA + AAB4WTswRQAAAAAAAAAAAADsYVk1MSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPvDwsJmZWFhUlJQUFBQUFBQUFBQUFBQUDY7MDEG + AwIdLgAAAAAAAFw2NTWdAAAAAAAAAAAAAO9hUjsxJS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbGxsJmZWFSUlJSUFBQUFBQUFBQ + UFBQNjY1NAUDAw0sAAAAAADcWTs1OQAAAAAAAAAAAAAA72ZcOzRDLAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfGx8RmZWFSUlJS + UFBQUFBQUFBQUFBQOzYwMQYDAyoAAAAAAHhZNjWLAAAAAAAAAAAAAAAAZWFZNTIsAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfH + x8dpYWVSUlJSUFBQUFBQUFBQUFA2OzUwMQMDGwAAAAAAXFA1OPAAAAAAAAAAAAAAAABlZVw7NCUuAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA7szKysfBYWFhUlJSUFBQUFBQUFBQUFA2OzAxBwMQLgAAAABZWTVKAAAAAAAAAAAAAAAAAOJm + YTs1RC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA5czMysrCZWFSUlJSUlBQUFBQUFBQUDY7MDExAxEuAAAA31k7NYwAAAAAAAAA + AAAAAAAAAMZlXDs4lwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2czMzMzHZGFhUlJSUlBQUFBQUFBQUDs1MAYGPywAAACsNjs4 + lgAAAAAAAAAAAAAAAAAAAGVkWThKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2dXPz8vLwmFhYVJSUlJQUFBQUFBQNjUwMRQ/ + LAAAAKA7NTkAAAAAAAAAAAAAAAAAAAAAAGFcWTiYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA79fVz8/PymlhYVJSUlJSUlBS + UFA7NjRBQUIsAAAAoDUwMZIAAAAAAAAAAAAAAAAAAAAA4mVZO0oAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+9fX19DXz8xr + ZmFhUlJSUlJSUFludEpERCwAAACiNTQvIi4AAAAAAAAAAAAAAAAAAAAAylxZOJkAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ANfW19fQ0NDPy8RrZ2dna3h+fX2gdUtFHS4AAIswLzEVLgAAAAAAAAAAAAAAAAAAAAAAaVk4OS4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAO/X19fX19PQztDQ0M7Oy6jOf32eTjISLC4AjzExBgYsAAAAAAAAAAAAAAAAAAAAAAD4 + WTs0gi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAADt2djX19fX09PQ0NDOz86oqaZGMRUgMTEkLzEGAx0uAAAAAAAAAAAA + AAAAAAAAAABbNTQxj5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mR5AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7eLi2NjX09jT09DTzs6pcjs1KzAvLzExMQYHDSkA + AAAAAAAAAAAAAAAAAAAAAKo7MDEVLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADX + ZWRcpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPri4uLY1NTU09PTzmdcUEo7NTU1 + MDAxMQMCKCwAAAAAAAAAAAAAAAAAAAAAtDA0MTGPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADHZGRcWaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/Pjq6t3f6vd/ + UlK+WVk2Ozs7NDAxAwMBJywAAAAAAAAAAAAAAAAAAACYNTAxMUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAz2RkXFm9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAqFxcUlJQNjY5MTExBAIKGSkuAAAAAAAAAI+PhISEhIA0NTQ0QQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9kXFxZqgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABrUFJSUlJZWVk4MDEGAwIDDSkpLiUXEzExBzExMDA1NTU1NTWfAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADPZGRcWaDAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKlfUmFhUmt2WTs1MDExAwMDDRkDBjEGMTExNDU1Ozs2Ozs7 + PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mRkXFlyugAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuqzOfn6of1lQNjs1MDExBgYGBjExMTExNDU1 + Ozs2Njs2WW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOJk + ZFxZWXWwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACXh0E4NDU4OUWFkC6TutrU0WtSUlBQNjs1NTAxMTEx + MTEvNTU2Njs2UFBZUl/dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADiZGRcWVk9n64AAAAAAAAAAAAAAAAAAAAAAJuHQDg4NTU1NTg4Ozs7OEuPk4ZSUlJSUFBQ + UDs7NTU1MDAwMDA1NTU2NlBZXNEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA4mRkXFlZOzmKnQAAAAAAAAAAAAAAAItANDU1ODU7OztZWVk2WVBZUFBZ + XGRhUlJSUFBQNjY2Ozs2NTU1MDAwNkam4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO1rYVxZWTs4RoiSAAAAAAAAjEQ4NDU1OzU7WVlQeVxS + UmRSUlJhYWRhYWFhUlJQUFBQUFA2Njs2NS8RFYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADvaWRcXFk7ODhHhZWGRDQ1ODU7OzY7 + WVB54AAAAADtyGZlZWVhZWVhZWFSUlJQUFBQUFBQNjswMAwnLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRhXFxZOzs1Ozg1 + OzU7OzZZUGvaAAAAAAAAAAAAAADXZWVmZWVhYWFSUlJQUFBQUFA2NjAvBQwpLAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADE + ZWFcXFlZWVk2WVBZXNEAAAAAAAAAAAAAAAAAAAAAAMZmZWVlYWFSUlBQUFBQUDs2MC8FBg0oLC4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA1WVhYWFSUlxn0QAAAAAAAAAAAAAAAAAAAAAAAAAA+8NmZWVhYVJSUlBQUFBQNjs2LwUG + Bg0cHSAfIYGBlwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAANnBZsTiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMbBZmFhUlJSUlBS + UFBQNjUwLzEGBgYGBjEGMTExMYecAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAx8fE + Z2ZhUlJSUlBQUDY7NjUwMTExMQYxBjEGMTE0NDSJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAfn5+xGdhUlJSUlJQUFA7NjU1MDExMTExBjExODU7NThAmAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACbmIiNh0pKdLsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADcfn5+xHhcYVJSUlJSUDZZNjs1NTU0LwwdkAAAbjs7Ozg0iAAAAAAAAAAAAAAA + AAAAAJyXiERGODg4ODg7O1lZbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRkeH5+eXhkYWFhUlJQUFA2Njs7NjAvLx0uAAAA31k7Ozg0OZcA + AAAAAAAAAJuMh0c5NDU4ODg7OztZO1lZc9sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADTUlJSXH19fnlkYWFhUlJSUFBQUDY1NTAxCiwAAAAA + AHY7NTU0NEScmJeIS0c4ODg4ODs7OztZWVlZWVx/3wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRhUlA7PaV9f35pYWVSUlJQUFA2OzY1 + MTExJAAAAAAAALo1ODUwNTg4ODg7NTU7OztZO1BZUFxczt8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYVJSNjaXANvOy37CYWFh + UlJQUFBQNTUvMQMQLgAAAAAAAABKNTU4Ozs7WTtZWVlSXFJSy9wAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtkUlk2NAAA + AN/Oy8vHZGFSUlJSUFA7NTAxBhApLgCSly4uLgCuRjU7WVlQXFJry98AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAK6Yl5ePl4+Pj4+Pj4+Xj4+Xj4+Xj5eQLpYAAAAAAAAAAAAAAAAAAAAA + zmFSUDtBAAAAAOzQzsvLxFxSUlJQUDY1MDEHFScaETExMRIkLC4At7q73wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhkXFk7ODg0MDQwNDQwNDg0NDA0NDA0NDA0MTQ0MTE0P5cuAAAA + AAAAAAAAAADMUlw2NYAAAAAAAOzT0M7Lf35rZ1xcXFlIR0AaDQYxBjEGMTEQKS4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVZmZkXFxZWTtZOzs7Ozs7Ozs7Ozs7NTs7NTs1OzU1 + ODQwMUUuAAAAAAAAAAAAAMtcUDswgQAAAAAAAMzU087Oy3/IfsRzcm5IRhMFBQUvLwUxAwYMKS4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6xmZlZFJcUlxSXFJcUlxSXFJZUFlQ + WVBZXFBZWVlZOzs4NEabAAAAAAAAAAAAf1k7NTCEAAAAAADqYczS09HOzst/fn55cm49ODAwMDAwMQUx + AwYNKS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO/PaWVhZWFhZWRh + YWFhYWFhYWFhZGFhYWFhUlJcXFk7ODmdAAAAAAAAAABzWTYwNI8AAAAAANBhYX7c0tHOzs7Lf35+czs7 + NTs1NTU1NAUGAwMQLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO3EXFJZOziiAAAAAAAAADs2MDQvAAAAAAAAxGFSWbLa3NTU + 0M6of6BwUFA2NlA7OzYwLzEGAwIdLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxGRcWTuJAAAAAAAANTUwMDIAAAAAAABh + YVJwAAD04NTU0dKmW1JZUFBQNlA2OzYwLwYDAwspAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7WRcWTs9jZwALi41MDA0 + PwAAAAAAAGVhUE4AAAAAAAAAv1JSUlJQUFBQUFA2OzUwMQYDAhksAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGlkXFk7 + Oz1HRjU1MDCIAAAAAAAAZVJZigAAAAAAAABSUlJSUlJSUFBQUFA2OzUwMQMCCiwAAAAAAAAAAACworMA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAANVlZFJZUFk2OzU1OAAAAAAAAABmZFmfAAAAAAAAUlJSUlJSUlBQUFBQUFA2OzAxBgMCGSwAAAAA + APJ1Ozs4OfEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAO9mYWFhUlxQOzt0AAAAAAAAAMpkWTsAAAAAANFhYWFhUlJSUFBQUFBQUFA7NjEx + BgMNKS4AAK1IO1k7Ozs7SgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGZWVlUlxSWwAAAAAAAAAA72RcO4oAAAAAX2FhYWFhUlJSUFBQ + UFBQUDY1NTExAwMeLIREODtZW9oAX1k7pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6wWVlZsQAAAAAAAAAAAAAZVxZOwAAAAB4a2lh + ZWFSUlJQUFBQUFBQUDs1MDEGBhAHNDU7WawAAAAAXFk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiZFk7 + jQAAAH15xMRraWRSUlJQUFBQUFBQNjs1MDExMTEwO6YAAAAAAADrXFl1AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABmXFk4AAAAu35+x37ExHhrXFxcUFBQUFBQNjU1LzExNHAAAAAAAAAAAABrXFm3AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAOJkXDuKAAAAf8t+yMjIfn5+xHJ4a19cXFlZPT1GRkCZAAAAAAAAAAAAAO9kWXQA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZSWTsAAADeqMvLy8jLyH5+fn55eXl5c3Nub0hG8AAAAAAAAAAA + AAAAAGtcO7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mRZO44AAADdzs/Pz8zLy39/f39+fn5+dnZ0Sk4A + AAAAAAAAAAAAAAAA72RZdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFJZOQAAAADr09DQ0M7PzsvLqH+o + fX2goHSgtAAAAAAAAAAAAAAAAAAAZFw7twAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYXFk7jAAAAAD819fX + 19DQ0M7Ozqiopn2moKYAAAAAAAAAAAAAAAAAAADYZFmeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcNjVL + AAAAAAAA4tnX19TT086pqampp6enAAAAAAAAAAAAAAAAAAAAAABkWTsAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAFxZO0cAAAAAAAAAAO3i2NTS0tLRrKurrAAAAAAAAAAAAAAAAAAAAAAAAM9kWaEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAUjs1hwAAAAAAAAAAAAD45tza0r3Su/UAAAAAAAAAAAAAAAAAAAAAAAAAAGRcWQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABcOzWOAAAAAAAAAAAAAAAAeV9yuAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAxGRkuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Fw7NZ0AAAAAAAAAAAAAAN9cWVsAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAZmTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+WTs4AAAAAAAAAAAAAAAAXFxQtwAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAADiws8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxQO4cAAAAAAAAAAAAAANJc + UHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFk1rQAAAAAA + AAAAAAAAXFk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABS + WTUAAAAAAAAAAAAAAH1ZNokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA1Fw7SAAAAAAAAAAAAAAAXDs4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB+WTuiAAAAAAAAAAAAAGdcO4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxSOwAAAAAAAAAAAAAAZFJZAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFk9AAAAAAAAAAAAAMpmXKcAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOpcWaEAAAAAAAAAAAAA7mZkeQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf1w7AAAAAAAAAAAAAAAA + ymZkWaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnWW8AAAAA + AAAAAAAAAAAA4mZkWVmhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFxZugAAAAAAAAAAAAAAAAAAAGtkXFk7nwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADcXFkAAAAAAAAAAAAAAAAAAAAAANdmZFlZO58AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAH5coAAAAAAAAAAAAAAAAAAAAAAAAADEZFxcWTuiAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxGRcWVk9sAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANxkXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA72tk + XFlZdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxFzaAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAO9rXFxcXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmawAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAADva2Rc0wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1WbqAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADCwQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP////////////////////////////////////////////////////////////////// + ///////////////////////////+P////////////////////h////////////////////4f//////// + ////////////D////////////////////w////////////////////+H////////////////////h/// + /////////////////8f////////////////////D////////////////////w/////////////////// + /+H////////////////////h//8/////////////////8P//H/////////////////D//w////////// + ///////wf/8P////////////////+H//D/////////////////g//w/////////////////8P/8P//// + /////////////B//D/////////////////wf/w/////////////////+H/4P/////////////////g/+ + D///////////8AD///8P/g///////////8AAP///B/4P//////////+AAA///wf+D///////////AAAH + //+D/g///////////gAAAf//g/4P//////////wAAAD//4H+D//////////8AAAAf//B/g////////// + /AAAAD//wf4P//////////wAAAAf/8H+D//////////8AAAAD//h/g///////////AAAAA//4f4P//// + //////wAAAAH/+H+D//////////8AAAAA//B/g///////////gAAAAH/wf4P//////////4AAAAB/8P+ + D//////////+AAAAAPeD/g///////////wAAAAD/g/4H//////////8AAAAAfwf+B///////////gAAA + AH8H/gf//////////4AAAAA/B/4D///////////AAAAAPg/+A///////////4AAAAD4P/wP///////// + //AAAAA+D/8B///////////wAAAAHh//Af//////////+AAAABwf/4H///////////wAAAAcH//B//// + ///////+AAAAHD//4P///////////wAAABwf/+D///////////+AAAAcD//wf///////////4AAADA// + +D////////////AAAAQP//gf///////////8AAAAB//8D/////+P/////wAAAAf//A//////g//////A + AAAD//wP/////8D/////+AAAAf/8D//////wP//////+AAB/AA///////A///////gAAAAAP//////8B + //////4AAAAAH///////wH/////+AAAAAD////////AP///gAAAAAAB////////8Af//AAAAAAAD//// + /////wA//AAAAAAAH//////////AB+AAAAAAAf//////////8AAAA8AAAAH///////////4AAB/8AAAA + ////////////gAD//4AAAD///////////+AH//+AAAAA///////////4P///wAAAAB////////////// + /+AAAAAP///////////////wAAAAA///8Af/////////8AAAAwH//AAH//////////AAAAOAf4AAD/// + ///////gAAAD4AAAAH//////////4AAAA/AAAAf//////////+BAAAH8AAD////////////A4AAAggAf + /////4AAAD//wPAAAACH//////AAAAAB/8D4AAAAf//////gAAAAAP/A/AAAAD//////8AAAAAB/wPgA + AAAf//////4AAAAAP8D4AAAAH///////////4B/B+AAAAA////////////wPwfhgAAAP///////////+ + AQH4fwAAB////////////4AB+H8AAAf8f//////////AA/h+AAAD4D//////////4AP4fAAAAYA///// + //////gH+DwAAAACH//////////8D/w8AAAADx/////////////8HAAAAD8P/////////////hwAAAD/ + h/////////////4OAAAB/4f/////////////DgAAA//D/////////////wcAAAf/w/////////////+H + gAAH/+H/////////////g8AAD//h/////////////8PwAB//8f/////////////D/AA///D///////// + ////w/8Af//4/////////////8P/w///+H////////////+D/4f///x/////////////h/+H///8f/// + /////////4f/D/////////////////+H/x//////////////////j/4f/////////////////w/+P/// + //////////////8P/D//////////////////H/x//////////////////x/4f/////////////////4f + +H/////////////////+P/wf/////////////////j/+B/////////////////4//4H///////////// + ///8f//Af////////////////H//8B////////////////x///wH///////////////4///+A/////// + ////////+P///4H///////////////n////g///////////////x////////////////////8/////// + ////////////////////////KAAAAEAAAACAAAAAAQAIAAAAAAAAEAAAAAAAAAAAAAAAAQAAAAEAAAAA + AABMTHgAXl5/AHp6egB+fn4ABgaOAAgIiwANDYoACQmNABwchwAQEIoAFBSJABAQjgAYGI4AHh6PAAYG + kQAGBpQACQmQAAwMkgALC5QADAyWAAYGmgAGBp4ACAiaAA0NmQAICJ4ADg6dABERkQAVFZEAExOWABYW + lgAdHZAAGhqWAB4elQAWFpkAFxecABgYmQAeHpkAGRmcAB0dnAAjI4oAJiaKACgoiAAtLYgAPDyHADEx + jgA2No8APj6LADg4jQA/P44AIyOQACYmkgAlJZQAKSmTACoqlgAhIZkAISGdACUlnQAqKpoALi6ZACkp + nQA1NZAAOzuQAD09kwAxMZgAMTGdADQ0ngA+PpwABgahAAYGpgAJCaAADg6hAAoKpgAODqYADg6oABIS + ogAWFqEAEhKlABYWpwAZGaIAHh6jABoapwATE6oAFBSqABcXrQAbG6kAHR2oAB4erQAiIqIAJyejACUl + pgApKaAALS2hACUlqQAoKKoALi6oACkprQAyMqAANDShADAwpQA2NqUAOTmjADw8ogA4OKUAPDylADEx + qQA0NKkAMDCsADU1rgA5OakAPDyrADs7rwA/P64AIyOxACkpsQA3N7IAMzO1AD4+swA/P7QAOTm/AE1N + hwBFRYoAUFCBAFFRiQBUVIsAQ0OWAExMlABGRpoAQ0OfAExMmQBQUJ4AZWWHAGxshQBmZooAdXWBAHh4 + hQBycosAaWmWAG5ulwBgYJsAZGScAG5unAB1dZAAcXGUAHV1ngBERKIAQ0OkAEVFpwBMTKIASEimAE9P + pgBCQqkARUWpAEBArgBFRa4ASUmoAExMqgBKSq0ATk6sAFdXpgBRUakAV1epAFFRrgBUVK4AWVmqAEJC + sgBFRbIAQUG0AEpKsABNTbEASkq0AE9PtQBFRbsATU24AFNTswBVVbAAUFC1AFlZsQBdXbEAWVm1AF1d + tQBQULgAXl6+AGFhogBra6MAYGCqAGlpqQBsbK0AcXGgAHp6pQBxcagAdnarAHt7qgB+fq0AY2OyAGZm + sQBgYLUAZWW1AGlpsQBsbLIAaGi3AGFhugBlZboAaWm6AG1tuQBoaL4AcXGxAHZ2sQBycrQAdXW3AHp6 + sgB7e7QAcHC8AHl5uwBGRsQAXl7AAFtbxABeXsQAZWXCAGtrxABgYMgAbGzLAG5uzwBycsMAdXXCAHNz + xQB0dMUAeXnBAH9/wgB4eMYAfn7HAHFxzQB4eMgAfn7IAHp6zQBvb9MAe3vRAH192QCAgKwAgICwAIiI + ugCSkr0Ag4PGAISExACEhMoAiIjNAJSUxwCEhNcAk5PVAKWl3AAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASeMAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKdaAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGtEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFpaAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADq + GtIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAABpkAAAAAAAAAABKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAC1GgAAAAAAAAAAGqIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAABqbAAAAAAAAABpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABaGgAAAAAAAAAUYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA2xSkAAAAAAAAGmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAC6gTY/fo4AAAAAAAAAAAAAAAAaOAAAAAAAABRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPMeFBQRFBEULYcAAAAAAAAAAAAAZBq+AAAAAAAaYQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAnEQUVFRUUBREeewAAAAAAAAAAAAAUZAAAAAAAFGEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAADjHhQVRUVFFRUPBREwAAAAAAAAAAAAFBQAAAAAABpkAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAtR4VRUVFRUVFFQ8RES0AAAAAAAAAAKgUuQAAAAAUZAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOMnGkVFRUVFRUUVBRERMAAAAAAAAADMFKQAAAAAGpYAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBQVRUVFRUVFRRUFERF8AAAAAAAAXBrvAAAAABqk + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgeFUVFRUVFRUVFFQURG4cAAAAAABQnAAAA + AAAUmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNOBQVRUVFRUVFRUUVFBEwAAD/AM0U + gAAAAAAAGmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEgD0VFRUVFRUVFRRURFIgA + AAA4FO8AAAAAABQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4YSAVRUVFRUVFRUVF + BREwAAAAGjgAAAAAAAAUFLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN9lOBpFRUVF + RUVFRRUUDgAAzBSkAAAAAAAAJxSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtJhk + FBVFRUVFRUVFBR4AAG0aAAAAAAAAAAAUFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADNqIBaGkVFRUVFFRQ4jgBkFAAAAAAAAAAAthqbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAPW0oqg8UFNTVHJlZYcANhSMAAAAAAAAAABkGsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAMy0pLSwta21mCd7eSwULQAAAAAAAAAAABQ8AAAAAAAAAAAAAAAAAAAAAAAAANZy + AAAAAAAAAAAAAAAAAAAAAAAA+fTFxba0sDgODg8RERsEAAAAAAAAAAAgFLcAAAAAAAAAAAAAAAAAAAAA + AAAA3El1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACbfRUaFAcHKoQAAAAAvoqKMxRlAAAAAAAAAAAAAAAA + AAAAAAAAAAAA3VBd3wAAAAAAAAAAAAAAAAAAAAAAAAAAwCcVU1EPEREbei0eFBERFBEUxQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA7GBJmOMAAAAAAAAAAAAAAAC6pGWfvQDFtnRFRQ8PEREREQcRERE4AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAaGpjOAAAAAAAAumUYGhQUFBQbLTZFRUVFRRUUBQcRQMUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKcaGhRlur6AGBgeFGQAALUgFBERFUVFRUVFFQ8BAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALYnGhQaFBhk3wAAAAAAAACiHg9FRUVFRUUF + GwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtcPMAAAAAAAAAAAAAAGUgGkVF + RUVFBREKKB4UPKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + mGBLFUVFRRUFBRERHiAaJ7oAAAAAAAAAAAAAANK0xd8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAADxkZTgPFUVFRRUPG4YAxRQaZAAAAADvpGU4GhoaGl3nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAREYGYPBQVRUVFSQV5AAAAYRQYZRoaFBoUGmTNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAC1EREA8KJkS0VFRRUUKgSJigCMOBQncMXqAAAAAAAAAAAAAAAAAAAAAOuncGRhYWFh + YWFhYWRhYWSAAAAAAAAAZRE2AAD2tLV0UFNLHioJEREOgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdBoU + FBQUFBQUFBQUFBQUFBjvAAAAAGUUQAAAAFzFtKiYbVwUBQUFBRGFAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAADj398AAAAAAAAA9JgaGM4AAABAFIIAAOMUgc7FtJg8GhVFFRERKAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAG0aZL6QIBG6AADnHsAAAPE2FUVFRUUaBRQwAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAthoUEREeAAAA6hrSAACoEUVFRUVFRQURGwQAANRdUAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJx4UtgAAAAAaZAAAIBEVRUVFRUUVERF6glBa + 321LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApxoAAGVkUEtKRUVFFQUR + ERjNAAAAUM0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaZADOZXBldHJx + UVAgIIAAAAAAAOoaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmBrAAMWi + qICnp3VkYWQAAAAAAAAAGrQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa + mwAA88W0oqKoqJvOAAAAAAAAANdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAFGQAAAAA487FxcXjAAAAAAAAAAAAGswAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABqAAAAAAAAAOL4AAAAAAAAAAAAAAKxRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAN8a0QAAAAAAcFoAAAAAAAAAAAAAAAAA7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC1GgAAAAAAABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAWmQAAAAAAFpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAABrMAAAAAAAaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJAAAAAAAAULUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADabQAAAAAAAABdGrAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXd8AAAAAAAAAAOoaGrUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAANcaUN8AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOvXAAAAAAAAAAAAAAAAANdK9wAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//////////////////////////f/////////8//////////z//////// + //n/////////+f/////////4//////////z/f////////P8////////+fz////////5/P////////j8/ + /////A//Pz/////wA/8fP/////AB/58/////4AD/nz/////gAH+PP////+AAP48/////8AAfjz/////w + AA+fP/////AADR8/////+AAHHz/////4AAc/H/////wABj8f/////gAGf5//////AAJ/j/////+AAj/H + /////+AAP+f//z//8AAf4///j///4A8D///h///gAAP///g//BAAD////wfgAAA/////wAGAAf/////w + B/AA//////4/+AAH///////8AAH/w/////wAEPAD/////AAcAD/////4gAID//wAAfjAAP///gAAeOAA + f///4/g4wAB//////wDGAD//////gcYAGP/////h5gAAf//////mAAc///////IAHz//////8QA/n/// + ///5gD+f//////ngf8//////+fn/z//////x8//v//////P3////////8+f////////z7/////////fn + ////////5/H////////n+H///////+/+H///////z/+P///////f//////////////8oAAAAMAAAAGAA + AAABAAgAAAAAAAAJAAAAAAAAAAAAAAABAAAAAQAAAAAAACUlXgAqKl4AMTFXADc3VwA1NVgANzddABkZ + ZgAWFm4AGBhoABwcagAZGW0AExNzABYWcAATE3YAFBR1ABoadAASEnkAFBR7ABISfgAVFX0AHx99ACEh + YAAlJWAAIiJmAC0taQAyMmAAOTlkADExbgA7O28APz9uACYmdAAvL3YAIyN7ACEhfQApKXoAKyt+AC0t + fAAxMXMANjZwADQ0dAA8PHMANTV5ADExfQA1NX4AOjp5AEJCXQBJSVoASUleAE1NXQBAQGEATExkAEVF + bABLS2sATU1rAEhIbABUVGsAWFhqAFpabQBDQ3EASkp1AEJCegBRUXAAW1twAFNTegBfX3gAY2NvAGdn + cQBiYnYAZWV1AG1tcABubnUAY2N7AGZmegBhYX0Aa2t+AHFxcwBycnQAd3d3AHZ2eABxcX4Aenp8AA0N + hQAODokACgqOAA0NjQAREYIAFRWAABERhQAXF4QAGhqEABAQiAAVFYoAEBCMABcXjAAaGokADQ2QAAsL + lgANDZUACgqZAA0NmQAJCZ0ADQ2dABISkwAaGpAAHByRAB4elwAQEJgAFRWZABISngAXF50AGRmdACMj + gAAmJoEAIiKEAC0tgwAgII4AKyuLADIygQA7O4UAMTGIADY2jwA/P4sAIyOVACEhnQAoKJgAMzOSADk5 + kAAHB6IABQWlAAgIoQAMDKIACgqmAA4OpAAFBagABQWtAAwMqgAQEKEAERGmABQUpAAaGqMAEBCpABUV + rAAbG6wABQWxAAUFtQAKCrMADQ28ABMTsAAVFbEAFBS1ABgYsgAeHrIAGhq0AB4etgAQELoAHR29ACUl + pAAqKqIAIiKqAC0tqQAwMKkAPDyuACQksAArK7MAICC/ACgouAAtLbsAKSm+ACwsvQA1NbYAPT2yADIy + ugA2NrsAMTG9ADg4uQA9PboAODi+AEBAggBDQ4oASkqJAF1dhQBeXokAYWGAAG5uhABgYIoAd3eFAHx8 + gAB9fYgAYmKfAHV1kAB7e5EAe3ubAE9PpABRUaEASkq1AEFBuwBBQb8ARUW8AFZWsgBdXbQAUlK+AFhY + uAB1daIAeHilAGVltQBvb7QAZWW6AGJivQB/f7cAEhLAABYWwAAdHcYAIiLAACYmygA0NMMAODjCADU1 + zAA6OsoAQ0PDAEVFwgBCQsUASEjBAE5OwABPT8cAQkLIAExMywBQUMUAVVXEAFhYxABTU80AWVnIAERE + 0ABMTNEAV1fRAFxc0wBlZckAcHDAAHd3zQB5ec8AZGTRAGpq0QBoaNsAcnLSAHt70wB8fNMAf3/WAH9/ + 3gCCgsIAgoLGAIGB2QCHh+UAkJDnAKGh6AAAAAAA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJhJAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPN4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACKRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADgLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbUcA + AAAAAPhBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApikAAAAAAMkmAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9mhPAAAAAMYhAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIU3AAAAALAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC/HRka + ME0AAAAAAAAAAN1wAAAAALAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJgXVsTDRYwAAAAAAAAAABt + OQAAAK0hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSBhYBlYBMJBU0AAAAAAACOHAAAAKYkAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAJuHgYGBgWVYCwVPAAAAAADkWAAAAKYsAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAANOQh4GBgYWAWAgEAAAAAADQWgAAAKYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANSSh4GB + gYGBZVgJMAAAAACMLQAAAKYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPLTkIeBgYeBgWATFk0AAABg + uAAAANcfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADWk4eHgYGBgYFgCC4AAMNeAAAAALBYUQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA1puHgYeBgYFlExYAAIU9AAAAAOlrMwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA+9mch4GHgYGFXQtRAGVPAAAAAACUJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzo + 15SHh4GBayxHAFtEAAAAAAAAijkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6+nhraaton45SRMu + AAAAAAAA5SFPAAAAAAAAAAAAAAAAAMi2AAAAAAAAAAAAAAAAAP3y6ubpxm1aWBMCUQAAAAAAAFsyAAAA + AAAAAAAAAAAAAADknrYAAAAAAAAAAAAAAAAAAAAAAJiFZVsLBEcAuj8+O1ssAAAAAAAAAAAAAAAAAAAA + AOyfs0sAAAAAAAAAAAAAAE+6AKKYn2VbDRgQWF1gZW8AAAAAAAAAAAAAAAAAAAAAAAAA9phoLT8AAAAA + AEBwYGVgXix7gYWBZWBdXW3DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA14VeHTQka2Wh+ADx1ZCHkIeB + gWVSMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpiIWf7QAAAAAAAADTkIeBgWVdCzA5OUQAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD3nIiHhYFgWBMNWFssQgAAAAAAAAAAvElJAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAmKaUkIeBZWAQTQCeWzdRAEs8LFprbZ3NAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADwgXfDpZCHgWATMAAAsmtbbWWKquwAAAAAAAAAAAAAwDw7Ox00HTQpNDQ3QwAAAADYZUsA + 8NeXiIVaGyYQMkfLAAAAAAAAAAAAAAAAAAAA6ZSIhYWFhYWFhYVlWjcAAAChWwAA7t3esKadWFtYDRoA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA54o9UQB7WAAA3XXM8OCMhYFlWAswAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACYbSFbLAAA2C0AAKGHgYGFYBMWuwAAtUAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA4ZOIAAAA8WhRAJCQh4GBgV0LMD18zp9JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AIg8vqaclIiHgWVYE70AAAB8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOxou8fa2K2kpKF7 + vwAAAACtQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKPgD26eHdxqLCAAAAAAAAewAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACXPAAAAPrlyNEAAAAAAAAAmLcAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABtSwAAAACKAAAAAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABrAAAAAMK0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO54AAAAAG0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMa1AAAA8H8AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIwAAAAAANd+SQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAH4AAAAAAAD6jnVEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + 0L8AAAAAAAAAAPGXfwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAogAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /////wAA///5////AAD///n///8AAP///P///wAA///8////AAD///58//8AAP///nz//wAA///+PP// + AAD///88//8AAP/A/zz//wAA/4B/nP//AAD/gB+c//8AAP+AD5z//wAA/4APnP//AAD/gAec//8AAP+A + A5z//wAA/8ADPH//AAD/4AM8f/8AAP/gAT5//wAA//ABPz//AAD//AA/H/8AAD/+AB+f/wAAj//4CB// + AADh/8gAP/8AAPg+AAD//wAA/wAgA///AAD/wfwAP/8AAP///AAP8QAA///+AEIBAAD///wAYB8AAPgA + PEAD/wAA+AAcwAf/AAD//4TAA/8AAP//4MwBnwAA///xxAAPAAD////gAO8AAP///+AB5wAA////8gP3 + AAD////zh/MAAP////Pf+wAA////95//AAD////nv/8AAP///+c//wAA////74//AAD////vw/8AAP// + /8/x/wAA////3///AAD///////8AACgAAAAgAAAAQAAAAAEACAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAB + AAAAAAAANTVZADMzXwA7O1oAGxtpABYWcQAVFXcAGxt2ABwcdAAUFHgAERF9ABcXfwAbG34AKipgACAg + agAkJG0AKipoADY2YwAxMWcAPz9lACEhdgApKXIALCxyACgodQAsLHYALy94ACoqfwA1NXMAMDB2ADU1 + dgAwMHkANzd7ADU1fQA/P3sAQ0NfAEdHXQBAQGsARkZtAFhYZgBBQXAASUlyAEtLdgBPT3oASEh8AFZW + dgBeXnMAUlJ7AFxcfwBlZW4AYWF3AGxsdgBycn4ADg6LAA0NjgASEoMAEBCHABgYgAAREYoAEhKOABoa + jwAdHY4ACwuTAA0NkgAMDJUACgqaAAkJnQAODp8AEhKQABcXkQAbG5EAHx+RABERmQAUFJgAFxefAB8f + nQAhIYIAKiqGACcniwAlJY8AMzOBADIyhwA0NIgAMDCOAD8/iwAoKJEAKSmUAD09mwAHB6IABgamAAgI + ogAICKYABQWpAAUFrAAJCagAGRmgABwcoQAQEKsAFhaqABkZrAAdHa0ABga2AAoKtQAODrkAERGwABsb + sgAWFrgAHh67ABwcvAAhIacALS2nACIirgAlJa8AKSmoACkprQAtLawANzelADg4pgAyMqkAMDCtADs7 + rwAgILUAJSW6ADAwtgAzM7wANze+ADs7uQA8PL0AQECGAFZWgQBTU4UAWlqDAFBQiwBUVI0AQ0OaAFxc + nwBnZ4cAd3eFAHp6hgB/f4YAdnaKAHt7iAB/f4sAb2+QAHl5kQBBQa0AX1+hAE5OswBERLsAQEC9AFpa + tQBSUrwAYWGvAGJitwBqarEAeXm2ABUVwQAvL8wANzfAADs7xwA9PckAPDzNAE5OwwBSUsEAUFDEAFVV + xQBbW8IAXV3CAF5exQBYWMkAV1fUAGdnyQBzc8cAZ2fSAGpq0ABiYtoAenrTAICAgwCAgJAAgYG8AIGB + zgCRkdIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJMAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvKAAAAHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA8AAAAdowAAAAAAAAAAAAAAAAAAAAAAB0PAjAAAAAAAJMtAABwjQAAAAAAAAAAAAAAAAAAAABhQUE0 + BQMAAAAAABgAAG8AAAAAAAAAAAAAAAAAAAAAAGZYWFhBCQIAAAAAQwAAbgAAAAAAAAAAAAAAAAAAAAAA + m1xYWFhBBSMAAABLAABuAAAAAAAAAAAAAAAAAAAAAACuZVxYWFg/BLAAmIIAAHAzAAAAAAAAAAAAAAAA + AAAAAACcZVhYWFg2IwBeAAAAeyQAAAAAAAAAAAAAAAAAAAAAAACgaVxYWD8SAEsAAAAARQAAAAAAAAAA + AAAAAAAAAAAAAACunnlvcCEzDAAAAACrJwAAAAAAAAAAAJWHAAAAAAAAAAAAr6qkXjoJJgAAAAAMAAAA + AAAAAAAAAACSgQAAAAAAAAAAAABvYj8FEhgJQ1UAAAAAAAAAAAAAAAAAoU0oAACPT0heSE5aWEE/DIYA + AAAAAAAAAAAAAAAAAAAAAK1hSJAAAAAAqWRYWD8EMokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfmdc + WjQJGFUnAAAAALEvKwAAAAAAAAAAAAAAAAAAAABhVmpcWD8TAH9LGjxslgAAAAAAAJkgIBodGh0dJAAA + AEEAtHtoSRgUEDEAAAAAAAAAAAAAAAAAAAAAAACiTLAAOgAAhad9QUE2EAAAAAAAAAAAAAAAAAAAAAAA + AAAAYkVPALMoAGJYWEEFJgCDLgAAAAAAAAAAAAAAAAAAAAAAAAAAAE6LamddWD8IhgCnMwAAAAAAAAAA + AAAAAAAAAAAAAAAApC6Ynn56bY4AAABRAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAArJaaAAAAAKIAAAAA + AAAAAAAAAAAAAAAAAAAAAACBAACyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApwAAAFEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB0AAAAUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMAAAAAdi4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP///////f////7////+/////nf///9z//4fM//8D7f//Ae3//wDt//8ATP//gFz//8B + e///gHn/P+A9/8/8Af/xgAf//DwD///+APH//gIH4A6Af//iwH//+JAn///AE///wDv//+x7///t//// + 3f///93////ef////7//////KAAAABAAAAAgAAAAAQAIAAAAAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAA + AAAcHHoAGRl+ACMjcgAlJXMAISF1AExMbABaWnIAFBSEABAQiAAMDJUAIyOaAD09kwAGBqUACAihAAgI + pAAHB6sAGxugABgYpgASEq8AHR2rAAsLtAAbG7QAIiKwAD09swBCQo0AX1+CAFdXiABVVZEAUlKWAFtb + kQBcXJIAYWGNAGlpiABsbIsAd3ePAGpqkwBra5UAYGCZAHl5kQB+fpAAenqZAFdXpABYWKQAXFykAFpa + rQBubqYAZWWtAG1tqgB2dqAAdnauAH19rABjY7MAZGS2AGxsuABxcbkAdXW/AEhIwQB8fM4AZmbXAGFh + 2ACGhr8AgoLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /wAAAAAAAAA1AAAAAAAAAAAAAAAAAAAAAD4AAAAAAAAAAAAAAAAAAAAAJwAeAAAAAAAAAAAMAQcAACoA + HAAAAAAAAAAAFQ0KBgA4AB4AAAAAAAAAADwQDQkAJgAZAAAAAAAANQAAOxYSGiEAADUAAAAAAAA1AAAA + MRIDKCAkAAAAAAAAABweODoXDQgpAAAAAAAAAAAAAAAAABQOBRshJC4AAAA1LTUrACsAGAsBJwAANQAA + AAAAADU2ACQTDQUAKQAAAAAAAAAAAAAvPTkzAAAAAAAAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAAA1MAAA + AAAAAAAAAAAAAAAAAAAAAAAA/f8AAP7/AAD/XwAA418AAOFfAADhXwAAsG8AANwPAADgHwAA/wEAAMKG + AAD8hQAA/4cAAP+/AAD/zwAA//8AACgAAACAAAAAAAEAAAEAGAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODrMQEKpjY7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbG7kPD6sREaJ+fqwA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABxcdwODq8QEKQvL6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMPD6gSEp1wcKUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABiYtYNDa4QEKM4OJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMPD6cREZx3d6MAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NsgNDa0Q + EKA3N50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMODqYSEpoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ78NDasQEJ9GRp4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAACAgOIMDLAPD6QSEpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UODqkREZxWVp4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABT + U9IMDK4QEKEbG5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACEhNVISLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7MODqcREZpjY50AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEKoSEp89PZ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJsANDasQEJ8k + JJUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPD6gSEp0TE5N5 + eZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACAgOIMDLEPD6QSEpZmZpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAODqkREZ0TE5FZWZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UNDakREZs1NZYAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDasQEJ4TE5FERI0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABSUtEMDK4PD6ATE5Rzc5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAMDKwPD6ETE5IwMIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7MODqYSEphCQpQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDK4PD6ESEpMuLogAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGLwM + DKsQEJ0bG5B/f4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC64ODqISEpMa + God/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABwcN0LC7APD6ISEpVWVpQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAALC68ODqIREZMUFIl/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrUNDagREZkjI48A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCq8NDaMREZQTE4l/f38AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA1NcgMDKwPD58TE5FhYZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoKCq8NDaMREZQTE4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcJdMTIc7O3wt + LXUtLXItLW8uLm9ERHBYWHNwcHB2dnZ+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7IODqUSEpY5OY4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaMQEJQTE4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABYWKAZGYgTE4ITE30UFHoVFXgWFnUWFnIXF3AYGG0ZGWoeHmg2NmZdXW5wcHB6enoAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAKCrcMDKkQEJsTE45ycokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQQEJUT + E4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHJoQEJAREYkREYQSEoETE4ETE4ATE34UFHsUFHYV + FXMXF24YGGsZGWkaGmc2NmNcXGxwcHB9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSUtILC68ODqASEpNFRY4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edsKCrANDaQQEJUoKIsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIqgODpkODpMP + D5AQEIwPD4wQEIwQEIsQEIoREYcSEoQTE38UFHoVFXQWFm4YGGkaGmYbG2ZAQGNpaWl1dXUAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrMNDaUR + EZYbG4t+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQQEJUuLosAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA2NrgaGqcLC5wMDJoMDJkMDJgMDJcMDJcMDJYNDZYNDZMODpEPD40REYgTE4IUFHsV + FXQXF2wZGWcaGmUpKWFWVmtvb29/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAXF7wMDKsQEJwTE45XV4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edsKCrANDaUREZUuLowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIiNkhIbQVFasJCaQJCaMJCaIKCqAKCp8KCp4K + Cp4KCp0KCpwLC5oMDJcNDZMPD48REYkTE4EUFHgWFnAYGGkaGmUgIGNMTGVra2t8fHwAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYdgLC7AODqASEpIqKol9fX0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQREZYuLowAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTMkf + H7gTE7EICKoICKoHB6gICKUICKQHB6MICKMICKIICKEJCaAJCZ4KCpwMDJgNDZMPD44REYUTE34VFXQY + GGwZGWUbG2M/P2FpaWl5eXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAKCrMNDaUREZYUFIpvb4YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoKCrANDaQREZYv + L4wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAeHr8eHrsTE7UGBrAGBq4HB6sHB6gHB6YGBqYHB6YHB6YHB6UHB6QI + CKMICKEJCZ8KCpwMDJcODpEQEIoTE4AUFHYXF20ZGWYbG2M2NmFoaGh4eHgAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJb4MDKgQEJgTE4xDQ4gAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edoKCrANDaQREZZLS48AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeHsIdHb0SErgGBrQGBrEG + Bq0GBqoGBqgGBqcGBqcGBqcGBqcGBqYHB6YHB6UHB6MICKEKCp4LC5oNDZQQEI0SEoMUFHgXF20YGGYb + G2M2NmBpaWl6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtbdgM + DKkPD5oSEo4hIYYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC68NDaQQEJZMTJEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAcHMQcHMAVFbwFBbYFBbMGBq4GBqoGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6YHB6QI + CKIJCZ8KCpwMDJYPD44SEoQUFHgWFm4YGGYbG2M2NmBqamp9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6kODpsSEo8UFIhvb5AAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoLC68NDaQREZZMTJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMUcHMIaGr8FBbcFBbQFBa8GBqsGBqgGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6UHB6MICKEKCpwMDJYPD48SEoQUFHkWFm4ZGWYaGmNJSWNt + bW0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6gODpsSEo8TE4kA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC68ODqQREZVUVJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQNEc + HMQcHMEHB7sFBbYFBbEGBqwGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UHB6MICKEK + Cp0MDJcODo8SEoQUFHgXF20ZGWYbG2RRUWdwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAALC6YODpkREY8hIYkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqMREZVo + aJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABnZ94cHMQcHMIODrwFBbcFBbMGBq0GBqoGBqgGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcGBqYHB6YHB6QICKEKCp0MDJcPD48SEoMUFHgXF24ZGWYgIGNbW2t1dXUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABWVsILC6MODpcREY89PY0AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edoLC64ODqMREZRmZo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMccHMMaGsAFBbkF + BbQFBbAGBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6QICKEKCp0MDJYP + D44SEoMUFHYYGGwaGmUpKWFpaWl8fHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFqsN + DZ4PD5UREY1kZJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqESEpNlZY4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAnJ8scHMUcHMMLC70FBbcFBbIGBq0GBqoGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcHB6YHB6QICKEKCpwNDZUQEIwTE4AVFXQYGGkbG2RAQGNubm4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC6YNDZwQEJISEo0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoLC64ODqESEpJJSYsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaOEcHMgcHMQVFcAFBboFBbQFBbAGBqwG + BqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UHB6MJCaALC5sNDZMQEIoTE34W + FnAZGWcbG2VbW2t4eHgAAAAAAAAAAAAAAAD///8AAAAAAAAAAAAAAABISL0MDKINDZgQEJA1NY4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqESEpFISIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAcHMobG8UcHMQMDL0FBbcFBbIGBq4GBqoGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqYHB6UICKMJCZ8LC5oODpEREYUUFHkXF20aGmYtLWJtbW0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALC6kMDJ8ODpUREY9kZJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsLC64ODqESEpE7 + O4V9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaOEbG8kbG8QZGcEGBrkFBbYFBbEGBqwGBqoGBqgGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKIKCp4MDJcPD44TE4EVFXQYGGkaGmZT + U2p4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f9ALC6YNDZsPD5MYGI0AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edsLC7AODqISEpInJ4N4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMsbG8cc + HMQTE8AFBbgFBbMFBbAGBqwGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YH + B6QICKEKCpwNDZQQEIoTE3wXF28ZGWcsLGRubm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAiIrMMDKINDZkQ + EJI+PpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6etwKCrINDaUREZQUFIZzc3MAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACEhOgfH8odHcUcHMMODr0FBbcFBbIFBa8GBqsGBqkGBqgGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6MJCZ8LC5kODpASEoMUFHYXF2saGmdUVG18fHwAAAAA + AAAAAAAAAAAAAAAAAAALC6oMDKAODpYQEJB1dZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8 + fN8KCrUMDKgQEJcTE4hTU319fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHR9YkJMohIccfH8MODrwF + BbYFBbEGBq4GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKEKCp0N + DZUQEIsTE30XF28ZGWkxMWVzc3MAAAAAAAAAAAAAAAAAAABmZskLC6cNDZ0PD5UgII8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+fuMJCbgLC60PD5sTE4w+Pn93d3cAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAsLM4oKMooKMUmJsQQELwFBbYFBbIGBq4GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcHB6YHB6QJCaALC5oODpASEoMVFXYYGG0ZGWtnZ3IAAAAAAAAAAAAAAAAAAAAj + I7MLC6QNDZsPD5NVVZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLsKCrENDaIS + EpIaGoR0dHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMM4uLsotLcgrK8UTE70FBbYFBbIG + Bq4GBqsGBqkGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UICKEKCpwNDZQQEIoUFHsW + FnAYGGxMTG8AAAAAAAAAAAAAAAAAAAALC6kMDKIODpkREZJ/f5cAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAHB78JCbYMDKkQEJkTE4tZWYV9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABzc+M0NM8zM8wyMsowMMgXF78FBbYFBbIGBq4GBqsGBqoGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqcHB6YHB6MJCZ8MDJgPD48TE4EVFXUXF242Nmx8fHwAAAAAAAAAAAAAAAALC6YMDKAPD5g2NpEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYN0ICLoKCq8ODqASEpIxMYp9fX0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYN46OtA4OM43N8s1NckiIsEFBbYFBbIFBa8GBqwG + BqoGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UICKELC5sODpISEoUUFHkXF3EoKHN6enoA + AAAAAAAAAAB0dMkMDKQNDZ0QEJVbW5MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAlJcgJCbYMDKkQEJsTE49mZo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZWdo/ + P9E+Ps89Pc07O8svL8QODrgFBbMFBbAGBq0GBqsGBqkGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcHB6YI + CKIKCpwNDZUREYgUFHwXF3QqKn93d3cAAAAAAAAAAABaWr4MDKAODpkYGJF9fYoAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLwLC7EODqMREZYzM5EAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcXNtERNJDQ89BQc0/P8o7O8ggIL8FBbQFBbIFBa8GBqwGBqoG + BqkGBqgGBqgGBqcGBqcGBqcGBqcGBqYHB6MKCp4MDJcQEIsVFYAmJn8sLIB0dHQAAAAAAAAAAAA/P7AN + DZwPD5UZGY4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ + CbgMDKwPD6ATE5NubpYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6euRKStNISNFH + R85ERM1DQ8w7O8gbG70FBbMFBbEGBq4GBqwGBqsGBqoGBqkGBqgGBqgGBqgGBqgHB6UJCZ8MDJgTE48s + LI4xMYYwMINxcXEAAAAAAAAAAAA9PacODpYQEJATE4hpaYcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtsKCrQNDagREZo2NpYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACFheZQUNROTtJLS9BLS89JSc1HR8s9PccgIL0NDbQFBbEFBa8GBq0GBqwG + BqsGBqoGBqoGBqoHB6cREaYlJac1NaI2NpY2Now2Nohubm4AAAAAAAAAAABXV6UPD5AREYoTE4JNTX9/ + f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NcgLC68PD6ET + E5VgYJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYWNZTU9RRUdJQUNBO + Ts5MTM1LS8xKSso7O8QqKr0cHLkUFLUTE7MUFLIbG7QkJLY1Nbk5Obg6OrM7O6o8PKA9PZM2NotXV3F6 + enoAAAAAAABVVZUPD4sSEoUUFH0zM3Z4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAZGbYODqUREZgcHIx+fooAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB7e+JYWNZWVtRVVdJTU9BRUc9QUM5OTs1MTMtMTMpKSslISMdGRsdERMRCQsRB + QcJBQb9AQLpBQbJBQak+PpwaGoIrK3Vzc3N8fHwAAABkZIQQEIUSEoIVFXgXF3JwcHAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f9sNDaYQEJgTE4xISIp+fn4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZtpcXNZaWtRXV9JWVtFV + VdBUVM9SUs5QUM1OTsxMTMtMTMpKSslISMdHR8NGRr9GRrpGRrIgIJgREYU1NXdNTXQPD4IUFIBWVnEP + D4QSEn8VFXUXF29QUG55eXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAaGqgQEJgTE4sVFYFlZYJ+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABjY9gODrQnJ7MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABoaNtgYNZeXtVcXNRaWtFYWNFWVs9WVs9UVM5SUsxQUMtPT8pNTchNTcRMTMAj + I6wMDJsODpBnZ3gODogODogODocSEoMUFIESEoAUFHYXF242NmVubm4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUVLQPD5UTE4oVFYEuLnt3d3cAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRtEMDLgNDbIPD6tFRbIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDg+JlZdZiYtRgYNNeXtFc + XM9bW85ZWcxXV8xWVstUVMpOTsUUFLEJCakKCqM0NJcNDZkMDJUNDZQMDJINDZAODowREYYTE3kWFm4e + HmZgYGlycnIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABycq0P + D5ISEosUFIIWFn5dXYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAoKMYMDLgNDbIODqwQEKZRUbMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACRkeKBgdtzc9RxcdBwcNBvb89zc9CIiNU4OL0GBq0HB6p1dbUSEqMLC6ML + C6ALC5wKCpoMDJgXF4oQEIsTE4AUFHMYGGk/P19lZWVwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABra5MODpAREYwTE4YVFYI3N4UAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRc0MDLQNDa8PD6oQEKVmZrkAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABGRrsSEqsICKsICKoJCagJCaUKCqIKCp8bG4sYGIgREYcTE3oVFW0YGGcjI2NJSWZt + bW16enoAAAAAAAAAAAAAAAAAAAAAAAAAAABnZ4NeXoFdXYBaWn9aWn9aWoBISIQODpIQEJASEowTE4gz + M5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABFRcwMDLMODq8PD6oQEKVSUrUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdHbAGBqkICKwHB60ICKwHB6kICKYREaUZ + GaQMDJcPD48SEoIUFHcWFm0YGGgZGWc2NmJnZ2dwcHB4eHhXV389PXshIXkVFXwVFXwUFH0TE4IREYgQ + EI0NDZIMDJMMDJUNDZQODpUREZESEpFLS6MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRcwMDLQNDa8ODqoQEKY8PK+AgLgA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABL + S7sYGK0HB6wHB68HB64GBqskJLI1NbQJCaIKCp0NDZUPD4wSEoETE3kVFXEWFm0XF2s9PWBDQ2QaGnAU + FHYTE3oTE34TE4ATE4MSEoUREYoPD5AODpYMDJkLC5sLC5oMDJoNDZoPD5kbG5wAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABhYdcMDLQNDbAODqsQEKYlJahgYLIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYbFaWsBMTMExMbwwMLxGRsA7O7sMDKkICKQJCaEKCpsNDZUP + D44REYUTE34TE3cUFHQTE3QTE3cTE3kSEn0REYMQEIcPD4oPD48ODpINDZYNDZoMDJ8KCqAKCqEKCqAL + C6ENDaIlJaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtgMDLUNDbAODqwPD6YQEKE4OKZr + a6oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABkZJVDQ5EmJo4REZAREZAREZAREZAeHpA5OY9SUotuboV8fHx3d4NiYrRjY8dgYMpT + U8UgILUHB6sHB6gHB6YICKMJCaAKCpwMDJcODpIPD4sQEIYREYQREYIREYMREYUPD4gPD4sODo4MDJIM + DJYLC5kLC54KCqEKCqQJCaYKCqcKCqgjI69wcMkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABiYtgMDLUMDLEODqsPD6YQEKEcHJ1ISKJsbKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2dpdERJEfH40REY8QEJAQEJIQEJMPD5QPD5UPD5UPD5cO + DpgNDZkLC5oYGJg7O5JjY4Vycn9eXooGBq8GBq0GBqsGBqkHB6gHB6YICKMICKEKCp0LC5oMDJcNDZMO + DpEODpAODo8ODo4ODo0MDI4MDJALC5MLC5gLC5wKCqEJCaUKCqgWFq1XV8MAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYdkLC7YMDLENDasODqYQEKEREZwb + G5ZMTJt1dZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUVJMmJo0REY4QEJAPD5IP + D5QODpYODpkNDZwNDZ4NDaANDaEMDKMMDKMLC6MKCqMJCaQICKUHB6kWFqgUFKoGBrEGBq8GBqwGBqoG + BqkHB6cHB6UHB6MICKIJCaAKCp4KCpwLC5sLC5oLC5YMDJMLC40LC4wLC4sLC44LC5MhIZ5GRrF+fsoA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABxcd0YGLsLC7INDa0ODqcPD6AREZsSEpYjI5JISJJubo8AAAAAAAAAAAAAAAAAAAAAAABb + W5M1NY4REY8QEJAPD5IODpQODpcNDZkNDZ0MDKELC6QLC6gwMLQKCq0KCq4JCa8KCq8JCa4ICK4HB68H + B7AGBrEGBrMFBbMGBrQGBrAGBq4GBqsGBqkGBqgGBqYHB6YHB6UHB6QICKIICKEJCaAKCp4KCpoLC5IL + C4ksLHM8PHRiYoMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+MYGLwLC7MMDK4NDagPD6IQEJsS + EpYSEpEqKpBRUY5xcYhbW4ozM4sREY4REZAQEJIPD5UODpcNDZoMDJ0MDKALC6QLC6gwMLV+ftAAAAAA + AAAAAAAAAABtbdkyMscICLoHB7kGBrkGBrgGBrcFBbcFBbcFBbYGBrQFBbEGBq0GBqoGBqkGBqgGBqcG + BqYHB6YHB6UHB6QICKIICKEKCpoLC5EMDIUtLWxlZWV0dHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAlJcMKCrQMDK8MDKkODqQPD54QEJoQEJcQEJYQEJUQEJUPD5YODpcNDZsMDJ4MDKEL + C6QLC6giIrFjY8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTtUFBb8FBb0PD7wEBLkF + BbgFBbcFBbMFBbAGBqwGBqoGBqgGBqcGBqcGBqcGBqcHB6YHB6QICKEKCpsMDI8NDYMPD3owMGpoaGh2 + dnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcMKCrYKCrELC60MDKkNDaYN + DaQNDaIMDKEMDKEMDKILC6ULC6gWFq1WVsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAiIsUSEr8EBLsFBbkFBbcFBbEGBq4GBqoGBqkGBqgGBqcGBqcGBqcHB6YH + B6QICKEKCpoMDJAODoMREXkSEnMyMmdnZ2dxcXF8fHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABDQ88JCbgJCbUKCrMKCrEKCq8KCq0KCq0WFrFWVsUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhOYeHsUQEL8EBLoFBbgFBbQF + Ba8GBqwGBqkGBqgGBqcGBqcGBqcHB6YHB6QICKEKCpwMDJMPD4cREX0SEnUUFHAzM2NVVWdVVW5JSXJF + RXdHR31JSYJMTIdiYo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYNgWFr8JCbokJMBoaNIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA0NM0kJMUZGb4MDLgFBbQFBbEGBq0GBqoGBqkGBqgGBqgGBqgGBqYHB6UICKIJCZ0LC5cO + Do4QEIMSEnsTE3UUFHMVFXMVFXIVFXUVFXYVFXgUFHwUFIAUFIMVFYZDQ5B7e5MAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvL8kpKcEjI70cHLoREbQFBa8GBqwGBqoG + BqkGBqkGBqkGBqgHB6YHB6MJCaAKCpsMDJUODo0QEIYSEoETE34UFHwUFHoUFHsTE3oTE3sTE34TE4QT + E4kTE40TE44TE41LS5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA0NMMuLr4qKrwkJLsZGbYJCa4GBqwGBqwGBqsGBqsGBqoHB6gHB6UICKIJCZ8KCpsMDJcODpIPD40Q + EIkREYgSEoUSEoESEn4SEn0SEoEQEIgQEJAQEJUQEJcSEpYTE5MkJI9ubpYAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzc5Vra5ZOTpZP + T5hCQpg0NJg1NZw3N6Fra7YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZMkzM741Nb4uLrwpKbohIbUKCq4FBa4FBa4GBq0GBqwG + BqsHB6gHB6UICKIJCaAKCp0LC5oMDJcNDZQODpEQEIwREYYqKnBUVG9qaoQAAAAAAAAoKKMODp0PD50R + EZkSEpQTE41MTJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6epFj + Y5RNTZM3N48hIY8SEpASEpISEpMREZUREZYSEpgSEpoSEp0SEqEdHacAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQELMKCq8mJrc6 + Ors1NbkuLrYmJrUQELAFBa8FBbEFBa8GBq0GBqsHB6gHB6YHB6MICKEJCaAKCp0LC5oMDJYODo8QEIcP + D4FWVmt6enoAAAAAAAAAAAB4eMsNDaIODp8QEJkSEpMTE4wcHIlmZpUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABzc5VbW5NFRZEuLpAYGI4REZAREZIREZMQEJQQEJYPD5kPD5oPD5wPD58PD6APD6IQEKQoKK1n + Z8kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABUVMkGBrAGBqsFBagVFao4OLQ6OrUzM7UtLbgSErQFBbMFBbMFBbAGBq0GBqoGBqgH + B6cHB6UHB6MICKEKCp0LC5kNDZAQEIcQEH4mJnFycnIAAAAAAAAAAAAAAAAAAAAyMq0ODpwQEJYREZES + Eo0TE4o0NI98fJNra5NiYpNNTZM/P5InJ5ASEpAREZEREZMREZQQEJYQEJcPD5kODpsODp0NDaANDaIN + DaQMDKYNDagMDKo+Prt1dc8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHB7UHB64GBqkGBqMGBp4gIJlZWaw+Prk4 + OLsxMb0aGrkFBbUFBbMFBa8GBqwGBqoGBqgGBqYHB6UHB6MJCaALC5sNDZIQEIgREX0TE3lbW3IAAAAA + AAAAAAAAAAAAAAAAAABjY7EPD5cQEJMREZAREY8SEpASEpEREZMREZQQEJUQEJcPD5cPD5kODpsODpwO + Dp4NDaEMDKMMDKUMDKcMDKkLC6sXF7BLS8J1ddEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH + B7QHB60HB6cICJ8ICJphYYwAAABpacFERME9PcI3N8IfH7wICLUFBbIGBq4GBqsGBqkGBqgGBqYHB6QI + CKEKCpwNDZIQEIcREX0TE3Y/P2x4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAzM5cPD5EPD5IPD5UPD5gP + D50ODp8NDaENDaIMDKMMDKUMDKYLC6gLC6oLC60KCq49Pb9nZ80AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB3d9gICLMICKwICKUJCZwWFpIAAAAAAAAAAAB1ddFISMhCQsc9PcUt + LcEQELYFBbAGBqwGBqoGBqkGBqgHB6YICKIKCp0NDZQQEIoSEn0TE3UvL2tubm57e3sAAABubopmZol9 + fX17e3t/f38AAABra5ogIJUNDZYNDZwNDaEMDKYLC6kLC6wKCq4jI7c+PsB1ddMAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABubpppaZNmZo9jY4xiYohhYYhh + YYdhYYdhYYdgYIZgYIZgYIZgYIZhYYdhYYdhYYdhYYhhYYhhYYhiYohiYohiYohpaYh/f39/f38AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQMgICLMJCasKCqILC5ks + LIsAAAAAAAAAAAAAAAB7e9tOTsxISMpBQcg8PMUnJ7wQELIGBqwGBqsGBqoHB6gICKQKCqAMDJgPD40U + FIMgIH82NnJmZmZHR20fH3YSEn0REYAQEIEsLHhZWXFwcHB+fn4AAAB/f6hkZLJtbcF0dMwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NcUNDbIODqsP + D6QQEJ0REZgSEpQSEpISEpETE5ATE48TE44TE40TE40TE40TE40TE40TE40TE40TE40TE40TE40TE40T + E40TE40TE40TE4sTE4sTE4oTE4gUFIgVFYYvL4VhYYh9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA/P8YJCbAKCqkLC58NDZVCQocAAAAAAAAAAAAAAAAAAAB7e9pTU85NTcxISMlBQcU8PMEv + L7wdHbUTE7IODq8ODqoQEKYYGKIgIJwmJpMnJ4hAQG0yMmYTE3UTE3gSEnwREX4REX4REXwREXs7O21q + amp6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABGRtMLC7wLC7gMDLMMDK0NDagNDaMODqAODp4PD54PD50PD50PD5wQEJsQEJsQEJsQ + EJsQEJsQEJsQEJsQEJoPD5oPD5kPD5kPD5kPD5kQEJgQEJgQEJYQEJUQEJQSEpITE5ATE4wUFIg+Pol4 + eIQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/P8IJCawLC6QNDZoPD5BKSoUAAAAAAAAAAAAA + AAAAAAAAAAA8PMlYWM5TU8tMTMhHR8RAQMI7O8A1Nb8wML0qKrgmJrMgIKwiIqMkJJslJZEhIX4QEHwQ + EH0QEIAQEIIQEIMQEIAREXwSEncSEnYxMWtpaWl6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOYlJccKCroKCrcKCrIKCrALC60L + C6sLC6sMDKsMDKsMDKsMDKsMDKoMDKoMDKoMDKoMDKoMDKoMDKgMDKcMDKcMDKYMDKcMDKcMDKcMDKYM + DKUMDKQNDaMODqAPD54QEJoSEpUTE48rK45xcZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+PrwK + CqYMDJ4PD5QQEItgYIUAAAAAAAAAAAAAAAAAAAB1ddgFBbhAQMdeXsxYWMlTU8VMTMRGRsNAQMQ7O8I1 + Nb4wMLoqKrMmJqsiIqQeHpsODo4ODosPD4oPD4sPD4wPD4wQEIgREYASEnkTE3MTE3EyMmhqamp+fn4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB9feJBQcwWFr0ICLcJCbYJCbUJCbUJCbUJCbUJCbQJCbQJCbMJCbMJCbMJCbMJCbMJ + CbMJCbIJCbIKCrIKCrIKCrIKCrIKCrIKCrIKCrEKCrEKCq8MDKwNDagODqMQEJwSEpYcHJFxcZsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAuLq4LC6ANDZoQEI4SEohoaIcAAAAAAAAAAAAAAAAAAABLS8sFBbYF + BbAuLrljY8hdXcdWVsVQUMVLS8dFRcU/P8I6Or01NbkwMLMoKK0QEKALC5oLC5cMDJcMDJcMDJYNDZQO + DpAQEIgSEn8TE3YUFG8WFm1CQmZubm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB7e90AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABt + bdgmJr4LC7AMDKsODqQQEJwSEpZeXqAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC50LC5kNDZMREYoTE4YA + AAAAAAAAAAAAAAAAAAAAAAAhIb4GBrMHB6sWFqR1daBkZMFjY8hcXMlXV8pQUMlKSsRFRb8/P7s7O7Ux + MZ8ICKYJCaIJCaEJCaAJCZ4KCp0LC5sMDJYODpAQEIcTE3wUFHIWFmsYGGpWVmt2dnYAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJsAMDLEODqoQEKIREZo/P54AAAAAAAAAAAAA + AAAAAAAAAAAMDJUNDZMPD48SEogZGYUAAAAAAAAAAAAAAAAAAAAAAAAHB7gHB7AICKgpKaAAAAAAAACN + jcl3d85cXMtcXMxWVshXV8FHR7UdHaYGBqkICKgHB6YHB6QHB6QICKMICKIJCaAKCpwMDJcODo8REYUT + E3kXF24ZGWgoKGRra2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABw + cN4LC7UMDK4ODqYPD58bG5pTU515eZAAAAB+fn58fHwMDJENDZAPD40SEokuLogAAAAAAAAAAAAAAAAA + AAAAAAAICLcICLAJCaZCQpwAAAAAAAAAAAAAAAAAAAAAAAAAAAB0dLoFBagGBqoGBqoHB6oHB6gHB6cH + B6YHB6YHB6UHB6QICKEKCpwMDJYPD40TE4EVFXQYGGkaGmZJSWZ1dXUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGL0LC7MMDKsNDaUODp8ODpscHJkoKJMlJZAMDJQN + DZEPD44REYxPT5UAAAAAAAAAAAAAAAAAAAAAAAAICLgJCa8LC6VNTZ0AAAAAAAAAAAAAAAAAAAAAAAAA + AAAFBasFBakGBqsGBqwGBqoGBqkGBqgGBqcGBqcGBqcHB6YHB6QICKEKCpwNDZQQEIoTE3wWFnAZGWcj + I2NsbGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABra6pXV6N/f6IAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERNAK + CrcKCrELC6wLC6cKCqQKCqIKCp4LC5oNDZUPD5IREZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCboKCrAM + DKVQUJ8AAAAAAAAAAAAAAAAAAAAAAAAGBq8GBq0FBasGBqwFBasGBqsGBqkGBqcGBqcGBqcGBqcGBqcH + B6UHB6MJCZ8LC5kODpESEoQUFHcXF2wZGWdKSmd1dXUAAAAAAAAAAAAAAAAAAACAgK0/P6QSEpsSEpkT + E5YcHJSAgKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+UICLsJCbcJCbMJCbAJCa0JCaoLC6MMDJ4ODps2NqIAAAAA + AAAAAAAAAAAAAAAAAAAAAAA0NMoKCrIMDKYXF50AAAAAAAAAAAAAAAAAAABVVcMGBq8GBq4FBa8GBq4F + Ba0GBqsGBqgGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKIKCp0MDJYQEIsTE38VFXIXF2swMGRra2t5eXkA + AAAAAABnZ6EiIpoQEJ0PD6APD6AQEKAREZ0SEpkwMJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcgHB7wH + B7oICLYJCbEKCqwMDKgZGacAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+MKCrUMDKkODp5PT5kAAAAA + AAAAAAAAAAAcHK8HB68GBrEFBbIGBrIFBa8GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcHB6YHB6QJCaAL + C5sODpIREYYTE3oVFXEWFm5fX2lwcHBdXYcwMI0REZQPD5wODqMYGKlfX8EAAAAcHKoQEKESEpxVVakA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB/f+YVFcIHB70ICLkKCrUlJbkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAJCbkMDK0ODqIZGZkAAAAAAAAAAAAAAAAlJbIfH7YVFbkKCrcFBbUFBbEGBq0GBqoGBqgG + BqcGBqcGBqcGBqcGBqcGBqcHB6UICKIKCp4MDJcPD44SEoMTE3kTE3Q5OW0fH3oSEoYREZEPD5oODqNe + XsAAAAAAAAAAAAAAAAAODqsQEKQSEpwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtoLC7INDacPD51PT5kAAAAAAAAAAAA8PLYq + KrkoKL0mJsAgIL4VFbgNDbIGBqwGBqkGBqgGBqgGBqcGBqcGBqcGBqcHB6YHB6QJCaALC5sNDZMQEIoR + EYESEnwSEn0SEoMREY4PD5hGRrEAAAAAAAAAAAAAAAAAAAAAAABxcdoNDawQEKM6OqUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK + CrgMDK0ODqIZGZoAAAAAAAAAAABoaLszM7swML8uLsEsLMIrK8ApKbwnJ7kbG7MVFa8NDasICKkGBqcG + BqcGBqcGBqcHB6UICKIKCp4LC5gODpEPD4cSEoQTE4UQEIstLZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAaGrkODqsREaB/f6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtkLC7MMDKgODp5PT5sAAAAAAAAAAAA8PLw5OcA2NsM0NMMy + MsUxMcIvL74uLrwtLbkrK7cqKrQjI7IdHbAZGa0UFKwUFKoUFKcUFKMWFp8cHJkiIpQlJZIiIoppaaMA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOINDbEPD6UvL6MAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrgLC60NDaMX + F5wAAAAAAAAAAAB2dsNBQcI/P8U9Pcg7O8g6Osg5OcQ3N8I1Nb80NLwyMrowMLcuLrYsLLUqKrQqKrIp + KbAoKKwnJ6UnJ54nJ5gmJpWCgpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGboO + DqsREZ9+fqsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABiYtgKCrEMDKcODp5cXJkAAAAAAAAAAABubsxISMlFRctERMtCQstAQMs/P8k9 + PcU8PME6Or85Ob03N7s2Nro0NLkzM7YyMrMxMa8xMagwMKEvL548PJsAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACAgOIMDLAPD6Q4OKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrQLC6kNDZ8eHpgAAAAAAAAA + AAAAAAB4eNdPT89MTNBKSs9JSc5HR8xFRcpERMhCQsVAQMI/P8E+Pr89Pbw7O7k6OrY6OrE5Oas5OaY4 + OKVzc6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UODqkREZ57e6gA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABfX9MLC6wNDaEODphhYZQAAAAAAAAAAAAAAACQkOZVVdNTU9NRUdFQUM9OTs5MTMxMTMpKSsdI + SMRHR8BFRb1ERLtDQ7dBQbNCQq9BQa1JSa4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABhYdcNDa8QEKRBQaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6wNDaAPD5c8PJQAAAAAAAAAAAAAAAAAAAAA + AABgYNlaWtZYWNNWVtBVVc5TU8xSUshRUcRPT8FOTr5MTLtMTLhKSrVLS7VOTrUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7QODqkREZ8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6wO + DqAQEJcvL5MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaNpgYNReXtFcXM1bW8lZWcRXV8BWVr5VVbxV + VbtUVLteXr4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABERM4MDLAPD6ZLS6sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC6sODp8QEJU/P5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACAgNxmZs9jY8tiYsVhYcJgYL9gYMBra76UlM8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7YODq0QEKUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKkODp0REZVdXZgAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArK7QeHq0gIKpjY64AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8UMDLQO + Dq5pacEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABaWsoMDKgODpwREZR3d5oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2dsgICKoK + CqUcHKEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC7oNDbU1Nb0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMbsMDKYPD5oZGZMAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAUFK4KCqcMDKJ8fKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYt0ZGb9FRcsAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC64NDaMQ + EJpBQZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcXMELC6cMDKIxMaEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALC6wNDaIQEJliYp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAALC6gNDaEODp0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6oODqAQEJgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5ObYNDaMODpxERJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABaWsoMDKkODp8pKZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKkODp8XF5cAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMrsNDacPD51cXKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAXF7QMDKkODp5PT5sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC68NDaUPD50A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrQMDKsXF6EAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAMDK0ODqMhIZ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Nc0KCrcM + DK5LS68AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1ddEMDKsODqJPT6cAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABxceEJCbsLC7MwMLMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9 + Pb8NDakPD6EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Nc0KCrkMDLEODqhQULEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGLAODqYsLKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABiYtwKCrgMDLIODqkQEKJMTKsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKwODqVlZa8AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGL0MDLMNDawPD6UREZ5KSqUA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABlZcwNDaoPD6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABTU9MLC7YMDLAODqkQEKMREZxJSaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMrsODqlBQa4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8QLC7QNDa0PD6cQEKESEptaWqYA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLAO + Dqh9fbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAmJsIMDLMNDawPD6YREaAcHJxsbKsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABmZs8NDa8iIq4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOQZGbsMDLIODqsPD6YREaAwMKUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJL0NDbFlZb8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB/f+IZGboNDbAPD6wQEKgdHagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALC7kYGLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+IaGrkODrIODrBQUMYAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERNELC7t1ddUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGcUZGcAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////// + /////////////////////////////////j////////////////////4f///////////////////+H/// + /////////////////w////////////////////8P////////////////////h/////////////////// + /4f////////////////////H////////////////////w////////////////////8P///////////// + ///////h////////////////////4f//P/////////////////D//x/////////////////w//8P//// + ////////////8H//D/////////////////h//w/////////////////4P/8P/////////////////D// + D/////////////////wf/wf////////////////8H/8H/////////////////h/+B/////////////// + //4P/g////////////AA////D/4P///////////AAD///wf+D///////////gAAP//8H/g////////// + /wAAB///g/4P//////////4AAAH//4P+D//////////8AAAA//+B/g///////////AAAAH//wf4P//// + //////wAAAA//8H+D//////////8AAAAH//B/g///////////AAAAA//4P4P//////////wAAAAP/+H+ + D//////////8AAAAB//h/g///////////AAAAAP/wf4P//////////4AAAAB/8H+D//////////+AAAA + Af/D/g///////////gAAAAD3g/4P//////////8AAAAA/4P+B///////////AAAAAH8H/gf///////// + /4AAAAB/B/4H//////////+AAAAAPwf+A///////////wAAAAD4P/gP//////////+AAAAA+D/8D//// + ///////wAAAAPg//Af//////////8AAAAB4f/wH///////////gAAAAcH/+B///////////8AAAAHB// + wf///////////gAAABw//+D///////////8AAAAcH//g////////////gAAAHA//8H///////////+AA + AAwP//g////////////wAAAED//4H////////////AAAAAf//A//////j/////8AAAAH//wP/////4P/ + ////wAAAA//8D//////A//////gAAAH//A//////8D///////gAAfwAP//////wP//////4AAAAAD/// + ////Af/////+AAAAAB///////8B//////gAAAAA////////wD///4AAAAAAAf////////AH//wAAAAAA + A/////////8AP/wAAAAAAB//////////wAfgAAAAAAH///////////AAAAPAAAAB///////////+AAAf + /AAAAP///////////4AA//+AAAA////////////gB///gAAAAP//////////+D///8AAAAAf//////// + ///////gAAAAD///////////////8AAAAAP///AH//////////AAAAMB//wAB//////////wAAADgH+A + AA//////////4AAAA+AAAAB//////////+AAAAPwAAAH///////////gQAAB/AAA////////////wOAA + AIIAH/////+AAAA//8DwAAAAh//////wAAAAAf/A+AAAAH//////4AAAAAD/wPwAAAA///////AAAAAA + f8D4AAAAH//////+AAAAAD/A+AAAAB////////+//+AfwfgAAAAP///////////8D8H4YAAAD/////// + /////gEB+H8AAAf///////////+AAfh/AAAH/H//////////wAP4fgAAA+A//////////+AD+HwAAAGA + P//////////4B/g8AAAAAh///////////A/8PAAAAA8f/////////////BwAAAA/D/////////////4c + AAAA/4f////////////+DgAAAf+H/////////////w4AAAP/w/////////////8HAAAH/8P///////// + ////h4AAB//h/////////////4PAAA//4f/////////////D8AAf//H/////////////w/wAP//w//// + /////////8P/AH//+P/////////////D/8P///h/////////////g/+H///8f////////////4f/h/// + /H////////////+H/w//////////////////h/8f/////////////////4/+H/////////////////8P + /j//////////////////D/w//////////////////x/8f/////////////////8f+H////////////// + ///+H/h//////////////////j/8H/////////////////4//gf////////////////+P/+B//////// + /////////H//wH////////////////x///Af///////////////8f//8B///////////////+P///gP/ + //////////////j///+B///////////////5////4P//////////////8f////////////////////P/ + /////////////////////////////ygAAABAAAAAgAAAAAEAGAAAAAAAADAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxccwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODqV7e8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABCQrUkJKYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp11dbcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ6YiIqMAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6eswNDZt7 + e7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAANDZs3N6YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODqgAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABQULgNDZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp5RUa0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODppJSakAAAAAAAAAAAAAAAAAAAAAAAAA + AAANDZkzM6IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ6MODpoAAAAAAAAA + AAAAAAAAAAAAAAAAAAANDZgzM6EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABr + a8QNDZhZWaoAAAAAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABoaKlMTJkqKpY9PZNMTJR1dZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAANDZghIZ4AAAAAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhMQWFpcLC5EKCpIJCZIJCZELC5AMDJMyMo94eIUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0NKgNDZhxcakAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdHZwKCo4HB5EICJsHB58ICJsICJMI + CI8KCo8REZFTU4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZczM6AAAAAAAAAAAAAAAAAA + AAANDZgzM6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eMYWFpUICJEGBp0G + BqUGBqcGBqUGBqEHB5sHB5EJCYwLC5E4OI4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZgNDZgA + AAAAAAAAAAAAAAAAAAANDZg0NKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABN + TbIXF5cICJsGBqUGBqcGBqcGBqcGBqcGBqUGBp0GBpAICIsLC48xMY4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABLS68NDZdgYKoAAAAAAAAAAAAAAAANDZk0NKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB+fsgcHJoICJsGBqUGBqcGBqcGBqcGBqcGBqcGBqUGBp0GBpEICIsLC5A+PosAAAAA + AAAAAAAAAAAAAAAAAAAAAABtbboNDZdYWKoAAAAAAAAAAAAAAAANDZlSUqoAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIpoLC5QGBqEGBqcGBqcGBqcGBqcGBqcGBqcGBqUGBp0G + BpEICIsMDJFUVIsAAAAAAAAAAAAAAAAAAAAAAAAvL6INDZiAgLAAAAAAAAAAAAAAAAAODppaWqsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjI50VFZUHB5sGBqUGBqcGBqcGBqcG + BqcGBqcGBqcGBqUGBp0GBpEJCY0REZF5eYYAAAAAAAAAAAAAAAAAAAANDZgXF5oAAAAAAAAAAAAAAAAA + AAANDZlPT6YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaL8hIZkKCpIG + Bp0GBqUGBqcGBqcGBqcGBqcGBqcGBqcGBqUGBp0HB5EKCpA5OY0AAAAAAAD///8AAABhYbkNDZdFRaMA + AAAAAAAAAAAAAAAAAAANDZgxMZ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAwMKEbG5UGBpIGBqEGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqUHB5sICI8MDJNycosAAAAAAAAA + AAAkJJ4NDZeBgbEAAAAAAAAAAAAAAAAAAAAMDJYNDZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACTk9UwMKAbG5cHB5sGBqUGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqEHB5IK + CpA7O5AAAAAAAAAAAAANDZggIJ0AAAAAAAAAAAAAAAAAAAAAAAANDZUMDJRra6MAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzc8M5OaQjI50HB5sGBqEGBqUGBqcGBqcGBqcG + BqcGBqcGBqUHB5sJCZAfH5AAAAAAAABoaLkNDZhZWaoAAAAAAAAAAAAAAAAAAAAAAAAaGpwMDJNDQ58A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdXbdERKg0NKINDZUG + Bp0GBqUGBqcGBqcGBqcGBqcGBqcGBp8ICJATE5YAAAAAAAA5OagNDZkAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAMDJYNDZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABkZLtPT6xFRaclJZ4KCpwGBqEGBqUGBqcGBqcGBqcGBp8ODpMnJ51xcZQAAAA1NaINDZgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABfX78NDZhJSagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACIiM1ZWbJUVK5LS6wsLKIbG6MVFacUFKoXF60qKq43N6c3N6N4eIQAAAAu + LpgNDZVkZJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0NKgNDZl7e6oAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqartgYLVcXLFXV7FTU7NQULdNTbhJSbVF + Ra4eHplQUIhERIs8PIcLC5A2NpEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZcoKJwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRsQoKLEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAClpdyDg8ZnZ7lj + Y7dgYLddXbZYWLQmJp0aGo8YGI4KCpIODosKCo4SEo97e3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe + HpYNDZVhYaIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABgYMgODqM+PrMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTKJDQ5YICJkICJ4HB5kNDYkKCowoKIhsbIUAAAAAAAAAAAAA + AABxcaBubpxubpcjI5AMDJM7O6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbMsbG6cmJqp2dsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2drEYGJoICJ4TE6obG6kGBpQICI4KCo4Q + EI1QUIE2No8TE5MMDJMMDJIMDJELC5ELC5ENDZZlZbkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7e9EoKKwODqBHR7J5ebsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbK1XV6c8PKNXV6Z6eqUAAABmZrFeXr4zM7UG + BqUGBqEHB5sHB5IICJAKCpAJCY4JCY0KCo0LC48LC5AMDJMjI54AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAoKKoODp0ODpxCQqpwcLEAAAAAAAAAAAAAAAAAAAAAAABsbK08PKENDZgNDZcNDZcNDZcMDJYMDJQV + FZE1NZAmJpIHB6UGBqcGBqcGBqUGBqEHB58HB5kHB44KCosLC5AyMpljY7IAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABCQrINDZsNDZkNDZk+PqNqaqlxcahERKIWFpkNDZcNDZYNDZgwMKQA + AAAAAABMTLEZGZsMDJMKCpAICJIHB50GBqUGBqcGBqcGBqcGBqcHB58HB5BMTHgAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdXb4ZGZ0NDZgNDZcNDZcNDZcNDZgw + MKV5ecIAAAAAAAAAAAAAAAAAAAAAAAAAAABSUq8QEJEICJMHB6EGBqcGBqcGBqcGBqcHB58HB48QEIle + Xn8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1 + Nas/P65+fscAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8PKYYGJgJCaAGBqcGBqcGBqcG + BqcGBqEHB5IJCYwQEIsjI4oSEpMNDZknJ51XV6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERKku + LqgSEqMGBp8GBqEGBqUGBqUHB50GBpIHB48JCY8LC5ATE5EeHpgNDZkYGJxtba4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB6erNeXrJhYbdzc8UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAqKpo3N6Q8PKYfH5oGBpMGBp0GBqUGBqUGBqEHB58HB5kUFIl1dYEAAABjY7INDZkNDZkz + M6EAAAAAAAAAAAAAAACBgbBaWqs9PaQgIJ4NDZsNDZsODpwODp4mJqtxcc4AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC5AKCoxGRppISKgqKpsJCZMGBqEGBqcGBqcGBqcICJ8JCZJHR4kA + AAAAAAAAAAA0NJ4NDZcWFpk0NKANDZoNDZoNDZkNDZkNDZkODpoxMadiYrsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS7ALC5ALC5AAAACIiLpSUq44OKUTE6MGBqcGBqcG + BqcHB58JCZEmJop5eXlpaZZqapYAAABgYJsfH5oNDZoZGZw8PKtiYrp+fskAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvb9NAQLQ6Oqo2NqM0NKAyMp4xMZwxMZ0xMZ0y + Mp4yMp8zM6AzM6AzM6AzM6AyMqBDQ6QAAAAAAAAAAAAAAAAAAAAAAAA9PacMDJElJZQAAAAAAACUlMdd + XbRPT7U3N7EdHagXF6cTE6EYGJctLYgcHIcLC5ALC5AYGI1lZYcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3N7MODpwNDZkNDZcM + DJYNDZUNDZUNDZYNDZcNDZgNDZgNDZgNDZgNDZcMDJYNDZYXF5t+fq0AAAAAAAAAAAAAAAA5OaMMDJIv + L5oAAAAAAAAAAAAuLqBgYLVaWrNNTa5BQao1NagpKaAPD5IHB5AHB5AICI8KCo4QEI5mZooAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB4eMh1dcV0dMUAAAAAAAAAAAAAAAAAAAAAAAAAAACEhMtAQK0NDZgODppoaLEAAAAA + AAAAAAAwMJgMDJNSUp8AAAAAAAB+fscMDJRQUJ9sbLJmZrdaWrFLS64qKp4HB58HB58GBp8HB5sHB5EJ + CY4eHo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA1NasODpo4OKV2dqt1dZ4cHJEMDJNqaqsAAAAAAAB0dMYNDZeBgawAAAAAAACSkr0pKZMICJ8HB6cG + BqcGBqcGBqUHB5sICI4LC48/P44AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABfX8ANDZkMDJQLC5ELC5ANDZcAAAAAAAAAAAB5ecwNDZl6erEAAAAAAABQ + UKgJCZEHB58GBqcGBqcGBqcGBqcGBqEGBpMJCYwQEI9+fn4AAAAAAABwcLwkJKgYGKMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbG50NDZUNDZdgYLoAAAAAAAAAAAAAAAAN + DZs3N6YAAAAAAAAWFpkLC5IHB58GBqcGBqcGBqcGBqcGBqUGBpsICI4KCo1NTYdQUJ4YGKIkJKd5ecMx + MakZGaMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABDQ7IODpoAAAAAAAA9PaYxMaEeHqMSEqUKCqYGBqcGBqcGBqcGBp8GBo8JCYsMDJIX + F5xmZrsAAAAAAAAAAAAaGqFmZroAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODpo3N6IAAABqarFDQ6g8PKU5Oac1Na4rK7IjI7EeHq0W + FqEbG5YeHpU+PpwAAAAAAAAAAAAAAAAAAAB6es0ODp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQa8NDZmAgKwAAABgYLVRUa1LS6lH + R6tERLI/P7Q7O684OKU1NaA1NaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp9aWrYAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZlISKYA + AAAAAACEhMlfX7VaWrFUVLBRUa9OTqxMTKpKSqxtbbgAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsAaGqEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAANDZk0NKMAAAAAAAAAAAAAAAB6esFoaLdkZLRhYbRgYLV/f8IAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAODp9pab0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAANDZpISKkAAAAAAAAAAAAAAAAAAAAAAAAjI55zc7IAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABFRbsbG6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxccMODppycrQAAAAAAAAAAAAAAAAAAAA7O6oiIqEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fdkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS7QODpwAAAAAAAAAAAAAAAAAAAAA + AAAODp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJqY4OKkAAAAA + AAAAAAAAAAAAAAAmJqc3N6cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODp9ubroAAAAAAAAAAAAAAAAAAAAODp0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAODqAAAAAAAAAAAAAAAAAAAAAAAAAbG6NJSbEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlZcIwMKwAAAAAAAAAAAAAAAAAAAAAAAAAAAApKaoODp5RUbQA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJqp1dcIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB7e88ODp4ODp5OTrEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGqcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsEODp4aGqN0dMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABubs9b + W8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsQODqeEhNcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA5Ob8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////// + ////////////9//////////z//////////P/////////+f/////////5//////////j//////////P9/ + ///////8/z////////5/P////////n8////////+Pz/////8D/8/P/////AD/x8/////8AH/nz/////g + AP+fP////+AAf48/////4AA/jz/////wAB+PP/////AAD58/////8AANHz/////4AAcfP/////gABz8f + /////AAGPx/////+AAZ/n/////8AAn+P/////4ACP8f/////4AA/5///P//wAB/j//+P///gDwP//+H/ + /+AAA///+D/8EAAP////B+AAAD/////AAYAB//////AH8AD//////j/4AAf///////wAAf/D/////AAQ + 8AP////8ABwAP/////iAAgP//AAB+MAA///+AAB44AB////j+DjAAH//////AMYAP/////+BxgAY//// + /+HmAAB//////+YABz//////8gAfP//////xAD+f//////mAP5//////+eB/z//////5+f/P//////Hz + /+//////8/f////////z5/////////Pv////////9+f////////n8f///////+f4f///////7/4f//// + ///P/4///////9///////////////ygAAAAwAAAAYAAAAAEAGAAAAAAAABsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7FlZXoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAByctIxMYgA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAASEqdjY3UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPT8c1NX4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAASEp5tbXUAAAAAAAAAAAAAAAAAAACCgsJfX3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKLg8PHMAAAAAAAAAAAAAAAAAAABSUr4x + MXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/ + f9YaGpB2dnkAAAAAAAAAAAAAAABGRr0jI3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODqVISGwAAAAAAAAAAAAAAAA9PbofH30AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAB7e5I7O28tLWkyMmBISF5ycnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCQsUjI4AAAAAA + AAAAAAAAAAA4OLkgIH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSUqMODpAPD4sQEIgSEn8WFnAhIWFISFoAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAQEJlYWGoAAAAAAAAAAAA2NrsjI30AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATE7AHB6YH + B6IICKAJCZwNDZETE38YGGg1NVh3d3cAAAAAAAAAAAAAAAAAAAAAAAAUFKwxMW4AAAAAAAAAAAArK74o + KHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAREbsFBa4GBqcGBqYGBqYHB6MKCpoREYcYGGwxMVd3d3gAAAAAAAAAAAAA + AAAAAABVVcQXF4QAAAAAAAAAAAAsLL0vL3YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFsAFBbEGBqgFBaYFBaYGBqYG + BqQKCpwQEIkYGGw3N1cAAAAAAAAAAAAAAAAAAABiYr0ZGYYAAAAAAAAAAAAsLL00NHQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAdHcYICLcFBasFBacFBaYFBaYGBqYGBqUKCpwREYUZGWZLS1oAAAAAAAAAAAAAAAAbG6A3N3kA + AAAAAAAAAAAsLLwyMnMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaN4TE8AFBbEGBqgGBqcGBqcGBqcGBqYGBqQLC5gU + FH0hIWBxcXMAAAAAAAAAAAAODpVvb4YAAAAAAAAAAAAwML0mJnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcsN + DbwFBa4FBagFBaYGBqcFBaYGBqYHB6IODpAXF25CQlsAAAAAAABLS7YZGYkAAAAAAAAAAAAAAAA4OL4Y + GIN4eHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8kQELoFBa0FBagGBqcFBaYFBaYGBqUKCpsTE34lJWAAAAAA + AAAPD6RDQ3wAAAAAAAAAAAAAAABNTc4QEJhPT2YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHh+U1NcwcHL4GBq4F + BakGBqcGBqcGBqYICKEPD4sbG297e38AAAANDZpubn4AAAAAAAAAAAAAAAAAAAATE7EqKnsAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACQkOdERNA0NMYVFbYGBqwFBagGBqcHB6QVFZUsLIBvb3UAAAAQEI1jY28AAAAA + AAAAAAAAAAAAAAAAAAAQEKFXV24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABaWtdNTc9CQsgyMr8tLbsz + M7o8PLE2NpFRUWhoaHwTE3xDQ18AAAAAAAAAAAAAAAAAAAAAAABYWMIjI4F3d3gAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbW7deXokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAChoehpadlXV9FTU81PT8pBQb8XF50bG4IREYISEnoqKl5/f38AAAAAAAAAAAAAAAAA + AAAAAAASEodAQGIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUMUqKqFg + YIoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7IICKcK + Cp8UFIoXF202NlhtbXAAAAB3d4VaWnFSUnFGRnIQEIgyMnwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlZcogIKpDQ4pqan8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABxcX55eX4AAAA8PK4kJLAgIK8KCp0PD4kUFHUiImYZGXUREYIPD4oMDJUKCpoZGZ0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8fNMdHbMe + Hpc8PHlcXHAAAAAAAAAAAAAAAAAAAABUVH0iIoQPD5EODpUNDZgbG4kyMoEkJJQGBqYGBqUJCZ8LC5cM + DJEMDI0KCo4aGp1KSrQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLr4ODqIcHIo2NnBHR24rK34QEJIMDJswMKmCgsYAAABp + adEiIsAFBbIEBK4FBa0GBqgGBqYHB6QICJ4NDYVLS2MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTMoL + C60LC6YjI6pwcMAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEsEEBLUFBasFBacGBqYICJ8PD4gcHGpOTl9a + Wm1UVGxnZ3MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f94e + HrwODrAGBqkGBqgHB6MLC5YQEIQSEngTE3MWFn4TE4wtLXxkZG8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAB9fYhnZ3tgYH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGrQqKrQWFrIFBbAGBqoHB6MJCZ0MDJIYGHVubnYAAAArK6QX + F4xFRWx4eHsAAABqan9NTXc0NHkfH4YTE5MPD5omJqdlZbUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZtAGBqQ7O4VLS7UgIL8G + BrEGBqgGBqQLC5cSEntMTGMAAAAAAABAQIIREZATE5EPD5gNDZ4ODqU1NbZmZsgAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAB4eJ5MTHdFRW9AQHA/P24/P24/P24/P24/P29DQ2tFRWtLS2tnZ3AAAAAA + AAAAAAAAAAA4OMELC5lubn8AAABiYtE0NMEYGLIMDKsODp4aGoU5OWQxMW4fH3NAQGFlZXV1daIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS8kUFLULC6gLC6UMDKMMDKIM + DKMMDKMMDKMMDKMNDaIPD5sXF4pNTWsAAAAAAAAAAAAvL7AQEI0AAAAAAAB3d81GRsJISME4OMErK7ck + JKITE4UODokQEIYTE3Y3N10AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZWcgREaJAQHp4eHoAAAAgII4W + FoEAAAAAAABDQ8MqKox4eKVnZ9FOTsAbG6sICKMICKEKCpoREYYYGGlMTFwAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAeHrYWFpkmJoEQEI0wMH4AAAAAAAA6OsY4OHkAAAAAAAAtLakFBasGBqgGBqYHB6QL + C5gUFHslJV5+fn4AAAAAAABcXIZUVHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRdAHB7YQEKkAAAAAAAAAAABpadEd + HZB7e30AAAAICLQFBa8GBqgFBaYGBqYICKEODo4WFm9KSl9ERHohIZ1vb7QkJKhjY34AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDapKSnB1dZAoKL4fH70VFbANDaoHB6cGBqUKCpoREYUVFYBi + Yp8AAAAAAAAAAAAjI5cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfX9AcHJJ8fIBWVrI6 + Oso2NsQyMrsuLrYpKbInJ6ooKJh7e5AAAAAAAAAAAAAAAAAyMr1SUnoAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAQEKVRUXAAAAB7e9NMTNFISMpERMNBQbs/P7FRUaAAAAAAAAAAAAAAAAAAAAAA + AAAjI5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH6pISHcAAAAAAAAAAACAgNpYWMZY + WLh/f7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7ZhYYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODp1tbYMAAAAAAAAAAAAAAAAUFKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfX7IAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEpcAAAAAAAAAAAAAAABPT6RKSokAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5ec8uLoYAAAAAAAAA + AAAAAAAUFJkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABFRbxfX4UAAAAAAAAAAABiYtM5OZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGaYAAAAAAAAAAAAAAAAAAAA1NcMxMZNj + Y3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2 + No8AAAAAAAAAAAAAAAAAAAAAAACCgtgYGK8tLYtiYncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABlZbp+fpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtbdMXF6w/P4sA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9PbUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///////8AAP//+f///wAA///5////AAD///z///8AAP///P///wAA///+fP// + AAD///58//8AAP///jz//wAA////PP//AAD/wP88//8AAP+Af5z//wAA/4AfnP//AAD/gA+c//8AAP+A + D5z//wAA/4AHnP//AAD/gAOc//8AAP/AAzx//wAA/+ADPH//AAD/4AE+f/8AAP/wAT8//wAA//wAPx// + AAA//gAfn/8AAI//+Agf/wAA4f/IAD//AAD4PgAA//8AAP8AIAP//wAA/8H8AD//AAD///wAD/EAAP// + /gBCAQAA///8AGAfAAD4ADxAA/8AAPgAHMAH/wAA//+EwAP/AAD//+DMAZ8AAP//8cQADwAA////4ADv + AAD////gAecAAP////ID9wAA////84fzAAD////z3/sAAP////ef/wAA////57//AAD////nP/8AAP// + /++P/wAA////78P/AAD////P8f8AAP///9///wAA////////AAAoAAAAIAAAAEAAAAABABgAAAAAAAAM + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCzAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWlq+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAPT22AAAAAAAAAAAATU27AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT22AAAAAAAAAAAAPT22AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGC7Hx+rEhKo + UFC1AAAAAAAAAAAAAAAAAAAAAAAAWVm+AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjIzIBganBganBganBganBganhobCAAAAAAAAAAAAAAAABgan + AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + iorFBganBganBganBganBganBganhobCAAAAAAAAAAAAPDy1AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABganBganBganBganBganBganBgan + AAAAAAAAAAAAFBSqAAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAXV24BganBganBganBganBganBganQkKwAAAAf3/GWVm9AAAAAAAAPDy1gYHH + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyutBgan + BganBganBganBganBganAAAAOjqzAAAAAAAAAAAAdHTFPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyutBganBganBganBganBgankZG5NzevAAAA + AAAAAAAAAAAAPDy0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAg4O/Hh6pBganBganBganMjKqERGodna8AAAAAAAAAAAAAAAAISGtAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXV3Ba2vFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + goK0BganBganERGoc3O5eHi+bW2+YWG8BganAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAeHjIPj63aGjCAAAAAAAAAAAAAAAAVVW5ExOqLCyuQECvJiaoBganBganBganBganNjavXl65 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALy+xIiKuFBSq + Skq5AAAAAAAAAAAAXFy4BganBganBganBganJiaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZWW1BganBgan + BganBganBganKSmrLCyvf3/FAAAAAAAAAAAAAAAAAAAAh4fNfHzLAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFC1KCiqEBCnBganBganBganSEitAAAAW1u3ICCsOzuz + FBSqLy+xWVm+AAAAAAAAAAAAAAAAAAAAAAAAAAAAXV3BPj63PT21PDy1PDy1PDy1PDy1PT21AAAAAAAA + AAAAOTmxZ2e4nJy7BganBganBganGxunHBynNDSsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT21cnLCAAAAOjqzk5PFAAAANTWtR0etJSWnEBCm + BganBganNTWtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAgYHHBganExOqAAAAAAAAOTmxAAAAEBCnBganBganBganBganhYXAgIDGPz+3AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + OzuzAAAAERGoBganBganBganBganLCyuAAAAAAAATU27AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU1O4AAAAERGoBganBganBganAAAA + AAAAAAAAAAAAeXnKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAPDy0AAAAAAAAW1u2ODiwAAAAAAAAAAAAAAAAAAAAT0+9AAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGjCAAAAAAAA + SEi3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeHjIAAAAAAAAAAAAZ2fCAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + TU28AAAAAAAAAAAAWlq/aGjCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPz+3e3vL + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////////////7////+/////3f///93//4f + t//8B7f//AO3//4Dt//+ATP//wFz//+Ae///wD3/z/wB//HgA//+HA////4A+f/+AgfwDgD///JAf//4 + 0A///9A3///oe///7Pv//+3////d////3P////8///////////8oAAAAEAAAACAAAAABABgAAAAAAAAD + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAeXmRAAAAW1uRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT2THBx6Wlpy + AAAAAAAAV1ekAAAAVVWRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwu0BgamDAyVTExsAAAAdXW/AAAA + XFySAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWHYBwerBgamEBCIAAAAYGCZAAAAQkKNAAAAAAAAAAAA + AAAAAAAAAAAAgoLJAAAAAAAAZmbXGxu0GBimX1+CaWmIAAAAAAAAgoLJAAAAAAAAAAAAAAAAAAAAAAAA + goLJAAAAAAAAAAAAdnagGxugIyNyfn6QYWGNamqTAAAAAAAAAAAAAAAAAAAAAAAAAAAAUlKWXV2ScXG5 + fHzOIiKwBwekFBSEenqaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHR2rCAih + ISF1V1eIbGyLa2uVbm6mAAAAAAAAAAAAZGS2WlqtY2OzWFikAAAAXFykAAAAPT2zIyOaGRl+d3ePAAAA + goLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoLJbGy4AAAAa2uTEhKvCAikJSVzAAAAenqZAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAZWWthoa/SEjBfX2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAdnauAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + goLJbW2qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA//8AAP7/AAD/XwAA418AAOFfAADhXwAAsG8AANwPAADgHwAA/wEAAMKFAAD8hQAA/4cAAP+/ + AAD/zwAA//8AAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAIABJREFUeJzsvWe0HNd1 + JvrtU1XdfQMuLiJJMOAyCiRNEhQpUhITJIuyRHFI2JQt2ZoRMbZH4zDrkeuNxpb9bJOzbI2X7PGS9GRL + shwo28p6HjGIpChRBDMYACIwIud8cUPnrnDO+3FqV+2q7otwcUEE9l6rVufuqur6vp33AbrSla50pStd + 6UpXutKVrnSlK11pl1U9PfdtKBaXAKAOW1e60pVTVdaWSnc91dtrnuzrM1s8790AXABevLkAHHSJ4KQT + dbx3oCsnvgy77sJ9St1rAGgAWwqF+wAUAfQAKAEooEsCJ6V0CaArhxTPmFENDBoABkBAdPlPi8XfBDAt + 3vpgicCDvaa6JHCSSJcAunJImR5FW/uM+Re2ADSA0PP+EMAggBkApgPoh7UKXJzCBDDqukN7PG/h8d6P + qZIuAXTlsGRWGH5Zw1oAGoAmOvMrhcKnAMwGMBPAAKxLUMAp6ArUlRpc3tv7pRd6eja/UiqtfHhgwDw+ + bdpTq0qlO9A5FnJSHP9JsZNdOSHEebK3d2mL6IaICBERmsC+X61UfgdAA8AYgAMARgFUAfiwXHFSS12p + wbXF4t37HeeukGgwIrIkGN8aIri12o23BcGrAKJ4C+Nb5swTVroWQFcOV8iLom9zHEADUERz/59i8RZY + V2AQNh5wSlgBdaUGV/X03PtsT8/m3Y5zT4to0CdCAMAnQhBvIVB+VmvAHv8ATrJ4SJcAunK4Yq5rtb6t + gTLHAQyAC4rFj8D6/wOwBNALGws4KQlg1HWHXurp+eYzPT2juxznnpZSg75S8InsphSC+HFAhD2t1pf/ + KooiAHMBzELqCnk4Cc6Bc7x3oCsnjRAA507XPStS6ipNBE0Eh2igFEVb1mg9Amv6+gBaSM3gE9oEZhl1 + 3aE7isUvbfK8+2pEC0PW8LwpZbfY/QmJqpuaza/9YaOxHBb0vbCgNziJ3IAuAXTlSIRuJxp1Xfc/6xgI + mgj9jkM/9f3XYC92JgAfFgQnNADqSg3+WrH4uQ2ue19VqfdGRAhisAe88XPxbRPY/Mj4+N9+3fe3w2ZA + +mDBD9hj5uMP4scn7PG7x3sHunJSif54EKx8qFB4HcClBBsEO811r5lP9KOtxrRg3YAKgBpSS4BDByeM + 1JUaXF8o3P28Uja4B7BmT27lfQ787Wi17v/zavUJWI0/B9YyasEeXw0ngdkvpWsBdOVIhT7tONMCpT7I + kXANYA5Qey4MtyHVgNIKiI7f7maFNf46z/tumegjIVEpiE38vMYPhNk/bszafxsb+7vvtVpbkWr9AizY + AwB12OxHOb5twJ6DE9oN6loAXTkSMQCivUHw4HTX/Qup5i4oFm9As/kUrGbsj29rAJo4QUhgbbG45CXH + uacFDEVCu0eABTpiK0ApRPHzTWB4Za32wL82m5tgg3szYBWngQV+ExbwFaSWTzN+7YQGP3ASmSpdOWHE + AVB8oK/vpUCpSzlQponwcK329R/YfPg+ALsA7AEwAqsdAxwnMGwrFBZtct37fGCIzfrIpvAyZn4kSMAH + 6huazce+UqsthwU+VzkCqZVTAzAOe4wjsHUQY/FzDVgL6IQmga4F0JUjFVsJrPXDIdGlBIDI6pErisWr + fxAE62C1fx9S4MhYwNsmo6479Ibn3fcW0SIOWIYdgC/9fR+ob2+1nvpOrbZ8lzEEm9/3YJVliNTcr8AC + fTTeGPgVpBbACR0ABboE0JUjF+v2h+ED5Dh/oACQsdf4HMe59Gxg2nar/SQBeEgtgGMOiIZSg+sKhbtX + KHVPJqAHtAX3+H4rBf5Lu4xxYIt5XNhaGc5uNJCa+2NiY+DXYcmOzf8TvhKy6wJ0ZTKiAJTu7+9/KwDO + DuPAWUSEF5vNH3692XwOwDCAHQB2w5rGXB58TAlgR6GwaIPr3ucTDUVAsl+dNH7IGt/3n/x2tfryLmMU + UsJi4LOfz1q/jBT04/Fx1ZCa/CdV/UPXAujKZMQACAvGPBsR/ToZk7gBFxaLV6HZfBlW+0sr4JgGAxtK + Db5VKNz7lk3rdQR7CCQBPt+Y+jbfX/rtavWlnVbjc/UeA58zGTK6X0Y78KXWl0WSJ4V0CaArkxEDQBei + 6Omm6/46AVDGgAAMKnXeVUrNWaF1E5YAuDTYQ9ogNKUA2ee6C5d73n3NuIKPwc/pPGn6+0S17b7/xL9l + gV+ABb5BFvg1WNCzv88pPk7zsa9/whc8TSRdAujKZEWv9/37z3CcrykSnqQxuK5YvHRFo7EPFvy9SJtj + HEyxeby+WFzymlL3tWl7zudzcI+otrPVevyb1eoLO+x1z5YJA58rGBn4bO7zJk39JtIIPx/PSQd+oEsA + XZm8mN/VeuQhYFtozDmKKLGdzy0U3o1G41m0uwENWI05JbKmWPzSdqXukuY+F/KwBeAT1Xb5/mP/XK0u + 226v9z6kzUoyl99AO/AryAJflviedOZ+J+kSQFcmKwaAcY151if6Dc4EEBH6lTp9oVJzVmXdALYCpsQN + WFUs3ndAqSVagl9svlLV3b7/yD/Was9uMaaAlIj4mg9gAX0kwD8pGnyORLoE0JWjEV3S+ummUr9BsLZ0 + ZAxAhI/29LxvVa0m3YAirK/NwcBJA+jVYvGLB4iW6PiLpL8fEGFE6599eXz8B5ss8LlTj8t2uWPxHQ18 + li4BdOVoRCMIlpLjJJMviAhkDE73vAUAHoXVur1orwmYVI58l+ctWk90N3cjckVfBKBpzPqf1mp/+50w + HEc6oKSENPYQIAt8Bv87DvgsXQLoylHJB6Joy0PAtgg4hxAXBRGhRDS4yHHOfDKK6shmA7i4hjAJUO1U + 6h5uQErmb9nxZOuXlMt/ADuUYzbSZh3AArqJrsZvk+5EoK4cjRgA2jXmWRiTWgFxPGBBsXguLOhlNoDX + EJhUEVpENKiJMgSgAURKzRsimo90Kk8xfqkOW6q7F7Y/YWe87Y6fG4Yt7OlUyXdKgx/oEkBXjl5MUevV + XBKcrBVmDM4rFC6HBbx0A5gAJnXt9RnzL/FUYkg3gIC+m4vF62DBX4IFL4N/Hyzgd8KSwDse+CxdAujK + 0Yru1XolAz+ZgkmEfqLTLldqFiwg83GASQ3MnB0E32QXgJPvbAVcUip9OP4tgjXlK7BlyHthOxP3oQv8 + jHQJoCtHLe/1/aeIXYDYCkDsBlxbKi1AuowYLyXGM/SPmADO0LpcAL4lpxMjvl8imv7Jnp7LkFb0VZF2 + 7I2gC/w26RJAV45WbD0A8GriAoh4wHmFwmXIugEyDjCp66/m+59PSu+IYIyx943BlaXSe5EaBpzuq8e3 + HOh7xwOfpUsAXZkK0UVjnk56AoxJLIBpSs29LHUD2ALIZwOOSG6Joq1kzPcBwLDFEUsv0cCvWyuAvRK5 + otk7IrJ/JNIlgK5Mheii1qsZiDIQSACuKZXehZQAZHPQZAZoGgDm4Wbzjw1QTn7TmIR8riiVrou/v5D7 + rZNqYOfbIV0C6MqUSEHrVQxAOSTEADjN8+bDgnCq3IDoq8Yc0Fr/Mwce2ZRQxqAPmP7bvb03Ip1MlG9I + 6pJALF0C6MpUiLk2CFYlWQCRDoQxOM11zz+diJcNk9mAybgBbNIHH280vgBjdqlY+zvxpozBpYXCorOI + 5qB9xaJJxx5ORemeiK5MlRgXeFZxU5DYYAzeWygMIZsN4N6AyWhkbgNoDQfBZxUAN0cCRaB4R2/vIqTL + lvUjO/SjawWgSwBdmTrRnjGrgdQk50AgAJxfLF4IC3iuCThakzwC0Po931+qtb5fan++vdjzFr1bqXNg + CaDTwp3veOmehK5MlZhSXBGo4ixAUhoMYJbrnoWUADgbUMDkNDK7ASGA5vcbjT8joOLCWgKSDBb39S1G + SgDsCpz0qxdPlXQJoCtTJlwRCIhYQGwF9BANXJKmA3ljn3wyK1Qluf77jdnbCsO/dbVOwM8EcAbRgl/2 + vMthV/PhFX3kxN93NAl0CaArUyXmqiBYLcuB88i6uqdHugH5OMBkrsVkau+nW62vamNWuMakVoDWUABu + LJVuQ2oF8HwAJp+TngBGXXdoR6GwqKHU4JF+tksAXZlK0a4xz8oaALYE4nTgWbAmvySASZcFI3UFfACN + LUFwLxOAG7sgSmtMB07/TLF4A1IrgDMSJ21AcHVPzxef6Oszj/f3m5dLpc2vFYtLN3jeVbDHxBsT64TH + 1yWArkylGA/YIkuBORBIAGY6zpmwF2YRqRsg6wEmA8QkI/C5MFwRav2AozUUb1wc5Hk3n0M0FykB8GzA + k84K2Od5Cw8Q3c3rF/JMxGHH+UXY45JzGA96brsE0JWpFFM0ZrWcCyDrcT2geK3rzkPqBkgCmOxK1Rkr + 4JUg+GsCKg5bAfHWa8zgJ0qlm5FaAZwWPOkCgptc94vJTAQxE7FsCW4w3vKuTkesdwmgK1MqvVqvAnLF + QEgrAy8sFs9GOwFIc3UykgQEv6D1ulYU/UuSiTAGpDXIGFyg1PvPSq0ATgueVMVB2wuFRVWiRYnmR7rm + wbi1hObCTkSagXQ2woSuzklx0F05acRc7ftPTdQTQABO9zx2AyQJcBzgaAiAA4Ktt6Lo29wbAB03DBuD + gjGlT5dKt8ACQ8YCeGGQE94K2Oa698hFTnkQqg9U/1e9vhTAmQDmwRLBdFgrYMK6h+5MwK5MtRgXeDYA + ru+UDRhQajaycYB8JmBSswLjz0TLFy26IOzru6UVBMMolWbz2DB4Hpy+PpwxOvq+i7WeuXdkZM1rO3c+ + 9s1t215AOgeQLYkTsltwR6Gw6E1gEa9+FLAFAGAkipa/Zcw0WEz7sOeYlzCfMM7RJYCuTLWYgjGrG0TX + cx0AEUEZAw2g1/YEuEhJQGYCJmUBjN9yy6UjM2b8341i8RcDovnKGDgAdPybId83BoWZMzHPmHedOWvW + u9594YW/+infHw2q1edbw8P/8MsvvPBzZNctkPNGjrtscZx7OPCXLH6iFEIifLtcfhx2HqJCumQZL4DS + KSsLoEsAXZl6sa3BKsWyvPLIGHzA885eGgQVpASQjwMc1gKiu2677XOVYvG/7Jo27TxtDCKtoXkWgZhJ + IEuSjTF2I4Kx7sGMwrRpHyv193/sZ6ed9jqGh79w83PPPQAkylWuAHTciGDUdYdeVmoRz0DkacgBEfaF + 4fMvaG1gXRsmrnxgs+O+dwmgK1MvUfQkuW42BmAHdwIAepXiSjzu15eZgIP64bVarVD+rd/6HxWl7ip7 + 3hytNUwQQDP4geSWSSD5QkEKOh5fbuLnIgDkupfSaaf9609uvvlHP1+79k/+etu23bCalCcIMTG97USw + 3vPukSm/UCyB9vNabRnSgGaA1JWR+91xn7tBwK5MtZgbw3ALkLU75bSg0113DizY2Q2QLsCEBLD7Yx/7 + g12/+Zvby677F5pojvZ96CCwWxjCRBFMGAJhCASB3cIQFAQg8djE9/nzURhChyGiIEAYhkBPzy8vWrDg + kc+fe+7VyLYSH5fCobpSg2Wixfmof0iEca3X/TSKxpFd+YgXP+ERaGzJtEnXAujKlMtrxeIN68TjTEEQ + EVa3Wlthrz3e8hN7MoHA0Q9/+KaRmTO/UlbqMqM1dBAkcwA1m/Rig5gRmEhcFgz+4piMNFKLQapIct35 + l1100QP/3fc/8Tc7d76GdK6gXBz0bbEE1hcKdwVEg4n5z6shEWFZtfozpKsfhUgXQJEEMOH+dgmgK1Mu + e5T6s8wTHAgE0NK6tTwMR2A1qYPU9Gf/P2OVbr3llq/unTbtd6E1dBQlIGdfPwGv1qlvnyMBfpyQUAx8 + ADZNSGSJBHa9AZMGL3uuvfDCr36gUvntpeUyk1Yt/iSvHnTMSeCAUkuiXOFPRIQGcODffX8PrO8PWKDX + Yachy+nHXQugK2+PbC4UFr1BdJN8TsYBNofhW7mPdOwfGlu06JJ9s2Z9twZcjjBMAK6BBNQMbA0kpGBy + wI8EGZhcbMAga50kC44gHTZKwFmfOP/8zy5dufLPkXUBGkgDbseMBN4qFu/cQjQkgc+xgDfr9ceQdjZG + sNqfwc8WgI+DBFW7BNCVKZU9St2Zn9kPIAHZ443GGmQBI6PrBgB23377B3YQPYgo6suDPWPuI43qswYH + kAQEmSwkMfB9JiX5w0wwrNZ1HLic3tv7oY9On/7Qo+PjrwEZT8IgtQSOiex3nKz2R7IW4vDfNxqvw5b9 + Alntz+sd8krME5JUlwC6MmUy4rpDL8fLdhuyytzE0XYiwkgUbVurdRXpar0RUgBFAPQbN930f+015guk + tTXPBfATTa51gj5JBFpskihYo7MFIAkhiRXw/gJJXIBRQ8bgg2efveTR8fG/km/JbVNuBezxvIWr47Lf + UPj/mgg7ff8lpL6/Rlr0wwueHlL7A10C6MoUyoa4TDVBiAAVjMEzrdYyWPOZy3Z92Au3BSB84brrfqfe + 3//nKgyBKEq1tNT+QEdwS+Dzc0AK9onuS3Iw8b4bYxJTm98/p1S68rr+/kueq1aZtDgYmK8VmDLZ6rp3 + SeBz4K8F1L9Trb4Im53gZdDqSJc8ryHr+0+4X10C6MqUyG7PW/harP2ZBAxSS6BizJ6fBcEeWK0VwoKH + V+tpPvae93ya+vv/1Pg+dByEk9F6aQFI8CbAR3scgAOF+QxBJo6AbJUPWyzSHaD4u949ffp7n6tWdyFL + XFxG3DHINlkZdd2hl5Rawv6+XAh1p+8v3WkMweL3UNr/oKTUJYCuTIlscpwvyiCaXLobAFb7/grYIJpB + dsmu+lfnz39P38DAn+ogSDr4khRebO4DQtMDWY1/OMCPP4+c+6DFbRIz4EBbfF/DWiLn9PZeCeDnYt/Z + z2awTVksYKPn3RVK4APJ7eO12mrYugRCSqQy+Cf3qUsAXTm2st3zFq0lWiQvVGkF1I0Z+3artQ628457 + 9+sAqjdOm+ZcMn/+XyMME6AZY2DiFl5AmOiwoMz7+5rN9/hz0k3IBxGBNO+fcQPsDyVEQPH+RyJW0KPU + 7DNdd87OMORgWxkp4KasNqCu1OBzSi3hwB9nADQRhsPw+Ve0bsIWKBlktX8+8n/IfekSQFeOWrY5zj2s + 7WWxCoPpZd9/DrZSDUg1Vg1A9Q8vueQeaN2njZ3jF8Vaug38RFYja51YAPkYQKdiIFkDkLEGkA0m5hcO + jGDdFxOTGstHBwev/8fh4QOwAOxHSgKcijtqAlhXKNwVAoMS/EyuD1YqP0fa5MNVf6z9qzhCMuoSQFeO + SqT25x51af7H2n89rO8v/dXq54eGfqGk1DUmCADEuffIwi2T4kNq8ksLwKA9BoAcccgMgg4CmDBMQS9i + AFqAXXseyHVt9iJ+L+LXLi4Wr/2jgYHT32y17r+/1RqDrcGXQTeZ1jxiqSs1+Lzj3B1KzQ9LrAfC8LkV + WreQNv20kAb/qjiMwp+8dAmgK0clWx3ni3lNJTXW8lT75+vUy1dMn/47JgytXx4DlWKQc/uw9PsjSQiw + +f68ua/jGv+o1bKVg1EEEwTc+QcgDU7yLROADLb5SiF0HESuCxQKQLEI1/MQEmHAceZf39t717uLxetf + qtX+5sdRxATAxgJbAkdMBOuKxbsCof0lCdxvtT+n/vKFP6z9D9v8B7oE0JWjkHWFwp1biRbKAhVp/leB + sW83m+uR+v6JxvrsOefM9xxnyMR1/UnkX2tQbO7ntb8WZKCNgY4iC/RWC2GrlQD9kFc+pb08CRnEz8n9 + j4xB4PsIgwBRvQ6lFBzHji4kY9Cv1FUf6e//zk1R9E9P1Gpfe9SY7UgDc4dMweWlrtTgs0rdLZt9IoB9 + /+dWWN9/evx2H6nvf1hlv52kSwBdmbTsUepenQN/cvECeKXZ7KT9KwDK7ykWP51of9jx3ZnIPVI/PxLg + 91stRI0GIt9H5PsAcmWERyBGbDJ9qWNLQMv7cb9AFIZwiKCIEBo7/bjXcX5r8cDAJ/5DEHz+9+r1f0W2 + aUiGFg4qbxWLdwVEg2FO+wdA7YFKRTb9RPJc4ghTf1K6BNCVSUms/YfkxSrN1Row9p1mcwPsRcvmag2x + yVpy3fNkjb+Jy3d5ihBr+UhrhI0G/EYDURAgkmk8sT+He8XLz7Lm503nj0WppFSRyYFjAsm6B3GcQBnT + X3Ddv7yvv39JLQj+539rtZbGx8xa+aBuwYjrDr3gOHcHgkSDeD92+f7PllvffyLtn89EHLZ0CeAkl7pS + g7scZ3GFaFGLaKhJdIUDrA6JqBd4aiCKHrjY91cjqyiPKlAFpNpflqlypVpIhJWNxvOwef+89h8HUHG0 + Pl/H0X5jDEwU2dSb1tBaI2o0ELRaCJrNJAiWKdgR+3JEByKqEzPaH6m2l5ZMYExCagZxetCYpLw5swAK + AFLqXQOFwnf+zfN+/lajcc/no2gd2guG2s7/mmLxiwHRYECUDPqM7Idq/1Kt8sCPTtq/gsMs++14Oo70 + A105MWTMcYa2KnVvlej2CBiUc+Lz912ihyvN5uc+EYabkZqksk7niDC0uVC4faPj3O8rhRaR3ZSCTwSf + CFVg7A9HR/8VaeS/AmAYwG4AO+4eHPRunjXrMdLaLt/F0f9m0wbwms1Mak6mFI8G/BzNz5v2+Sk7vlJ2 + A+DHxMYWwG6tt/cAhXlEp3nG2PHGxqBgDLx4K5h0dSKj9b/+uNH4wneM2Yu0N1/66eb1np7F61z3R6EA + P29vNhr/+P/W6xthtb8DC/YDAHYB2AlgL4BRWCuApwEdtkx2MYauHCdpKjX4G677ua1K/ahFtDAESrIC + j0dGS1O2RXQRPO8/fsiYZT/WehSHGBR5KPmk5329RTSUXKjxYMpAKUREeKnZXPpaGFZgFaMPSwAjAPYD + OPBGobD9VwqFu0lrwPehKxWE5TJMq5Wk6eRUTgZfXo7YhCFqM/8TElAqQwBhTGZB/FpEBBDhuXr9pSfK + 5TVbfX/9tELBm0k0SwHJvAM5AQkAlFJXLPC8T9/huoP9Ybh2tT0fyXlfXywufMPzfhQSlSQBhESoGvP6 + X5TLj8CCvwDLh1VYAtgfn9MybADwiMEPdAngpJJdrrtoreM8WiVaLFW41PiZuXFZMii6hcLiuu8/uNF+ + LD8O7rAunjHHGdrmOF+SWlNOp60DY1+sVJ6ENf817MU5DnuxDgMYabVa45/0vP8RVSrQ1WoCet4JI4Da + 1ltwJDubOziZ+suAXxJATgMH4nUQYdn4+IqWMWFZ6+arzebm7b7/xoxCwZuh1JzMIigkuJWoSEpde6Hn + 3flxzzvnKmO2/lzryt8rNb3a2/vDllJD/NsyiPp4ufzV9Vo7SJt+GgDGYAlgGFbzV5CmII+YALoxgJNE + 1hQKX9oA3JVoerFlqtnYL0fqm/OFboim/crAwDceGx//DOyF4yENIAGHcRHtct3bjfze3H6sbDaXxd8L + pFV/ie8PTldVKmtgzOXceMMNNwyc5Lio3UiZDPg7+f4y4i9Jk2fuB3EQMFIKhgg7g2D7uA3G8cBNf2MU + jW8cG3vwYqWWfqS///r5jnO5VgpRfEyGbPbAAUBE0whYMr+3d8m3jXkRRP01oktl8JFTf7t9/98fDsMy + 7Ao/CvYvrcNqfHkuJ+X7s3QJ4ASXMccZest1fzQCLOSccDKwAnGhDKUtuGwVsKMZIufsK7XwM4XCL33D + 959BdsUYySMTYmw8tj6SKjwRIKsbM/bdRkNW/WUi/0jTVUHJmKebwOUM74mikkddVwsc1PTvBL5AWDZc + g08Advj+jvhrePZe0hD0ptb73yyXt1yu1JyP9ffffLbjLJRhf84gJJWFSl3LBGQgSqjtF2/+vC36mQ1r + +mtkiXQcaeHPEdcbSOkSwAksmwuFxauVui8CBjkQJf9tHryR1MojW4/PSWi+iPniP7ev7z/B99cjjQV0 + Mig6SgNYlNGi8W/DGKxstZ5Dek1NrP2BsD+Kvuw7zn9LWnzFj7LmTDoCj0LyAcO89pfgT3zwGPz8mokJ + YFOlsh0pvzbi4xqDJYEQgFqj9eiacnnHlUrNu7Wv78NnO86VTJJcWsySqTWIvzgkqn3lwIEvw/r9pfh0 + tGABPxZv+cj/pE9UlwBOUHm1WLx3k1L3MKBljT0XnMsQPg+z1IIIEgIwBlopq8mIUCS66D1KvetlWx7L + 5qxcCKMjCezxvIWvi9+Wb6obM/adZnMdrL96MO3vA9DXRdHWnzjOdwLgN/LANLBmiQGAvD+Nw187jE3/ + TtpfTtdh/1/2M0j3iQBsC4JN41oz4LibsQzri5fj41WwjTrTVmpdXVmp7LxSqZ/e1tf34bmue7EHlKJ4 + nwD7v0oyCoyp/2xs7EvbjCnBpv3c+D+pISWbTtp/0tIlgBNM6koNri4UfrQ312DD5ml+/Ixc4CJT146U + MKLYD2VzUwG4uq/vAy9XKsOIF9QU24Qz7nxgOmv9ZFGNWFNvDsM1ODztz/xELwTBH17lujcCOEsSGvfk + A5PPU+fB31bll9P8fI6TqD9/JiaArdXqxngXeRoQE8AobICzEb9eip+fBmBgpda1lZXKzjOBGbeUSldc + VCq9v0+p02WAky25N+r1hx4LQ2728ZDm/Pl3OOgnff+jMpO6BHACyXbPW/Si6/6Iy0GlJgpyoJYz7WRk + XLaz5jMEDDANYMDzzocdKJmfI88FK20kEBANJg8E+AnAGY4zBOC1+Od54MdEE2oNAHOvMWNfi6LfnKfU + vxPRNHksBEAGCI94xdC85s+diyhHAslim+z3x+8nAMNhuHddvb4PKQGw/88BubH4cQQLXB7MWUFMBDuB + 2j80m6NoNl9YqNTc95VKl84pFM517CpJeKlaffJh398F22Ism33GkZLMWPy9k47656VLACeIrC6V7l2r + 1D1y5ZdAaCcZpOLg37DW27dH0Z7tUTRe1To0POUawK8Vi78kA3UyWAgiDBCdDWtmDiCtKmOgduwnd40Z + kz6/rIQrpP5qhLTpJ08s8qI1AMLf1Xob88+HAAAgAElEQVTVN4H/NeA4fwnxAuIvIwFkGTCciBDazH6k + RJgHPqf5QiCb8ovfz6b62nJ5DbLaX7o3PIGX4wAushODJBFMA9C/Suv6qnp9D+p1uSaiXBpNxhhGYNN+ + oxBBVHQJ4NSQvZ63cK3r3reXaGEe+JIAWCvVjRl90/eXP9hobNyfzoVjbCTBvF8rFpPfYG3Kb2CtuKhY + vPDJVqsGq3X6YS+4AuwF3oaxkH+HS2Hjzj0FYIZdj54JgEFSR1oPn79o2VAJlmj93T8DRi9R6m/IklJG + OCiYzPyXz4vHHcFP7Tl/rl/gAp98Dj4x/Y3BgTDcuzbV/oE4LgY+r77DBMfDTuU5kETQD0sEfbDxkh5k + F0dF/NkqLOiHYQlgPP4euXrxUUuXAI6jrC6V7n1VqbtCYFBegIEAP1+wTWMaa5vNJ/6+Xn8d6UXDK+my + yc7BvEjBXiUOkPTZZ0ZfG4Mzi8X5aLXWwl6IvbBanBfqDCba78yCn6IW/mKl+t/UehjtQEiaYYY/9rFL + G8CCplIXtoBzA98v7x0ff/2Zfft2PbZ58903OM6f9BPN5/3M/rCYMhyLyQUJO4E/M1QzBr00+dkKkP0G + B9H+7NrIARxyEU7OqshzIEmjF5YE+pAlgSKyQz4lAXCm4YjbfQ8lXQI4DvJWsbhkt1L37BYrvrRpftEQ + sl/rV78xNvbwHmM8pE0hrJHkhNqk1txBugSWI7R/kjkgQtFxBmEB3xNvkgDalulOovJAxv/nbR7RwJu2 + RJV/KgKgf3bFFR+ftWDBYioUrtzuOHPAC3lGEXShgMGeHnx07lz4F1xwYO/IyIbhtWvHZ7dalye/iSyw + M8/nwA+IysE8+AWhdjL9k6afmNh2+P6mDtpfmv6devCT3cDBiYDPORMvEwDHUGrIFv1M6JodjXQJ4G2U + N4vFJfuVunOLGKApy2jzFoAP1F+u1X74vWZzOyzwubeeLygeq11HunhlC0Dgxr56iHT5q0hobU2EHqWm + wZqeBaQXYX6l3uRi642iVXDtJZNph43vn6vULETRRn7/N2+66VMXzJ9/R9HzZuoosrP+fR+SAIzWyX1l + zKzTBwZmzb3qKozt318e2by5MT2KTmNQAqL2IP6NZOeE6Q+0R/sz+X6R5+e4ShS7GFDKTiUi8l8eHl6O + VPtzXIOHgR5q8Y2JiKCFlEiKSJdHLyA22HK/x27UlPn9UroEcIxlS6GwaL9Si8eI7txCNBgXe7TV6yc1 + 9TFoa8CO742Ofn+N1iGsz8j/VQvpWK0Ksj3hySAKD9bMVwBCraGVgivGacEYDBDNir+3gOzFyASQkXla + jz8OjJMx04koIRa2AErGFAGo/3rRRZd9/JprPtff0zMNQYDI96G0BsULfhieA8BWQHwLrWHCENoYTJs2 + baBwySWl5du2rT5vfHyBBxRl/KJjAFBo/o7tvSLXz+TLBVacTuVjWVWprBjL5v1lWpMJ4HAq8SYiAu7s + Y8LlICDHLZnkZY3GlIIfOEEJYLvnLfKJBqvAQgOgRrQojhhRBFwepeuhtZ2RCc8QERxgtbJ/YJsUgNUF + Y8YyH4m/rmTMatf6YQAAt8PPVIhuiv85ahEN+cCQT3Tjm2hPP3WqOw+VSvzQ4Sh67Z+sye/CmohsjrNv + KEtCuSecNYUPIPJEURCfF43Ud1f2mFnrsBXAFoBcrTej3TxjVkfAjRSTi4K1AgyA+cC8r1x33UcXXnzx + RYgihK0WlNZQQYAoikBRBBWDHLFFwAQAre0sgNgq0FEER+vC5WeccfGuVqsy4PtF2RTEx9QpM9CJAPKm + fzxpJ+MWEQDSGnvCcPvK8fFNyKb9mHClSS4HgR5K+D2yHZvjCgrZlZFlZeZhTxSajBx3Atjrugv3KbW4 + TrSwCVwRAkNrO/zRE91OmAoC2irIQuCK/Pv5HQ1jbmyrOMs9zn9mot+VmqoT+Dt16/H9Ta3WE18rl1+C + 9Q9lYQ1Pf+W88CiyRTZyIGToGZNEpJKGlLgphesIQIT3F4tnPd9qVZGSAGujNgsAAFxj1hDRjawpFQDH + GFCxiKtvvnmeNzgI7ftArPF1rPFJazgM9g7gl8A3UYRIa0Rag6KoMHfWrFm1vXsTpElGkn6KJAAmAY7q + 501+VtsRxzKsgkDdmNozw8PLkDX9ZSWeNP8n65PLDKXsIKYO7wGOEfiB40QA6wuFJaNKLW4AN70ODGZ6 + vyFMOc45x3KwM3LEZygPbqIJgd3x46JOPeOfCvKSWqhtYi4/RkoOq+r1B79Xq62HNfk5kC8vQC4IGcHE + 4NcAtAeMK2OmE5DUADiwYFWURrtNqnlcWBJgC4Cfl3gzJWBVXcQSFAAqFjHrQx+CMzAAHQQZgFNMAIgi + RFEEJQggit0AHQM/iqcBhWFoR4FpjUBrC9aBAbQqlYxFA6QEoMR/KsmXYy1BDvxJg5TWQGwRBVr7z4yP + PzVmTL7kl4mXS3HlFOCjBecxB/nB5G0jgHHHGdrieXeXgTt3EA3KTrLMRu3lm1ISEhCvHQkZSG3R6bWJ + JF98QuJiS78gbfrIlORSe9WZLDjxgebDo6Pff9G2f3IenCvByrAXHheEyIowGYXOmIolYHUTuBFAov1d + YxDE97k46DTPm41WiwtR5CbnWySijFktwe/OmIGZH/oQjOPABAF0GALxsM82IohJgH191vhRTAJRTAIh + b1GEABa8UW8vAt+H7/uZwiB2QQhiuIU8/+I/aCulZs0fp0lfajZXbG61RpH66ez3j8GSL5/3YxaUe7vl + mBNAQ6nBtYXCl1YR3ZkpU1Uq4+BEOTLoRABsL+WDQJ3uT2Tqy/umw2v8+GCkkrHTcpaEJDGp/WV9vpxB + X9Z63/0jI4+ssyOfS/FPsclfRgr8YaSaX0agOwahHGPgxPvhxhkAJoEodg8MEQrW71dIYwEcjJJTg5Lv + vjKKVj/uuuMETC/MmIHBD3wAAOyE3hjoiM15Br+JXQHkn4sJQMfmfhjfBlGEMJ7Fx2PGIgAYHIQ/OmpJ + ROycA0sCkrGSNCDSa0s63waAirMJBOC5VmvZ8kplE1LfnGfuM/hHkU7fkWsAnNRyzAngtWLxRyKIl/rD + QIaZ5fP8XvbjWCbS/BORwcGkE+iT7yCxIkxs6h8suChjDhKJbfP54ls2Tze3Wqu/OTb2IiwAuflDmvw8 + RYc1v+wEkxqobfccWOAzEXFbGWs71pYDjsPuBpOAKx53Moq0Czyjpk+/dfpNN9nv932r4a3PbiP6QvvL + rY0AcuCPtLaBUTmWKz7YgAj+tGl+WC4XeMd4p2UUTV4nMpLGG2DBDwAwBi8HwYqXLfhl0I/NflmKy8G/ + o+rBP5HkmBPANGPur8Z57yT0KZg5zD1mDZmxBOLvkr52p1tM8FjKhGZ+hxhA3uy3T6aPkr51pBonuS+O + g1tA2SKoG1N5pVx+4fFGYwfSgQ9caMJaJw9+uRClHDPdURRgElAYu9KOw2a7CBBOs1VpEvzSBegUCDSl + 3t7nCjfeeKs2Jgn4JdqdU30c5Ov0PAM/tgwirRHx9F1hMcliHR/2+tin1PhupcoXGXM+/wdufIxssigg + s/R3YpXFxy/duKeazWUv1moMfvkfjMfnnsFfxhT14J9IcswJYDAIHthZKn0pM0IayKRjkucFEWSCaOL7 + ZKQ9/9xEj6VMRAD58GsnMrBv7EwUQEoAMg4gXRlDhE2t1huPjo+vPmBMgGx6T/qbEvx50/OwtI8MjiX3 + Y5AoY+wfbwwGsgQgm1LkR5Pf2r9o0ZxdAwOfiYwBeK09kcLjIh8t8/yxzx9Vq4iaTeggSGb8J/+x60Ir + BVMsQhcKaR+EUml9MxFOK5XmfGPz5p98Ytas/jOA03hWlhMD3BE7KwuGOGjLfRGB1v4Tvr9sZb2+A50J + mN2uA0hLcZs4hcAPvA0EcHoUbX0tDO8YUerqClAMHeeGBpHXNMZrAZ4POH2Oc36YIwip/WVkHWgH3EFT + gbEcToQ/854JptHkYwFGEIIBEBjjjxkzYsTnR6No1DfGX16pbNykdRXpoXFlGEeaJfg52Jfv/z4s01PJ + Wn0iawUg9pVFDr+fqB8io4d2FyA5LaOLFl2yva/vQQ2cq+PcPi/uwYDXWkPHJBD5PvzxcQSVCsJqNdk3 + +Z8mcZIgsBZhs2krIT0PUU8PdE8PQs/LxE+Gpk+f9cjo6NIbBwevvkipC3gJMSKb7kzKkyktV5bW3G6t + 9z5WrS7bGYZVZM1+WX+/H+ngzSkZv3UiytuSBfiFVuvHAJbCjjn6LoDTAMyBHXg4gLS5hbWPjELTLKLi + As+babiqdYLfmcy/ciSpPwBY5vt7D/JzExkjJrfJQFNe848gm+PPt38e1mEWbRbgJkA07yC1AiIOEhqD + K113zkqbgZBuQGZ0+N4PfOCGrf39jxqt+7TvZ/x6LQggiiKE1Spa+/ejVS5nDlqelCTOg/ZAcEiEIIrg + 1+toNhoIi0VQqQSnpweGCCXXLVS0bj48MvLk/mnTtr+vUHh/CSgmtQlMAtICAFAFai/7/pqn63U2+Ttq + /gVEtVsKhbPf5Tg392i9YiawdwYQuEGw8tooGp3gPz4p5XjUAeQLHpiBAXstZFK7AOiAMdXnfP9A7nP5 + 7zke0skwyd/X4pY1f76zjHP8HHHOL/d0xGanA4zJnn3AakTSGorINgjFmvNspWavBLYgSwCJFbD7xhuv + 39nT8yiCoE9qeeTA75fLaO7Zg7Bez4y7aiMAytVKIFstyZZBYhVy+q9eR7G/H07KG8FLlcrqjUqtuaa/ + /xcudJzLZgBzlbACAGBbFG3fEIY7ljYaEviybbkKYPzDrtt/U6n06zOJrikY0+/CWkxsgjlK4UcAPGCN + a8x4yZinS8CWojFbrmy1nhL/8UThqRNO3k4CkBc+d0W5sH8Et7ZKszMhgNwtxHs6vfZ2SCfNfrDX8rVO + 3MHHzSX5sl65uOSkTM6iMau5Y4/jFqz9ndhU5i89nWg20mIgGQtQr7/vfdfv7O19EEHQl6T2tE4Kfvh+ + c88etEZGsjGPg5wgGalP3AG0Z4P4+wiA0RrNchlBo8EegQ+gcUDr+qPl8uOPAk8A8K4rFi/SQLGmtV4T + BOPIxjLyBFy7tVic875C4Y5B4GIulpL7KdPPjiXNy30iNIlu4IvwoZ4eKGCbA2wrGvN0AdhSiqJVVwXB + KpzAxPB2EQAzNrc5csqrDpv75vHUhMMjgbx/erwIQOdu89d6Hvh88Unfn6fJyMKeI/L3O0mvMZu5YSfZ + 4ipAGQMgAOfb/nsGflIN+KMrrnhfub//+xQEfZzmQ+z3c2Vf1Gigvm0boiDoCPpOJ4RvJ4rvmNzzsiJU + GYN9zeYIUiLlhUda8du952xpcx9S15LdGSPOf+MKxyne1tv7K3OIFiYXUPxb/KfJfSJkTVTKxRsIOIeA + c5pE1xMAUgoPeh4cY14tAGuKxqzu1XrV1b7/5CFO09smbwcByIAXT5ph8Mv2U3mtTgTwid5zPAggr90P + puwkEbD/z+eDN+7nZ+12VBfFBWG45qeFwjiA6fnhHVwJiHhHphnTf5XjnLYiisYQE8C/XHHFHTNmzvyj + MAx7ldYJ6JNbrRHs34/m/v0ZlpLFWxP5RBPKBGleIAVb3Zha3KUng3dcnx/Cgr0H6cAN7rNnAgjOIlJ3 + 9Pa+f77rftAFemW1E6cL+c/iAiMOJipBRJJgwWXRYn9Zeymiy3zgshrRp0aVwoOum5CCZ8yaHq1XXWtJ + 4WDX0jGRt8sCkH4+k0Ed2brzPLiBzvU6nd7X6b3HSiYK7HX6wzq9zueCy015ayvnPVrxgGci4FY2/1Xu + VscXtwGwSKkrVthefu9/X3LJx8+cNes3uXHHRJFt5Y2beqA1mjt3IqxUDqn1Ox3IhAcnNH2SRYktFnZn + 9kcRB2H5PMrpOc346wtICYAtTAKgP1koXPDeUum/uMCcfH0JYP8AiuMRDGyh4VOtL4gA8ePkPtLyZEkE + 8jERXdYCLiOiT40phQdcFw7watGYZ4rGrI7C8KkP2MVc28phJjp9k5G30wXgP4xvVW4D2jV9XuTzB4sR + HEvJX9sTmf/o8HzeHZAVqlP9B5teYx5sEd0qn5Qlf8kBGIOLiBZ8SKnzrjrvvF+4ZM6c26I40o+4Y0+F + IVTs77e2b4cWNfnJQVF770ab0KH/JiPMcCAb2d/Wam0XP5nv1a8i7bUvQWSXLiOa9tv9/Z8tEl3P+8lA + R7zvEOckSSHGz0s3ih/z60rcz4C8w6aE1dC2tDhwWYvoMjIGqlDA/YXCeBF41jNmTTGKnrrB95eKY58S + K+F4RNE7AbiTpj/Y5zu5Bm+nTBjXOsj78+891kEh+meiuWd63trQmOlsXiQMTOkqQxwQLJ59tj/jzDML + FEVwGPRRZDMHYQjU6wiGh6FbLQDpVZgwmCh+6uTX50d182dki7QfLzPeIlsGzJkAECE0xv/iyMgPYbU+ + L8qxE8B2AHuQxgKAtL3Z+1Kp9OFpnveXhmhasrqSqMxMTP+DnUx0AL+4n1zMMi7Q4X4mwCVfj19Djjzy + vnBsJTzbE0VP7Q6CJz9pV3uetJVwPAhgKuRE2+/jEsA5hBAA73HP+2YA/Lr0MTgSxmaH6utD33nnwenp + sQ09DPwogsudfI0Ggj17rAuArObnAh2pmoDOJdwZAhAkEOYJAEiqAJk8VgXBmscqldVI5+XvB7ADwDZY + AhhFukCH+6dKzbykt/drIdEtstpUrvrDPScyz1oFdj8+Pv7oC2E4Ppuo/xLPO22m4wwMOM7ALNed5REV + 5ip1Bp9kCGJgkpBgnpAg4vd1IgdpRSSxBPl6/JwDvFow5tlSFD293/eXHikhnGhA6srUivstpRbMdpxX + eaZUKKPcrovi6aejOG+e7crjJp4whCMm+KDRQLhvn633jyUT2cxpfo7uA+1XoGzwklo4IQDekE7tiWcb + +v80Nnb/mDE8B3EUwF5Y7b89vj8WvxY93du7eJdS/6SBwU7j12RDGpNXC2iub7We+Xal8hrSwjSOD0pA + AQBdpNTAeYXCnNNdd9ZM153dR9Q/XalZE5HCRATRyWI4pKWAHBnEroULPNcbRT92g+Cpm31/JbLuZpul + 2iWAU1scAKVHXfd/auC/yyijN306es49F8Z1kyk8XNdPce0+RRF0pQI9Pp5ofhYJ9E7gl1bAROY/vy/j + ApBtAmohnuYTBwCfC4IVT9VqbyJNJR8AsBsW/Dtg3YHxFx2nZ3dPzz82gcWyuCjMjV1nN4CrD/drvfYn + o6NPv2UzDAx8mbZlI4pPhAynyBFqzk2FwlnzPG/2LNedPajUrIQUcGgySF5DzjKQ5BBndBDfcmYiTwgO + sL03ih5Wrda3brVkIJeVjPgzXTl1hQAUf49o3kcd58cALo5cF8V581CYOzczlFOO5OIpPrpaRTQ+3vEi + 6VTsk38uTwZ54Odn93HLbwAk/r82BgeA0b8fH38E6ZCUcaT+/w5YIjjwk97eD44q9Q0DDHL3ZdJ1SmL6 + MlJ3oG7M2Cu12tJHbGcm16Owl8Sl2nLxD0kA+Q7KfCl1UlR1tevOOcfz5sx23TmDrjtrjnQhkCMGZAEP + dCAEdLAAYjLIWwsKQEHr53t8/+u3NhoPxMdWl7/flVNTYqsQvV8met8FM2b8sGf+/H7jukl0PynnlbX9 + UYSoUkFUrSYXkuHbDsAHDg7+PPD5vclshPg5bv1llRsD1P9Wvf7IviCoIE0fj8Ca/DsB7Pwj1/UW9PT8 + FYDreTQY/07HgaDx4p9bg+Cl/zM+vny/BR9nxOTin3JlY16VJxkpgLSGhd0FTzyXv82ThHO16849x/Pm + DDjOwFzPm9cHTOtVqj8P+uS+fF48lpZDQg6ULfiKZzeWPzU6ehksme2VB92VU1MYi8G7L7tssS4W+3UU + wfDQzhjsPMWHc/5RtYqo0ciY7fxlnVIXsmU7ATaywM+AHin45eCXjF8eP98Cglt6e9/vEJlxrfdD60of + UC8asy+Iolcu9rxfmqbUpwJjBjKzDtkCoLTNnMFfN2bs2XL5Jz/3/WGkWp8rC7k3gBfl4BJtnr3IBCBL + piX4k+wD0nn/+eddAO7yMBxfbnP9icUwm6jnUs+bO8/zZvcrNTDLdWcNKDUrnuDcMU/eKZ2WdH4iNVXK + vv/vsEu41RETQNcCOMVl3xVXzNmh1HcbwC/yrD0Ic9/wIh1aQxuD1tiYrfPPSad8JQNNEoNs5tE5Tdy2 + Oi+QyQSww51kKShdgpxnGGRsbmPaZpgThDVC2RkTIRG2BMFL/5/V+oR0jKCc/isHgPIQUNmfwVxHyJr5 + vGtS80sSyG/y9U6WgnQjFAC1qFA4q4eoeIbnzfKUKs5wnFkKwCyl5vEOdWoBdwDAmPpfjYzcvQnYB0to + S4GuBXBKS/3KK2evM+bpwJgFRkT4eYAHa3wAiFot+JWK7eyLP98pd3SwgoY8+A82Ej0//Um6DgkpGAOj + VKKeo/ji5ggWF97IeQDsroDSuRIRESrG7Hm+XH7y8azWzw//5AGs3JnJI9g6rcuXn7nSiQykdcCuQt5C + KE7wvPycA8B90vcrAJx4iGvbzIa5gHe5580mQCu7RQqIpivlusaEm+zwFxN/P4AuAZzSsjUMvxoCC+Qs + Popn8ZkY6MYYhJUKwkYj48cDnQlAPi+bZtry+0Lrty2CIjVz7vNAXJUXpyspfg8HtyLKTmRiwsn7xZKI + NrRaz/xDubwCKdiA7Eq/DHwJfjn/X05elqelLaWPLBnIQOFEpJB3FfJWQp4MpKWQ+a19gHrcdj9mTgNS + ousR9wG8gwmgrtTgXsdZFBANlozZck4QPNXhbSdigc9hyZaLL/7jkSj6VbkGH4/rAhEQhogaDYTNpp3P + T2mxTqfbvLS9T3xeavL8wqd+HIDjIB+/D7AaH7CanEuGuelGTvpJOqViktDINYXExDSm9ZYHR0Yee0Nr + vvg5tZefxSAn/7LJL+cxHM4koLx7nrcQGKyd2q7zcYS8C5GPL+TXcMhnHaR1wH8L9+BkSOwdFQOoKzW4 + 03UXjxEtrhLdnq/ucIFneoEHKQyfviYMV4mX8/GvE1rKCxZcuMmY5WEUDURRhDCK7CjwMETUbCJoNqHD + MFMdIpfGPtiBZoAvLID8Utyy6CagOL8fV/YFQKYaj+fzc6Yhr83Z2ZY+Lc/zl2OLuH6/rPWWFZXKsp/7 + /j6kgJKpPfb1pcbnQSwTaf3J/vf5Q8q7DXn3oVM6UWr9TpZAfn1BOdBF9trIWMf/4Z075WXEcYa2Oc7d + Y0R3RkSDmVQV2gNZsYy7wCOFKHrog77/ALJNO8ekM2uq5K3zzvtezZhP8EIbkTEI6nWE1SrkgizS/JaD + WIHDswA65fMTPz8GfhCX9iYkACCIK/E0VyXmTHgZyc5Uw8WgT2YaEGW67faE4Wtra7U3lrZae5Bd3kw2 + DXGEP+/rs9afknkMh5COh4jOxJC3GPIkkX++U3GSzObyLIpn5Y6ckrK+UFhygOhOXpcgQa/QdklZKpBo + NCA+MbHZCaDsAY94Wj/04VaLyeBYdfEdlYyfffb5G5TaEEaRBbvW8MtlRM1mtvAG7U08eV/8YAeUGesl + Unuassudt5RCK9b8TAShNP2J8FyzuWzN+PimC3t75/Yo5c3yvBk9RIWZSs1QAIpEhUGlZrIl0DCm2tS6 + oo1plYNg+EAQDP+s0dgc71re7JXTl/IRfh66KrX+lMxjmIQcjguRJ4hOZOFM8FkWrgpfL3/0lJExxxna + 4rp3jxLdGQGD0rztuOYAp5rQ/m/zGQQyNFp2jHnU0/qhj1oykBW2x50MNs6b9wcHiL4QAXaVnbExu2qP + TMmJne0UiZ8MAeTXQPRjf7/F2l+ppL6fawAMEZ5vNpetSlfi5V2Sa3h08gwkyJPYIdK/lS/yFtpX9pXb + lE5hOkaST/dLcHeyHjq9xt+TJGxgS6lPHQLY4XmLdil1d5Xodr6o5a1cmUcDyYKZ8t/m22TVGIgzKsow + JRm4xjwaheHf/XIQcK31cSODLY6zeP+sWV/2C4VzTBTBHx21I7rjXHqeADoRIu/wQcEPZPz/fNFNEG9N + Yf6zFaABaKUAIjzbbC5bWS4z+LkA0Ee65Blr4k6aEMhe1Fp8D2v9BlLwc5pPLqfeaXm1Ewn8B5ND1QR1 + egykx9jKv3BSyrpCYck+pe5qEi2UF3Wy0pBMN/GFimy/ZPKPcxQ6131FItiUn6cnnt/uGvO9A0HwrSV2 + so7suD1mWmWf4yzcRXR3Dbg9BAbV4CBQLCIYHbWaX/xwYqrjKLU/MCEBcMQ/sQAAtIRLwK7W076/7JUU + /Ax8BqwMwkkCyK8CxiLBzz5uA+nMRS7prSEFfsdFVU8xORi+zaHecMLKmOMMbXPdJQeI7gqJBmXKKQE+ + 0uqvxK5kUxXZXIgkgIQ6xWx5JW4VUhLIEEN2e92Loq+vCoIH/kTrA8gtSoujvNj2Oc7CPURL6kS3+8AQ + F8JoAKq/3x5ftZqAjScDSzaarO+fvD6RBQAkPf3N+D5bBGz6P+X7y1aka/FxPr6GtPyWNTSPA2CulasW + ycCWNPtZ+3OOvyE2nr14uKm9U15OKgLY7nmL9jjOkvF4pWFp1if13jnwSzKYaM1BFjImIYFMv7aYo5e3 + AjJkIKLSInz7ExVF3741Gy+IxM8f1gW42fMWjwKL60Q3hcYMSbAmVXMA4HnJEtz2oDrk59FZ8x82AeS/ + UwQBuaW3JW6l9v95GC5bUa3mwc/5eF6Ik5fi4tLbfLWd9G2BbOyAM43s17fEfSaJk83cP2ZyUhDAumJx + yX6l7qwDi2TNeERZ01MSAHd8dVpwVANoAJWNrdb6F+r1jRu0rn+oWDz7/FLpnLMd55wCUCBjsrPd5FBN + 2Zsd35d5akkOTvr5sgv8xI2ihz7m+/fjEPGCA647tEepxVVgUY3odhmoTK7cWPNn0prGZIDMM+2Qf98R + mv7J8znwy4L0AjUAACAASURBVHQgE7EPWAJAagFERPhpGC5b3nkhTl6Lj5fjGkNqAfC5SUoA0NkCkCTA + rkDSWIisqf+OBz7LCUsAdaUGt3ve4t1K3eMTDUkQ86rC+dpy+Vy+1FQToWZMZVcQbHmlXt+wMgy5ZDKj + GAHoXyqVhi4uld41T6lzSbgCGdALzZ+4AOK+MwEZxI+3e1o/2oqib90RBK8AiFa67lnacW6sE93kAzeG + xgwB2SvcAGlALwZ6cvXLxxzEFODPRIEoW8KLDreZ+wL08jUJfohzH8ASADv2IREejqJlL6cr8+TBz2vx + 7YO1AtgFCMXPStDLwJfcHfk/njR1G8dTTjgCGHWcoW2et2SY6K6IaLAtmNfJxBcmpnQBNICaMeVdYbj5 + lVpt4ythOIbUdMwHjvJ+Ic0l6r2+p2fBfM+7YJ7jnIcY+PkAoXQNJBkkwcIs+PNLWW+Pv/PsTiFbAMhr + f9b8/JqOnzMxMXCBjfyuBD0dLIIJwS/Ajdz72kqHBTknOX9jEBChDvivGbNpn9Yj+6JoeEMQ7EIKfgb+ + PqTmP6fmOBXIkgc+82OnQzpcj+YdLScMAezxvIXbXPfusdi/7xjJ76DpeS35ZOItEerGjO8Kw80rarX1 + y62m5+ufg+DsK/LyW01k009AWoFVAFC8WKk57+7pufi8QuHS6USzEccLJGiZDPjDSXwAbaBvyyZI6yIv + DHqTv8/EkNP+8urPZDKIkjHWEwIbaDPzk/sdQJ8nAFa9gSAAGconAIoIo1pvDYC9PvBWK4pWrQuCF57W + ehssMXCg7h0fpDvWctwJYGOhsHiX49zVIFqU99dZqwc5X19D+PjxVgPG94ThhpdrtfUvW00vBzrydclR + YgY9p4s4QiyXgHaQtmv2AOiFnTVfutZ1z76yp+fyc1z3kgJR0cSWQbKIBZCJH+SDh5msQX4UFESVi3gt + MesF6PlxxioQ1gFHzxAfjBeDv5P9zO9vGwIy0ePc8/w9Ms0aGJPO3hPnhEt5XUrr+eOFOF8vAmt6tF49 + YMzKm5vNJ5H127v++xTLcSOAt4rFJbsc554AGMoU7eS1PDr49WzeA2O7g2D9S/X62hetppf136ztO4Fe + pojqyOaGOfXETRglWPDLrSfeSv+hVLrkwmLx8jMc5zz7q2kqMR876BQ36AR8ylsB/J38vNYJKSTkEBPB + ZmO2vRFF2zYaM/b7rnsrkEbPXKJMGJ1PkjT3OwX38qO8gGwQEbnvYgLK5z55ue58r2yS34utFBk/cYHn + SsDTXhQ9mJty2yWEKZC3lQDqSg2uKxbvHhb5+4OBPE8KEYCKMbs2tVqvvtFq7X4+Bb1c/JG1/eGAnh+z + 9uc4gIG9/rj9kleZYQLoQ44M5hJNv7FUunhBqXT1dLvabpYMhGsA5AAvNwF+Et+RpChztz7gb9F662tR + tP3lKNp3wB63AWDuct3rFhBdyL6MlyOAvFmfAHgC4E90y5+Xt/k4BRNA3gLi1XiVAL6be484P+Me0SPF + KJI9Gd1A31HI20IAo647tN7z7i0rdXsADHYq0+2k4TnIVzVm59ZWa+UzjcamV7VuITuzHbB/er4Q5GCg + 52mvTA7s/8tGkERxInUFSshaBH252x4ApYuVmntTX9+1p7vuBX1E0+wetl+XMpHdyWpoAz8ApTVqxlS3 + RNG2jVG05ydhuIPPwVUzZ06/8Zxzzpzd19cPIhO0WtHZGzZcFlarGQJgUOW1PqcHGdw6d1+L+5H8jPgT + 5HEgZ/20EYBwCZxcOnUCArDfbUmr7AKPIAz/7nZrGZywDVonshxTAthWKCza7bpLxkThTqZ4B1nwy+fr + xmzf7Psrnm40NqzWuol0JWGpwGThh6z/5u1wQC9zxfLiAbIkIAcylJDGBqQ10IcsGRTjeMEVZ7ju+b1M + BkJksM4+ka4mw89prf09Wu/ZEYZ7Xvb97Ru1romP676+Pnz+mmtuvOy88843UWTdAWOAeOpPbfNmVF9/ + HajXE8DJ8HlSGCUAnwztFOCPxOPEvGcrQJBUknmQxVEyRQoRGJ0gjSrjJW15P85wpLfLEARf+NVW60lk + szndvP8h5JgQwMZicfEux7mrRrSoY1NOTtNHcUCvaczwviha83C1uuwVq+l5Zdd8b7dsHJFLbB8N6Dtp + DZlFY+Up57t1sgo6EUEP4kzCxcXiubMdZ+6g686ZTjSrQFSQPxga449qPTIaRSPlKKquC4K9q8JwRLxF + BttDANF3brvtk3OnT5+TAN8YOwGIXQWtgSBAY+NG1LdsAYIgo7Uz7bwQWp7BLi20+HGyvl4+6xAH9QA7 + tJMLp+IgX7ZSUsZC+L1Am5WQj4kkw0MEERARjDEvVH3/Tz/j+6+gW/l3WDKlBPBWqbRkp+Pc4xMNJVdp + Tnvku/J8YN9wGK58rtFY8WgYjsKChrV9Pn0n/foG2rV9PqI/GdBPJEkWC2mKUM50YzJgwEsSYFJgsuDZ + dHKKS6cmFyBbuZyvdAs+/5733HDt+effmGQDYgsg0chap7PljUFUr6Py1lvwh4cTkz/i29x/FSqVne5D + acVlMlsq/oycXy+rI9mv52h/cqBCwyduidZtlZUyLqKApBAKSOMXPEJMxbcmDL9yZ632BXRr/w8pR00A + daUG1xaLdw8rdVcYF+5kTEaIOny+eIiq42G4fL3vr/n7ZnM90hQbzz/j/ZIXex70eU3Pf/ZUgn4ikWTA + 17Uc6MjugSQDJoHEIkCWCPITXHgf88CXHW/+Q7fd9vmS500jY6BbLbR270Zzxw6E1SpMEABE8EollM44 + Az1nngk4Vj/XtmxBdfv2bFMQA1x07+VX1Ako23TF5r8B4Bvj9wAFWfeQmVIhtLwokU4Pmi0ArbPVkzkr + ILnHgEdKAmwNaGOW3l8uf/ZhY/Ygm+E5HsM+TliZNAGMuu7QukLh3nGi22VEPw9+aUrWoujVrb7/7A+a + zde3GKOQ1fY8oFT69gzqeodNmvYMelnR93ZEiKWLkI8XTEQGmTQi2q0BaQXkzf1MZuP35s8/944rrvhL + aI3W3r0ov/46EM/0VwwMubeeh9JZZ6F4+ukwxmDszTfhV6uZ/4nX0ONxXgx47uiTVgCzE9md8u8fHX3k + /N7es6/0vMt6gILU5pluSqTsmZw8jhPEcQFHgN8VBMCpRB4jZpgEYuBLEoii6JnfHx//fWSHfHKFYdca + wCQIgAN7o0R3ysUV5X0J/gDYMxwETzxSr7/wlNYNpFqQL/q8b89+PWt67uHOm/gc9GPA88bX5dsdCc7H + C/JkUBQbWwAl8RwHGTtZABL8CeF9+eKLr/mF+fO/WF23Ds0dO9KaA8qOzk4c4Pj/cfv7UZw/35LA+vUI + tU60fyBn+fEor/iWLQPZX8Gm0Mpmc8XLo6NvAdBnuG7vNdOnX3GWUueUgIIsiZYnK18nIYmA4wdMBknR + VPwdXLQkSQBEMErZakeyRU/jvv9vf1ypfAXtc/+6LgGOYCz4xmJx8U7XvesNokX5YJ6h9kBfXevnNjSb + T/9Ns/k6UhN4NiwYOE7EjSGs1Thtx4Mc8qDniz8P+hMh4su/y/iQpno+XtBp/ru0ADq5ALJnwQcQnKbU + aLBrF4Lt25My3ySFCGRKdZMdJEKrVoO/di0K8+bBmzED/shIVvsL8PNIryB+nf9nxN9FxmBLEGxi8AMI + d4fhyAMHDvx0FpFzeX//eWcXCuef4Tjnmfj98sCSlW3jugHOUmhj4PDaBUhjBgnomUz4GCkdMwZBTKVC + 4Q4AP0SaQZKn4x3vChySAN4qlZbscpx71pPtyGuL4mfBXy2H4U/vr9V++oTWdVjgz0U2qAekAOYpMNKn + ryHr60vQS+CfCKCfSGRqnZC6NC20z4LPLwOVyXghGwOQcYBoruPUKtu2pdFwAKREDJEo0Zj5XL/WGtWd + O+FMnw4UCnZMuDT3Ebf0xmSQn6rELPVGq7XmuQMHXkVK5klm5oAxraWVym4AywB47yuVzptVKMwbdN25 + PUQDvUpN6yHqT06ajPYTgZRCJIKYhmwJsUaaATAAjFKphSMIIZ4i3LukVPrIN5vNx4GkDaJbTRhLRwJo + xIG9EaXu3CKAn48S8/3QmN17ff+Bf67Xn19vfXsGvkzhxUH/TL5eavp8Sa70608G0E8kHNNgl0TBHpeM + G2TiYmiv1JWWAN8a/dprSyPXbffjKDevH2lbnUz5GQDNchk/dpxX3kP0rl6iPmkF8DDPENb859n/ADAc + hntfPnBg2e4gqCEFP0/2qSKdtBvFx1dc1myW0WyuxUGCn1cXi/MIoES/y9oCQRAvBsHez/b3/9LpRKcn + pMbuKNIYQUSEXs97F5rN1UgLxuQ1JYdDveMkQwBjjjO0uVC4+3ml7gyAwY5FOtK/N2b99mbzoXsbjRdh + 1x0bgPVvpbnFwJeVeTWkwJcz4GQEv1P0/mT+o6SLAExQCQy04VnW6wCAXuF5i6vAFQHR4DTgMzuN2V9S + 6o8KwDUMUmYNGayThCD/z2la93qOU8hE/mEj/hFS8GsiDIfh3rWVypoNtdo+8bVs3ciVdniqT4iYAJBN + i8o18ZJU6PJWq3oY58SeSGPq9gym5j/vLxOAIkKDqARgJtKFQaRLKdf7e8eJC1jgbywU7l2h1J0M7hBI + Wm3zo7V8Y1atqtW+/3e+vxX2Tz0NadGODOrJgF4tt+UDerJw45Qt6awqNVi+9dZfrLvuNaFSgy3gvfA8 + xctiZcxgYwwFwS4nCLa6QfCK2r//ja2vvvrnO4Gb5FCPfqXKe4FvENH4bKKb5bivzImMzed8We9FSp3t + EHk+pak+Tv2xmzdqzOjq8fHlm6tVCXz5H9dgwT8KO9RjFJYQAlgA5ysnuSaijQSQTRZkqoDludQ2qMf3 + M8VlHCRUAHYFQRnANGSX/q7Ev+sjrTV5x4kLAKuLxZVhbvgG530jNgGJ0DRm9cpa7QdfS4Ev/Xv+c/Lz + 2HnjVVY5b59P3Z2SoK/fcstpw0Hwn1ozZnzIV+rKrb29cw3iBhlRuZdU8YnXAACOc1lUKNgOn+nTUQQQ + rFuHyPcTXxdEA3OIPrvbmCc2EL1wDtF7k6ABZacHtdX3E6GPqE8u2hGK1ziotqFef0uAn4HPrhyDisE/ + AksGNaQLUXpISaCELAFIEpBukUwQADkCmEnUq+L9zIw9F8/5xviPNRo7kW3m4t+VWah3pLgAEBIN5ift + cDAo1vh7X6rV/vbr7cCX/r0cxyz9QAZ+viT3lK3Zrt9yy2ljhcJ/rpdKt23r7X0fAx7G2IU6JfiRAzyX + 7vJ9QQ7GGJSGhuDMmIEDL74IHQSZSTyzlPrgXmOe2ku0Zxpwer5YR57kxFVgoqfcUFUgeT0A/NdGRzch + zW5I4POCG3KNPV50o4F0wEq+PiK/6GUnC2AiSwAA0EfkOIBdVJTSl4wggF1BsAPtKVkP7UVX70hxgWy5 + rlzGuQXs3dho/ODPm81XkJr6shMvQrtvzxcFr7qS1/h5E/+UAD0A7Lvhhttqp5/+u9uKxY/A8yyo4yW6 + TA7I/3973xokx3Wd993ueewuHlyAAN9FgpREitQLoUQpFEULFu3YkWgTpaRsJakU6DhKyZUH6cRJ/qRK + +qH8kkuSU46dVCm0VFSicuISY5miLYqRCNEkRUIkXiQIgFwsgQWwWOxj3tM9Pd335kf36T73Ts9isTOz + wMz0V9U179mZ2T7feZ+TJvC8r98U/Pi6ELA2b8b2Bx/EyoEDaDUaWunu7cCnnw+CZ3fb9jYbKJKpDwDx + LEEWI6CAIG+l4+k0ALjQbs9B1/y0UrvEDnPHHi3dIIuOaoLMJZZpm225wJszTOIA6RbgDjIdKUXIA5UK + wEvl8pGUf1XXuMK4IQewk4CZ/wvt9vf+S6Ox/1TIlqTxKVJNgk+RfBJ6Enwy9c2RzCOn7QFg8bOf/QeV + zZu/XJqa+pCKGnEUNdzQbWaGK6bhuXDHGj96jF+PZ/+TJrdtbPnoR+EdOgS/0Yhz9R6Ae/P5v/fHjca3 + /sXU1D+n1Wc8rUCXCoCrlJdTqmBWbtJ8QWFZeLtSeQtJBN1F+H+mKb7LCE3+KvRqO7PsViCJwHPtbq6z + Ng/T/BcA8MTk5K8RI1EPgJYtsCycarWOzwZBHZ31FKO+EGTNyAHAlFJ/XLGsf6WEQEup179Tq/3pj6SU + ALYh1Pz56PkSnSuXKKCS5uOP9I+98PDDX6xu3fqfV3K5nbHQq3AoJx/dpQytzrW8qeHpNXzun2IEECAh + ASkENn/4w3COHoXXbIbbeBCa8b80NfXA3wTBc7+cy/0KF46YAITAW1Keut22b+HxAEpRIBL+plL1065b + QpLNcRD+z1cQTvNdQmgBUIVdt8YbngUJoFdO8kszO4K021tt+6EaOpcEUDlwWynv+VKJVrxTzQmfFcHj + TmOLHAA82Gj8x69b1revyef/7u+2WscA3ICwao9SekD4g3FtX0Ei/Fzw+XCNkTPzAaD8hS88tOT7Xy9P + THxYSRn64ikCn6bdlSH8QKfAm5aBAhBExMJ7LgKlEAiBzffcg/rx4zEJtAHcZtt3P12vvygnJ5/bk8v9 + isU1JIATUs78wvOO3zU1dUc8AYh/yej5C60WDRwhIaINPjzaX4U+T3EtFp6ZFg1SnpNqpp+x7emXgIdt + IK77jz+zCteIv91svr6sFAk5xad42pms0pGyRi8XcR3Av5XyHMKBCjcgIVQK4NA/nm9YrSLx8+kH5UsY + Ru6HbX7mM9ctbN367QUh/r7K5aCixZvSFH5TiMMHO4kB6QIfm/zcbYBOApSloeUbm++6C7WTJ9FynJAg + lMJNxeKOFxqNt6oTE+VPF4ufvlapnQ2g9mq7/frzjjPzq1NTH4w+eBJEE0lJMYTAhWaT/H8K/tGabW75 + OUhmKfbzf576XhcLhd+0gGnBSI1POapLufh0tXoMoYHAhZ8HpMe+BgDQC4F4/TqZ+MSQDtK1vtlmOZKC + DwAXP//5L83lcn+ohNikgiB0Ks2g3iU0vIQu8B3Cbvj9RCyxyY/EkaXcKZXttoXA1K23oj4zAz8IoITA + zlzuOgBnD7vu3GHX/TYSXzwPwL7dtnfaCN0B3rAjlIJtWWgp5b3ZbC5Ar/S7ooJUs+3p/Zb1Fb7fIEZE + CK9XKi9G9/CgJc//mw1BYwsiAN5+S66VFz0ukRAAj+7zneojK/jOZz5z3fy2bd9fse0H4gAf8/O1CD/Q + odW5H88Fn5MHjOeAvzcMAgj9WwRUqqtU6PtLCVUoYNPNN2P5zBlYAOZarQsIBZ5iN6SlLQDWTsvaTlE4 + RE+yoydAKSyF0X8F/fwwS7Y3VIhOFAqPSWAXgLgDMG4HVgpn2+1fvBh+70L02ShdSZZrDYnFOtZlwEBC + ABTgaSKpVaeoP0X8zR58Xkc9kj/iwkMP/e6ZrVv/SAKbNHOfCz4SgZFMyLm2l9HRLpUg22349TqCVguB + 48RNLABgT00Btg17agr21BREPp9YGoA2Lt33/TjyT0TgA7A3bcLE9DTeXFmZedvzytFXof8hLdwEAGwF + rqGdBtwKsCPzf9nzLkBvR+bnwYYv71jJ5Xa9IsRXKE3J3SOEH8b9Qbl8APp5y7cOk9uaaf8InADI9JcI + hZyq+4j902r0R1LwAWDuN37jT0u53JekUrGvb2r0S932ajW0l5bQKpfRrlSSE5blqbUwebWqfQYxMQF7 + yxbkpqdhbdqkrTrnE3radFsIKClR2bJl6amZmZejt+H/W6rO8397YuLufBRE5IJEn0cohTdrNbIAeOdm + GgFsCI7k80/FnahIgqEKoWV0rNn88aJSZMhQ0Jpc1zJCAmgi0/4xOAEACTO2kAQCyQQkxhzpH865//6d + 56anf1QX4u9IP4yBkrbnGt5M41GO3nddeEtLcM6dQ+C6ejtfiuCbP6RGCK0W2q0WguVlqFwOue3bYW3b + BpnPJ5N5iAgQhdGVwvZ8/hr2dkQAVLxTBuDsBHbGC0Ki7xUg1P5KCNSkXF5Riqbn8CpPsgI3NI12pFj8 + 8rwQu8kNijMh0e/QkHL+fzcaJxGmrcnl4c1JVKew4cR1NYOP4eJxJirWoMfocbo9kig9+OCnzmze/BeB + bV+vWAWfJvxAapTeK5XgLCzAu3gxNo3iqjqkC/1qwk+34/cKAjSXluCvrMDauhXWjh0I8vlwSAdlBgAa + vZVnL+eluzWEwlB7by53Yx5J7k2pcFUXuS0Lrdbp6CE+2ISGtvDCroGfD6cKhb0zlvUVczgp7R2UQuDn + 1epzCP1+QCe8NN9/pK3XywHPAqwlLzuyWPrUp35zYdOm/ymBzZL5+2nmPaJLCaBVLsM5cwbtanVVwU8T + +rUQAGdfuu7W6/CaTWDbNojpaW1YAhCP3uIJA54GqwKoXgMU20rFxUF81ZcCMO+6F5BYf7yr0ySAgaJs + 27sOWdafsYGyyWDS6Jj3/YPPet4iwroVcmG59ifXh9cqZMBljAQbZZx/8MHfvzg19XUlZRywo7SddsmI + oN1ooDk7Gwt+LPwpgn85Qp/2WHxpvLdbqcB3HNg7dkBGU3EkQAtHuevWMXlpCmg3IgKgyUFkSUil8PMw + kg7oU354vcfABcmxrOlD+fxTbSGmtenENLcQQAtwvlsuP48waE2ft4lE8/PGJF6enAEZAeD8Jz/5++Vi + 8evS95MAHtDh75MVEPg+nLk5OAsLmt/UTfgJq5FAGtKEn25zK8P3fTQWF1HYtg0oFMzSOV7bwYO47aJS + 0o3eU6poJ18UFCwHwbno9UQg3PzfMB/6rXz+G01gt8+0fjuaVUi3Zz3v1YvhFCqK/FMqmzoUue8/Vlbt + WjDWBHD+/vsfL01MdGp+5u9zN8AtleC8+y4C39fHFBnmM1IuzeuXBKvMo9cquh2lweK/rxScahUT27cD + lkXBG9OD4A1/Mp6yS3dEJrYNoOr7S9Gn4Bkg3tE58CzQ8ULhsXkhHuUjyeMjsgQaSpWfqtXeQOL781Jl + CvyZab9M+zOMLQGc+/jHHy8Vi9+QUX++VIbPj0TryyBAY3YWXqWiCf5q5v66Bd94HfnnaX+H++5+EMBp + NDC5ZQtaUvKyXF5AGHNGAShTAZCNsMyYRnJfa9s72Gv4KHKz2WcgOJ3P750V4pua5qd6B0p7AnjDcV5a + VIrajHmjEm9Nzop+VsFYEsC5++57rFQsfkP5fqfgs8i+UgpevY7mqVPwg6DD3OdafxCC33Gdpb44KcTL + WBwHxU2bUG63yylvq2F7EBwq2zZUZP7bItkcvMOybr7TsjafDCc78yzAwDs7y7a96w3L+jNKb/ok9NEl + kUEDqPyfZnMWYcaD0n5m0Q8v+c2EPwVjRwDnPvaxf1PK57/JI/2Sa3wkZn9rYQHOwoKu9dHd1++W3rts + MLMfQDyggxMOz4NzK6HVbKIRnvgcHR9NIHIBotdxC8AWAvdOTt56stGgSkA+knyguf+Ttv1UO5pQ1aH5 + mUVwpNl8FUmxGhU6mRV/lLHItH8XjNU8tMV77/3cim3/kfR9yCBAEASQQRCO6fJ9qCCA9H0EnofGzIwm + /Hwbjub/o7sF0AtioaZKN3abr1/TSEkItF0XS2H/Pr0Nz07Gb32f6/4snsChkiWctH3nPYXCXfz5ffxq + XfFWPv9lR4jd8dQOnvNnkf+aUtWnGo1Z6CW/lOIkAqB+lSzwtwrGhgBKu3ffvyDE92Qk9NL3kyO6L/B9 + +K4bpvcaDT1yRtVn6L/Jz5GWPeAaPh7cCkZI3B1QCudKpSXoRkvabAZlA6dJ+C2DBKYt69pPhN2E1G27 + 2gbjnrGYy+1eEuIrvNSZB/3ikmfLwqznnURivfI5FVXok4mywN8lMBYE4N5557XzwBNSyi1c4PnhBwH8 + ZhPN2Vn4rpuq9Vcz+ft2hhlRf27+S6b9aZ03381ICzKPOg4V8cTyhM6uTWUDR7TZWypZwiEA7J6augeh + oKVN7u3rTL3TlvUNXtrLq/3ilVDRhOpna7Xj0WfgjWqk/Snnn5n+a8BYEMBssfjDtlLvDwztr4IASkoE + QYCgVoNz9mzoFmB14R+EyU/vlSr40AOAsYBAN/+jKbhz0dtx4Tc3JisAmFDqMKUDNUsgcgNuzefvRjLO + m8Z4cxLoC07l8/scYA9v8kldTy4ETvv+28tK0fcg35/PpMwq/i4DI08A795999c8pT6hmfqR309mf7tU + gnP+/JqFn9B31WJqfySCT8IfGKRA7gkFMM+FI7xM4Te7OAEAm4Jgf9roXSKCAlB8eGLiAwgJgNaaEwnE + vUS9oizE3sD4joHQC3+o9Pe1UPsDSdEPdfxx4c8q/taIkSaAxfe979crQvyBqflBZOD78MtleEtLXYN9 + GyX8qdqfRfjThIMWePAR3ueTCT5pbdyaFfCA5+23lKrwtdymg3/X5OQHkb5Uw0afzp8AmI79FdHZ7EO3 + 60rVj4QpToUkNclH0VPgL0v7rREjSwDunXdee8G2vyV9H4oF/BRlAHwfXrWK1sqKtnHzUsI/iHC4AtK1 + P/RNTYEhELwfHkJgOQgWzvp+HXoJ8GoFPMoG/lbbuhG5ADQe7HrLes8NQkwjIQDa60dr4Hq2AnwhpnmQ + 1UwBUtBzttWaiV5CDUp8CQ3X/lngb40YWQJ41/e/67fbN5PgB3QZBfwC1w0n9KAzx7+a8A8ELIqvpfqM + ACA3k/l+P3rtGcc5hU7hX62EV01K+Vfc7CfBp9mECsBDmzbtRrLXj9wAsgJ6hgvspg9Fm4nibUXMzTlY + r9P3MzsceeAv8/0vAyNJAPO33fYFR8pf536/khJSyvDSdeEtL2tan06yjRb+1JQfDO1PQTCg0/wHgPAx + 70ClwglgLS286u12+y+56W8ZwUChFG4vFD6IUOg3ISGBvu3W4+a/tpGakVxdqcZsEJiryPl6eU5ymfZf + I0aOANybb96+CHxNRgJPKb4gqvkPggBeqZRs2AE6LjdM8wNdtX8sAIb/z3vh4+IgAHOuyPJMoAAAGb9J + REFUS8K/2gSfDgL4PSlLNvBMHAcAI4Ho820RYsf9udytCM1/2u5LbkDPwUC+lITXAfAsx7w+oJRvJM7G + fPeAkSOAOaW+2vb9W2QQhAQQmbIkaO1SKRnhBd307xbwGxSUKfyAJvS0mp2EwTeEn0aMCQDHy+Xj0VuZ + 8/toYUs8NYx/BACyIOXTcRyAFQRRPEAB+NDU1Eegr/cmK6BnAoiLmBjZ8aWnCsC86/Lx5Gnfj+8hzLBG + jBQBVO+4471VIX6PCzF3eNuVShgMxOrCz7FRpn9HmbER8eemP9f+AHDW806dD4N/5vhubh53C47JI+32 + XwqlqnGpH4sFECHcms/fg9ANICuACICCgT39FvTBzIAsPfaC41B6k48448LPp1RnWCNGigBOO863AeZD + I4mw+44Tj+HmdbHxVFkkZ86G+P2rBP7MVF9sEhtBMUTv88bKyhEk2t9c0X6p4Jj891Ku5IBntJpfIoHo + SXZSE8DdAKoJ6CkbEGt/JLGPeH05gGXfN1ObpnvD13xluAyMDAEs3Hjjr3qW9QDX7AQZBPBrtdjPTPP7 + CVfE7+efh5n+nAS8qB6e5/4FgLOt1qnzvt+ALhw8NcbLYrshsILgu7QTQJgWQGQFvHdy8kNIdwN6CgZy + F6BjiKoQWEwIgO8nuCIDSkcNI0MAF4EvA52mvxICfrWqTfC9lN8/yLOoq+nPI+CWFW7+saww8BfVwJP2 + J4uBaX9uGpPpv9bcuAIgP+d5+4VSczRdw1IqvoyGjFJNwDXQSaCnmoDz+fzuePoR0i2xekhwZLyRi5Np + /z5gJAjA1P5cuwaui6DV6myJu1LCfxmmf7z4QySFMWQqCwAnms0j84nvT4ExvgNvrdFxCcDPKfXfKQ4Q + Cz90yX5gcvJu6HGAnmoCPCGuSYu/KPY3L7RaK0i3ALI13z1iJAjgIvBlfgLFs+6ljE1/0zLgRLERMIWf + b7SRTPNrZbAiGYThW1ZsLQgAPuAdK5V45J9v7jW39q4lOBYstds/4M1BWqNQZAXcUizeiQHWBNC8w/gm + gCO+zwkgrbox6/lfJ4aeAJanp+/1bDvW/rHwC4Gg2QwLgcA0P3TTHymX/Uaq5kcS+NK23JimPwsESpEs + w3yzVnutLCX59mnaXzP/FS006P4R5e8EwSmh1N9wC4C7AQLADZZ1xz2WdT10K6CIPrUJk+anceWOlHUk + 5n+8ER16g9NGcvlIYegJ4OLk5L/jSzpjYZYSfrPZOU57g03/NOE303xavl+E/e8e1/4sNw4AK+32wsFy + mZfFUlEMDcQwh2FCpO7T1iAB+AUpn9YmfxjZAADYPTX1fiQpQbNB6LIIwAdEt99eKIWmUiYBkLXDU3+Z + +b9ODD0BOEI8zAN7QHS2NJth2S/0nPKGqwqDcCj+wE1/n2l+Mvc9dp1rfx/wDiwvv4zOwF/aPLzLbYyR + n2u1nhRKVW3S/tHB3YBbi8UPIJ0AcujRAoi1v36dfjre4TjwAaXjgKEmgDM33fRFaVlbO/x5IcKcP1N6 + V0T7R39P+/tM65t+vzkFp8P0B3Cy0Tg6325Txx8NxKBFGL3Mw4u1bB74a14LYLYJbxVixw1CbEV6NmBd + lYHd/geVxP+Pq4TZkWn/HjHUBFAD9tIgjNj3B8KiH2O4RzftvxHCH2cdhOjI83O/n/L9XnSfH8UCYtM/ + CBYOrKwch27682GYNBJrvfPwFADf9f3/SnEA28gE0C7BT05O9s0NSAO9QTuMc3AXIG26UWYBrBNDTQBN + 4LNm3lgJAem6wBq1/yCQJvwduX7D7Ce/X1t+Cd30/9mFC/uRaEI+B7+EZA1WL/PwFIDgt9rtgwI4S5rf + rAcAgFuKxfchFHoaFsLHhfVlUpAAIIQwyzf4qvrM/O8RQ0sAZ6+77h+CLcQkyCBA0Gp1pPo2QvvzCD/Q + KfxayysJvkgm35L2p8IfXvF3sFx+uRJqQ4kk6k/rvvu5AVcB8PNSfs+cFBR3CCqF62z7doQaf5IdlA1Y + txWgDSeJ/hb0GABvF8i0f48YWgJwbPteLcJOqbVWq8P3Tjv6jY48PzqFn0x6nwt9dNki0580v2XFVsys + 6x4/VqtRMww3/cvQtX8TvffEK4Q1AU/aWH0W+J5C4Xbo8wJ5VWA/wX9Ws08oQw8YWgJoCvFL3PcHEAf/ + AN1m5MFAQj9JoCPVh0sIPzf9iQSA+DHT79+/uPga9Kg/F/4VJNq/H/PwqCZgxgLe1AqDWIEQhMB7Jiff + h2RiMK8K7EtREHM5uFFltntkFkAPGFoC8IT4kBnJV1JCttupDT6D0v5pwi/XIPyU54/z/dH9vEy5ImXp + hdX9/hWERLDetF83SABBXqkXyOyPg4BRTEIB2JrL7UQo8D0RAKdnPoeAPca1/UYkcMYGQ0kATcualkJs + jc+CSFtKz9Oe103w+3XWpBb5sFQfBfq6Cj9dp+o/6EG/g8vLpt9P+f6V6CDTv4H+jsNSAALl+0/GKUAR + Lh3hwrrNtm9CsjeAjwy/7KrAtCcKANtzue3G56LLTPj7gKEkgMpNN33MdAAVIgJIMcX7jTjmwH1+kT68 + U4v2M+Hn/j+NvybhFwBeXFx87rTrriAp9aU6f9L8pP0HtQFXzgfBbCzFXSqJ78vnb4S+OOSy6gH4u6Y9 + OS9EIeUp/f+njimGkgAIWsANYQagW/Cvn3/TDPbxxp6Ojj7D14+Dfuy+eN13RFYHa7WXT4cLPnnQj4R/ + OTpK0X2D2oGnPlAofJYCkVzi+HefFGIS+vYgcgHWnAlYw4fWEgPsdkYEPWIo14Pz4B8X8sDIAJiv6YUM + uODH7yeS0Vy8r9+P0nw0xJO0PDf7ufDzdN+hWu3lw2GdP+W7W0jSfcsAlhBq/15z/pf8yjUh/jXoewu9 + p4LuP9ZulxCeR0QCNCaMEgiXrEZcoxTzJUYZ+oSh/jG1PL9SiUCif9o/diNStD4Jv9nNR1rfY7n9juur + Cz9F/EnzlxEKPgk/j/oPZA7eUi63KwA+ot3JCVAIVIJgZUkpHwkBkP9Pwr/uWgDCFsu6FsbWMuhZycwK + 6AFDaQF4SgllCKTyvERLG/7qeqSDa7luWl8haeU1G3sCCu4BHeZ/+9LCb+b6SfNvhOkPADhv249wra8N + W4nuf7fVegfQaoT4GvHLEsxuTy6EMQB6mAt/Zg30AUNJAGSSKqVi9RdPygUT0lVb4NNBJBJfZ+9ppvno + 78YtvXygR1TNxzV/nOcH1ir85PMvIiSADRF+AFgW4lHw78qP6P7Djcbc6u9ymWAbibT7EmE32xKAzALo + CUPJoLvOnn2OR+K1OnsYmsqI1nc9zBMcRk4/uk6+PTf34/bd6JKq+lqWBZcCftHBU30W1qT5LyIkAF7r + P9AR2Bfy+d2eELu5O6VtTRICC75/+lQ4rIPX6PNjTVV64hIkzR41zf++7CUcdwwlAQCAAI7xkd5akXgX + Mljt0CYGgaXz6P0i7a75+cbRioTdEwJuJPxpZj+EQBvwLiH8S0iEn/x+GvE10CGY5yxrHw9qaiPVoutn + XPdM9HQ+qqvvU3oUgHtzuR3oJIAsC9AHDKcLAMCS8oiy7XuUZUEqFQt97LNHQUF+0lLrcAcMPx9A52sZ + GZg5fm2IJ4v4UzDQNPnbgBfl+UtIov3dhH8ZofDzHv+BFsHUhNjLSZHv6VPh528902jQpl4SfBrT3W0T + 8SVhSrOK7pu0rALStX9GAj1iaAlgAniyKcQXzPQbEEmHZYUkED1O96emCM3Ho5MdSHEB2N+idB+v46eg + HzX18GAfAJSlLL2ysLDfGOphCv8iEr/fjPgPtAHmTD6/54QQu9KsIPoec553EqDZpNqijste0tlNervc + nxYDyNADhpUA1EfPnXvux7fddk4JcbNE2D0XRIFBaVnhTjtGAoppYH5WdtP8sfY3BCBtTRdv66VhnvQa + /nfnPO/Ua4uLv2DDPLsF/Ljm3zDhB4CLtr2PiEvb1IvENTpcr89EP5G5h5AvIr08SyWy2OKbdCW8zxT8 + LA7QJwwrAQCAyvv+17xC4ZsKAAoFLRgYm/URKXAzv+ON6NIw9xUz31PXdbEy3oCZ+2km/7Fa7bVDib/P + N9zyIh/S+mm5/g1pfa0Ae83BJXyWQTUIlg75fhl6rULaHsLLdlXMUj/C9YXCtfC8d9A9DmDyeoY1YpgJ + QO45d+6JH9522z+Bbd8nAahCAX67nfirkRUQpwNFurLQMgHQo/+k/fhePsr10+IOChDGZcEiqemvBEHp + 4MrKy+8m/j519fGBHiT8y0iq/LjPvyHCf6pQeOQdIaY7wvrRd1cAjjvOm9HTJZIFHSYBrDlIOaXUu90e + I6mOagHMGEDmCvQBw0wACkDw9vLyv7ztuut+IoTYLAqFcA8gEi0MRMM1IojIIhDR4wKsz5QF/rSAHxIh + oDXdfGtvnG1gvr5AuLnnpeXlo/RZkZT2NtBZ27+EkAz4Rp8NHXq5aFmP0vfWZhYibkdsvdxsUu6ffP8m + QheGb+pds/a/0fdP/3Uu10HO9GJDurkLwC8zrBPDTgD+4/X6zB8Wi//01unp71oTE5uU68apPNLKZv06 + aWj+Rjz4x31eTQiYYEh2GxFR0Nm57PsLR8rl195NGnq4yc/7+Un4yeQn4d/wdVdNy5p+SYi92sxC5gIE + QmCu3T6xHJb+rmcN+ZpBtQHGG5j+f6b9+4BhJgAgUkx/sLx84D9J+cW7rr32WyKXm5LRPoBYmJXqGAoa + hpaiPXucKMjkh+4GmDUG3NRXUc+8I2XjeLN5hC3t4FN8aHNPBXpLbwn6PL91+c+9Yi6XeySOd8BIdyL8 + XV6oVo9FT+duTAPJFuK17CFMRTdJNn6E1VKBWQxgHRhmAogVPQD3q6XSgU84zuf/8datX7U972N8co2W + ykJnOpDn+7WdfdBTfzwzQBAAAsA73mgcfSXZ1UfuM9eS5hivEhKTv2/ac71YtKxHO9wdFgRdDoJz70jZ + jJ5ufi/KAPT189OvfF2hcAM6G4KEcWRYB4aZAIBE2FoAGq+47tlXXPc/fGli4nN3TE7+jgVs53X9vMyX + hDt+LHqcCz5ZCPEAOuY6CCHgStk4Xq8fea1SOYWEkEjwKUBGJj/X/GUkG3x4S+8VEf6VXG7Xa0LsMaso + SfglgBnH4bl//t3SzP/LgbqU9FIIF51uQIYeMSoEQLnoKoD8f3PdH8F1D/6jiYlfvmVi4oFttv1+8tH5 + FGFAr/nX+gD480QyCssHvHnPO3u60Zg51mxehF4LT3lxrh1J+Pn4blreaabMrogZO2/bj5i5f5+5AA2l + qj9oNmcQdvqZgUwy/9fvunTJzqDzzdLqATLt3wOGnQCAhARchCdDPInme677/+C6B28U4oZ7Jybu3lEs + 3rHJtq+fDmfZxYE7hSg7wCL4fBJOOQhKS+32wmKrtfB6vU7juYk7aE0V7a0nv5jWdJPQ8629pPUH2tSz + Vixa1uPc34+LnhB+yTnPO45kuAcPZtJB1X89WzBcmo1GoNVcgAzrxKgQAC9KEcZ93rxSrR86TgmOcwTR + /PodQmy6o1i8QQLWjkJhR862ixIQZL/Ou+4FAOKw4yxALxjkKfI29Fp4EgjS/KT96+jMk18Viy3n8/nd + R4Fd5P/zCkcKgv68Xn8nejq5WxT5Jxdm3cE/AGHLL7cC0i2CblWAGQn0gFEgACCxAszbfHtuA8AWRDvt + l5SqLbnuMoAcXNecYmNGl+P6IPa+JPi8Dr4eHaT9SfBJSMjXv+Jan3DWth8zg388zXnR92feDoN/UVFj + THRm7n8jySwT/D5hVAgA0EmAWwC8WGVzdJibbPgs+7Qac1P4PSRan4Sfa/8mksh4muBfFcIPAFUh9pLw + a9WOCAngYL1+FOHvwdOZ/Hv2pv0Jq8QB6BmrHBnWiVEiACAhATMiTyctCT4ts+RjrPk8e4ojcAuABJi0 + PkXCHejNMA57nLfFXnFz38QMlf4yzc/rHJpSVn/meRcR/i4mmfJYRl8tmkswZCb0fcSoEQCQCD+dRzwy + 30Co7WmENWl/En7aa0cbbulEI2uCCICOlnHQ/byS76oTfAKV/vqG4JP5/0aj8SrC3yOqBNYKf8j87zn3 + b76wi4Tzu82nZISwTowiAQC63841twtd2Ok6xQD4PkzTBaD34Tvq2+ygbMBQ7K1vWtb0i5a116x2pOKf + tlLuC45zGonvz6sZef1Cz+Z/DjjcBj7SrR8gw+AwqgRA4EQAJNYACbkp9JeKAcRVwkjIgGt6yZ5/VWM2 + n9/HBT4OAkaXZ9rtY0tKBQh/C+5Gkfnft7JlC6jwYizQJSvUyjAYjDoBEOgcImH1kZ5T7pZa4lkAPjqQ + k8tQnacXo9y/Vv3HzP/9tRoF/3jdP2l/0/zvCeb6NoWwIUgwEsgwGIwLAXCYAkuZA9OnTCMA8z2GEvP5 + /O6jQuwyo//kDiwGwdsnpHSQBP946s/U/v2AMn/c+AdXCpUgWEEn2Y7M/+NKYhwJoBvG5oSas+3HuPDH + bc7Rfa/X64eRBP/M6kZOAP0LcLJuTRjmvxeOUCNc1bGVYUPWUDGGqEbBP7PvPxACjlKVn3reApLGH9L+ + aWXMfRN+ANpAlRQpN+M55u0M60BGAGOGE8XivgCYTtviIQG82Wy+hDAoqqCnT7n539fKPx78A5KgAvVk + 1IKgZrzkqs+yDAsyAhgzLFrWo2lTf6M8qfvTMPXHg39N6Nq/P5V/DAXgMG/XJneAmrXK4Qh1MxDLSSAj + gnUiI4Axwkout6spxJ60qb+BEDjXbh9dVIoEOy3111vbbxfYQJkvYCHQtRPtNgUBeev1VV1kNSzICGCM + MJvLPWZG/uNxZ0LgJ7XaYYTmPw/+UerPDP71HWY6EOEf85aV8tCp/TMLoA/ICGCMUKKxX0b+XwKYb7cP + vxWm/gB96MegUn86UgKBAFAPgiWkd2OaxVcZ1oGMAMYEM4XCIwEw3dH6G10/2mweQ5gWVtCbfgaX+oug + DPOfgn8CwJLnnYdu+vMKzKuuu3LYkBHAmOCibT/K9xrEAz8BlJV698dJ6o8H/8yuv4FsJd4s5aH4RkQC + VJL5luPMQu/F4L0XmQXQIzICGAOs5HK7asbMfz7teMZxjiJsjAKSrj/T9x/Y0I+CUmXS+PxoSVk54PuL + 0IWfiIiPU8ssgHUiI4AxwFwuty+t7j8A0FSq9L+azZPQU39U+NPfoR9dEHv8EQmQ9r/Qah2BPt2JCMBs + uc6wTmQEMAZYtqxH+UqzePAngDnPO4JE+/vQU391bMCyEsvzDgnDAoBSzvcbjVegCz8NYeFzFTPt3wMy + AhhxnCgW93lC7JKG+R/1RTtP1euHkFT+mcE/vu57YJr2/VJWJqT8K9L+NoAj9fqTF5RqolP4iQCuyAal + UUPWDDTiuMgWfvKhHxLAYhAcXwgLf8y6fz7FmEZ+DRLq4Wr1t/+ZELd8fGLit+akzP+PVuscgJ1IOhL5 + 58oIoE/ICGCEsZLL7TogxB4z5Udtv89Uqy8hOQc86Np/o9eVqSeUKj3hOH8B4AYAt0SfhUx92q0w0JTk + uCEjgBHGbC6XjPyGbgUsB8GxN8PCn0kki1V46o9r/40QMnORahWhR1CM7qcdCwOvSBwnZAQwwljp0vgj + hcDrjcYBdKb++C6DDdX+0AmghnBYazu69JFsWWpgY4lppJERwIjiRLG4bzZl5LcEUJFy5hnPu4BwSQrV + /ZOPzc3/gaX+UkATnB2Eml9Fn8lGKOxUm0CWSWb+9wEZAYwo5m378XjopzHxZ8ZxDiPUrDTxN23g50Zr + WW4BIPrbDehjyWn8+kYS00gjI4ARxJlCYc8xYHfasE9XqZXvNJvHEa5JI+1PPf807tvFlREyIgGyBmhB + CxUDUeQ/M//7hIwARhAXbLuj8o8sgGOO8xN0an8y/YkABtf11x28tdec3Gw+lgl/n5AVAo0YmpY1XRbi + Uc3sR6j9W4DzI8eZQRj8o5FffKkpH/d9pWrseekvX8KSaf4BILMARgwnC4XHeM6fE8FZz/vbeaWo4I5S + f2bd/9UUYb8aPsNII7MARgzLlvUo7/bj+/7+vF7/BfTUH9f+G536y3AVICOAEcLxqO4/beDnQhAcmA/X + b1BajXf9Ud1/C1eP9s+wAcgIYIRAQz94+o8yAE9Xq/sRBv+AUMt3m/iTEcAYISOAEcGZQmFPk9X907Yf + CWAhCF45LKULfeAn9/0HOvEnw9WLjABGBOdzuX08+Bev/ALww2r1eSSpP6q2M1N/WXXdGCIjgBFAKZfb + VbKsR81R3wGAspSHD4ban1J/Gz7xJ8PVi4wARgDvFAqPUaWfWf33WqPxEsKOum7a/0qU/Wa4SpARwJCj + aVnTK1Hqj+f9pRCoKXXy/4ZNP7zwp4GwtZYH/zLtP6bICGDIMVMs7guo6w+Ih31IAK/W6z9GqP2p8Idr + fz7ue6PLfjNcJcgIYMixYNuPk+anrToKQEPKE9/3vHnohT/c988KfzJkBDDMOFUsPuIJsYuklzS/AvBs + tfoDABNICn942S8V/lDkP8OYIiOAIcZiLrc3XqtN67UAnGg2v/VsEKwgTP2Zvn82Vy9DjKwZaIhhA2Uu + +FLKkwcc5zt/4nllhBN1KfJPwl9BVvabgaFzH3OGYYI4WCg8NC/ExE99v/K1IAgA3AzgRgDbEPr/HoAV + ABcAnAdwEUAJyWy9zAUYY2QEMNwQCM38zQC2A7gewE0Itf+m6PEmgGUACwhJYAWhFeAiswDGHpkLMDqg + QRot6PP06wgJgAQ/K/vNECMjgOEHjcmi0d7V6HYOYZCvjtD3J7M/8/0zZMiQIQPw/wGcCGmdjgnpvgAA + AABJRU5ErkJggigAAACAAAAAAAEAAAEAIAAAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAABwAAAA0AAAASAAAAFAAAABAAAAAKAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAUAAAANAAAAGAAAACQAAAAnAAAAIwAAABcAAAAMAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAABMAAAAlAAAAOAAAAEAAAAA7AAAAKwAA + ABcAAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAGBASnQAEBQTcAAABEAAAAUwAAAFEAAABAAAAAJgAAABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYG1UMODrP/EBCq/wwMj6MAAABcAAAAYAAA + AFIAAAA3AAAAHQAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAw0NtfAPD6v/ERGi/wYGX4QAAABoAAAAYAAAAEgAAAAqAAAAEgAAAAUAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCgrDkw4Or/8QEKT/EhKT3wAA + AGgAAABoAAAAVgAAADgAAAAdAAAACgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAEBNQkDAyz/w8PqP8SEp3/CAhkkwAAAGsAAABiAAAARwAAACgAAAASAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKCsCjDQ2u/xAQ + o/8REY3VAAAAagAAAGkAAABVAAAANgAAABsAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQYG1UQMDLP/Dw+n/xERnP8GBleLAAAAbQAAAGEAAABEAAAAJgAA + ABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoK + vNENDa3/EBCg/xERi9YAAABtAAAAaQAAAFMAAAAzAAAAGAAAAAgAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAwAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBwfPYwwMs/8ODqb/EhKa/wICNnsAAABuAAAAXwAA + AEIAAAAjAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAADAAAABwAAAAoAAAALAAAACAAAAAUAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADCwu34Q0Nq/8QEJ//Dw+BxAAAAG8AAABpAAAAUAAAADAAAAAWAAAABwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAgAAAAQAAAAGAAAABoAAAAWAAAADgAA + AAcAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMiDDAyw/w8PpP8SEpj/AQEcdgAA + AG8AAABdAAAAPgAAACEAAAAMAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAFAAAAEAAAAB4AAAAtAAAAMQAAACoAAAAcAAAADQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAQE0yQLC7X/Dg6p/xERnP8NDXWyAAAAcQAAAGgAAABNAAAALQAAABQAAAAGAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAXAAAALQAAAEMAAABKAAAAQAAA + ACwAAAAWAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoKv7IMDK7/EBCh/xIS + kvUAAABxAAAAcAAAAFsAAAA7AAAAHgAAAAsAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAACgoKrIAODp7BAQEkXwAAAF4AAABVAAAAPAAAAB8AAAAMAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABBwfPVAsLs/8ODqf/ERGa/woKZqIAAAB0AAAAaAAAAEoAAAAqAAAAEgAA + AAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAMEBCq/xISn/8QEIfOAAAAbQAA + AGQAAABJAAAAKAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCgq44Q0N + q/8QEJ//EhKN6wAAAHQAAABwAAAAWQAAADgAAAAbAAAACQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQEBghwPD6j/EhKd/xMTk/8CAjCHAAAAbwAAAFMAAAAuAAAAFAAAAAUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMiDDAyx/w8PpP8SEpb/CAhZnQAAAHUAAABmAAAARgAA + ACYAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBga7Sg4Oqf8REZ3/ExOR/woK + XKwAAAB0AAAAWQAAADMAAAAXAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE + 0yQLC7X/DQ2p/xERm/8SEoTZAAAAdgAAAG8AAABVAAAAMwAAABgAAAAHAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIGBrtKDQ2r/xAQnv8TE5H/Dw9txgAAAHgAAABeAAAANwAAABoAAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJvrMMDK7/Dw+g/xMTlP8EBEGOAAAAdgAA + AGIAAABBAAAAIgAAAA0AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgYGuEsMDKz/Dw+h/xMT + kv8TE3jfAAAAewAAAGIAAAA6AAAAHAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAADAAAABAAAAAUAAAAHAAAABwAAAAcAAAAGAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABBwfOVAsLs/8ODqb/EhKY/xAQeMkAAAB4AAAAbQAAAFAAAAAuAAAAFQAAAAYAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADBQW3TAwMrv8PD6H/EhKT/xISeOAAAAB+AAAAZQAAADwAAAAdAAAACQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAGAAAACgAAAA4AAAASAAAAFQAAABgAAAAZAAAAGAAA + ABYAAAATAAAADwAAAAoAAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCgq48AwMq/8QEJ3/ExOM9gEB + GYAAAAB1AAAAXgAAADwAAAAeAAAACwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGBrNNCwuu/w4O + ov8SEpP/ExOE9wAAAIAAAABmAAAAPQAAAB4AAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAHAAAADQAA + ABQAAAAdAAAAJAAAACwAAAAwAAAAMwAAADUAAAA0AAAAMQAAACwAAAAmAAAAHgAAABYAAAAPAAAACAAA + AAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEICMWTCwuw/w8Pov8SEpX/DAxlsQAAAHoAAABqAAAASgAAACoAAAASAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAABAUFs00LC6//Dg6i/xERk/8UFIn/AAAAgAAAAGcAAAA9AAAAHgAA + AAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAEAAAACgAAABQAAAAfAAAALQAAADoAAABFAAAATwAAAFUAAABZAAAAWwAA + AFoAAABXAAAATwAAAEYAAAA8AAAAMAAAACQAAAAZAAAAEAAAAAgAAAAEAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUF1TQKCrX/DQ2o/xER + mf8TE4ftAAAAfAAAAHQAAABZAAAANwAAABoAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAEBwe8iQoK + r/8NDaP/ERGU/xMTif8AAACAAAAAZgAAAD0AAAAdAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAoAAAAXAAAAKAAA + ADsAAABOAAAAXgAAAGsAAABzAAAAeAAAAHwAAAB9AAAAfAAAAHoAAAB0AAAAbAAAAGEAAABTAAAARAAA + ADQAAAAkAAAAFwAAAA4AAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwkJvNEMDKz/Dw+f/xMTkf8JCVOjAAAAegAAAGcAAABFAAAAJAAA + AA8AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUHB7uJCgqv/w0No/8REZT/ExOK/wAAAH8AAABkAAAAOwAA + AB0AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMAAAAJAAAAFwAAACsAAABDAAAAWwcHTJMPD16+EhJh0hQUZeMVFWLkFRVf5BYW + XuQSEkrJCQkyrQAAAI8AAACJAAAAgQAAAHUAAABnAAAAVgAAAEMAAAAwAAAAIAAAABIAAAAJAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBwfKdAsL + sv8ODqX/EhKW/xEReNQAAAB+AAAAcgAAAFQAAAAxAAAAFwAAAAcAAAABAAAAAAAAAAAAAAAAAAAABQcH + vIkKCrD/DQ2j/xAQlP8TE4r/AAAAfQAAAGIAAAA5AAAAGwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAAABIAAAAmAQEtTQ0N + dq8SEoX3ExOC/xMTff8UFHr/FRV4/xYWdf8WFnL/Fxdw/xgYbf8ZGWr/GRll+RUVTdoEBB6kAAAAjwAA + AIUAAAB2AAAAZQAAAFEAAAA7AAAAKAAAABcAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAroVCgq3/wwMqf8QEJv/ExOO/wICLI4AAAB6AAAAYgAA + AD4AAAAgAAAADAAAAAIAAAAAAAAAAAAAAAAAAAAFBwe8iQoKsP8NDaT/EBCV/xMTi/8AAAB7AAAAXwAA + ADcAAAAaAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAALAAAAHRQUgm4TE5b1EBCQ/xERif8REYT/EhKB/xMTgf8TE4D/ExN+/xQU + e/8UFHb/FRVz/xcXbv8YGGv/GRlp/xoaZ/8VFUrbBAQdpQAAAI8AAACCAAAAcQAAAFsAAABEAAAALgAA + ABwAAAAOAAAABgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAIJCb+zCwuv/w4OoP8SEpP/Dw9txQAAAH8AAABuAAAATQAAACwAAAATAAAABQAAAAAAAAAAAAAAAAAA + AAUHB7yJCgqw/w0NpP8QEJX/EhJ/5wAAAHoAAABdAAAANgAAABkAAAAHAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABEXF4pVIiKo/w4O + mf8ODpP/Dw+Q/xAQjP8PD4z/EBCM/xAQi/8QEIr/ERGH/xIShP8TE3//FBR6/xUVdP8WFm7/GBhp/xoa + Zv8bG2b/ExM/zgAAAJYAAACKAAAAeQAAAGQAAABMAAAANAAAAB8AAAAQAAAABwAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQcH0GMKCrP/DQ2l/xERlv8TE4f2AAAAgQAA + AHgAAABcAAAAOAAAABsAAAAJAAAAAQAAAAAAAAAAAAAABQcHvIkKCrD/DQ2k/xAQlf8REXvfAAAAeAAA + AFsAAAA0AAAAGAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAGDQ1sJiIisecaGqf/Cwuc/wwMmv8MDJn/DAyY/wwMl/8MDJf/DAyW/w0N + lv8NDZP/Dg6R/w8Pjf8REYj/ExOC/xQUe/8VFXT/Fxds/xkZZ/8aGmX/GRlW7QcHJa0AAACQAAAAgAAA + AGoAAABRAAAANwAAACEAAAARAAAABwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABAkJuPAMDKv/EBCc/xMTjv8LC1evAAAAfgAAAGgAAABFAAAAJAAAAA4AAAADAAAAAAAA + AAAAAAAFBwe8iQoKsP8NDaX/ERGV/xERfN8AAAB2AAAAWQAAADMAAAAXAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgbG7eEISG0/xUV + q/8JCaT/CQmj/wkJov8KCqD/Cgqf/woKnv8KCp7/Cgqd/woKnP8LC5r/DAyX/w0Nk/8PD4//ERGJ/xMT + gf8UFHj/FhZw/xgYaf8aGmX/Gxtg+Q0NL7wAAACUAAAAgwAAAG4AAABUAAAAOQAAACIAAAAQAAAABwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCAjCowsLsP8ODqD/EhKS/xMT + feYAAACCAAAAcwAAAFIAAAAuAAAAFAAAAAUAAAAAAAAAAAAAAAUHB7yJCgqw/w0NpP8REZb/ERF83wAA + AHUAAABWAAAAMQAAABUAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACB8fvMsfH7j/ExOx/wgIqv8ICKr/Bweo/wgIpf8ICKT/Bwej/wgI + o/8ICKL/CAih/wkJoP8JCZ7/Cgqc/wwMmP8NDZP/Dw+O/xERhf8TE37/FRV0/xgYbP8ZGWX/Gxtj/xMT + Pc8AAACWAAAAhgAAAHAAAABVAAAAOQAAACEAAAAPAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEGBs9UCgqz/w0Npf8REZb/FBSK/wICK5EAAAB5AAAAXAAAADYAAAAZAAAABwAA + AAAAAAAAAAAABQcHu4kKCrD/DQ2k/xERlv8REXzeAAAAcwAAAFMAAAAvAAAAFAAAAAUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJHh6//x4e + u/8TE7X/Bgaw/wYGrv8HB6v/Bweo/wcHpv8GBqb/Bwem/wcHpv8HB6X/Bwek/wgIo/8ICKH/CQmf/woK + nP8MDJf/Dg6R/xAQiv8TE4D/FBR2/xcXbf8ZGWb/Gxtj/xUVSNsAAACXAAAAhwAAAG8AAABTAAAANgAA + AB4AAAANAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQJCbbhDAyo/xAQ + mP8TE4z/EBBoyAAAAHwAAABiAAAAOwAAAB0AAAAJAAAAAAAAAAAAAAAFBwe7iQoKsP8NDaT/ERGW/w0N + ab0AAABwAAAAUQAAACwAAAATAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgeHsL/HR29/xISuP8GBrT/Bgax/wYGrf8GBqr/Bgao/wYG + p/8GBqf/Bgan/wYGp/8GBqb/Bwem/wcHpf8HB6P/CAih/woKnv8LC5r/DQ2U/xAQjf8SEoP/FBR4/xcX + bf8YGGb/Gxtj/xUVR9sAAACWAAAAhQAAAG0AAABPAAAAMgAAABsAAAALAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwgIvZYMDKn/Dw+a/xISjv8TE37vAAAAfAAAAGIAAAA7AAAAHQAA + AAkAAAAAAAAAAAAAAAUHB7uJCwuv/w0NpP8QEJb/DQ1qvAAAAG4AAABOAAAAKgAAABIAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxwc + xP8cHMD/FRW8/wUFtv8FBbP/Bgau/wYGqv8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgam/wcH + pv8HB6T/CAii/wkJn/8KCpz/DAyW/w8Pjv8SEoT/FBR4/xYWbv8YGGb/Gxtj/xUVR9sAAACVAAAAggAA + AGgAAABKAAAALQAAABYAAAAIAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBASoQAsL + qf8ODpv/EhKP/xQUiP8EBD6SAAAAXgAAADcAAAAaAAAACAAAAAAAAAAAAAAABQcHu4kLC6//DQ2k/xER + lv8NDWq8AAAAbQAAAEwAAAApAAAAEQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFHBzF/xwcwv8aGr//BQW3/wUFtP8FBa//Bgar/wYG + qP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6X/Bwej/wgIof8KCpz/DAyW/w8P + j/8SEoT/FBR5/xYWbv8ZGWb/Ghpj/xAQM8IAAACSAAAAfgAAAGIAAABDAAAAJwAAABIAAAAGAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAZCwuo/w4Om/8SEo//ExOJ/wEBHH4AAABVAAAAMAAA + ABUAAAAFAAAAAAAAAAAAAAAFBwe7iQsLr/8ODqT/ERGV/wwMZLMAAABtAAAATAAAACkAAAAQAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAMcHMnWHBzE/xwcwf8HB7v/BQW2/wUFsf8GBqz/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGpv8HB6X/Bwej/wgIof8KCp3/DAyX/w4Oj/8SEoT/FBR4/xcXbf8ZGWb/Gxtk/woK + KbUAAACPAAAAeAAAAFoAAAA7AAAAIAAAAA0AAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADAYG + oWYLC6b/Dg6Z/xERj/8TE4LvAAAAbQAAAEoAAAAoAAAAEAAAAAMAAAAAAAAAAAAAAAUHB7uJCwuu/w4O + o/8REZX/BgZKmgAAAG0AAABNAAAAKgAAABEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARsbzqkcHMT/HBzC/w4OvP8FBbf/BQWz/wYG + rf8GBqr/Bgao/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpv8HB6b/Bwek/wgI + of8KCp3/DAyX/w8Pj/8SEoP/FBR4/xcXbv8ZGWb/Gxtg+QQEHKYAAACKAAAAcQAAAFEAAAAxAAAAGAAA + AAgAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAASCQmnrwsLo/8ODpf/ERGP/w8Pcs4AAABkAAAAPwAA + ACAAAAALAAAAAQAAAAAAAAAAAAAABQcHu4kLC67/Dg6j/xERlP8GBkicAAAAcAAAAFAAAAAsAAAAEwAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABGBjWWRwcx/8cHMP/GhrA/wUFuf8FBbT/BQWw/wYGq/8GBqn/Bgao/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6b/Bwek/wgIof8KCp3/DAyW/w8Pjv8SEoP/FBR2/xgY + bP8aGmX/GRlW7QAAAJYAAACDAAAAZgAAAEQAAAAmAAAAEAAAAAUAAAABAAAAAAAAAAAAAAABAAAACAAA + ABoKCqfyDQ2e/w8Plf8REY3/CAhVoAAAAFgAAAA0AAAAGAAAAAcAAAABAAAAAAAAAAAAAAAFBwe7iQsL + rv8ODqH/EhKT/wYGSJ0AAABzAAAAVQAAADAAAAAVAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGxvJ8Rwcxf8cHMP/Cwu9/wUF + t/8FBbL/Bgat/wYGqv8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8HB6b/Bwek/wgIof8KCpz/DQ2V/xAQjP8TE4D/FRV0/xgYaf8bG2T/ExM/zgAAAJEAAAB4AAAAWQAA + ADcAAAAbAAAACgAAAAIAAAAAAAAAAAAAAAMAAAAOBwejdgsLpv8NDZz/EBCS/xISjf8AAABtAAAASwAA + ACkAAAARAAAABAAAAAAAAAAAAAAAAAAAAAUHB7uJCwuu/w4Oof8SEpL/DQ1lvwAAAHcAAABaAAAANAAA + ABgAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEaGtKoHBzI/xwcxP8VFcD/BQW6/wUFtP8FBbD/Bgas/wYGqf8GBqj/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/Bwej/wkJoP8LC5v/DQ2T/xAQ + iv8TE37/FhZw/xkZZ/8bG2X/BAQdpgAAAIcAAABrAAAASQAAACkAAAAS/////wAAAAEAAAAAAAAABQAA + ABUJCae9DAyi/w0NmP8QEJD/Dw951gAAAGIAAAA+AAAAHwAAAAsAAAABAAAAAAAAAAAAAAAAAAAABQcH + u4kLC67/Dg6h/xISkf8ODmPBAAAAfAAAAGEAAAA6AAAAHAAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQU3iYcHMr/GxvF/xwc + xP8MDL3/BQW3/wUFsv8GBq7/Bgaq/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGpv8HB6X/CAij/wkJn/8LC5r/Dg6R/xERhf8UFHn/Fxdt/xoaZv8YGFLnAAAAkgAA + AHsAAABaAAAAOAAAABsAAAAKAAAAAQAAAAEAAAAKAwOAOAsLqf8MDJ//Dg6V/xERj/8ICFagAAAAVQAA + ADIAAAAXAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAEBwe8iQsLrv8ODqH/EhKR/xERa9EAAACCAAAAaAAA + AEIAAAAiAAAADAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAARoa0qgbG8n/GxvE/xkZwf8GBrn/BQW2/wUFsf8GBqz/Bgaq/wYG + qP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpv8HB6X/CAii/woK + nv8MDJf/Dw+O/xMTgf8VFXT/GBhp/xoaZv8KCiyzAAAAhwAAAGsAAABIAAAAJwAAABAAAAAEAAAAAwAA + AA8ICKaECwum/w0Nm/8PD5P/ERGK9wAAAGsAAABIAAAAJwAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAQHB7yJCwuw/w4Oov8SEpL/ExN46QAAAIcAAABxAAAATAAAACoAAAARAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBTeJhwc + y/8bG8f/HBzE/xMTwP8FBbj/BQWz/wUFsP8GBqz/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6T/CAih/woKnP8NDZT/EBCK/xMTfP8XF2//GRln/xcX + VOcAAACRAAAAeAAAAFcAAAAzAAAAGAAAAAgAAAAHAAAAFQoKq+UMDKL/DQ2Z/xAQkv8PD3bNAAAAXgAA + ADsAAAAdAAAACgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAwcHv4gKCrL/DQ2l/xERlP8UFIb/AAAAjAAA + AHoAAABXAAAAMwAAABcAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHh7Vix8fyv8dHcX/HBzD/w4Ovf8FBbf/BQWy/wUF + r/8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcH + pv8HB6P/CQmf/wsLmf8ODpD/EhKD/xQUdv8XF2v/Ghpn/woKLrEAAACDAAAAZQAAAEAAAAAhAAAADQAA + AAsFBZZFCwuq/wwMoP8ODpb/EBCQ/wQEQ4wAAABRAAAALgAAABUAAAAGAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACBwfEhgoKtf8MDKj/EBCX/xMTiP8JCUayAAAAggAAAGQAAAA/AAAAIQAAAAwAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADJCTP1iQkyv8hIcf/Hx/D/w4OvP8FBbb/BQWx/wYGrv8GBqv/Bgap/wYGqP8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgam/wcHpf8ICKH/Cgqd/w0Nlf8QEIv/ExN9/xcX + b/8ZGWn/FhZR4QAAAIwAAABwAAAATAAAACkAAAATAAAAEAkJqZ4LC6f/DQ2d/w8Plf8REYjuAAAAZwAA + AEQAAAAkAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEHB8qECQm4/wsLrf8PD5v/ExOM/xAQ + Yc0AAACIAAAAcAAAAE0AAAAsAAAAFAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEnJ+I6LCzO/ygoyv8oKMX/JibE/xAQ + vP8FBbb/BQWy/wYGrv8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bwem/wcHpP8JCaD/Cwua/w4OkP8SEoP/FRV2/xgYbf8ZGWv/AQETmAAAAHgAAABVAAAAMAAA + ABkAAAAVCgqq5AsLpP8NDZv/Dw+T/wsLZ7EAAABbAAAANwAAABsAAAAIAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQUF00QICLv/Cgqx/w0Nov8SEpL/ExOB9wAAAIsAAAB7AAAAXAAAADoAAAAdAAAACgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAExMd5wMDDO/y4uyv8tLcj/KyvF/xMTvf8FBbb/BQWy/wYGrv8GBqv/Bgap/wYG + qP8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bwel/wgIof8KCpz/DQ2U/xAQ + iv8UFHv/FhZw/xgYbP8ODj69AAAAfwAAAF0AAAA2AAAAHgMDfzcLC6n/DAyi/w4Omf8REZL/AgIzgQAA + AFAAAAAtAAAAFAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPbIwcHv/8JCbb/DAyp/xAQ + mf8TE4v/CQlLrAAAAIIAAABrAAAASgAAACoAAAASAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzM9evNDTP/zMz + zP8yMsr/MDDI/xcXv/8FBbb/BQWy/wYGrv8GBqv/Bgaq/wYGqP8GBqj/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8HB6b/Bwej/wkJn/8MDJj/Dw+P/xMTgf8VFXX/Fxdu/xMTU9kAAACDAAAAYwAA + ADoAAAAiBweeZAsLpv8MDKD/Dw+Y/w8PfNUAAABrAAAASQAAACcAAAAQAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABBgbLoggIuv8KCq//Dg6g/xISkv8TE3neAAAAggAAAHYAAABaAAAAOQAA + AB0AAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI5OdbMOjrQ/zg4zv83N8v/NTXJ/yIiwf8FBbb/BQWy/wUF + r/8GBqz/Bgaq/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/CAih/wsL + m/8ODpL/EhKF/xQUef8XF3H/Hh5t8wAAAIUAAABmAAAAPQAAACQKCqGQDAyk/w0Nnf8QEJX/CgpdqgAA + AGkAAABGAAAAJQAAAA4AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAs8TBwfB4AkJ + tv8MDKn/EBCb/xMTj/8GBkicAAAAewAAAGgAAABKAAAAKgAAABMAAAAGAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMz + 2Bg+PtXbPz/R/z4+z/89Pc3/OzvL/y8vxP8ODrj/BQWz/wUFsP8GBq3/Bgar/wYGqf8GBqj/Bgao/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8ICKL/Cgqc/w0Nlf8REYj/FBR8/xcXdP8qKn//AAAAiAAA + AGkAAABAAAAAJwsLn6wMDKD/Dg6Z/xAQjfYBARuCAAAAbAAAAEoAAAAoAAAAEAAAAAMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEBNszCAi8/wsLsf8ODqP/ERGW/xISf9sAAAB6AAAAcwAA + AFoAAAA7AAAAHwAAAAwAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMz2BhCQtbbRETS/0NDz/9BQc3/Pz/K/zs7 + yP8gIL//BQW0/wUFsv8FBa//Bgas/wYGqv8GBqn/Bgao/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgam/wcH + o/8KCp7/DAyX/xAQi/8VFYD/JiZ//ywsgP8AAACLAAAAbgAAAEgAAAAuDAycyQ0NnP8PD5X/ERGK9gAA + AH0AAABxAAAAUQAAAC4AAAAUAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEGBtRjCQm4/wwMrP8PD6D/ExOT/wcHTZUAAAB3AAAAaQAAAE0AAAAuAAAAFgAAAAcAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADAAAABQAAAAcAAAAGAAAABAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAATMz2BhDQ9m0SkrT/0hI0f9HR87/RETN/0NDzP87O8j/Gxu9/wUFs/8FBbH/Bgau/wYG + rP8GBqv/Bgaq/wYGqf8GBqj/Bgao/wYGqP8GBqj/Bwel/wkJn/8MDJj/ExOP/ywsjv8xMYb/MDCD/wAA + AI4AAAB1AAAAUwAAADsNDZLMDg6W/xAQkP8TE4j/BQU3mQAAAHgAAABbAAAANgAAABkAAAAIAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMeiCgq0/w0NqP8REZr/EhKE2AAA + AHUAAABzAAAAXwAAAEAAAAAjAAAADwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAoAAAAQAAAAFAAA + ABQAAAAQAAAACgAAAAUAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJFRdqnUFDU/05O + 0v9LS9D/S0vP/0lJzf9HR8v/PT3H/yAgvf8NDbT/BQWx/wUFr/8GBq3/Bgas/wYGq/8GBqr/Bgaq/wYG + qv8HB6f/ERGm/yUlp/81NaL/NjaW/zY2jP82Noj/AAAAkQAAAH0AAABiAAAATwwMfrAPD5D/ERGK/xMT + gv8ODlK8AAAAgAAAAGYAAABAAAAAIQAAAAwAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMJCb3RCwuv/w8Pof8TE5X/CgpgpQAAAHgAAABuAAAAVAAAADQAAAAZAAAACQAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAAIAAAAEgAAAB8AAAApAAAAKwAAACYAAAAcAAAAEgAAAAkAAAAFAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFEROFmUlLV9VNT1P9RUdL/UFDQ/05Ozv9MTM3/S0vM/0pK + yv87O8T/Kiq9/xwcuf8UFLX/ExOz/xQUsv8bG7T/JCS2/zU1uf85Obj/Ojqz/zs7qv88PKD/PT2T/zY2 + i/8JCTCuAAAAhQAAAHQAAABoDAxosg8Pi/8SEoX/FBR9/xMTYdwAAACHAAAAcQAAAEwAAAAqAAAAEgAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUF2DMLC7LwDg6l/xER + mP8TE4j1AQEZgQAAAHkAAABmAAAARgAAACcAAAARAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAwAAAAbAAAALgAA + AD4AAABFAAAAQQAAADUAAAAnAAAAGgAAABAAAAAIAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAFCQuMtVlbax1hY1v9WVtT/VVXS/1NT0P9RUc//UFDO/05Ozf9MTMv/TEzK/0pKyf9ISMf/RkbH/0RE + xP9CQsT/QUHC/0FBv/9AQLr/QUGy/0FBqf8+Ppz/GhqC/xISZeQAAACMAAAAgwAAAH4ICDufEBCF/xIS + gv8VFXj/Fxdy/wAAAI8AAAB7AAAAWgAAADgAAAAdAAAACgAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAwoKu4UNDab/EBCY/xMTjP8REWfEAAAAgQAAAHUAAABZAAAANgAA + ABoAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAADQQElkcAAAA0AAAASQAAAFUAAABXAAAATgAAAEEAAAAzAAAAJQAA + ABkAAAAQAAAACAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSkriaFlZ1+pcXNb/WlrU/1dX + 0v9WVtH/VVXQ/1RUz/9SUs7/UFDN/05OzP9MTMv/TEzK/0pKyf9ISMf/R0fD/0ZGv/9GRrr/Rkay/yAg + mP8REYX/Dw9d1gsLQboPD4L/Dg59+AgIMK4PD4T/EhJ//xUVdf8XF2//DAw2twAAAIYAAABrAAAASwAA + AC4AAAAYAAAACwAAAAUAAAADAAAAAgAAAAQAAAAGAAAACAAAAAoAAAALAAAADQAAAA4AAAAPAQFsIw0N + o/EQEJj/ExOL/xUVgf8FBTWdAAAAgQAAAGgAAABEAAAAJAAAAA4AAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAILC8KjDg60/w8P + q+UFBXRyAAAAUwAAAFwAAABcAAAAVgAAAEwAAAA/AAAAMQAAACQAAAAZAAAAEAAAAAoAAAAFAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAA01N3ntcXNjrYGDW/15e1f9cXNT/WlrR/1hY0f9WVs//VlbP/1RU + zv9SUsz/UFDL/09Pyv9NTcj/TU3E/0xMwP8jI6z/DAyb/w4OkP8EBCGaDg6I/w4OiP8ODof/DQ2B+Q8P + fvkSEoD/FBR2/xcXbv8UFEvaAAAAkQAAAH0AAABiAAAARgAAAC4AAAAcAAAAEgAAAA0AAAANAAAAEQAA + ABUAAAAaAAAAHgAAACEAAAAjAAAAJAAAACYAAAApDAyVsw8Plf8TE4r/FRWB/xQUa+IAAACIAAAAcQAA + AE0AAAAqAAAAEgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQsLw8EMDLj/DQ2y/w8Pq/8ODpzEAgJFZAAAAFgAAABbAAAAWgAA + AFQAAABKAAAAPgAAADIAAAAmAAAAGwAAABMAAAAMAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA + AANMTN9pVlbYu2Bg1fZiYtT/YGDT/15e0f9cXM//W1vO/1lZzP9XV8z/VlbL/1RUyv9OTsX/FBSx/wkJ + qf8KCqP/CwuD1A0Nmf8MDJX/DQ2U/wwMkv8NDZD/Dg6M/xERhv8TE3n/FhZu/xkZY/kCAhCgAAAAjQAA + AHoAAABkAAAATAAAADcAAAAoAAAAIQAAACMAAAAoAAAAMAAAADcAAAA8AAAAQAAAAEQAAABGAAAARwAA + AEoJCXCSDw+S/xISi/8UFIL/FhZ+/wcHQKYAAABzAAAATwAAACwAAAATAAAABAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQXhMgsL + v+AMDLj/DQ2y/w4OrP8QEKb/Dg6XuAICRWQAAABXAAAAWgAAAFkAAABTAAAASwAAAEAAAAA1AAAAKgAA + AB8AAAAWAAAADwAAAAkAAAAFAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABUhI1VpQUNKfVlbPvVlZ + zNdYWMjYV1fI2FVVx9hRUcXMR0e/pBMTsdcGBq3/Bweq/wYGeo0KCqD2Cwuj/wsLoP8LC5z/Cgqa/wwM + mP8NDYX0EBCL/xMTgP8UFHP/GBhp/xMTOs8AAACaAAAAjwAAAH4AAABrAAAAVwAAAEcAAABAAAAAQgAA + AEoAAABVAAAAXgAAAGQAAABoAAAAawAAAG0AAABvAAAAcAYGSZcODpD/ERGM/xMThv8VFYL/ExNw2AAA + AGkAAABHAAAAJgAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgYG1kQLC77CDAy0/w0Nr/8PD6r/EBCl/wwM + kaACAkVjAAAAVQAAAFkAAABZAAAAVQAAAE8AAABFAAAAOgAAADAAAAAkAAAAGwAAABQAAAANAAAACAAA + AAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMAAAAHAAAADAAAABIAAAAXAAAAHQAAACIAAAAkAAAAJQAAACQAAAAhAAAAHgQE + lFkGBqS9Bwen8wgIq/8ICKr/CQmo/wkJpf8KCqL/Cgqf/wsLg+4ODoP0ERGH/xMTev8VFW3/GBhn/xkZ + XPMPDzXBAAAAkgAAAIUAAAB2AAAAaQAAAGQAAABoAAAAbwAAAHgAAAB/BQU0mwcHPaUHBz2mBgY9qAYG + PqgGBj+oCQlavQ4Okv8QEJD/EhKM/xMTiP8SEn7bAAAAVwAAADgAAAAdAAAADAAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIGBtVECwu9wgwMs/8ODq//Dw+q/xAQpf8ODpi3AgJGYgAAAFUAAABaAAAAXAAA + AFoAAABVAAAATAAAAEIAAAA3AAAALAAAACEAAAAZAAAAEgAAAAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAYAAAAKAAAAEAAAABcAAAAfAAAAJwAA + AC8AAAA1AAAAOgAAADwAAAA9AAAAOwAAADcAAAAxAAAAMB0dsP8GBqn/CAis/wcHrf8ICKz/Bwep/wgI + pv8REaX/GRmk/wwMl/8PD4//EhKC/xQUd/8WFm3/GBho/xkZZ/8VFUnbAAAAmAAAAI8AAACHDQ1IsRMT + XtEUFHHwFRV8/xUVfP8UFH3/ExOC/xERiP8QEI3/DQ2S/wwMk/8MDJX/DQ2U/w4Olf8REZH/EhKR/xAQ + hcAAAAA+AAAAJgAAABIAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACBgbVRAsL + vcIMDLT/DQ2v/w4Oqv8QEKb/Dw+dzwgIdoMAAABWAAAAXQAAAGEAAABgAAAAXAAAAFUAAABLAAAAPwAA + ADQAAAApAAAAHwAAABcAAAAQAAAACgAAAAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAACAAAABQAA + AAgAAAAOAAAAFAAAAB0AAAAmAAAAMQAAAD0AAABIAAAAUwAAAFsAAABiAAAAZAAAAGUAAABjAAAAXgAA + AFcAAABRS0u7/xgYrf8HB6z/Bwev/wcHrv8GBqv/JCSy/zU1tP8JCaL/Cgqd/w0Nlf8PD4z/EhKB/xMT + ef8VFXH/FhZt/xcXa/8SEj3QEBA6yBUVbfkUFHb/ExN6/xMTfv8TE4D/ExOD/xIShf8REYr/Dw+Q/w4O + lv8MDJn/Cwub/wsLmv8MDJr/DQ2a/w8Pmf8REZj0AQE2RQAAACUAAAAVAAAACQAAAAMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgYG1UQKCsGkDAy0/w0NsP8ODqv/EBCm/w8P + n+cLC4mmAgI+bQAAAGIAAABmAAAAZwAAAGQAAABdAAAAVAAAAEkAAAA9AAAAMQAAACcAAAAeAAAAFgAA + ABAAAAAKAAAABwAAAAUAAAAGAAAACAAAAA0AAAATAAAAGgAAACMAAAAuAAAAOgAAAEcAAABUAAAAYAAA + AGsAAABzAAAAeAAAAHoAAAB8AAAAfAAAAHwAAAB6AAAAdgAAAHNJSabdWlrA/0xMwf8xMbz/MDC8/0ZG + wP87O7v/DAyp/wgIpP8JCaH/Cgqb/w0Nlf8PD47/ERGF/xMTfv8TE3f/FBR0/xMTdP8TE3f/ExN5/xIS + ff8REYP/EBCH/w8Piv8PD4//Dg6S/w0Nlv8NDZr/DAyf/woKoP8KCqH/Cgqg/wsLof8NDaL/Dg6h5gUF + fFQAAAAeAAAAEgAAAAkAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIEBNQkCgrDowwMtf8NDbD/Dg6s/w8Ppv8QEKH/Dw+U0wkJcpkBAR9uAAAAawAA + AG0AAABrAAAAZgAAAF4AAABTAAAASAAAADwAAAAwAAAAJgAAAB0AAAAXAAAAFAAAABUAAAAbAAAAIgAA + ACwAAAA3AAAAQwAAAFAAAABeAAAAaQgIVp8MDHHFEBCD5xERkP8REZD/ERGQ/xERkP8PD4nvDAx2zwcH + WbECAiuSAAAAgwwMIo5UVK7pY2PH/2Bgyv9TU8X/ICC1/wcHq/8HB6j/Bwem/wgIo/8JCaD/Cgqc/wwM + l/8ODpL/Dw+L/xAQhv8REYT/ERGC/xERg/8REYX/Dw+I/w8Pi/8ODo7/DAyS/wwMlv8LC5n/Cwue/woK + of8KCqT/CQmm/woKp/8KCqj/Cwun5QkJo5QAAAAdAAAAFAAAAAwAAAAGAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBATUJAoK + w6MMDLX/DAyx/w4Oq/8PD6b/EBCh/xISmfQPD4XCCAhglwAAAG8AAABzAAAAcwAAAG8AAABoAAAAXgAA + AFMAAABGAAAAOwAAADIAAAAuAAAAMAAAADcAAABBAAAATQAAAFoAAABmBARBiw0NccQREYbvERGP/xAQ + kP8QEJL/EBCT/w8PlP8PD5X/Dw+V/w8Pl/8ODpj/DQ2Z/wsLmv8JCZLvBwd1yQICOZ0MDCGTExNTrQYG + r/8GBq3/Bgar/wYGqf8HB6j/Bwem/wgIo/8ICKH/Cgqd/wsLmv8MDJf/DQ2T/w4Okf8ODpD/Dg6P/w4O + jv8ODo3/DAyO/wwMkP8LC5P/CwuY/wsLnP8KCqH/CQml/woKqP8KCqnyCQmorgcHoWUAAAAXAAAAEQAA + AAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQE1CQJCcSjCwu2/wwMsf8NDav/Dg6m/xAQ + of8REZz/EhKS9Q4Oeb0EBEKMAAAAdwAAAHkAAAB3AAAAcQAAAGkAAABfAAAAVwAAAFIAAABVAAAAXAAA + AGYBARx3CwtlshAQgucREY7/EBCQ/w8Pkv8PD5T/Dg6W/w4Omf8NDZz/DQ2e/w0NoP8NDaH/DAyj/wwM + o/8LC6P/Cgqj/wkJpP8ICKX/Bwep/wcHo+8GBqXwBgax/wYGr/8GBqz/Bgaq/wYGqf8HB6f/Bwel/wcH + o/8ICKL/CQmg/woKnv8KCpz/Cwub/wsLmv8LC5b/DAyT/wsLjf8LC4z/CwuL/wsLjv8LC5P/CwuV6AoK + mMAJCZqFBQWOSAAAABcAAAATAAAADwAAAAsAAAAIAAAABQAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEEBNojCQnFkwoKt/ALC7L/DQ2t/w4Op/8PD6D/ERGb/xISlv8SEorsDw9xwgQE + PZMAAAB+AAAAfQAAAHoAAAB2AAAAdQEBGn0KCl2qDw951hERj/8QEJD/Dw+S/w4OlP8ODpf/DQ2Z/w0N + nf8MDKH/Cwuk/wsLqP8LC6fYCgqt/woKrv8JCa//Cgqv/wkJrv8ICK7/Bwev/wcHsP8GBrH/Bgaz/wUF + s/8GBrT/Bgaw/wYGrv8GBqv/Bgap/wYGqP8GBqb/Bwem/wcHpf8HB6T/CAii/wgIof8JCaD/Cgqe/woK + mv8LC5L/CwuJ/woKXNsKClDKBwc7oQEBHXEAAABMAAAANAAAACQAAAAbAAAAFwAAABYAAAAVAAAAFAAA + ABIAAAAPAAAACwAAAAcAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLEFAgI + yYQKCrjwCwuz/wwMrv8NDaj/Dw+i/xAQm/8SEpb/EhKR/xIShOUMDGG2AgIsjwgIT6kPD3fYERGO/xER + kP8QEJL/Dw+V/w4Ol/8NDZr/DAyd/wwMoP8LC6T/Cwuo/wsLqNgICKWFAwOBOQAAABUAAAAQBQW/SggI + wJYHB7zSCAi6/wcHuf8GBrn/Bga4/wYGt/8FBbf/BQW3/wUFtv8GBrT/BQWx/wYGrf8GBqr/Bgap/wYG + qP8GBqf/Bgam/wcHpv8HB6X/Bwek/wgIov8ICKH/Cgqa/wsLkf8MDIX/DAxV3AAAAJoAAACLAAAAdQAA + AFwAAABGAAAANQAAAC4AAAAsAAAALAAAAC0AAAAtAAAAKgAAACUAAAAfAAAAFwAAAA8AAAAIAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQICzhMICM10CQm74QoKtP8MDK//DAyp/w4O + pP8PD57/EBCa/xAQl/8QEJb/EBCV/xAQlf8PD5b/Dg6X/w0Nm/8MDJ7/DAyh/wsLpP8LC6j/Cgqp5QkJ + qaEEBJJJAAAAFwAAABAAAAAKAAAABgAAAAMAAAACAAAAAgAAAAMBAbEWBQXNZgUFxLQFBb//BQW9/w8P + vP8EBLn/BQW4/wUFt/8FBbP/BQWw/wYGrP8GBqr/Bgao/wYGp/8GBqf/Bgan/wYGp/8HB6b/Bwek/wgI + of8KCpv/DAyP/w0Ng/8PD3r/Dw9S2wAAAJcAAACJAAAAdgAAAGQAAABXAAAAUAAAAE8AAABQAAAAUQAA + AFAAAABNAAAARgAAAD0AAAAxAAAAJAAAABgAAAAOAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAABAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAHAAAABQAAAAQAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADBwfQZAkJvOEKCrb/Cgqx/wsLrf8MDKn/DQ2m/w0NpP8NDaL/DAyh/wwM + of8MDKL/Cwul/wsLqP8KCqnyCQmprwYGpGYAAAAYAAAAEQAAAAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAAgICuhUEBMx2FhbC8RISv/8EBLv/BQW5/wUFt/8FBbH/Bgau/wYG + qv8GBqn/Bgao/wYGp/8GBqf/Bgan/wcHpv8HB6T/CAih/woKmv8MDJD/Dg6D/xERef8SEnP/ERFP2wAA + AJgAAACOAAAAgwAAAHoAAAB0AAAAcgAAAHEAAABwAAAAbgAAAGsAAABmAAAAXgAAAFIAAABCAAAAMQAA + ACIAAAAUAAAACwAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIAAAADAAAABQAAAAcAAAAIAAAACwAAAA4AAAAQAAAAEwAAABUAAAAXAAAAFwAA + ABYAAAAUAAAADgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwYG + 0lQICMDCCQm4/wkJtf8KCrP/Cgqx/woKr/8KCq3/Cgqt/woKrfIJCauvBgalZQAAABgAAAASAAAADAAA + AAcAAAAEAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAIgINOMHh7F/xAQv/8EBLr/BQW4/wUFtP8FBa//Bgas/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bwem/wcH + pP8ICKH/Cgqc/wwMk/8PD4f/ERF9/xISdf8UFHD/ExNL3AcHIa4KCi2wDw9GwRAQUcYQEFbEDw9awQ8P + X74KClCjAQEafgAAAHUAAABzAAAAbAAAAGEAAABRAAAAPgAAACwAAAAbAAAAEAAAAAgAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAEAAAABQAAAAgAAAAKAAAADQAAABEAAAAUAAAAGAAA + ABwAAAAgAAAAJAAAACgAAAAsAAAALwAAADEAAAAyAAAALgAAACYAAAAcAAAAEAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIFBdY0CAjDpAgIvPAJCbr/CQm44ggI + tpsGBq9hAAAAFQAAABAAAAALAAAABwAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEh0xYqKsvyJCTF/xkZvv8MDLj/BQW0/wUF + sf8GBq3/Bgaq/wYGqf8GBqj/Bgao/wYGqP8GBqb/Bwel/wgIov8JCZ3/CwuX/w4Ojv8QEIP/EhJ7/xMT + df8UFHP/FRVz/xUVcv8VFXX/FRV2/xUVeP8UFHz/FBSA/xQUg/8VFYb/ERFzyQMDMIUAAAB2AAAAdQAA + AGwAAABcAAAASgAAADYAAAAkAAAAFgAAAAwAAAAHAAAABAAAAAQAAAAFAAAABwAAAAgAAAALAAAADgAA + ABIAAAAVAAAAGgAAAB8AAAAjAAAAKQAAAC4AAAA0AAAAOQAAAD8AAABEAAAASQAAAE0AAABQAAAAUQAA + AE8AAABIAAAAOwAAACoAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAUAAAAHAAAACAAAAAcAAAAFAAAAAwAAAAEAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAS0t218vL8n/KSnB/yMjvf8cHLr/ERG0/wUFr/8GBqz/Bgaq/wYGqf8GBqn/Bgap/wYG + qP8HB6b/Bwej/wkJoP8KCpv/DAyV/w4Ojf8QEIb/EhKB/xMTfv8UFHz/FBR6/xQUe/8TE3r/ExN7/xMT + fv8TE4T/ExOJ/xMTjf8TE47/ExON/w8Pc78BARp+AAAAeAAAAHMAAABmAAAAVQAAAEAAAAAuAAAAIAAA + ABcAAAATAAAAEgAAABQAAAAXAAAAGwAAACAAAAAlAAAAKgAAADAAAAA2AAAAPQAAAEQAAABLAAAAUgAA + AFkAAABeAAAAYwAAAGYAAABoAAAAaAAAAGcAAABkAAAAXwAAAFMAAABDAAAAMAAAABsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABS4uyHk0NMP/Li6+/yoq + vP8kJLv/GRm2/wkJrv8GBqz/Bgas/wYGq/8GBqv/Bgaq/wcHqP8HB6X/CAii/wkJn/8KCpv/DAyX/w4O + kv8PD43/EBCJ/xERiP8SEoX/EhKB/xISfv8SEn3/EhKB/xAQiP8QEJD/EBCV/xAQl/8SEpb/ExOT/xMT + h+wHB02VAAAAeQAAAHcAAABuAAAAXwAAAE0AAAA9AAAAMQAAACwAAAAsAAAALgAAADMAAAA5AAAAPwAA + AEYAAABNAAAAVQAAAFwAAABiAAAAaAAAAGwAAABwAAAAcwQEQY4GBk6XDAxvuQwMcbgPD3zIERGH2RER + i9gREZDWCgqHmgAAADsAAAAoAAAAFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAHAAAAFxgYr6szM77/NTW+/y4uvP8pKbr/ISG1/woKrv8FBa7/BQWu/wYG + rf8GBqz/Bgar/wcHqP8HB6X/CAii/wkJoP8KCp3/Cwua/wwMl/8NDZT/Dg6R/xAQjP8REYb/Dw9e4ggI + L7AGBjKYAAAAYggIZ3EPD5nkDg6d/w8Pnf8REZn/EhKU/xMTjf8QEHC+AQEafgAAAHkAAAB1AAAAagAA + AF4AAABUAAAATwAAAE8AAABTAAAAWQAAAF4AAABkAAAAaQAAAG4AAABxAgIvhggIVqENDWy7EBB61RIS + h+4SEpD/EhKS/xISk/8REZX/ERGW/xISmP8SEpr/EhKd/xISof8REaPyAAAAKAAAABsAAAAOAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAA + AAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAsCAnw6BQWw8woK + r/8mJrf/Ojq7/zU1uf8uLrb/Jia1/xAQsP8FBa//BQWx/wUFr/8GBq3/Bgar/wcHqP8HB6b/Bwej/wgI + of8JCaD/Cgqd/wsLmv8MDJb/Dg6P/xAQh/8PD4H/BgYlrQAAAIUAAABoAAAARQAAACkLC6KNDQ2i/w4O + n/8QEJn/EhKT/xMTjP8TE4X1CQlUngAAAHgAAAB4AAAAdQAAAHAAAABuAAAAbQAAAG8AAABzBARBjgkJ + XqoODnHEEBCA3hERi/cREZD/ERGS/xERk/8QEJT/EBCW/w8Pmf8PD5r/Dw+c/w8Pn/8PD6D/Dw+i/xAQ + pP8QEKTlDQ2poAUFlkgAAAAVAAAADQAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAACAAAABAAAAAcAAAAIAAAACgAAAAsAAAAMAAAADQAAAA4AAAAPAAAADwAA + AA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAA + AA8AAAAPAAAADgAAAA0AAAAMAAAACgAAAAkAAAAIAAAABgAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAAEAUFsa4GBrD/Bgar/wUFqP8VFar/ODi0/zo6tf8zM7X/LS24/xIS + tP8FBbP/BQWz/wUFsP8GBq3/Bgaq/wYGqP8HB6f/Bwel/wcHo/8ICKH/Cgqd/wsLmf8NDZD/EBCH/xAQ + fv8QEGPnAAAAjQAAAHMAAABSAAAANQAAACUGBoZLDAye1w4OnP8QEJb/ERGR/xISjf8TE4r/EhJ82gMD + L4QHB0qYCAhVog0NbLsPD3fMEBCE5hISkP8REZH/ERGT/xERlP8QEJb/EBCX/w8Pmf8ODpv/Dg6d/w0N + oP8NDaL/DQ2k/wwMpv8NDaj/DAyq/wwMqsoLC6qQBQWaRQAAABQAAAAPAAAACgAAAAcAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAgAAAAOAAAAFQAA + ABoAAAAeAAAAIAAAACIAAAAkAAAAJQAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAA + ACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAkAAAAIwAAACEAAAAgAAAAHQAA + ABoAAAAVAAAAEAAAAAoAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBAWsiBwe1/wcH + rv8GBqn/Bgaj/wYGnv8KCo/oNTWa0T4+uf84OLv/MTG9/xoauf8FBbX/BQWz/wUFr/8GBqz/Bgaq/wYG + qP8GBqb/Bwel/wcHo/8JCaD/Cwub/w0Nkv8QEIj/ERF9/xMTef8GBiinAAAAfgAAAGIAAABKAAAAPQAA + ADoAAAA+CgqFog8Pl/8QEJP/ERGQ/xERj/8SEpD/EhKR/xERk/8REZT/EBCV/xAQl/8PD5f/Dw+Z/w4O + m/8ODpz/Dg6e/w0Nof8MDKP/DAyl/wwMp/8MDKn/Cwur/wsLrPIKCqy7CQmujwUFp1MAAAAUAAAAEAAA + AAwAAAAIAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAHAAAADwAAABsAAAApAAAAMwAAADsAAAA/AAAAQgAAAEQAAABGAAAASAAA + AEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAA + AEgAAABIAAAARwAAAEYAAABEAAAAQQAAAD8AAAA8AAAANwAAADAAAAAlAAAAGQAAAA8AAAAHAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAABQUFuG0HB7T/Bwet/wcHp/8ICJ//CAia/wMDSJ8AAABfPDyvw0RE + wf89PcL/NzfC/x8fvP8ICLX/BQWy/wYGrv8GBqv/Bgap/wYGqP8GBqb/Bwek/wgIof8KCpz/DQ2S/xAQ + h/8REX3/ExN2/w8PR8sAAACHAAAAcwAAAGIAAABcAAAAXQAAAGIAAABmAwM2dw0NhNYPD5H/Dw+S/w8P + lf8PD5j/Dw+d/w4On/8NDaH/DQ2i/wwMo/8MDKX/DAym/wsLqP8LC6r/Cwut/woKrv8KCq7JCQmvnQcH + sHADA5UyAAAAEgAAAA4AAAAKAAAABwAAAAUAAAADAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAkAAAAWAAAAKQAA + AD0AAABOAAAAWgAAAGIAAABnAAAAagAAAG0AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbwAA + AG8AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbQAAAGsAAABqAAAAaAAA + AGQAAABeAAAAUwAAAEQAAAAzAAAAIgAAABQAAAAKAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAHBga4iwgI + s/8ICKz/CAil/wkJnP8JCYzxAAAAeAAAAFUAAAAyRETBu0hIyP9CQsf/PT3F/y0twf8QELb/BQWw/wYG + rP8GBqr/Bgap/wYGqP8HB6b/CAii/woKnf8NDZT/EBCK/xISff8TE3X/ExNX4AAAAJEAAACEAAAAewUF + NZMHB0CdAAAAggAAAIQAAACAAAAAdggIVpgNDYzqDQ2W/w0NnP8NDaH/DAym/wsLqf8LC6z/Cgqu/woK + r+QKCq/ICAixjgcHrmEDA5UyAAAAEQAAAA4AAAAKAAAACAAAAAYAAAAEAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAACAAAACgAAABgAAAAuAAAARAAAAFgAAABnBgZRlAYGTJkGBkmcBgZHnwcH + RKEHB0SiBwdDogcHQ6IHB0OiBwdCowcHQqMHB0KjBwdCowcHQ6IHB0OiBwdDogcHRKIHB0SiBwdEogcH + RKEHB0ShBwdEoQUFOZgAAACAAAAAgAAAAH8AAAB/AAAAfgAAAHsAAABzAAAAZgAAAFMAAAA9AAAAKQAA + ABcAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAcICLnFCAiz/wkJq/8KCqL/CwuZ/woKeNsAAAB0AAAATwAA + ACwAAAAUSEjOt05OzP9ISMr/QUHI/zw8xf8nJ7z/EBCy/wYGrP8GBqv/Bgaq/wcHqP8ICKT/Cgqg/wwM + mP8PD43/FBSD/yAgf/8kJGXpAAAAmQ4OQMISEm/xEhJ9/xERgP8QEIH/Dg5l3wUFKqkAAACPAAAAgQAA + AG8HB1eDCwuGoQoKl5cKCqWQBgalUgYGrk8AAAAQAAAADgAAAAwAAAAJAAAABwAAAAUAAAADAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICM9kDAy60w0N + sv8ODqv/Dw+k/xAQnf8REZj/EhKU/xISkv8SEpH/ExOQ/xMTj/8TE47/ExON/xMTjf8TE43/ExON/xMT + jf8TE43/ExON/xMTjf8TE43/ExON/xMTjf8TE43/ExON/xMTjf8TE4v/ExOL/xMTiv8TE4j/FBSI/xUV + hv8TE3XgBwdEogAAAIIAAAB7AAAAbgAAAFsAAABEAAAALgAAABsAAAAOAAAABgAAAAIAAAAAAAAACAgI + tsYJCbD/Cgqp/wsLn/8NDZX/CgpjxAAAAHAAAABKAAAAJwAAABAAAAAJTEzNu1NTzv9NTcz/SEjJ/0FB + xf88PMH/Ly+8/x0dtf8TE7L/Dg6v/w4Oqv8QEKb/GBii/yAgnP8mJpP/JyeI/x4eU9gREU3bExN1/xMT + eP8SEnz/ERF+/xERfv8REXz/ERF7/w0NS84AAACVAAAAhQAAAG8AAABUAAAAOQAAACEAAAARAAAACAAA + AAMAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQoKxcALC7z/Cwu4/wwMs/8MDK3/DQ2o/w0No/8ODqD/Dg6e/w8P + nv8PD53/Dw+d/w8PnP8QEJv/EBCb/xAQm/8QEJv/EBCb/xAQm/8QEJv/EBCa/w8Pmv8PD5n/Dw+Z/w8P + mf8PD5n/EBCY/xAQmP8QEJb/EBCV/xAQlP8SEpL/ExOQ/xMTjP8UFIj/ERFuzgEBGIcAAAB8AAAAcQAA + AGAAAABKAAAAMwAAACEAAAASAAAACQAAAAQAAAAKCAixxgkJrP8LC6T/DQ2a/w8PkP8KClq8AAAAbAAA + AEQAAAAjAAAADQAAAAgDA6tRPDzJ/1hYzv9TU8v/TEzI/0dHxP9AQML/OzvA/zU1v/8wML3/Kiq4/yYm + s/8gIKz/IiKj/yQkm/8lJZH/GBh59BAQfP8QEH3/EBCA/xAQgv8QEIP/EBCA/xERfP8SEnf/EhJ2/xAQ + U9sAAACWAAAAhQAAAGwAAABNAAAAMAAAABgAAAAJAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLbEggI + z4MJCcDhCgq6/woKt/8KCrL/Cgqw/wsLrf8LC6v/Cwur/wwMq/8MDKv/DAyr/wwMq/8MDKr/DAyq/wwM + qv8MDKr/DAyq/wwMqv8MDKj/DAyn/wwMp/8MDKb/DAyn/wwMp/8MDKf/DAym/wwMpf8MDKT/DQ2j/w4O + oP8PD57/EBCa/xISlf8TE4//ExOB5AUFP5AAAAB4AAAAcgAAAGQAAABQAAAAOwAAACgAAAAaAAAAEQAA + ABQJCarICgqm/wwMnv8PD5T/EBCL/wcHQaMAAABnAAAAPwAAACAAAAAKAAAACAUFuIwFBbj/QEDH/15e + zP9YWMn/U1PF/0xMxP9GRsP/QEDE/zs7wv81Nb7/MDC6/yoqs/8mJqv/IiKk/x4em/8ODo7/Dg6L/w8P + iv8PD4v/Dw+M/w8PjP8QEIj/ERGA/xISef8TE3P/ExNx/xERUNsAAACVAAAAgQAAAGYAAABFAAAAKAAA + ABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMFBdZEBwfJhQgIvcQICLnwCAi3/wkJ + tv8JCbX/CQm1/wkJtf8JCbX/CQm0/wkJtP8JCbP/CQmz/wkJs/8JCbP/CQmz/wkJs/8JCbL/CQmy/woK + sv8KCrL/Cgqy/woKsv8KCrL/Cgqy/woKsf8KCrH/Cgqv/wwMrP8NDaj/Dg6j/xAQnP8SEpb/ExON9QYG + UJEAAAB0AAAAcgAAAGgAAABYAAAARgAAADUAAAApAAAAKQoKoNkLC6D/DQ2a/xAQjv8SEoj/BQU5mgAA + AGEAAAA6AAAAHAAAAAgAAAAJBga3uAUFtv8FBbD/Li65/2NjyP9dXcf/VlbF/1BQxf9LS8f/RUXF/z8/ + wv86Or3/NTW5/zAws/8oKK3/EBCg/wsLmv8LC5f/DAyX/wwMl/8MDJb/DQ2U/w4OkP8QEIj/EhJ//xMT + dv8UFG//FhZt/w8PPcgAAACRAAAAeQAAAFoAAAA5AAAAHQAAAAsAAAADAAAAAAAAAAAAAAABAAAAAgAA + AAUAAAAIAAAACwAAAA4AAAANAAAACgAAAAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAUAAAAHBATKRwQEx0gFBcBKBQW/SgUFvUsFBb5bCAjAiAYG + vWsFBbdNBQW3TQUFuUwFBblMBQW6TAUFvUsDA6osAAAADgAAAAwAAAAMAAAACgAAAAoAAAAKAAAACgUF + xUgFBcJJCQm+lwoKtuELC7D/DAyr/w4OpP8QEJz/EhKW/wwMb6gAAABwAAAAcwAAAG4AAABkAAAAVgAA + AEoAAABHCwud/wsLmf8NDZP/ERGK/xMThv8AAAB8AAAAWQAAADMAAAAXAAAABwAAAAkGBrfjBgaz/wcH + q/8GBp7uKChro1xcvvJjY8j/XFzJ/1dXyv9QUMn/SkrE/0VFv/8/P7v/Nze0+RoaleUICKb/CQmi/wkJ + of8JCaD/CQme/woKnf8LC5v/DAyW/w4OkP8QEIf/ExN8/xQUcv8WFmv/GBhq/wcHJq0AAACJAAAAbQAA + AEwAAAAsAAAAFAAAAAYAAAABAAAAAwAAAAYAAAAKAAAAEgAAABkAAAAfAAAAIwAAACEAAAAbAAAAEgAA + AAkAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAgAA + AAIAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABAcHzGUKCrjhDAyx/w4O + qv8QEKL/ERGa/xAQhswBARx2AAAAdQAAAHYAAABzAAAAbAAAAGsMDJX/DQ2T/w8Pj/8SEoj/ExOC+AAA + AHMAAABPAAAALAAAABMAAAAFAAAACQcHuP8HB7D/CAio/wcHkdwAAABxAAAAXEFBpZhXV8POXFzL/1xc + zP9WVsj/TEy97jQ0rucPD6HwBgap/wgIqP8HB6b/Bwek/wcHpP8ICKP/CAii/wkJoP8KCpz/DAyX/w4O + j/8REYX/ExN5/xcXbv8ZGWj/GBhZ7QAAAJQAAAB+AAAAXgAAADsAAAAfAAAADgAAAAgAAAAMAAAAFAAA + AB0AAAAnAAAAMgAAADsAAABAAAAAPgAAADMAAAAkAAAAFQAAAAkAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQICzhMICMeTCwu1/wwMrv8ODqb/Dw+f/xERlvQMDHW0AgIvhwAA + AH4AAACBAAAAgwwMkf8NDZD/Dw+N/xISif8REXjfAAAAZgAAAEIAAAAjAAAADgAAAAMAAAAICAi3/wgI + sP8JCab/Bwd9wgAAAHMAAABeAAAAOwAAAB8AAAARAAAAFQAAACoDA4KMBQWo/wYGqv8GBqr/Bweq/wcH + qP8HB6f/Bwem/wcHpv8HB6X/Bwek/wgIof8KCpz/DAyW/w8Pjf8TE4H/FRV0/xgYaf8aGmb/Dw82wQAA + AIoAAABuAAAATQAAAC8AAAAdAAAAGAAAAB4AAAAqAAAANwAAAEIAAABNAAAAVgAAAFsAAABZAAAATwAA + ADsAAAAmAAAAEwAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEGBtZECgq58AsLs/8MDKv/DQ2l/w4On/8ODpv/DAyS7gsLheAKCoLiDAyU/w0Nkf8PD47/ERGM/wwM + bbgAAABTAAAAMwAAABkAAAAIAAAAAQAAAAcICLj/CQmv/wsLpf8ICHe3AAAAdQAAAGUAAABEAAAAJQAA + ABQAAAAXBASZewUFq/8FBan/Bgar/wYGrP8GBqr/Bgap/wYGqP8GBqf/Bgan/wYGp/8HB6b/Bwek/wgI + of8KCpz/DQ2U/xAQiv8TE3z/FhZw/xkZZ/8ZGVzzAAAAkwAAAH0AAABgAAAARAAAADUAAAAxAAAAOQAA + AEUAAABQAgI/awkJcpkNDXqwBARKggAAAGgAAABhAAAAUAAAADkAAAAhAAAADgAAAAQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAs4TCQnCwQoKt/8KCrH/Cwus/wsL + p/8KCqT/Cgqi/woKnv8LC5r/DQ2V/w8Pkv8REZL/BARQeQAAAD4AAAAjAAAAEAAAAAUAAAAAAAAABQkJ + uv8KCrD/DAyl/wkJeLUAAAB2AAAAbgAAAFIAAAAxAAAAHwQEjEkGBq//Bgat/wUFq/8GBqz/BQWr/wYG + q/8GBqn/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/Bwej/wkJn/8LC5n/Dg6R/xIShP8UFHf/Fxds/xkZ + Z/8PDzbAAAAAigAAAHUAAABeAAAAUQAAAE4AAABSBgZggg8PjswSEpv/EhKZ/xMTlv8TE5D1BARKgQAA + AGgAAABgAAAATAAAADEAAAAZAAAACQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAACBwfNgwgIu/8JCbf/CQmz/wkJsP8JCa3/CQmq/wsLo/8MDJ7/Dg6b/w4O + kNQAAAA+AAAAKAAAABQAAAAIAAAAAgAAAAAAAAADCAi/0QoKsv8MDKb/Dg6Z9QEBGn0AAAB1AAAAYQAA + AEAAAAAqBgaorgYGr/8GBq7/BQWv/wYGrv8FBa3/Bgar/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + pv8HB6X/CAii/woKnf8MDJb/EBCL/xMTf/8VFXL/Fxdr/xUVUOEAAACUAAAAhgAAAHUAAABpCgponhAQ + kusQEJ3/Dw+g/w8PoP8QEKD/ERGd/xISmf8TE47fAAAAYgAAAGYAAABaAAAAQgAAACYAAAARAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQXXRAcH + weAHB7z/Bwe6/wgItv8JCbH/Cgqs/wwMqP8ODqPzBAR2WAAAACMAAAAVAAAACgAAAAMAAAABAAAAAAAA + AAEHB8qDCgq1/wwMqf8ODp7/CwtytwAAAHgAAABtAAAAUQAAADgREazzBwev/wYGsf8FBbL/Bgay/wUF + r/8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6T/CQmg/wsLm/8ODpL/ERGG/xMT + ev8VFXH/FhZu/wEBEaAAAACPCQlJpxAQfNwREZT/Dw+c/w4Oo/8NDaXzCgqgpggImWoPD6bxEBCh/xIS + nP8ODoWzAAAAYwAAAGMAAABRAAAANgAAABwAAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLPEwYG0IMHB7/wBwe9/wgIuf8KCrX/Cwux4wUF + lEgAAAAYAAAAEAAAAAgAAAADAAAAAQAAAAAAAAAAAAAAAAMD2iMJCbn/DAyt/w4Oov8QEJX1AQEafgAA + AHUAAABgAAAARiUlsv8fH7b/FRW5/woKt/8FBbX/BQWx/wYGrf8GBqr/Bgao/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wcHpf8ICKL/Cgqe/wwMl/8PD47/EhKD/xMTef8TE3T/EBBP0xMTc/ESEob/ERGR/w8P + mv8ODqP/CgqfpwEBSTQAAAAZAAAAEAYGtjsODqv/EBCk/xISnP8EBFB4AAAAZgAAAF0AAABGAAAAKQAA + ABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMFBddEBATLRwQEwTkAAAAMAAAACgAAAAgAAAAFAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAQgIxaILC7L/DQ2n/w8Pnf8LC3K3AAAAeAAAAG0AAABTKyuw6ioquf8oKL3/JibA/yAg + vv8VFbj/DQ2y/wYGrP8GBqn/Bgao/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bwem/wcHpP8JCaD/Cwub/w0N + k/8QEIr/ERGB/xISfP8SEn3/EhKD/xERjv8PD5j/DQ2ZwgMDaUUAAAAcAAAAEQAAAAkAAAAEAAAAAwoK + wJMNDaz/EBCj/xAQktIAAABiAAAAZAAAAFQAAAA4AAAAHQAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAA + AAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPaIwoKuP8MDK3/Dg6i/xAQ + lvUBARp+AAAAdQAAAGAvL6K4MzO7/zAwv/8uLsH/LCzC/ysrwP8pKbz/Jye5/xsbs/8VFa//DQ2r/wgI + qf8GBqf/Bgan/wYGp/8GBqf/Bwel/wgIov8KCp7/CwuY/w4Okf8PD4f/EhKE/xMThf8QEIv/Dw+N3wcH + d2sAAAAjAAAAFAAAAAoAAAAFAAAAAgAAAAAAAAAAAgLOEwwMtfAODqv/ERGg/wYGX4MAAABmAAAAXgAA + AEYAAAApAAAAEgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABCAjEogsLs/8MDKj/Dg6e/woKdLcAAAB3AAAAaxMTT2w8PLz/OTnA/zY2 + w/80NMP/MjLF/zExwv8vL77/Li68/y0tuf8rK7f/Kiq0/yMjsv8dHbD/GRmt/xQUrP8UFKr/FBSn/xQU + o/8WFp//HByZ/yIilP8lJZL/FBSD7wkJaJsAAAA+AAAAIwAAABAAAAAGAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAABCQnIgw0Nsf8PD6X/ERGW3gAAAGQAAABmAAAAVAAAADcAAAAcAAAACgAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBNkjCgq4/wsL + rf8NDaP/Dg6Y9QAAAHYAAABzAAAAXDQ0p6xBQcL/Pz/F/z09yP87O8j/OjrI/zk5xP83N8L/NTW//zQ0 + vP8yMrr/MDC3/y4utv8sLLX/Kiq0/yoqsv8pKbD/KCis/ycnpf8nJ57/JyeY/yYmlf8ICDeBAAAASwAA + ACsAAAAUAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAs4TCwu28A4Oq/8REZ//BgZdhAAA + AGgAAABfAAAARgAAACgAAAARAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMOiCgqx/wwMp/8ODp7/BwdkpwAAAHYAAABmAAAASD09 + u75ISMn/RUXL/0REy/9CQsv/QEDL/z8/yf89PcX/PDzB/zo6v/85Ob3/Nze7/zY2uv80NLn/MzO2/zIy + s/8xMa//MTGo/zAwof8vL57/KSmS6AAAAFgAAAA3AAAAHQAAAAsAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEJCciDDAyw/w8PpP8QEJDUAAAAZgAAAGYAAABTAAAANQAAABsAAAAJAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE + 0yQKCrT/Cwup/w0Nn/8NDZHtAAAAeAAAAG0AAABPAAAALkZGyblPT8//TEzQ/0pKz/9JSc7/R0fM/0VF + yv9ERMj/QkLF/0BAwv8/P8H/Pj6//z09vP87O7n/Ojq2/zo6sf85Oav/OTmm/zg4pf8hIXugAAAAQAAA + ACUAAAASAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE1CQLC7X/Dg6p/xER + nv8GBlyHAAAAaQAAAF4AAABEAAAAJgAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwkJu6ULC6z/DQ2h/w4OmP8HB1eiAAAAcAAA + AFMAAAAvAAAAFklJ1ptVVdP/U1PT/1FR0f9QUM//Tk7O/0xMzP9MTMr/SkrH/0hIxP9HR8D/RUW9/0RE + u/9DQ7f/QUGz/0JCr/9BQa3/PT2p7gAAAEAAAAApAAAAFQAAAAgAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJwaMNDa//EBCk/xAQjcoAAABoAAAAZgAAAFEAAAAzAAAAGAAA + AAgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADAwOhLgsLrP8NDaD/Dw+X/wwMeswAAABvAAAAUgAAAC4AAAAUAAAABkVF4FZSUtbpWlrW/1hY + 0/9WVtD/VVXO/1NTzP9SUsj/UVHE/09Pwf9OTr7/TEy7/0xMuP9KSrX/S0u1/0lJs/cjI4BkAAAAJQAA + ABUAAAAKAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBgbVRAsL + tP8ODqn/ERGf/wICOnQAAABoAAAAWgAAAD4AAAAhAAAADAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAASCwus/w4OoP8QEJf/Dw+D3QAA + AGsAAABMAAAAKgAAABEAAAADAAAAAQAAAANMTN57XFzX62Bg1P9eXtH/XFzN/1tbyf9ZWcT/V1fA/1ZW + vv9VVbz/VVW7/1RUu/9LS7fjLCyVWgAAABsAAAARAAAACAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCgq/wgwMsP8PD6b/Dg6PvgAAAGAAAABaAAAAQwAA + ACYAAAAQAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABgQEo0ELC6v/Dg6f/xAQlf8ODnrLAAAAZgAAAEQAAAAkAAAADgAAAAIAAAAAAAAAAAAA + AAEAAAADS0vcalRU0b1hYc72Y2PL/2Jixf9hYcL/YGC//2BgwP9OTrLUQECqjgAAAB0AAAASAAAACgAA + AAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEHB9BjCwu2/w4Orf8QEKX/AgJGZAAAAE8AAAA+AAAAJQAAABEAAAAEAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBwevcAwMqf8ODp3/ERGV/wkJ + Y6cAAABfAAAAPAAAAB0AAAAKAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAFAAAAEQAAACgZGa7qHh6t/yAg + qv8oKJC4AAAASgAAAC8AAAAYAAAACwAAAAUAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMKCr3gDAy0/w4Orv8LC5ucAAAAOwAA + ADEAAAAfAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAsJCbGrDAyo/w4OnP8REZT/BARFigAAAFcAAAAzAAAAFwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAgAAAAoAAAAaBgacjAgIqv8KCqX/Cgqa7AAAAFMAAAA3AAAAHQAAAAsAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQcH1GILC7r/DQ21/w4OsdUAAAAjAAAAHQAAABMAAAAJAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADwoKr9YMDKb/Dw+a/xER + kPYAAABpAAAATAAAACoAAAASAAAABAAAAAAAAAAAAAAAAAAAAAEAAAAGAAAAEgEBQzUJCarzCgqn/wwM + ov8FBWCFAAAARAAAACgAAAASAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQkJyqILC7zwDAy8wwAA + ABAAAAAOAAAACQAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAQAAAASCwuu/w0No/8QEJr/Dg59yQAAAGIAAABCAAAAIgAAAAwAAAACAAAAAAAA + AAAAAAAAAAAAAwAAAAwAAAAeCQmhqAsLp/8MDKL/DAyR2AAAAFAAAAA0AAAAGgAAAAoAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAEAAAABQAAAAUAAAADAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgUFrFALC6z/DQ2i/xAQ + mf8JCWiiAAAAWQAAADcAAAAbAAAACAAAAAEAAAAAAAAAAAAAAAEAAAAGAAAAFAUFjGALC6j/DQ2h/w4O + nf8EBFF6AAAAQQAAACUAAAAQAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAICAixfgsLqv8ODqD/EBCY/wEBIHAAAABOAAAALgAAABQAAAAFAAAAAAAA + AAAAAAAAAAAAAQAAAAoAAAAdCwulzg0No/8ODpz/DQ2ExQAAAFEAAAAzAAAAGQAAAAgAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAwJCbGrDAyp/w4O + n/8PD4/jAAAAXwAAAEQAAAAkAAAADgAAAAMAAAAAAAAAAAAAAAAAAAADAAAADgcHpXYMDKn/Dg6f/w8P + lPYCAjl4AAAASgAAACwAAAAUAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAAEAsLr9YNDaf/Dw+d/woKdKkAAABXAAAAOQAAABwAAAAJAAAAAQAA + AAAAAAAAAAAAAAAAAAMAAAAQCwuw8gwMqf8ODp7/Cwt0twAAAGYAAABMAAAAMAAAABkAAAAKAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAUCwuv/w0N + pf8PD53/AgI8dAAAAE0AAAAvAAAAFQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAwcHw2gKCrT/DAyr/w4O + nvUBAR9zAAAAaAAAAFYAAAA+AAAAKgAAABoAAAAQAAAACQAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACAUFp1IMDK3/Dg6j/w8Pl+sAAABaAAAAQgAAACUAAAAOAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAACCQnC0QoKt/8MDK7/DAyTvAAAAF8AAABnAAAAYQAAAFQAAABEAAAAMwAA + ACYAAAAZAAAAEAAAAAkAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAALCQmujwwM + q/8ODqL/DAyGuAAAAFEAAAA3AAAAHAAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEHB8ySCQm7/wsL + s/8MDKbZAgJGYgAAAFsAAABjAAAAYwAAAFwAAABRAAAAQwAAADQAAAAmAAAAGQAAABAAAAAIAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAABAKCq/JDQ2p/w8Pof8CAkBuAAAASAAAAC0AAAAUAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICzxMJCcPRCgq5/wwMsf8ODqj/Dg6UuQICP2sAAABiAAAAZwAA + AGYAAABeAAAAUgAAAEMAAAAzAAAAJQAAABgAAAAOAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAFQwM + rPIODqb/Dw+Y4AAAAFMAAAA9AAAAIwAAAA4AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIC + zxMICMiiCgq4/wwMsv8ODqn/EBCi/w4Ojr0CAjtyAAAAaAAAAGoAAABoAAAAXwAAAFIAAABCAAAAMQAA + ACMAAAAVAAAADAAAAAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAoFBaJVDAys/w4Opf8KCoCgAAAASgAAADMAAAAZAAAACAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHB9JjCgq58AwMs/8NDaz/Dw+l/xER + nv8PD4jAAgI4dgAAAGoAAABsAAAAaAAAAF4AAABPAAAAPgAAAC4AAAAeAAAAEgAAAAgAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAADwkJ + rp8NDar/Dw+k/wICRWcAAABAAAAAKAAAABIAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEEBNojCQnBsgsLtv8MDLD/Dg6p/xAQo/8REZz/Dw+HwQICN3kAAABrAAAAawAA + AGYAAABaAAAASgAAADcAAAAkAAAAFQAAAAoAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAWDAyv1w4Oqf8NDZjIAAAASwAAADYAAAAeAAAACwAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBgbVRAoK + vOALC7T/DQ2t/w8Pp/8QEKH/EhKb/wwMfa0BAR5vAAAAagAAAGgAAABeAAAATAAAADcAAAAhAAAAEAAA + AAYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAACwIC + gTgMDLD/Dg6o/wcHeIUAAABCAAAAKwAAABUAAAAGAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwcH0GQKCrrhDAyz/w0NrP8PD6b/ERGg/xIS + mPQJCXOYAAAAYgAAAGEAAABVAAAAQgAAACoAAAAVAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAPCQmyng0Nr/8NDaboAAAARwAAADYAAAAgAAAADQAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMICMuDCwu38AwMsv8ODqv/Dw+m/xERoP8REZjdBARZcQAAAE0AAAA+AAAAKgAA + ABcAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAA + ABILC7bkDQ2x/woKmaAAAAA7AAAAKgAAABYAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAs4TCQnIhAsL + tvANDbD/Dw+s/xAQqP8REaTyBARzWgAAAC0AAAAfAAAAEQAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBgbAWgsLuf8MDLLyAQE7QAAAACsAAAAdAAAADQAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLOEwkJyIQMDLXwDg6y/w4OsP8NDbG4AAAAGQAA + ABIAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAMKCsPCCwu7/wkJtY8AAAAhAAAAGgAAABAAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQICzxMICM9kBgbKRwAAAAsAAAAKAAAABwAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLbEgoKwu8LC73wAQF6IAAAABIAAAANAAAACAAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAQAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABBgbbUgYG2EQAAAAHAAAABwAAAAUAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/////////AH///////////////////wA///////////////////8AP////////////////// + /AB///////////////////wAf//////////////////8AD///////////////////AA///////////// + //////4AP//////////////////+AB///////////////////gAf//////////////////8AD/8D//// + ////////////AA/+Af///////////////4AH/gD///////////////+AB/4A////////////////wAP+ + AH///////////////8AD/AB////////////////AA/wAf///////////////4AH8AH////////////// + /+AB/AB////////////////wAPwAf///////////////8AD8AH//////////+AD///AAfAB///////// + /8AAH//4AHwAf/////////8AAAf/+AB8AH/////////+AAAB//wAPAB//////////AAAAH/8ADwAf/// + //////wAAAA//AAcAH/////////4AAAAH/4AHAB/////////+AAAAA/+ABwAf/////////gAAAAH/gAM + AH/////////4AAAAA/8ADAB/////////+AAAAAH/AAwAf/////////gAAAAA/wAMAH/////////4AAAA + AH+ADAB/////////+AAAAAB/gAwAf/////////gAAAAAP4AMAH/////////4AAAAAB8ADAB///////// + +AAAAAAfAAwAf/////////gAAAAADwAMAH/////////4AAAAAAYADAB//////////AAAAAAGABwAf/// + //////wAAAAAAgAcAD/////////+AAAAAAAAHAA//////////gAAAAAAADwAP/////////8AAAAAAAA8 + AB//////////AAAAAAAAfAAf/////////4AAAAAAAHwAD/////////+AAAAAAAB8AA//////////wAAA + AAAA/gAH/////////+AAAAAAAP4AB//////////wAAAAAAD/AAP/////////+AAAAAAA/wAD//////// + //gAAAAAAP+AAf////+Af//8AAAAAAB/wAH/////AD///wAAAAAAf+AA/////wAP//+AAAAAAH/gAH// + //8AA///wAAAAAAfgAB/////AAD///AAAAAAAAAAf////wAAH//4AAAAAAAAAH////8AAAf//gAAAAAA + AAB/////AAAA//+AAAAAAAAAf////4AAAB//gAAAAAAAAH/////gAAAH/AAAAAAAAAB/////+AAAAOAA + AAAAAAAA//////4AAAAAAAAAAAAAAP//////gAAAAAAAAAAAAAH///////AAAAAAAAAAAAAH///////8 + AAAAAAAAAAAAD////////wAAAAAAAAAAAAP////////AAAAAAAAAAAAA////////8AAAAAAAAAAAAD// + +AD///wAAAH4AAAAAAAf/gAA////AAAH/wAAAAAAB8AAAP///8AAP/+AAAAAAAAAAAD////wAf//gAAA + AAAAAAAA/////////8AAAAAAAAAAAP////////+AAAAAAAAAAAD//8AAAB//gAAAAAAAAAAA/+AAAAAA + P4AAAAAAAAAAAP/AAAAAAB+AAAAAAAAAAAf/wAAAAAAHgAAAAAAAAAA//8AAAAAAA4AAAAAAAAAH///A + AAAAAAGAAAAAAAAA////wAAAAAAAgAAAAAAAP////8AAAAAAAAAAAAAAAP/////gAAAAAAAAAAAAAAB8 + D///8AAAAAAAAAAAAAAAYAP///wAAAAAAAAAAAAAAAAB////8AAHwAAAAAAAAAAAAf////////gAAAAA + AAAAAAD////////+AAAAAAAAAAAA/////////wAAEAAAAAAAAH/////////AABAAAAAAAAA///////// + 4AAQAAAAAAAAP/////////AAOAAAAAAAAB/////////8AHgAAAAAAAAf/////////4P8AAAAAAMAD/// + /////////AAAAAAHAA////////////4AAAAAH4AP///////////+AAAAAD+AB////////////wAAAAA/ + wAf///////////8AAAAAf8AD////////////AAAAAH/AA////////////wAAAAD/4AP///////////8A + GAAB/+AD////////////ABwAB//wA////////////gA8AD//8AP///////////4AOAA///gD//////// + ///+ADgAf//8B////////////gAwAH////////////////4AcAD////////////////8AHAA//////// + /////////ABwAH////////////////wA8AAf///////////////8APAAB///////////////+ADwAAH/ + //////////////gB+AAAf//////////////4AfgAAB//////////////8AH+AAAP//////////////AD + /wAAD//////////////gA//AAAf/////////////4AP/4AAH/////////////+AH//gAB/////////// + ///gB//+AAf/////////////4A///4AH/////////////+AP///gD//////////////gH///+D////// + ////////4B////////8oAAAAQAAAAIAAAAABACAAAAAAAABCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABwAAAA4AAAARAAAADAAA + AAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAA + AA4AAAAcAAAAJgAAAB0AAAAPAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIICLxaCgqokwAAADkAAAAzAAAAHQAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBga1Ow4Opf8ICIqIAAAARAAAAC4AAAATAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNDaHHDg6d5wAA + AEwAAAA+AAAAIQAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADCwuqaw4Onf8ICH+OAAAASgAAADAAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAA + AAcAAAAFAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAoODpzkDQ2a6AAAAFEAAAA+AAAAHwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAABwAAABAAAAAXAAAAEwAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDAyiiw0Nm/8GBnOHAAAASwAA + AC0AAAAQAAAAAgAAAAAAAAAAAAAAAQAAAA8AAAAiAAAAMgAAACoAAAAXAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQE + pCwNDZv/DQ2U0gAAAFMAAAA8AAAAGwAAAAUAAAAAAAAAAAAAAAMAAAAWDg6o/wUFcnYAAAA+AAAAIgAA + AAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAHDQ2duA0Nm/8DA1Z0AAAASgAAACkAAAAMAAAAAQAAAAAAAAAEBwefUw4O + nv8LC4y1AAAATAAAACoAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAYAAAAIAAAACgAAAAkAAAAHAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJqFwODpr/DAyMvgAAAFUAAAA5AAAAFwAA + AAQAAAAAAAAABQgIm1MNDZn/DAyR1gAAAFEAAAAsAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACgAAABMAAAAdAAAAJAAA + ACcAAAAlAAAAHwAAABYAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDg6Z5A4O + mv8BASNkAAAASAAAACQAAAAKAAAAAAAAAAUICJpTDQ2Y/wwMj9YAAABTAAAALgAAAA4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADgAA + ACAAAAA0AAAARgAAAFEAAABXAAAAVAAAAEoAAAA7AAAAKQAAABcAAAAKAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABQ0NnpsNDZj/CgqBrAAAAFUAAAAzAAAAEwAAAAMAAAAFCAiZUw0NmP8MDI7WAAAAUwAA + AC4AAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAACwAAACEBAS1NCAhymwoKdLoMDIffCgp2yQgIa7gBATKKAAAAawAAAFUAAAA7AAAAIwAA + ABAAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAEHB6Q+DQ2Y/w0NlekAAABcAAAARAAAAB8AAAAHAAAABQgI + mVMNDZj/DAyO1gAAAFMAAAAuAAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABYWFpCGDQ2T9QsLkf8KCpL/CQmS/wkJkf8LC5D/DAyT/woK + edUAABmHAAAAZwAAAEkAAAAsAAAAFAAAAAcAAAABAAAAAAAAAAAAAAAAAAAACQ4OmNYNDZj/BgZpkQAA + AFIAAAAtAAAADgAAAAYICJlTDQ2Y/wwMjtYAAABTAAAALgAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcODnw9HR2c/woKjv8HB5H/CAib/wcH + n/8ICJv/CAiT/wgIj/8KCo//DAyP+QUFVq8AAAByAAAAUgAAADAAAAAVAAAABwAAAAEAAAAAAAAAAAAA + AAQMDJ99DQ2X/wwMjtYAAABbAAAAOgAAABcAAAAICAiZUw0NmP8MDI7WAAAAUQAAACwAAAANAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJHh6gmBYW + lf8ICJH/Bgad/wYGpf8GBqf/Bgal/wYGof8HB5v/BweR/wkJjP8LC5H/Cgp0zwAAAHgAAABVAAAAMAAA + ABQAAAAFAAAAAAAAAAAAAAABBQWbLg0NmP8NDZj/AgI8cgAAAEIAAAAdAAAACggImlMNDZj/DQ2Q1QAA + AE8AAAArAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACCEhn8wXF5f/CAib/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgal/wYGnf8GBpD/CAiL/wsL + j/8KCnnWAAAAdwAAAFEAAAAqAAAAEAAAAAMAAAAAAAAAAAAAAA4NDZS9DQ2X/wkJfKQAAABEAAAAHgAA + AAoICJtTDQ2Z/w0NkdUAAABLAAAAKAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYjI6KVHBya/wgIm/8GBqX/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqX/Bgad/wYGkf8ICIv/CwuQ/wkJbMgAAABxAAAASAAAACEAAAAKAAAAAQAAAAEAAAASDAyMmQ0N + l/8KCoKtAAAAPgAAABoAAAAICAibUw0Nmf8LC4e0AAAASQAAACcAAAAKAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADHh6pciIimv8LC5T/Bgah/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpf8GBp3/BgaR/wgIi/8MDJH/BQVWrgAAAGYAAAA6AAAAFwAA + AAUAAAAFAAAAGw0Nk9sNDZj/BQVjgQAAADQAAAASAAAABwgIm1MODpr/CgqCqwAAAEwAAAAqAAAACwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARIS + lB0jI53/FRWV/wcHm/8GBqX/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgal/wYGnf8GBpH/CQmN/wwM + j/kAABmGAAAAVAAAACkAAAANAAAADAUFfk8NDZj/Dg6W9QAAAE4AAAAoAAAACwAAAAUICJtTDQ2Z/wsL + hLcAAABVAAAAMAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAFISGhrSEhmf8KCpL/Bgad/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqX/Bgad/wcHkf8KCpD/CgpzzgAAAGwAAAA9/////wAAABcMDJOlDQ2X/wsLh8IAAABBAAAAHAAA + AAYAAAAECAiZUw0NmP8MDIzYAAAAXwAAADsAAAAVAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARkZsC0mJp3zGxuV/wYGkv8GBqH/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpf8HB5v/CAiP/wwMk/8CAjCOAAAAUQAAACkAAAAkDg6V5w0N + l/8FBWSAAAAAMwAAABIAAAACAAAAAwgIn1AMDJb/DQ2X/wAAAGgAAABIAAAAHwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAELy+uhDAw + oP8bG5f/Bweb/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgah/wcHkv8KCpD/Cgp1zAAA + AGEAAAA3CAiIcg0NmP8NDZXqAAAASgAAACYAAAAKAAAAAAAAAAEICKlMDQ2V/wwMlP8GBmSXAAAAVgAA + AC0AAAAOAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAc5Oaq0OTmk/yMjnf8HB5v/Bgah/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + pf8HB5v/CQmQ/wsLh+oAAABrAAAAQgoKjp0NDZj/CgqBrAAAAEAAAAAdAAAABQAAAAAAAAABAwOfGA0N + l/EMDJP/CwuDxAAAAF4AAAA+AAAAGwAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS2zHEVFrd1ERKj/NDSi/w0Nlf8GBp3/Bgal/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgaf/wgIkP8TE5b/AAAAcwAAAEwNDZXQDQ2Z/wICP28AAAA+AAAAGwAA + AAQAAAAAAAAAAAAAAAMMDKZrDAyW/w0Nl/8CAj1wAAAATQAAACwAAAAPAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAACQAA + AAoAAAAHAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIrK60dTk6y309P + rP9FRaf/JSWe/woKnP8GBqH/Bgal/wYGp/8GBqf/Bgan/wYGn/8ODpP/Jyed/w8PSpYAAABZDQ2Q1A0N + mP8BASBtAAAARgAAAB8AAAAGAAAAAAAAAAAAAAABAAAABg0NnqgNDZj/DAyLvgAAAFgAAAA/AAAAHwAA + AAgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAADAAAABcAAAAdAAAAGgAAABAAAAAIAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAhQULatWVmy/1RUrv9LS6z/LCyi/xsbo/8VFaf/FBSq/xcXrf8qKq7/Nzen/zc3 + o/8GBhyKAAAAbQsLh9oNDZX/BgZgngAAAFcAAAAsAAAADgAAAAEAAAAAAAAAAAAAAAMAAAAMDg6Y1g0N + mf8FBV+GAAAAUwAAADEAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBciAAAAAlAAAAMgAAADIAAAAoAAAAHAAAABIAAAAKAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABUJCu2xfX7bsYGC1/1xcsf9XV7H/U1Oz/1BQ + t/9NTbj/SUm1/0VFrv8eHpn/BwdWswkJZsEJCWjKCwuQ/wsLetIAAABtAAAARAAAACIAAAAQAAAADQAA + ABAAAAAUAAAAGwcHgWINDZf/DQ2Q4gAAAGQAAABDAAAAHAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODrLDDg6o4wYGgmYAAAA9AAAAOwAA + ADMAAAAqAAAAIAAAABcAAAAOAAAACAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACFBQ + vIJoaLrQZ2e5/2Njt/9gYLf/XV22/1hYtP8mJp3/CQmH7QkJh+8KCpL/CQmJ+QoKjv8MDIz4AAAAhAAA + AGQAAABEAAAAMAAAACwAAAAxAAAAOQAAAEAAAABNCwuO6w0Nlf8HB22iAAAASQAAACAAAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAS/Jw0N + rKcODqP/DQ2gywcHh3YAAAA9AAAAPQAAADgAAAAxAAAAKAAAAB8AAAAVAAAADgAAAAcAAAADAAAAAQAA + AAAAAAAAAAAAAQAAAAQAAAAKAAAAFR8fYjc6Opd1NzeNfDc3iX8qKn98CwuBuwoKdsMICJn/CAie/wcH + mf8ICIf5CgqM/woKeN8BAS2TAAAAbwAAAGAAAABeAAAAZQQEWJAFBVSTBgZNlAsLhOUMDJP/DAyOzQAA + AD4AAAAbAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAFBASqKwwMqZoODqLxDg6h5QkJlI4CAlFWAAAARAAAAEIAAAA9AAAANAAA + ACoAAAAgAAAAFgAAAA4AAAAKAAAACQAAAA0AAAAVAAAAIAAAACwAAAA5AAAARAAAAEwAAABPAAAAUDQ0 + jKsYGJr/CAie/xMTqv8bG6n/BgaU/wgIjv8KCo7/CwuL+QYGTLMLC3jSDAyQ9wwMk/8MDJL/DAyR/wsL + kf8LC5H/DQ2W/woKkKAAAAAmAAAADwAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAFAgKOGwwMq4oODqLjDg6g/w0N + msEICIOKAQEoVwAAAE4AAABKAAAAQwAAADgAAAAtAAAAJgAAACUAAAAsAAAAOAAAAEYBASVcCAh2lwoK + f64MDIzMCgp9rgYGWIgPDyx1W1us7V5evv8zM7X/Bgal/wYGof8HB5v/BweS/wgIkP8KCpD/CQmO/wkJ + jf8KCo3/CwuP/wsLkP8MDJP/DQ2V5woKjn8AAAAfAAAAEAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAAEAAAACgsLrGwODqDjDg6d/w4OnP8MDJLGCAh5kwEBJGIAAABXAAAAUQAAAEwAAABMAQEmWwgI + dZcMDIrMDQ2Y/w0Nl/8NDZf/DQ2X/wwMlv8MDJT/DAyN9QkJeNEHB4PfBwel/wYGp/8GBqf/Bgal/wYG + of8HB5//BweZ/wcHjv8KCov/CwuQ/wwMh9cLC4aiBwd7aAAAACoAAAAeAAAAEgAAAAcAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACAgIqk0NDZ3HDQ2b/w0Nmf8NDZn/DAyMyggI + cZkGBmaRCwuGww0NlfUNDZf/DQ2W/w0NmP8NDZXaCgqKfwoKkXkNDZa8DQ2W8gwMk/8KCpD/CAiS/wcH + nf8GBqX/Bgan/wYGp/8GBqf/Bgan/wcHn/8HB5D/BgZEtwAAAH4AAABgAAAASQAAAD0AAAA2AAAALgAA + ACIAAAAVAAAACgAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAABgAA + AAcAAAAHAAAABQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABwUF + ny0NDZ6qDQ2Y8g0NmP8NDZf/DQ2X/w0Nl/8NDZj/DQ2W2goKkIsEBHE/AAAAGQAAABAAAAALAAAACgAA + AA0LC6FeFhaUvRAQkf8ICJP/Bweh/wYGp/8GBqf/Bgan/wYGp/8HB5//BweP/wsLh/kDAzeiAAAAegAA + AGsAAABiAAAAWQAAAFAAAABEAAAANAAAACMAAAASAAAABwAAAAIAAAABAAAAAwAAAAUAAAAIAAAADAAA + ABAAAAAUAAAAGQAAAB4AAAAgAAAAHAAAABQAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAABQICjRsLC6RtDg6b1Q0NmsoLC5aGBARzPgAAABgAAAAQAAAACAAA + AAQAAAABAAAAAAAAAAAAAAAAAAAAAx8fkiA0NKL0GBiY/wkJoP8GBqf/Bgan/wYGp/8GBqf/Bgah/wcH + kv8JCYz/CwuJ+QsLfeUMDJD4DQ2Z/w0NkeMJCYKuAAAkYQAAAFEAAABDAAAAMAAAAB4AAAAVAAAAFAAA + ABcAAAAdAAAAJAAAACoAAAAxAAAANQAAADoAAAA9AAAAPAAAADMAAAAjAAAAEAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAcAAAAKAAAACgAA + AAgAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGLi6ZUj4+pvYuLqj/EhKj/wYG + n/8GBqH/Bgal/wYGpf8HB53/BgaS/wcHj/8JCY//CwuQ/wwMjvcMDJDsDQ2Z/w4OmPQICHaWAAAAWQAA + AE8AAABAAAAANwAAADYAAAA5AAAAQAAAAEcAAABNAAAAUgUFZ30GBnKICgqKpwoKkKQICJmQAAAAJgAA + ABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACAAAAAsAAAANAAAADgAAAA4AAAAOAAAADgAA + AA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAANAAAADAAAAAgAAAAEAAAAAQAAAAAAAAAAAAAABwEB + Ti0WFpHpNzek/zw8pv8fH5r/BgaT/wYGnf8GBqX/Bgal/wYGof8HB5//BweZ/wkJhPMBAReKAAAAYAsL + h6MNDZn/DQ2Z/wwMkNYCAjxyAAAAWgAAAFYCAkBrBQVjgAoKgqsMDI3LDQ2W6g0Nm/8NDZv/Dg6c/w4O + nv8ODqLlCgqqkwAAABcAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACgAAABcAAAAjAAAAKwAA + AC4AAAAuAAAALgAAAC4AAAAuAAAALgAAAC4AAAAuAAAALgAAAC4AAAAuAAAALQAAACoAAAAiAAAAFQAA + AAoAAAADAAAAAAAAAAoKCpJ3CwuQ/woKjP8uLo3hSEio/yoqm/8JCZP/Bgah/wYGp/8GBqf/Bgan/wgI + n/8JCZL/CAhhvQAAAG0AAABVBARWcA0Ni9UNDZf/DQ2V9Q0NjtUNDZr/DQ2a/w0Nmf8NDZn/DQ2Z/w4O + mv8NDZjZDAyWpAoKmXgDA3o7AAAAFwAAABAAAAAJAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAA + ABIAAAAnAAAAPAAAAEoAAABRAAAAVAAAAFYAAABXAAAAVgAAAFUAAABUAAAAUwAAAFMAAABTAAAAUwAA + AFMAAABRAAAASAAAADYAAAAhAAAADgAAAAUAAAANDQ2VvQsLkP8LC5D/AAAAZj4+j5xSUq7/ODil/xMT + o/8GBqf/Bgan/wYGp/8HB5//CQmR/w4OfeUAAACGBQVQmQUFT5cAAABzCAhlpAwMkusNDZr/Dg6Y8w0N + l80MDJWkCwuZhgcHklkAAAAbAAAAFAAAAA8AAAAKAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAQLC7WWDQ2hyQ0Nl88NDZHTDQ2O1QwMjdcMDIvYDAyM2AwMjNgMDI3XDAyO1wwM + jtYMDI7WDAyO1gwMjtYMDI/XCwuJxAAAIWkAAABUAAAAQAAAACgAAAAVAAAAFw0NkswMDJH/DAyI5AAA + AFkAAAA1R0efk11dtP9PT7X/Nzex/x0dqP8XF6f/ExOh/xgYl/8ZGX3oCgp+7AsLkP8LC5D/CwuH8QMD + O5sAAABsAAAATAAAACwAAAAYAAAADgAAAAoAAAAHAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCQnAZg4OpNMODpz/DQ2Z/w0Nl/8MDJb/DQ2V/w0N + lf8NDZb/DQ2X/w0NmP8NDZj/DQ2Y/w0NmP8NDZf/DAyW/w0Nlv8NDZf0BQVhgwAAAFUAAABGAAAAMwAA + ADENDY/QDAyS/wwMidoAAABQAAAALAcHgl8uLqD/YGC1/1pas/9NTa7/QUGq/zU1qP8pKaD/Dw+S/wcH + kP8HB5D/CAiP/woKjv8LC4z5AwM+mgAAAF4AAAAzAAAAFAAAAAUAAAAEAAAACAAAAAsAAAAKAAAABwAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAHAAAADggI + qU4ICJtTDQ2djgwMmZAMDJqRCwuXdggIklgICJVWCAiZVQgImlQICJlUCAiWVQwMmYENDZfJDQ2Y/w4O + mv8JCYGcAAAAVQAAAFIAAABUCwuG2AwMk/8KCni0AAAARgAAACULC5WGDAyU/yAghcdaWqniZma3/1pa + sf9LS67/Hx+Z8gcHn/8HB5//Bgaf/wcHm/8HB5H/CQmO/wsLhusAAAB5AAAATwAAACgAAAAVAAAAFQAA + AB4AAAAkAAAAIwAAABcAAAALAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAUAAAAHAAAACAAAAAgAAAAHAAAABQAAAAUAAAAFAAAABQAA + AAUAAAAGAAAACgkJp00ODpvVDg6a/w0NktEHB2eMBgZRjQsLie0MDJP/CAhzmQAAADcAAAAbCwuckQ0N + l/8GBlyBAAAATSMjZ140NIWIDw+G4wgIn/8HB6f/Bgan/wYGp/8GBqX/Bweb/wgIjv8LC4//CQluxgAA + AGsAAABGAAAAMQAAAC8AAAA5AAAAQQAAAD8AAAAxAAAAGwAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwOYGQ0NoKgNDZn/DAyU/wsLkf8LC5D/DQ2X/wIC + T1sAAAAjAAAAEAwMo4wNDZn/BwdtiAAAAE4AAAA/DAyHtwkJkf8HB5//Bgan/wYGp/8GBqf/Bgan/wYG + of8GBpP/CQmM/wsLjfkAAACBAAAAYgEBKFcJCY2UDg6f5w4On/QDA15sAAAARAAAAC4AAAAUAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAGCwurWw4O + mPENDZX/DQ2X/wwMlqYAAAAjAAAAEAAAAAcGBq08DQ2b/w0Nk9IAAABVAAAATRYWmf8LC5L/Bwef/wYG + p/8GBqf/Bgan/wYGp/8GBqX/Bgab/wgIjv8KCo3/BwdXtgoKeLYODp70Dg6e5woKkYsNDZrZDg6f8wEB + K1MAAAA+AAAAIwAAAAwAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMDA58YCAiuTAYGoEEAAAATAAAADAAAAAUAAAABAAAABw0NncYODpr/BQVhfwAA + AFc2NqP2MTGh/x4eo/8SEqX/Cgqm/wYGp/8GBqf/Bgan/wYGn/8GBo//CQmL/wwMkv8ODpj1CgqSnwEB + SzIAAAAXBASJNA4OnPIKCpGfAAAARwAAADMAAAAXAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAEAAAAAAAAAAAAA + AAIICKtMDg6a/w0Nj9IAAABZNzeXvUNDqP88PKX/OTmn/zU1rv8rK7L/IyOx/x4erf8WFqH/GxuW/x4e + lf8XF4jUAQEvUAAAACIAAAANAAAABQAAAAYMDKWLDg6f/wICS14AAABAAAAAJQAAAAwAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACA0NmsgNDZn/BgZeghAQNV1OTq3kUVGt/0tLqf9HR6v/RESy/z8/ + tP87O6//ODil/zU1oP81NaT/Dw9QZwAAACcAAAANAAAAAgAAAAAAAAABAgKNGw4On/8LC5OsAAAASQAA + ADMAAAAWAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUICJhVDQ2Z/wwMicAAAABMGhoaNVFR + s7NfX7X/Wlqx/1RUsP9RUa//Tk6s/0xMqv9KSqz/ODifuwAAACwAAAASAAAABQAAAAAAAAAAAAAAAAAA + AAUNDaGpDg6c8gEBK1IAAAA7AAAAHgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAQFUKg0N + mf8NDZLVAAAASAAAACYAAAAOU1PCT1tbs85oaLf/ZGS0/2FhtP9cXLP4RUWnrwAAACMAAAARAAAABgAA + AAEAAAAAAAAAAAAAAAAAAAACBgatPA4On/8LC5ScAAAANgAAAB8AAAAKAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACAcHkFkNDZr/DAyNvwAAAEAAAAAfAAAABwAAAAUAAAAYFRV/eCMjnv8kJIejAAAANwAA + ABsAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcODqfEDg6l8QAAACQAAAAVAAAACAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLC5iUDg6a/wgIfJEAAAA2AAAAFgAAAAMAAAAKAAAAIA0N + ls4NDZjoAAAAOgAAAB4AAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBAS/JwsL + uIcAAAAQAAAACgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAQDQ2avQ4OnP8BAS1TAAAALAAA + AA4AAAADAAAAEQkJk3wODp//BQVvdgAAADAAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADAAAAAwAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAFQ4O + nOUNDZfRAAAAPQAAACEAAAAIAAAAAwEBZiMODp7lDQ2V0gAAAEsAAAAxAAAAFQAAAAYAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABQEBVykODp//CgqKlgAAADMAAAAYAAAABAAAAAMKCrFqDg6d/wcHdX8AAABMAAAAPgAA + ACoAAAAZAAAADgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoICJtmDg6g/wICU1YAAAAoAAAAEAAAAAEAAAABCAi/Rw4O + nvENDZe/AgJLWwAAAEkAAABDAAAANwAAACgAAAAYAAAADAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAQDAyfoQ0NntoAAAA1AAAAHgAA + AAgAAAAAAAAAAAAAAAMHB7Q6Dg6g4g4Onv8MDJa2AgJIYAAAAEsAAABDAAAAMwAAACEAAAAQAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAFw4O + oeUJCZOPAAAAKgAAABQAAAADAAAAAAAAAAAAAAAAAAAAAwICoBgMDKiKDg6e/w4Onv8MDJS5AgJJYAAA + AEQAAAAyAAAAGwAAAAoAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABwUFmkMODqPyAQFAPAAAAB8AAAAMAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQUF + rCoNDaKpDg6e/w4On/IJCZSQAAAAMwAAAB8AAAANAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMDK+YDAyorAAAACAAAAATAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAABQQEpCwNDaapDg6n/woKsIAAAAAUAAAACAAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDg6y0QMDmDEAAAAQAAAACAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAkAAAAKAAAACAAA + AAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQE + 0iQAAAAHAAAABQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /8B/////////wH/////////AP////////8A/////////4D/////////gHg///////+AeB///////8AwH + ///////wDAf///////gEB/////gD+AQH////4AD8BAf////gAHwAB////8AAHAAH////wAAOAAf////A + AAYAB////8AABgAH////wAADAAf////AAAAAB////8AAAAAH////wAAAAAf////gAAAAA////+AAAAAD + ////8AAABAH////wAAAEAf////gAAAYA//8H/AAABgB//wH+AAADAH//AD8AAAAAf/8AB8AAAAB//wAA + wAAAAH//AAAAAAAAf//AAAAAAAB///AAAAAAAP///AAAAAAAP4D/gAAAAAAAAP/gAOAAAAAA//gH8AAA + AAD4AAAwAAAAAPgAABAAAAAA+AAAAAAAAAP4AAAAAAAAf/gAAAAAAAAf+AAAAAAAAA//gAAAAAAAB/// + /gAAAAAH////AAAAAAP////AAAAAA////+DAAAAB/////+AAAgH/////4AAHAf/////gAAcB/////+AA + D4H/////4AA/gf/////AAH/B/////8AAP///////wAAP///////AAAP//////4DAAf//////gOAB//// + //+A8AH//////4H8Af//////gf8B//////+D////KAAAADAAAABgAAAAAQAgAAAAAACAJQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAh7AQICLzIAAAZNAAACDwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmXCw4Oq+wEBCacAAAAPgAA + AQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsL + sZMMDHPYAAAAcAAAAQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAsLsScODqb6AwMfnQAAADYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7G3Cwtk0wAAAGkAAAELAAAAAAAAAAAAAAAAAAAAAAIC + HggAAAA3AAABEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrNPDw+d+wICEZMAAAAqAAAAAAAA + AAAAAAAAAAAAAAsLiIIFBS2jAAAAOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7EFDAyv4QoK + T8oAAABcAAABBgAAAAAAAAAAAAAAAA4OpbYNDVvZAAAAUQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAACgqyhRAQjPQAAAeJAAABHgAAAAAAAAAAAAAAAAwMqcIPD2/pAAAAWgAAAQMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQoLAAABKQAAAEIAAABKAAAAPAAAABwAAAAFAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAACgq1JA4Opf4HBzi8AAAASgAAAAIAAAAAAAAAAAsLqcoQEHTuAAAAXAAA + AgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEIRUGBjKHDAxMzRAQVN8QEEbaCgonvgEB + BI0AAABXAAAAGgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAoKtMQPD3XpAAABegAAABEAAAAAAAAAAAsL + qc8QEHTtAAAAWAAAAgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBB1BBISgboODpD+Dw+L/xAQ + iP4SEn/+FhZw/hcXWvQKCiK+AAAAewAAAC0AAAADAAAAAAAAAAAAAAAAAAAAAAoKtmgQEJn+BAQfqQAA + ADQAAAAAAAAAAAoKrdEPD3HpAAAAUQAAAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBitRhMT + sP8HB6b/Bwei/wgIoP8JCZz/DQ2R/xMTf/8YGGj+ERE62AAAAYgAAAAyAAAAAwAAAAAAAAAAAAAAAAoK + sxYMDKn2DAxU2AAAAF8AAA0GAAAAAAkJtNsNDWniAAAASQAABAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAGxvIbBERu/8FBa7+Bgan/wYGpv4GBqb+Bwej/goKmv8REYf+GBhs/hMTP94AAAKIAAAAKwAA + AAEAAAAAAAAAAAAAAAALC6uxEhKC+QAAA2wAAA8IAAAAAAoKs9sMDF/aAAAAQQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAGRnLVhYWwP8FBbH+Bgao/wUFpv4FBab+Bgam/gYGpP8KCpz+EBCJ/hgY + bP8QEDbVAAAAeAAAABcAAAAAAAAAAAAAAAAKCpmjERGC9gAAAU4BARUCAAAAAAoKs9sLC1nUAAAAQAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRnLFhoaxvsICLf+BQWr/wUFp/4FBab+BQWm/gYG + pv8GBqX+Cgqc/hERhf8ZGWb+CQkeugAAAFQCAgIGAAAAAAoKhQ4LC5ruDAxc0QAABSgAAAAAAAAAAAoK + stsMDFnXAAAASwAAAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZzqcTE8D/BQWx/wYG + qP8GBqf/Bgan/wYGp/8GBqb/Bgak/wsLmP8UFH3/GBhZ9AEBBI4GBgcoCAg5AwgIhF0ODpX/BgYukwEB + DQ0AAAAAAAAAAAoKsdcODmXlAAAAZAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsb + 0CYcHMn0DQ28/wUFrv4FBaj+BQWm/gYGp/8FBab+Bgam/gcHov8ODpD+Fxdu/gwMLMYAAABOBAQ4AwkJ + m7oPD4T0AAAGSwEBEQIAAAAAAAAAAAoKr88SEoD4AAAEhwAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAlJdNuJyfJ/hAQuv4FBa3+BQWo/gYGp/8FBab+BQWm/gYGpf8KCpv+ExN+/hUV + VO0AAABwAwM6GAsLo/oKClTDAQEJHwAAAAAAAAAAAAAAAAgIu7cQEJj+BgYntAAAAD8AAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKtEBMzPUljU1zP8cHL7/Bgau/wUFqf8GBqf/Bgan/wYG + pv8ICKH/Dw+L/xoabv0DAwuFBARJSA0Nmv4EBCCTAAAIEgAAAAAAAAAAAAAAAAgIvTYLC6/2Dg5q4QAA + AHcAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANzfTAkBA15NERND+NDTG/hUV + tv8GBqz+BQWo/gYGp/8HB6T+FRWV/iwsgP4FBQ+SBAQ8YxAQjf4DAxadAAABJAAAAAAAAAAAAAAAAAAA + AAAJCbpnDw+h/QUFKKsAAABLAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBERUAAABCAAAAHQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEND + 1gFJSdhgUFDV701Nz/9CQsj+MjK//i0tu/8zM7r+PDyx/jY2kf4HByeyBAQmmRMTfP8LCzDEAAAARwAA + AAIAAAAAAAAAAAAAAAAAAAAACwumrhAQduoAAAOIAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJk6oGBkikAAAEcQAAAEsAAAAeAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAUFDXFlNT1YpYWNXlV1fR/lNTzf9PT8r/QUG//xMTnPoMDHrvDAyA+RIS + ev4TE03mAAAAgAAAAC4AAAIHAAABDQAAAxoAAAwgBAQ9WxISh/8KCjbGAAAASAAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJqD4LC6+2DAyU3wYGR6IAAApyAAAAWQAA + ADIAAAASAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLnoHKChsMyQkVVghIVVUEBBzYAgI + qucICKf+Cgqf/hAQiPoWFmz9Dw841QEBBpIBAQZiBQUeigYGKKgGBjOxBQVBvBAQiP4QEGbaAAACMAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqmLwsL + rKANDaPqCQlmwgQEJ5cAAAF1AAAAVQAAAC4AAAASAAAABAAAAAAAAAAAAQELBAQEDxYBAQQ5AQEQbQMD + GY8BAQqGAwMKczY2rPckJLD+ICCv/goKnf8PD4n+FBR1/hERWuwREXD2ERGC/g8Piv8MDJX+Cgqa/w0N + mPIHB0NcBQUqBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCqgbCgquiAwMru0NDZDtCQlWygQEIqUAAAJ+AAAAWAAAATEAAAIyAgIRZQgI + RLANDXjoDw+R/g4Olf8NDZj+CAiA6xAQbNoXF47wBgam/wYGpf8JCZ//CwuX/wwMkf8MDI3/CgqO/gkJ + lu0ICJm6BweCcgUFVBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKrw8KCrRuCwuz2g4Oov4PD4TxCgpR0QYG + O7wLC2vdDg6R/AwMm/4KCprXCQmPgQkJm1sICLSaBga44gUFsv8EBK7+BQWt/gYGqP8GBqb+Bwek/ggI + nv8LC4T8BQUmtwAABloBARQeAQEVIQAADx8AAAsOAAACAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqyBAkJ + t08JCba5Cgqt/QsLpv4KCqHkCAiSkwgIiTkICIsEAAAAAAAAAAAAAAAABwe6BA0NxU8QEMH8BAS1/gUF + q/8FBaf+Bgam/ggIn/8PD4j+EhJk9AcHHrUICCWqCAgrsAQEGJoAAABzAAAAOgAAAAoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAgEAAAEFAAABCwAAABMAAAAaAAAFEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABwezHwgIqywICJgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAiIseTHh68/g4OsP8GBqn/Bgao/wcHo/8LC5b/EBCE/xISeP8TE3P+EhJ8+hISjP0NDWjdAgIUnAAA + AGIAAAAhAAABCwAAAhEAAAIeAAABMgAAAEoAAAZlAwMYgwQEJpoFBTOiAgIXQAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAMDJg1Fxez+yoqtP8WFrL+BQWw/gYGqv8HB6P+CQmd/gwMkv8ODm/0AgIQkgQE + RGINDZjfERGJ+AgIPcAAAAaHAgIQewUFJ5cICEK3Cwtf1A0NfOsPD5H6Dw+a/w8PnuYNDYuiBgZGHAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAEEwAAACYAAAAqAAAALQAAADAAAAAwAAAAMAAAADAAAAAwAAAALwAA + ACsAAAApAAAAIAAAAAkAAAAAAAAAAAAAAAAGBrOcBgak/gwMaM0zM6vgICC//gYGsf8GBqj+Bgak/gsL + l/8SEnv+BwcouAAAAEoBARBeCQlexRAQkP0ODo/5Dg6Y/Q0Nnv4LC6T7Cwun0wsLp58LC6ZoDAyiLQwM + mAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBXgeBQVLiQcHQ7gICEDACQlGxQkJRcYJCUXGCQlFxgkJ + RcYJCUbGCAg9wggIOr8ICDS5AgIRmQAAAGAAAAAZAAAGAQAAAAAGBrLLCwuZ/wMDIZITE0sqQUHI0jQ0 + wf8YGLL/DAyr/w4Onv8aGoX/FBRH1g0NVdkNDWjrBwcyxAICHZsFBVeMBwd9WgkJkjEKCqUIAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBqEvCQm2ugoKsvQLC6j+Cwul/gwM + o/8MDKL+DAyj/wwMo/4MDKP+DAyj/g0Nov8PD5v+EhKI+QcHMrcAAAByAAACKQICOQYICKHWEBCN/gIC + D3gKCjkJExOokkZGwv9ISMH+ODjB/isrt/8kJKL+EhKF/Q4Oif4QEIb+ExN2/wwMOtEAAAB2AQEXFgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJ + twsICLYoCQmvPAkJrD8JCas/CQmtNQkJry0JCbIlCQm1HAoKsiMLC61ICwuvrQ8PofwJCVPFAAAFhwAA + AF0KCoPoEhJ/+gAAAFkEBEIEBgawwAoKe903N3qsT0/K2zs7ueUWFqn5CAij/wgIof8KCpr/ERGG/xgY + af4ICB64AAAATAAAAwMAAAwCAAAEFAAAAC8AAAAaAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK + s1ALC7DrCwuU8wcHcN8MDIv6Dg5p2wAABy0AAAAABwe4ygYGV8sAAABSERFVEAMDmNQFBav+Bgao/wYG + pv4HB6T+CwuY/xQUe/4WFlPuAAABgQAAAigBARFRCAhIqAcHPa8AAABrAAABFQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAICLcjBgbBvgcHtv4LC6f5BgZEYwQEKQYAAAAACAi0mgwMiO0AAASEBwdIcAgI + tP8FBa/+Bgao/wUFpv4GBqb+CAih/w4Ojv4WFm/+BwclugkJUMENDZTpCgqAlRAQoOkFBTGfAAAATQAA + AQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABga/AgcHvSoHB54fAAAAAAAAAAAAAAAACQm0LwwM + qv0GBju5DQ08kSgovv8fH73/FRWw/w0Nqv8HB6f/Bgal/woKmv8REYX/ExN//AoKaaMGBlEgAAAAAAsL + qF8ODo3oAAAFfAAAARwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAkJt6ULC4rtAQEIgzExodA6Osr+NjbE/zIyu/4uLrb+KSmy/ycnqv4oKJj+CwsyiQQE + JwoAAAAAAAAAAAoKqgUMDLHXBwdAsQAAAE4AAAEDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKsSkMDKT6BAQxsAkJHD5ERMK0TEzR/khIyv5ERMP+QUG7/z8/ + sf4zM5DZBQUTIwAAAAAAAAAAAAAAAAAAAAALC7BpDg6L6AAAAXgAAAEXAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqQYNDaPrCAhHvAUFESAnJ24CSkrFUFNT + zrxWVsb7UlK29T4+k6kiIl0jGxtOAQAAAAAAAAAAAAAAAAAAAAAKCrMODQ2x7AUFNqEAAAA1AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqiYODp3+BQUqlAIC + DA4AAAAAAAAAABYWbysJCaDzAgIeYBwcSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgq0eQkJ + iaUBARgSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK + qlcODpX6AQEKXQEBDAMAAAAACQlnAgkJgLYICF66AgITFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAYGgwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAsLqIsLC3LaAAAEMQAAAAAAAAAABweHSg0NlvcBAQ9dAQERBQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqMIGBkGjAQEOEwAAAAAAAAAACAi7ogkJds0AAAFzAAAAQQAA + ABMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqdCQ0NovIBARFcAQESBAAAAAAAAAAACAiyIgoK + t9ILC4DXBAQrngAAAHMAAABBAAAAEgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmQSAoKd9EAAAgoAAAAAAAA + AAAAAAAAAAAAAAkJrgoKCrOCDQ2s8wwMedwEBCafAAAAbwAAAC0AAAIDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmRnwQE + N4MBARYKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqzGwoKtpcODqn1CgprxwAACFIAAAMJAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAICK4QCQmiyQEBESEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrAdCgqieQUF + ThkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAICLAFBQWDKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//8P///wAA///wf/// + AAD///h///8AAP//+D7//wAA///8PH//AAD///w8f/8AAP///Bw//wAA//P+HD//AAD/wH4MP/8AAP+A + Hww//wAA/wAPDD//AAD/AAcEP/8AAP8AA4R//wAA/wADhH//AAD/AAEMP/8AAP+AAAw//wAA/4AADD// + AAD/wAAcH/8AAP/AABwf/wAAv+AAHg//AAAP8AAPD/8AAAP8AAAH/wAAAH8AAA//AADADAAAD/8AAPAA + AAA//wAA/AAAAA//AAD/AHAAB8AAAP/j/AAAAAAA///8AAAAAAD4ABwAAAMAAPAABAAAfwAA8AAAAAH/ + AAD8AAAAAAcAAP//wEAABwAA///gQAADAAD///HAAEMAAP///+AAwQAA////4AHhAAD////gAeEAAP// + /+GH8QAA////4Q/7AAD////jD/8AAP///+MD/wAA////wwD/AAD////HgH8AAP///8fgfwAA////j/j/ + AAD///+f//8AACgAAAAgAAAAQAAAAAEAIAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiaBgQEPm8AAAIvAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ2nxAEB + EHoAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAALC7FbCQlVxgAAAC4AAAAAAAAAAAAAAAAAAAcEAAABBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAoKtgYNDZ3hAAAHbgAAAAMAAAAAAAAAAAgIWG8AAABIAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLr4oICEC6AAAAIAAAAAAAAAAADw+e0AICEXcAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQELAQAA + AhYAAAAvAAAAKwAAAA4AAAAAAAAAAAAAAAAAAAAACgq2KA0Nhu4AAAFaAAAAAQAAAAANDaDaBAQdhgAA + AQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAHBzxbDQ1b1BERYOoQEEPZBQUUnQAAAEIAAAAFAAAAAAAAAAAAAAAADAysyAUFJqQAAAAQAAAAAA0N + od8EBB2CAAABAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAFhagIBAQqfoJCZ7/Cgqa/w4OjP8WFnH+Dg40zwAAAF0AAAAHAAAAAAAAAAAKCrNtDAxi3QAA + ADsAAAAADAyn5QMDGHUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAaGslGDg65/wUFqP8GBqb/Bgak/woKmf8UFHr/EBA71wAAAFYAAAADAAAAAAkJ + qBoQEI/8AAADSAAAAAAMDKfnAgIOZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZzBoUFMH9BQWs/wYGp/8GBqf/Bgam/woKm/8VFXf/DAwpwQAA + AC8AAAAACQmOQw0Nd+cAAAchAAAAAA0NpucBAQxqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoay64KCrf/BQWp/wYGp/8GBqf/Bgal/wwM + lf8XF2f6AgIJgAcHKgoKCo+jCAhFqgEBCwYAAAAADQ2k4gQEGY8AAAAGAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHx/RICIiyfAKCrT/BQWo/wYG + p/8GBqf/Bwei/xISg/8NDTLGAgIlIwwMm/ECAhZSAAAAAAAAAAAKCq/UCQlAxQAAACQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMjLTRDU1 + zPYWFrj/BQWq/wYGp/8GBqb/DQ2T/xcXVOIDAy9WDAx25wAABDIAAAAAAAAAAAgIvFMODovxAAAEaQAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRkAAAAcAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAARETWOExM1N87O8f/JSW6/yAgtf8tLaz/KChx7QMDH4kSEnH1AAAAWgAAAAAAAAAAAAAAAAoK + npEJCUTCAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmSqwUFOpsAAAJRAAAAIAAA + AAUAAAAAAAAAAAAAAAAAAAAATU3OCU1Nw21PT8S+Tk7B2jo6vNsNDZbsCwuK+xMTd/0HBxqqAAAAOgAA + ASAAAAM6AgIjXxMTffoBAQpnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrAFCwuqXwsL + lrgHB0+wAQESdQAAAEMAAAAaAAAABAAAAAAICBkCDQ0lFAgIGkMBAQ9qAwMRWiMjrvsZGaz/DQ2T/hUV + cf0MDELSDg5k4w4Oe/QKCor2DQ2G4QQEJSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAACgqyAQoKrkgMDK25Cwt84QcHQLsCAg9+AAAGUQUFMYgKCmjUDQ2V9wwMm+4JCZX2EBCE6AgI + pv8GBqX/CQmc/wsLk/8JCXTsBgZspgUFalsEBD8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrUuCgqymwwMpfMMDJn4CgqWxQkJkmwICIkVCAiiAgYG + ujgMDMGwBga2/wUFqf8GBqb/CgqZ/w4OXusEBBWVBQUchwEBC3AAAAA0AAAABQAAAAAAAAAAAAAAAAAA + AQEAAAAGAAAADgAAAg0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgaPDQYGihQAAAAAAAAAAAAA + AAAAAAAAAAAAABYWvxEfH7PdEhKw/wUFqv8ICKL/DQ2P/xERff8ODl7fDw+F5AkJSMUAAANnAAAAJwAA + ATABAQtSBAQlgQcHPacJCU+9BQU2aAAAAAAAAAAAAAAAAAAACgkAAAAaAAAAHQAAACAAAAQgAAAEIAAA + ACAAAAAcAAAAFwAAAAQAAAAACgqrDQYGqPQeHovbHh67/gYGrf8HB6T/DQ2P/wkJOscBARRJCQljxQ4O + eesKCmzdDAyJ8A0Nn+kMDKK2DAyifQwMlj0KCnEDAAAAAAAAAAAAAAAABgZ9mAkJY9EKCmHXCwth2AsL + YdkLC2HZCgpd1wsLV9MJCT2/AAACYwAABA4EBH40Cwue/wICFGYuLqqGNzfA/xsbsv8XF5//GBhn7A4O + auoMDFPfAwMmnwUFVU4ICIoZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLcaCAi4XAkJ + sXoJCax/CQmsegkJr3IJCbJpCgqucQwMqbUMDHXfAQEOgAICMm8QEIr9AQEPRAcHk3klJYrbSEi93zEx + tvINDZ/9Cgqb/xAQh/8SEk7lAAACWAAADQEAAAgJAAAAHQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKs1QKCqfrCAiK7w0NcdcCAiEWBwefgQUF + QbcICDYxBASk6wUFqf8GBqb/CQmd/xUVeP8ICB6sAgIXVwkJXLUICEKyAAAAOQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGwR0HB7dyBwdwKAAA + AAAICKwyCwuI6ggILI0cHLz/ERGw/wkJqP8GBqX/DQ2S/xERbvMLC3CnCAhxIw0NpawDAx2JAAABDgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCrCtBQU1rC8vlsE9Pcn/Nze+/zAwtv8tLaf/FBRLnAUFLAQAAAAACgqyKwoK + cNMAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKrFAKCmDSDg4sHEdHvXNSUszfUFC8+js7la4XF0MTAAAAAAAA + AAAAAAAADAyutwICGX0AAAEGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwupdggIR64DAw4HAAAAAA4Of4UEBDx8GhpDAQAA + AAAAAAAAAAAAAAAAAAAKCrA1BgZpUAAAEQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKSpAwMhagAAAAAGBngiCgp51wAA + DRkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLks8AAAsnAAAAAAgI + tlcICGrGAAAFYgAAACMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCZYjBwdZrwEB + DggAAAAAAAAAAAkJs1oMDJnXBwdDtAAAA2EAAAEWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJ + m3gCAiFKAAAAAAAAAAAAAAAAAAAAAAoKtwwLC7J5DAyS0QEBFzQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAABgaTRAMDPQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCaYBAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA//j////8f////HP///wz///+Mf/8HhH//AcR//gDE//4ARP/+AET//wAEf/8ADH//gAw/x8A + OP8HgAD/AIAA/8AAAf/4AABw/nwAAOAEAADgAAAf4AAAA//wAAP/+IAB///AEf//wDj//8R4///I//// + yD///4wf//+eH///n78oAAAAEAAAACAAAAABACAAAAAAAEAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABARTAQUFPncAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC5aCAAACKAAAAAACAhgwAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAMFAAAAFgAAAAMAAAAACAicLAUFMogAAAAACQlbqgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCkwICwt3yg4OcvAKCi6rAAAAGgAAAAAKCnquAgI0EwgIX68AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAADw+AGAsLtP4GBqb/DAyV/wwMN7sCAhcMDAyPkAICNhoHB1qnAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGcevBwer/wYGpv8PD4j9BgYiXQgIYaQDA0kBCQlrwwAA + AAoAAAAAAAAAAAAAAAAAAAAAAAACDQAAAAAAAAAAJyenETc3y8MbG7T/GBim/xERRasHBzuaAAAAAAkJ + lXUCAhJYAAAAAAAAAAAAAAAAAAAAAAgIimsEBDp2AAAELwMDCwcmJmsDLCxyYCMjZ54VFZ74Dw9l6QYG + KoQGBkuhCQlNmgAAAAAAAAAAAAAAAAAAAAAAAAAABweNEgoKp3IICGqyBwdZpgoKhpMJCaOHCgqo5QcH + pP8LC4D1BQVChwICGywAAAABAAAAAAAAAAIAAAAGAAAAAAAADwIBASMOAgJDEwMDPxUBASINAgIzARER + sXwVFaj2CAih/w0NaekJCVGuBgY6lgYGTZcJCWmWCQljWQAAAAAGBposCQmLoAoKhqsKCoiiCwt7rgMD + InQICHaoDg5YajAwru4bG5f2DQ148gYGM4sEBEwJAwM5CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAICLVXCQmJmAUFazIICEuYDg6u+ggIpP8PD2XnBwdVdgYGQYgAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAACQl9nzAwkpRCQr/2JSVzlwMDLwELC6JtAAAGMQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJbo4JCUQKBwdRfAAAAAAAAAAABQV6DQMDShQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFWQkFBUFrBQV2FQcHb5YBARJPAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBpIvAQEbEwAAAAAFBXkDCgqpUwICJA0AAAAAAAAAAPx/ + AAD+XwAA4k8AAMEfAADAHwAA4A8AAGBPAAAADwAAgAQAAIAAAACAAQAA/AAAAP+AAAD/jAAA/wMAAP8j + AAA= + + + + AntMe! - Bändige deine Ameisen! + + \ No newline at end of file diff --git a/AntMe/Main.resx b/AntMe/Main.resx new file mode 100644 index 0000000..2cac64b --- /dev/null +++ b/AntMe/Main.resx @@ -0,0 +1,5074 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + System.Windows.Forms.StatusStrip, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + 153, 22 + + + 75, 22 + + + speed15fpmMenuItem + + + Magenta + + + Slower + + + germanMenuItem + + + 80 fps + + + About... + + + 3 + + + + TextBeforeImage + + + System.Windows.Forms.ToolStrip, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + speedDropDownToolItem + + + 57, 22 + + + + False + + + settingsMenuItem + + + Settings + + + 3 + + + 181, 22 + + + startToolItem + + + Magenta + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 924, 625 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 171, 22 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 178, 6 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + speedMaxToolItem + + + 2 fps + + + $this + + + 6, 25 + + + tabControl + + + speed30fpmToolItem + + + 3, 3 + + + Fill + + + Pause + + + AntMe.Gui.WebBrowserEx, AntMe, Version=1.7.0.325, Culture=neutral, PublicKeyToken=a423eba442ea5664 + + + 42, 22 + + + slowerToolItem + + + AntMe! - Rule your ants! + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + logoutButton + + + infoBoxMenuItem + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Stop + + + 153, 22 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Magenta + + + 171, 22 + + + speed80fpmMenuItem + + + [speed] + + + 100 fps + + + 0 + + + stopMenuItem + + + group1ToolItem + + + 0 + + + 153, 22 + + + System.Windows.Forms.ToolStripSeparator, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 15 fps (100%) + + + False + + + TextBeforeImage + + + Class-Description + + + MiddleLeft + + + 6, 13 + + + 153, 22 + + + 153, 22 + + + englishMenuItem + + + sourceLabelToolItem + + + System.Windows.Forms.ToolStripStatusLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.MenuStrip, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 116, 22 + + + 46, 22 + + + fpsBarItem + + + 0, 0 + + + Stop + + + languageMenuItem + + + System.Windows.Forms.Form, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 23, 22 + + + speed22fpmMenuItem + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 0 + + + System.Windows.Forms.ToolStripDropDownButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + profileButton + + + Online-Forum + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 3, 3, 3, 3 + + + speed15fpmToolItem + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Login with your AntMe! Online Account + + + 153, 22 + + + speed8fpmToolItem + + + 0, 49 + + + 2 fps + + + speed8fpmMenuItem + + + Exit + + + 910, 593 + + + Logout + + + 153, 22 + + + 153, 22 + + + Magenta + + + closeMenuItem + + + 153, 22 + + + 153, 22 + + + 164, 22 + + + 181, 22 + + + System.Windows.Forms.ToolStripComboBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 932, 723 + + + False + + + 153, 22 + + + 181, 22 + + + Speed + + + 153, 22 + + + welcomeTab + + + System.Windows.Forms.ToolStripStatusLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + 22,5 fps (150%) + + + False + + + 8 fps + + + statusStrip + + + 78, 17 + + + Plugins... + + + CenterScreen + + + 2 + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + speed22fpmToolItem + + + welcomeTab + + + 30 fps (200%) + + + 6, 25 + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + New Version + + + 93, 22 + + + 65, 20 + + + Speedsettings + + + AntMe! Website + + + Account Settings + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 164, 22 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + speedMaxMenuItem + + + classDescriptionMenuItem + + + 23, 22 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + AntMe! Tutorials + + + Source: + + + 23, 22 + + + helpMenuItem + + + System.Windows.Forms.ToolStripSeparator, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 105, 22 + + + fasterToolItem + + + 105, 22 + + + German + + + speed30fpmMenuItem + + + 50 fps + + + Start + + + 23, 22 + + + + AAABABAAgIAAAAEACAAoTAAABgEAAEBAAAABAAgAKBYAAC5NAAAwMAAAAQAIAKgOAABWYwAAICAAAAEA + CACoCAAA/nEAABAQAAABAAgAaAUAAKZ6AACAgAAAAQAYACjIAAAOgAAAQEAAAAEAGAAoMgAANkgBADAw + AAABABgAqBwAAF56AQAgIAAAAQAYAKgMAAAGlwEAEBAAAAEAGABoAwAArqMBAAAAAAABACAAHHoAABan + AQCAgAAAAQAgACgIAQAyIQIAQEAAAAEAIAAoQgAAWikDADAwAAABACAAqCUAAIJrAwAgIAAAAQAgAKgQ + AAAqkQMAEBAAAAEAIABoBAAA0qEDACgAAACAAAAAAAEAAAEACAAAAAAAAEAAAAAAAAAAAAAAAAEAAAAB + AAAAAAAAPz9fABkZZQAWFm0AGBhqAA8PegAUFHMAHBxzABISewAfH3oAISFjACoqYgAtLW0ANDRjAD4+ + YAAyMmoAOztsACYmcQArK3MAIiJ9ACwsewA0NHUAPDx0ADw8fABBQWQASUllAENDbQBMTG8AU1NnAFRU + bABcXGsARERzAEtLcwBHR30ATU1/AFZWcQBZWXIAVVV+AFpafwBmZmYAYGBpAGtrawBnZ3IAZ2d4AHJy + cgBycn8Ae3t7AA4OhAAODowAEhKDABkZhAAREYsAGhqLAA0NkwAGBp4ADAybABERkwAbG5IAEBCZABAQ + nQAWFp0AGxuaACQkhAAtLYIAIyOMACwsiwAyMoQAOzuFADMziwA7O4wAJCSSACsrkQAiIpsALCycADQ0 + lAA9PZIAMzOcADw8mwA4OJ8APj6dAAYGpgALC6IABgaqAAkJqQAMDKkACgqtAAwMrQAQEKEAFRWiABAQ + pQAVFaUAGhqkABAQqQAVFaoAFRWtABoaqwAFBbMACQmxAAwMsQAJCbUADAy0AAUFugAKCrkAEhKyABsb + swAUFLwAGRm5AB0duQAYGL0AHh69ACQkpAAoKKEALy+hACwspAAiIqsAKSmtADMzogA6OqQAMTGsADo6 + rAAjI7MAKyu0ACMjvAArK7sAMTG0ADo6tAAzM7sAOzu8AEJChwBKSoUARESLAElJiwBcXIIAU1OMAFxc + igBDQ5EATEyTAENDmwBOTpoAVFSTAFpakgBTU54AXFyYAGFhhQBra4UAYmKKAGxsiwB3d4MAeHiEAHFx + iAB+fooAY2OTAGtrkwBiYpsAbGyaAHNzlQB7e5IAdHSaAEFBpABKSqQAQUGsAEpKrABXV6QAW1uiAFVV + qQBZWawARESyAEpKtQBERLwAS0u7AFFRswBVVbwAXFy+AGdnoQBqaqEAZGSuAGtrqgB2dqEAcHClAH9/ + ogBycqwAe3uoAH5+qQB9fawAYWGxAGRksgBiYrUAa2u2AGNjvQBpabwAdXW1AHR0ugB9fbgAFBTAABsb + wwAcHMkAJCTDACsrwgAlJckALCzKADQ0wwA8PMIAMzPKADw8ygA8PNAAQ0PDAEtLxABDQ8sAS0vLAFRU + wwBcXMIAU1PMAFpaywBERNIAS0vRAFNT0QBbW9MAWlraAGJiwwBqasEAZGTKAG5uzQB2dsMAdHTLAHt7 + ygBgYNMAYWHVAGVl1gBoaNIAYmLaAGtr2QBzc9EAfHzSAHFx2gB2dtgAcHDdAHl52gBoaOEAcnLiAH19 + 4wCCgpkAgICjAICArQCAgLgAjY3JAJSUzwCEhNUAiIjVAICA2wCIiNkAgYHjAISE6ACQkOQAAAAAAAAA + AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFy6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrXFm3AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtkWXAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRZ + O7IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA4lxZTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAZFk7sgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKXFlOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRcO4kAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+lxcOwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7 + jQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAADXXFk5AAAAAAAAAAAAAAAAAAAAAAD2pwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABkXDuZAAAAAAAAAAAAAAAAAAAAAFw7TgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRcO0YAAAAAAAAAAAAAAAAAAAAAXDs4nAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA72RZOJkAAAAAAAAAAAAAAAAAAABcOziMAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7SgAAAAAAAAAAAAAAAAAAAFw7 + OIIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXXFk4mwAAAAAAAAAA + AAAAAAAAXFk4QgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTuH + AAAAAAAAAAAAAAAAAABcWThBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAGlcOzmWAAAAAAAAAAAAAAAAAGRZNTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAA62Q7OIsAAAAAAAAAAAAAAAAAXFk4NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7QAAAAAAAAAAAAAAAAOxhWTU0AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKXDs4lwAAAAAAAAAAAAAA7FxQODQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACbgRcSEgwSGiQsLC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTVFAAAAAAAAAAAAAADrZFk1NAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAACiMjExMQcGBgMDAwoQJCwuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRcOzSSAAAAAAAAAAAA + AOxcWTUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAPTQwMTExMTExBwYDAwMCDR4sLgAAAAAAAAAAAAAAAAAAAAAAAAAA12E7NYIA + AAAAAAAAAAAA7GFZNUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAHI7NTU0MDAxMTExMTEDAwMCAhgpLAAAAAAAAAAAAAAAAAAAAAAA + AAAAYVk7OS4AAAAAAAAAAADsYVk1QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+Wzs7NjU1OzU7NTU0LzExAwMCAgsdLC4AAAAAAAAA + AAAAAAAAAAAAAABpXDs0hQAAAAAAAAAAAOxhWTVBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+XhcUDY2NjY2Njs2OzYwNDExBwYDAgoZ + KS4AAAAAAAAAAAAAAAAAAAAAAOJkOzVBLgAAAAAAAAAA7GRZNUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQeGdcUlJZUFBQNjY2OzY7 + NTA0MQMDAgIYKS4AAAAAAAAAAAAAAAAAAAAAAGRZNTSQAAAAAAAAAADsXFI4QQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGtraVJhUlJQ + UFBQUFBQNjY7NjAwMQYDAgINKSwAAAAAAAAAAAAAAAAAAAAAxFk7MIAAAAAAAAAAAOtkWTWIAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + wmtpYWFSUlBQUFBQUFBQUDY7NjU0MTECAgINKS4AAAAAAAAAAAAAAAAAAADmWTs0MgAAAAAAAAAA7FxZ + NYgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADCwmlhZVJSUlBQUFBQUFBQUFA7NjUwMQYDAgINKS4AAAAAAAAAAAAAAAAAAABcNjQ0AAAA + AAAAAADsYVk1iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAMLCwmVhYVJSUFBQUFBQUFBQUDY2NjU1MTEDAgIZKQAAAAAAAAAAAAAAAAAA + AFk2MDAAAAAAAAAAAOxcXDWLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1cLCZWFhUlJSUFBQUFBQUFBQUFA7NjUwMQYDAgIcLAAAAAAA + AAAAAAAAAAAAWTswQAAAAAAAAAAA7GRZNZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiwsJmZWFhUlBQUFBQUFBQUFBQUFBQOzswMQYD + AgoeLAAAAAAAAAAAAAAAANFQNTRFAAAAAAAAAADsXFk1lwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDwsJlYWFSUlJQUFBQUFBQUFBQ + UFA2OzYwMQYDAgspLgAAAAAAAAAAAAAAXDs1MJcAAAAAAAAAAOxcWTWXAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfCwmZlYVJSUlBQ + UFBQUFBQUFBQUFA2OzU0MQYDAhgpAAAAAAAAAAAAAABZOzU0AAAAAAAAAAAA61xQNIIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7cPC + wWVhYVJSUlBQUFBQUFBQUFBQUFA2OzYxMQMCAh4uAAAAAP8AAAAAqFk1NUQAAAAAAAAAAADsXFk1gQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAw8PCZmVhYVJSUFBQUFBQUFBQUFBQUFA2NTUxMQMCDSkAAAAAAAAAAABcNjU4lwAAAAAAAAAA + AOxkWTVDLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADtw8LCZWVhUlJSUFBQUFBQUFBQUFBQUDY7NTAxBwMCHS4AAAAAAAAA6Fk7NTkA + AAAAAAAAAAAA7FxZND4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDw8LBZWFhUlJSUFBQUFBQUFBQUFBQUFA7NS8xAwILKQAAAAAA + AAB4WTswRQAAAAAAAAAAAADsYVk1MSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPvDwsJmZWFhUlJQUFBQUFBQUFBQUFBQUDY7MDEG + AwIdLgAAAAAAAFw2NTWdAAAAAAAAAAAAAO9hUjsxJS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbGxsJmZWFSUlJSUFBQUFBQUFBQ + UFBQNjY1NAUDAw0sAAAAAADcWTs1OQAAAAAAAAAAAAAA72ZcOzRDLAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfGx8RmZWFSUlJS + UFBQUFBQUFBQUFBQOzYwMQYDAyoAAAAAAHhZNjWLAAAAAAAAAAAAAAAAZWFZNTIsAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfH + x8dpYWVSUlJSUFBQUFBQUFBQUFA2OzUwMQMDGwAAAAAAXFA1OPAAAAAAAAAAAAAAAABlZVw7NCUuAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA7szKysfBYWFhUlJSUFBQUFBQUFBQUFA2OzAxBwMQLgAAAABZWTVKAAAAAAAAAAAAAAAAAOJm + YTs1RC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA5czMysrCZWFSUlJSUlBQUFBQUFBQUDY7MDExAxEuAAAA31k7NYwAAAAAAAAA + AAAAAAAAAMZlXDs4lwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2czMzMzHZGFhUlJSUlBQUFBQUFBQUDs1MAYGPywAAACsNjs4 + lgAAAAAAAAAAAAAAAAAAAGVkWThKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2dXPz8vLwmFhYVJSUlJQUFBQUFBQNjUwMRQ/ + LAAAAKA7NTkAAAAAAAAAAAAAAAAAAAAAAGFcWTiYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA79fVz8/PymlhYVJSUlJSUlBS + UFA7NjRBQUIsAAAAoDUwMZIAAAAAAAAAAAAAAAAAAAAA4mVZO0oAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+9fX19DXz8xr + ZmFhUlJSUlJSUFludEpERCwAAACiNTQvIi4AAAAAAAAAAAAAAAAAAAAAylxZOJkAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ANfW19fQ0NDPy8RrZ2dna3h+fX2gdUtFHS4AAIswLzEVLgAAAAAAAAAAAAAAAAAAAAAAaVk4OS4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAO/X19fX19PQztDQ0M7Oy6jOf32eTjISLC4AjzExBgYsAAAAAAAAAAAAAAAAAAAAAAD4 + WTs0gi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAADt2djX19fX09PQ0NDOz86oqaZGMRUgMTEkLzEGAx0uAAAAAAAAAAAA + AAAAAAAAAABbNTQxj5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mR5AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7eLi2NjX09jT09DTzs6pcjs1KzAvLzExMQYHDSkA + AAAAAAAAAAAAAAAAAAAAAKo7MDEVLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADX + ZWRcpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPri4uLY1NTU09PTzmdcUEo7NTU1 + MDAxMQMCKCwAAAAAAAAAAAAAAAAAAAAAtDA0MTGPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADHZGRcWaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/Pjq6t3f6vd/ + UlK+WVk2Ozs7NDAxAwMBJywAAAAAAAAAAAAAAAAAAACYNTAxMUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAz2RkXFm9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAqFxcUlJQNjY5MTExBAIKGSkuAAAAAAAAAI+PhISEhIA0NTQ0QQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9kXFxZqgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABrUFJSUlJZWVk4MDEGAwIDDSkpLiUXEzExBzExMDA1NTU1NTWfAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADPZGRcWaDAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKlfUmFhUmt2WTs1MDExAwMDDRkDBjEGMTExNDU1Ozs2Ozs7 + PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mRkXFlyugAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuqzOfn6of1lQNjs1MDExBgYGBjExMTExNDU1 + Ozs2Njs2WW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOJk + ZFxZWXWwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACXh0E4NDU4OUWFkC6TutrU0WtSUlBQNjs1NTAxMTEx + MTEvNTU2Njs2UFBZUl/dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADiZGRcWVk9n64AAAAAAAAAAAAAAAAAAAAAAJuHQDg4NTU1NTg4Ozs7OEuPk4ZSUlJSUFBQ + UDs7NTU1MDAwMDA1NTU2NlBZXNEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA4mRkXFlZOzmKnQAAAAAAAAAAAAAAAItANDU1ODU7OztZWVk2WVBZUFBZ + XGRhUlJSUFBQNjY2Ozs2NTU1MDAwNkam4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO1rYVxZWTs4RoiSAAAAAAAAjEQ4NDU1OzU7WVlQeVxS + UmRSUlJhYWRhYWFhUlJQUFBQUFA2Njs2NS8RFYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADvaWRcXFk7ODhHhZWGRDQ1ODU7OzY7 + WVB54AAAAADtyGZlZWVhZWVhZWFSUlJQUFBQUFBQNjswMAwnLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRhXFxZOzs1Ozg1 + OzU7OzZZUGvaAAAAAAAAAAAAAADXZWVmZWVhYWFSUlJQUFBQUFA2NjAvBQwpLAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADE + ZWFcXFlZWVk2WVBZXNEAAAAAAAAAAAAAAAAAAAAAAMZmZWVlYWFSUlBQUFBQUDs2MC8FBg0oLC4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA1WVhYWFSUlxn0QAAAAAAAAAAAAAAAAAAAAAAAAAA+8NmZWVhYVJSUlBQUFBQNjs2LwUG + Bg0cHSAfIYGBlwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAANnBZsTiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMbBZmFhUlJSUlBS + UFBQNjUwLzEGBgYGBjEGMTExMYecAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAx8fE + Z2ZhUlJSUlBQUDY7NjUwMTExMQYxBjEGMTE0NDSJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAfn5+xGdhUlJSUlJQUFA7NjU1MDExMTExBjExODU7NThAmAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACbmIiNh0pKdLsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADcfn5+xHhcYVJSUlJSUDZZNjs1NTU0LwwdkAAAbjs7Ozg0iAAAAAAAAAAAAAAA + AAAAAJyXiERGODg4ODg7O1lZbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRkeH5+eXhkYWFhUlJQUFA2Njs7NjAvLx0uAAAA31k7Ozg0OZcA + AAAAAAAAAJuMh0c5NDU4ODg7OztZO1lZc9sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADTUlJSXH19fnlkYWFhUlJSUFBQUDY1NTAxCiwAAAAA + AHY7NTU0NEScmJeIS0c4ODg4ODs7OztZWVlZWVx/3wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRhUlA7PaV9f35pYWVSUlJQUFA2OzY1 + MTExJAAAAAAAALo1ODUwNTg4ODg7NTU7OztZO1BZUFxczt8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYVJSNjaXANvOy37CYWFh + UlJQUFBQNTUvMQMQLgAAAAAAAABKNTU4Ozs7WTtZWVlSXFJSy9wAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtkUlk2NAAA + AN/Oy8vHZGFSUlJSUFA7NTAxBhApLgCSly4uLgCuRjU7WVlQXFJry98AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAK6Yl5ePl4+Pj4+Pj4+Xj4+Xj4+Xj5eQLpYAAAAAAAAAAAAAAAAAAAAA + zmFSUDtBAAAAAOzQzsvLxFxSUlJQUDY1MDEHFScaETExMRIkLC4At7q73wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhkXFk7ODg0MDQwNDQwNDg0NDA0NDA0NDA0MTQ0MTE0P5cuAAAA + AAAAAAAAAADMUlw2NYAAAAAAAOzT0M7Lf35rZ1xcXFlIR0AaDQYxBjEGMTEQKS4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVZmZkXFxZWTtZOzs7Ozs7Ozs7Ozs7NTs7NTs1OzU1 + ODQwMUUuAAAAAAAAAAAAAMtcUDswgQAAAAAAAMzU087Oy3/IfsRzcm5IRhMFBQUvLwUxAwYMKS4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6xmZlZFJcUlxSXFJcUlxSXFJZUFlQ + WVBZXFBZWVlZOzs4NEabAAAAAAAAAAAAf1k7NTCEAAAAAADqYczS09HOzst/fn55cm49ODAwMDAwMQUx + AwYNKS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO/PaWVhZWFhZWRh + YWFhYWFhYWFhZGFhYWFhUlJcXFk7ODmdAAAAAAAAAABzWTYwNI8AAAAAANBhYX7c0tHOzs7Lf35+czs7 + NTs1NTU1NAUGAwMQLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO3EXFJZOziiAAAAAAAAADs2MDQvAAAAAAAAxGFSWbLa3NTU + 0M6of6BwUFA2NlA7OzYwLzEGAwIdLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxGRcWTuJAAAAAAAANTUwMDIAAAAAAABh + YVJwAAD04NTU0dKmW1JZUFBQNlA2OzYwLwYDAwspAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7WRcWTs9jZwALi41MDA0 + PwAAAAAAAGVhUE4AAAAAAAAAv1JSUlJQUFBQUFA2OzUwMQYDAhksAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGlkXFk7 + Oz1HRjU1MDCIAAAAAAAAZVJZigAAAAAAAABSUlJSUlJSUFBQUFA2OzUwMQMCCiwAAAAAAAAAAACworMA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAANVlZFJZUFk2OzU1OAAAAAAAAABmZFmfAAAAAAAAUlJSUlJSUlBQUFBQUFA2OzAxBgMCGSwAAAAA + APJ1Ozs4OfEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAO9mYWFhUlxQOzt0AAAAAAAAAMpkWTsAAAAAANFhYWFhUlJSUFBQUFBQUFA7NjEx + BgMNKS4AAK1IO1k7Ozs7SgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGZWVlUlxSWwAAAAAAAAAA72RcO4oAAAAAX2FhYWFhUlJSUFBQ + UFBQUDY1NTExAwMeLIREODtZW9oAX1k7pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6wWVlZsQAAAAAAAAAAAAAZVxZOwAAAAB4a2lh + ZWFSUlJQUFBQUFBQUDs1MDEGBhAHNDU7WawAAAAAXFk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiZFk7 + jQAAAH15xMRraWRSUlJQUFBQUFBQNjs1MDExMTEwO6YAAAAAAADrXFl1AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABmXFk4AAAAu35+x37ExHhrXFxcUFBQUFBQNjU1LzExNHAAAAAAAAAAAABrXFm3AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAOJkXDuKAAAAf8t+yMjIfn5+xHJ4a19cXFlZPT1GRkCZAAAAAAAAAAAAAO9kWXQA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZSWTsAAADeqMvLy8jLyH5+fn55eXl5c3Nub0hG8AAAAAAAAAAA + AAAAAGtcO7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mRZO44AAADdzs/Pz8zLy39/f39+fn5+dnZ0Sk4A + AAAAAAAAAAAAAAAA72RZdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFJZOQAAAADr09DQ0M7PzsvLqH+o + fX2goHSgtAAAAAAAAAAAAAAAAAAAZFw7twAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYXFk7jAAAAAD819fX + 19DQ0M7Ozqiopn2moKYAAAAAAAAAAAAAAAAAAADYZFmeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcNjVL + AAAAAAAA4tnX19TT086pqampp6enAAAAAAAAAAAAAAAAAAAAAABkWTsAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAFxZO0cAAAAAAAAAAO3i2NTS0tLRrKurrAAAAAAAAAAAAAAAAAAAAAAAAM9kWaEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAUjs1hwAAAAAAAAAAAAD45tza0r3Su/UAAAAAAAAAAAAAAAAAAAAAAAAAAGRcWQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABcOzWOAAAAAAAAAAAAAAAAeV9yuAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAxGRkuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Fw7NZ0AAAAAAAAAAAAAAN9cWVsAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAZmTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+WTs4AAAAAAAAAAAAAAAAXFxQtwAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAADiws8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxQO4cAAAAAAAAAAAAAANJc + UHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFk1rQAAAAAA + AAAAAAAAXFk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABS + WTUAAAAAAAAAAAAAAH1ZNokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA1Fw7SAAAAAAAAAAAAAAAXDs4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB+WTuiAAAAAAAAAAAAAGdcO4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxSOwAAAAAAAAAAAAAAZFJZAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFk9AAAAAAAAAAAAAMpmXKcAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOpcWaEAAAAAAAAAAAAA7mZkeQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf1w7AAAAAAAAAAAAAAAA + ymZkWaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnWW8AAAAA + AAAAAAAAAAAA4mZkWVmhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFxZugAAAAAAAAAAAAAAAAAAAGtkXFk7nwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADcXFkAAAAAAAAAAAAAAAAAAAAAANdmZFlZO58AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAH5coAAAAAAAAAAAAAAAAAAAAAAAAADEZFxcWTuiAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxGRcWVk9sAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANxkXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA72tk + XFlZdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxFzaAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAO9rXFxcXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmawAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAADva2Rc0wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1WbqAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADCwQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP////////////////////////////////////////////////////////////////// + ///////////////////////////+P////////////////////h////////////////////4f//////// + ////////////D////////////////////w////////////////////+H////////////////////h/// + /////////////////8f////////////////////D////////////////////w/////////////////// + /+H////////////////////h//8/////////////////8P//H/////////////////D//w////////// + ///////wf/8P////////////////+H//D/////////////////g//w/////////////////8P/8P//// + /////////////B//D/////////////////wf/w/////////////////+H/4P/////////////////g/+ + D///////////8AD///8P/g///////////8AAP///B/4P//////////+AAA///wf+D///////////AAAH + //+D/g///////////gAAAf//g/4P//////////wAAAD//4H+D//////////8AAAAf//B/g////////// + /AAAAD//wf4P//////////wAAAAf/8H+D//////////8AAAAD//h/g///////////AAAAA//4f4P//// + //////wAAAAH/+H+D//////////8AAAAA//B/g///////////gAAAAH/wf4P//////////4AAAAB/8P+ + D//////////+AAAAAPeD/g///////////wAAAAD/g/4H//////////8AAAAAfwf+B///////////gAAA + AH8H/gf//////////4AAAAA/B/4D///////////AAAAAPg/+A///////////4AAAAD4P/wP///////// + //AAAAA+D/8B///////////wAAAAHh//Af//////////+AAAABwf/4H///////////wAAAAcH//B//// + ///////+AAAAHD//4P///////////wAAABwf/+D///////////+AAAAcD//wf///////////4AAADA// + +D////////////AAAAQP//gf///////////8AAAAB//8D/////+P/////wAAAAf//A//////g//////A + AAAD//wP/////8D/////+AAAAf/8D//////wP//////+AAB/AA///////A///////gAAAAAP//////8B + //////4AAAAAH///////wH/////+AAAAAD////////AP///gAAAAAAB////////8Af//AAAAAAAD//// + /////wA//AAAAAAAH//////////AB+AAAAAAAf//////////8AAAA8AAAAH///////////4AAB/8AAAA + ////////////gAD//4AAAD///////////+AH//+AAAAA///////////4P///wAAAAB////////////// + /+AAAAAP///////////////wAAAAA///8Af/////////8AAAAwH//AAH//////////AAAAOAf4AAD/// + ///////gAAAD4AAAAH//////////4AAAA/AAAAf//////////+BAAAH8AAD////////////A4AAAggAf + /////4AAAD//wPAAAACH//////AAAAAB/8D4AAAAf//////gAAAAAP/A/AAAAD//////8AAAAAB/wPgA + AAAf//////4AAAAAP8D4AAAAH///////////4B/B+AAAAA////////////wPwfhgAAAP///////////+ + AQH4fwAAB////////////4AB+H8AAAf8f//////////AA/h+AAAD4D//////////4AP4fAAAAYA///// + //////gH+DwAAAACH//////////8D/w8AAAADx/////////////8HAAAAD8P/////////////hwAAAD/ + h/////////////4OAAAB/4f/////////////DgAAA//D/////////////wcAAAf/w/////////////+H + gAAH/+H/////////////g8AAD//h/////////////8PwAB//8f/////////////D/AA///D///////// + ////w/8Af//4/////////////8P/w///+H////////////+D/4f///x/////////////h/+H///8f/// + /////////4f/D/////////////////+H/x//////////////////j/4f/////////////////w/+P/// + //////////////8P/D//////////////////H/x//////////////////x/4f/////////////////4f + +H/////////////////+P/wf/////////////////j/+B/////////////////4//4H///////////// + ///8f//Af////////////////H//8B////////////////x///wH///////////////4///+A/////// + ////////+P///4H///////////////n////g///////////////x////////////////////8/////// + ////////////////////////KAAAAEAAAACAAAAAAQAIAAAAAAAAEAAAAAAAAAAAAAAAAQAAAAEAAAAA + AABMTHgAXl5/AHp6egB+fn4ABgaOAAgIiwANDYoACQmNABwchwAQEIoAFBSJABAQjgAYGI4AHh6PAAYG + kQAGBpQACQmQAAwMkgALC5QADAyWAAYGmgAGBp4ACAiaAA0NmQAICJ4ADg6dABERkQAVFZEAExOWABYW + lgAdHZAAGhqWAB4elQAWFpkAFxecABgYmQAeHpkAGRmcAB0dnAAjI4oAJiaKACgoiAAtLYgAPDyHADEx + jgA2No8APj6LADg4jQA/P44AIyOQACYmkgAlJZQAKSmTACoqlgAhIZkAISGdACUlnQAqKpoALi6ZACkp + nQA1NZAAOzuQAD09kwAxMZgAMTGdADQ0ngA+PpwABgahAAYGpgAJCaAADg6hAAoKpgAODqYADg6oABIS + ogAWFqEAEhKlABYWpwAZGaIAHh6jABoapwATE6oAFBSqABcXrQAbG6kAHR2oAB4erQAiIqIAJyejACUl + pgApKaAALS2hACUlqQAoKKoALi6oACkprQAyMqAANDShADAwpQA2NqUAOTmjADw8ogA4OKUAPDylADEx + qQA0NKkAMDCsADU1rgA5OakAPDyrADs7rwA/P64AIyOxACkpsQA3N7IAMzO1AD4+swA/P7QAOTm/AE1N + hwBFRYoAUFCBAFFRiQBUVIsAQ0OWAExMlABGRpoAQ0OfAExMmQBQUJ4AZWWHAGxshQBmZooAdXWBAHh4 + hQBycosAaWmWAG5ulwBgYJsAZGScAG5unAB1dZAAcXGUAHV1ngBERKIAQ0OkAEVFpwBMTKIASEimAE9P + pgBCQqkARUWpAEBArgBFRa4ASUmoAExMqgBKSq0ATk6sAFdXpgBRUakAV1epAFFRrgBUVK4AWVmqAEJC + sgBFRbIAQUG0AEpKsABNTbEASkq0AE9PtQBFRbsATU24AFNTswBVVbAAUFC1AFlZsQBdXbEAWVm1AF1d + tQBQULgAXl6+AGFhogBra6MAYGCqAGlpqQBsbK0AcXGgAHp6pQBxcagAdnarAHt7qgB+fq0AY2OyAGZm + sQBgYLUAZWW1AGlpsQBsbLIAaGi3AGFhugBlZboAaWm6AG1tuQBoaL4AcXGxAHZ2sQBycrQAdXW3AHp6 + sgB7e7QAcHC8AHl5uwBGRsQAXl7AAFtbxABeXsQAZWXCAGtrxABgYMgAbGzLAG5uzwBycsMAdXXCAHNz + xQB0dMUAeXnBAH9/wgB4eMYAfn7HAHFxzQB4eMgAfn7IAHp6zQBvb9MAe3vRAH192QCAgKwAgICwAIiI + ugCSkr0Ag4PGAISExACEhMoAiIjNAJSUxwCEhNcAk5PVAKWl3AAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASeMAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKdaAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGtEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFpaAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADq + GtIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAABpkAAAAAAAAAABKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAC1GgAAAAAAAAAAGqIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAABqbAAAAAAAAABpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABaGgAAAAAAAAAUYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA2xSkAAAAAAAAGmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAC6gTY/fo4AAAAAAAAAAAAAAAAaOAAAAAAAABRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPMeFBQRFBEULYcAAAAAAAAAAAAAZBq+AAAAAAAaYQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAnEQUVFRUUBREeewAAAAAAAAAAAAAUZAAAAAAAFGEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAADjHhQVRUVFFRUPBREwAAAAAAAAAAAAFBQAAAAAABpkAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAtR4VRUVFRUVFFQ8RES0AAAAAAAAAAKgUuQAAAAAUZAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOMnGkVFRUVFRUUVBRERMAAAAAAAAADMFKQAAAAAGpYAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBQVRUVFRUVFRRUFERF8AAAAAAAAXBrvAAAAABqk + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgeFUVFRUVFRUVFFQURG4cAAAAAABQnAAAA + AAAUmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNOBQVRUVFRUVFRUUVFBEwAAD/AM0U + gAAAAAAAGmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEgD0VFRUVFRUVFRRURFIgA + AAA4FO8AAAAAABQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4YSAVRUVFRUVFRUVF + BREwAAAAGjgAAAAAAAAUFLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN9lOBpFRUVF + RUVFRRUUDgAAzBSkAAAAAAAAJxSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtJhk + FBVFRUVFRUVFBR4AAG0aAAAAAAAAAAAUFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADNqIBaGkVFRUVFFRQ4jgBkFAAAAAAAAAAAthqbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAPW0oqg8UFNTVHJlZYcANhSMAAAAAAAAAABkGsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAMy0pLSwta21mCd7eSwULQAAAAAAAAAAABQ8AAAAAAAAAAAAAAAAAAAAAAAAANZy + AAAAAAAAAAAAAAAAAAAAAAAA+fTFxba0sDgODg8RERsEAAAAAAAAAAAgFLcAAAAAAAAAAAAAAAAAAAAA + AAAA3El1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACbfRUaFAcHKoQAAAAAvoqKMxRlAAAAAAAAAAAAAAAA + AAAAAAAAAAAA3VBd3wAAAAAAAAAAAAAAAAAAAAAAAAAAwCcVU1EPEREbei0eFBERFBEUxQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA7GBJmOMAAAAAAAAAAAAAAAC6pGWfvQDFtnRFRQ8PEREREQcRERE4AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAaGpjOAAAAAAAAumUYGhQUFBQbLTZFRUVFRRUUBQcRQMUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKcaGhRlur6AGBgeFGQAALUgFBERFUVFRUVFFQ8BAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALYnGhQaFBhk3wAAAAAAAACiHg9FRUVFRUUF + GwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtcPMAAAAAAAAAAAAAAGUgGkVF + RUVFBREKKB4UPKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + mGBLFUVFRRUFBRERHiAaJ7oAAAAAAAAAAAAAANK0xd8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAADxkZTgPFUVFRRUPG4YAxRQaZAAAAADvpGU4GhoaGl3nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAREYGYPBQVRUVFSQV5AAAAYRQYZRoaFBoUGmTNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAC1EREA8KJkS0VFRRUUKgSJigCMOBQncMXqAAAAAAAAAAAAAAAAAAAAAOuncGRhYWFh + YWFhYWRhYWSAAAAAAAAAZRE2AAD2tLV0UFNLHioJEREOgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdBoU + FBQUFBQUFBQUFBQUFBjvAAAAAGUUQAAAAFzFtKiYbVwUBQUFBRGFAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAADj398AAAAAAAAA9JgaGM4AAABAFIIAAOMUgc7FtJg8GhVFFRERKAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAG0aZL6QIBG6AADnHsAAAPE2FUVFRUUaBRQwAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAthoUEREeAAAA6hrSAACoEUVFRUVFRQURGwQAANRdUAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJx4UtgAAAAAaZAAAIBEVRUVFRUUVERF6glBa + 321LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApxoAAGVkUEtKRUVFFQUR + ERjNAAAAUM0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaZADOZXBldHJx + UVAgIIAAAAAAAOoaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmBrAAMWi + qICnp3VkYWQAAAAAAAAAGrQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa + mwAA88W0oqKoqJvOAAAAAAAAANdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAFGQAAAAA487FxcXjAAAAAAAAAAAAGswAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABqAAAAAAAAAOL4AAAAAAAAAAAAAAKxRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAN8a0QAAAAAAcFoAAAAAAAAAAAAAAAAA7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC1GgAAAAAAABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAWmQAAAAAAFpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAABrMAAAAAAAaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJAAAAAAAAULUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADabQAAAAAAAABdGrAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXd8AAAAAAAAAAOoaGrUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAANcaUN8AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOvXAAAAAAAAAAAAAAAAANdK9wAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//////////////////////////f/////////8//////////z//////// + //n/////////+f/////////4//////////z/f////////P8////////+fz////////5/P////////j8/ + /////A//Pz/////wA/8fP/////AB/58/////4AD/nz/////gAH+PP////+AAP48/////8AAfjz/////w + AA+fP/////AADR8/////+AAHHz/////4AAc/H/////wABj8f/////gAGf5//////AAJ/j/////+AAj/H + /////+AAP+f//z//8AAf4///j///4A8D///h///gAAP///g//BAAD////wfgAAA/////wAGAAf/////w + B/AA//////4/+AAH///////8AAH/w/////wAEPAD/////AAcAD/////4gAID//wAAfjAAP///gAAeOAA + f///4/g4wAB//////wDGAD//////gcYAGP/////h5gAAf//////mAAc///////IAHz//////8QA/n/// + ///5gD+f//////ngf8//////+fn/z//////x8//v//////P3////////8+f////////z7/////////fn + ////////5/H////////n+H///////+/+H///////z/+P///////f//////////////8oAAAAMAAAAGAA + AAABAAgAAAAAAAAJAAAAAAAAAAAAAAABAAAAAQAAAAAAACUlXgAqKl4AMTFXADc3VwA1NVgANzddABkZ + ZgAWFm4AGBhoABwcagAZGW0AExNzABYWcAATE3YAFBR1ABoadAASEnkAFBR7ABISfgAVFX0AHx99ACEh + YAAlJWAAIiJmAC0taQAyMmAAOTlkADExbgA7O28APz9uACYmdAAvL3YAIyN7ACEhfQApKXoAKyt+AC0t + fAAxMXMANjZwADQ0dAA8PHMANTV5ADExfQA1NX4AOjp5AEJCXQBJSVoASUleAE1NXQBAQGEATExkAEVF + bABLS2sATU1rAEhIbABUVGsAWFhqAFpabQBDQ3EASkp1AEJCegBRUXAAW1twAFNTegBfX3gAY2NvAGdn + cQBiYnYAZWV1AG1tcABubnUAY2N7AGZmegBhYX0Aa2t+AHFxcwBycnQAd3d3AHZ2eABxcX4Aenp8AA0N + hQAODokACgqOAA0NjQAREYIAFRWAABERhQAXF4QAGhqEABAQiAAVFYoAEBCMABcXjAAaGokADQ2QAAsL + lgANDZUACgqZAA0NmQAJCZ0ADQ2dABISkwAaGpAAHByRAB4elwAQEJgAFRWZABISngAXF50AGRmdACMj + gAAmJoEAIiKEAC0tgwAgII4AKyuLADIygQA7O4UAMTGIADY2jwA/P4sAIyOVACEhnQAoKJgAMzOSADk5 + kAAHB6IABQWlAAgIoQAMDKIACgqmAA4OpAAFBagABQWtAAwMqgAQEKEAERGmABQUpAAaGqMAEBCpABUV + rAAbG6wABQWxAAUFtQAKCrMADQ28ABMTsAAVFbEAFBS1ABgYsgAeHrIAGhq0AB4etgAQELoAHR29ACUl + pAAqKqIAIiKqAC0tqQAwMKkAPDyuACQksAArK7MAICC/ACgouAAtLbsAKSm+ACwsvQA1NbYAPT2yADIy + ugA2NrsAMTG9ADg4uQA9PboAODi+AEBAggBDQ4oASkqJAF1dhQBeXokAYWGAAG5uhABgYIoAd3eFAHx8 + gAB9fYgAYmKfAHV1kAB7e5EAe3ubAE9PpABRUaEASkq1AEFBuwBBQb8ARUW8AFZWsgBdXbQAUlK+AFhY + uAB1daIAeHilAGVltQBvb7QAZWW6AGJivQB/f7cAEhLAABYWwAAdHcYAIiLAACYmygA0NMMAODjCADU1 + zAA6OsoAQ0PDAEVFwgBCQsUASEjBAE5OwABPT8cAQkLIAExMywBQUMUAVVXEAFhYxABTU80AWVnIAERE + 0ABMTNEAV1fRAFxc0wBlZckAcHDAAHd3zQB5ec8AZGTRAGpq0QBoaNsAcnLSAHt70wB8fNMAf3/WAH9/ + 3gCCgsIAgoLGAIGB2QCHh+UAkJDnAKGh6AAAAAAA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJhJAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPN4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACKRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADgLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbUcA + AAAAAPhBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApikAAAAAAMkmAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9mhPAAAAAMYhAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIU3AAAAALAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC/HRka + ME0AAAAAAAAAAN1wAAAAALAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJgXVsTDRYwAAAAAAAAAABt + OQAAAK0hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSBhYBlYBMJBU0AAAAAAACOHAAAAKYkAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAJuHgYGBgWVYCwVPAAAAAADkWAAAAKYsAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAANOQh4GBgYWAWAgEAAAAAADQWgAAAKYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANSSh4GB + gYGBZVgJMAAAAACMLQAAAKYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPLTkIeBgYeBgWATFk0AAABg + uAAAANcfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADWk4eHgYGBgYFgCC4AAMNeAAAAALBYUQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA1puHgYeBgYFlExYAAIU9AAAAAOlrMwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA+9mch4GHgYGFXQtRAGVPAAAAAACUJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzo + 15SHh4GBayxHAFtEAAAAAAAAijkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6+nhraaton45SRMu + AAAAAAAA5SFPAAAAAAAAAAAAAAAAAMi2AAAAAAAAAAAAAAAAAP3y6ubpxm1aWBMCUQAAAAAAAFsyAAAA + AAAAAAAAAAAAAADknrYAAAAAAAAAAAAAAAAAAAAAAJiFZVsLBEcAuj8+O1ssAAAAAAAAAAAAAAAAAAAA + AOyfs0sAAAAAAAAAAAAAAE+6AKKYn2VbDRgQWF1gZW8AAAAAAAAAAAAAAAAAAAAAAAAA9phoLT8AAAAA + AEBwYGVgXix7gYWBZWBdXW3DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA14VeHTQka2Wh+ADx1ZCHkIeB + gWVSMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpiIWf7QAAAAAAAADTkIeBgWVdCzA5OUQAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD3nIiHhYFgWBMNWFssQgAAAAAAAAAAvElJAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAmKaUkIeBZWAQTQCeWzdRAEs8LFprbZ3NAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADwgXfDpZCHgWATMAAAsmtbbWWKquwAAAAAAAAAAAAAwDw7Ox00HTQpNDQ3QwAAAADYZUsA + 8NeXiIVaGyYQMkfLAAAAAAAAAAAAAAAAAAAA6ZSIhYWFhYWFhYVlWjcAAAChWwAA7t3esKadWFtYDRoA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA54o9UQB7WAAA3XXM8OCMhYFlWAswAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACYbSFbLAAA2C0AAKGHgYGFYBMWuwAAtUAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA4ZOIAAAA8WhRAJCQh4GBgV0LMD18zp9JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AIg8vqaclIiHgWVYE70AAAB8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOxou8fa2K2kpKF7 + vwAAAACtQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKPgD26eHdxqLCAAAAAAAAewAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACXPAAAAPrlyNEAAAAAAAAAmLcAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABtSwAAAACKAAAAAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABrAAAAAMK0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO54AAAAAG0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMa1AAAA8H8AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIwAAAAAANd+SQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAH4AAAAAAAD6jnVEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + 0L8AAAAAAAAAAPGXfwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAogAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /////wAA///5////AAD///n///8AAP///P///wAA///8////AAD///58//8AAP///nz//wAA///+PP// + AAD///88//8AAP/A/zz//wAA/4B/nP//AAD/gB+c//8AAP+AD5z//wAA/4APnP//AAD/gAec//8AAP+A + A5z//wAA/8ADPH//AAD/4AM8f/8AAP/gAT5//wAA//ABPz//AAD//AA/H/8AAD/+AB+f/wAAj//4CB// + AADh/8gAP/8AAPg+AAD//wAA/wAgA///AAD/wfwAP/8AAP///AAP8QAA///+AEIBAAD///wAYB8AAPgA + PEAD/wAA+AAcwAf/AAD//4TAA/8AAP//4MwBnwAA///xxAAPAAD////gAO8AAP///+AB5wAA////8gP3 + AAD////zh/MAAP////Pf+wAA////95//AAD////nv/8AAP///+c//wAA////74//AAD////vw/8AAP// + /8/x/wAA////3///AAD///////8AACgAAAAgAAAAQAAAAAEACAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAB + AAAAAAAANTVZADMzXwA7O1oAGxtpABYWcQAVFXcAGxt2ABwcdAAUFHgAERF9ABcXfwAbG34AKipgACAg + agAkJG0AKipoADY2YwAxMWcAPz9lACEhdgApKXIALCxyACgodQAsLHYALy94ACoqfwA1NXMAMDB2ADU1 + dgAwMHkANzd7ADU1fQA/P3sAQ0NfAEdHXQBAQGsARkZtAFhYZgBBQXAASUlyAEtLdgBPT3oASEh8AFZW + dgBeXnMAUlJ7AFxcfwBlZW4AYWF3AGxsdgBycn4ADg6LAA0NjgASEoMAEBCHABgYgAAREYoAEhKOABoa + jwAdHY4ACwuTAA0NkgAMDJUACgqaAAkJnQAODp8AEhKQABcXkQAbG5EAHx+RABERmQAUFJgAFxefAB8f + nQAhIYIAKiqGACcniwAlJY8AMzOBADIyhwA0NIgAMDCOAD8/iwAoKJEAKSmUAD09mwAHB6IABgamAAgI + ogAICKYABQWpAAUFrAAJCagAGRmgABwcoQAQEKsAFhaqABkZrAAdHa0ABga2AAoKtQAODrkAERGwABsb + sgAWFrgAHh67ABwcvAAhIacALS2nACIirgAlJa8AKSmoACkprQAtLawANzelADg4pgAyMqkAMDCtADs7 + rwAgILUAJSW6ADAwtgAzM7wANze+ADs7uQA8PL0AQECGAFZWgQBTU4UAWlqDAFBQiwBUVI0AQ0OaAFxc + nwBnZ4cAd3eFAHp6hgB/f4YAdnaKAHt7iAB/f4sAb2+QAHl5kQBBQa0AX1+hAE5OswBERLsAQEC9AFpa + tQBSUrwAYWGvAGJitwBqarEAeXm2ABUVwQAvL8wANzfAADs7xwA9PckAPDzNAE5OwwBSUsEAUFDEAFVV + xQBbW8IAXV3CAF5exQBYWMkAV1fUAGdnyQBzc8cAZ2fSAGpq0ABiYtoAenrTAICAgwCAgJAAgYG8AIGB + zgCRkdIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJMAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvKAAAAHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA8AAAAdowAAAAAAAAAAAAAAAAAAAAAAB0PAjAAAAAAAJMtAABwjQAAAAAAAAAAAAAAAAAAAABhQUE0 + BQMAAAAAABgAAG8AAAAAAAAAAAAAAAAAAAAAAGZYWFhBCQIAAAAAQwAAbgAAAAAAAAAAAAAAAAAAAAAA + m1xYWFhBBSMAAABLAABuAAAAAAAAAAAAAAAAAAAAAACuZVxYWFg/BLAAmIIAAHAzAAAAAAAAAAAAAAAA + AAAAAACcZVhYWFg2IwBeAAAAeyQAAAAAAAAAAAAAAAAAAAAAAACgaVxYWD8SAEsAAAAARQAAAAAAAAAA + AAAAAAAAAAAAAACunnlvcCEzDAAAAACrJwAAAAAAAAAAAJWHAAAAAAAAAAAAr6qkXjoJJgAAAAAMAAAA + AAAAAAAAAACSgQAAAAAAAAAAAABvYj8FEhgJQ1UAAAAAAAAAAAAAAAAAoU0oAACPT0heSE5aWEE/DIYA + AAAAAAAAAAAAAAAAAAAAAK1hSJAAAAAAqWRYWD8EMokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfmdc + WjQJGFUnAAAAALEvKwAAAAAAAAAAAAAAAAAAAABhVmpcWD8TAH9LGjxslgAAAAAAAJkgIBodGh0dJAAA + AEEAtHtoSRgUEDEAAAAAAAAAAAAAAAAAAAAAAACiTLAAOgAAhad9QUE2EAAAAAAAAAAAAAAAAAAAAAAA + AAAAYkVPALMoAGJYWEEFJgCDLgAAAAAAAAAAAAAAAAAAAAAAAAAAAE6LamddWD8IhgCnMwAAAAAAAAAA + AAAAAAAAAAAAAAAApC6Ynn56bY4AAABRAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAArJaaAAAAAKIAAAAA + AAAAAAAAAAAAAAAAAAAAAACBAACyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApwAAAFEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB0AAAAUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMAAAAAdi4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP///////f////7////+/////nf///9z//4fM//8D7f//Ae3//wDt//8ATP//gFz//8B + e///gHn/P+A9/8/8Af/xgAf//DwD///+APH//gIH4A6Af//iwH//+JAn///AE///wDv//+x7///t//// + 3f///93////ef////7//////KAAAABAAAAAgAAAAAQAIAAAAAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAA + AAAcHHoAGRl+ACMjcgAlJXMAISF1AExMbABaWnIAFBSEABAQiAAMDJUAIyOaAD09kwAGBqUACAihAAgI + pAAHB6sAGxugABgYpgASEq8AHR2rAAsLtAAbG7QAIiKwAD09swBCQo0AX1+CAFdXiABVVZEAUlKWAFtb + kQBcXJIAYWGNAGlpiABsbIsAd3ePAGpqkwBra5UAYGCZAHl5kQB+fpAAenqZAFdXpABYWKQAXFykAFpa + rQBubqYAZWWtAG1tqgB2dqAAdnauAH19rABjY7MAZGS2AGxsuABxcbkAdXW/AEhIwQB8fM4AZmbXAGFh + 2ACGhr8AgoLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /wAAAAAAAAA1AAAAAAAAAAAAAAAAAAAAAD4AAAAAAAAAAAAAAAAAAAAAJwAeAAAAAAAAAAAMAQcAACoA + HAAAAAAAAAAAFQ0KBgA4AB4AAAAAAAAAADwQDQkAJgAZAAAAAAAANQAAOxYSGiEAADUAAAAAAAA1AAAA + MRIDKCAkAAAAAAAAABweODoXDQgpAAAAAAAAAAAAAAAAABQOBRshJC4AAAA1LTUrACsAGAsBJwAANQAA + AAAAADU2ACQTDQUAKQAAAAAAAAAAAAAvPTkzAAAAAAAAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAAA1MAAA + AAAAAAAAAAAAAAAAAAAAAAAA/f8AAP7/AAD/XwAA418AAOFfAADhXwAAsG8AANwPAADgHwAA/wEAAMKG + AAD8hQAA/4cAAP+/AAD/zwAA//8AACgAAACAAAAAAAEAAAEAGAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODrMQEKpjY7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbG7kPD6sREaJ+fqwA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABxcdwODq8QEKQvL6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMPD6gSEp1wcKUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABiYtYNDa4QEKM4OJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMPD6cREZx3d6MAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NsgNDa0Q + EKA3N50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMODqYSEpoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ78NDasQEJ9GRp4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAACAgOIMDLAPD6QSEpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UODqkREZxWVp4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABT + U9IMDK4QEKEbG5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACEhNVISLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7MODqcREZpjY50AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEKoSEp89PZ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJsANDasQEJ8k + JJUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPD6gSEp0TE5N5 + eZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACAgOIMDLEPD6QSEpZmZpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAODqkREZ0TE5FZWZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UNDakREZs1NZYAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDasQEJ4TE5FERI0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABSUtEMDK4PD6ATE5Rzc5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAMDKwPD6ETE5IwMIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7MODqYSEphCQpQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDK4PD6ESEpMuLogAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGLwM + DKsQEJ0bG5B/f4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC64ODqISEpMa + God/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABwcN0LC7APD6ISEpVWVpQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAALC68ODqIREZMUFIl/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrUNDagREZkjI48A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCq8NDaMREZQTE4l/f38AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA1NcgMDKwPD58TE5FhYZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoKCq8NDaMREZQTE4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcJdMTIc7O3wt + LXUtLXItLW8uLm9ERHBYWHNwcHB2dnZ+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7IODqUSEpY5OY4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaMQEJQTE4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABYWKAZGYgTE4ITE30UFHoVFXgWFnUWFnIXF3AYGG0ZGWoeHmg2NmZdXW5wcHB6enoAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAKCrcMDKkQEJsTE45ycokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQQEJUT + E4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHJoQEJAREYkREYQSEoETE4ETE4ATE34UFHsUFHYV + FXMXF24YGGsZGWkaGmc2NmNcXGxwcHB9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSUtILC68ODqASEpNFRY4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edsKCrANDaQQEJUoKIsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIqgODpkODpMP + D5AQEIwPD4wQEIwQEIsQEIoREYcSEoQTE38UFHoVFXQWFm4YGGkaGmYbG2ZAQGNpaWl1dXUAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrMNDaUR + EZYbG4t+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQQEJUuLosAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA2NrgaGqcLC5wMDJoMDJkMDJgMDJcMDJcMDJYNDZYNDZMODpEPD40REYgTE4IUFHsV + FXQXF2wZGWcaGmUpKWFWVmtvb29/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAXF7wMDKsQEJwTE45XV4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edsKCrANDaUREZUuLowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIiNkhIbQVFasJCaQJCaMJCaIKCqAKCp8KCp4K + Cp4KCp0KCpwLC5oMDJcNDZMPD48REYkTE4EUFHgWFnAYGGkaGmUgIGNMTGVra2t8fHwAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYdgLC7AODqASEpIqKol9fX0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQREZYuLowAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTMkf + H7gTE7EICKoICKoHB6gICKUICKQHB6MICKMICKIICKEJCaAJCZ4KCpwMDJgNDZMPD44REYUTE34VFXQY + GGwZGWUbG2M/P2FpaWl5eXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAKCrMNDaUREZYUFIpvb4YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoKCrANDaQREZYv + L4wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAeHr8eHrsTE7UGBrAGBq4HB6sHB6gHB6YGBqYHB6YHB6YHB6UHB6QI + CKMICKEJCZ8KCpwMDJcODpEQEIoTE4AUFHYXF20ZGWYbG2M2NmFoaGh4eHgAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJb4MDKgQEJgTE4xDQ4gAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edoKCrANDaQREZZLS48AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeHsIdHb0SErgGBrQGBrEG + Bq0GBqoGBqgGBqcGBqcGBqcGBqcGBqYHB6YHB6UHB6MICKEKCp4LC5oNDZQQEI0SEoMUFHgXF20YGGYb + G2M2NmBpaWl6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtbdgM + DKkPD5oSEo4hIYYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC68NDaQQEJZMTJEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAcHMQcHMAVFbwFBbYFBbMGBq4GBqoGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6YHB6QI + CKIJCZ8KCpwMDJYPD44SEoQUFHgWFm4YGGYbG2M2NmBqamp9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6kODpsSEo8UFIhvb5AAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoLC68NDaQREZZMTJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMUcHMIaGr8FBbcFBbQFBa8GBqsGBqgGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6UHB6MICKEKCpwMDJYPD48SEoQUFHkWFm4ZGWYaGmNJSWNt + bW0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6gODpsSEo8TE4kA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC68ODqQREZVUVJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQNEc + HMQcHMEHB7sFBbYFBbEGBqwGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UHB6MICKEK + Cp0MDJcODo8SEoQUFHgXF20ZGWYbG2RRUWdwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAALC6YODpkREY8hIYkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqMREZVo + aJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABnZ94cHMQcHMIODrwFBbcFBbMGBq0GBqoGBqgGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcGBqYHB6YHB6QICKEKCp0MDJcPD48SEoMUFHgXF24ZGWYgIGNbW2t1dXUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABWVsILC6MODpcREY89PY0AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edoLC64ODqMREZRmZo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMccHMMaGsAFBbkF + BbQFBbAGBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6QICKEKCp0MDJYP + D44SEoMUFHYYGGwaGmUpKWFpaWl8fHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFqsN + DZ4PD5UREY1kZJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqESEpNlZY4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAnJ8scHMUcHMMLC70FBbcFBbIGBq0GBqoGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcHB6YHB6QICKEKCpwNDZUQEIwTE4AVFXQYGGkbG2RAQGNubm4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC6YNDZwQEJISEo0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoLC64ODqESEpJJSYsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaOEcHMgcHMQVFcAFBboFBbQFBbAGBqwG + BqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UHB6MJCaALC5sNDZMQEIoTE34W + FnAZGWcbG2VbW2t4eHgAAAAAAAAAAAAAAAD///8AAAAAAAAAAAAAAABISL0MDKINDZgQEJA1NY4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqESEpFISIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAcHMobG8UcHMQMDL0FBbcFBbIGBq4GBqoGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqYHB6UICKMJCZ8LC5oODpEREYUUFHkXF20aGmYtLWJtbW0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALC6kMDJ8ODpUREY9kZJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsLC64ODqESEpE7 + O4V9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaOEbG8kbG8QZGcEGBrkFBbYFBbEGBqwGBqoGBqgGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKIKCp4MDJcPD44TE4EVFXQYGGkaGmZT + U2p4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f9ALC6YNDZsPD5MYGI0AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edsLC7AODqISEpInJ4N4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMsbG8cc + HMQTE8AFBbgFBbMFBbAGBqwGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YH + B6QICKEKCpwNDZQQEIoTE3wXF28ZGWcsLGRubm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAiIrMMDKINDZkQ + EJI+PpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6etwKCrINDaUREZQUFIZzc3MAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACEhOgfH8odHcUcHMMODr0FBbcFBbIFBa8GBqsGBqkGBqgGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6MJCZ8LC5kODpASEoMUFHYXF2saGmdUVG18fHwAAAAA + AAAAAAAAAAAAAAAAAAALC6oMDKAODpYQEJB1dZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8 + fN8KCrUMDKgQEJcTE4hTU319fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHR9YkJMohIccfH8MODrwF + BbYFBbEGBq4GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKEKCp0N + DZUQEIsTE30XF28ZGWkxMWVzc3MAAAAAAAAAAAAAAAAAAABmZskLC6cNDZ0PD5UgII8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+fuMJCbgLC60PD5sTE4w+Pn93d3cAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAsLM4oKMooKMUmJsQQELwFBbYFBbIGBq4GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcHB6YHB6QJCaALC5oODpASEoMVFXYYGG0ZGWtnZ3IAAAAAAAAAAAAAAAAAAAAj + I7MLC6QNDZsPD5NVVZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLsKCrENDaIS + EpIaGoR0dHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMM4uLsotLcgrK8UTE70FBbYFBbIG + Bq4GBqsGBqkGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UICKEKCpwNDZQQEIoUFHsW + FnAYGGxMTG8AAAAAAAAAAAAAAAAAAAALC6kMDKIODpkREZJ/f5cAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAHB78JCbYMDKkQEJkTE4tZWYV9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABzc+M0NM8zM8wyMsowMMgXF78FBbYFBbIGBq4GBqsGBqoGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqcHB6YHB6MJCZ8MDJgPD48TE4EVFXUXF242Nmx8fHwAAAAAAAAAAAAAAAALC6YMDKAPD5g2NpEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYN0ICLoKCq8ODqASEpIxMYp9fX0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYN46OtA4OM43N8s1NckiIsEFBbYFBbIFBa8GBqwG + BqoGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UICKELC5sODpISEoUUFHkXF3EoKHN6enoA + AAAAAAAAAAB0dMkMDKQNDZ0QEJVbW5MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAlJcgJCbYMDKkQEJsTE49mZo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZWdo/ + P9E+Ps89Pc07O8svL8QODrgFBbMFBbAGBq0GBqsGBqkGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcHB6YI + CKIKCpwNDZUREYgUFHwXF3QqKn93d3cAAAAAAAAAAABaWr4MDKAODpkYGJF9fYoAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLwLC7EODqMREZYzM5EAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcXNtERNJDQ89BQc0/P8o7O8ggIL8FBbQFBbIFBa8GBqwGBqoG + BqkGBqgGBqgGBqcGBqcGBqcGBqcGBqYHB6MKCp4MDJcQEIsVFYAmJn8sLIB0dHQAAAAAAAAAAAA/P7AN + DZwPD5UZGY4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ + CbgMDKwPD6ATE5NubpYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6euRKStNISNFH + R85ERM1DQ8w7O8gbG70FBbMFBbEGBq4GBqwGBqsGBqoGBqkGBqgGBqgGBqgGBqgHB6UJCZ8MDJgTE48s + LI4xMYYwMINxcXEAAAAAAAAAAAA9PacODpYQEJATE4hpaYcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtsKCrQNDagREZo2NpYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACFheZQUNROTtJLS9BLS89JSc1HR8s9PccgIL0NDbQFBbEFBa8GBq0GBqwG + BqsGBqoGBqoGBqoHB6cREaYlJac1NaI2NpY2Now2Nohubm4AAAAAAAAAAABXV6UPD5AREYoTE4JNTX9/ + f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NcgLC68PD6ET + E5VgYJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYWNZTU9RRUdJQUNBO + Ts5MTM1LS8xKSso7O8QqKr0cHLkUFLUTE7MUFLIbG7QkJLY1Nbk5Obg6OrM7O6o8PKA9PZM2NotXV3F6 + enoAAAAAAABVVZUPD4sSEoUUFH0zM3Z4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAZGbYODqUREZgcHIx+fooAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB7e+JYWNZWVtRVVdJTU9BRUc9QUM5OTs1MTMtMTMpKSslISMdGRsdERMRCQsRB + QcJBQb9AQLpBQbJBQak+PpwaGoIrK3Vzc3N8fHwAAABkZIQQEIUSEoIVFXgXF3JwcHAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f9sNDaYQEJgTE4xISIp+fn4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZtpcXNZaWtRXV9JWVtFV + VdBUVM9SUs5QUM1OTsxMTMtMTMpKSslISMdHR8NGRr9GRrpGRrIgIJgREYU1NXdNTXQPD4IUFIBWVnEP + D4QSEn8VFXUXF29QUG55eXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAaGqgQEJgTE4sVFYFlZYJ+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABjY9gODrQnJ7MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABoaNtgYNZeXtVcXNRaWtFYWNFWVs9WVs9UVM5SUsxQUMtPT8pNTchNTcRMTMAj + I6wMDJsODpBnZ3gODogODogODocSEoMUFIESEoAUFHYXF242NmVubm4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUVLQPD5UTE4oVFYEuLnt3d3cAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRtEMDLgNDbIPD6tFRbIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDg+JlZdZiYtRgYNNeXtFc + XM9bW85ZWcxXV8xWVstUVMpOTsUUFLEJCakKCqM0NJcNDZkMDJUNDZQMDJINDZAODowREYYTE3kWFm4e + HmZgYGlycnIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABycq0P + D5ISEosUFIIWFn5dXYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAoKMYMDLgNDbIODqwQEKZRUbMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACRkeKBgdtzc9RxcdBwcNBvb89zc9CIiNU4OL0GBq0HB6p1dbUSEqMLC6ML + C6ALC5wKCpoMDJgXF4oQEIsTE4AUFHMYGGk/P19lZWVwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABra5MODpAREYwTE4YVFYI3N4UAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRc0MDLQNDa8PD6oQEKVmZrkAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABGRrsSEqsICKsICKoJCagJCaUKCqIKCp8bG4sYGIgREYcTE3oVFW0YGGcjI2NJSWZt + bW16enoAAAAAAAAAAAAAAAAAAAAAAAAAAABnZ4NeXoFdXYBaWn9aWn9aWoBISIQODpIQEJASEowTE4gz + M5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABFRcwMDLMODq8PD6oQEKVSUrUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdHbAGBqkICKwHB60ICKwHB6kICKYREaUZ + GaQMDJcPD48SEoIUFHcWFm0YGGgZGWc2NmJnZ2dwcHB4eHhXV389PXshIXkVFXwVFXwUFH0TE4IREYgQ + EI0NDZIMDJMMDJUNDZQODpUREZESEpFLS6MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRcwMDLQNDa8ODqoQEKY8PK+AgLgA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABL + S7sYGK0HB6wHB68HB64GBqskJLI1NbQJCaIKCp0NDZUPD4wSEoETE3kVFXEWFm0XF2s9PWBDQ2QaGnAU + FHYTE3oTE34TE4ATE4MSEoUREYoPD5AODpYMDJkLC5sLC5oMDJoNDZoPD5kbG5wAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABhYdcMDLQNDbAODqsQEKYlJahgYLIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYbFaWsBMTMExMbwwMLxGRsA7O7sMDKkICKQJCaEKCpsNDZUP + D44REYUTE34TE3cUFHQTE3QTE3cTE3kSEn0REYMQEIcPD4oPD48ODpINDZYNDZoMDJ8KCqAKCqEKCqAL + C6ENDaIlJaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtgMDLUNDbAODqwPD6YQEKE4OKZr + a6oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABkZJVDQ5EmJo4REZAREZAREZAREZAeHpA5OY9SUotuboV8fHx3d4NiYrRjY8dgYMpT + U8UgILUHB6sHB6gHB6YICKMJCaAKCpwMDJcODpIPD4sQEIYREYQREYIREYMREYUPD4gPD4sODo4MDJIM + DJYLC5kLC54KCqEKCqQJCaYKCqcKCqgjI69wcMkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABiYtgMDLUMDLEODqsPD6YQEKEcHJ1ISKJsbKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2dpdERJEfH40REY8QEJAQEJIQEJMPD5QPD5UPD5UPD5cO + DpgNDZkLC5oYGJg7O5JjY4Vycn9eXooGBq8GBq0GBqsGBqkHB6gHB6YICKMICKEKCp0LC5oMDJcNDZMO + DpEODpAODo8ODo4ODo0MDI4MDJALC5MLC5gLC5wKCqEJCaUKCqgWFq1XV8MAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYdkLC7YMDLENDasODqYQEKEREZwb + G5ZMTJt1dZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUVJMmJo0REY4QEJAPD5IP + D5QODpYODpkNDZwNDZ4NDaANDaEMDKMMDKMLC6MKCqMJCaQICKUHB6kWFqgUFKoGBrEGBq8GBqwGBqoG + BqkHB6cHB6UHB6MICKIJCaAKCp4KCpwLC5sLC5oLC5YMDJMLC40LC4wLC4sLC44LC5MhIZ5GRrF+fsoA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABxcd0YGLsLC7INDa0ODqcPD6AREZsSEpYjI5JISJJubo8AAAAAAAAAAAAAAAAAAAAAAABb + W5M1NY4REY8QEJAPD5IODpQODpcNDZkNDZ0MDKELC6QLC6gwMLQKCq0KCq4JCa8KCq8JCa4ICK4HB68H + B7AGBrEGBrMFBbMGBrQGBrAGBq4GBqsGBqkGBqgGBqYHB6YHB6UHB6QICKIICKEJCaAKCp4KCpoLC5IL + C4ksLHM8PHRiYoMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+MYGLwLC7MMDK4NDagPD6IQEJsS + EpYSEpEqKpBRUY5xcYhbW4ozM4sREY4REZAQEJIPD5UODpcNDZoMDJ0MDKALC6QLC6gwMLV+ftAAAAAA + AAAAAAAAAABtbdkyMscICLoHB7kGBrkGBrgGBrcFBbcFBbcFBbYGBrQFBbEGBq0GBqoGBqkGBqgGBqcG + BqYHB6YHB6UHB6QICKIICKEKCpoLC5EMDIUtLWxlZWV0dHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAlJcMKCrQMDK8MDKkODqQPD54QEJoQEJcQEJYQEJUQEJUPD5YODpcNDZsMDJ4MDKEL + C6QLC6giIrFjY8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTtUFBb8FBb0PD7wEBLkF + BbgFBbcFBbMFBbAGBqwGBqoGBqgGBqcGBqcGBqcGBqcHB6YHB6QICKEKCpsMDI8NDYMPD3owMGpoaGh2 + dnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcMKCrYKCrELC60MDKkNDaYN + DaQNDaIMDKEMDKEMDKILC6ULC6gWFq1WVsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAiIsUSEr8EBLsFBbkFBbcFBbEGBq4GBqoGBqkGBqgGBqcGBqcGBqcHB6YH + B6QICKEKCpoMDJAODoMREXkSEnMyMmdnZ2dxcXF8fHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABDQ88JCbgJCbUKCrMKCrEKCq8KCq0KCq0WFrFWVsUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhOYeHsUQEL8EBLoFBbgFBbQF + Ba8GBqwGBqkGBqgGBqcGBqcGBqcHB6YHB6QICKEKCpwMDJMPD4cREX0SEnUUFHAzM2NVVWdVVW5JSXJF + RXdHR31JSYJMTIdiYo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYNgWFr8JCbokJMBoaNIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA0NM0kJMUZGb4MDLgFBbQFBbEGBq0GBqoGBqkGBqgGBqgGBqgGBqYHB6UICKIJCZ0LC5cO + Do4QEIMSEnsTE3UUFHMVFXMVFXIVFXUVFXYVFXgUFHwUFIAUFIMVFYZDQ5B7e5MAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvL8kpKcEjI70cHLoREbQFBa8GBqwGBqoG + BqkGBqkGBqkGBqgHB6YHB6MJCaAKCpsMDJUODo0QEIYSEoETE34UFHwUFHoUFHsTE3oTE3sTE34TE4QT + E4kTE40TE44TE41LS5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA0NMMuLr4qKrwkJLsZGbYJCa4GBqwGBqwGBqsGBqsGBqoHB6gHB6UICKIJCZ8KCpsMDJcODpIPD40Q + EIkREYgSEoUSEoESEn4SEn0SEoEQEIgQEJAQEJUQEJcSEpYTE5MkJI9ubpYAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzc5Vra5ZOTpZP + T5hCQpg0NJg1NZw3N6Fra7YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZMkzM741Nb4uLrwpKbohIbUKCq4FBa4FBa4GBq0GBqwG + BqsHB6gHB6UICKIJCaAKCp0LC5oMDJcNDZQODpEQEIwREYYqKnBUVG9qaoQAAAAAAAAoKKMODp0PD50R + EZkSEpQTE41MTJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6epFj + Y5RNTZM3N48hIY8SEpASEpISEpMREZUREZYSEpgSEpoSEp0SEqEdHacAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQELMKCq8mJrc6 + Ors1NbkuLrYmJrUQELAFBa8FBbEFBa8GBq0GBqsHB6gHB6YHB6MICKEJCaAKCp0LC5oMDJYODo8QEIcP + D4FWVmt6enoAAAAAAAAAAAB4eMsNDaIODp8QEJkSEpMTE4wcHIlmZpUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABzc5VbW5NFRZEuLpAYGI4REZAREZIREZMQEJQQEJYPD5kPD5oPD5wPD58PD6APD6IQEKQoKK1n + Z8kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABUVMkGBrAGBqsFBagVFao4OLQ6OrUzM7UtLbgSErQFBbMFBbMFBbAGBq0GBqoGBqgH + B6cHB6UHB6MICKEKCp0LC5kNDZAQEIcQEH4mJnFycnIAAAAAAAAAAAAAAAAAAAAyMq0ODpwQEJYREZES + Eo0TE4o0NI98fJNra5NiYpNNTZM/P5InJ5ASEpAREZEREZMREZQQEJYQEJcPD5kODpsODp0NDaANDaIN + DaQMDKYNDagMDKo+Prt1dc8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHB7UHB64GBqkGBqMGBp4gIJlZWaw+Prk4 + OLsxMb0aGrkFBbUFBbMFBa8GBqwGBqoGBqgGBqYHB6UHB6MJCaALC5sNDZIQEIgREX0TE3lbW3IAAAAA + AAAAAAAAAAAAAAAAAABjY7EPD5cQEJMREZAREY8SEpASEpEREZMREZQQEJUQEJcPD5cPD5kODpsODpwO + Dp4NDaEMDKMMDKUMDKcMDKkLC6sXF7BLS8J1ddEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH + B7QHB60HB6cICJ8ICJphYYwAAABpacFERME9PcI3N8IfH7wICLUFBbIGBq4GBqsGBqkGBqgGBqYHB6QI + CKEKCpwNDZIQEIcREX0TE3Y/P2x4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAzM5cPD5EPD5IPD5UPD5gP + D50ODp8NDaENDaIMDKMMDKUMDKYLC6gLC6oLC60KCq49Pb9nZ80AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB3d9gICLMICKwICKUJCZwWFpIAAAAAAAAAAAB1ddFISMhCQsc9PcUt + LcEQELYFBbAGBqwGBqoGBqkGBqgHB6YICKIKCp0NDZQQEIoSEn0TE3UvL2tubm57e3sAAABubopmZol9 + fX17e3t/f38AAABra5ogIJUNDZYNDZwNDaEMDKYLC6kLC6wKCq4jI7c+PsB1ddMAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABubpppaZNmZo9jY4xiYohhYYhh + YYdhYYdhYYdgYIZgYIZgYIZgYIZhYYdhYYdhYYdhYYhhYYhhYYhiYohiYohiYohpaYh/f39/f38AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQMgICLMJCasKCqILC5ks + LIsAAAAAAAAAAAAAAAB7e9tOTsxISMpBQcg8PMUnJ7wQELIGBqwGBqsGBqoHB6gICKQKCqAMDJgPD40U + FIMgIH82NnJmZmZHR20fH3YSEn0REYAQEIEsLHhZWXFwcHB+fn4AAAB/f6hkZLJtbcF0dMwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NcUNDbIODqsP + D6QQEJ0REZgSEpQSEpISEpETE5ATE48TE44TE40TE40TE40TE40TE40TE40TE40TE40TE40TE40TE40T + E40TE40TE40TE4sTE4sTE4oTE4gUFIgVFYYvL4VhYYh9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA/P8YJCbAKCqkLC58NDZVCQocAAAAAAAAAAAAAAAAAAAB7e9pTU85NTcxISMlBQcU8PMEv + L7wdHbUTE7IODq8ODqoQEKYYGKIgIJwmJpMnJ4hAQG0yMmYTE3UTE3gSEnwREX4REX4REXwREXs7O21q + amp6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABGRtMLC7wLC7gMDLMMDK0NDagNDaMODqAODp4PD54PD50PD50PD5wQEJsQEJsQEJsQ + EJsQEJsQEJsQEJsQEJoPD5oPD5kPD5kPD5kPD5kQEJgQEJgQEJYQEJUQEJQSEpITE5ATE4wUFIg+Pol4 + eIQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/P8IJCawLC6QNDZoPD5BKSoUAAAAAAAAAAAAA + AAAAAAAAAAA8PMlYWM5TU8tMTMhHR8RAQMI7O8A1Nb8wML0qKrgmJrMgIKwiIqMkJJslJZEhIX4QEHwQ + EH0QEIAQEIIQEIMQEIAREXwSEncSEnYxMWtpaWl6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOYlJccKCroKCrcKCrIKCrALC60L + C6sLC6sMDKsMDKsMDKsMDKsMDKoMDKoMDKoMDKoMDKoMDKoMDKgMDKcMDKcMDKYMDKcMDKcMDKcMDKYM + DKUMDKQNDaMODqAPD54QEJoSEpUTE48rK45xcZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+PrwK + CqYMDJ4PD5QQEItgYIUAAAAAAAAAAAAAAAAAAAB1ddgFBbhAQMdeXsxYWMlTU8VMTMRGRsNAQMQ7O8I1 + Nb4wMLoqKrMmJqsiIqQeHpsODo4ODosPD4oPD4sPD4wPD4wQEIgREYASEnkTE3MTE3EyMmhqamp+fn4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB9feJBQcwWFr0ICLcJCbYJCbUJCbUJCbUJCbUJCbQJCbQJCbMJCbMJCbMJCbMJCbMJ + CbMJCbIJCbIKCrIKCrIKCrIKCrIKCrIKCrIKCrEKCrEKCq8MDKwNDagODqMQEJwSEpYcHJFxcZsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAuLq4LC6ANDZoQEI4SEohoaIcAAAAAAAAAAAAAAAAAAABLS8sFBbYF + BbAuLrljY8hdXcdWVsVQUMVLS8dFRcU/P8I6Or01NbkwMLMoKK0QEKALC5oLC5cMDJcMDJcMDJYNDZQO + DpAQEIgSEn8TE3YUFG8WFm1CQmZubm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB7e90AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABt + bdgmJr4LC7AMDKsODqQQEJwSEpZeXqAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC50LC5kNDZMREYoTE4YA + AAAAAAAAAAAAAAAAAAAAAAAhIb4GBrMHB6sWFqR1daBkZMFjY8hcXMlXV8pQUMlKSsRFRb8/P7s7O7Ux + MZ8ICKYJCaIJCaEJCaAJCZ4KCp0LC5sMDJYODpAQEIcTE3wUFHIWFmsYGGpWVmt2dnYAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJsAMDLEODqoQEKIREZo/P54AAAAAAAAAAAAA + AAAAAAAAAAAMDJUNDZMPD48SEogZGYUAAAAAAAAAAAAAAAAAAAAAAAAHB7gHB7AICKgpKaAAAAAAAACN + jcl3d85cXMtcXMxWVshXV8FHR7UdHaYGBqkICKgHB6YHB6QHB6QICKMICKIJCaAKCpwMDJcODo8REYUT + E3kXF24ZGWgoKGRra2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABw + cN4LC7UMDK4ODqYPD58bG5pTU515eZAAAAB+fn58fHwMDJENDZAPD40SEokuLogAAAAAAAAAAAAAAAAA + AAAAAAAICLcICLAJCaZCQpwAAAAAAAAAAAAAAAAAAAAAAAAAAAB0dLoFBagGBqoGBqoHB6oHB6gHB6cH + B6YHB6YHB6UHB6QICKEKCpwMDJYPD40TE4EVFXQYGGkaGmZJSWZ1dXUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGL0LC7MMDKsNDaUODp8ODpscHJkoKJMlJZAMDJQN + DZEPD44REYxPT5UAAAAAAAAAAAAAAAAAAAAAAAAICLgJCa8LC6VNTZ0AAAAAAAAAAAAAAAAAAAAAAAAA + AAAFBasFBakGBqsGBqwGBqoGBqkGBqgGBqcGBqcGBqcHB6YHB6QICKEKCpwNDZQQEIoTE3wWFnAZGWcj + I2NsbGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABra6pXV6N/f6IAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERNAK + CrcKCrELC6wLC6cKCqQKCqIKCp4LC5oNDZUPD5IREZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCboKCrAM + DKVQUJ8AAAAAAAAAAAAAAAAAAAAAAAAGBq8GBq0FBasGBqwFBasGBqsGBqkGBqcGBqcGBqcGBqcGBqcH + B6UHB6MJCZ8LC5kODpESEoQUFHcXF2wZGWdKSmd1dXUAAAAAAAAAAAAAAAAAAACAgK0/P6QSEpsSEpkT + E5YcHJSAgKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+UICLsJCbcJCbMJCbAJCa0JCaoLC6MMDJ4ODps2NqIAAAAA + AAAAAAAAAAAAAAAAAAAAAAA0NMoKCrIMDKYXF50AAAAAAAAAAAAAAAAAAABVVcMGBq8GBq4FBa8GBq4F + Ba0GBqsGBqgGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKIKCp0MDJYQEIsTE38VFXIXF2swMGRra2t5eXkA + AAAAAABnZ6EiIpoQEJ0PD6APD6AQEKAREZ0SEpkwMJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcgHB7wH + B7oICLYJCbEKCqwMDKgZGacAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+MKCrUMDKkODp5PT5kAAAAA + AAAAAAAAAAAcHK8HB68GBrEFBbIGBrIFBa8GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcHB6YHB6QJCaAL + C5sODpIREYYTE3oVFXEWFm5fX2lwcHBdXYcwMI0REZQPD5wODqMYGKlfX8EAAAAcHKoQEKESEpxVVakA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB/f+YVFcIHB70ICLkKCrUlJbkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAJCbkMDK0ODqIZGZkAAAAAAAAAAAAAAAAlJbIfH7YVFbkKCrcFBbUFBbEGBq0GBqoGBqgG + BqcGBqcGBqcGBqcGBqcGBqcHB6UICKIKCp4MDJcPD44SEoMTE3kTE3Q5OW0fH3oSEoYREZEPD5oODqNe + XsAAAAAAAAAAAAAAAAAODqsQEKQSEpwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtoLC7INDacPD51PT5kAAAAAAAAAAAA8PLYq + KrkoKL0mJsAgIL4VFbgNDbIGBqwGBqkGBqgGBqgGBqcGBqcGBqcGBqcHB6YHB6QJCaALC5sNDZMQEIoR + EYESEnwSEn0SEoMREY4PD5hGRrEAAAAAAAAAAAAAAAAAAAAAAABxcdoNDawQEKM6OqUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK + CrgMDK0ODqIZGZoAAAAAAAAAAABoaLszM7swML8uLsEsLMIrK8ApKbwnJ7kbG7MVFa8NDasICKkGBqcG + BqcGBqcGBqcHB6UICKIKCp4LC5gODpEPD4cSEoQTE4UQEIstLZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAaGrkODqsREaB/f6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtkLC7MMDKgODp5PT5sAAAAAAAAAAAA8PLw5OcA2NsM0NMMy + MsUxMcIvL74uLrwtLbkrK7cqKrQjI7IdHbAZGa0UFKwUFKoUFKcUFKMWFp8cHJkiIpQlJZIiIoppaaMA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOINDbEPD6UvL6MAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrgLC60NDaMX + F5wAAAAAAAAAAAB2dsNBQcI/P8U9Pcg7O8g6Osg5OcQ3N8I1Nb80NLwyMrowMLcuLrYsLLUqKrQqKrIp + KbAoKKwnJ6UnJ54nJ5gmJpWCgpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGboO + DqsREZ9+fqsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABiYtgKCrEMDKcODp5cXJkAAAAAAAAAAABubsxISMlFRctERMtCQstAQMs/P8k9 + PcU8PME6Or85Ob03N7s2Nro0NLkzM7YyMrMxMa8xMagwMKEvL548PJsAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACAgOIMDLAPD6Q4OKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrQLC6kNDZ8eHpgAAAAAAAAA + AAAAAAB4eNdPT89MTNBKSs9JSc5HR8xFRcpERMhCQsVAQMI/P8E+Pr89Pbw7O7k6OrY6OrE5Oas5OaY4 + OKVzc6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UODqkREZ57e6gA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABfX9MLC6wNDaEODphhYZQAAAAAAAAAAAAAAACQkOZVVdNTU9NRUdFQUM9OTs5MTMxMTMpKSsdI + SMRHR8BFRb1ERLtDQ7dBQbNCQq9BQa1JSa4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABhYdcNDa8QEKRBQaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6wNDaAPD5c8PJQAAAAAAAAAAAAAAAAAAAAA + AABgYNlaWtZYWNNWVtBVVc5TU8xSUshRUcRPT8FOTr5MTLtMTLhKSrVLS7VOTrUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7QODqkREZ8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6wO + DqAQEJcvL5MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaNpgYNReXtFcXM1bW8lZWcRXV8BWVr5VVbxV + VbtUVLteXr4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABERM4MDLAPD6ZLS6sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC6sODp8QEJU/P5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACAgNxmZs9jY8tiYsVhYcJgYL9gYMBra76UlM8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7YODq0QEKUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKkODp0REZVdXZgAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArK7QeHq0gIKpjY64AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8UMDLQO + Dq5pacEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABaWsoMDKgODpwREZR3d5oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2dsgICKoK + CqUcHKEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC7oNDbU1Nb0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMbsMDKYPD5oZGZMAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAUFK4KCqcMDKJ8fKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYt0ZGb9FRcsAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC64NDaMQ + EJpBQZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcXMELC6cMDKIxMaEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALC6wNDaIQEJliYp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAALC6gNDaEODp0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6oODqAQEJgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5ObYNDaMODpxERJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABaWsoMDKkODp8pKZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKkODp8XF5cAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMrsNDacPD51cXKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAXF7QMDKkODp5PT5sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC68NDaUPD50A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrQMDKsXF6EAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAMDK0ODqMhIZ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Nc0KCrcM + DK5LS68AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1ddEMDKsODqJPT6cAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABxceEJCbsLC7MwMLMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9 + Pb8NDakPD6EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Nc0KCrkMDLEODqhQULEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGLAODqYsLKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABiYtwKCrgMDLIODqkQEKJMTKsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKwODqVlZa8AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGL0MDLMNDawPD6UREZ5KSqUA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABlZcwNDaoPD6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABTU9MLC7YMDLAODqkQEKMREZxJSaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMrsODqlBQa4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8QLC7QNDa0PD6cQEKESEptaWqYA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLAO + Dqh9fbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAmJsIMDLMNDawPD6YREaAcHJxsbKsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABmZs8NDa8iIq4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOQZGbsMDLIODqsPD6YREaAwMKUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJL0NDbFlZb8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB/f+IZGboNDbAPD6wQEKgdHagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALC7kYGLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+IaGrkODrIODrBQUMYAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERNELC7t1ddUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGcUZGcAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////// + /////////////////////////////////j////////////////////4f///////////////////+H/// + /////////////////w////////////////////8P////////////////////h/////////////////// + /4f////////////////////H////////////////////w////////////////////8P///////////// + ///////h////////////////////4f//P/////////////////D//x/////////////////w//8P//// + ////////////8H//D/////////////////h//w/////////////////4P/8P/////////////////D// + D/////////////////wf/wf////////////////8H/8H/////////////////h/+B/////////////// + //4P/g////////////AA////D/4P///////////AAD///wf+D///////////gAAP//8H/g////////// + /wAAB///g/4P//////////4AAAH//4P+D//////////8AAAA//+B/g///////////AAAAH//wf4P//// + //////wAAAA//8H+D//////////8AAAAH//B/g///////////AAAAA//4P4P//////////wAAAAP/+H+ + D//////////8AAAAB//h/g///////////AAAAAP/wf4P//////////4AAAAB/8H+D//////////+AAAA + Af/D/g///////////gAAAAD3g/4P//////////8AAAAA/4P+B///////////AAAAAH8H/gf///////// + /4AAAAB/B/4H//////////+AAAAAPwf+A///////////wAAAAD4P/gP//////////+AAAAA+D/8D//// + ///////wAAAAPg//Af//////////8AAAAB4f/wH///////////gAAAAcH/+B///////////8AAAAHB// + wf///////////gAAABw//+D///////////8AAAAcH//g////////////gAAAHA//8H///////////+AA + AAwP//g////////////wAAAED//4H////////////AAAAAf//A//////j/////8AAAAH//wP/////4P/ + ////wAAAA//8D//////A//////gAAAH//A//////8D///////gAAfwAP//////wP//////4AAAAAD/// + ////Af/////+AAAAAB///////8B//////gAAAAA////////wD///4AAAAAAAf////////AH//wAAAAAA + A/////////8AP/wAAAAAAB//////////wAfgAAAAAAH///////////AAAAPAAAAB///////////+AAAf + /AAAAP///////////4AA//+AAAA////////////gB///gAAAAP//////////+D///8AAAAAf//////// + ///////gAAAAD///////////////8AAAAAP///AH//////////AAAAMB//wAB//////////wAAADgH+A + AA//////////4AAAA+AAAAB//////////+AAAAPwAAAH///////////gQAAB/AAA////////////wOAA + AIIAH/////+AAAA//8DwAAAAh//////wAAAAAf/A+AAAAH//////4AAAAAD/wPwAAAA///////AAAAAA + f8D4AAAAH//////+AAAAAD/A+AAAAB////////+//+AfwfgAAAAP///////////8D8H4YAAAD/////// + /////gEB+H8AAAf///////////+AAfh/AAAH/H//////////wAP4fgAAA+A//////////+AD+HwAAAGA + P//////////4B/g8AAAAAh///////////A/8PAAAAA8f/////////////BwAAAA/D/////////////4c + AAAA/4f////////////+DgAAAf+H/////////////w4AAAP/w/////////////8HAAAH/8P///////// + ////h4AAB//h/////////////4PAAA//4f/////////////D8AAf//H/////////////w/wAP//w//// + /////////8P/AH//+P/////////////D/8P///h/////////////g/+H///8f////////////4f/h/// + /H////////////+H/w//////////////////h/8f/////////////////4/+H/////////////////8P + /j//////////////////D/w//////////////////x/8f/////////////////8f+H////////////// + ///+H/h//////////////////j/8H/////////////////4//gf////////////////+P/+B//////// + /////////H//wH////////////////x///Af///////////////8f//8B///////////////+P///gP/ + //////////////j///+B///////////////5////4P//////////////8f////////////////////P/ + /////////////////////////////ygAAABAAAAAgAAAAAEAGAAAAAAAADAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxccwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODqV7e8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABCQrUkJKYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp11dbcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ6YiIqMAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6eswNDZt7 + e7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAANDZs3N6YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODqgAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABQULgNDZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp5RUa0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODppJSakAAAAAAAAAAAAAAAAAAAAAAAAA + AAANDZkzM6IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ6MODpoAAAAAAAAA + AAAAAAAAAAAAAAAAAAANDZgzM6EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABr + a8QNDZhZWaoAAAAAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABoaKlMTJkqKpY9PZNMTJR1dZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAANDZghIZ4AAAAAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhMQWFpcLC5EKCpIJCZIJCZELC5AMDJMyMo94eIUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0NKgNDZhxcakAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdHZwKCo4HB5EICJsHB58ICJsICJMI + CI8KCo8REZFTU4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZczM6AAAAAAAAAAAAAAAAAA + AAANDZgzM6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eMYWFpUICJEGBp0G + BqUGBqcGBqUGBqEHB5sHB5EJCYwLC5E4OI4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZgNDZgA + AAAAAAAAAAAAAAAAAAANDZg0NKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABN + TbIXF5cICJsGBqUGBqcGBqcGBqcGBqcGBqUGBp0GBpAICIsLC48xMY4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABLS68NDZdgYKoAAAAAAAAAAAAAAAANDZk0NKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB+fsgcHJoICJsGBqUGBqcGBqcGBqcGBqcGBqcGBqUGBp0GBpEICIsLC5A+PosAAAAA + AAAAAAAAAAAAAAAAAAAAAABtbboNDZdYWKoAAAAAAAAAAAAAAAANDZlSUqoAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIpoLC5QGBqEGBqcGBqcGBqcGBqcGBqcGBqcGBqUGBp0G + BpEICIsMDJFUVIsAAAAAAAAAAAAAAAAAAAAAAAAvL6INDZiAgLAAAAAAAAAAAAAAAAAODppaWqsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjI50VFZUHB5sGBqUGBqcGBqcGBqcG + BqcGBqcGBqcGBqUGBp0GBpEJCY0REZF5eYYAAAAAAAAAAAAAAAAAAAANDZgXF5oAAAAAAAAAAAAAAAAA + AAANDZlPT6YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaL8hIZkKCpIG + Bp0GBqUGBqcGBqcGBqcGBqcGBqcGBqcGBqUGBp0HB5EKCpA5OY0AAAAAAAD///8AAABhYbkNDZdFRaMA + AAAAAAAAAAAAAAAAAAANDZgxMZ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAwMKEbG5UGBpIGBqEGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqUHB5sICI8MDJNycosAAAAAAAAA + AAAkJJ4NDZeBgbEAAAAAAAAAAAAAAAAAAAAMDJYNDZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACTk9UwMKAbG5cHB5sGBqUGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqEHB5IK + CpA7O5AAAAAAAAAAAAANDZggIJ0AAAAAAAAAAAAAAAAAAAAAAAANDZUMDJRra6MAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzc8M5OaQjI50HB5sGBqEGBqUGBqcGBqcGBqcG + BqcGBqcGBqUHB5sJCZAfH5AAAAAAAABoaLkNDZhZWaoAAAAAAAAAAAAAAAAAAAAAAAAaGpwMDJNDQ58A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdXbdERKg0NKINDZUG + Bp0GBqUGBqcGBqcGBqcGBqcGBqcGBp8ICJATE5YAAAAAAAA5OagNDZkAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAMDJYNDZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABkZLtPT6xFRaclJZ4KCpwGBqEGBqUGBqcGBqcGBqcGBp8ODpMnJ51xcZQAAAA1NaINDZgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABfX78NDZhJSagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACIiM1ZWbJUVK5LS6wsLKIbG6MVFacUFKoXF60qKq43N6c3N6N4eIQAAAAu + LpgNDZVkZJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0NKgNDZl7e6oAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqartgYLVcXLFXV7FTU7NQULdNTbhJSbVF + Ra4eHplQUIhERIs8PIcLC5A2NpEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZcoKJwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRsQoKLEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAClpdyDg8ZnZ7lj + Y7dgYLddXbZYWLQmJp0aGo8YGI4KCpIODosKCo4SEo97e3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe + HpYNDZVhYaIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABgYMgODqM+PrMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTKJDQ5YICJkICJ4HB5kNDYkKCowoKIhsbIUAAAAAAAAAAAAA + AABxcaBubpxubpcjI5AMDJM7O6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbMsbG6cmJqp2dsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2drEYGJoICJ4TE6obG6kGBpQICI4KCo4Q + EI1QUIE2No8TE5MMDJMMDJIMDJELC5ELC5ENDZZlZbkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7e9EoKKwODqBHR7J5ebsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbK1XV6c8PKNXV6Z6eqUAAABmZrFeXr4zM7UG + BqUGBqEHB5sHB5IICJAKCpAJCY4JCY0KCo0LC48LC5AMDJMjI54AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAoKKoODp0ODpxCQqpwcLEAAAAAAAAAAAAAAAAAAAAAAABsbK08PKENDZgNDZcNDZcNDZcMDJYMDJQV + FZE1NZAmJpIHB6UGBqcGBqcGBqUGBqEHB58HB5kHB44KCosLC5AyMpljY7IAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABCQrINDZsNDZkNDZk+PqNqaqlxcahERKIWFpkNDZcNDZYNDZgwMKQA + AAAAAABMTLEZGZsMDJMKCpAICJIHB50GBqUGBqcGBqcGBqcGBqcHB58HB5BMTHgAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdXb4ZGZ0NDZgNDZcNDZcNDZcNDZgw + MKV5ecIAAAAAAAAAAAAAAAAAAAAAAAAAAABSUq8QEJEICJMHB6EGBqcGBqcGBqcGBqcHB58HB48QEIle + Xn8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1 + Nas/P65+fscAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8PKYYGJgJCaAGBqcGBqcGBqcG + BqcGBqEHB5IJCYwQEIsjI4oSEpMNDZknJ51XV6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERKku + LqgSEqMGBp8GBqEGBqUGBqUHB50GBpIHB48JCY8LC5ATE5EeHpgNDZkYGJxtba4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB6erNeXrJhYbdzc8UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAqKpo3N6Q8PKYfH5oGBpMGBp0GBqUGBqUGBqEHB58HB5kUFIl1dYEAAABjY7INDZkNDZkz + M6EAAAAAAAAAAAAAAACBgbBaWqs9PaQgIJ4NDZsNDZsODpwODp4mJqtxcc4AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC5AKCoxGRppISKgqKpsJCZMGBqEGBqcGBqcGBqcICJ8JCZJHR4kA + AAAAAAAAAAA0NJ4NDZcWFpk0NKANDZoNDZoNDZkNDZkNDZkODpoxMadiYrsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS7ALC5ALC5AAAACIiLpSUq44OKUTE6MGBqcGBqcG + BqcHB58JCZEmJop5eXlpaZZqapYAAABgYJsfH5oNDZoZGZw8PKtiYrp+fskAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvb9NAQLQ6Oqo2NqM0NKAyMp4xMZwxMZ0xMZ0y + Mp4yMp8zM6AzM6AzM6AzM6AyMqBDQ6QAAAAAAAAAAAAAAAAAAAAAAAA9PacMDJElJZQAAAAAAACUlMdd + XbRPT7U3N7EdHagXF6cTE6EYGJctLYgcHIcLC5ALC5AYGI1lZYcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3N7MODpwNDZkNDZcM + DJYNDZUNDZUNDZYNDZcNDZgNDZgNDZgNDZgNDZcMDJYNDZYXF5t+fq0AAAAAAAAAAAAAAAA5OaMMDJIv + L5oAAAAAAAAAAAAuLqBgYLVaWrNNTa5BQao1NagpKaAPD5IHB5AHB5AICI8KCo4QEI5mZooAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB4eMh1dcV0dMUAAAAAAAAAAAAAAAAAAAAAAAAAAACEhMtAQK0NDZgODppoaLEAAAAA + AAAAAAAwMJgMDJNSUp8AAAAAAAB+fscMDJRQUJ9sbLJmZrdaWrFLS64qKp4HB58HB58GBp8HB5sHB5EJ + CY4eHo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA1NasODpo4OKV2dqt1dZ4cHJEMDJNqaqsAAAAAAAB0dMYNDZeBgawAAAAAAACSkr0pKZMICJ8HB6cG + BqcGBqcGBqUHB5sICI4LC48/P44AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABfX8ANDZkMDJQLC5ELC5ANDZcAAAAAAAAAAAB5ecwNDZl6erEAAAAAAABQ + UKgJCZEHB58GBqcGBqcGBqcGBqcGBqEGBpMJCYwQEI9+fn4AAAAAAABwcLwkJKgYGKMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbG50NDZUNDZdgYLoAAAAAAAAAAAAAAAAN + DZs3N6YAAAAAAAAWFpkLC5IHB58GBqcGBqcGBqcGBqcGBqUGBpsICI4KCo1NTYdQUJ4YGKIkJKd5ecMx + MakZGaMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABDQ7IODpoAAAAAAAA9PaYxMaEeHqMSEqUKCqYGBqcGBqcGBqcGBp8GBo8JCYsMDJIX + F5xmZrsAAAAAAAAAAAAaGqFmZroAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODpo3N6IAAABqarFDQ6g8PKU5Oac1Na4rK7IjI7EeHq0W + FqEbG5YeHpU+PpwAAAAAAAAAAAAAAAAAAAB6es0ODp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQa8NDZmAgKwAAABgYLVRUa1LS6lH + R6tERLI/P7Q7O684OKU1NaA1NaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp9aWrYAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZlISKYA + AAAAAACEhMlfX7VaWrFUVLBRUa9OTqxMTKpKSqxtbbgAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsAaGqEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAANDZk0NKMAAAAAAAAAAAAAAAB6esFoaLdkZLRhYbRgYLV/f8IAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAODp9pab0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAANDZpISKkAAAAAAAAAAAAAAAAAAAAAAAAjI55zc7IAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABFRbsbG6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxccMODppycrQAAAAAAAAAAAAAAAAAAAA7O6oiIqEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fdkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS7QODpwAAAAAAAAAAAAAAAAAAAAA + AAAODp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJqY4OKkAAAAA + AAAAAAAAAAAAAAAmJqc3N6cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODp9ubroAAAAAAAAAAAAAAAAAAAAODp0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAODqAAAAAAAAAAAAAAAAAAAAAAAAAbG6NJSbEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlZcIwMKwAAAAAAAAAAAAAAAAAAAAAAAAAAAApKaoODp5RUbQA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJqp1dcIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB7e88ODp4ODp5OTrEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGqcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsEODp4aGqN0dMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABubs9b + W8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsQODqeEhNcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA5Ob8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////// + ////////////9//////////z//////////P/////////+f/////////5//////////j//////////P9/ + ///////8/z////////5/P////////n8////////+Pz/////8D/8/P/////AD/x8/////8AH/nz/////g + AP+fP////+AAf48/////4AA/jz/////wAB+PP/////AAD58/////8AANHz/////4AAcfP/////gABz8f + /////AAGPx/////+AAZ/n/////8AAn+P/////4ACP8f/////4AA/5///P//wAB/j//+P///gDwP//+H/ + /+AAA///+D/8EAAP////B+AAAD/////AAYAB//////AH8AD//////j/4AAf///////wAAf/D/////AAQ + 8AP////8ABwAP/////iAAgP//AAB+MAA///+AAB44AB////j+DjAAH//////AMYAP/////+BxgAY//// + /+HmAAB//////+YABz//////8gAfP//////xAD+f//////mAP5//////+eB/z//////5+f/P//////Hz + /+//////8/f////////z5/////////Pv////////9+f////////n8f///////+f4f///////7/4f//// + ///P/4///////9///////////////ygAAAAwAAAAYAAAAAEAGAAAAAAAABsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7FlZXoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAByctIxMYgA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAASEqdjY3UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPT8c1NX4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAASEp5tbXUAAAAAAAAAAAAAAAAAAACCgsJfX3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKLg8PHMAAAAAAAAAAAAAAAAAAABSUr4x + MXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/ + f9YaGpB2dnkAAAAAAAAAAAAAAABGRr0jI3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODqVISGwAAAAAAAAAAAAAAAA9PbofH30AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAB7e5I7O28tLWkyMmBISF5ycnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCQsUjI4AAAAAA + AAAAAAAAAAA4OLkgIH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSUqMODpAPD4sQEIgSEn8WFnAhIWFISFoAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAQEJlYWGoAAAAAAAAAAAA2NrsjI30AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATE7AHB6YH + B6IICKAJCZwNDZETE38YGGg1NVh3d3cAAAAAAAAAAAAAAAAAAAAAAAAUFKwxMW4AAAAAAAAAAAArK74o + KHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAREbsFBa4GBqcGBqYGBqYHB6MKCpoREYcYGGwxMVd3d3gAAAAAAAAAAAAA + AAAAAABVVcQXF4QAAAAAAAAAAAAsLL0vL3YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFsAFBbEGBqgFBaYFBaYGBqYG + BqQKCpwQEIkYGGw3N1cAAAAAAAAAAAAAAAAAAABiYr0ZGYYAAAAAAAAAAAAsLL00NHQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAdHcYICLcFBasFBacFBaYFBaYGBqYGBqUKCpwREYUZGWZLS1oAAAAAAAAAAAAAAAAbG6A3N3kA + AAAAAAAAAAAsLLwyMnMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaN4TE8AFBbEGBqgGBqcGBqcGBqcGBqYGBqQLC5gU + FH0hIWBxcXMAAAAAAAAAAAAODpVvb4YAAAAAAAAAAAAwML0mJnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcsN + DbwFBa4FBagFBaYGBqcFBaYGBqYHB6IODpAXF25CQlsAAAAAAABLS7YZGYkAAAAAAAAAAAAAAAA4OL4Y + GIN4eHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8kQELoFBa0FBagGBqcFBaYFBaYGBqUKCpsTE34lJWAAAAAA + AAAPD6RDQ3wAAAAAAAAAAAAAAABNTc4QEJhPT2YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHh+U1NcwcHL4GBq4F + BakGBqcGBqcGBqYICKEPD4sbG297e38AAAANDZpubn4AAAAAAAAAAAAAAAAAAAATE7EqKnsAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACQkOdERNA0NMYVFbYGBqwFBagGBqcHB6QVFZUsLIBvb3UAAAAQEI1jY28AAAAA + AAAAAAAAAAAAAAAAAAAQEKFXV24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABaWtdNTc9CQsgyMr8tLbsz + M7o8PLE2NpFRUWhoaHwTE3xDQ18AAAAAAAAAAAAAAAAAAAAAAABYWMIjI4F3d3gAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbW7deXokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAChoehpadlXV9FTU81PT8pBQb8XF50bG4IREYISEnoqKl5/f38AAAAAAAAAAAAAAAAA + AAAAAAASEodAQGIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUMUqKqFg + YIoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7IICKcK + Cp8UFIoXF202NlhtbXAAAAB3d4VaWnFSUnFGRnIQEIgyMnwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlZcogIKpDQ4pqan8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABxcX55eX4AAAA8PK4kJLAgIK8KCp0PD4kUFHUiImYZGXUREYIPD4oMDJUKCpoZGZ0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8fNMdHbMe + Hpc8PHlcXHAAAAAAAAAAAAAAAAAAAABUVH0iIoQPD5EODpUNDZgbG4kyMoEkJJQGBqYGBqUJCZ8LC5cM + DJEMDI0KCo4aGp1KSrQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLr4ODqIcHIo2NnBHR24rK34QEJIMDJswMKmCgsYAAABp + adEiIsAFBbIEBK4FBa0GBqgGBqYHB6QICJ4NDYVLS2MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTMoL + C60LC6YjI6pwcMAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEsEEBLUFBasFBacGBqYICJ8PD4gcHGpOTl9a + Wm1UVGxnZ3MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f94e + HrwODrAGBqkGBqgHB6MLC5YQEIQSEngTE3MWFn4TE4wtLXxkZG8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAB9fYhnZ3tgYH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGrQqKrQWFrIFBbAGBqoHB6MJCZ0MDJIYGHVubnYAAAArK6QX + F4xFRWx4eHsAAABqan9NTXc0NHkfH4YTE5MPD5omJqdlZbUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZtAGBqQ7O4VLS7UgIL8G + BrEGBqgGBqQLC5cSEntMTGMAAAAAAABAQIIREZATE5EPD5gNDZ4ODqU1NbZmZsgAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAB4eJ5MTHdFRW9AQHA/P24/P24/P24/P24/P29DQ2tFRWtLS2tnZ3AAAAAA + AAAAAAAAAAA4OMELC5lubn8AAABiYtE0NMEYGLIMDKsODp4aGoU5OWQxMW4fH3NAQGFlZXV1daIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS8kUFLULC6gLC6UMDKMMDKIM + DKMMDKMMDKMMDKMNDaIPD5sXF4pNTWsAAAAAAAAAAAAvL7AQEI0AAAAAAAB3d81GRsJISME4OMErK7ck + JKITE4UODokQEIYTE3Y3N10AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZWcgREaJAQHp4eHoAAAAgII4W + FoEAAAAAAABDQ8MqKox4eKVnZ9FOTsAbG6sICKMICKEKCpoREYYYGGlMTFwAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAeHrYWFpkmJoEQEI0wMH4AAAAAAAA6OsY4OHkAAAAAAAAtLakFBasGBqgGBqYHB6QL + C5gUFHslJV5+fn4AAAAAAABcXIZUVHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRdAHB7YQEKkAAAAAAAAAAABpadEd + HZB7e30AAAAICLQFBa8GBqgFBaYGBqYICKEODo4WFm9KSl9ERHohIZ1vb7QkJKhjY34AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDapKSnB1dZAoKL4fH70VFbANDaoHB6cGBqUKCpoREYUVFYBi + Yp8AAAAAAAAAAAAjI5cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfX9AcHJJ8fIBWVrI6 + Oso2NsQyMrsuLrYpKbInJ6ooKJh7e5AAAAAAAAAAAAAAAAAyMr1SUnoAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAQEKVRUXAAAAB7e9NMTNFISMpERMNBQbs/P7FRUaAAAAAAAAAAAAAAAAAAAAAA + AAAjI5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH6pISHcAAAAAAAAAAACAgNpYWMZY + WLh/f7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7ZhYYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODp1tbYMAAAAAAAAAAAAAAAAUFKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfX7IAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEpcAAAAAAAAAAAAAAABPT6RKSokAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5ec8uLoYAAAAAAAAA + AAAAAAAUFJkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABFRbxfX4UAAAAAAAAAAABiYtM5OZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGaYAAAAAAAAAAAAAAAAAAAA1NcMxMZNj + Y3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2 + No8AAAAAAAAAAAAAAAAAAAAAAACCgtgYGK8tLYtiYncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABlZbp+fpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtbdMXF6w/P4sA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9PbUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///////8AAP//+f///wAA///5////AAD///z///8AAP///P///wAA///+fP// + AAD///58//8AAP///jz//wAA////PP//AAD/wP88//8AAP+Af5z//wAA/4AfnP//AAD/gA+c//8AAP+A + D5z//wAA/4AHnP//AAD/gAOc//8AAP/AAzx//wAA/+ADPH//AAD/4AE+f/8AAP/wAT8//wAA//wAPx// + AAA//gAfn/8AAI//+Agf/wAA4f/IAD//AAD4PgAA//8AAP8AIAP//wAA/8H8AD//AAD///wAD/EAAP// + /gBCAQAA///8AGAfAAD4ADxAA/8AAPgAHMAH/wAA//+EwAP/AAD//+DMAZ8AAP//8cQADwAA////4ADv + AAD////gAecAAP////ID9wAA////84fzAAD////z3/sAAP////ef/wAA////57//AAD////nP/8AAP// + /++P/wAA////78P/AAD////P8f8AAP///9///wAA////////AAAoAAAAIAAAAEAAAAABABgAAAAAAAAM + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCzAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWlq+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAPT22AAAAAAAAAAAATU27AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT22AAAAAAAAAAAAPT22AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGC7Hx+rEhKo + UFC1AAAAAAAAAAAAAAAAAAAAAAAAWVm+AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjIzIBganBganBganBganBganhobCAAAAAAAAAAAAAAAABgan + AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + iorFBganBganBganBganBganBganhobCAAAAAAAAAAAAPDy1AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABganBganBganBganBganBganBgan + AAAAAAAAAAAAFBSqAAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAXV24BganBganBganBganBganBganQkKwAAAAf3/GWVm9AAAAAAAAPDy1gYHH + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyutBgan + BganBganBganBganBganAAAAOjqzAAAAAAAAAAAAdHTFPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyutBganBganBganBganBgankZG5NzevAAAA + AAAAAAAAAAAAPDy0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAg4O/Hh6pBganBganBganMjKqERGodna8AAAAAAAAAAAAAAAAISGtAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXV3Ba2vFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + goK0BganBganERGoc3O5eHi+bW2+YWG8BganAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAeHjIPj63aGjCAAAAAAAAAAAAAAAAVVW5ExOqLCyuQECvJiaoBganBganBganBganNjavXl65 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALy+xIiKuFBSq + Skq5AAAAAAAAAAAAXFy4BganBganBganBganJiaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZWW1BganBgan + BganBganBganKSmrLCyvf3/FAAAAAAAAAAAAAAAAAAAAh4fNfHzLAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFC1KCiqEBCnBganBganBganSEitAAAAW1u3ICCsOzuz + FBSqLy+xWVm+AAAAAAAAAAAAAAAAAAAAAAAAAAAAXV3BPj63PT21PDy1PDy1PDy1PDy1PT21AAAAAAAA + AAAAOTmxZ2e4nJy7BganBganBganGxunHBynNDSsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT21cnLCAAAAOjqzk5PFAAAANTWtR0etJSWnEBCm + BganBganNTWtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAgYHHBganExOqAAAAAAAAOTmxAAAAEBCnBganBganBganBganhYXAgIDGPz+3AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + OzuzAAAAERGoBganBganBganBganLCyuAAAAAAAATU27AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU1O4AAAAERGoBganBganBganAAAA + AAAAAAAAAAAAeXnKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAPDy0AAAAAAAAW1u2ODiwAAAAAAAAAAAAAAAAAAAAT0+9AAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGjCAAAAAAAA + SEi3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeHjIAAAAAAAAAAAAZ2fCAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + TU28AAAAAAAAAAAAWlq/aGjCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPz+3e3vL + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////////////7////+/////3f///93//4f + t//8B7f//AO3//4Dt//+ATP//wFz//+Ae///wD3/z/wB//HgA//+HA////4A+f/+AgfwDgD///JAf//4 + 0A///9A3///oe///7Pv//+3////d////3P////8///////////8oAAAAEAAAACAAAAABABgAAAAAAAAD + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAeXmRAAAAW1uRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT2THBx6Wlpy + AAAAAAAAV1ekAAAAVVWRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwu0BgamDAyVTExsAAAAdXW/AAAA + XFySAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWHYBwerBgamEBCIAAAAYGCZAAAAQkKNAAAAAAAAAAAA + AAAAAAAAAAAAgoLJAAAAAAAAZmbXGxu0GBimX1+CaWmIAAAAAAAAgoLJAAAAAAAAAAAAAAAAAAAAAAAA + goLJAAAAAAAAAAAAdnagGxugIyNyfn6QYWGNamqTAAAAAAAAAAAAAAAAAAAAAAAAAAAAUlKWXV2ScXG5 + fHzOIiKwBwekFBSEenqaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHR2rCAih + ISF1V1eIbGyLa2uVbm6mAAAAAAAAAAAAZGS2WlqtY2OzWFikAAAAXFykAAAAPT2zIyOaGRl+d3ePAAAA + goLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoLJbGy4AAAAa2uTEhKvCAikJSVzAAAAenqZAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAZWWthoa/SEjBfX2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAdnauAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + goLJbW2qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA//8AAP7/AAD/XwAA418AAOFfAADhXwAAsG8AANwPAADgHwAA/wEAAMKFAAD8hQAA/4cAAP+/ + AAD/zwAA//8AAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAIABJREFUeJzsvWe0HNd1 + JvrtU1XdfQMuLiJJMOAyCiRNEhQpUhITJIuyRHFI2JQt2ZoRMbZH4zDrkeuNxpb9bJOzbI2X7PGS9GRL + shwo28p6HjGIpChRBDMYACIwIud8cUPnrnDO+3FqV+2q7otwcUEE9l6rVufuqur6vp33AbrSla50pStd + 6UpXutKVrnSlK11pl1U9PfdtKBaXAKAOW1e60pVTVdaWSnc91dtrnuzrM1s8790AXABevLkAHHSJ4KQT + dbx3oCsnvgy77sJ9St1rAGgAWwqF+wAUAfQAKAEooEsCJ6V0CaArhxTPmFENDBoABkBAdPlPi8XfBDAt + 3vpgicCDvaa6JHCSSJcAunJImR5FW/uM+Re2ADSA0PP+EMAggBkApgPoh7UKXJzCBDDqukN7PG/h8d6P + qZIuAXTlsGRWGH5Zw1oAGoAmOvMrhcKnAMwGMBPAAKxLUMAp6ArUlRpc3tv7pRd6eja/UiqtfHhgwDw+ + bdpTq0qlO9A5FnJSHP9JsZNdOSHEebK3d2mL6IaICBERmsC+X61UfgdAA8AYgAMARgFUAfiwXHFSS12p + wbXF4t37HeeukGgwIrIkGN8aIri12o23BcGrAKJ4C+Nb5swTVroWQFcOV8iLom9zHEADUERz/59i8RZY + V2AQNh5wSlgBdaUGV/X03PtsT8/m3Y5zT4to0CdCAMAnQhBvIVB+VmvAHv8ATrJ4SJcAunK4Yq5rtb6t + gTLHAQyAC4rFj8D6/wOwBNALGws4KQlg1HWHXurp+eYzPT2juxznnpZSg75S8InsphSC+HFAhD2t1pf/ + KooiAHMBzELqCnk4Cc6Bc7x3oCsnjRAA507XPStS6ipNBE0Eh2igFEVb1mg9Amv6+gBaSM3gE9oEZhl1 + 3aE7isUvbfK8+2pEC0PW8LwpZbfY/QmJqpuaza/9YaOxHBb0vbCgNziJ3IAuAXTlSIRuJxp1Xfc/6xgI + mgj9jkM/9f3XYC92JgAfFgQnNADqSg3+WrH4uQ2ue19VqfdGRAhisAe88XPxbRPY/Mj4+N9+3fe3w2ZA + +mDBD9hj5uMP4scn7PG7x3sHunJSif54EKx8qFB4HcClBBsEO811r5lP9KOtxrRg3YAKgBpSS4BDByeM + 1JUaXF8o3P28Uja4B7BmT27lfQ787Wi17v/zavUJWI0/B9YyasEeXw0ngdkvpWsBdOVIhT7tONMCpT7I + kXANYA5Qey4MtyHVgNIKiI7f7maFNf46z/tumegjIVEpiE38vMYPhNk/bszafxsb+7vvtVpbkWr9AizY + AwB12OxHOb5twJ6DE9oN6loAXTkSMQCivUHw4HTX/Qup5i4oFm9As/kUrGbsj29rAJo4QUhgbbG45CXH + uacFDEVCu0eABTpiK0ApRPHzTWB4Za32wL82m5tgg3szYBWngQV+ExbwFaSWTzN+7YQGP3ASmSpdOWHE + AVB8oK/vpUCpSzlQponwcK329R/YfPg+ALsA7AEwAqsdAxwnMGwrFBZtct37fGCIzfrIpvAyZn4kSMAH + 6huazce+UqsthwU+VzkCqZVTAzAOe4wjsHUQY/FzDVgL6IQmga4F0JUjFVsJrPXDIdGlBIDI6pErisWr + fxAE62C1fx9S4MhYwNsmo6479Ibn3fcW0SIOWIYdgC/9fR+ob2+1nvpOrbZ8lzEEm9/3YJVliNTcr8AC + fTTeGPgVpBbACR0ABboE0JUjF+v2h+ED5Dh/oACQsdf4HMe59Gxg2nar/SQBeEgtgGMOiIZSg+sKhbtX + KHVPJqAHtAX3+H4rBf5Lu4xxYIt5XNhaGc5uNJCa+2NiY+DXYcmOzf8TvhKy6wJ0ZTKiAJTu7+9/KwDO + DuPAWUSEF5vNH3692XwOwDCAHQB2w5rGXB58TAlgR6GwaIPr3ucTDUVAsl+dNH7IGt/3n/x2tfryLmMU + UsJi4LOfz1q/jBT04/Fx1ZCa/CdV/UPXAujKZMQACAvGPBsR/ToZk7gBFxaLV6HZfBlW+0sr4JgGAxtK + Db5VKNz7lk3rdQR7CCQBPt+Y+jbfX/rtavWlnVbjc/UeA58zGTK6X0Y78KXWl0WSJ4V0CaArkxEDQBei + 6Omm6/46AVDGgAAMKnXeVUrNWaF1E5YAuDTYQ9ogNKUA2ee6C5d73n3NuIKPwc/pPGn6+0S17b7/xL9l + gV+ABb5BFvg1WNCzv88pPk7zsa9/whc8TSRdAujKZEWv9/37z3CcrykSnqQxuK5YvHRFo7EPFvy9SJtj + HEyxeby+WFzymlL3tWl7zudzcI+otrPVevyb1eoLO+x1z5YJA58rGBn4bO7zJk39JtIIPx/PSQd+oEsA + XZm8mN/VeuQhYFtozDmKKLGdzy0U3o1G41m0uwENWI05JbKmWPzSdqXukuY+F/KwBeAT1Xb5/mP/XK0u + 226v9z6kzUoyl99AO/AryAJflviedOZ+J+kSQFcmKwaAcY151if6Dc4EEBH6lTp9oVJzVmXdALYCpsQN + WFUs3ndAqSVagl9svlLV3b7/yD/Was9uMaaAlIj4mg9gAX0kwD8pGnyORLoE0JWjEV3S+ummUr9BsLZ0 + ZAxAhI/29LxvVa0m3YAirK/NwcBJA+jVYvGLB4iW6PiLpL8fEGFE6599eXz8B5ss8LlTj8t2uWPxHQ18 + li4BdOVoRCMIlpLjJJMviAhkDE73vAUAHoXVur1orwmYVI58l+ctWk90N3cjckVfBKBpzPqf1mp/+50w + HEc6oKSENPYQIAt8Bv87DvgsXQLoylHJB6Joy0PAtgg4hxAXBRGhRDS4yHHOfDKK6shmA7i4hjAJUO1U + 6h5uQErmb9nxZOuXlMt/ADuUYzbSZh3AArqJrsZvk+5EoK4cjRgA2jXmWRiTWgFxPGBBsXguLOhlNoDX + EJhUEVpENKiJMgSgAURKzRsimo90Kk8xfqkOW6q7F7Y/YWe87Y6fG4Yt7OlUyXdKgx/oEkBXjl5MUevV + XBKcrBVmDM4rFC6HBbx0A5gAJnXt9RnzL/FUYkg3gIC+m4vF62DBX4IFL4N/Hyzgd8KSwDse+CxdAujK + 0Yru1XolAz+ZgkmEfqLTLldqFiwg83GASQ3MnB0E32QXgJPvbAVcUip9OP4tgjXlK7BlyHthOxP3oQv8 + jHQJoCtHLe/1/aeIXYDYCkDsBlxbKi1AuowYLyXGM/SPmADO0LpcAL4lpxMjvl8imv7Jnp7LkFb0VZF2 + 7I2gC/w26RJAV45WbD0A8GriAoh4wHmFwmXIugEyDjCp66/m+59PSu+IYIyx943BlaXSe5EaBpzuq8e3 + HOh7xwOfpUsAXZkK0UVjnk56AoxJLIBpSs29LHUD2ALIZwOOSG6Joq1kzPcBwLDFEUsv0cCvWyuAvRK5 + otk7IrJ/JNIlgK5Mheii1qsZiDIQSACuKZXehZQAZHPQZAZoGgDm4Wbzjw1QTn7TmIR8riiVrou/v5D7 + rZNqYOfbIV0C6MqUSEHrVQxAOSTEADjN8+bDgnCq3IDoq8Yc0Fr/Mwce2ZRQxqAPmP7bvb03Ip1MlG9I + 6pJALF0C6MpUiLk2CFYlWQCRDoQxOM11zz+diJcNk9mAybgBbNIHH280vgBjdqlY+zvxpozBpYXCorOI + 5qB9xaJJxx5ORemeiK5MlRgXeFZxU5DYYAzeWygMIZsN4N6AyWhkbgNoDQfBZxUAN0cCRaB4R2/vIqTL + lvUjO/SjawWgSwBdmTrRnjGrgdQk50AgAJxfLF4IC3iuCThakzwC0Po931+qtb5fan++vdjzFr1bqXNg + CaDTwp3veOmehK5MlZhSXBGo4ixAUhoMYJbrnoWUADgbUMDkNDK7ASGA5vcbjT8joOLCWgKSDBb39S1G + SgDsCpz0qxdPlXQJoCtTJlwRCIhYQGwF9BANXJKmA3ljn3wyK1Qluf77jdnbCsO/dbVOwM8EcAbRgl/2 + vMthV/PhFX3kxN93NAl0CaArUyXmqiBYLcuB88i6uqdHugH5OMBkrsVkau+nW62vamNWuMakVoDWUABu + LJVuQ2oF8HwAJp+TngBGXXdoR6GwqKHU4JF+tksAXZlK0a4xz8oaALYE4nTgWbAmvySASZcFI3UFfACN + LUFwLxOAG7sgSmtMB07/TLF4A1IrgDMSJ21AcHVPzxef6Oszj/f3m5dLpc2vFYtLN3jeVbDHxBsT64TH + 1yWArkylGA/YIkuBORBIAGY6zpmwF2YRqRsg6wEmA8QkI/C5MFwRav2AozUUb1wc5Hk3n0M0FykB8GzA + k84K2Od5Cw8Q3c3rF/JMxGHH+UXY45JzGA96brsE0JWpFFM0ZrWcCyDrcT2geK3rzkPqBkgCmOxK1Rkr + 4JUg+GsCKg5bAfHWa8zgJ0qlm5FaAZwWPOkCgptc94vJTAQxE7FsCW4w3vKuTkesdwmgK1MqvVqvAnLF + QEgrAy8sFs9GOwFIc3UykgQEv6D1ulYU/UuSiTAGpDXIGFyg1PvPSq0ATgueVMVB2wuFRVWiRYnmR7rm + wbi1hObCTkSagXQ2woSuzklx0F05acRc7ftPTdQTQABO9zx2AyQJcBzgaAiAA4Ktt6Lo29wbAB03DBuD + gjGlT5dKt8ACQ8YCeGGQE94K2Oa698hFTnkQqg9U/1e9vhTAmQDmwRLBdFgrYMK6h+5MwK5MtRgXeDYA + ru+UDRhQajaycYB8JmBSswLjz0TLFy26IOzru6UVBMMolWbz2DB4Hpy+PpwxOvq+i7WeuXdkZM1rO3c+ + 9s1t215AOgeQLYkTsltwR6Gw6E1gEa9+FLAFAGAkipa/Zcw0WEz7sOeYlzCfMM7RJYCuTLWYgjGrG0TX + cx0AEUEZAw2g1/YEuEhJQGYCJmUBjN9yy6UjM2b8341i8RcDovnKGDgAdPybId83BoWZMzHPmHedOWvW + u9594YW/+infHw2q1edbw8P/8MsvvPBzZNctkPNGjrtscZx7OPCXLH6iFEIifLtcfhx2HqJCumQZL4DS + KSsLoEsAXZl6sa3BKsWyvPLIGHzA885eGgQVpASQjwMc1gKiu2677XOVYvG/7Jo27TxtDCKtoXkWgZhJ + IEuSjTF2I4Kx7sGMwrRpHyv193/sZ6ed9jqGh79w83PPPQAkylWuAHTciGDUdYdeVmoRz0DkacgBEfaF + 4fMvaG1gXRsmrnxgs+O+dwmgK1MvUfQkuW42BmAHdwIAepXiSjzu15eZgIP64bVarVD+rd/6HxWl7ip7 + 3hytNUwQQDP4geSWSSD5QkEKOh5fbuLnIgDkupfSaaf9609uvvlHP1+79k/+etu23bCalCcIMTG97USw + 3vPukSm/UCyB9vNabRnSgGaA1JWR+91xn7tBwK5MtZgbw3ALkLU75bSg0113DizY2Q2QLsCEBLD7Yx/7 + g12/+Zvby677F5pojvZ96CCwWxjCRBFMGAJhCASB3cIQFAQg8djE9/nzURhChyGiIEAYhkBPzy8vWrDg + kc+fe+7VyLYSH5fCobpSg2Wixfmof0iEca3X/TSKxpFd+YgXP+ERaGzJtEnXAujKlMtrxeIN68TjTEEQ + EVa3Wlthrz3e8hN7MoHA0Q9/+KaRmTO/UlbqMqM1dBAkcwA1m/Rig5gRmEhcFgz+4piMNFKLQapIct35 + l1100QP/3fc/8Tc7d76GdK6gXBz0bbEE1hcKdwVEg4n5z6shEWFZtfozpKsfhUgXQJEEMOH+dgmgK1Mu + e5T6s8wTHAgE0NK6tTwMR2A1qYPU9Gf/P2OVbr3llq/unTbtd6E1dBQlIGdfPwGv1qlvnyMBfpyQUAx8 + ADZNSGSJBHa9AZMGL3uuvfDCr36gUvntpeUyk1Yt/iSvHnTMSeCAUkuiXOFPRIQGcODffX8PrO8PWKDX + Yachy+nHXQugK2+PbC4UFr1BdJN8TsYBNofhW7mPdOwfGlu06JJ9s2Z9twZcjjBMAK6BBNQMbA0kpGBy + wI8EGZhcbMAga50kC44gHTZKwFmfOP/8zy5dufLPkXUBGkgDbseMBN4qFu/cQjQkgc+xgDfr9ceQdjZG + sNqfwc8WgI+DBFW7BNCVKZU9St2Zn9kPIAHZ443GGmQBI6PrBgB23377B3YQPYgo6suDPWPuI43qswYH + kAQEmSwkMfB9JiX5w0wwrNZ1HLic3tv7oY9On/7Qo+PjrwEZT8IgtQSOiex3nKz2R7IW4vDfNxqvw5b9 + Alntz+sd8krME5JUlwC6MmUy4rpDL8fLdhuyytzE0XYiwkgUbVurdRXpar0RUgBFAPQbN930f+015guk + tTXPBfATTa51gj5JBFpskihYo7MFIAkhiRXw/gJJXIBRQ8bgg2efveTR8fG/km/JbVNuBezxvIWr47Lf + UPj/mgg7ff8lpL6/Rlr0wwueHlL7A10C6MoUyoa4TDVBiAAVjMEzrdYyWPOZy3Z92Au3BSB84brrfqfe + 3//nKgyBKEq1tNT+QEdwS+Dzc0AK9onuS3Iw8b4bYxJTm98/p1S68rr+/kueq1aZtDgYmK8VmDLZ6rp3 + SeBz4K8F1L9Trb4Im53gZdDqSJc8ryHr+0+4X10C6MqUyG7PW/harP2ZBAxSS6BizJ6fBcEeWK0VwoKH + V+tpPvae93ya+vv/1Pg+dByEk9F6aQFI8CbAR3scgAOF+QxBJo6AbJUPWyzSHaD4u949ffp7n6tWdyFL + XFxG3DHINlkZdd2hl5Rawv6+XAh1p+8v3WkMweL3UNr/oKTUJYCuTIlscpwvyiCaXLobAFb7/grYIJpB + dsmu+lfnz39P38DAn+ogSDr4khRebO4DQtMDWY1/OMCPP4+c+6DFbRIz4EBbfF/DWiLn9PZeCeDnYt/Z + z2awTVksYKPn3RVK4APJ7eO12mrYugRCSqQy+Cf3qUsAXTm2st3zFq0lWiQvVGkF1I0Z+3artQ628457 + 9+sAqjdOm+ZcMn/+XyMME6AZY2DiFl5AmOiwoMz7+5rN9/hz0k3IBxGBNO+fcQPsDyVEQPH+RyJW0KPU + 7DNdd87OMORgWxkp4KasNqCu1OBzSi3hwB9nADQRhsPw+Ve0bsIWKBlktX8+8n/IfekSQFeOWrY5zj2s + 7WWxCoPpZd9/DrZSDUg1Vg1A9Q8vueQeaN2njZ3jF8Vaug38RFYja51YAPkYQKdiIFkDkLEGkA0m5hcO + jGDdFxOTGstHBwev/8fh4QOwAOxHSgKcijtqAlhXKNwVAoMS/EyuD1YqP0fa5MNVf6z9qzhCMuoSQFeO + SqT25x51af7H2n89rO8v/dXq54eGfqGk1DUmCADEuffIwi2T4kNq8ksLwKA9BoAcccgMgg4CmDBMQS9i + AFqAXXseyHVt9iJ+L+LXLi4Wr/2jgYHT32y17r+/1RqDrcGXQTeZ1jxiqSs1+Lzj3B1KzQ9LrAfC8LkV + WreQNv20kAb/qjiMwp+8dAmgK0clWx3ni3lNJTXW8lT75+vUy1dMn/47JgytXx4DlWKQc/uw9PsjSQiw + +f68ua/jGv+o1bKVg1EEEwTc+QcgDU7yLROADLb5SiF0HESuCxQKQLEI1/MQEmHAceZf39t717uLxetf + qtX+5sdRxATAxgJbAkdMBOuKxbsCof0lCdxvtT+n/vKFP6z9D9v8B7oE0JWjkHWFwp1biRbKAhVp/leB + sW83m+uR+v6JxvrsOefM9xxnyMR1/UnkX2tQbO7ntb8WZKCNgY4iC/RWC2GrlQD9kFc+pb08CRnEz8n9 + j4xB4PsIgwBRvQ6lFBzHji4kY9Cv1FUf6e//zk1R9E9P1Gpfe9SY7UgDc4dMweWlrtTgs0rdLZt9IoB9 + /+dWWN9/evx2H6nvf1hlv52kSwBdmbTsUepenQN/cvECeKXZ7KT9KwDK7ykWP51of9jx3ZnIPVI/PxLg + 91stRI0GIt9H5PsAcmWERyBGbDJ9qWNLQMv7cb9AFIZwiKCIEBo7/bjXcX5r8cDAJ/5DEHz+9+r1f0W2 + aUiGFg4qbxWLdwVEg2FO+wdA7YFKRTb9RPJc4ghTf1K6BNCVSUms/YfkxSrN1Row9p1mcwPsRcvmag2x + yVpy3fNkjb+Jy3d5ihBr+UhrhI0G/EYDURAgkmk8sT+He8XLz7Lm503nj0WppFSRyYFjAsm6B3GcQBnT + X3Ddv7yvv39JLQj+539rtZbGx8xa+aBuwYjrDr3gOHcHgkSDeD92+f7PllvffyLtn89EHLZ0CeAkl7pS + g7scZ3GFaFGLaKhJdIUDrA6JqBd4aiCKHrjY91cjqyiPKlAFpNpflqlypVpIhJWNxvOwef+89h8HUHG0 + Pl/H0X5jDEwU2dSb1tBaI2o0ELRaCJrNJAiWKdgR+3JEByKqEzPaH6m2l5ZMYExCagZxetCYpLw5swAK + AFLqXQOFwnf+zfN+/lajcc/no2gd2guG2s7/mmLxiwHRYECUDPqM7Idq/1Kt8sCPTtq/gsMs++14Oo70 + A105MWTMcYa2KnVvlej2CBiUc+Lz912ihyvN5uc+EYabkZqksk7niDC0uVC4faPj3O8rhRaR3ZSCTwSf + CFVg7A9HR/8VaeS/AmAYwG4AO+4eHPRunjXrMdLaLt/F0f9m0wbwms1Mak6mFI8G/BzNz5v2+Sk7vlJ2 + A+DHxMYWwG6tt/cAhXlEp3nG2PHGxqBgDLx4K5h0dSKj9b/+uNH4wneM2Yu0N1/66eb1np7F61z3R6EA + P29vNhr/+P/W6xthtb8DC/YDAHYB2AlgL4BRWCuApwEdtkx2MYauHCdpKjX4G677ua1K/ahFtDAESrIC + j0dGS1O2RXQRPO8/fsiYZT/WehSHGBR5KPmk5329RTSUXKjxYMpAKUREeKnZXPpaGFZgFaMPSwAjAPYD + OPBGobD9VwqFu0lrwPehKxWE5TJMq5Wk6eRUTgZfXo7YhCFqM/8TElAqQwBhTGZB/FpEBBDhuXr9pSfK + 5TVbfX/9tELBm0k0SwHJvAM5AQkAlFJXLPC8T9/huoP9Ybh2tT0fyXlfXywufMPzfhQSlSQBhESoGvP6 + X5TLj8CCvwDLh1VYAtgfn9MybADwiMEPdAngpJJdrrtoreM8WiVaLFW41PiZuXFZMii6hcLiuu8/uNF+ + LD8O7rAunjHHGdrmOF+SWlNOp60DY1+sVJ6ENf817MU5DnuxDgMYabVa45/0vP8RVSrQ1WoCet4JI4Da + 1ltwJDubOziZ+suAXxJATgMH4nUQYdn4+IqWMWFZ6+arzebm7b7/xoxCwZuh1JzMIigkuJWoSEpde6Hn + 3flxzzvnKmO2/lzryt8rNb3a2/vDllJD/NsyiPp4ufzV9Vo7SJt+GgDGYAlgGFbzV5CmII+YALoxgJNE + 1hQKX9oA3JVoerFlqtnYL0fqm/OFboim/crAwDceGx//DOyF4yENIAGHcRHtct3bjfze3H6sbDaXxd8L + pFV/ie8PTldVKmtgzOXceMMNNwyc5Lio3UiZDPg7+f4y4i9Jk2fuB3EQMFIKhgg7g2D7uA3G8cBNf2MU + jW8cG3vwYqWWfqS///r5jnO5VgpRfEyGbPbAAUBE0whYMr+3d8m3jXkRRP01oktl8JFTf7t9/98fDsMy + 7Ao/CvYvrcNqfHkuJ+X7s3QJ4ASXMccZest1fzQCLOSccDKwAnGhDKUtuGwVsKMZIufsK7XwM4XCL33D + 959BdsUYySMTYmw8tj6SKjwRIKsbM/bdRkNW/WUi/0jTVUHJmKebwOUM74mikkddVwsc1PTvBL5AWDZc + g08Advj+jvhrePZe0hD0ptb73yyXt1yu1JyP9ffffLbjLJRhf84gJJWFSl3LBGQgSqjtF2/+vC36mQ1r + +mtkiXQcaeHPEdcbSOkSwAksmwuFxauVui8CBjkQJf9tHryR1MojW4/PSWi+iPniP7ev7z/B99cjjQV0 + Mig6SgNYlNGi8W/DGKxstZ5Dek1NrP2BsD+Kvuw7zn9LWnzFj7LmTDoCj0LyAcO89pfgT3zwGPz8mokJ + YFOlsh0pvzbi4xqDJYEQgFqj9eiacnnHlUrNu7Wv78NnO86VTJJcWsySqTWIvzgkqn3lwIEvw/r9pfh0 + tGABPxZv+cj/pE9UlwBOUHm1WLx3k1L3MKBljT0XnMsQPg+z1IIIEgIwBlopq8mIUCS66D1KvetlWx7L + 5qxcCKMjCezxvIWvi9+Wb6obM/adZnMdrL96MO3vA9DXRdHWnzjOdwLgN/LANLBmiQGAvD+Nw187jE3/ + TtpfTtdh/1/2M0j3iQBsC4JN41oz4LibsQzri5fj41WwjTrTVmpdXVmp7LxSqZ/e1tf34bmue7EHlKJ4 + nwD7v0oyCoyp/2xs7EvbjCnBpv3c+D+pISWbTtp/0tIlgBNM6koNri4UfrQ312DD5ml+/Ixc4CJT146U + MKLYD2VzUwG4uq/vAy9XKsOIF9QU24Qz7nxgOmv9ZFGNWFNvDsM1ODztz/xELwTBH17lujcCOEsSGvfk + A5PPU+fB31bll9P8fI6TqD9/JiaArdXqxngXeRoQE8AobICzEb9eip+fBmBgpda1lZXKzjOBGbeUSldc + VCq9v0+p02WAky25N+r1hx4LQ2728ZDm/Pl3OOgnff+jMpO6BHACyXbPW/Si6/6Iy0GlJgpyoJYz7WRk + XLaz5jMEDDANYMDzzocdKJmfI88FK20kEBANJg8E+AnAGY4zBOC1+Od54MdEE2oNAHOvMWNfi6LfnKfU + vxPRNHksBEAGCI94xdC85s+diyhHAslim+z3x+8nAMNhuHddvb4PKQGw/88BubH4cQQLXB7MWUFMBDuB + 2j80m6NoNl9YqNTc95VKl84pFM517CpJeKlaffJh398F22Ism33GkZLMWPy9k47656VLACeIrC6V7l2r + 1D1y5ZdAaCcZpOLg37DW27dH0Z7tUTRe1To0POUawK8Vi78kA3UyWAgiDBCdDWtmDiCtKmOgduwnd40Z + kz6/rIQrpP5qhLTpJ08s8qI1AMLf1Xob88+HAAAgAElEQVTVN4H/NeA4fwnxAuIvIwFkGTCciBDazH6k + RJgHPqf5QiCb8ovfz6b62nJ5DbLaX7o3PIGX4wAushODJBFMA9C/Suv6qnp9D+p1uSaiXBpNxhhGYNN+ + oxBBVHQJ4NSQvZ63cK3r3reXaGEe+JIAWCvVjRl90/eXP9hobNyfzoVjbCTBvF8rFpPfYG3Kb2CtuKhY + vPDJVqsGq3X6YS+4AuwF3oaxkH+HS2Hjzj0FYIZdj54JgEFSR1oPn79o2VAJlmj93T8DRi9R6m/IklJG + OCiYzPyXz4vHHcFP7Tl/rl/gAp98Dj4x/Y3BgTDcuzbV/oE4LgY+r77DBMfDTuU5kETQD0sEfbDxkh5k + F0dF/NkqLOiHYQlgPP4euXrxUUuXAI6jrC6V7n1VqbtCYFBegIEAP1+wTWMaa5vNJ/6+Xn8d6UXDK+my + yc7BvEjBXiUOkPTZZ0ZfG4Mzi8X5aLXWwl6IvbBanBfqDCba78yCn6IW/mKl+t/UehjtQEiaYYY/9rFL + G8CCplIXtoBzA98v7x0ff/2Zfft2PbZ58903OM6f9BPN5/3M/rCYMhyLyQUJO4E/M1QzBr00+dkKkP0G + B9H+7NrIARxyEU7OqshzIEmjF5YE+pAlgSKyQz4lAXCm4YjbfQ8lXQI4DvJWsbhkt1L37BYrvrRpftEQ + sl/rV78xNvbwHmM8pE0hrJHkhNqk1txBugSWI7R/kjkgQtFxBmEB3xNvkgDalulOovJAxv/nbR7RwJu2 + RJV/KgKgf3bFFR+ftWDBYioUrtzuOHPAC3lGEXShgMGeHnx07lz4F1xwYO/IyIbhtWvHZ7dalye/iSyw + M8/nwA+IysE8+AWhdjL9k6afmNh2+P6mDtpfmv6devCT3cDBiYDPORMvEwDHUGrIFv1M6JodjXQJ4G2U + N4vFJfuVunOLGKApy2jzFoAP1F+u1X74vWZzOyzwubeeLygeq11HunhlC0Dgxr56iHT5q0hobU2EHqWm + wZqeBaQXYX6l3uRi642iVXDtJZNph43vn6vULETRRn7/N2+66VMXzJ9/R9HzZuoosrP+fR+SAIzWyX1l + zKzTBwZmzb3qKozt318e2by5MT2KTmNQAqL2IP6NZOeE6Q+0R/sz+X6R5+e4ShS7GFDKTiUi8l8eHl6O + VPtzXIOHgR5q8Y2JiKCFlEiKSJdHLyA22HK/x27UlPn9UroEcIxlS6GwaL9Si8eI7txCNBgXe7TV6yc1 + 9TFoa8CO742Ofn+N1iGsz8j/VQvpWK0Ksj3hySAKD9bMVwBCraGVgivGacEYDBDNir+3gOzFyASQkXla + jz8OjJMx04koIRa2AErGFAGo/3rRRZd9/JprPtff0zMNQYDI96G0BsULfhieA8BWQHwLrWHCENoYTJs2 + baBwySWl5du2rT5vfHyBBxRl/KJjAFBo/o7tvSLXz+TLBVacTuVjWVWprBjL5v1lWpMJ4HAq8SYiAu7s + Y8LlICDHLZnkZY3GlIIfOEEJYLvnLfKJBqvAQgOgRrQojhhRBFwepeuhtZ2RCc8QERxgtbJ/YJsUgNUF + Y8YyH4m/rmTMatf6YQAAt8PPVIhuiv85ahEN+cCQT3Tjm2hPP3WqOw+VSvzQ4Sh67Z+sye/CmohsjrNv + KEtCuSecNYUPIPJEURCfF43Ud1f2mFnrsBXAFoBcrTej3TxjVkfAjRSTi4K1AgyA+cC8r1x33UcXXnzx + RYgihK0WlNZQQYAoikBRBBWDHLFFwAQAre0sgNgq0FEER+vC5WeccfGuVqsy4PtF2RTEx9QpM9CJAPKm + fzxpJ+MWEQDSGnvCcPvK8fFNyKb9mHClSS4HgR5K+D2yHZvjCgrZlZFlZeZhTxSajBx3Atjrugv3KbW4 + TrSwCVwRAkNrO/zRE91OmAoC2irIQuCK/Pv5HQ1jbmyrOMs9zn9mot+VmqoT+Dt16/H9Ta3WE18rl1+C + 9Q9lYQ1Pf+W88CiyRTZyIGToGZNEpJKGlLgphesIQIT3F4tnPd9qVZGSAGujNgsAAFxj1hDRjawpFQDH + GFCxiKtvvnmeNzgI7ftArPF1rPFJazgM9g7gl8A3UYRIa0Rag6KoMHfWrFm1vXsTpElGkn6KJAAmAY7q + 501+VtsRxzKsgkDdmNozw8PLkDX9ZSWeNP8n65PLDKXsIKYO7wGOEfiB40QA6wuFJaNKLW4AN70ODGZ6 + vyFMOc45x3KwM3LEZygPbqIJgd3x46JOPeOfCvKSWqhtYi4/RkoOq+r1B79Xq62HNfk5kC8vQC4IGcHE + 4NcAtAeMK2OmE5DUADiwYFWURrtNqnlcWBJgC4Cfl3gzJWBVXcQSFAAqFjHrQx+CMzAAHQQZgFNMAIgi + RFEEJQggit0AHQM/iqcBhWFoR4FpjUBrC9aBAbQqlYxFA6QEoMR/KsmXYy1BDvxJg5TWQGwRBVr7z4yP + PzVmTL7kl4mXS3HlFOCjBecxB/nB5G0jgHHHGdrieXeXgTt3EA3KTrLMRu3lm1ISEhCvHQkZSG3R6bWJ + JF98QuJiS78gbfrIlORSe9WZLDjxgebDo6Pff9G2f3IenCvByrAXHheEyIowGYXOmIolYHUTuBFAov1d + YxDE97k46DTPm41WiwtR5CbnWySijFktwe/OmIGZH/oQjOPABAF0GALxsM82IohJgH191vhRTAJRTAIh + b1GEABa8UW8vAt+H7/uZwiB2QQhiuIU8/+I/aCulZs0fp0lfajZXbG61RpH66ez3j8GSL5/3YxaUe7vl + mBNAQ6nBtYXCl1YR3ZkpU1Uq4+BEOTLoRABsL+WDQJ3uT2Tqy/umw2v8+GCkkrHTcpaEJDGp/WV9vpxB + X9Z63/0jI4+ssyOfS/FPsclfRgr8YaSaX0agOwahHGPgxPvhxhkAJoEodg8MEQrW71dIYwEcjJJTg5Lv + vjKKVj/uuuMETC/MmIHBD3wAAOyE3hjoiM15Br+JXQHkn4sJQMfmfhjfBlGEMJ7Fx2PGIgAYHIQ/OmpJ + ROycA0sCkrGSNCDSa0s63waAirMJBOC5VmvZ8kplE1LfnGfuM/hHkU7fkWsAnNRyzAngtWLxRyKIl/rD + QIaZ5fP8XvbjWCbS/BORwcGkE+iT7yCxIkxs6h8suChjDhKJbfP54ls2Tze3Wqu/OTb2IiwAuflDmvw8 + RYc1v+wEkxqobfccWOAzEXFbGWs71pYDjsPuBpOAKx53Moq0Czyjpk+/dfpNN9nv932r4a3PbiP6QvvL + rY0AcuCPtLaBUTmWKz7YgAj+tGl+WC4XeMd4p2UUTV4nMpLGG2DBDwAwBi8HwYqXLfhl0I/NflmKy8G/ + o+rBP5HkmBPANGPur8Z57yT0KZg5zD1mDZmxBOLvkr52p1tM8FjKhGZ+hxhA3uy3T6aPkr51pBonuS+O + g1tA2SKoG1N5pVx+4fFGYwfSgQ9caMJaJw9+uRClHDPdURRgElAYu9KOw2a7CBBOs1VpEvzSBegUCDSl + 3t7nCjfeeKs2Jgn4JdqdU30c5Ov0PAM/tgwirRHx9F1hMcliHR/2+tin1PhupcoXGXM+/wdufIxssigg + s/R3YpXFxy/duKeazWUv1moMfvkfjMfnnsFfxhT14J9IcswJYDAIHthZKn0pM0IayKRjkucFEWSCaOL7 + ZKQ9/9xEj6VMRAD58GsnMrBv7EwUQEoAMg4gXRlDhE2t1huPjo+vPmBMgGx6T/qbEvx50/OwtI8MjiX3 + Y5AoY+wfbwwGsgQgm1LkR5Pf2r9o0ZxdAwOfiYwBeK09kcLjIh8t8/yxzx9Vq4iaTeggSGb8J/+x60Ir + BVMsQhcKaR+EUml9MxFOK5XmfGPz5p98Ytas/jOA03hWlhMD3BE7KwuGOGjLfRGB1v4Tvr9sZb2+A50J + mN2uA0hLcZs4hcAPvA0EcHoUbX0tDO8YUerqClAMHeeGBpHXNMZrAZ4POH2Oc36YIwip/WVkHWgH3EFT + gbEcToQ/854JptHkYwFGEIIBEBjjjxkzYsTnR6No1DfGX16pbNykdRXpoXFlGEeaJfg52Jfv/z4s01PJ + Wn0iawUg9pVFDr+fqB8io4d2FyA5LaOLFl2yva/vQQ2cq+PcPi/uwYDXWkPHJBD5PvzxcQSVCsJqNdk3 + +Z8mcZIgsBZhs2krIT0PUU8PdE8PQs/LxE+Gpk+f9cjo6NIbBwevvkipC3gJMSKb7kzKkyktV5bW3G6t + 9z5WrS7bGYZVZM1+WX+/H+ngzSkZv3UiytuSBfiFVuvHAJbCjjn6LoDTAMyBHXg4gLS5hbWPjELTLKLi + As+babiqdYLfmcy/ciSpPwBY5vt7D/JzExkjJrfJQFNe848gm+PPt38e1mEWbRbgJkA07yC1AiIOEhqD + K113zkqbgZBuQGZ0+N4PfOCGrf39jxqt+7TvZ/x6LQggiiKE1Spa+/ejVS5nDlqelCTOg/ZAcEiEIIrg + 1+toNhoIi0VQqQSnpweGCCXXLVS0bj48MvLk/mnTtr+vUHh/CSgmtQlMAtICAFAFai/7/pqn63U2+Ttq + /gVEtVsKhbPf5Tg392i9YiawdwYQuEGw8tooGp3gPz4p5XjUAeQLHpiBAXstZFK7AOiAMdXnfP9A7nP5 + 7zke0skwyd/X4pY1f76zjHP8HHHOL/d0xGanA4zJnn3AakTSGorINgjFmvNspWavBLYgSwCJFbD7xhuv + 39nT8yiCoE9qeeTA75fLaO7Zg7Bez4y7aiMAytVKIFstyZZBYhVy+q9eR7G/H07KG8FLlcrqjUqtuaa/ + /xcudJzLZgBzlbACAGBbFG3fEIY7ljYaEviybbkKYPzDrtt/U6n06zOJrikY0+/CWkxsgjlK4UcAPGCN + a8x4yZinS8CWojFbrmy1nhL/8UThqRNO3k4CkBc+d0W5sH8Et7ZKszMhgNwtxHs6vfZ2SCfNfrDX8rVO + 3MHHzSX5sl65uOSkTM6iMau5Y4/jFqz9ndhU5i89nWg20mIgGQtQr7/vfdfv7O19EEHQl6T2tE4Kfvh+ + c88etEZGsjGPg5wgGalP3AG0Z4P4+wiA0RrNchlBo8EegQ+gcUDr+qPl8uOPAk8A8K4rFi/SQLGmtV4T + BOPIxjLyBFy7tVic875C4Y5B4GIulpL7KdPPjiXNy30iNIlu4IvwoZ4eKGCbA2wrGvN0AdhSiqJVVwXB + KpzAxPB2EQAzNrc5csqrDpv75vHUhMMjgbx/erwIQOdu89d6Hvh88Unfn6fJyMKeI/L3O0mvMZu5YSfZ + 4ipAGQMgAOfb/nsGflIN+KMrrnhfub//+xQEfZzmQ+z3c2Vf1Gigvm0boiDoCPpOJ4RvJ4rvmNzzsiJU + GYN9zeYIUiLlhUda8du952xpcx9S15LdGSPOf+MKxyne1tv7K3OIFiYXUPxb/KfJfSJkTVTKxRsIOIeA + c5pE1xMAUgoPeh4cY14tAGuKxqzu1XrV1b7/5CFO09smbwcByIAXT5ph8Mv2U3mtTgTwid5zPAggr90P + puwkEbD/z+eDN+7nZ+12VBfFBWG45qeFwjiA6fnhHVwJiHhHphnTf5XjnLYiisYQE8C/XHHFHTNmzvyj + MAx7ldYJ6JNbrRHs34/m/v0ZlpLFWxP5RBPKBGleIAVb3Zha3KUng3dcnx/Cgr0H6cAN7rNnAgjOIlJ3 + 9Pa+f77rftAFemW1E6cL+c/iAiMOJipBRJJgwWXRYn9Zeymiy3zgshrRp0aVwoOum5CCZ8yaHq1XXWtJ + 4WDX0jGRt8sCkH4+k0Ed2brzPLiBzvU6nd7X6b3HSiYK7HX6wzq9zueCy015ayvnPVrxgGci4FY2/1Xu + VscXtwGwSKkrVthefu9/X3LJx8+cNes3uXHHRJFt5Y2beqA1mjt3IqxUDqn1Ox3IhAcnNH2SRYktFnZn + 9kcRB2H5PMrpOc346wtICYAtTAKgP1koXPDeUum/uMCcfH0JYP8AiuMRDGyh4VOtL4gA8ePkPtLyZEkE + 8jERXdYCLiOiT40phQdcFw7watGYZ4rGrI7C8KkP2MVc28phJjp9k5G30wXgP4xvVW4D2jV9XuTzB4sR + HEvJX9sTmf/o8HzeHZAVqlP9B5teYx5sEd0qn5Qlf8kBGIOLiBZ8SKnzrjrvvF+4ZM6c26I40o+4Y0+F + IVTs77e2b4cWNfnJQVF770ab0KH/JiPMcCAb2d/Wam0XP5nv1a8i7bUvQWSXLiOa9tv9/Z8tEl3P+8lA + R7zvEOckSSHGz0s3ih/z60rcz4C8w6aE1dC2tDhwWYvoMjIGqlDA/YXCeBF41jNmTTGKnrrB95eKY58S + K+F4RNE7AbiTpj/Y5zu5Bm+nTBjXOsj78+891kEh+meiuWd63trQmOlsXiQMTOkqQxwQLJ59tj/jzDML + FEVwGPRRZDMHYQjU6wiGh6FbLQDpVZgwmCh+6uTX50d182dki7QfLzPeIlsGzJkAECE0xv/iyMgPYbU+ + L8qxE8B2AHuQxgKAtL3Z+1Kp9OFpnveXhmhasrqSqMxMTP+DnUx0AL+4n1zMMi7Q4X4mwCVfj19Djjzy + vnBsJTzbE0VP7Q6CJz9pV3uetJVwPAhgKuRE2+/jEsA5hBAA73HP+2YA/Lr0MTgSxmaH6utD33nnwenp + sQ09DPwogsudfI0Ggj17rAuArObnAh2pmoDOJdwZAhAkEOYJAEiqAJk8VgXBmscqldVI5+XvB7ADwDZY + AhhFukCH+6dKzbykt/drIdEtstpUrvrDPScyz1oFdj8+Pv7oC2E4Ppuo/xLPO22m4wwMOM7ALNed5REV + 5ip1Bp9kCGJgkpBgnpAg4vd1IgdpRSSxBPl6/JwDvFow5tlSFD293/eXHikhnGhA6srUivstpRbMdpxX + eaZUKKPcrovi6aejOG+e7crjJp4whCMm+KDRQLhvn633jyUT2cxpfo7uA+1XoGzwklo4IQDekE7tiWcb + +v80Nnb/mDE8B3EUwF5Y7b89vj8WvxY93du7eJdS/6SBwU7j12RDGpNXC2iub7We+Xal8hrSwjSOD0pA + AQBdpNTAeYXCnNNdd9ZM153dR9Q/XalZE5HCRATRyWI4pKWAHBnEroULPNcbRT92g+Cpm31/JbLuZpul + 2iWAU1scAKVHXfd/auC/yyijN306es49F8Z1kyk8XNdPce0+RRF0pQI9Pp5ofhYJ9E7gl1bAROY/vy/j + ApBtAmohnuYTBwCfC4IVT9VqbyJNJR8AsBsW/Dtg3YHxFx2nZ3dPzz82gcWyuCjMjV1nN4CrD/drvfYn + o6NPv2UzDAx8mbZlI4pPhAynyBFqzk2FwlnzPG/2LNedPajUrIQUcGgySF5DzjKQ5BBndBDfcmYiTwgO + sL03ih5Wrda3brVkIJeVjPgzXTl1hQAUf49o3kcd58cALo5cF8V581CYOzczlFOO5OIpPrpaRTQ+3vEi + 6VTsk38uTwZ54Odn93HLbwAk/r82BgeA0b8fH38E6ZCUcaT+/w5YIjjwk97eD44q9Q0DDHL3ZdJ1SmL6 + MlJ3oG7M2Cu12tJHbGcm16Owl8Sl2nLxD0kA+Q7KfCl1UlR1tevOOcfz5sx23TmDrjtrjnQhkCMGZAEP + dCAEdLAAYjLIWwsKQEHr53t8/+u3NhoPxMdWl7/flVNTYqsQvV8met8FM2b8sGf+/H7jukl0PynnlbX9 + UYSoUkFUrSYXkuHbDsAHDg7+PPD5vclshPg5bv1llRsD1P9Wvf7IviCoIE0fj8Ca/DsB7Pwj1/UW9PT8 + FYDreTQY/07HgaDx4p9bg+Cl/zM+vny/BR9nxOTin3JlY16VJxkpgLSGhd0FTzyXv82ThHO16849x/Pm + DDjOwFzPm9cHTOtVqj8P+uS+fF48lpZDQg6ULfiKZzeWPzU6ehksme2VB92VU1MYi8G7L7tssS4W+3UU + wfDQzhjsPMWHc/5RtYqo0ciY7fxlnVIXsmU7ATaywM+AHin45eCXjF8eP98Cglt6e9/vEJlxrfdD60of + UC8asy+Iolcu9rxfmqbUpwJjBjKzDtkCoLTNnMFfN2bs2XL5Jz/3/WGkWp8rC7k3gBfl4BJtnr3IBCBL + piX4k+wD0nn/+eddAO7yMBxfbnP9icUwm6jnUs+bO8/zZvcrNTDLdWcNKDUrnuDcMU/eKZ2WdH4iNVXK + vv/vsEu41RETQNcCOMVl3xVXzNmh1HcbwC/yrD0Ic9/wIh1aQxuD1tiYrfPPSad8JQNNEoNs5tE5Tdy2 + Oi+QyQSww51kKShdgpxnGGRsbmPaZpgThDVC2RkTIRG2BMFL/5/V+oR0jKCc/isHgPIQUNmfwVxHyJr5 + vGtS80sSyG/y9U6WgnQjFAC1qFA4q4eoeIbnzfKUKs5wnFkKwCyl5vEOdWoBdwDAmPpfjYzcvQnYB0to + S4GuBXBKS/3KK2evM+bpwJgFRkT4eYAHa3wAiFot+JWK7eyLP98pd3SwgoY8+A82Ej0//Um6DgkpGAOj + VKKeo/ji5ggWF97IeQDsroDSuRIRESrG7Hm+XH7y8azWzw//5AGs3JnJI9g6rcuXn7nSiQykdcCuQt5C + KE7wvPycA8B90vcrAJx4iGvbzIa5gHe5580mQCu7RQqIpivlusaEm+zwFxN/P4AuAZzSsjUMvxoCC+Qs + Popn8ZkY6MYYhJUKwkYj48cDnQlAPi+bZtry+0Lrty2CIjVz7vNAXJUXpyspfg8HtyLKTmRiwsn7xZKI + NrRaz/xDubwCKdiA7Eq/DHwJfjn/X05elqelLaWPLBnIQOFEpJB3FfJWQp4MpKWQ+a19gHrcdj9mTgNS + ousR9wG8gwmgrtTgXsdZFBANlozZck4QPNXhbSdigc9hyZaLL/7jkSj6VbkGH4/rAhEQhogaDYTNpp3P + T2mxTqfbvLS9T3xeavL8wqd+HIDjIB+/D7AaH7CanEuGuelGTvpJOqViktDINYXExDSm9ZYHR0Yee0Nr + vvg5tZefxSAn/7LJL+cxHM4koLx7nrcQGKyd2q7zcYS8C5GPL+TXcMhnHaR1wH8L9+BkSOwdFQOoKzW4 + 03UXjxEtrhLdnq/ucIFneoEHKQyfviYMV4mX8/GvE1rKCxZcuMmY5WEUDURRhDCK7CjwMETUbCJoNqHD + MFMdIpfGPtiBZoAvLID8Utyy6CagOL8fV/YFQKYaj+fzc6Yhr83Z2ZY+Lc/zl2OLuH6/rPWWFZXKsp/7 + /j6kgJKpPfb1pcbnQSwTaf3J/vf5Q8q7DXn3oVM6UWr9TpZAfn1BOdBF9trIWMf/4Z075WXEcYa2Oc7d + Y0R3RkSDmVQV2gNZsYy7wCOFKHrog77/ALJNO8ekM2uq5K3zzvtezZhP8EIbkTEI6nWE1SrkgizS/JaD + WIHDswA65fMTPz8GfhCX9iYkACCIK/E0VyXmTHgZyc5Uw8WgT2YaEGW67faE4Wtra7U3lrZae5Bd3kw2 + DXGEP+/rs9afknkMh5COh4jOxJC3GPIkkX++U3GSzObyLIpn5Y6ckrK+UFhygOhOXpcgQa/QdklZKpBo + NCA+MbHZCaDsAY94Wj/04VaLyeBYdfEdlYyfffb5G5TaEEaRBbvW8MtlRM1mtvAG7U08eV/8YAeUGesl + Unuassudt5RCK9b8TAShNP2J8FyzuWzN+PimC3t75/Yo5c3yvBk9RIWZSs1QAIpEhUGlZrIl0DCm2tS6 + oo1plYNg+EAQDP+s0dgc71re7JXTl/IRfh66KrX+lMxjmIQcjguRJ4hOZOFM8FkWrgpfL3/0lJExxxna + 4rp3jxLdGQGD0rztuOYAp5rQ/m/zGQQyNFp2jHnU0/qhj1oykBW2x50MNs6b9wcHiL4QAXaVnbExu2qP + TMmJne0UiZ8MAeTXQPRjf7/F2l+ppL6fawAMEZ5vNpetSlfi5V2Sa3h08gwkyJPYIdK/lS/yFtpX9pXb + lE5hOkaST/dLcHeyHjq9xt+TJGxgS6lPHQLY4XmLdil1d5Xodr6o5a1cmUcDyYKZ8t/m22TVGIgzKsow + JRm4xjwaheHf/XIQcK31cSODLY6zeP+sWV/2C4VzTBTBHx21I7rjXHqeADoRIu/wQcEPZPz/fNFNEG9N + Yf6zFaABaKUAIjzbbC5bWS4z+LkA0Ee65Blr4k6aEMhe1Fp8D2v9BlLwc5pPLqfeaXm1Ewn8B5ND1QR1 + egykx9jKv3BSyrpCYck+pe5qEi2UF3Wy0pBMN/GFimy/ZPKPcxQ6131FItiUn6cnnt/uGvO9A0HwrSV2 + so7suD1mWmWf4yzcRXR3Dbg9BAbV4CBQLCIYHbWaX/xwYqrjKLU/MCEBcMQ/sQAAtIRLwK7W076/7JUU + /Ax8BqwMwkkCyK8CxiLBzz5uA+nMRS7prSEFfsdFVU8xORi+zaHecMLKmOMMbXPdJQeI7gqJBmXKKQE+ + 0uqvxK5kUxXZXIgkgIQ6xWx5JW4VUhLIEEN2e92Loq+vCoIH/kTrA8gtSoujvNj2Oc7CPURL6kS3+8AQ + F8JoAKq/3x5ftZqAjScDSzaarO+fvD6RBQAkPf3N+D5bBGz6P+X7y1aka/FxPr6GtPyWNTSPA2CulasW + ycCWNPtZ+3OOvyE2nr14uKm9U15OKgLY7nmL9jjOkvF4pWFp1if13jnwSzKYaM1BFjImIYFMv7aYo5e3 + AjJkIKLSInz7ExVF3741Gy+IxM8f1gW42fMWjwKL60Q3hcYMSbAmVXMA4HnJEtz2oDrk59FZ8x82AeS/ + UwQBuaW3JW6l9v95GC5bUa3mwc/5eF6Ik5fi4tLbfLWd9G2BbOyAM43s17fEfSaJk83cP2ZyUhDAumJx + yX6l7qwDi2TNeERZ01MSAHd8dVpwVANoAJWNrdb6F+r1jRu0rn+oWDz7/FLpnLMd55wCUCBjsrPd5FBN + 2Zsd35d5akkOTvr5sgv8xI2ihz7m+/fjEPGCA647tEepxVVgUY3odhmoTK7cWPNn0prGZIDMM+2Qf98R + mv7J8znwy4L0AjUAACAASURBVHQgE7EPWAJAagFERPhpGC5b3nkhTl6Lj5fjGkNqAfC5SUoA0NkCkCTA + rkDSWIisqf+OBz7LCUsAdaUGt3ve4t1K3eMTDUkQ86rC+dpy+Vy+1FQToWZMZVcQbHmlXt+wMgy5ZDKj + GAHoXyqVhi4uld41T6lzSbgCGdALzZ+4AOK+MwEZxI+3e1o/2oqib90RBK8AiFa67lnacW6sE93kAzeG + xgwB2SvcAGlALwZ6cvXLxxzEFODPRIEoW8KLDreZ+wL08jUJfohzH8ASADv2IREejqJlL6cr8+TBz2vx + 7YO1AtgFCMXPStDLwJfcHfk/njR1G8dTTjgCGHWcoW2et2SY6K6IaLAtmNfJxBcmpnQBNICaMeVdYbj5 + lVpt4ythOIbUdMwHjvJ+Ic0l6r2+p2fBfM+7YJ7jnIcY+PkAoXQNJBkkwcIs+PNLWW+Pv/PsTiFbAMhr + f9b8/JqOnzMxMXCBjfyuBD0dLIIJwS/Ajdz72kqHBTknOX9jEBChDvivGbNpn9Yj+6JoeEMQ7EIKfgb+ + PqTmP6fmOBXIkgc+82OnQzpcj+YdLScMAezxvIXbXPfusdi/7xjJ76DpeS35ZOItEerGjO8Kw80rarX1 + y62m5+ufg+DsK/LyW01k009AWoFVAFC8WKk57+7pufi8QuHS6USzEccLJGiZDPjDSXwAbaBvyyZI6yIv + DHqTv8/EkNP+8urPZDKIkjHWEwIbaDPzk/sdQJ8nAFa9gSAAGconAIoIo1pvDYC9PvBWK4pWrQuCF57W + ehssMXCg7h0fpDvWctwJYGOhsHiX49zVIFqU99dZqwc5X19D+PjxVgPG94ThhpdrtfUvW00vBzrydclR + YgY9p4s4QiyXgHaQtmv2AOiFnTVfutZ1z76yp+fyc1z3kgJR0cSWQbKIBZCJH+SDh5msQX4UFESVi3gt + MesF6PlxxioQ1gFHzxAfjBeDv5P9zO9vGwIy0ePc8/w9Ms0aGJPO3hPnhEt5XUrr+eOFOF8vAmt6tF49 + YMzKm5vNJ5H127v++xTLcSOAt4rFJbsc554AGMoU7eS1PDr49WzeA2O7g2D9S/X62hetppf136ztO4Fe + pojqyOaGOfXETRglWPDLrSfeSv+hVLrkwmLx8jMc5zz7q2kqMR876BQ36AR8ylsB/J38vNYJKSTkEBPB + ZmO2vRFF2zYaM/b7rnsrkEbPXKJMGJ1PkjT3OwX38qO8gGwQEbnvYgLK5z55ue58r2yS34utFBk/cYHn + SsDTXhQ9mJty2yWEKZC3lQDqSg2uKxbvHhb5+4OBPE8KEYCKMbs2tVqvvtFq7X4+Bb1c/JG1/eGAnh+z + 9uc4gIG9/rj9kleZYQLoQ44M5hJNv7FUunhBqXT1dLvabpYMhGsA5AAvNwF+Et+RpChztz7gb9F662tR + tP3lKNp3wB63AWDuct3rFhBdyL6MlyOAvFmfAHgC4E90y5+Xt/k4BRNA3gLi1XiVAL6be484P+Me0SPF + KJI9Gd1A31HI20IAo647tN7z7i0rdXsADHYq0+2k4TnIVzVm59ZWa+UzjcamV7VuITuzHbB/er4Q5GCg + 52mvTA7s/8tGkERxInUFSshaBH252x4ApYuVmntTX9+1p7vuBX1E0+wetl+XMpHdyWpoAz8ApTVqxlS3 + RNG2jVG05ydhuIPPwVUzZ06/8Zxzzpzd19cPIhO0WtHZGzZcFlarGQJgUOW1PqcHGdw6d1+L+5H8jPgT + 5HEgZ/20EYBwCZxcOnUCArDfbUmr7AKPIAz/7nZrGZywDVonshxTAthWKCza7bpLxkThTqZ4B1nwy+fr + xmzf7Psrnm40NqzWuol0JWGpwGThh6z/5u1wQC9zxfLiAbIkIAcylJDGBqQ10IcsGRTjeMEVZ7ju+b1M + BkJksM4+ka4mw89prf09Wu/ZEYZ7Xvb97Ru1romP676+Pnz+mmtuvOy88843UWTdAWOAeOpPbfNmVF9/ + HajXE8DJ8HlSGCUAnwztFOCPxOPEvGcrQJBUknmQxVEyRQoRGJ0gjSrjJW15P85wpLfLEARf+NVW60lk + szndvP8h5JgQwMZicfEux7mrRrSoY1NOTtNHcUCvaczwviha83C1uuwVq+l5Zdd8b7dsHJFLbB8N6Dtp + DZlFY+Up57t1sgo6EUEP4kzCxcXiubMdZ+6g686ZTjSrQFSQPxga449qPTIaRSPlKKquC4K9q8JwRLxF + BttDANF3brvtk3OnT5+TAN8YOwGIXQWtgSBAY+NG1LdsAYIgo7Uz7bwQWp7BLi20+HGyvl4+6xAH9QA7 + tJMLp+IgX7ZSUsZC+L1Am5WQj4kkw0MEERARjDEvVH3/Tz/j+6+gW/l3WDKlBPBWqbRkp+Pc4xMNJVdp + Tnvku/J8YN9wGK58rtFY8WgYjsKChrV9Pn0n/foG2rV9PqI/GdBPJEkWC2mKUM50YzJgwEsSYFJgsuDZ + dHKKS6cmFyBbuZyvdAs+/5733HDt+effmGQDYgsg0chap7PljUFUr6Py1lvwh4cTkz/i29x/FSqVne5D + acVlMlsq/oycXy+rI9mv52h/cqBCwyduidZtlZUyLqKApBAKSOMXPEJMxbcmDL9yZ632BXRr/w8pR00A + daUG1xaLdw8rdVcYF+5kTEaIOny+eIiq42G4fL3vr/n7ZnM90hQbzz/j/ZIXex70eU3Pf/ZUgn4ikWTA + 17Uc6MjugSQDJoHEIkCWCPITXHgf88CXHW/+Q7fd9vmS500jY6BbLbR270Zzxw6E1SpMEABE8EollM44 + Az1nngk4Vj/XtmxBdfv2bFMQA1x07+VX1Ako23TF5r8B4Bvj9wAFWfeQmVIhtLwokU4Pmi0ArbPVkzkr + ILnHgEdKAmwNaGOW3l8uf/ZhY/Ygm+E5HsM+TliZNAGMuu7QukLh3nGi22VEPw9+aUrWoujVrb7/7A+a + zde3GKOQ1fY8oFT69gzqeodNmvYMelnR93ZEiKWLkI8XTEQGmTQi2q0BaQXkzf1MZuP35s8/944rrvhL + aI3W3r0ov/46EM/0VwwMubeeh9JZZ6F4+ukwxmDszTfhV6uZ/4nX0ONxXgx47uiTVgCzE9md8u8fHX3k + /N7es6/0vMt6gILU5pluSqTsmZw8jhPEcQFHgN8VBMCpRB4jZpgEYuBLEoii6JnfHx//fWSHfHKFYdca + wCQIgAN7o0R3ysUV5X0J/gDYMxwETzxSr7/wlNYNpFqQL/q8b89+PWt67uHOm/gc9GPA88bX5dsdCc7H + C/JkUBQbWwAl8RwHGTtZABL8CeF9+eKLr/mF+fO/WF23Ds0dO9KaA8qOzk4c4Pj/cfv7UZw/35LA+vUI + tU60fyBn+fEor/iWLQPZX8Gm0Mpmc8XLo6NvAdBnuG7vNdOnX3GWUueUgIIsiZYnK18nIYmA4wdMBknR + VPwdXLQkSQBEMErZakeyRU/jvv9vf1ypfAXtc/+6LgGOYCz4xmJx8U7XvesNokX5YJ6h9kBfXevnNjSb + T/9Ns/k6UhN4NiwYOE7EjSGs1Thtx4Mc8qDniz8P+hMh4su/y/iQpno+XtBp/ru0ADq5ALJnwQcQnKbU + aLBrF4Lt25My3ySFCGRKdZMdJEKrVoO/di0K8+bBmzED/shIVvsL8PNIryB+nf9nxN9FxmBLEGxi8AMI + d4fhyAMHDvx0FpFzeX//eWcXCuef4Tjnmfj98sCSlW3jugHOUmhj4PDaBUhjBgnomUz4GCkdMwZBTKVC + 4Q4AP0SaQZKn4x3vChySAN4qlZbscpx71pPtyGuL4mfBXy2H4U/vr9V++oTWdVjgz0U2qAekAOYpMNKn + ryHr60vQS+CfCKCfSGRqnZC6NC20z4LPLwOVyXghGwOQcYBoruPUKtu2pdFwAKREDJEo0Zj5XL/WGtWd + O+FMnw4UCnZMuDT3Ebf0xmSQn6rELPVGq7XmuQMHXkVK5klm5oAxraWVym4AywB47yuVzptVKMwbdN25 + PUQDvUpN6yHqT06ajPYTgZRCJIKYhmwJsUaaATAAjFKphSMIIZ4i3LukVPrIN5vNx4GkDaJbTRhLRwJo + xIG9EaXu3CKAn48S8/3QmN17ff+Bf67Xn19vfXsGvkzhxUH/TL5eavp8Sa70608G0E8kHNNgl0TBHpeM + G2TiYmiv1JWWAN8a/dprSyPXbffjKDevH2lbnUz5GQDNchk/dpxX3kP0rl6iPmkF8DDPENb859n/ADAc + hntfPnBg2e4gqCEFP0/2qSKdtBvFx1dc1myW0WyuxUGCn1cXi/MIoES/y9oCQRAvBsHez/b3/9LpRKcn + pMbuKNIYQUSEXs97F5rN1UgLxuQ1JYdDveMkQwBjjjO0uVC4+3ml7gyAwY5FOtK/N2b99mbzoXsbjRdh + 1x0bgPVvpbnFwJeVeTWkwJcz4GQEv1P0/mT+o6SLAExQCQy04VnW6wCAXuF5i6vAFQHR4DTgMzuN2V9S + 6o8KwDUMUmYNGayThCD/z2la93qOU8hE/mEj/hFS8GsiDIfh3rWVypoNtdo+8bVs3ciVdniqT4iYAJBN + i8o18ZJU6PJWq3oY58SeSGPq9gym5j/vLxOAIkKDqARgJtKFQaRLKdf7e8eJC1jgbywU7l2h1J0M7hBI + Wm3zo7V8Y1atqtW+/3e+vxX2Tz0NadGODOrJgF4tt+UDerJw45Qt6awqNVi+9dZfrLvuNaFSgy3gvfA8 + xctiZcxgYwwFwS4nCLa6QfCK2r//ja2vvvrnO4Gb5FCPfqXKe4FvENH4bKKb5bivzImMzed8We9FSp3t + EHk+pak+Tv2xmzdqzOjq8fHlm6tVCXz5H9dgwT8KO9RjFJYQAlgA5ysnuSaijQSQTRZkqoDludQ2qMf3 + M8VlHCRUAHYFQRnANGSX/q7Ev+sjrTV5x4kLAKuLxZVhbvgG530jNgGJ0DRm9cpa7QdfS4Ev/Xv+c/Lz + 2HnjVVY5b59P3Z2SoK/fcstpw0Hwn1ozZnzIV+rKrb29cw3iBhlRuZdU8YnXAACOc1lUKNgOn+nTUQQQ + rFuHyPcTXxdEA3OIPrvbmCc2EL1wDtF7k6ABZacHtdX3E6GPqE8u2hGK1ziotqFef0uAn4HPrhyDisE/ + AksGNaQLUXpISaCELAFIEpBukUwQADkCmEnUq+L9zIw9F8/5xviPNRo7kW3m4t+VWah3pLgAEBIN5ift + cDAo1vh7X6rV/vbr7cCX/r0cxyz9QAZ+viT3lK3Zrt9yy2ljhcJ/rpdKt23r7X0fAx7G2IU6JfiRAzyX + 7vJ9QQ7GGJSGhuDMmIEDL74IHQSZSTyzlPrgXmOe2ku0Zxpwer5YR57kxFVgoqfcUFUgeT0A/NdGRzch + zW5I4POCG3KNPV50o4F0wEq+PiK/6GUnC2AiSwAA0EfkOIBdVJTSl4wggF1BsAPtKVkP7UVX70hxgWy5 + rlzGuQXs3dho/ODPm81XkJr6shMvQrtvzxcFr7qS1/h5E/+UAD0A7Lvhhttqp5/+u9uKxY/A8yyo4yW6 + TA7I/3973xokx3Wd993ueewuHlyAAN9FgpREitQLoUQpFEULFu3YkWgTpaRsJakU6DhKyZUH6cRJ/qRK + +qH8kkuSU46dVCm0VFSicuISY5miLYqRCNEkRUIkXiQIgFwsgQWwWOxj3tM9Pd335kf36T73Ts9isTOz + wMz0V9U179mZ2T7feZ+TJvC8r98U/Pi6ELA2b8b2Bx/EyoEDaDUaWunu7cCnnw+CZ3fb9jYbKJKpDwDx + LEEWI6CAIG+l4+k0ALjQbs9B1/y0UrvEDnPHHi3dIIuOaoLMJZZpm225wJszTOIA6RbgDjIdKUXIA5UK + wEvl8pGUf1XXuMK4IQewk4CZ/wvt9vf+S6Ox/1TIlqTxKVJNgk+RfBJ6Enwy9c2RzCOn7QFg8bOf/QeV + zZu/XJqa+pCKGnEUNdzQbWaGK6bhuXDHGj96jF+PZ/+TJrdtbPnoR+EdOgS/0Yhz9R6Ae/P5v/fHjca3 + /sXU1D+n1Wc8rUCXCoCrlJdTqmBWbtJ8QWFZeLtSeQtJBN1F+H+mKb7LCE3+KvRqO7PsViCJwHPtbq6z + Ng/T/BcA8MTk5K8RI1EPgJYtsCycarWOzwZBHZ31FKO+EGTNyAHAlFJ/XLGsf6WEQEup179Tq/3pj6SU + ALYh1Pz56PkSnSuXKKCS5uOP9I+98PDDX6xu3fqfV3K5nbHQq3AoJx/dpQytzrW8qeHpNXzun2IEECAh + ASkENn/4w3COHoXXbIbbeBCa8b80NfXA3wTBc7+cy/0KF46YAITAW1Keut22b+HxAEpRIBL+plL1065b + QpLNcRD+z1cQTvNdQmgBUIVdt8YbngUJoFdO8kszO4K021tt+6EaOpcEUDlwWynv+VKJVrxTzQmfFcHj + TmOLHAA82Gj8x69b1revyef/7u+2WscA3ICwao9SekD4g3FtX0Ei/Fzw+XCNkTPzAaD8hS88tOT7Xy9P + THxYSRn64ikCn6bdlSH8QKfAm5aBAhBExMJ7LgKlEAiBzffcg/rx4zEJtAHcZtt3P12vvygnJ5/bk8v9 + isU1JIATUs78wvOO3zU1dUc8AYh/yej5C60WDRwhIaINPjzaX4U+T3EtFp6ZFg1SnpNqpp+x7emXgIdt + IK77jz+zCteIv91svr6sFAk5xad42pms0pGyRi8XcR3Av5XyHMKBCjcgIVQK4NA/nm9YrSLx8+kH5UsY + Ru6HbX7mM9ctbN367QUh/r7K5aCixZvSFH5TiMMHO4kB6QIfm/zcbYBOApSloeUbm++6C7WTJ9FynJAg + lMJNxeKOFxqNt6oTE+VPF4ufvlapnQ2g9mq7/frzjjPzq1NTH4w+eBJEE0lJMYTAhWaT/H8K/tGabW75 + OUhmKfbzf576XhcLhd+0gGnBSI1POapLufh0tXoMoYHAhZ8HpMe+BgDQC4F4/TqZ+MSQDtK1vtlmOZKC + DwAXP//5L83lcn+ohNikgiB0Ks2g3iU0vIQu8B3Cbvj9RCyxyY/EkaXcKZXttoXA1K23oj4zAz8IoITA + zlzuOgBnD7vu3GHX/TYSXzwPwL7dtnfaCN0B3rAjlIJtWWgp5b3ZbC5Ar/S7ooJUs+3p/Zb1Fb7fIEZE + CK9XKi9G9/CgJc//mw1BYwsiAN5+S66VFz0ukRAAj+7zneojK/jOZz5z3fy2bd9fse0H4gAf8/O1CD/Q + odW5H88Fn5MHjOeAvzcMAgj9WwRUqqtU6PtLCVUoYNPNN2P5zBlYAOZarQsIBZ5iN6SlLQDWTsvaTlE4 + RE+yoydAKSyF0X8F/fwwS7Y3VIhOFAqPSWAXgLgDMG4HVgpn2+1fvBh+70L02ShdSZZrDYnFOtZlwEBC + ABTgaSKpVaeoP0X8zR58Xkc9kj/iwkMP/e6ZrVv/SAKbNHOfCz4SgZFMyLm2l9HRLpUg22349TqCVguB + 48RNLABgT00Btg17agr21BREPp9YGoA2Lt33/TjyT0TgA7A3bcLE9DTeXFmZedvzytFXof8hLdwEAGwF + rqGdBtwKsCPzf9nzLkBvR+bnwYYv71jJ5Xa9IsRXKE3J3SOEH8b9Qbl8APp5y7cOk9uaaf8InADI9JcI + hZyq+4j902r0R1LwAWDuN37jT0u53JekUrGvb2r0S932ajW0l5bQKpfRrlSSE5blqbUwebWqfQYxMQF7 + yxbkpqdhbdqkrTrnE3radFsIKClR2bJl6amZmZejt+H/W6rO8397YuLufBRE5IJEn0cohTdrNbIAeOdm + GgFsCI7k80/FnahIgqEKoWV0rNn88aJSZMhQ0Jpc1zJCAmgi0/4xOAEACTO2kAQCyQQkxhzpH865//6d + 56anf1QX4u9IP4yBkrbnGt5M41GO3nddeEtLcM6dQ+C6ejtfiuCbP6RGCK0W2q0WguVlqFwOue3bYW3b + BpnPJ5N5iAgQhdGVwvZ8/hr2dkQAVLxTBuDsBHbGC0Ki7xUg1P5KCNSkXF5Riqbn8CpPsgI3NI12pFj8 + 8rwQu8kNijMh0e/QkHL+fzcaJxGmrcnl4c1JVKew4cR1NYOP4eJxJirWoMfocbo9kig9+OCnzmze/BeB + bV+vWAWfJvxAapTeK5XgLCzAu3gxNo3iqjqkC/1qwk+34/cKAjSXluCvrMDauhXWjh0I8vlwSAdlBgAa + vZVnL+eluzWEwlB7by53Yx5J7k2pcFUXuS0Lrdbp6CE+2ISGtvDCroGfD6cKhb0zlvUVczgp7R2UQuDn + 1epzCP1+QCe8NN9/pK3XywHPAqwlLzuyWPrUp35zYdOm/ymBzZL5+2nmPaJLCaBVLsM5cwbtanVVwU8T + +rUQAGdfuu7W6/CaTWDbNojpaW1YAhCP3uIJA54GqwKoXgMU20rFxUF81ZcCMO+6F5BYf7yr0ySAgaJs + 27sOWdafsYGyyWDS6Jj3/YPPet4iwroVcmG59ifXh9cqZMBljAQbZZx/8MHfvzg19XUlZRywo7SddsmI + oN1ooDk7Gwt+LPwpgn85Qp/2WHxpvLdbqcB3HNg7dkBGU3EkQAtHuevWMXlpCmg3IgKgyUFkSUil8PMw + kg7oU354vcfABcmxrOlD+fxTbSGmtenENLcQQAtwvlsuP48waE2ft4lE8/PGJF6enAEZAeD8Jz/5++Vi + 8evS95MAHtDh75MVEPg+nLk5OAsLmt/UTfgJq5FAGtKEn25zK8P3fTQWF1HYtg0oFMzSOV7bwYO47aJS + 0o3eU6poJ18UFCwHwbno9UQg3PzfMB/6rXz+G01gt8+0fjuaVUi3Zz3v1YvhFCqK/FMqmzoUue8/Vlbt + WjDWBHD+/vsfL01MdGp+5u9zN8AtleC8+y4C39fHFBnmM1IuzeuXBKvMo9cquh2lweK/rxScahUT27cD + lkXBG9OD4A1/Mp6yS3dEJrYNoOr7S9Gn4Bkg3tE58CzQ8ULhsXkhHuUjyeMjsgQaSpWfqtXeQOL781Jl + CvyZab9M+zOMLQGc+/jHHy8Vi9+QUX++VIbPj0TryyBAY3YWXqWiCf5q5v66Bd94HfnnaX+H++5+EMBp + NDC5ZQtaUvKyXF5AGHNGAShTAZCNsMyYRnJfa9s72Gv4KHKz2WcgOJ3P750V4pua5qd6B0p7AnjDcV5a + VIrajHmjEm9Nzop+VsFYEsC5++57rFQsfkP5fqfgs8i+UgpevY7mqVPwg6DD3OdafxCC33Gdpb44KcTL + WBwHxU2bUG63yylvq2F7EBwq2zZUZP7bItkcvMOybr7TsjafDCc78yzAwDs7y7a96w3L+jNKb/ok9NEl + kUEDqPyfZnMWYcaD0n5m0Q8v+c2EPwVjRwDnPvaxf1PK57/JI/2Sa3wkZn9rYQHOwoKu9dHd1++W3rts + MLMfQDyggxMOz4NzK6HVbKIRnvgcHR9NIHIBotdxC8AWAvdOTt56stGgSkA+knyguf+Ttv1UO5pQ1aH5 + mUVwpNl8FUmxGhU6mRV/lLHItH8XjNU8tMV77/3cim3/kfR9yCBAEASQQRCO6fJ9qCCA9H0EnofGzIwm + /Hwbjub/o7sF0AtioaZKN3abr1/TSEkItF0XS2H/Pr0Nz07Gb32f6/4snsChkiWctH3nPYXCXfz5ffxq + XfFWPv9lR4jd8dQOnvNnkf+aUtWnGo1Z6CW/lOIkAqB+lSzwtwrGhgBKu3ffvyDE92Qk9NL3kyO6L/B9 + +K4bpvcaDT1yRtVn6L/Jz5GWPeAaPh7cCkZI3B1QCudKpSXoRkvabAZlA6dJ+C2DBKYt69pPhN2E1G27 + 2gbjnrGYy+1eEuIrvNSZB/3ikmfLwqznnURivfI5FVXok4mywN8lMBYE4N5557XzwBNSyi1c4PnhBwH8 + ZhPN2Vn4rpuq9Vcz+ft2hhlRf27+S6b9aZ03381ICzKPOg4V8cTyhM6uTWUDR7TZWypZwiEA7J6augeh + oKVN7u3rTL3TlvUNXtrLq/3ilVDRhOpna7Xj0WfgjWqk/Snnn5n+a8BYEMBssfjDtlLvDwztr4IASkoE + QYCgVoNz9mzoFmB14R+EyU/vlSr40AOAsYBAN/+jKbhz0dtx4Tc3JisAmFDqMKUDNUsgcgNuzefvRjLO + m8Z4cxLoC07l8/scYA9v8kldTy4ETvv+28tK0fcg35/PpMwq/i4DI08A795999c8pT6hmfqR309mf7tU + gnP+/JqFn9B31WJqfySCT8IfGKRA7gkFMM+FI7xM4Te7OAEAm4Jgf9roXSKCAlB8eGLiAwgJgNaaEwnE + vUS9oizE3sD4joHQC3+o9Pe1UPsDSdEPdfxx4c8q/taIkSaAxfe979crQvyBqflBZOD78MtleEtLXYN9 + GyX8qdqfRfjThIMWePAR3ueTCT5pbdyaFfCA5+23lKrwtdymg3/X5OQHkb5Uw0afzp8AmI79FdHZ7EO3 + 60rVj4QpToUkNclH0VPgL0v7rREjSwDunXdee8G2vyV9H4oF/BRlAHwfXrWK1sqKtnHzUsI/iHC4AtK1 + P/RNTYEhELwfHkJgOQgWzvp+HXoJ8GoFPMoG/lbbuhG5ADQe7HrLes8NQkwjIQDa60dr4Hq2AnwhpnmQ + 1UwBUtBzttWaiV5CDUp8CQ3X/lngb40YWQJ41/e/67fbN5PgB3QZBfwC1w0n9KAzx7+a8A8ELIqvpfqM + ACA3k/l+P3rtGcc5hU7hX62EV01K+Vfc7CfBp9mECsBDmzbtRrLXj9wAsgJ6hgvspg9Fm4nibUXMzTlY + r9P3MzsceeAv8/0vAyNJAPO33fYFR8pf536/khJSyvDSdeEtL2tan06yjRb+1JQfDO1PQTCg0/wHgPAx + 70ClwglgLS286u12+y+56W8ZwUChFG4vFD6IUOg3ISGBvu3W4+a/tpGakVxdqcZsEJiryPl6eU5ymfZf + I0aOANybb96+CHxNRgJPKb4gqvkPggBeqZRs2AE6LjdM8wNdtX8sAIb/z3vh4+IgAHOuyPJMoAAAGb9J + REFUS8K/2gSfDgL4PSlLNvBMHAcAI4Ho820RYsf9udytCM1/2u5LbkDPwUC+lITXAfAsx7w+oJRvJM7G + fPeAkSOAOaW+2vb9W2QQhAQQmbIkaO1SKRnhBd307xbwGxSUKfyAJvS0mp2EwTeEn0aMCQDHy+Xj0VuZ + 8/toYUs8NYx/BACyIOXTcRyAFQRRPEAB+NDU1Eegr/cmK6BnAoiLmBjZ8aWnCsC86/Lx5Gnfj+8hzLBG + jBQBVO+4471VIX6PCzF3eNuVShgMxOrCz7FRpn9HmbER8eemP9f+AHDW806dD4N/5vhubh53C47JI+32 + XwqlqnGpH4sFECHcms/fg9ANICuACICCgT39FvTBzIAsPfaC41B6k48448LPp1RnWCNGigBOO863AeZD + I4mw+44Tj+HmdbHxVFkkZ86G+P2rBP7MVF9sEhtBMUTv88bKyhEk2t9c0X6p4Jj891Ku5IBntJpfIoHo + SXZSE8DdAKoJ6CkbEGt/JLGPeH05gGXfN1ObpnvD13xluAyMDAEs3Hjjr3qW9QDX7AQZBPBrtdjPTPP7 + CVfE7+efh5n+nAS8qB6e5/4FgLOt1qnzvt+ALhw8NcbLYrshsILgu7QTQJgWQGQFvHdy8kNIdwN6CgZy + F6BjiKoQWEwIgO8nuCIDSkcNI0MAF4EvA52mvxICfrWqTfC9lN8/yLOoq+nPI+CWFW7+saww8BfVwJP2 + J4uBaX9uGpPpv9bcuAIgP+d5+4VSczRdw1IqvoyGjFJNwDXQSaCnmoDz+fzuePoR0i2xekhwZLyRi5Np + /z5gJAjA1P5cuwaui6DV6myJu1LCfxmmf7z4QySFMWQqCwAnms0j84nvT4ExvgNvrdFxCcDPKfXfKQ4Q + Cz90yX5gcvJu6HGAnmoCPCGuSYu/KPY3L7RaK0i3ALI13z1iJAjgIvBlfgLFs+6ljE1/0zLgRLERMIWf + b7SRTPNrZbAiGYThW1ZsLQgAPuAdK5V45J9v7jW39q4lOBYstds/4M1BWqNQZAXcUizeiQHWBNC8w/gm + gCO+zwkgrbox6/lfJ4aeAJanp+/1bDvW/rHwC4Gg2QwLgcA0P3TTHymX/Uaq5kcS+NK23JimPwsESpEs + w3yzVnutLCX59mnaXzP/FS006P4R5e8EwSmh1N9wC4C7AQLADZZ1xz2WdT10K6CIPrUJk+anceWOlHUk + 5n+8ER16g9NGcvlIYegJ4OLk5L/jSzpjYZYSfrPZOU57g03/NOE303xavl+E/e8e1/4sNw4AK+32wsFy + mZfFUlEMDcQwh2FCpO7T1iAB+AUpn9YmfxjZAADYPTX1fiQpQbNB6LIIwAdEt99eKIWmUiYBkLXDU3+Z + +b9ODD0BOEI8zAN7QHS2NJth2S/0nPKGqwqDcCj+wE1/n2l+Mvc9dp1rfx/wDiwvv4zOwF/aPLzLbYyR + n2u1nhRKVW3S/tHB3YBbi8UPIJ0AcujRAoi1v36dfjre4TjwAaXjgKEmgDM33fRFaVlbO/x5IcKcP1N6 + V0T7R39P+/tM65t+vzkFp8P0B3Cy0Tg6325Txx8NxKBFGL3Mw4u1bB74a14LYLYJbxVixw1CbEV6NmBd + lYHd/geVxP+Pq4TZkWn/HjHUBFAD9tIgjNj3B8KiH2O4RzftvxHCH2cdhOjI83O/n/L9XnSfH8UCYtM/ + CBYOrKwch27682GYNBJrvfPwFADf9f3/SnEA28gE0C7BT05O9s0NSAO9QTuMc3AXIG26UWYBrBNDTQBN + 4LNm3lgJAem6wBq1/yCQJvwduX7D7Ce/X1t+Cd30/9mFC/uRaEI+B7+EZA1WL/PwFIDgt9rtgwI4S5rf + rAcAgFuKxfchFHoaFsLHhfVlUpAAIIQwyzf4qvrM/O8RQ0sAZ6+77h+CLcQkyCBA0Gp1pPo2QvvzCD/Q + KfxayysJvkgm35L2p8IfXvF3sFx+uRJqQ4kk6k/rvvu5AVcB8PNSfs+cFBR3CCqF62z7doQaf5IdlA1Y + txWgDSeJ/hb0GABvF8i0f48YWgJwbPteLcJOqbVWq8P3Tjv6jY48PzqFn0x6nwt9dNki0580v2XFVsys + 6x4/VqtRMww3/cvQtX8TvffEK4Q1AU/aWH0W+J5C4Xbo8wJ5VWA/wX9Ws08oQw8YWgJoCvFL3PcHEAf/ + AN1m5MFAQj9JoCPVh0sIPzf9iQSA+DHT79+/uPga9Kg/F/4VJNq/H/PwqCZgxgLe1AqDWIEQhMB7Jiff + h2RiMK8K7EtREHM5uFFltntkFkAPGFoC8IT4kBnJV1JCttupDT6D0v5pwi/XIPyU54/z/dH9vEy5ImXp + hdX9/hWERLDetF83SABBXqkXyOyPg4BRTEIB2JrL7UQo8D0RAKdnPoeAPca1/UYkcMYGQ0kATcualkJs + jc+CSFtKz9Oe103w+3XWpBb5sFQfBfq6Cj9dp+o/6EG/g8vLpt9P+f6V6CDTv4H+jsNSAALl+0/GKUAR + Lh3hwrrNtm9CsjeAjwy/7KrAtCcKANtzue3G56LLTPj7gKEkgMpNN33MdAAVIgJIMcX7jTjmwH1+kT68 + U4v2M+Hn/j+NvybhFwBeXFx87rTrriAp9aU6f9L8pP0HtQFXzgfBbCzFXSqJ78vnb4S+OOSy6gH4u6Y9 + OS9EIeUp/f+njimGkgAIWsANYQagW/Cvn3/TDPbxxp6Ojj7D14+Dfuy+eN13RFYHa7WXT4cLPnnQj4R/ + OTpK0X2D2oGnPlAofJYCkVzi+HefFGIS+vYgcgHWnAlYw4fWEgPsdkYEPWIo14Pz4B8X8sDIAJiv6YUM + uODH7yeS0Vy8r9+P0nw0xJO0PDf7ufDzdN+hWu3lw2GdP+W7W0jSfcsAlhBq/15z/pf8yjUh/jXoewu9 + p4LuP9ZulxCeR0QCNCaMEgiXrEZcoxTzJUYZ+oSh/jG1PL9SiUCif9o/diNStD4Jv9nNR1rfY7n9juur + Cz9F/EnzlxEKPgk/j/oPZA7eUi63KwA+ot3JCVAIVIJgZUkpHwkBkP9Pwr/uWgDCFsu6FsbWMuhZycwK + 6AFDaQF4SgllCKTyvERLG/7qeqSDa7luWl8haeU1G3sCCu4BHeZ/+9LCb+b6SfNvhOkPADhv249wra8N + W4nuf7fVegfQaoT4GvHLEsxuTy6EMQB6mAt/Zg30AUNJAGSSKqVi9RdPygUT0lVb4NNBJBJfZ+9ppvno + 78YtvXygR1TNxzV/nOcH1ir85PMvIiSADRF+AFgW4lHw78qP6P7Djcbc6u9ymWAbibT7EmE32xKAzALo + CUPJoLvOnn2OR+K1OnsYmsqI1nc9zBMcRk4/uk6+PTf34/bd6JKq+lqWBZcCftHBU30W1qT5LyIkAF7r + P9AR2Bfy+d2eELu5O6VtTRICC75/+lQ4rIPX6PNjTVV64hIkzR41zf++7CUcdwwlAQCAAI7xkd5akXgX + Mljt0CYGgaXz6P0i7a75+cbRioTdEwJuJPxpZj+EQBvwLiH8S0iEn/x+GvE10CGY5yxrHw9qaiPVoutn + XPdM9HQ+qqvvU3oUgHtzuR3oJIAsC9AHDKcLAMCS8oiy7XuUZUEqFQt97LNHQUF+0lLrcAcMPx9A52sZ + GZg5fm2IJ4v4UzDQNPnbgBfl+UtIov3dhH8ZofDzHv+BFsHUhNjLSZHv6VPh528902jQpl4SfBrT3W0T + 8SVhSrOK7pu0rALStX9GAj1iaAlgAniyKcQXzPQbEEmHZYUkED1O96emCM3Ho5MdSHEB2N+idB+v46eg + HzX18GAfAJSlLL2ysLDfGOphCv8iEr/fjPgPtAHmTD6/54QQu9KsIPoec553EqDZpNqijste0tlNervc + nxYDyNADhpUA1EfPnXvux7fddk4JcbNE2D0XRIFBaVnhTjtGAoppYH5WdtP8sfY3BCBtTRdv66VhnvQa + /nfnPO/Ua4uLv2DDPLsF/Ljm3zDhB4CLtr2PiEvb1IvENTpcr89EP5G5h5AvIr08SyWy2OKbdCW8zxT8 + LA7QJwwrAQCAyvv+17xC4ZsKAAoFLRgYm/URKXAzv+ON6NIw9xUz31PXdbEy3oCZ+2km/7Fa7bVDib/P + N9zyIh/S+mm5/g1pfa0Ae83BJXyWQTUIlg75fhl6rULaHsLLdlXMUj/C9YXCtfC8d9A9DmDyeoY1YpgJ + QO45d+6JH9522z+Bbd8nAahCAX67nfirkRUQpwNFurLQMgHQo/+k/fhePsr10+IOChDGZcEiqemvBEHp + 4MrKy+8m/j519fGBHiT8y0iq/LjPvyHCf6pQeOQdIaY7wvrRd1cAjjvOm9HTJZIFHSYBrDlIOaXUu90e + I6mOagHMGEDmCvQBw0wACkDw9vLyv7ztuut+IoTYLAqFcA8gEi0MRMM1IojIIhDR4wKsz5QF/rSAHxIh + oDXdfGtvnG1gvr5AuLnnpeXlo/RZkZT2NtBZ27+EkAz4Rp8NHXq5aFmP0vfWZhYibkdsvdxsUu6ffP8m + QheGb+pds/a/0fdP/3Uu10HO9GJDurkLwC8zrBPDTgD+4/X6zB8Wi//01unp71oTE5uU68apPNLKZv06 + aWj+Rjz4x31eTQiYYEh2GxFR0Nm57PsLR8rl195NGnq4yc/7+Un4yeQn4d/wdVdNy5p+SYi92sxC5gIE + QmCu3T6xHJb+rmcN+ZpBtQHGG5j+f6b9+4BhJgAgUkx/sLx84D9J+cW7rr32WyKXm5LRPoBYmJXqGAoa + hpaiPXucKMjkh+4GmDUG3NRXUc+8I2XjeLN5hC3t4FN8aHNPBXpLbwn6PL91+c+9Yi6XeySOd8BIdyL8 + XV6oVo9FT+duTAPJFuK17CFMRTdJNn6E1VKBWQxgHRhmAogVPQD3q6XSgU84zuf/8datX7U972N8co2W + ykJnOpDn+7WdfdBTfzwzQBAAAsA73mgcfSXZ1UfuM9eS5hivEhKTv2/ac71YtKxHO9wdFgRdDoJz70jZ + jJ5ufi/KAPT189OvfF2hcAM6G4KEcWRYB4aZAIBE2FoAGq+47tlXXPc/fGli4nN3TE7+jgVs53X9vMyX + hDt+LHqcCz5ZCPEAOuY6CCHgStk4Xq8fea1SOYWEkEjwKUBGJj/X/GUkG3x4S+8VEf6VXG7Xa0LsMaso + SfglgBnH4bl//t3SzP/LgbqU9FIIF51uQIYeMSoEQLnoKoD8f3PdH8F1D/6jiYlfvmVi4oFttv1+8tH5 + FGFAr/nX+gD480QyCssHvHnPO3u60Zg51mxehF4LT3lxrh1J+Pn4blreaabMrogZO2/bj5i5f5+5AA2l + qj9oNmcQdvqZgUwy/9fvunTJzqDzzdLqATLt3wOGnQCAhARchCdDPInme677/+C6B28U4oZ7Jybu3lEs + 3rHJtq+fDmfZxYE7hSg7wCL4fBJOOQhKS+32wmKrtfB6vU7juYk7aE0V7a0nv5jWdJPQ8629pPUH2tSz + Vixa1uPc34+LnhB+yTnPO45kuAcPZtJB1X89WzBcmo1GoNVcgAzrxKgQAC9KEcZ93rxSrR86TgmOcwTR + /PodQmy6o1i8QQLWjkJhR862ixIQZL/Ou+4FAOKw4yxALxjkKfI29Fp4EgjS/KT96+jMk18Viy3n8/nd + R4Fd5P/zCkcKgv68Xn8nejq5WxT5Jxdm3cE/AGHLL7cC0i2CblWAGQn0gFEgACCxAszbfHtuA8AWRDvt + l5SqLbnuMoAcXNecYmNGl+P6IPa+JPi8Dr4eHaT9SfBJSMjXv+Jan3DWth8zg388zXnR92feDoN/UVFj + THRm7n8jySwT/D5hVAgA0EmAWwC8WGVzdJibbPgs+7Qac1P4PSRan4Sfa/8mksh4muBfFcIPAFUh9pLw + a9WOCAngYL1+FOHvwdOZ/Hv2pv0Jq8QB6BmrHBnWiVEiACAhATMiTyctCT4ts+RjrPk8e4ojcAuABJi0 + PkXCHejNMA57nLfFXnFz38QMlf4yzc/rHJpSVn/meRcR/i4mmfJYRl8tmkswZCb0fcSoEQCQCD+dRzwy + 30Co7WmENWl/En7aa0cbbulEI2uCCICOlnHQ/byS76oTfAKV/vqG4JP5/0aj8SrC3yOqBNYKf8j87zn3 + b76wi4Tzu82nZISwTowiAQC63841twtd2Ok6xQD4PkzTBaD34Tvq2+ygbMBQ7K1vWtb0i5a116x2pOKf + tlLuC45zGonvz6sZef1Cz+Z/DjjcBj7SrR8gw+AwqgRA4EQAJNYACbkp9JeKAcRVwkjIgGt6yZ5/VWM2 + n9/HBT4OAkaXZ9rtY0tKBQh/C+5Gkfnft7JlC6jwYizQJSvUyjAYjDoBEOgcImH1kZ5T7pZa4lkAPjqQ + k8tQnacXo9y/Vv3HzP/9tRoF/3jdP2l/0/zvCeb6NoWwIUgwEsgwGIwLAXCYAkuZA9OnTCMA8z2GEvP5 + /O6jQuwyo//kDiwGwdsnpHSQBP946s/U/v2AMn/c+AdXCpUgWEEn2Y7M/+NKYhwJoBvG5oSas+3HuPDH + bc7Rfa/X64eRBP/M6kZOAP0LcLJuTRjmvxeOUCNc1bGVYUPWUDGGqEbBP7PvPxACjlKVn3reApLGH9L+ + aWXMfRN+ANpAlRQpN+M55u0M60BGAGOGE8XivgCYTtviIQG82Wy+hDAoqqCnT7n539fKPx78A5KgAvVk + 1IKgZrzkqs+yDAsyAhgzLFrWo2lTf6M8qfvTMPXHg39N6Nq/P5V/DAXgMG/XJneAmrXK4Qh1MxDLSSAj + gnUiI4Axwkout6spxJ60qb+BEDjXbh9dVIoEOy3111vbbxfYQJkvYCHQtRPtNgUBeev1VV1kNSzICGCM + MJvLPWZG/uNxZ0LgJ7XaYYTmPw/+UerPDP71HWY6EOEf85aV8tCp/TMLoA/ICGCMUKKxX0b+XwKYb7cP + vxWm/gB96MegUn86UgKBAFAPgiWkd2OaxVcZ1oGMAMYEM4XCIwEw3dH6G10/2mweQ5gWVtCbfgaX+oug + DPOfgn8CwJLnnYdu+vMKzKuuu3LYkBHAmOCibT/K9xrEAz8BlJV698dJ6o8H/8yuv4FsJd4s5aH4RkQC + VJL5luPMQu/F4L0XmQXQIzICGAOs5HK7asbMfz7teMZxjiJsjAKSrj/T9x/Y0I+CUmXS+PxoSVk54PuL + 0IWfiIiPU8ssgHUiI4AxwFwuty+t7j8A0FSq9L+azZPQU39U+NPfoR9dEHv8EQmQ9r/Qah2BPt2JCMBs + uc6wTmQEMAZYtqxH+UqzePAngDnPO4JE+/vQU391bMCyEsvzDgnDAoBSzvcbjVegCz8NYeFzFTPt3wMy + AhhxnCgW93lC7JKG+R/1RTtP1euHkFT+mcE/vu57YJr2/VJWJqT8K9L+NoAj9fqTF5RqolP4iQCuyAal + UUPWDDTiuMgWfvKhHxLAYhAcXwgLf8y6fz7FmEZ+DRLq4Wr1t/+ZELd8fGLit+akzP+PVuscgJ1IOhL5 + 58oIoE/ICGCEsZLL7TogxB4z5Udtv89Uqy8hOQc86Np/o9eVqSeUKj3hOH8B4AYAt0SfhUx92q0w0JTk + uCEjgBHGbC6XjPyGbgUsB8GxN8PCn0kki1V46o9r/40QMnORahWhR1CM7qcdCwOvSBwnZAQwwljp0vgj + hcDrjcYBdKb++C6DDdX+0AmghnBYazu69JFsWWpgY4lppJERwIjiRLG4bzZl5LcEUJFy5hnPu4BwSQrV + /ZOPzc3/gaX+UkATnB2Eml9Fn8lGKOxUm0CWSWb+9wEZAYwo5m378XjopzHxZ8ZxDiPUrDTxN23g50Zr + WW4BIPrbDehjyWn8+kYS00gjI4ARxJlCYc8xYHfasE9XqZXvNJvHEa5JI+1PPf807tvFlREyIgGyBmhB + CxUDUeQ/M//7hIwARhAXbLuj8o8sgGOO8xN0an8y/YkABtf11x28tdec3Gw+lgl/n5AVAo0YmpY1XRbi + Uc3sR6j9W4DzI8eZQRj8o5FffKkpH/d9pWrseekvX8KSaf4BILMARgwnC4XHeM6fE8FZz/vbeaWo4I5S + f2bd/9UUYb8aPsNII7MARgzLlvUo7/bj+/7+vF7/BfTUH9f+G536y3AVICOAEcLxqO4/beDnQhAcmA/X + b1BajXf9Ud1/C1eP9s+wAcgIYIRAQz94+o8yAE9Xq/sRBv+AUMt3m/iTEcAYISOAEcGZQmFPk9X907Yf + CWAhCF45LKULfeAn9/0HOvEnw9WLjABGBOdzuX08+Bev/ALww2r1eSSpP6q2M1N/WXXdGCIjgBFAKZfb + VbKsR81R3wGAspSHD4ban1J/Gz7xJ8PVi4wARgDvFAqPUaWfWf33WqPxEsKOum7a/0qU/Wa4SpARwJCj + aVnTK1Hqj+f9pRCoKXXy/4ZNP7zwp4GwtZYH/zLtP6bICGDIMVMs7guo6w+Ih31IAK/W6z9GqP2p8Idr + fz7ue6PLfjNcJcgIYMixYNuPk+anrToKQEPKE9/3vHnohT/c988KfzJkBDDMOFUsPuIJsYuklzS/AvBs + tfoDABNICn942S8V/lDkP8OYIiOAIcZiLrc3XqtN67UAnGg2v/VsEKwgTP2Zvn82Vy9DjKwZaIhhA2Uu + +FLKkwcc5zt/4nllhBN1KfJPwl9BVvabgaFzH3OGYYI4WCg8NC/ExE99v/K1IAgA3AzgRgDbEPr/HoAV + ABcAnAdwEUAJyWy9zAUYY2QEMNwQCM38zQC2A7gewE0Itf+m6PEmgGUACwhJYAWhFeAiswDGHpkLMDqg + QRot6PP06wgJgAQ/K/vNECMjgOEHjcmi0d7V6HYOYZCvjtD3J7M/8/0zZMiQIQPw/wGcCGmdjgnpvgAA + AABJRU5ErkJggigAAACAAAAAAAEAAAEAIAAAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAABwAAAA0AAAASAAAAFAAAABAAAAAKAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAUAAAANAAAAGAAAACQAAAAnAAAAIwAAABcAAAAMAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAABMAAAAlAAAAOAAAAEAAAAA7AAAAKwAA + ABcAAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAGBASnQAEBQTcAAABEAAAAUwAAAFEAAABAAAAAJgAAABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYG1UMODrP/EBCq/wwMj6MAAABcAAAAYAAA + AFIAAAA3AAAAHQAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAw0NtfAPD6v/ERGi/wYGX4QAAABoAAAAYAAAAEgAAAAqAAAAEgAAAAUAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCgrDkw4Or/8QEKT/EhKT3wAA + AGgAAABoAAAAVgAAADgAAAAdAAAACgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAEBNQkDAyz/w8PqP8SEp3/CAhkkwAAAGsAAABiAAAARwAAACgAAAASAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKCsCjDQ2u/xAQ + o/8REY3VAAAAagAAAGkAAABVAAAANgAAABsAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQYG1UQMDLP/Dw+n/xERnP8GBleLAAAAbQAAAGEAAABEAAAAJgAA + ABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoK + vNENDa3/EBCg/xERi9YAAABtAAAAaQAAAFMAAAAzAAAAGAAAAAgAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAwAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBwfPYwwMs/8ODqb/EhKa/wICNnsAAABuAAAAXwAA + AEIAAAAjAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAADAAAABwAAAAoAAAALAAAACAAAAAUAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADCwu34Q0Nq/8QEJ//Dw+BxAAAAG8AAABpAAAAUAAAADAAAAAWAAAABwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAgAAAAQAAAAGAAAABoAAAAWAAAADgAA + AAcAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMiDDAyw/w8PpP8SEpj/AQEcdgAA + AG8AAABdAAAAPgAAACEAAAAMAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAFAAAAEAAAAB4AAAAtAAAAMQAAACoAAAAcAAAADQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAQE0yQLC7X/Dg6p/xERnP8NDXWyAAAAcQAAAGgAAABNAAAALQAAABQAAAAGAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAXAAAALQAAAEMAAABKAAAAQAAA + ACwAAAAWAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoKv7IMDK7/EBCh/xIS + kvUAAABxAAAAcAAAAFsAAAA7AAAAHgAAAAsAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAACgoKrIAODp7BAQEkXwAAAF4AAABVAAAAPAAAAB8AAAAMAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABBwfPVAsLs/8ODqf/ERGa/woKZqIAAAB0AAAAaAAAAEoAAAAqAAAAEgAA + AAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAMEBCq/xISn/8QEIfOAAAAbQAA + AGQAAABJAAAAKAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCgq44Q0N + q/8QEJ//EhKN6wAAAHQAAABwAAAAWQAAADgAAAAbAAAACQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQEBghwPD6j/EhKd/xMTk/8CAjCHAAAAbwAAAFMAAAAuAAAAFAAAAAUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMiDDAyx/w8PpP8SEpb/CAhZnQAAAHUAAABmAAAARgAA + ACYAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBga7Sg4Oqf8REZ3/ExOR/woK + XKwAAAB0AAAAWQAAADMAAAAXAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE + 0yQLC7X/DQ2p/xERm/8SEoTZAAAAdgAAAG8AAABVAAAAMwAAABgAAAAHAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIGBrtKDQ2r/xAQnv8TE5H/Dw9txgAAAHgAAABeAAAANwAAABoAAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJvrMMDK7/Dw+g/xMTlP8EBEGOAAAAdgAA + AGIAAABBAAAAIgAAAA0AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgYGuEsMDKz/Dw+h/xMT + kv8TE3jfAAAAewAAAGIAAAA6AAAAHAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAADAAAABAAAAAUAAAAHAAAABwAAAAcAAAAGAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABBwfOVAsLs/8ODqb/EhKY/xAQeMkAAAB4AAAAbQAAAFAAAAAuAAAAFQAAAAYAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADBQW3TAwMrv8PD6H/EhKT/xISeOAAAAB+AAAAZQAAADwAAAAdAAAACQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAGAAAACgAAAA4AAAASAAAAFQAAABgAAAAZAAAAGAAA + ABYAAAATAAAADwAAAAoAAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCgq48AwMq/8QEJ3/ExOM9gEB + GYAAAAB1AAAAXgAAADwAAAAeAAAACwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGBrNNCwuu/w4O + ov8SEpP/ExOE9wAAAIAAAABmAAAAPQAAAB4AAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAHAAAADQAA + ABQAAAAdAAAAJAAAACwAAAAwAAAAMwAAADUAAAA0AAAAMQAAACwAAAAmAAAAHgAAABYAAAAPAAAACAAA + AAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEICMWTCwuw/w8Pov8SEpX/DAxlsQAAAHoAAABqAAAASgAAACoAAAASAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAABAUFs00LC6//Dg6i/xERk/8UFIn/AAAAgAAAAGcAAAA9AAAAHgAA + AAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAEAAAACgAAABQAAAAfAAAALQAAADoAAABFAAAATwAAAFUAAABZAAAAWwAA + AFoAAABXAAAATwAAAEYAAAA8AAAAMAAAACQAAAAZAAAAEAAAAAgAAAAEAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUF1TQKCrX/DQ2o/xER + mf8TE4ftAAAAfAAAAHQAAABZAAAANwAAABoAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAEBwe8iQoK + r/8NDaP/ERGU/xMTif8AAACAAAAAZgAAAD0AAAAdAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAoAAAAXAAAAKAAA + ADsAAABOAAAAXgAAAGsAAABzAAAAeAAAAHwAAAB9AAAAfAAAAHoAAAB0AAAAbAAAAGEAAABTAAAARAAA + ADQAAAAkAAAAFwAAAA4AAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwkJvNEMDKz/Dw+f/xMTkf8JCVOjAAAAegAAAGcAAABFAAAAJAAA + AA8AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUHB7uJCgqv/w0No/8REZT/ExOK/wAAAH8AAABkAAAAOwAA + AB0AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMAAAAJAAAAFwAAACsAAABDAAAAWwcHTJMPD16+EhJh0hQUZeMVFWLkFRVf5BYW + XuQSEkrJCQkyrQAAAI8AAACJAAAAgQAAAHUAAABnAAAAVgAAAEMAAAAwAAAAIAAAABIAAAAJAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBwfKdAsL + sv8ODqX/EhKW/xEReNQAAAB+AAAAcgAAAFQAAAAxAAAAFwAAAAcAAAABAAAAAAAAAAAAAAAAAAAABQcH + vIkKCrD/DQ2j/xAQlP8TE4r/AAAAfQAAAGIAAAA5AAAAGwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAAABIAAAAmAQEtTQ0N + dq8SEoX3ExOC/xMTff8UFHr/FRV4/xYWdf8WFnL/Fxdw/xgYbf8ZGWr/GRll+RUVTdoEBB6kAAAAjwAA + AIUAAAB2AAAAZQAAAFEAAAA7AAAAKAAAABcAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAroVCgq3/wwMqf8QEJv/ExOO/wICLI4AAAB6AAAAYgAA + AD4AAAAgAAAADAAAAAIAAAAAAAAAAAAAAAAAAAAFBwe8iQoKsP8NDaT/EBCV/xMTi/8AAAB7AAAAXwAA + ADcAAAAaAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAALAAAAHRQUgm4TE5b1EBCQ/xERif8REYT/EhKB/xMTgf8TE4D/ExN+/xQU + e/8UFHb/FRVz/xcXbv8YGGv/GRlp/xoaZ/8VFUrbBAQdpQAAAI8AAACCAAAAcQAAAFsAAABEAAAALgAA + ABwAAAAOAAAABgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAIJCb+zCwuv/w4OoP8SEpP/Dw9txQAAAH8AAABuAAAATQAAACwAAAATAAAABQAAAAAAAAAAAAAAAAAA + AAUHB7yJCgqw/w0NpP8QEJX/EhJ/5wAAAHoAAABdAAAANgAAABkAAAAHAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABEXF4pVIiKo/w4O + mf8ODpP/Dw+Q/xAQjP8PD4z/EBCM/xAQi/8QEIr/ERGH/xIShP8TE3//FBR6/xUVdP8WFm7/GBhp/xoa + Zv8bG2b/ExM/zgAAAJYAAACKAAAAeQAAAGQAAABMAAAANAAAAB8AAAAQAAAABwAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQcH0GMKCrP/DQ2l/xERlv8TE4f2AAAAgQAA + AHgAAABcAAAAOAAAABsAAAAJAAAAAQAAAAAAAAAAAAAABQcHvIkKCrD/DQ2k/xAQlf8REXvfAAAAeAAA + AFsAAAA0AAAAGAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAGDQ1sJiIisecaGqf/Cwuc/wwMmv8MDJn/DAyY/wwMl/8MDJf/DAyW/w0N + lv8NDZP/Dg6R/w8Pjf8REYj/ExOC/xQUe/8VFXT/Fxds/xkZZ/8aGmX/GRlW7QcHJa0AAACQAAAAgAAA + AGoAAABRAAAANwAAACEAAAARAAAABwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABAkJuPAMDKv/EBCc/xMTjv8LC1evAAAAfgAAAGgAAABFAAAAJAAAAA4AAAADAAAAAAAA + AAAAAAAFBwe8iQoKsP8NDaX/ERGV/xERfN8AAAB2AAAAWQAAADMAAAAXAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgbG7eEISG0/xUV + q/8JCaT/CQmj/wkJov8KCqD/Cgqf/woKnv8KCp7/Cgqd/woKnP8LC5r/DAyX/w0Nk/8PD4//ERGJ/xMT + gf8UFHj/FhZw/xgYaf8aGmX/Gxtg+Q0NL7wAAACUAAAAgwAAAG4AAABUAAAAOQAAACIAAAAQAAAABwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCAjCowsLsP8ODqD/EhKS/xMT + feYAAACCAAAAcwAAAFIAAAAuAAAAFAAAAAUAAAAAAAAAAAAAAAUHB7yJCgqw/w0NpP8REZb/ERF83wAA + AHUAAABWAAAAMQAAABUAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACB8fvMsfH7j/ExOx/wgIqv8ICKr/Bweo/wgIpf8ICKT/Bwej/wgI + o/8ICKL/CAih/wkJoP8JCZ7/Cgqc/wwMmP8NDZP/Dw+O/xERhf8TE37/FRV0/xgYbP8ZGWX/Gxtj/xMT + Pc8AAACWAAAAhgAAAHAAAABVAAAAOQAAACEAAAAPAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEGBs9UCgqz/w0Npf8REZb/FBSK/wICK5EAAAB5AAAAXAAAADYAAAAZAAAABwAA + AAAAAAAAAAAABQcHu4kKCrD/DQ2k/xERlv8REXzeAAAAcwAAAFMAAAAvAAAAFAAAAAUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJHh6//x4e + u/8TE7X/Bgaw/wYGrv8HB6v/Bweo/wcHpv8GBqb/Bwem/wcHpv8HB6X/Bwek/wgIo/8ICKH/CQmf/woK + nP8MDJf/Dg6R/xAQiv8TE4D/FBR2/xcXbf8ZGWb/Gxtj/xUVSNsAAACXAAAAhwAAAG8AAABTAAAANgAA + AB4AAAANAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQJCbbhDAyo/xAQ + mP8TE4z/EBBoyAAAAHwAAABiAAAAOwAAAB0AAAAJAAAAAAAAAAAAAAAFBwe7iQoKsP8NDaT/ERGW/w0N + ab0AAABwAAAAUQAAACwAAAATAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgeHsL/HR29/xISuP8GBrT/Bgax/wYGrf8GBqr/Bgao/wYG + p/8GBqf/Bgan/wYGp/8GBqb/Bwem/wcHpf8HB6P/CAih/woKnv8LC5r/DQ2U/xAQjf8SEoP/FBR4/xcX + bf8YGGb/Gxtj/xUVR9sAAACWAAAAhQAAAG0AAABPAAAAMgAAABsAAAALAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwgIvZYMDKn/Dw+a/xISjv8TE37vAAAAfAAAAGIAAAA7AAAAHQAA + AAkAAAAAAAAAAAAAAAUHB7uJCwuv/w0NpP8QEJb/DQ1qvAAAAG4AAABOAAAAKgAAABIAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxwc + xP8cHMD/FRW8/wUFtv8FBbP/Bgau/wYGqv8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgam/wcH + pv8HB6T/CAii/wkJn/8KCpz/DAyW/w8Pjv8SEoT/FBR4/xYWbv8YGGb/Gxtj/xUVR9sAAACVAAAAggAA + AGgAAABKAAAALQAAABYAAAAIAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBASoQAsL + qf8ODpv/EhKP/xQUiP8EBD6SAAAAXgAAADcAAAAaAAAACAAAAAAAAAAAAAAABQcHu4kLC6//DQ2k/xER + lv8NDWq8AAAAbQAAAEwAAAApAAAAEQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFHBzF/xwcwv8aGr//BQW3/wUFtP8FBa//Bgar/wYG + qP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6X/Bwej/wgIof8KCpz/DAyW/w8P + j/8SEoT/FBR5/xYWbv8ZGWb/Ghpj/xAQM8IAAACSAAAAfgAAAGIAAABDAAAAJwAAABIAAAAGAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAZCwuo/w4Om/8SEo//ExOJ/wEBHH4AAABVAAAAMAAA + ABUAAAAFAAAAAAAAAAAAAAAFBwe7iQsLr/8ODqT/ERGV/wwMZLMAAABtAAAATAAAACkAAAAQAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAMcHMnWHBzE/xwcwf8HB7v/BQW2/wUFsf8GBqz/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGpv8HB6X/Bwej/wgIof8KCp3/DAyX/w4Oj/8SEoT/FBR4/xcXbf8ZGWb/Gxtk/woK + KbUAAACPAAAAeAAAAFoAAAA7AAAAIAAAAA0AAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADAYG + oWYLC6b/Dg6Z/xERj/8TE4LvAAAAbQAAAEoAAAAoAAAAEAAAAAMAAAAAAAAAAAAAAAUHB7uJCwuu/w4O + o/8REZX/BgZKmgAAAG0AAABNAAAAKgAAABEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARsbzqkcHMT/HBzC/w4OvP8FBbf/BQWz/wYG + rf8GBqr/Bgao/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpv8HB6b/Bwek/wgI + of8KCp3/DAyX/w8Pj/8SEoP/FBR4/xcXbv8ZGWb/Gxtg+QQEHKYAAACKAAAAcQAAAFEAAAAxAAAAGAAA + AAgAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAASCQmnrwsLo/8ODpf/ERGP/w8Pcs4AAABkAAAAPwAA + ACAAAAALAAAAAQAAAAAAAAAAAAAABQcHu4kLC67/Dg6j/xERlP8GBkicAAAAcAAAAFAAAAAsAAAAEwAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABGBjWWRwcx/8cHMP/GhrA/wUFuf8FBbT/BQWw/wYGq/8GBqn/Bgao/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6b/Bwek/wgIof8KCp3/DAyW/w8Pjv8SEoP/FBR2/xgY + bP8aGmX/GRlW7QAAAJYAAACDAAAAZgAAAEQAAAAmAAAAEAAAAAUAAAABAAAAAAAAAAAAAAABAAAACAAA + ABoKCqfyDQ2e/w8Plf8REY3/CAhVoAAAAFgAAAA0AAAAGAAAAAcAAAABAAAAAAAAAAAAAAAFBwe7iQsL + rv8ODqH/EhKT/wYGSJ0AAABzAAAAVQAAADAAAAAVAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGxvJ8Rwcxf8cHMP/Cwu9/wUF + t/8FBbL/Bgat/wYGqv8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8HB6b/Bwek/wgIof8KCpz/DQ2V/xAQjP8TE4D/FRV0/xgYaf8bG2T/ExM/zgAAAJEAAAB4AAAAWQAA + ADcAAAAbAAAACgAAAAIAAAAAAAAAAAAAAAMAAAAOBwejdgsLpv8NDZz/EBCS/xISjf8AAABtAAAASwAA + ACkAAAARAAAABAAAAAAAAAAAAAAAAAAAAAUHB7uJCwuu/w4Oof8SEpL/DQ1lvwAAAHcAAABaAAAANAAA + ABgAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEaGtKoHBzI/xwcxP8VFcD/BQW6/wUFtP8FBbD/Bgas/wYGqf8GBqj/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/Bwej/wkJoP8LC5v/DQ2T/xAQ + iv8TE37/FhZw/xkZZ/8bG2X/BAQdpgAAAIcAAABrAAAASQAAACkAAAAS/////wAAAAEAAAAAAAAABQAA + ABUJCae9DAyi/w0NmP8QEJD/Dw951gAAAGIAAAA+AAAAHwAAAAsAAAABAAAAAAAAAAAAAAAAAAAABQcH + u4kLC67/Dg6h/xISkf8ODmPBAAAAfAAAAGEAAAA6AAAAHAAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQU3iYcHMr/GxvF/xwc + xP8MDL3/BQW3/wUFsv8GBq7/Bgaq/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGpv8HB6X/CAij/wkJn/8LC5r/Dg6R/xERhf8UFHn/Fxdt/xoaZv8YGFLnAAAAkgAA + AHsAAABaAAAAOAAAABsAAAAKAAAAAQAAAAEAAAAKAwOAOAsLqf8MDJ//Dg6V/xERj/8ICFagAAAAVQAA + ADIAAAAXAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAEBwe8iQsLrv8ODqH/EhKR/xERa9EAAACCAAAAaAAA + AEIAAAAiAAAADAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAARoa0qgbG8n/GxvE/xkZwf8GBrn/BQW2/wUFsf8GBqz/Bgaq/wYG + qP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpv8HB6X/CAii/woK + nv8MDJf/Dw+O/xMTgf8VFXT/GBhp/xoaZv8KCiyzAAAAhwAAAGsAAABIAAAAJwAAABAAAAAEAAAAAwAA + AA8ICKaECwum/w0Nm/8PD5P/ERGK9wAAAGsAAABIAAAAJwAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAQHB7yJCwuw/w4Oov8SEpL/ExN46QAAAIcAAABxAAAATAAAACoAAAARAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBTeJhwc + y/8bG8f/HBzE/xMTwP8FBbj/BQWz/wUFsP8GBqz/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6T/CAih/woKnP8NDZT/EBCK/xMTfP8XF2//GRln/xcX + VOcAAACRAAAAeAAAAFcAAAAzAAAAGAAAAAgAAAAHAAAAFQoKq+UMDKL/DQ2Z/xAQkv8PD3bNAAAAXgAA + ADsAAAAdAAAACgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAwcHv4gKCrL/DQ2l/xERlP8UFIb/AAAAjAAA + AHoAAABXAAAAMwAAABcAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHh7Vix8fyv8dHcX/HBzD/w4Ovf8FBbf/BQWy/wUF + r/8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcH + pv8HB6P/CQmf/wsLmf8ODpD/EhKD/xQUdv8XF2v/Ghpn/woKLrEAAACDAAAAZQAAAEAAAAAhAAAADQAA + AAsFBZZFCwuq/wwMoP8ODpb/EBCQ/wQEQ4wAAABRAAAALgAAABUAAAAGAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACBwfEhgoKtf8MDKj/EBCX/xMTiP8JCUayAAAAggAAAGQAAAA/AAAAIQAAAAwAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADJCTP1iQkyv8hIcf/Hx/D/w4OvP8FBbb/BQWx/wYGrv8GBqv/Bgap/wYGqP8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgam/wcHpf8ICKH/Cgqd/w0Nlf8QEIv/ExN9/xcX + b/8ZGWn/FhZR4QAAAIwAAABwAAAATAAAACkAAAATAAAAEAkJqZ4LC6f/DQ2d/w8Plf8REYjuAAAAZwAA + AEQAAAAkAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEHB8qECQm4/wsLrf8PD5v/ExOM/xAQ + Yc0AAACIAAAAcAAAAE0AAAAsAAAAFAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEnJ+I6LCzO/ygoyv8oKMX/JibE/xAQ + vP8FBbb/BQWy/wYGrv8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bwem/wcHpP8JCaD/Cwua/w4OkP8SEoP/FRV2/xgYbf8ZGWv/AQETmAAAAHgAAABVAAAAMAAA + ABkAAAAVCgqq5AsLpP8NDZv/Dw+T/wsLZ7EAAABbAAAANwAAABsAAAAIAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQUF00QICLv/Cgqx/w0Nov8SEpL/ExOB9wAAAIsAAAB7AAAAXAAAADoAAAAdAAAACgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAExMd5wMDDO/y4uyv8tLcj/KyvF/xMTvf8FBbb/BQWy/wYGrv8GBqv/Bgap/wYG + qP8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bwel/wgIof8KCpz/DQ2U/xAQ + iv8UFHv/FhZw/xgYbP8ODj69AAAAfwAAAF0AAAA2AAAAHgMDfzcLC6n/DAyi/w4Omf8REZL/AgIzgQAA + AFAAAAAtAAAAFAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPbIwcHv/8JCbb/DAyp/xAQ + mf8TE4v/CQlLrAAAAIIAAABrAAAASgAAACoAAAASAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzM9evNDTP/zMz + zP8yMsr/MDDI/xcXv/8FBbb/BQWy/wYGrv8GBqv/Bgaq/wYGqP8GBqj/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8HB6b/Bwej/wkJn/8MDJj/Dw+P/xMTgf8VFXX/Fxdu/xMTU9kAAACDAAAAYwAA + ADoAAAAiBweeZAsLpv8MDKD/Dw+Y/w8PfNUAAABrAAAASQAAACcAAAAQAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABBgbLoggIuv8KCq//Dg6g/xISkv8TE3neAAAAggAAAHYAAABaAAAAOQAA + AB0AAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI5OdbMOjrQ/zg4zv83N8v/NTXJ/yIiwf8FBbb/BQWy/wUF + r/8GBqz/Bgaq/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/CAih/wsL + m/8ODpL/EhKF/xQUef8XF3H/Hh5t8wAAAIUAAABmAAAAPQAAACQKCqGQDAyk/w0Nnf8QEJX/CgpdqgAA + AGkAAABGAAAAJQAAAA4AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAs8TBwfB4AkJ + tv8MDKn/EBCb/xMTj/8GBkicAAAAewAAAGgAAABKAAAAKgAAABMAAAAGAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMz + 2Bg+PtXbPz/R/z4+z/89Pc3/OzvL/y8vxP8ODrj/BQWz/wUFsP8GBq3/Bgar/wYGqf8GBqj/Bgao/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8ICKL/Cgqc/w0Nlf8REYj/FBR8/xcXdP8qKn//AAAAiAAA + AGkAAABAAAAAJwsLn6wMDKD/Dg6Z/xAQjfYBARuCAAAAbAAAAEoAAAAoAAAAEAAAAAMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEBNszCAi8/wsLsf8ODqP/ERGW/xISf9sAAAB6AAAAcwAA + AFoAAAA7AAAAHwAAAAwAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMz2BhCQtbbRETS/0NDz/9BQc3/Pz/K/zs7 + yP8gIL//BQW0/wUFsv8FBa//Bgas/wYGqv8GBqn/Bgao/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgam/wcH + o/8KCp7/DAyX/xAQi/8VFYD/JiZ//ywsgP8AAACLAAAAbgAAAEgAAAAuDAycyQ0NnP8PD5X/ERGK9gAA + AH0AAABxAAAAUQAAAC4AAAAUAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEGBtRjCQm4/wwMrP8PD6D/ExOT/wcHTZUAAAB3AAAAaQAAAE0AAAAuAAAAFgAAAAcAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADAAAABQAAAAcAAAAGAAAABAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAATMz2BhDQ9m0SkrT/0hI0f9HR87/RETN/0NDzP87O8j/Gxu9/wUFs/8FBbH/Bgau/wYG + rP8GBqv/Bgaq/wYGqf8GBqj/Bgao/wYGqP8GBqj/Bwel/wkJn/8MDJj/ExOP/ywsjv8xMYb/MDCD/wAA + AI4AAAB1AAAAUwAAADsNDZLMDg6W/xAQkP8TE4j/BQU3mQAAAHgAAABbAAAANgAAABkAAAAIAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMeiCgq0/w0NqP8REZr/EhKE2AAA + AHUAAABzAAAAXwAAAEAAAAAjAAAADwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAoAAAAQAAAAFAAA + ABQAAAAQAAAACgAAAAUAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJFRdqnUFDU/05O + 0v9LS9D/S0vP/0lJzf9HR8v/PT3H/yAgvf8NDbT/BQWx/wUFr/8GBq3/Bgas/wYGq/8GBqr/Bgaq/wYG + qv8HB6f/ERGm/yUlp/81NaL/NjaW/zY2jP82Noj/AAAAkQAAAH0AAABiAAAATwwMfrAPD5D/ERGK/xMT + gv8ODlK8AAAAgAAAAGYAAABAAAAAIQAAAAwAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMJCb3RCwuv/w8Pof8TE5X/CgpgpQAAAHgAAABuAAAAVAAAADQAAAAZAAAACQAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAAIAAAAEgAAAB8AAAApAAAAKwAAACYAAAAcAAAAEgAAAAkAAAAFAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFEROFmUlLV9VNT1P9RUdL/UFDQ/05Ozv9MTM3/S0vM/0pK + yv87O8T/Kiq9/xwcuf8UFLX/ExOz/xQUsv8bG7T/JCS2/zU1uf85Obj/Ojqz/zs7qv88PKD/PT2T/zY2 + i/8JCTCuAAAAhQAAAHQAAABoDAxosg8Pi/8SEoX/FBR9/xMTYdwAAACHAAAAcQAAAEwAAAAqAAAAEgAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUF2DMLC7LwDg6l/xER + mP8TE4j1AQEZgQAAAHkAAABmAAAARgAAACcAAAARAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAwAAAAbAAAALgAA + AD4AAABFAAAAQQAAADUAAAAnAAAAGgAAABAAAAAIAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAFCQuMtVlbax1hY1v9WVtT/VVXS/1NT0P9RUc//UFDO/05Ozf9MTMv/TEzK/0pKyf9ISMf/RkbH/0RE + xP9CQsT/QUHC/0FBv/9AQLr/QUGy/0FBqf8+Ppz/GhqC/xISZeQAAACMAAAAgwAAAH4ICDufEBCF/xIS + gv8VFXj/Fxdy/wAAAI8AAAB7AAAAWgAAADgAAAAdAAAACgAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAwoKu4UNDab/EBCY/xMTjP8REWfEAAAAgQAAAHUAAABZAAAANgAA + ABoAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAADQQElkcAAAA0AAAASQAAAFUAAABXAAAATgAAAEEAAAAzAAAAJQAA + ABkAAAAQAAAACAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSkriaFlZ1+pcXNb/WlrU/1dX + 0v9WVtH/VVXQ/1RUz/9SUs7/UFDN/05OzP9MTMv/TEzK/0pKyf9ISMf/R0fD/0ZGv/9GRrr/Rkay/yAg + mP8REYX/Dw9d1gsLQboPD4L/Dg59+AgIMK4PD4T/EhJ//xUVdf8XF2//DAw2twAAAIYAAABrAAAASwAA + AC4AAAAYAAAACwAAAAUAAAADAAAAAgAAAAQAAAAGAAAACAAAAAoAAAALAAAADQAAAA4AAAAPAQFsIw0N + o/EQEJj/ExOL/xUVgf8FBTWdAAAAgQAAAGgAAABEAAAAJAAAAA4AAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAILC8KjDg60/w8P + q+UFBXRyAAAAUwAAAFwAAABcAAAAVgAAAEwAAAA/AAAAMQAAACQAAAAZAAAAEAAAAAoAAAAFAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAA01N3ntcXNjrYGDW/15e1f9cXNT/WlrR/1hY0f9WVs//VlbP/1RU + zv9SUsz/UFDL/09Pyv9NTcj/TU3E/0xMwP8jI6z/DAyb/w4OkP8EBCGaDg6I/w4OiP8ODof/DQ2B+Q8P + fvkSEoD/FBR2/xcXbv8UFEvaAAAAkQAAAH0AAABiAAAARgAAAC4AAAAcAAAAEgAAAA0AAAANAAAAEQAA + ABUAAAAaAAAAHgAAACEAAAAjAAAAJAAAACYAAAApDAyVsw8Plf8TE4r/FRWB/xQUa+IAAACIAAAAcQAA + AE0AAAAqAAAAEgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQsLw8EMDLj/DQ2y/w8Pq/8ODpzEAgJFZAAAAFgAAABbAAAAWgAA + AFQAAABKAAAAPgAAADIAAAAmAAAAGwAAABMAAAAMAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA + AANMTN9pVlbYu2Bg1fZiYtT/YGDT/15e0f9cXM//W1vO/1lZzP9XV8z/VlbL/1RUyv9OTsX/FBSx/wkJ + qf8KCqP/CwuD1A0Nmf8MDJX/DQ2U/wwMkv8NDZD/Dg6M/xERhv8TE3n/FhZu/xkZY/kCAhCgAAAAjQAA + AHoAAABkAAAATAAAADcAAAAoAAAAIQAAACMAAAAoAAAAMAAAADcAAAA8AAAAQAAAAEQAAABGAAAARwAA + AEoJCXCSDw+S/xISi/8UFIL/FhZ+/wcHQKYAAABzAAAATwAAACwAAAATAAAABAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQXhMgsL + v+AMDLj/DQ2y/w4OrP8QEKb/Dg6XuAICRWQAAABXAAAAWgAAAFkAAABTAAAASwAAAEAAAAA1AAAAKgAA + AB8AAAAWAAAADwAAAAkAAAAFAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABUhI1VpQUNKfVlbPvVlZ + zNdYWMjYV1fI2FVVx9hRUcXMR0e/pBMTsdcGBq3/Bweq/wYGeo0KCqD2Cwuj/wsLoP8LC5z/Cgqa/wwM + mP8NDYX0EBCL/xMTgP8UFHP/GBhp/xMTOs8AAACaAAAAjwAAAH4AAABrAAAAVwAAAEcAAABAAAAAQgAA + AEoAAABVAAAAXgAAAGQAAABoAAAAawAAAG0AAABvAAAAcAYGSZcODpD/ERGM/xMThv8VFYL/ExNw2AAA + AGkAAABHAAAAJgAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgYG1kQLC77CDAy0/w0Nr/8PD6r/EBCl/wwM + kaACAkVjAAAAVQAAAFkAAABZAAAAVQAAAE8AAABFAAAAOgAAADAAAAAkAAAAGwAAABQAAAANAAAACAAA + AAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMAAAAHAAAADAAAABIAAAAXAAAAHQAAACIAAAAkAAAAJQAAACQAAAAhAAAAHgQE + lFkGBqS9Bwen8wgIq/8ICKr/CQmo/wkJpf8KCqL/Cgqf/wsLg+4ODoP0ERGH/xMTev8VFW3/GBhn/xkZ + XPMPDzXBAAAAkgAAAIUAAAB2AAAAaQAAAGQAAABoAAAAbwAAAHgAAAB/BQU0mwcHPaUHBz2mBgY9qAYG + PqgGBj+oCQlavQ4Okv8QEJD/EhKM/xMTiP8SEn7bAAAAVwAAADgAAAAdAAAADAAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIGBtVECwu9wgwMs/8ODq//Dw+q/xAQpf8ODpi3AgJGYgAAAFUAAABaAAAAXAAA + AFoAAABVAAAATAAAAEIAAAA3AAAALAAAACEAAAAZAAAAEgAAAAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAYAAAAKAAAAEAAAABcAAAAfAAAAJwAA + AC8AAAA1AAAAOgAAADwAAAA9AAAAOwAAADcAAAAxAAAAMB0dsP8GBqn/CAis/wcHrf8ICKz/Bwep/wgI + pv8REaX/GRmk/wwMl/8PD4//EhKC/xQUd/8WFm3/GBho/xkZZ/8VFUnbAAAAmAAAAI8AAACHDQ1IsRMT + XtEUFHHwFRV8/xUVfP8UFH3/ExOC/xERiP8QEI3/DQ2S/wwMk/8MDJX/DQ2U/w4Olf8REZH/EhKR/xAQ + hcAAAAA+AAAAJgAAABIAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACBgbVRAsL + vcIMDLT/DQ2v/w4Oqv8QEKb/Dw+dzwgIdoMAAABWAAAAXQAAAGEAAABgAAAAXAAAAFUAAABLAAAAPwAA + ADQAAAApAAAAHwAAABcAAAAQAAAACgAAAAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAACAAAABQAA + AAgAAAAOAAAAFAAAAB0AAAAmAAAAMQAAAD0AAABIAAAAUwAAAFsAAABiAAAAZAAAAGUAAABjAAAAXgAA + AFcAAABRS0u7/xgYrf8HB6z/Bwev/wcHrv8GBqv/JCSy/zU1tP8JCaL/Cgqd/w0Nlf8PD4z/EhKB/xMT + ef8VFXH/FhZt/xcXa/8SEj3QEBA6yBUVbfkUFHb/ExN6/xMTfv8TE4D/ExOD/xIShf8REYr/Dw+Q/w4O + lv8MDJn/Cwub/wsLmv8MDJr/DQ2a/w8Pmf8REZj0AQE2RQAAACUAAAAVAAAACQAAAAMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgYG1UQKCsGkDAy0/w0NsP8ODqv/EBCm/w8P + n+cLC4mmAgI+bQAAAGIAAABmAAAAZwAAAGQAAABdAAAAVAAAAEkAAAA9AAAAMQAAACcAAAAeAAAAFgAA + ABAAAAAKAAAABwAAAAUAAAAGAAAACAAAAA0AAAATAAAAGgAAACMAAAAuAAAAOgAAAEcAAABUAAAAYAAA + AGsAAABzAAAAeAAAAHoAAAB8AAAAfAAAAHwAAAB6AAAAdgAAAHNJSabdWlrA/0xMwf8xMbz/MDC8/0ZG + wP87O7v/DAyp/wgIpP8JCaH/Cgqb/w0Nlf8PD47/ERGF/xMTfv8TE3f/FBR0/xMTdP8TE3f/ExN5/xIS + ff8REYP/EBCH/w8Piv8PD4//Dg6S/w0Nlv8NDZr/DAyf/woKoP8KCqH/Cgqg/wsLof8NDaL/Dg6h5gUF + fFQAAAAeAAAAEgAAAAkAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIEBNQkCgrDowwMtf8NDbD/Dg6s/w8Ppv8QEKH/Dw+U0wkJcpkBAR9uAAAAawAA + AG0AAABrAAAAZgAAAF4AAABTAAAASAAAADwAAAAwAAAAJgAAAB0AAAAXAAAAFAAAABUAAAAbAAAAIgAA + ACwAAAA3AAAAQwAAAFAAAABeAAAAaQgIVp8MDHHFEBCD5xERkP8REZD/ERGQ/xERkP8PD4nvDAx2zwcH + WbECAiuSAAAAgwwMIo5UVK7pY2PH/2Bgyv9TU8X/ICC1/wcHq/8HB6j/Bwem/wgIo/8JCaD/Cgqc/wwM + l/8ODpL/Dw+L/xAQhv8REYT/ERGC/xERg/8REYX/Dw+I/w8Pi/8ODo7/DAyS/wwMlv8LC5n/Cwue/woK + of8KCqT/CQmm/woKp/8KCqj/Cwun5QkJo5QAAAAdAAAAFAAAAAwAAAAGAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBATUJAoK + w6MMDLX/DAyx/w4Oq/8PD6b/EBCh/xISmfQPD4XCCAhglwAAAG8AAABzAAAAcwAAAG8AAABoAAAAXgAA + AFMAAABGAAAAOwAAADIAAAAuAAAAMAAAADcAAABBAAAATQAAAFoAAABmBARBiw0NccQREYbvERGP/xAQ + kP8QEJL/EBCT/w8PlP8PD5X/Dw+V/w8Pl/8ODpj/DQ2Z/wsLmv8JCZLvBwd1yQICOZ0MDCGTExNTrQYG + r/8GBq3/Bgar/wYGqf8HB6j/Bwem/wgIo/8ICKH/Cgqd/wsLmv8MDJf/DQ2T/w4Okf8ODpD/Dg6P/w4O + jv8ODo3/DAyO/wwMkP8LC5P/CwuY/wsLnP8KCqH/CQml/woKqP8KCqnyCQmorgcHoWUAAAAXAAAAEQAA + AAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQE1CQJCcSjCwu2/wwMsf8NDav/Dg6m/xAQ + of8REZz/EhKS9Q4Oeb0EBEKMAAAAdwAAAHkAAAB3AAAAcQAAAGkAAABfAAAAVwAAAFIAAABVAAAAXAAA + AGYBARx3CwtlshAQgucREY7/EBCQ/w8Pkv8PD5T/Dg6W/w4Omf8NDZz/DQ2e/w0NoP8NDaH/DAyj/wwM + o/8LC6P/Cgqj/wkJpP8ICKX/Bwep/wcHo+8GBqXwBgax/wYGr/8GBqz/Bgaq/wYGqf8HB6f/Bwel/wcH + o/8ICKL/CQmg/woKnv8KCpz/Cwub/wsLmv8LC5b/DAyT/wsLjf8LC4z/CwuL/wsLjv8LC5P/CwuV6AoK + mMAJCZqFBQWOSAAAABcAAAATAAAADwAAAAsAAAAIAAAABQAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEEBNojCQnFkwoKt/ALC7L/DQ2t/w4Op/8PD6D/ERGb/xISlv8SEorsDw9xwgQE + PZMAAAB+AAAAfQAAAHoAAAB2AAAAdQEBGn0KCl2qDw951hERj/8QEJD/Dw+S/w4OlP8ODpf/DQ2Z/w0N + nf8MDKH/Cwuk/wsLqP8LC6fYCgqt/woKrv8JCa//Cgqv/wkJrv8ICK7/Bwev/wcHsP8GBrH/Bgaz/wUF + s/8GBrT/Bgaw/wYGrv8GBqv/Bgap/wYGqP8GBqb/Bwem/wcHpf8HB6T/CAii/wgIof8JCaD/Cgqe/woK + mv8LC5L/CwuJ/woKXNsKClDKBwc7oQEBHXEAAABMAAAANAAAACQAAAAbAAAAFwAAABYAAAAVAAAAFAAA + ABIAAAAPAAAACwAAAAcAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLEFAgI + yYQKCrjwCwuz/wwMrv8NDaj/Dw+i/xAQm/8SEpb/EhKR/xIShOUMDGG2AgIsjwgIT6kPD3fYERGO/xER + kP8QEJL/Dw+V/w4Ol/8NDZr/DAyd/wwMoP8LC6T/Cwuo/wsLqNgICKWFAwOBOQAAABUAAAAQBQW/SggI + wJYHB7zSCAi6/wcHuf8GBrn/Bga4/wYGt/8FBbf/BQW3/wUFtv8GBrT/BQWx/wYGrf8GBqr/Bgap/wYG + qP8GBqf/Bgam/wcHpv8HB6X/Bwek/wgIov8ICKH/Cgqa/wsLkf8MDIX/DAxV3AAAAJoAAACLAAAAdQAA + AFwAAABGAAAANQAAAC4AAAAsAAAALAAAAC0AAAAtAAAAKgAAACUAAAAfAAAAFwAAAA8AAAAIAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQICzhMICM10CQm74QoKtP8MDK//DAyp/w4O + pP8PD57/EBCa/xAQl/8QEJb/EBCV/xAQlf8PD5b/Dg6X/w0Nm/8MDJ7/DAyh/wsLpP8LC6j/Cgqp5QkJ + qaEEBJJJAAAAFwAAABAAAAAKAAAABgAAAAMAAAACAAAAAgAAAAMBAbEWBQXNZgUFxLQFBb//BQW9/w8P + vP8EBLn/BQW4/wUFt/8FBbP/BQWw/wYGrP8GBqr/Bgao/wYGp/8GBqf/Bgan/wYGp/8HB6b/Bwek/wgI + of8KCpv/DAyP/w0Ng/8PD3r/Dw9S2wAAAJcAAACJAAAAdgAAAGQAAABXAAAAUAAAAE8AAABQAAAAUQAA + AFAAAABNAAAARgAAAD0AAAAxAAAAJAAAABgAAAAOAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAABAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAHAAAABQAAAAQAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADBwfQZAkJvOEKCrb/Cgqx/wsLrf8MDKn/DQ2m/w0NpP8NDaL/DAyh/wwM + of8MDKL/Cwul/wsLqP8KCqnyCQmprwYGpGYAAAAYAAAAEQAAAAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAAgICuhUEBMx2FhbC8RISv/8EBLv/BQW5/wUFt/8FBbH/Bgau/wYG + qv8GBqn/Bgao/wYGp/8GBqf/Bgan/wcHpv8HB6T/CAih/woKmv8MDJD/Dg6D/xERef8SEnP/ERFP2wAA + AJgAAACOAAAAgwAAAHoAAAB0AAAAcgAAAHEAAABwAAAAbgAAAGsAAABmAAAAXgAAAFIAAABCAAAAMQAA + ACIAAAAUAAAACwAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIAAAADAAAABQAAAAcAAAAIAAAACwAAAA4AAAAQAAAAEwAAABUAAAAXAAAAFwAA + ABYAAAAUAAAADgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwYG + 0lQICMDCCQm4/wkJtf8KCrP/Cgqx/woKr/8KCq3/Cgqt/woKrfIJCauvBgalZQAAABgAAAASAAAADAAA + AAcAAAAEAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAIgINOMHh7F/xAQv/8EBLr/BQW4/wUFtP8FBa//Bgas/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bwem/wcH + pP8ICKH/Cgqc/wwMk/8PD4f/ERF9/xISdf8UFHD/ExNL3AcHIa4KCi2wDw9GwRAQUcYQEFbEDw9awQ8P + X74KClCjAQEafgAAAHUAAABzAAAAbAAAAGEAAABRAAAAPgAAACwAAAAbAAAAEAAAAAgAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAEAAAABQAAAAgAAAAKAAAADQAAABEAAAAUAAAAGAAA + ABwAAAAgAAAAJAAAACgAAAAsAAAALwAAADEAAAAyAAAALgAAACYAAAAcAAAAEAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIFBdY0CAjDpAgIvPAJCbr/CQm44ggI + tpsGBq9hAAAAFQAAABAAAAALAAAABwAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEh0xYqKsvyJCTF/xkZvv8MDLj/BQW0/wUF + sf8GBq3/Bgaq/wYGqf8GBqj/Bgao/wYGqP8GBqb/Bwel/wgIov8JCZ3/CwuX/w4Ojv8QEIP/EhJ7/xMT + df8UFHP/FRVz/xUVcv8VFXX/FRV2/xUVeP8UFHz/FBSA/xQUg/8VFYb/ERFzyQMDMIUAAAB2AAAAdQAA + AGwAAABcAAAASgAAADYAAAAkAAAAFgAAAAwAAAAHAAAABAAAAAQAAAAFAAAABwAAAAgAAAALAAAADgAA + ABIAAAAVAAAAGgAAAB8AAAAjAAAAKQAAAC4AAAA0AAAAOQAAAD8AAABEAAAASQAAAE0AAABQAAAAUQAA + AE8AAABIAAAAOwAAACoAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAUAAAAHAAAACAAAAAcAAAAFAAAAAwAAAAEAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAS0t218vL8n/KSnB/yMjvf8cHLr/ERG0/wUFr/8GBqz/Bgaq/wYGqf8GBqn/Bgap/wYG + qP8HB6b/Bwej/wkJoP8KCpv/DAyV/w4Ojf8QEIb/EhKB/xMTfv8UFHz/FBR6/xQUe/8TE3r/ExN7/xMT + fv8TE4T/ExOJ/xMTjf8TE47/ExON/w8Pc78BARp+AAAAeAAAAHMAAABmAAAAVQAAAEAAAAAuAAAAIAAA + ABcAAAATAAAAEgAAABQAAAAXAAAAGwAAACAAAAAlAAAAKgAAADAAAAA2AAAAPQAAAEQAAABLAAAAUgAA + AFkAAABeAAAAYwAAAGYAAABoAAAAaAAAAGcAAABkAAAAXwAAAFMAAABDAAAAMAAAABsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABS4uyHk0NMP/Li6+/yoq + vP8kJLv/GRm2/wkJrv8GBqz/Bgas/wYGq/8GBqv/Bgaq/wcHqP8HB6X/CAii/wkJn/8KCpv/DAyX/w4O + kv8PD43/EBCJ/xERiP8SEoX/EhKB/xISfv8SEn3/EhKB/xAQiP8QEJD/EBCV/xAQl/8SEpb/ExOT/xMT + h+wHB02VAAAAeQAAAHcAAABuAAAAXwAAAE0AAAA9AAAAMQAAACwAAAAsAAAALgAAADMAAAA5AAAAPwAA + AEYAAABNAAAAVQAAAFwAAABiAAAAaAAAAGwAAABwAAAAcwQEQY4GBk6XDAxvuQwMcbgPD3zIERGH2RER + i9gREZDWCgqHmgAAADsAAAAoAAAAFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAHAAAAFxgYr6szM77/NTW+/y4uvP8pKbr/ISG1/woKrv8FBa7/BQWu/wYG + rf8GBqz/Bgar/wcHqP8HB6X/CAii/wkJoP8KCp3/Cwua/wwMl/8NDZT/Dg6R/xAQjP8REYb/Dw9e4ggI + L7AGBjKYAAAAYggIZ3EPD5nkDg6d/w8Pnf8REZn/EhKU/xMTjf8QEHC+AQEafgAAAHkAAAB1AAAAagAA + AF4AAABUAAAATwAAAE8AAABTAAAAWQAAAF4AAABkAAAAaQAAAG4AAABxAgIvhggIVqENDWy7EBB61RIS + h+4SEpD/EhKS/xISk/8REZX/ERGW/xISmP8SEpr/EhKd/xISof8REaPyAAAAKAAAABsAAAAOAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAA + AAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAsCAnw6BQWw8woK + r/8mJrf/Ojq7/zU1uf8uLrb/Jia1/xAQsP8FBa//BQWx/wUFr/8GBq3/Bgar/wcHqP8HB6b/Bwej/wgI + of8JCaD/Cgqd/wsLmv8MDJb/Dg6P/xAQh/8PD4H/BgYlrQAAAIUAAABoAAAARQAAACkLC6KNDQ2i/w4O + n/8QEJn/EhKT/xMTjP8TE4X1CQlUngAAAHgAAAB4AAAAdQAAAHAAAABuAAAAbQAAAG8AAABzBARBjgkJ + XqoODnHEEBCA3hERi/cREZD/ERGS/xERk/8QEJT/EBCW/w8Pmf8PD5r/Dw+c/w8Pn/8PD6D/Dw+i/xAQ + pP8QEKTlDQ2poAUFlkgAAAAVAAAADQAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAACAAAABAAAAAcAAAAIAAAACgAAAAsAAAAMAAAADQAAAA4AAAAPAAAADwAA + AA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAA + AA8AAAAPAAAADgAAAA0AAAAMAAAACgAAAAkAAAAIAAAABgAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAAEAUFsa4GBrD/Bgar/wUFqP8VFar/ODi0/zo6tf8zM7X/LS24/xIS + tP8FBbP/BQWz/wUFsP8GBq3/Bgaq/wYGqP8HB6f/Bwel/wcHo/8ICKH/Cgqd/wsLmf8NDZD/EBCH/xAQ + fv8QEGPnAAAAjQAAAHMAAABSAAAANQAAACUGBoZLDAye1w4OnP8QEJb/ERGR/xISjf8TE4r/EhJ82gMD + L4QHB0qYCAhVog0NbLsPD3fMEBCE5hISkP8REZH/ERGT/xERlP8QEJb/EBCX/w8Pmf8ODpv/Dg6d/w0N + oP8NDaL/DQ2k/wwMpv8NDaj/DAyq/wwMqsoLC6qQBQWaRQAAABQAAAAPAAAACgAAAAcAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAgAAAAOAAAAFQAA + ABoAAAAeAAAAIAAAACIAAAAkAAAAJQAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAA + ACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAkAAAAIwAAACEAAAAgAAAAHQAA + ABoAAAAVAAAAEAAAAAoAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBAWsiBwe1/wcH + rv8GBqn/Bgaj/wYGnv8KCo/oNTWa0T4+uf84OLv/MTG9/xoauf8FBbX/BQWz/wUFr/8GBqz/Bgaq/wYG + qP8GBqb/Bwel/wcHo/8JCaD/Cwub/w0Nkv8QEIj/ERF9/xMTef8GBiinAAAAfgAAAGIAAABKAAAAPQAA + ADoAAAA+CgqFog8Pl/8QEJP/ERGQ/xERj/8SEpD/EhKR/xERk/8REZT/EBCV/xAQl/8PD5f/Dw+Z/w4O + m/8ODpz/Dg6e/w0Nof8MDKP/DAyl/wwMp/8MDKn/Cwur/wsLrPIKCqy7CQmujwUFp1MAAAAUAAAAEAAA + AAwAAAAIAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAHAAAADwAAABsAAAApAAAAMwAAADsAAAA/AAAAQgAAAEQAAABGAAAASAAA + AEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAA + AEgAAABIAAAARwAAAEYAAABEAAAAQQAAAD8AAAA8AAAANwAAADAAAAAlAAAAGQAAAA8AAAAHAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAABQUFuG0HB7T/Bwet/wcHp/8ICJ//CAia/wMDSJ8AAABfPDyvw0RE + wf89PcL/NzfC/x8fvP8ICLX/BQWy/wYGrv8GBqv/Bgap/wYGqP8GBqb/Bwek/wgIof8KCpz/DQ2S/xAQ + h/8REX3/ExN2/w8PR8sAAACHAAAAcwAAAGIAAABcAAAAXQAAAGIAAABmAwM2dw0NhNYPD5H/Dw+S/w8P + lf8PD5j/Dw+d/w4On/8NDaH/DQ2i/wwMo/8MDKX/DAym/wsLqP8LC6r/Cwut/woKrv8KCq7JCQmvnQcH + sHADA5UyAAAAEgAAAA4AAAAKAAAABwAAAAUAAAADAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAkAAAAWAAAAKQAA + AD0AAABOAAAAWgAAAGIAAABnAAAAagAAAG0AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbwAA + AG8AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbQAAAGsAAABqAAAAaAAA + AGQAAABeAAAAUwAAAEQAAAAzAAAAIgAAABQAAAAKAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAHBga4iwgI + s/8ICKz/CAil/wkJnP8JCYzxAAAAeAAAAFUAAAAyRETBu0hIyP9CQsf/PT3F/y0twf8QELb/BQWw/wYG + rP8GBqr/Bgap/wYGqP8HB6b/CAii/woKnf8NDZT/EBCK/xISff8TE3X/ExNX4AAAAJEAAACEAAAAewUF + NZMHB0CdAAAAggAAAIQAAACAAAAAdggIVpgNDYzqDQ2W/w0NnP8NDaH/DAym/wsLqf8LC6z/Cgqu/woK + r+QKCq/ICAixjgcHrmEDA5UyAAAAEQAAAA4AAAAKAAAACAAAAAYAAAAEAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAACAAAACgAAABgAAAAuAAAARAAAAFgAAABnBgZRlAYGTJkGBkmcBgZHnwcH + RKEHB0SiBwdDogcHQ6IHB0OiBwdCowcHQqMHB0KjBwdCowcHQ6IHB0OiBwdDogcHRKIHB0SiBwdEogcH + RKEHB0ShBwdEoQUFOZgAAACAAAAAgAAAAH8AAAB/AAAAfgAAAHsAAABzAAAAZgAAAFMAAAA9AAAAKQAA + ABcAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAcICLnFCAiz/wkJq/8KCqL/CwuZ/woKeNsAAAB0AAAATwAA + ACwAAAAUSEjOt05OzP9ISMr/QUHI/zw8xf8nJ7z/EBCy/wYGrP8GBqv/Bgaq/wcHqP8ICKT/Cgqg/wwM + mP8PD43/FBSD/yAgf/8kJGXpAAAAmQ4OQMISEm/xEhJ9/xERgP8QEIH/Dg5l3wUFKqkAAACPAAAAgQAA + AG8HB1eDCwuGoQoKl5cKCqWQBgalUgYGrk8AAAAQAAAADgAAAAwAAAAJAAAABwAAAAUAAAADAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICM9kDAy60w0N + sv8ODqv/Dw+k/xAQnf8REZj/EhKU/xISkv8SEpH/ExOQ/xMTj/8TE47/ExON/xMTjf8TE43/ExON/xMT + jf8TE43/ExON/xMTjf8TE43/ExON/xMTjf8TE43/ExON/xMTjf8TE4v/ExOL/xMTiv8TE4j/FBSI/xUV + hv8TE3XgBwdEogAAAIIAAAB7AAAAbgAAAFsAAABEAAAALgAAABsAAAAOAAAABgAAAAIAAAAAAAAACAgI + tsYJCbD/Cgqp/wsLn/8NDZX/CgpjxAAAAHAAAABKAAAAJwAAABAAAAAJTEzNu1NTzv9NTcz/SEjJ/0FB + xf88PMH/Ly+8/x0dtf8TE7L/Dg6v/w4Oqv8QEKb/GBii/yAgnP8mJpP/JyeI/x4eU9gREU3bExN1/xMT + eP8SEnz/ERF+/xERfv8REXz/ERF7/w0NS84AAACVAAAAhQAAAG8AAABUAAAAOQAAACEAAAARAAAACAAA + AAMAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQoKxcALC7z/Cwu4/wwMs/8MDK3/DQ2o/w0No/8ODqD/Dg6e/w8P + nv8PD53/Dw+d/w8PnP8QEJv/EBCb/xAQm/8QEJv/EBCb/xAQm/8QEJv/EBCa/w8Pmv8PD5n/Dw+Z/w8P + mf8PD5n/EBCY/xAQmP8QEJb/EBCV/xAQlP8SEpL/ExOQ/xMTjP8UFIj/ERFuzgEBGIcAAAB8AAAAcQAA + AGAAAABKAAAAMwAAACEAAAASAAAACQAAAAQAAAAKCAixxgkJrP8LC6T/DQ2a/w8PkP8KClq8AAAAbAAA + AEQAAAAjAAAADQAAAAgDA6tRPDzJ/1hYzv9TU8v/TEzI/0dHxP9AQML/OzvA/zU1v/8wML3/Kiq4/yYm + s/8gIKz/IiKj/yQkm/8lJZH/GBh59BAQfP8QEH3/EBCA/xAQgv8QEIP/EBCA/xERfP8SEnf/EhJ2/xAQ + U9sAAACWAAAAhQAAAGwAAABNAAAAMAAAABgAAAAJAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLbEggI + z4MJCcDhCgq6/woKt/8KCrL/Cgqw/wsLrf8LC6v/Cwur/wwMq/8MDKv/DAyr/wwMq/8MDKr/DAyq/wwM + qv8MDKr/DAyq/wwMqv8MDKj/DAyn/wwMp/8MDKb/DAyn/wwMp/8MDKf/DAym/wwMpf8MDKT/DQ2j/w4O + oP8PD57/EBCa/xISlf8TE4//ExOB5AUFP5AAAAB4AAAAcgAAAGQAAABQAAAAOwAAACgAAAAaAAAAEQAA + ABQJCarICgqm/wwMnv8PD5T/EBCL/wcHQaMAAABnAAAAPwAAACAAAAAKAAAACAUFuIwFBbj/QEDH/15e + zP9YWMn/U1PF/0xMxP9GRsP/QEDE/zs7wv81Nb7/MDC6/yoqs/8mJqv/IiKk/x4em/8ODo7/Dg6L/w8P + iv8PD4v/Dw+M/w8PjP8QEIj/ERGA/xISef8TE3P/ExNx/xERUNsAAACVAAAAgQAAAGYAAABFAAAAKAAA + ABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMFBdZEBwfJhQgIvcQICLnwCAi3/wkJ + tv8JCbX/CQm1/wkJtf8JCbX/CQm0/wkJtP8JCbP/CQmz/wkJs/8JCbP/CQmz/wkJs/8JCbL/CQmy/woK + sv8KCrL/Cgqy/woKsv8KCrL/Cgqy/woKsf8KCrH/Cgqv/wwMrP8NDaj/Dg6j/xAQnP8SEpb/ExON9QYG + UJEAAAB0AAAAcgAAAGgAAABYAAAARgAAADUAAAApAAAAKQoKoNkLC6D/DQ2a/xAQjv8SEoj/BQU5mgAA + AGEAAAA6AAAAHAAAAAgAAAAJBga3uAUFtv8FBbD/Li65/2NjyP9dXcf/VlbF/1BQxf9LS8f/RUXF/z8/ + wv86Or3/NTW5/zAws/8oKK3/EBCg/wsLmv8LC5f/DAyX/wwMl/8MDJb/DQ2U/w4OkP8QEIj/EhJ//xMT + dv8UFG//FhZt/w8PPcgAAACRAAAAeQAAAFoAAAA5AAAAHQAAAAsAAAADAAAAAAAAAAAAAAABAAAAAgAA + AAUAAAAIAAAACwAAAA4AAAANAAAACgAAAAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAUAAAAHBATKRwQEx0gFBcBKBQW/SgUFvUsFBb5bCAjAiAYG + vWsFBbdNBQW3TQUFuUwFBblMBQW6TAUFvUsDA6osAAAADgAAAAwAAAAMAAAACgAAAAoAAAAKAAAACgUF + xUgFBcJJCQm+lwoKtuELC7D/DAyr/w4OpP8QEJz/EhKW/wwMb6gAAABwAAAAcwAAAG4AAABkAAAAVgAA + AEoAAABHCwud/wsLmf8NDZP/ERGK/xMThv8AAAB8AAAAWQAAADMAAAAXAAAABwAAAAkGBrfjBgaz/wcH + q/8GBp7uKChro1xcvvJjY8j/XFzJ/1dXyv9QUMn/SkrE/0VFv/8/P7v/Nze0+RoaleUICKb/CQmi/wkJ + of8JCaD/CQme/woKnf8LC5v/DAyW/w4OkP8QEIf/ExN8/xQUcv8WFmv/GBhq/wcHJq0AAACJAAAAbQAA + AEwAAAAsAAAAFAAAAAYAAAABAAAAAwAAAAYAAAAKAAAAEgAAABkAAAAfAAAAIwAAACEAAAAbAAAAEgAA + AAkAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAgAA + AAIAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABAcHzGUKCrjhDAyx/w4O + qv8QEKL/ERGa/xAQhswBARx2AAAAdQAAAHYAAABzAAAAbAAAAGsMDJX/DQ2T/w8Pj/8SEoj/ExOC+AAA + AHMAAABPAAAALAAAABMAAAAFAAAACQcHuP8HB7D/CAio/wcHkdwAAABxAAAAXEFBpZhXV8POXFzL/1xc + zP9WVsj/TEy97jQ0rucPD6HwBgap/wgIqP8HB6b/Bwek/wcHpP8ICKP/CAii/wkJoP8KCpz/DAyX/w4O + j/8REYX/ExN5/xcXbv8ZGWj/GBhZ7QAAAJQAAAB+AAAAXgAAADsAAAAfAAAADgAAAAgAAAAMAAAAFAAA + AB0AAAAnAAAAMgAAADsAAABAAAAAPgAAADMAAAAkAAAAFQAAAAkAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQICzhMICMeTCwu1/wwMrv8ODqb/Dw+f/xERlvQMDHW0AgIvhwAA + AH4AAACBAAAAgwwMkf8NDZD/Dw+N/xISif8REXjfAAAAZgAAAEIAAAAjAAAADgAAAAMAAAAICAi3/wgI + sP8JCab/Bwd9wgAAAHMAAABeAAAAOwAAAB8AAAARAAAAFQAAACoDA4KMBQWo/wYGqv8GBqr/Bweq/wcH + qP8HB6f/Bwem/wcHpv8HB6X/Bwek/wgIof8KCpz/DAyW/w8Pjf8TE4H/FRV0/xgYaf8aGmb/Dw82wQAA + AIoAAABuAAAATQAAAC8AAAAdAAAAGAAAAB4AAAAqAAAANwAAAEIAAABNAAAAVgAAAFsAAABZAAAATwAA + ADsAAAAmAAAAEwAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEGBtZECgq58AsLs/8MDKv/DQ2l/w4On/8ODpv/DAyS7gsLheAKCoLiDAyU/w0Nkf8PD47/ERGM/wwM + bbgAAABTAAAAMwAAABkAAAAIAAAAAQAAAAcICLj/CQmv/wsLpf8ICHe3AAAAdQAAAGUAAABEAAAAJQAA + ABQAAAAXBASZewUFq/8FBan/Bgar/wYGrP8GBqr/Bgap/wYGqP8GBqf/Bgan/wYGp/8HB6b/Bwek/wgI + of8KCpz/DQ2U/xAQiv8TE3z/FhZw/xkZZ/8ZGVzzAAAAkwAAAH0AAABgAAAARAAAADUAAAAxAAAAOQAA + AEUAAABQAgI/awkJcpkNDXqwBARKggAAAGgAAABhAAAAUAAAADkAAAAhAAAADgAAAAQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAs4TCQnCwQoKt/8KCrH/Cwus/wsL + p/8KCqT/Cgqi/woKnv8LC5r/DQ2V/w8Pkv8REZL/BARQeQAAAD4AAAAjAAAAEAAAAAUAAAAAAAAABQkJ + uv8KCrD/DAyl/wkJeLUAAAB2AAAAbgAAAFIAAAAxAAAAHwQEjEkGBq//Bgat/wUFq/8GBqz/BQWr/wYG + q/8GBqn/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/Bwej/wkJn/8LC5n/Dg6R/xIShP8UFHf/Fxds/xkZ + Z/8PDzbAAAAAigAAAHUAAABeAAAAUQAAAE4AAABSBgZggg8PjswSEpv/EhKZ/xMTlv8TE5D1BARKgQAA + AGgAAABgAAAATAAAADEAAAAZAAAACQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAACBwfNgwgIu/8JCbf/CQmz/wkJsP8JCa3/CQmq/wsLo/8MDJ7/Dg6b/w4O + kNQAAAA+AAAAKAAAABQAAAAIAAAAAgAAAAAAAAADCAi/0QoKsv8MDKb/Dg6Z9QEBGn0AAAB1AAAAYQAA + AEAAAAAqBgaorgYGr/8GBq7/BQWv/wYGrv8FBa3/Bgar/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + pv8HB6X/CAii/woKnf8MDJb/EBCL/xMTf/8VFXL/Fxdr/xUVUOEAAACUAAAAhgAAAHUAAABpCgponhAQ + kusQEJ3/Dw+g/w8PoP8QEKD/ERGd/xISmf8TE47fAAAAYgAAAGYAAABaAAAAQgAAACYAAAARAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQXXRAcH + weAHB7z/Bwe6/wgItv8JCbH/Cgqs/wwMqP8ODqPzBAR2WAAAACMAAAAVAAAACgAAAAMAAAABAAAAAAAA + AAEHB8qDCgq1/wwMqf8ODp7/CwtytwAAAHgAAABtAAAAUQAAADgREazzBwev/wYGsf8FBbL/Bgay/wUF + r/8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6T/CQmg/wsLm/8ODpL/ERGG/xMT + ev8VFXH/FhZu/wEBEaAAAACPCQlJpxAQfNwREZT/Dw+c/w4Oo/8NDaXzCgqgpggImWoPD6bxEBCh/xIS + nP8ODoWzAAAAYwAAAGMAAABRAAAANgAAABwAAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLPEwYG0IMHB7/wBwe9/wgIuf8KCrX/Cwux4wUF + lEgAAAAYAAAAEAAAAAgAAAADAAAAAQAAAAAAAAAAAAAAAAMD2iMJCbn/DAyt/w4Oov8QEJX1AQEafgAA + AHUAAABgAAAARiUlsv8fH7b/FRW5/woKt/8FBbX/BQWx/wYGrf8GBqr/Bgao/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wcHpf8ICKL/Cgqe/wwMl/8PD47/EhKD/xMTef8TE3T/EBBP0xMTc/ESEob/ERGR/w8P + mv8ODqP/CgqfpwEBSTQAAAAZAAAAEAYGtjsODqv/EBCk/xISnP8EBFB4AAAAZgAAAF0AAABGAAAAKQAA + ABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMFBddEBATLRwQEwTkAAAAMAAAACgAAAAgAAAAFAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAQgIxaILC7L/DQ2n/w8Pnf8LC3K3AAAAeAAAAG0AAABTKyuw6ioquf8oKL3/JibA/yAg + vv8VFbj/DQ2y/wYGrP8GBqn/Bgao/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bwem/wcHpP8JCaD/Cwub/w0N + k/8QEIr/ERGB/xISfP8SEn3/EhKD/xERjv8PD5j/DQ2ZwgMDaUUAAAAcAAAAEQAAAAkAAAAEAAAAAwoK + wJMNDaz/EBCj/xAQktIAAABiAAAAZAAAAFQAAAA4AAAAHQAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAA + AAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPaIwoKuP8MDK3/Dg6i/xAQ + lvUBARp+AAAAdQAAAGAvL6K4MzO7/zAwv/8uLsH/LCzC/ysrwP8pKbz/Jye5/xsbs/8VFa//DQ2r/wgI + qf8GBqf/Bgan/wYGp/8GBqf/Bwel/wgIov8KCp7/CwuY/w4Okf8PD4f/EhKE/xMThf8QEIv/Dw+N3wcH + d2sAAAAjAAAAFAAAAAoAAAAFAAAAAgAAAAAAAAAAAgLOEwwMtfAODqv/ERGg/wYGX4MAAABmAAAAXgAA + AEYAAAApAAAAEgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABCAjEogsLs/8MDKj/Dg6e/woKdLcAAAB3AAAAaxMTT2w8PLz/OTnA/zY2 + w/80NMP/MjLF/zExwv8vL77/Li68/y0tuf8rK7f/Kiq0/yMjsv8dHbD/GRmt/xQUrP8UFKr/FBSn/xQU + o/8WFp//HByZ/yIilP8lJZL/FBSD7wkJaJsAAAA+AAAAIwAAABAAAAAGAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAABCQnIgw0Nsf8PD6X/ERGW3gAAAGQAAABmAAAAVAAAADcAAAAcAAAACgAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBNkjCgq4/wsL + rf8NDaP/Dg6Y9QAAAHYAAABzAAAAXDQ0p6xBQcL/Pz/F/z09yP87O8j/OjrI/zk5xP83N8L/NTW//zQ0 + vP8yMrr/MDC3/y4utv8sLLX/Kiq0/yoqsv8pKbD/KCis/ycnpf8nJ57/JyeY/yYmlf8ICDeBAAAASwAA + ACsAAAAUAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAs4TCwu28A4Oq/8REZ//BgZdhAAA + AGgAAABfAAAARgAAACgAAAARAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMOiCgqx/wwMp/8ODp7/BwdkpwAAAHYAAABmAAAASD09 + u75ISMn/RUXL/0REy/9CQsv/QEDL/z8/yf89PcX/PDzB/zo6v/85Ob3/Nze7/zY2uv80NLn/MzO2/zIy + s/8xMa//MTGo/zAwof8vL57/KSmS6AAAAFgAAAA3AAAAHQAAAAsAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEJCciDDAyw/w8PpP8QEJDUAAAAZgAAAGYAAABTAAAANQAAABsAAAAJAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE + 0yQKCrT/Cwup/w0Nn/8NDZHtAAAAeAAAAG0AAABPAAAALkZGyblPT8//TEzQ/0pKz/9JSc7/R0fM/0VF + yv9ERMj/QkLF/0BAwv8/P8H/Pj6//z09vP87O7n/Ojq2/zo6sf85Oav/OTmm/zg4pf8hIXugAAAAQAAA + ACUAAAASAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE1CQLC7X/Dg6p/xER + nv8GBlyHAAAAaQAAAF4AAABEAAAAJgAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwkJu6ULC6z/DQ2h/w4OmP8HB1eiAAAAcAAA + AFMAAAAvAAAAFklJ1ptVVdP/U1PT/1FR0f9QUM//Tk7O/0xMzP9MTMr/SkrH/0hIxP9HR8D/RUW9/0RE + u/9DQ7f/QUGz/0JCr/9BQa3/PT2p7gAAAEAAAAApAAAAFQAAAAgAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJwaMNDa//EBCk/xAQjcoAAABoAAAAZgAAAFEAAAAzAAAAGAAA + AAgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADAwOhLgsLrP8NDaD/Dw+X/wwMeswAAABvAAAAUgAAAC4AAAAUAAAABkVF4FZSUtbpWlrW/1hY + 0/9WVtD/VVXO/1NTzP9SUsj/UVHE/09Pwf9OTr7/TEy7/0xMuP9KSrX/S0u1/0lJs/cjI4BkAAAAJQAA + ABUAAAAKAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBgbVRAsL + tP8ODqn/ERGf/wICOnQAAABoAAAAWgAAAD4AAAAhAAAADAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAASCwus/w4OoP8QEJf/Dw+D3QAA + AGsAAABMAAAAKgAAABEAAAADAAAAAQAAAANMTN57XFzX62Bg1P9eXtH/XFzN/1tbyf9ZWcT/V1fA/1ZW + vv9VVbz/VVW7/1RUu/9LS7fjLCyVWgAAABsAAAARAAAACAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCgq/wgwMsP8PD6b/Dg6PvgAAAGAAAABaAAAAQwAA + ACYAAAAQAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABgQEo0ELC6v/Dg6f/xAQlf8ODnrLAAAAZgAAAEQAAAAkAAAADgAAAAIAAAAAAAAAAAAA + AAEAAAADS0vcalRU0b1hYc72Y2PL/2Jixf9hYcL/YGC//2BgwP9OTrLUQECqjgAAAB0AAAASAAAACgAA + AAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEHB9BjCwu2/w4Orf8QEKX/AgJGZAAAAE8AAAA+AAAAJQAAABEAAAAEAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBwevcAwMqf8ODp3/ERGV/wkJ + Y6cAAABfAAAAPAAAAB0AAAAKAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAFAAAAEQAAACgZGa7qHh6t/yAg + qv8oKJC4AAAASgAAAC8AAAAYAAAACwAAAAUAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMKCr3gDAy0/w4Orv8LC5ucAAAAOwAA + ADEAAAAfAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAsJCbGrDAyo/w4OnP8REZT/BARFigAAAFcAAAAzAAAAFwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAgAAAAoAAAAaBgacjAgIqv8KCqX/Cgqa7AAAAFMAAAA3AAAAHQAAAAsAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQcH1GILC7r/DQ21/w4OsdUAAAAjAAAAHQAAABMAAAAJAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADwoKr9YMDKb/Dw+a/xER + kPYAAABpAAAATAAAACoAAAASAAAABAAAAAAAAAAAAAAAAAAAAAEAAAAGAAAAEgEBQzUJCarzCgqn/wwM + ov8FBWCFAAAARAAAACgAAAASAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQkJyqILC7zwDAy8wwAA + ABAAAAAOAAAACQAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAQAAAASCwuu/w0No/8QEJr/Dg59yQAAAGIAAABCAAAAIgAAAAwAAAACAAAAAAAA + AAAAAAAAAAAAAwAAAAwAAAAeCQmhqAsLp/8MDKL/DAyR2AAAAFAAAAA0AAAAGgAAAAoAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAEAAAABQAAAAUAAAADAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgUFrFALC6z/DQ2i/xAQ + mf8JCWiiAAAAWQAAADcAAAAbAAAACAAAAAEAAAAAAAAAAAAAAAEAAAAGAAAAFAUFjGALC6j/DQ2h/w4O + nf8EBFF6AAAAQQAAACUAAAAQAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAICAixfgsLqv8ODqD/EBCY/wEBIHAAAABOAAAALgAAABQAAAAFAAAAAAAA + AAAAAAAAAAAAAQAAAAoAAAAdCwulzg0No/8ODpz/DQ2ExQAAAFEAAAAzAAAAGQAAAAgAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAwJCbGrDAyp/w4O + n/8PD4/jAAAAXwAAAEQAAAAkAAAADgAAAAMAAAAAAAAAAAAAAAAAAAADAAAADgcHpXYMDKn/Dg6f/w8P + lPYCAjl4AAAASgAAACwAAAAUAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAAEAsLr9YNDaf/Dw+d/woKdKkAAABXAAAAOQAAABwAAAAJAAAAAQAA + AAAAAAAAAAAAAAAAAAMAAAAQCwuw8gwMqf8ODp7/Cwt0twAAAGYAAABMAAAAMAAAABkAAAAKAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAUCwuv/w0N + pf8PD53/AgI8dAAAAE0AAAAvAAAAFQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAwcHw2gKCrT/DAyr/w4O + nvUBAR9zAAAAaAAAAFYAAAA+AAAAKgAAABoAAAAQAAAACQAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACAUFp1IMDK3/Dg6j/w8Pl+sAAABaAAAAQgAAACUAAAAOAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAACCQnC0QoKt/8MDK7/DAyTvAAAAF8AAABnAAAAYQAAAFQAAABEAAAAMwAA + ACYAAAAZAAAAEAAAAAkAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAALCQmujwwM + q/8ODqL/DAyGuAAAAFEAAAA3AAAAHAAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEHB8ySCQm7/wsL + s/8MDKbZAgJGYgAAAFsAAABjAAAAYwAAAFwAAABRAAAAQwAAADQAAAAmAAAAGQAAABAAAAAIAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAABAKCq/JDQ2p/w8Pof8CAkBuAAAASAAAAC0AAAAUAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICzxMJCcPRCgq5/wwMsf8ODqj/Dg6UuQICP2sAAABiAAAAZwAA + AGYAAABeAAAAUgAAAEMAAAAzAAAAJQAAABgAAAAOAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAFQwM + rPIODqb/Dw+Y4AAAAFMAAAA9AAAAIwAAAA4AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIC + zxMICMiiCgq4/wwMsv8ODqn/EBCi/w4Ojr0CAjtyAAAAaAAAAGoAAABoAAAAXwAAAFIAAABCAAAAMQAA + ACMAAAAVAAAADAAAAAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAoFBaJVDAys/w4Opf8KCoCgAAAASgAAADMAAAAZAAAACAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHB9JjCgq58AwMs/8NDaz/Dw+l/xER + nv8PD4jAAgI4dgAAAGoAAABsAAAAaAAAAF4AAABPAAAAPgAAAC4AAAAeAAAAEgAAAAgAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAADwkJ + rp8NDar/Dw+k/wICRWcAAABAAAAAKAAAABIAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEEBNojCQnBsgsLtv8MDLD/Dg6p/xAQo/8REZz/Dw+HwQICN3kAAABrAAAAawAA + AGYAAABaAAAASgAAADcAAAAkAAAAFQAAAAoAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAWDAyv1w4Oqf8NDZjIAAAASwAAADYAAAAeAAAACwAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBgbVRAoK + vOALC7T/DQ2t/w8Pp/8QEKH/EhKb/wwMfa0BAR5vAAAAagAAAGgAAABeAAAATAAAADcAAAAhAAAAEAAA + AAYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAACwIC + gTgMDLD/Dg6o/wcHeIUAAABCAAAAKwAAABUAAAAGAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwcH0GQKCrrhDAyz/w0NrP8PD6b/ERGg/xIS + mPQJCXOYAAAAYgAAAGEAAABVAAAAQgAAACoAAAAVAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAPCQmyng0Nr/8NDaboAAAARwAAADYAAAAgAAAADQAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMICMuDCwu38AwMsv8ODqv/Dw+m/xERoP8REZjdBARZcQAAAE0AAAA+AAAAKgAA + ABcAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAA + ABILC7bkDQ2x/woKmaAAAAA7AAAAKgAAABYAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAs4TCQnIhAsL + tvANDbD/Dw+s/xAQqP8REaTyBARzWgAAAC0AAAAfAAAAEQAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBgbAWgsLuf8MDLLyAQE7QAAAACsAAAAdAAAADQAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLOEwkJyIQMDLXwDg6y/w4OsP8NDbG4AAAAGQAA + ABIAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAMKCsPCCwu7/wkJtY8AAAAhAAAAGgAAABAAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQICzxMICM9kBgbKRwAAAAsAAAAKAAAABwAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLbEgoKwu8LC73wAQF6IAAAABIAAAANAAAACAAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAQAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABBgbbUgYG2EQAAAAHAAAABwAAAAUAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/////////AH///////////////////wA///////////////////8AP////////////////// + /AB///////////////////wAf//////////////////8AD///////////////////AA///////////// + //////4AP//////////////////+AB///////////////////gAf//////////////////8AD/8D//// + ////////////AA/+Af///////////////4AH/gD///////////////+AB/4A////////////////wAP+ + AH///////////////8AD/AB////////////////AA/wAf///////////////4AH8AH////////////// + /+AB/AB////////////////wAPwAf///////////////8AD8AH//////////+AD///AAfAB///////// + /8AAH//4AHwAf/////////8AAAf/+AB8AH/////////+AAAB//wAPAB//////////AAAAH/8ADwAf/// + //////wAAAA//AAcAH/////////4AAAAH/4AHAB/////////+AAAAA/+ABwAf/////////gAAAAH/gAM + AH/////////4AAAAA/8ADAB/////////+AAAAAH/AAwAf/////////gAAAAA/wAMAH/////////4AAAA + AH+ADAB/////////+AAAAAB/gAwAf/////////gAAAAAP4AMAH/////////4AAAAAB8ADAB///////// + +AAAAAAfAAwAf/////////gAAAAADwAMAH/////////4AAAAAAYADAB//////////AAAAAAGABwAf/// + //////wAAAAAAgAcAD/////////+AAAAAAAAHAA//////////gAAAAAAADwAP/////////8AAAAAAAA8 + AB//////////AAAAAAAAfAAf/////////4AAAAAAAHwAD/////////+AAAAAAAB8AA//////////wAAA + AAAA/gAH/////////+AAAAAAAP4AB//////////wAAAAAAD/AAP/////////+AAAAAAA/wAD//////// + //gAAAAAAP+AAf////+Af//8AAAAAAB/wAH/////AD///wAAAAAAf+AA/////wAP//+AAAAAAH/gAH// + //8AA///wAAAAAAfgAB/////AAD///AAAAAAAAAAf////wAAH//4AAAAAAAAAH////8AAAf//gAAAAAA + AAB/////AAAA//+AAAAAAAAAf////4AAAB//gAAAAAAAAH/////gAAAH/AAAAAAAAAB/////+AAAAOAA + AAAAAAAA//////4AAAAAAAAAAAAAAP//////gAAAAAAAAAAAAAH///////AAAAAAAAAAAAAH///////8 + AAAAAAAAAAAAD////////wAAAAAAAAAAAAP////////AAAAAAAAAAAAA////////8AAAAAAAAAAAAD// + +AD///wAAAH4AAAAAAAf/gAA////AAAH/wAAAAAAB8AAAP///8AAP/+AAAAAAAAAAAD////wAf//gAAA + AAAAAAAA/////////8AAAAAAAAAAAP////////+AAAAAAAAAAAD//8AAAB//gAAAAAAAAAAA/+AAAAAA + P4AAAAAAAAAAAP/AAAAAAB+AAAAAAAAAAAf/wAAAAAAHgAAAAAAAAAA//8AAAAAAA4AAAAAAAAAH///A + AAAAAAGAAAAAAAAA////wAAAAAAAgAAAAAAAP////8AAAAAAAAAAAAAAAP/////gAAAAAAAAAAAAAAB8 + D///8AAAAAAAAAAAAAAAYAP///wAAAAAAAAAAAAAAAAB////8AAHwAAAAAAAAAAAAf////////gAAAAA + AAAAAAD////////+AAAAAAAAAAAA/////////wAAEAAAAAAAAH/////////AABAAAAAAAAA///////// + 4AAQAAAAAAAAP/////////AAOAAAAAAAAB/////////8AHgAAAAAAAAf/////////4P8AAAAAAMAD/// + /////////AAAAAAHAA////////////4AAAAAH4AP///////////+AAAAAD+AB////////////wAAAAA/ + wAf///////////8AAAAAf8AD////////////AAAAAH/AA////////////wAAAAD/4AP///////////8A + GAAB/+AD////////////ABwAB//wA////////////gA8AD//8AP///////////4AOAA///gD//////// + ///+ADgAf//8B////////////gAwAH////////////////4AcAD////////////////8AHAA//////// + /////////ABwAH////////////////wA8AAf///////////////8APAAB///////////////+ADwAAH/ + //////////////gB+AAAf//////////////4AfgAAB//////////////8AH+AAAP//////////////AD + /wAAD//////////////gA//AAAf/////////////4AP/4AAH/////////////+AH//gAB/////////// + ///gB//+AAf/////////////4A///4AH/////////////+AP///gD//////////////gH///+D////// + ////////4B////////8oAAAAQAAAAIAAAAABACAAAAAAAABCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABwAAAA4AAAARAAAADAAA + AAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAA + AA4AAAAcAAAAJgAAAB0AAAAPAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIICLxaCgqokwAAADkAAAAzAAAAHQAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBga1Ow4Opf8ICIqIAAAARAAAAC4AAAATAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNDaHHDg6d5wAA + AEwAAAA+AAAAIQAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADCwuqaw4Onf8ICH+OAAAASgAAADAAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAA + AAcAAAAFAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAoODpzkDQ2a6AAAAFEAAAA+AAAAHwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAABwAAABAAAAAXAAAAEwAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDAyiiw0Nm/8GBnOHAAAASwAA + AC0AAAAQAAAAAgAAAAAAAAAAAAAAAQAAAA8AAAAiAAAAMgAAACoAAAAXAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQE + pCwNDZv/DQ2U0gAAAFMAAAA8AAAAGwAAAAUAAAAAAAAAAAAAAAMAAAAWDg6o/wUFcnYAAAA+AAAAIgAA + AAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAHDQ2duA0Nm/8DA1Z0AAAASgAAACkAAAAMAAAAAQAAAAAAAAAEBwefUw4O + nv8LC4y1AAAATAAAACoAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAYAAAAIAAAACgAAAAkAAAAHAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJqFwODpr/DAyMvgAAAFUAAAA5AAAAFwAA + AAQAAAAAAAAABQgIm1MNDZn/DAyR1gAAAFEAAAAsAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACgAAABMAAAAdAAAAJAAA + ACcAAAAlAAAAHwAAABYAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDg6Z5A4O + mv8BASNkAAAASAAAACQAAAAKAAAAAAAAAAUICJpTDQ2Y/wwMj9YAAABTAAAALgAAAA4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADgAA + ACAAAAA0AAAARgAAAFEAAABXAAAAVAAAAEoAAAA7AAAAKQAAABcAAAAKAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABQ0NnpsNDZj/CgqBrAAAAFUAAAAzAAAAEwAAAAMAAAAFCAiZUw0NmP8MDI7WAAAAUwAA + AC4AAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAACwAAACEBAS1NCAhymwoKdLoMDIffCgp2yQgIa7gBATKKAAAAawAAAFUAAAA7AAAAIwAA + ABAAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAEHB6Q+DQ2Y/w0NlekAAABcAAAARAAAAB8AAAAHAAAABQgI + mVMNDZj/DAyO1gAAAFMAAAAuAAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABYWFpCGDQ2T9QsLkf8KCpL/CQmS/wkJkf8LC5D/DAyT/woK + edUAABmHAAAAZwAAAEkAAAAsAAAAFAAAAAcAAAABAAAAAAAAAAAAAAAAAAAACQ4OmNYNDZj/BgZpkQAA + AFIAAAAtAAAADgAAAAYICJlTDQ2Y/wwMjtYAAABTAAAALgAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcODnw9HR2c/woKjv8HB5H/CAib/wcH + n/8ICJv/CAiT/wgIj/8KCo//DAyP+QUFVq8AAAByAAAAUgAAADAAAAAVAAAABwAAAAEAAAAAAAAAAAAA + AAQMDJ99DQ2X/wwMjtYAAABbAAAAOgAAABcAAAAICAiZUw0NmP8MDI7WAAAAUQAAACwAAAANAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJHh6gmBYW + lf8ICJH/Bgad/wYGpf8GBqf/Bgal/wYGof8HB5v/BweR/wkJjP8LC5H/Cgp0zwAAAHgAAABVAAAAMAAA + ABQAAAAFAAAAAAAAAAAAAAABBQWbLg0NmP8NDZj/AgI8cgAAAEIAAAAdAAAACggImlMNDZj/DQ2Q1QAA + AE8AAAArAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACCEhn8wXF5f/CAib/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgal/wYGnf8GBpD/CAiL/wsL + j/8KCnnWAAAAdwAAAFEAAAAqAAAAEAAAAAMAAAAAAAAAAAAAAA4NDZS9DQ2X/wkJfKQAAABEAAAAHgAA + AAoICJtTDQ2Z/w0NkdUAAABLAAAAKAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYjI6KVHBya/wgIm/8GBqX/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqX/Bgad/wYGkf8ICIv/CwuQ/wkJbMgAAABxAAAASAAAACEAAAAKAAAAAQAAAAEAAAASDAyMmQ0N + l/8KCoKtAAAAPgAAABoAAAAICAibUw0Nmf8LC4e0AAAASQAAACcAAAAKAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADHh6pciIimv8LC5T/Bgah/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpf8GBp3/BgaR/wgIi/8MDJH/BQVWrgAAAGYAAAA6AAAAFwAA + AAUAAAAFAAAAGw0Nk9sNDZj/BQVjgQAAADQAAAASAAAABwgIm1MODpr/CgqCqwAAAEwAAAAqAAAACwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARIS + lB0jI53/FRWV/wcHm/8GBqX/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgal/wYGnf8GBpH/CQmN/wwM + j/kAABmGAAAAVAAAACkAAAANAAAADAUFfk8NDZj/Dg6W9QAAAE4AAAAoAAAACwAAAAUICJtTDQ2Z/wsL + hLcAAABVAAAAMAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAFISGhrSEhmf8KCpL/Bgad/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqX/Bgad/wcHkf8KCpD/CgpzzgAAAGwAAAA9/////wAAABcMDJOlDQ2X/wsLh8IAAABBAAAAHAAA + AAYAAAAECAiZUw0NmP8MDIzYAAAAXwAAADsAAAAVAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARkZsC0mJp3zGxuV/wYGkv8GBqH/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpf8HB5v/CAiP/wwMk/8CAjCOAAAAUQAAACkAAAAkDg6V5w0N + l/8FBWSAAAAAMwAAABIAAAACAAAAAwgIn1AMDJb/DQ2X/wAAAGgAAABIAAAAHwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAELy+uhDAw + oP8bG5f/Bweb/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgah/wcHkv8KCpD/Cgp1zAAA + AGEAAAA3CAiIcg0NmP8NDZXqAAAASgAAACYAAAAKAAAAAAAAAAEICKlMDQ2V/wwMlP8GBmSXAAAAVgAA + AC0AAAAOAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAc5Oaq0OTmk/yMjnf8HB5v/Bgah/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + pf8HB5v/CQmQ/wsLh+oAAABrAAAAQgoKjp0NDZj/CgqBrAAAAEAAAAAdAAAABQAAAAAAAAABAwOfGA0N + l/EMDJP/CwuDxAAAAF4AAAA+AAAAGwAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS2zHEVFrd1ERKj/NDSi/w0Nlf8GBp3/Bgal/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgaf/wgIkP8TE5b/AAAAcwAAAEwNDZXQDQ2Z/wICP28AAAA+AAAAGwAA + AAQAAAAAAAAAAAAAAAMMDKZrDAyW/w0Nl/8CAj1wAAAATQAAACwAAAAPAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAACQAA + AAoAAAAHAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIrK60dTk6y309P + rP9FRaf/JSWe/woKnP8GBqH/Bgal/wYGp/8GBqf/Bgan/wYGn/8ODpP/Jyed/w8PSpYAAABZDQ2Q1A0N + mP8BASBtAAAARgAAAB8AAAAGAAAAAAAAAAAAAAABAAAABg0NnqgNDZj/DAyLvgAAAFgAAAA/AAAAHwAA + AAgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAADAAAABcAAAAdAAAAGgAAABAAAAAIAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAhQULatWVmy/1RUrv9LS6z/LCyi/xsbo/8VFaf/FBSq/xcXrf8qKq7/Nzen/zc3 + o/8GBhyKAAAAbQsLh9oNDZX/BgZgngAAAFcAAAAsAAAADgAAAAEAAAAAAAAAAAAAAAMAAAAMDg6Y1g0N + mf8FBV+GAAAAUwAAADEAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBciAAAAAlAAAAMgAAADIAAAAoAAAAHAAAABIAAAAKAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABUJCu2xfX7bsYGC1/1xcsf9XV7H/U1Oz/1BQ + t/9NTbj/SUm1/0VFrv8eHpn/BwdWswkJZsEJCWjKCwuQ/wsLetIAAABtAAAARAAAACIAAAAQAAAADQAA + ABAAAAAUAAAAGwcHgWINDZf/DQ2Q4gAAAGQAAABDAAAAHAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODrLDDg6o4wYGgmYAAAA9AAAAOwAA + ADMAAAAqAAAAIAAAABcAAAAOAAAACAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACFBQ + vIJoaLrQZ2e5/2Njt/9gYLf/XV22/1hYtP8mJp3/CQmH7QkJh+8KCpL/CQmJ+QoKjv8MDIz4AAAAhAAA + AGQAAABEAAAAMAAAACwAAAAxAAAAOQAAAEAAAABNCwuO6w0Nlf8HB22iAAAASQAAACAAAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAS/Jw0N + rKcODqP/DQ2gywcHh3YAAAA9AAAAPQAAADgAAAAxAAAAKAAAAB8AAAAVAAAADgAAAAcAAAADAAAAAQAA + AAAAAAAAAAAAAQAAAAQAAAAKAAAAFR8fYjc6Opd1NzeNfDc3iX8qKn98CwuBuwoKdsMICJn/CAie/wcH + mf8ICIf5CgqM/woKeN8BAS2TAAAAbwAAAGAAAABeAAAAZQQEWJAFBVSTBgZNlAsLhOUMDJP/DAyOzQAA + AD4AAAAbAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAFBASqKwwMqZoODqLxDg6h5QkJlI4CAlFWAAAARAAAAEIAAAA9AAAANAAA + ACoAAAAgAAAAFgAAAA4AAAAKAAAACQAAAA0AAAAVAAAAIAAAACwAAAA5AAAARAAAAEwAAABPAAAAUDQ0 + jKsYGJr/CAie/xMTqv8bG6n/BgaU/wgIjv8KCo7/CwuL+QYGTLMLC3jSDAyQ9wwMk/8MDJL/DAyR/wsL + kf8LC5H/DQ2W/woKkKAAAAAmAAAADwAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAFAgKOGwwMq4oODqLjDg6g/w0N + msEICIOKAQEoVwAAAE4AAABKAAAAQwAAADgAAAAtAAAAJgAAACUAAAAsAAAAOAAAAEYBASVcCAh2lwoK + f64MDIzMCgp9rgYGWIgPDyx1W1us7V5evv8zM7X/Bgal/wYGof8HB5v/BweS/wgIkP8KCpD/CQmO/wkJ + jf8KCo3/CwuP/wsLkP8MDJP/DQ2V5woKjn8AAAAfAAAAEAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAAEAAAACgsLrGwODqDjDg6d/w4OnP8MDJLGCAh5kwEBJGIAAABXAAAAUQAAAEwAAABMAQEmWwgI + dZcMDIrMDQ2Y/w0Nl/8NDZf/DQ2X/wwMlv8MDJT/DAyN9QkJeNEHB4PfBwel/wYGp/8GBqf/Bgal/wYG + of8HB5//BweZ/wcHjv8KCov/CwuQ/wwMh9cLC4aiBwd7aAAAACoAAAAeAAAAEgAAAAcAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACAgIqk0NDZ3HDQ2b/w0Nmf8NDZn/DAyMyggI + cZkGBmaRCwuGww0NlfUNDZf/DQ2W/w0NmP8NDZXaCgqKfwoKkXkNDZa8DQ2W8gwMk/8KCpD/CAiS/wcH + nf8GBqX/Bgan/wYGp/8GBqf/Bgan/wcHn/8HB5D/BgZEtwAAAH4AAABgAAAASQAAAD0AAAA2AAAALgAA + ACIAAAAVAAAACgAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAABgAA + AAcAAAAHAAAABQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABwUF + ny0NDZ6qDQ2Y8g0NmP8NDZf/DQ2X/w0Nl/8NDZj/DQ2W2goKkIsEBHE/AAAAGQAAABAAAAALAAAACgAA + AA0LC6FeFhaUvRAQkf8ICJP/Bweh/wYGp/8GBqf/Bgan/wYGp/8HB5//BweP/wsLh/kDAzeiAAAAegAA + AGsAAABiAAAAWQAAAFAAAABEAAAANAAAACMAAAASAAAABwAAAAIAAAABAAAAAwAAAAUAAAAIAAAADAAA + ABAAAAAUAAAAGQAAAB4AAAAgAAAAHAAAABQAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAABQICjRsLC6RtDg6b1Q0NmsoLC5aGBARzPgAAABgAAAAQAAAACAAA + AAQAAAABAAAAAAAAAAAAAAAAAAAAAx8fkiA0NKL0GBiY/wkJoP8GBqf/Bgan/wYGp/8GBqf/Bgah/wcH + kv8JCYz/CwuJ+QsLfeUMDJD4DQ2Z/w0NkeMJCYKuAAAkYQAAAFEAAABDAAAAMAAAAB4AAAAVAAAAFAAA + ABcAAAAdAAAAJAAAACoAAAAxAAAANQAAADoAAAA9AAAAPAAAADMAAAAjAAAAEAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAcAAAAKAAAACgAA + AAgAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGLi6ZUj4+pvYuLqj/EhKj/wYG + n/8GBqH/Bgal/wYGpf8HB53/BgaS/wcHj/8JCY//CwuQ/wwMjvcMDJDsDQ2Z/w4OmPQICHaWAAAAWQAA + AE8AAABAAAAANwAAADYAAAA5AAAAQAAAAEcAAABNAAAAUgUFZ30GBnKICgqKpwoKkKQICJmQAAAAJgAA + ABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACAAAAAsAAAANAAAADgAAAA4AAAAOAAAADgAA + AA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAANAAAADAAAAAgAAAAEAAAAAQAAAAAAAAAAAAAABwEB + Ti0WFpHpNzek/zw8pv8fH5r/BgaT/wYGnf8GBqX/Bgal/wYGof8HB5//BweZ/wkJhPMBAReKAAAAYAsL + h6MNDZn/DQ2Z/wwMkNYCAjxyAAAAWgAAAFYCAkBrBQVjgAoKgqsMDI3LDQ2W6g0Nm/8NDZv/Dg6c/w4O + nv8ODqLlCgqqkwAAABcAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACgAAABcAAAAjAAAAKwAA + AC4AAAAuAAAALgAAAC4AAAAuAAAALgAAAC4AAAAuAAAALgAAAC4AAAAuAAAALQAAACoAAAAiAAAAFQAA + AAoAAAADAAAAAAAAAAoKCpJ3CwuQ/woKjP8uLo3hSEio/yoqm/8JCZP/Bgah/wYGp/8GBqf/Bgan/wgI + n/8JCZL/CAhhvQAAAG0AAABVBARWcA0Ni9UNDZf/DQ2V9Q0NjtUNDZr/DQ2a/w0Nmf8NDZn/DQ2Z/w4O + mv8NDZjZDAyWpAoKmXgDA3o7AAAAFwAAABAAAAAJAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAA + ABIAAAAnAAAAPAAAAEoAAABRAAAAVAAAAFYAAABXAAAAVgAAAFUAAABUAAAAUwAAAFMAAABTAAAAUwAA + AFMAAABRAAAASAAAADYAAAAhAAAADgAAAAUAAAANDQ2VvQsLkP8LC5D/AAAAZj4+j5xSUq7/ODil/xMT + o/8GBqf/Bgan/wYGp/8HB5//CQmR/w4OfeUAAACGBQVQmQUFT5cAAABzCAhlpAwMkusNDZr/Dg6Y8w0N + l80MDJWkCwuZhgcHklkAAAAbAAAAFAAAAA8AAAAKAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAQLC7WWDQ2hyQ0Nl88NDZHTDQ2O1QwMjdcMDIvYDAyM2AwMjNgMDI3XDAyO1wwM + jtYMDI7WDAyO1gwMjtYMDI/XCwuJxAAAIWkAAABUAAAAQAAAACgAAAAVAAAAFw0NkswMDJH/DAyI5AAA + AFkAAAA1R0efk11dtP9PT7X/Nzex/x0dqP8XF6f/ExOh/xgYl/8ZGX3oCgp+7AsLkP8LC5D/CwuH8QMD + O5sAAABsAAAATAAAACwAAAAYAAAADgAAAAoAAAAHAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCQnAZg4OpNMODpz/DQ2Z/w0Nl/8MDJb/DQ2V/w0N + lf8NDZb/DQ2X/w0NmP8NDZj/DQ2Y/w0NmP8NDZf/DAyW/w0Nlv8NDZf0BQVhgwAAAFUAAABGAAAAMwAA + ADENDY/QDAyS/wwMidoAAABQAAAALAcHgl8uLqD/YGC1/1pas/9NTa7/QUGq/zU1qP8pKaD/Dw+S/wcH + kP8HB5D/CAiP/woKjv8LC4z5AwM+mgAAAF4AAAAzAAAAFAAAAAUAAAAEAAAACAAAAAsAAAAKAAAABwAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAHAAAADggI + qU4ICJtTDQ2djgwMmZAMDJqRCwuXdggIklgICJVWCAiZVQgImlQICJlUCAiWVQwMmYENDZfJDQ2Y/w4O + mv8JCYGcAAAAVQAAAFIAAABUCwuG2AwMk/8KCni0AAAARgAAACULC5WGDAyU/yAghcdaWqniZma3/1pa + sf9LS67/Hx+Z8gcHn/8HB5//Bgaf/wcHm/8HB5H/CQmO/wsLhusAAAB5AAAATwAAACgAAAAVAAAAFQAA + AB4AAAAkAAAAIwAAABcAAAALAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAUAAAAHAAAACAAAAAgAAAAHAAAABQAAAAUAAAAFAAAABQAA + AAUAAAAGAAAACgkJp00ODpvVDg6a/w0NktEHB2eMBgZRjQsLie0MDJP/CAhzmQAAADcAAAAbCwuckQ0N + l/8GBlyBAAAATSMjZ140NIWIDw+G4wgIn/8HB6f/Bgan/wYGp/8GBqX/Bweb/wgIjv8LC4//CQluxgAA + AGsAAABGAAAAMQAAAC8AAAA5AAAAQQAAAD8AAAAxAAAAGwAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwOYGQ0NoKgNDZn/DAyU/wsLkf8LC5D/DQ2X/wIC + T1sAAAAjAAAAEAwMo4wNDZn/BwdtiAAAAE4AAAA/DAyHtwkJkf8HB5//Bgan/wYGp/8GBqf/Bgan/wYG + of8GBpP/CQmM/wsLjfkAAACBAAAAYgEBKFcJCY2UDg6f5w4On/QDA15sAAAARAAAAC4AAAAUAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAGCwurWw4O + mPENDZX/DQ2X/wwMlqYAAAAjAAAAEAAAAAcGBq08DQ2b/w0Nk9IAAABVAAAATRYWmf8LC5L/Bwef/wYG + p/8GBqf/Bgan/wYGp/8GBqX/Bgab/wgIjv8KCo3/BwdXtgoKeLYODp70Dg6e5woKkYsNDZrZDg6f8wEB + K1MAAAA+AAAAIwAAAAwAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMDA58YCAiuTAYGoEEAAAATAAAADAAAAAUAAAABAAAABw0NncYODpr/BQVhfwAA + AFc2NqP2MTGh/x4eo/8SEqX/Cgqm/wYGp/8GBqf/Bgan/wYGn/8GBo//CQmL/wwMkv8ODpj1CgqSnwEB + SzIAAAAXBASJNA4OnPIKCpGfAAAARwAAADMAAAAXAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAEAAAAAAAAAAAAA + AAIICKtMDg6a/w0Nj9IAAABZNzeXvUNDqP88PKX/OTmn/zU1rv8rK7L/IyOx/x4erf8WFqH/GxuW/x4e + lf8XF4jUAQEvUAAAACIAAAANAAAABQAAAAYMDKWLDg6f/wICS14AAABAAAAAJQAAAAwAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACA0NmsgNDZn/BgZeghAQNV1OTq3kUVGt/0tLqf9HR6v/RESy/z8/ + tP87O6//ODil/zU1oP81NaT/Dw9QZwAAACcAAAANAAAAAgAAAAAAAAABAgKNGw4On/8LC5OsAAAASQAA + ADMAAAAWAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUICJhVDQ2Z/wwMicAAAABMGhoaNVFR + s7NfX7X/Wlqx/1RUsP9RUa//Tk6s/0xMqv9KSqz/ODifuwAAACwAAAASAAAABQAAAAAAAAAAAAAAAAAA + AAUNDaGpDg6c8gEBK1IAAAA7AAAAHgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAQFUKg0N + mf8NDZLVAAAASAAAACYAAAAOU1PCT1tbs85oaLf/ZGS0/2FhtP9cXLP4RUWnrwAAACMAAAARAAAABgAA + AAEAAAAAAAAAAAAAAAAAAAACBgatPA4On/8LC5ScAAAANgAAAB8AAAAKAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACAcHkFkNDZr/DAyNvwAAAEAAAAAfAAAABwAAAAUAAAAYFRV/eCMjnv8kJIejAAAANwAA + ABsAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcODqfEDg6l8QAAACQAAAAVAAAACAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLC5iUDg6a/wgIfJEAAAA2AAAAFgAAAAMAAAAKAAAAIA0N + ls4NDZjoAAAAOgAAAB4AAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBAS/JwsL + uIcAAAAQAAAACgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAQDQ2avQ4OnP8BAS1TAAAALAAA + AA4AAAADAAAAEQkJk3wODp//BQVvdgAAADAAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADAAAAAwAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAFQ4O + nOUNDZfRAAAAPQAAACEAAAAIAAAAAwEBZiMODp7lDQ2V0gAAAEsAAAAxAAAAFQAAAAYAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABQEBVykODp//CgqKlgAAADMAAAAYAAAABAAAAAMKCrFqDg6d/wcHdX8AAABMAAAAPgAA + ACoAAAAZAAAADgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoICJtmDg6g/wICU1YAAAAoAAAAEAAAAAEAAAABCAi/Rw4O + nvENDZe/AgJLWwAAAEkAAABDAAAANwAAACgAAAAYAAAADAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAQDAyfoQ0NntoAAAA1AAAAHgAA + AAgAAAAAAAAAAAAAAAMHB7Q6Dg6g4g4Onv8MDJa2AgJIYAAAAEsAAABDAAAAMwAAACEAAAAQAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAFw4O + oeUJCZOPAAAAKgAAABQAAAADAAAAAAAAAAAAAAAAAAAAAwICoBgMDKiKDg6e/w4Onv8MDJS5AgJJYAAA + AEQAAAAyAAAAGwAAAAoAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABwUFmkMODqPyAQFAPAAAAB8AAAAMAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQUF + rCoNDaKpDg6e/w4On/IJCZSQAAAAMwAAAB8AAAANAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMDK+YDAyorAAAACAAAAATAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAABQQEpCwNDaapDg6n/woKsIAAAAAUAAAACAAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDg6y0QMDmDEAAAAQAAAACAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAkAAAAKAAAACAAA + AAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQE + 0iQAAAAHAAAABQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /8B/////////wH/////////AP////////8A/////////4D/////////gHg///////+AeB///////8AwH + ///////wDAf///////gEB/////gD+AQH////4AD8BAf////gAHwAB////8AAHAAH////wAAOAAf////A + AAYAB////8AABgAH////wAADAAf////AAAAAB////8AAAAAH////wAAAAAf////gAAAAA////+AAAAAD + ////8AAABAH////wAAAEAf////gAAAYA//8H/AAABgB//wH+AAADAH//AD8AAAAAf/8AB8AAAAB//wAA + wAAAAH//AAAAAAAAf//AAAAAAAB///AAAAAAAP///AAAAAAAP4D/gAAAAAAAAP/gAOAAAAAA//gH8AAA + AAD4AAAwAAAAAPgAABAAAAAA+AAAAAAAAAP4AAAAAAAAf/gAAAAAAAAf+AAAAAAAAA//gAAAAAAAB/// + /gAAAAAH////AAAAAAP////AAAAAA////+DAAAAB/////+AAAgH/////4AAHAf/////gAAcB/////+AA + D4H/////4AA/gf/////AAH/B/////8AAP///////wAAP///////AAAP//////4DAAf//////gOAB//// + //+A8AH//////4H8Af//////gf8B//////+D////KAAAADAAAABgAAAAAQAgAAAAAACAJQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAh7AQICLzIAAAZNAAACDwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmXCw4Oq+wEBCacAAAAPgAA + AQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsL + sZMMDHPYAAAAcAAAAQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAsLsScODqb6AwMfnQAAADYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7G3Cwtk0wAAAGkAAAELAAAAAAAAAAAAAAAAAAAAAAIC + HggAAAA3AAABEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrNPDw+d+wICEZMAAAAqAAAAAAAA + AAAAAAAAAAAAAAsLiIIFBS2jAAAAOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7EFDAyv4QoK + T8oAAABcAAABBgAAAAAAAAAAAAAAAA4OpbYNDVvZAAAAUQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAACgqyhRAQjPQAAAeJAAABHgAAAAAAAAAAAAAAAAwMqcIPD2/pAAAAWgAAAQMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQoLAAABKQAAAEIAAABKAAAAPAAAABwAAAAFAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAACgq1JA4Opf4HBzi8AAAASgAAAAIAAAAAAAAAAAsLqcoQEHTuAAAAXAAA + AgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEIRUGBjKHDAxMzRAQVN8QEEbaCgonvgEB + BI0AAABXAAAAGgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAoKtMQPD3XpAAABegAAABEAAAAAAAAAAAsL + qc8QEHTtAAAAWAAAAgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBB1BBISgboODpD+Dw+L/xAQ + iP4SEn/+FhZw/hcXWvQKCiK+AAAAewAAAC0AAAADAAAAAAAAAAAAAAAAAAAAAAoKtmgQEJn+BAQfqQAA + ADQAAAAAAAAAAAoKrdEPD3HpAAAAUQAAAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBitRhMT + sP8HB6b/Bwei/wgIoP8JCZz/DQ2R/xMTf/8YGGj+ERE62AAAAYgAAAAyAAAAAwAAAAAAAAAAAAAAAAoK + sxYMDKn2DAxU2AAAAF8AAA0GAAAAAAkJtNsNDWniAAAASQAABAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAGxvIbBERu/8FBa7+Bgan/wYGpv4GBqb+Bwej/goKmv8REYf+GBhs/hMTP94AAAKIAAAAKwAA + AAEAAAAAAAAAAAAAAAALC6uxEhKC+QAAA2wAAA8IAAAAAAoKs9sMDF/aAAAAQQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAGRnLVhYWwP8FBbH+Bgao/wUFpv4FBab+Bgam/gYGpP8KCpz+EBCJ/hgY + bP8QEDbVAAAAeAAAABcAAAAAAAAAAAAAAAAKCpmjERGC9gAAAU4BARUCAAAAAAoKs9sLC1nUAAAAQAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRnLFhoaxvsICLf+BQWr/wUFp/4FBab+BQWm/gYG + pv8GBqX+Cgqc/hERhf8ZGWb+CQkeugAAAFQCAgIGAAAAAAoKhQ4LC5ruDAxc0QAABSgAAAAAAAAAAAoK + stsMDFnXAAAASwAAAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZzqcTE8D/BQWx/wYG + qP8GBqf/Bgan/wYGp/8GBqb/Bgak/wsLmP8UFH3/GBhZ9AEBBI4GBgcoCAg5AwgIhF0ODpX/BgYukwEB + DQ0AAAAAAAAAAAoKsdcODmXlAAAAZAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsb + 0CYcHMn0DQ28/wUFrv4FBaj+BQWm/gYGp/8FBab+Bgam/gcHov8ODpD+Fxdu/gwMLMYAAABOBAQ4AwkJ + m7oPD4T0AAAGSwEBEQIAAAAAAAAAAAoKr88SEoD4AAAEhwAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAlJdNuJyfJ/hAQuv4FBa3+BQWo/gYGp/8FBab+BQWm/gYGpf8KCpv+ExN+/hUV + VO0AAABwAwM6GAsLo/oKClTDAQEJHwAAAAAAAAAAAAAAAAgIu7cQEJj+BgYntAAAAD8AAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKtEBMzPUljU1zP8cHL7/Bgau/wUFqf8GBqf/Bgan/wYG + pv8ICKH/Dw+L/xoabv0DAwuFBARJSA0Nmv4EBCCTAAAIEgAAAAAAAAAAAAAAAAgIvTYLC6/2Dg5q4QAA + AHcAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANzfTAkBA15NERND+NDTG/hUV + tv8GBqz+BQWo/gYGp/8HB6T+FRWV/iwsgP4FBQ+SBAQ8YxAQjf4DAxadAAABJAAAAAAAAAAAAAAAAAAA + AAAJCbpnDw+h/QUFKKsAAABLAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBERUAAABCAAAAHQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEND + 1gFJSdhgUFDV701Nz/9CQsj+MjK//i0tu/8zM7r+PDyx/jY2kf4HByeyBAQmmRMTfP8LCzDEAAAARwAA + AAIAAAAAAAAAAAAAAAAAAAAACwumrhAQduoAAAOIAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJk6oGBkikAAAEcQAAAEsAAAAeAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAUFDXFlNT1YpYWNXlV1fR/lNTzf9PT8r/QUG//xMTnPoMDHrvDAyA+RIS + ev4TE03mAAAAgAAAAC4AAAIHAAABDQAAAxoAAAwgBAQ9WxISh/8KCjbGAAAASAAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJqD4LC6+2DAyU3wYGR6IAAApyAAAAWQAA + ADIAAAASAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLnoHKChsMyQkVVghIVVUEBBzYAgI + qucICKf+Cgqf/hAQiPoWFmz9Dw841QEBBpIBAQZiBQUeigYGKKgGBjOxBQVBvBAQiP4QEGbaAAACMAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqmLwsL + rKANDaPqCQlmwgQEJ5cAAAF1AAAAVQAAAC4AAAASAAAABAAAAAAAAAAAAQELBAQEDxYBAQQ5AQEQbQMD + GY8BAQqGAwMKczY2rPckJLD+ICCv/goKnf8PD4n+FBR1/hERWuwREXD2ERGC/g8Piv8MDJX+Cgqa/w0N + mPIHB0NcBQUqBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCqgbCgquiAwMru0NDZDtCQlWygQEIqUAAAJ+AAAAWAAAATEAAAIyAgIRZQgI + RLANDXjoDw+R/g4Olf8NDZj+CAiA6xAQbNoXF47wBgam/wYGpf8JCZ//CwuX/wwMkf8MDI3/CgqO/gkJ + lu0ICJm6BweCcgUFVBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKrw8KCrRuCwuz2g4Oov4PD4TxCgpR0QYG + O7wLC2vdDg6R/AwMm/4KCprXCQmPgQkJm1sICLSaBga44gUFsv8EBK7+BQWt/gYGqP8GBqb+Bwek/ggI + nv8LC4T8BQUmtwAABloBARQeAQEVIQAADx8AAAsOAAACAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqyBAkJ + t08JCba5Cgqt/QsLpv4KCqHkCAiSkwgIiTkICIsEAAAAAAAAAAAAAAAABwe6BA0NxU8QEMH8BAS1/gUF + q/8FBaf+Bgam/ggIn/8PD4j+EhJk9AcHHrUICCWqCAgrsAQEGJoAAABzAAAAOgAAAAoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAgEAAAEFAAABCwAAABMAAAAaAAAFEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABwezHwgIqywICJgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAiIseTHh68/g4OsP8GBqn/Bgao/wcHo/8LC5b/EBCE/xISeP8TE3P+EhJ8+hISjP0NDWjdAgIUnAAA + AGIAAAAhAAABCwAAAhEAAAIeAAABMgAAAEoAAAZlAwMYgwQEJpoFBTOiAgIXQAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAMDJg1Fxez+yoqtP8WFrL+BQWw/gYGqv8HB6P+CQmd/gwMkv8ODm/0AgIQkgQE + RGINDZjfERGJ+AgIPcAAAAaHAgIQewUFJ5cICEK3Cwtf1A0NfOsPD5H6Dw+a/w8PnuYNDYuiBgZGHAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAEEwAAACYAAAAqAAAALQAAADAAAAAwAAAAMAAAADAAAAAwAAAALwAA + ACsAAAApAAAAIAAAAAkAAAAAAAAAAAAAAAAGBrOcBgak/gwMaM0zM6vgICC//gYGsf8GBqj+Bgak/gsL + l/8SEnv+BwcouAAAAEoBARBeCQlexRAQkP0ODo/5Dg6Y/Q0Nnv4LC6T7Cwun0wsLp58LC6ZoDAyiLQwM + mAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBXgeBQVLiQcHQ7gICEDACQlGxQkJRcYJCUXGCQlFxgkJ + RcYJCUbGCAg9wggIOr8ICDS5AgIRmQAAAGAAAAAZAAAGAQAAAAAGBrLLCwuZ/wMDIZITE0sqQUHI0jQ0 + wf8YGLL/DAyr/w4Onv8aGoX/FBRH1g0NVdkNDWjrBwcyxAICHZsFBVeMBwd9WgkJkjEKCqUIAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBqEvCQm2ugoKsvQLC6j+Cwul/gwM + o/8MDKL+DAyj/wwMo/4MDKP+DAyj/g0Nov8PD5v+EhKI+QcHMrcAAAByAAACKQICOQYICKHWEBCN/gIC + D3gKCjkJExOokkZGwv9ISMH+ODjB/isrt/8kJKL+EhKF/Q4Oif4QEIb+ExN2/wwMOtEAAAB2AQEXFgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJ + twsICLYoCQmvPAkJrD8JCas/CQmtNQkJry0JCbIlCQm1HAoKsiMLC61ICwuvrQ8PofwJCVPFAAAFhwAA + AF0KCoPoEhJ/+gAAAFkEBEIEBgawwAoKe903N3qsT0/K2zs7ueUWFqn5CAij/wgIof8KCpr/ERGG/xgY + af4ICB64AAAATAAAAwMAAAwCAAAEFAAAAC8AAAAaAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK + s1ALC7DrCwuU8wcHcN8MDIv6Dg5p2wAABy0AAAAABwe4ygYGV8sAAABSERFVEAMDmNQFBav+Bgao/wYG + pv4HB6T+CwuY/xQUe/4WFlPuAAABgQAAAigBARFRCAhIqAcHPa8AAABrAAABFQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAICLcjBgbBvgcHtv4LC6f5BgZEYwQEKQYAAAAACAi0mgwMiO0AAASEBwdIcAgI + tP8FBa/+Bgao/wUFpv4GBqb+CAih/w4Ojv4WFm/+BwclugkJUMENDZTpCgqAlRAQoOkFBTGfAAAATQAA + AQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABga/AgcHvSoHB54fAAAAAAAAAAAAAAAACQm0LwwM + qv0GBju5DQ08kSgovv8fH73/FRWw/w0Nqv8HB6f/Bgal/woKmv8REYX/ExN//AoKaaMGBlEgAAAAAAsL + qF8ODo3oAAAFfAAAARwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAkJt6ULC4rtAQEIgzExodA6Osr+NjbE/zIyu/4uLrb+KSmy/ycnqv4oKJj+CwsyiQQE + JwoAAAAAAAAAAAoKqgUMDLHXBwdAsQAAAE4AAAEDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKsSkMDKT6BAQxsAkJHD5ERMK0TEzR/khIyv5ERMP+QUG7/z8/ + sf4zM5DZBQUTIwAAAAAAAAAAAAAAAAAAAAALC7BpDg6L6AAAAXgAAAEXAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqQYNDaPrCAhHvAUFESAnJ24CSkrFUFNT + zrxWVsb7UlK29T4+k6kiIl0jGxtOAQAAAAAAAAAAAAAAAAAAAAAKCrMODQ2x7AUFNqEAAAA1AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqiYODp3+BQUqlAIC + DA4AAAAAAAAAABYWbysJCaDzAgIeYBwcSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgq0eQkJ + iaUBARgSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK + qlcODpX6AQEKXQEBDAMAAAAACQlnAgkJgLYICF66AgITFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAYGgwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAsLqIsLC3LaAAAEMQAAAAAAAAAABweHSg0NlvcBAQ9dAQERBQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqMIGBkGjAQEOEwAAAAAAAAAACAi7ogkJds0AAAFzAAAAQQAA + ABMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqdCQ0NovIBARFcAQESBAAAAAAAAAAACAiyIgoK + t9ILC4DXBAQrngAAAHMAAABBAAAAEgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmQSAoKd9EAAAgoAAAAAAAA + AAAAAAAAAAAAAAkJrgoKCrOCDQ2s8wwMedwEBCafAAAAbwAAAC0AAAIDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmRnwQE + N4MBARYKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqzGwoKtpcODqn1CgprxwAACFIAAAMJAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAICK4QCQmiyQEBESEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrAdCgqieQUF + ThkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAICLAFBQWDKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//8P///wAA///wf/// + AAD///h///8AAP//+D7//wAA///8PH//AAD///w8f/8AAP///Bw//wAA//P+HD//AAD/wH4MP/8AAP+A + Hww//wAA/wAPDD//AAD/AAcEP/8AAP8AA4R//wAA/wADhH//AAD/AAEMP/8AAP+AAAw//wAA/4AADD// + AAD/wAAcH/8AAP/AABwf/wAAv+AAHg//AAAP8AAPD/8AAAP8AAAH/wAAAH8AAA//AADADAAAD/8AAPAA + AAA//wAA/AAAAA//AAD/AHAAB8AAAP/j/AAAAAAA///8AAAAAAD4ABwAAAMAAPAABAAAfwAA8AAAAAH/ + AAD8AAAAAAcAAP//wEAABwAA///gQAADAAD///HAAEMAAP///+AAwQAA////4AHhAAD////gAeEAAP// + /+GH8QAA////4Q/7AAD////jD/8AAP///+MD/wAA////wwD/AAD////HgH8AAP///8fgfwAA////j/j/ + AAD///+f//8AACgAAAAgAAAAQAAAAAEAIAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiaBgQEPm8AAAIvAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ2nxAEB + EHoAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAALC7FbCQlVxgAAAC4AAAAAAAAAAAAAAAAAAAcEAAABBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAoKtgYNDZ3hAAAHbgAAAAMAAAAAAAAAAAgIWG8AAABIAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLr4oICEC6AAAAIAAAAAAAAAAADw+e0AICEXcAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQELAQAA + AhYAAAAvAAAAKwAAAA4AAAAAAAAAAAAAAAAAAAAACgq2KA0Nhu4AAAFaAAAAAQAAAAANDaDaBAQdhgAA + AQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAHBzxbDQ1b1BERYOoQEEPZBQUUnQAAAEIAAAAFAAAAAAAAAAAAAAAADAysyAUFJqQAAAAQAAAAAA0N + od8EBB2CAAABAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAFhagIBAQqfoJCZ7/Cgqa/w4OjP8WFnH+Dg40zwAAAF0AAAAHAAAAAAAAAAAKCrNtDAxi3QAA + ADsAAAAADAyn5QMDGHUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAaGslGDg65/wUFqP8GBqb/Bgak/woKmf8UFHr/EBA71wAAAFYAAAADAAAAAAkJ + qBoQEI/8AAADSAAAAAAMDKfnAgIOZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZzBoUFMH9BQWs/wYGp/8GBqf/Bgam/woKm/8VFXf/DAwpwQAA + AC8AAAAACQmOQw0Nd+cAAAchAAAAAA0NpucBAQxqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoay64KCrf/BQWp/wYGp/8GBqf/Bgal/wwM + lf8XF2f6AgIJgAcHKgoKCo+jCAhFqgEBCwYAAAAADQ2k4gQEGY8AAAAGAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHx/RICIiyfAKCrT/BQWo/wYG + p/8GBqf/Bwei/xISg/8NDTLGAgIlIwwMm/ECAhZSAAAAAAAAAAAKCq/UCQlAxQAAACQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMjLTRDU1 + zPYWFrj/BQWq/wYGp/8GBqb/DQ2T/xcXVOIDAy9WDAx25wAABDIAAAAAAAAAAAgIvFMODovxAAAEaQAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRkAAAAcAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAARETWOExM1N87O8f/JSW6/yAgtf8tLaz/KChx7QMDH4kSEnH1AAAAWgAAAAAAAAAAAAAAAAoK + npEJCUTCAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmSqwUFOpsAAAJRAAAAIAAA + AAUAAAAAAAAAAAAAAAAAAAAATU3OCU1Nw21PT8S+Tk7B2jo6vNsNDZbsCwuK+xMTd/0HBxqqAAAAOgAA + ASAAAAM6AgIjXxMTffoBAQpnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrAFCwuqXwsL + lrgHB0+wAQESdQAAAEMAAAAaAAAABAAAAAAICBkCDQ0lFAgIGkMBAQ9qAwMRWiMjrvsZGaz/DQ2T/hUV + cf0MDELSDg5k4w4Oe/QKCor2DQ2G4QQEJSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAACgqyAQoKrkgMDK25Cwt84QcHQLsCAg9+AAAGUQUFMYgKCmjUDQ2V9wwMm+4JCZX2EBCE6AgI + pv8GBqX/CQmc/wsLk/8JCXTsBgZspgUFalsEBD8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrUuCgqymwwMpfMMDJn4CgqWxQkJkmwICIkVCAiiAgYG + ujgMDMGwBga2/wUFqf8GBqb/CgqZ/w4OXusEBBWVBQUchwEBC3AAAAA0AAAABQAAAAAAAAAAAAAAAAAA + AQEAAAAGAAAADgAAAg0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgaPDQYGihQAAAAAAAAAAAAA + AAAAAAAAAAAAABYWvxEfH7PdEhKw/wUFqv8ICKL/DQ2P/xERff8ODl7fDw+F5AkJSMUAAANnAAAAJwAA + ATABAQtSBAQlgQcHPacJCU+9BQU2aAAAAAAAAAAAAAAAAAAACgkAAAAaAAAAHQAAACAAAAQgAAAEIAAA + ACAAAAAcAAAAFwAAAAQAAAAACgqrDQYGqPQeHovbHh67/gYGrf8HB6T/DQ2P/wkJOscBARRJCQljxQ4O + eesKCmzdDAyJ8A0Nn+kMDKK2DAyifQwMlj0KCnEDAAAAAAAAAAAAAAAABgZ9mAkJY9EKCmHXCwth2AsL + YdkLC2HZCgpd1wsLV9MJCT2/AAACYwAABA4EBH40Cwue/wICFGYuLqqGNzfA/xsbsv8XF5//GBhn7A4O + auoMDFPfAwMmnwUFVU4ICIoZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLcaCAi4XAkJ + sXoJCax/CQmsegkJr3IJCbJpCgqucQwMqbUMDHXfAQEOgAICMm8QEIr9AQEPRAcHk3klJYrbSEi93zEx + tvINDZ/9Cgqb/xAQh/8SEk7lAAACWAAADQEAAAgJAAAAHQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKs1QKCqfrCAiK7w0NcdcCAiEWBwefgQUF + QbcICDYxBASk6wUFqf8GBqb/CQmd/xUVeP8ICB6sAgIXVwkJXLUICEKyAAAAOQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGwR0HB7dyBwdwKAAA + AAAICKwyCwuI6ggILI0cHLz/ERGw/wkJqP8GBqX/DQ2S/xERbvMLC3CnCAhxIw0NpawDAx2JAAABDgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCrCtBQU1rC8vlsE9Pcn/Nze+/zAwtv8tLaf/FBRLnAUFLAQAAAAACgqyKwoK + cNMAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKrFAKCmDSDg4sHEdHvXNSUszfUFC8+js7la4XF0MTAAAAAAAA + AAAAAAAADAyutwICGX0AAAEGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwupdggIR64DAw4HAAAAAA4Of4UEBDx8GhpDAQAA + AAAAAAAAAAAAAAAAAAAKCrA1BgZpUAAAEQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKSpAwMhagAAAAAGBngiCgp51wAA + DRkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLks8AAAsnAAAAAAgI + tlcICGrGAAAFYgAAACMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCZYjBwdZrwEB + DggAAAAAAAAAAAkJs1oMDJnXBwdDtAAAA2EAAAEWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJ + m3gCAiFKAAAAAAAAAAAAAAAAAAAAAAoKtwwLC7J5DAyS0QEBFzQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAABgaTRAMDPQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCaYBAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA//j////8f////HP///wz///+Mf/8HhH//AcR//gDE//4ARP/+AET//wAEf/8ADH//gAw/x8A + OP8HgAD/AIAA/8AAAf/4AABw/nwAAOAEAADgAAAf4AAAA//wAAP/+IAB///AEf//wDj//8R4///I//// + yD///4wf//+eH///n78oAAAAEAAAACAAAAABACAAAAAAAEAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABARTAQUFPncAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC5aCAAACKAAAAAACAhgwAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAMFAAAAFgAAAAMAAAAACAicLAUFMogAAAAACQlbqgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCkwICwt3yg4OcvAKCi6rAAAAGgAAAAAKCnquAgI0EwgIX68AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAADw+AGAsLtP4GBqb/DAyV/wwMN7sCAhcMDAyPkAICNhoHB1qnAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGcevBwer/wYGpv8PD4j9BgYiXQgIYaQDA0kBCQlrwwAA + AAoAAAAAAAAAAAAAAAAAAAAAAAACDQAAAAAAAAAAJyenETc3y8MbG7T/GBim/xERRasHBzuaAAAAAAkJ + lXUCAhJYAAAAAAAAAAAAAAAAAAAAAAgIimsEBDp2AAAELwMDCwcmJmsDLCxyYCMjZ54VFZ74Dw9l6QYG + KoQGBkuhCQlNmgAAAAAAAAAAAAAAAAAAAAAAAAAABweNEgoKp3IICGqyBwdZpgoKhpMJCaOHCgqo5QcH + pP8LC4D1BQVChwICGywAAAABAAAAAAAAAAIAAAAGAAAAAAAADwIBASMOAgJDEwMDPxUBASINAgIzARER + sXwVFaj2CAih/w0NaekJCVGuBgY6lgYGTZcJCWmWCQljWQAAAAAGBposCQmLoAoKhqsKCoiiCwt7rgMD + InQICHaoDg5YajAwru4bG5f2DQ148gYGM4sEBEwJAwM5CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAICLVXCQmJmAUFazIICEuYDg6u+ggIpP8PD2XnBwdVdgYGQYgAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAACQl9nzAwkpRCQr/2JSVzlwMDLwELC6JtAAAGMQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJbo4JCUQKBwdRfAAAAAAAAAAABQV6DQMDShQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFWQkFBUFrBQV2FQcHb5YBARJPAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBpIvAQEbEwAAAAAFBXkDCgqpUwICJA0AAAAAAAAAAPx/ + AAD+XwAA4k8AAMEfAADAHwAA4A8AAGBPAAAADwAAgAQAAIAAAACAAQAA/AAAAP+AAAD/jAAA/wMAAP8j + AAA= + + + + speed100fpmToolItem + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Maximum + + + F1 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.TabPage, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + menuStrip + + + group2MenuItem + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + speed2fpmMenuItem + + + System.Windows.Forms.ToolStripDropDownButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 924, 24 + + + pauseMenuItem + + + 30 fps (200%) + + + producerComboBoxToolItem + + + 20, 20 + + + 116, 22 + + + speedLabelToolItem + + + 100 fps + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + speed50fpmToolItem + + + False + + + Pause + + + System.Windows.Forms.Timer, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Fill + + + toolStrip1 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Maximum + + + tabControl + + + System.Windows.Forms.ToolStripSeparator, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Start + + + 80 fps + + + stateLabelBarItem + + + 779, 17 + + + System.Windows.Forms.ToolStripProgressBar, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 23, 22 + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + TextBeforeImage + + + Main + + + 0, 24 + + + 181, 22 + + + timer + + + 100, 16 + + + False + + + 2 + + + 181, 22 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 153, 22 + + + False + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 1 + + + 61, 20 + + + 0 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + menuStrip + + + 153, 22 + + + Login + + + programMenuItem + + + 0 + + + 1 + + + 0, 674 + + + group2ToolItem + + + infoWebBrowser + + + Program + + + group1MenuItem + + + 924, 22 + + + onlineButton + + + Check for Updates + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 44, 20 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + speed80fpmToolItem + + + pauseToolItem + + + 916, 599 + + + $this + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 22,5 fps (150%) + + + MiddleRight + + + 15 fps (100%) + + + Magenta + + + 102, 6 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 105, 22 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + pluginSettingsMenuItem + + + 105, 22 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + progressBarItem + + + updateMenuItem + + + toolStrip + + + tutorialsMenuItem + + + 200, 25 + + + Magenta + + + System.Windows.Forms.TabControl, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 171, 22 + + + 130, 17 + + + loginButton + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Magenta + + + 8 fps + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Faster + + + speed2fpmToolItem + + + 153, 22 + + + [username] + + + 924, 696 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Magenta + + + 153, 22 + + + statusStrip1 + + + speedMenuItem + + + 0 + + + Language + + + English + + + Welcome + + + speed100fpmMenuItem + + + speed50fpmMenuItem + + + $this + + + 4, 22 + + + [fps] + + + startMenuItem + + + websiteMenuItem + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 153, 22 + + + 50 fps + + + stopToolItem + + + forumMenuItem + + + versionButton + + + $this + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 924, 25 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Magenta + + + 153, 22 + + + System.Windows.Forms.ToolStripStatusLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + stepCounterBarItem + + + Speed: + + + 96, 22 + + + System.Windows.Forms.ToolStripSeparator, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + [stepcounter] + + + Help + + + 171, 22 + + + True + + + 0, 24 + + + 223, 17 + + + 0, 0 + + + 0, 674 + + \ No newline at end of file diff --git a/AntMe/PluginItem.cs b/AntMe/PluginItem.cs new file mode 100644 index 0000000..6849d95 --- /dev/null +++ b/AntMe/PluginItem.cs @@ -0,0 +1,182 @@ +using System; + +using AntMe.SharedComponents.Plugin; + +namespace AntMe.Gui { + /// + /// class, that represents a plugin + /// + internal sealed class PluginItem { + private readonly IConsumerPlugin consumer; + private readonly IProducerPlugin producer; + private readonly string name; + private readonly string description; + private readonly Version version; + private readonly Guid guid; + private readonly CustomStateItem[] writeCustomStates; + private readonly CustomStateItem[] readCustomStates; + + + /// + /// Creates an instance of Plugin-Item, based on a producer. + /// + /// Producer-Plugin + /// List of custom states for write-access + /// List of custom states for read-access + public PluginItem(IProducerPlugin plugin, CustomStateItem[] writeCustomStates, CustomStateItem[] readCustomStates) + : this(writeCustomStates, readCustomStates, plugin) { + + // Check for null + if (plugin == null) { + throw new ArgumentNullException("plugin", Resource.PluginItemConstructorPluginIsNull); + } + + producer = plugin; + } + + /// + /// Creates an instance of Plugin-Item, based on a producer. + /// + /// Consumer-Plugin + /// List of custom states for write-access + /// List of custom states for read-access + public PluginItem(IConsumerPlugin plugin, CustomStateItem[] writeCustomStates, CustomStateItem[] readCustomStates) + : this(writeCustomStates, readCustomStates, plugin) + { + // Prüfen, ob Plugin angegeben wurde + if (plugin == null) { + throw new ArgumentNullException("plugin", Resource.PluginItemConstructorPluginIsNull); + } + + consumer = plugin; + } + + /// + /// Private constructor for a common way to handle attributes. + /// + /// Plugin + /// List of custom states for write-access + /// List of custom states for read-access + private PluginItem(CustomStateItem[] writeCustomStates, CustomStateItem[] readCustomStates, IPlugin plugin) + { + + // Check for null + if (plugin == null) { + throw new ArgumentNullException("plugin", Resource.PluginItemConstructorPluginIsNull); + } + + // Check for valid name + if (plugin.Name == string.Empty) { + throw new ArgumentException(Resource.PluginItemConstructorPluginHasNoName, "plugin"); + } + + name = plugin.Name; + description = plugin.Description; + guid = plugin.Guid; + version = plugin.Version; + + // Custom states + this.writeCustomStates = writeCustomStates; + if (this.writeCustomStates == null) { + this.writeCustomStates = new CustomStateItem[0]; + } + this.readCustomStates = readCustomStates; + if (this.readCustomStates == null) { + this.readCustomStates = new CustomStateItem[0]; + } + } + + /// + /// Gets the consumer-plugin or null, if its a producer-plugin. + /// + public IConsumerPlugin Consumer { + get { return consumer; } + } + + /// + /// Gets the producer-plugin or null, if its a consumer-plugin. + /// + public IProducerPlugin Producer { + get { return producer; } + } + + /// + /// True, if its a consumer-plugin, false in case of a producer-plugin. + /// + public bool IsConsumer { + get { return consumer != null; } + } + + /// + /// Gets the name of the Plugin. + /// + public string Name { + get { return name; } + } + + /// + /// Gets a short description of this Plugin. + /// + public string Description { + get { return description; } + } + + /// + /// Gets the plugin-version. + /// + public Version Version { + get { return version; } + } + + /// + /// Gets the plugin-. + /// + public Guid Guid { + get { return guid; } + } + + /// + /// Compares two instances of . + /// + /// other instance of + /// true, if equal + public override bool Equals(object obj) { + + // Check for right datatype + if (!(obj is PluginItem)) { + return false; + } + + PluginItem other = (PluginItem) obj; + + // compare guid + if (other.guid != guid) { + return false; + } + + // compare version + if (other.version != version) { + return false; + } + + // seams to be equal + return true; + } + + /// + /// Generates a hash for this instance. + /// + /// + public override int GetHashCode() { + return guid.GetHashCode(); + } + + /// + /// Gives the name of this plugin. + /// + /// Name of plugin + public override string ToString() { + return Name; + } + } +} \ No newline at end of file diff --git a/AntMe/PluginManager.cs b/AntMe/PluginManager.cs new file mode 100644 index 0000000..0d7117d --- /dev/null +++ b/AntMe/PluginManager.cs @@ -0,0 +1,1163 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Reflection; +using System.Security; +using System.Threading; +using System.Xml.Serialization; + +using AntMe.Gui.Properties; +using AntMe.SharedComponents.Plugin; +using AntMe.SharedComponents.States; + +namespace AntMe.Gui { + /// + /// Manager for all plugins and host for central game-loop + /// + /// Tom Wendel (tom@antme.net) + internal sealed class PluginManager { + #region Constants + + private const int FRAMERATE_SPAN = 10; + + #endregion + + #region Variables + + // Pluginlists + private readonly Dictionary activeConsumers; + private readonly Dictionary consumerList; + private readonly Dictionary producerList; + private PluginItem activeProducer; + + private Configuration config; + private PluginItem visiblePlugin; + private readonly List exceptions; + private PluginState lastState = PluginState.NotReady; + private bool ignoreStateupdate = false; + + private Thread requestThread; + + private bool speedLimiter; + private float frameLimit; + private float frameLimitMs; + private SimulationState lastSimulationState; + + private readonly float[] frameRateHistory; + private bool frameRateInvalidate; + private float frameRateAverage; + private int frameRatePosition; + + private readonly SynchronizationContext context = SynchronizationContext.Current; + + private readonly string configPath = Environment.GetFolderPath( + Environment.SpecialFolder.ApplicationData) + + Resources.ConfiguationPath; + + #endregion + + #region Constructor + + public PluginManager() { + producerList = new Dictionary(); + consumerList = new Dictionary(); + activeConsumers = new Dictionary(); + exceptions = new List(); + config = new Configuration(); + + frameRateHistory = new float[FRAMERATE_SPAN]; + + // Default Speed + SetSpeedLimit(true, 15.0f); + } + + #endregion + + #region Plugin Discovery + + /// + /// Search in default folders for a new plugin. + /// + public void SearchForPlugins() { + + string path = Directory.GetCurrentDirectory(); + + // List all potential files + List files = new List(); + files.AddRange(Directory.GetFiles(path, Resources.PluginSearchFilter)); + if (Directory.Exists(path + Resources.PluginSearchFolder)) { + files.AddRange(Directory.GetFiles(path + Resources.PluginSearchFolder, Resources.PluginSearchFilter)); + } + + // Enumerate all found files + for (int i = 0; i < files.Count; i++) { + CheckForPlugin(files[i]); + } + + // Check known Plugins + for (int i = 0; i < config.knownPluginFiles.Count; i++) { + if (!files.Contains(config.knownPluginFiles[i])) { + if (!CheckForPlugin(config.knownPluginFiles[i])) { + config.knownPluginFiles.RemoveAt(i); + i--; + } + } + } + } + + /// + /// Checks a single file for a new plugin. + /// + /// filename + /// true, if there are valid plugins inside + public bool CheckForPlugin(string filename) { + try { + FileInfo info = new FileInfo(filename); + Assembly assembly = Assembly.LoadFile(info.FullName); + if (addPlugin(assembly)) { + if (!config.knownPluginFiles.Contains(info.FullName)) { + config.knownPluginFiles.Add(info.FullName); + } + return true; + } + } + catch (FileLoadException ex) { + // Problems to open the file + exceptions.Add(ex); + } + catch (BadImageFormatException ex) { + // There is a wrong fileformat + exceptions.Add(ex); + } + catch (SecurityException ex) { + // no accessrights + exceptions.Add(ex); + } + catch (MissingMethodException ex) { + // problems with plugin + exceptions.Add(ex); + } + catch (TargetInvocationException ex) { + // missing references + exceptions.Add( + new Exception( + string.Format(Resource.PluginManagerMissingReferences, filename), + ex)); + } + catch (ReflectionTypeLoadException ex) { + // missing references + exceptions.Add( + new Exception( + string.Format(Resource.PluginManagerMissingReferences, filename), + ex)); + } + catch (Exception ex) { + // unknown exception + exceptions.Add(ex); + } + return false; + } + + /// + /// search in given assembly for a new plugin + /// + /// assembly to search in + /// true, if there are valid plugins inside + private bool addPlugin(Assembly assembly) { + bool hit = false; + + // Get all includes Types + foreach (Type type in assembly.GetExportedTypes()) { + // Find the attribute + List readCustomStates = new List(); + List writeCustomStates = new List(); + + foreach (CustomAttributeData customAttribute in CustomAttributeData.GetCustomAttributes(type)) { + string name; + string dataType; + string description; + switch (customAttribute.Constructor.ReflectedType.FullName) { + case "AntMe.SharedComponents.Plugin.ReadCustomStateAttribute": + name = string.Empty; + dataType = string.Empty; + description = string.Empty; + foreach (CustomAttributeNamedArgument argument in customAttribute.NamedArguments) { + switch (argument.MemberInfo.Name) { + case "Name": + name = (string) argument.TypedValue.Value; + break; + case "Type": + dataType = (string) argument.TypedValue.Value; + break; + case "Description": + description = (string) argument.TypedValue.Value; + break; + } + } + readCustomStates.Add(new CustomStateItem(name, dataType, description)); + break; + case "AntMe.SharedComponents.Plugin.WriteCustomStateAttribute": + name = string.Empty; + dataType = string.Empty; + description = string.Empty; + foreach (CustomAttributeNamedArgument argument in customAttribute.NamedArguments) { + switch (argument.MemberInfo.Name) { + case "Name": + name = (string) argument.TypedValue.Value; + break; + case "Type": + dataType = (string) argument.TypedValue.Value; + break; + case "Description": + description = (string) argument.TypedValue.Value; + break; + } + } + writeCustomStates.Add(new CustomStateItem(name, dataType, description)); + break; + } + } + + // If type has an attribute, search for the interfaces + foreach (Type plugin in type.GetInterfaces()) { + // Producer found + if (plugin == typeof (IProducerPlugin)) { + // Create an instance of plugin and add to list + PluginItem item = null; + try { + IProducerPlugin producerPlugin = + (IProducerPlugin) Activator.CreateInstance(type, false); + item = + new PluginItem(producerPlugin, writeCustomStates.ToArray(), readCustomStates.ToArray()); + hit = true; + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerProducerPluginCommonProblems, + type.FullName, + assembly.GetFiles()[0].Name), + ex)); + } + + // Warnings, of there is another Version of that plugin + if (item != null && producerList.ContainsKey(item.Guid)) { + if (producerList[item.Guid].Version > item.Version) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerProducerPluginNewerVersionLoaded, + item.Name, + item.Version))); + item = null; + } + else if (producerList[item.Guid].Version < item.Version) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerProducerPluginNewerVersion, + item.Name, + item.Version))); + DeactivateProducer(item.Guid); + producerList.Remove(item.Guid); + } + else { + // Samle plugin still loaded + item = null; + } + } + + // add to list + if (item != null) { + // Check, if plugin is preselected or saved as selected + producerList.Add(item.Guid, item); + if (config.selectedPlugins.Contains(item.Guid) || + (!config.loaded && + type.GetCustomAttributes(typeof (PreselectedAttribute), false).Length > 0)) { + ActivateProducer(item.Guid); + } + + // Load Settings + if (File.Exists(configPath + item.Guid + Resources.PluginSettingsFileExtension)) { + try { + item.Producer.Settings = + File.ReadAllBytes( + configPath + item.Guid + Resources.PluginSettingsFileExtension); + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerProducerPluginSettingsLoadFailed, + item.Name, + item.Version), + ex)); + } + } + } + } + + // Consumer found + else if (plugin == typeof (IConsumerPlugin)) { + // Create an instance of plugin and add to list + PluginItem item = null; + try { + IConsumerPlugin consumerPlugin = + (IConsumerPlugin) Activator.CreateInstance(type, false); + item = + new PluginItem(consumerPlugin, writeCustomStates.ToArray(), readCustomStates.ToArray()); + hit = true; + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerConsumerPluginCommonProblems, + type.FullName, + assembly.GetFiles()[0].Name), + ex)); + } + + // Warnings, of there is another Version of that plugin + if (item != null && consumerList.ContainsKey(item.Guid)) { + if (consumerList[item.Guid].Version > item.Version) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerConsumerPluginNewerVersionLoaded, + item.Name, + item.Version))); + item = null; + } + else if (consumerList[item.Guid].Version < item.Version) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerConsumerPluginNewerVersion, + item.Name, + item.Version))); + DeactivateConsumer(item.Guid); + consumerList.Remove(item.Guid); + } + else { + // Same plugin still loaded + item = null; + } + } + + // add to list + if (item != null) { + consumerList.Add(item.Guid, item); + + // Check, if plugin is preselected or saved as selected + if (config.selectedPlugins.Contains(item.Guid) || + (!config.loaded && + type.GetCustomAttributes(typeof (PreselectedAttribute), false).Length > 0)) { + ActivateConsumer(item.Guid); + } + + // Load Settings + if (File.Exists(configPath + item.Guid + Resources.PluginSettingsFileExtension)) { + try { + item.Consumer.Settings = + File.ReadAllBytes( + configPath + item.Guid + Resources.PluginSettingsFileExtension); + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerConsumerPluginSettingsLoadFailed, + item.Name, + item.Version), + ex)); + } + } + } + } + } + } + return hit; + } + + #endregion + + #region Properties + + /// + /// Gives a list of available producer-plugins. + /// + public PluginItem[] ProducerPlugins { + get { + PluginItem[] plugins = new PluginItem[producerList.Count]; + producerList.Values.CopyTo(plugins, 0); + return plugins; + } + } + + /// + /// Gives a list of available consumer-plugins. + /// + public PluginItem[] ConsumerPlugins { + get { + PluginItem[] plugins = new PluginItem[consumerList.Count]; + consumerList.Values.CopyTo(plugins, 0); + return plugins; + } + } + + /// + /// Gives a list of activated consumer-plugins. + /// + public PluginItem[] ActiveConsumerPlugins { + get { + PluginItem[] plugins = new PluginItem[activeConsumers.Count]; + activeConsumers.Values.CopyTo(plugins, 0); + return plugins; + } + } + + /// + /// Returns a list of exceptions that happened during the last call + /// + public List Exceptions { + get { return exceptions; } + } + + /// + /// Gives the active producer-plugin or null, if no plugin is active. + /// + public PluginItem ActiveProducerPlugin { + get { return activeProducer; } + } + + /// + /// Is manager ready to start. + /// + public bool CanStart { + get { return (State == PluginState.Ready || State == PluginState.Paused); } + } + + /// + /// Is manger ready for pause-mode. + /// + public bool CanPause { + get { return (State == PluginState.Running || State == PluginState.Ready); } + } + + /// + /// Is manager still running and can stop. + /// + public bool CanStop { + get { return (State == PluginState.Running || State == PluginState.Paused); } + } + + /// + /// Returns the current state of this manager. + /// + public PluginState State { + get { + if (!ignoreStateupdate) { + PluginState output = PluginState.NotReady; + + // capture producerstate + if (activeProducer != null) { + output = activeProducer.Producer.State; + } + + // check for changes + switch (output) { + case PluginState.NotReady: + case PluginState.Ready: + if (lastState == PluginState.Running || + lastState == PluginState.Paused) { + // Producer switched from running/paused to notReady or ready + // All running consumer have to stop + foreach (PluginItem item in activeConsumers.Values) { + if (item.Consumer.State == PluginState.Running || + item.Consumer.State == PluginState.Paused) { + item.Consumer.Stop(); + } + } + } + break; + case PluginState.Running: + if (lastState == PluginState.NotReady || + lastState == PluginState.Ready || + lastState == PluginState.Paused) { + // Producer switched from somewhere to running + // All ready or paused consumer have to start + foreach (PluginItem item in activeConsumers.Values) { + if (item.Consumer.State == PluginState.Paused || + item.Consumer.State == PluginState.Ready) { + item.Consumer.Start(); + } + } + } + break; + case PluginState.Paused: + if (lastState == PluginState.Running || + lastState == PluginState.Ready) { + // Producer switched to pause-mode + // All ready or running consumer have to pause + foreach (PluginItem item in activeConsumers.Values) { + if (item.Consumer.State == PluginState.Running || + item.Consumer.State == PluginState.Ready) { + item.Consumer.Pause(); + } + } + } + break; + } + + // Start requestLoop, if needed + if ((output == PluginState.Running || output == PluginState.Paused) && requestThread == null) { + requestThread = new Thread(requestLoop); + requestThread.IsBackground = true; + requestThread.Priority = ThreadPriority.Normal; + requestThread.Start(); + } + + // return + lastState = output; + return output; + } + else { + return lastState; + } + } + } + + /// + /// Gives the number of current simulation-round. + /// + public int CurrentRound { + get { + if (lastSimulationState != null) { + return lastSimulationState.CurrentRound; + } + return 0; + } + } + + /// + /// Gives the number of total rounds for the current simulation. + /// + public int TotalRounds { + get { + if (lastSimulationState != null) { + return Math.Max(lastSimulationState.CurrentRound, lastSimulationState.TotalRounds); + } + return 0; + } + } + + /// + /// Gives the current frame-rate for this simulation. + /// + public float FrameRate { + get { + // calculate new average + if (frameRateInvalidate) { + frameRateAverage = 0; + for (int i = 0; i < FRAMERATE_SPAN; i++) { + frameRateAverage += frameRateHistory[i]; + } + frameRateAverage /= FRAMERATE_SPAN; + frameRateInvalidate = false; + } + + // deliver + return frameRateAverage; + } + private set { + // write new value in ringbuffer + frameRateInvalidate = true; + frameRateHistory[frameRatePosition++%FRAMERATE_SPAN] = value; + } + } + + /// + /// Gives the current frame-rate-limit, if limiter is enabled. + /// + public float FrameLimit { + get { + if (FrameLimiterEnabled) { + return frameLimit; + } + return 0.0f; + } + } + + /// + /// Gives the state of the frame-rate-limiter. + /// + public bool FrameLimiterEnabled { + get { return speedLimiter; } + } + + /// + /// Gives the current configuration. + /// + public Configuration Configuration { + get { return config; } + } + + #endregion + + #region Methods + + /// + /// drops a consumer from active list. + /// + /// guid of plugin to drop + public void DeactivateConsumer(Guid guid) { + // Check, if plugin exists + if (!consumerList.ContainsKey(guid)) { + throw new InvalidOperationException(Resource.PluginManagerDeactivateConsumerNotInList); + } + + // Drop from active list + lock (activeConsumers) { + if (activeConsumers.ContainsKey(guid)) { + PluginItem plugin = activeConsumers[guid]; + + activeConsumers.Remove(guid); + config.selectedPlugins.Remove(guid); + + // Stop, if still running + if (plugin.Consumer.State == PluginState.Running || + plugin.Consumer.State == PluginState.Paused) { + plugin.Consumer.Stop(); + } + } + } + } + + /// + /// Adds a plugin to active list + /// + /// guid of new plugin + public void ActivateConsumer(Guid guid) { + // Check, if plugin exists + if (!consumerList.ContainsKey(guid)) { + throw new InvalidOperationException(Resource.PluginManagerActivateConsumerNotInList); + } + + // Add to list + lock (activeConsumers) { + if (!activeConsumers.ContainsKey(guid)) { + PluginItem plugin = consumerList[guid]; + + // Activate, if simulation still running + if (State == PluginState.Running) { + plugin.Consumer.Start(); + } + else if (State == PluginState.Paused) { + plugin.Consumer.Pause(); + } + + activeConsumers.Add(guid, plugin); + + // mark as selected in config + if (!config.selectedPlugins.Contains(guid)) { + config.selectedPlugins.Add(guid); + } + } + } + } + + /// + /// Deactivates the given producer + /// + /// guid of producer + public void DeactivateProducer(Guid guid) { + ignoreStateupdate = true; + + if (activeProducer != null && activeProducer.Guid == guid) { + // unhook producer + Stop(); + activeProducer = null; + config.selectedPlugins.Remove(guid); + } + ignoreStateupdate = false; + } + + /// + /// Changes the active Producer + /// + /// guid of new producer + public void ActivateProducer(Guid guid) { + ignoreStateupdate = true; + // check, if plugin with that guid exists + if (!producerList.ContainsKey(guid)) { + throw new InvalidOperationException(Resource.PluginManagerActivateProducerNotInList); + } + + // check, if same plugin is still active + if (activeProducer == null || activeProducer.Guid != guid) { + // unhook old producer + if (activeProducer != null) { + DeactivateProducer(activeProducer.Guid); + } + + // hook the new one + activeProducer = producerList[guid]; + + if (!config.selectedPlugins.Contains(guid)) { + config.selectedPlugins.Add(guid); + } + } + ignoreStateupdate = false; + } + + /// + /// Starts the manager, of its ready + /// + public void Start() { + ignoreStateupdate = true; + + // Start the producer + lock (activeProducer) { + if (activeProducer != null && + (activeProducer.Producer.State == PluginState.Ready || + activeProducer.Producer.State == PluginState.Paused)) { + activeProducer.Producer.Start(); + } + } + + ignoreStateupdate = false; + } + + /// + /// pause the manager + /// + public void Pause() { + ignoreStateupdate = true; + + // Suspend the producer + lock (activeProducer) { + if (activeProducer != null && + (activeProducer.Producer.State == PluginState.Running || + activeProducer.Producer.State == PluginState.Ready)) { + activeProducer.Producer.Pause(); + } + } + + ignoreStateupdate = false; + } + + /// + /// Stops the manager + /// + public void Stop() { + ignoreStateupdate = true; + + lock (activeProducer) { + if (activeProducer != null && + (activeProducer.Producer.State == PluginState.Running || + activeProducer.Producer.State == PluginState.Paused)) { + activeProducer.Producer.Stop(); + } + } + + ignoreStateupdate = false; + } + + /// + /// Loads the settings to configuration + /// + public void LoadSettings() { + ignoreStateupdate = true; + // check, if configfile exists + if (File.Exists(configPath + Resources.GlobalSettingsFileName)) { + // read configfile + FileStream file = File.Open(configPath + Resources.GlobalSettingsFileName, FileMode.Open); + + try { + XmlSerializer serializer = new XmlSerializer(typeof (Configuration)); + config = (Configuration) serializer.Deserialize(file); + config.loaded = true; + SetSpeedLimit(config.speedLimitEnabled, config.speedLimit); + } + catch (Exception ex) { + throw new Exception( + Resource.PluginManagerSettingsLoadFailed, + ex); + } + finally { + file.Close(); + } + } + ignoreStateupdate = false; + } + + /// + /// Saves the settings of plugin-manager to configuration-file. + /// + public void SaveSettings() { + ignoreStateupdate = true; + if (!Directory.Exists(configPath)) { + Directory.CreateDirectory(configPath); + } + + XmlSerializer serializer = new XmlSerializer(typeof (Configuration)); + MemoryStream puffer = new MemoryStream(); + serializer.Serialize(puffer, config); + File.WriteAllBytes(configPath + Resources.GlobalSettingsFileName, puffer.ToArray()); + ignoreStateupdate = false; + + // Save also plugin-Settings + // Producer-Stuff + foreach (PluginItem plugin in producerList.Values) { + try { + byte[] temp = plugin.Producer.Settings; + if (temp != null && temp.Length > 0) + File.WriteAllBytes(configPath + plugin.Guid + Resources.PluginSettingsFileExtension, + temp); + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerProducerPluginSettingsSaveFailed, plugin.Name, plugin.Version), + ex)); + } + } + + // Consumer-Stuff + foreach (PluginItem plugin in consumerList.Values) { + try { + byte[] temp = plugin.Consumer.Settings; + if (temp != null && temp.Length > 0) + File.WriteAllBytes( + configPath + plugin.Guid + Resources.PluginSettingsFileExtension, temp); + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerConsumerPluginSettingsSaveFailed, plugin.Name, plugin.Version), + ex)); + } + } + } + + /// + /// Sets the current visible plugin + /// + /// visible Plugin + public void SetVisiblePlugin(Guid guid) { + ignoreStateupdate = true; + // Set old plugin to invisible + if (visiblePlugin != null) { + if (visiblePlugin.IsConsumer) { + try { + visiblePlugin.Consumer.SetVisibility(false); + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerProducerVisibilitySetFailed, + visiblePlugin.Name, + visiblePlugin.Version), + ex)); + } + } + else { + try { + visiblePlugin.Producer.SetVisibility(false); + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerConsumerVisibilitySetFailed, + visiblePlugin.Name, + visiblePlugin.Version), + ex)); + } + } + } + + // Set new plugin to visible + if (producerList.ContainsKey(guid)) { + visiblePlugin = producerList[guid]; + try { + visiblePlugin.Producer.SetVisibility(true); + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerProducerVisibilitySetFailed, + visiblePlugin.Name, + visiblePlugin.Version), + ex)); + } + } + else if (consumerList.ContainsKey(guid)) { + visiblePlugin = consumerList[guid]; + try { + visiblePlugin.Consumer.SetVisibility(true); + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerConsumerVisibilitySetFailed, + visiblePlugin.Name, + visiblePlugin.Version), + ex)); + } + } + else { + visiblePlugin = null; + } + ignoreStateupdate = false; + } + + /// + /// Sets the speed-limitation for running simulations. + /// + /// sets the limitation to enabled + /// limits the speed to a specific frame-rate + public void SetSpeedLimit(bool enabled, float framesPerSecond) { + if (enabled) { + // Check for supported value + if (framesPerSecond <= 0.0f) { + throw new ArgumentOutOfRangeException( + "framesPerSecond", framesPerSecond, Resource.PluginManagerFrameRateTooLow); + } + + frameLimit = framesPerSecond; + frameLimitMs = 1000/framesPerSecond; + speedLimiter = true; + + config.speedLimit = frameLimit; + config.speedLimitEnabled = true; + } + else { + frameLimit = 0.0f; + frameLimitMs = 0.0f; + speedLimiter = false; + + config.speedLimit = 0.0f; + config.speedLimitEnabled = false; + } + } + + #endregion + + #region Requestloop + + /// + /// The game-loop. Runs, until state is set to Ready or notReady + /// + private void requestLoop() { + // Limiter- and frame-rate-handling + Stopwatch watch = new Stopwatch(); + + // Interrupt-Handling + bool interrupt = false; + + // Mainloop + while (activeProducer != null && + (activeProducer.Producer.State == PluginState.Running || + activeProducer.Producer.State == PluginState.Paused)) { + + // request Simulationstate, if loop is not paused + if (activeProducer != null && activeProducer.Producer.State == PluginState.Running) { + watch.Reset(); + watch.Start(); + + // Create new Simulationstate + SimulationState simulationState = new SimulationState(); + + // Request all consumers with CreateState-Method + lock (activeConsumers) { + foreach (PluginItem item in activeConsumers.Values) { + try { + lock (item) { + if (item.Consumer.State == PluginState.Running) { + item.Consumer.CreateState(ref simulationState); + } + } + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerLoopConsumer1Failed, item.Name, item.Version), + ex)); + interrupt = true; + break; + } + } + } + + // Break, if there was an interrupt + if (interrupt) { + break; + } + + // Request producers Simulationstate + lock (activeProducer) { + try { + if (activeProducer != null && activeProducer.Producer.State == PluginState.Running) { + activeProducer.Producer.CreateState(ref simulationState); + } + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerLoopProducerFailed, + activeProducer.Name, + activeProducer.Version), + ex)); + interrupt = true; + break; + } + } + + // Request all consumers with CreatingState-Method + lock (activeConsumers) { + foreach (PluginItem item in activeConsumers.Values) { + try { + lock (item) { + if (item.Consumer.State == PluginState.Running) { + item.Consumer.CreatingState(ref simulationState); + } + } + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerLoopConsumer2Failed, item.Name, item.Version), + ex)); + interrupt = true; + break; + } + } + } + + // On interrupt stop loop + if (interrupt) { + break; + } + + // Request all consumers with CreatedState-Method and also check for interrupt-Request + lock (activeConsumers) { + foreach (PluginItem item in activeConsumers.Values) { + try { + lock (item) { + if (item.Consumer.State == PluginState.Running) { + item.Consumer.CreatedState(ref simulationState); + } + } + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerLoopConsumer3Failed, item.Name, item.Version), + ex)); + interrupt = true; + break; + } + } + } + + // On interrupt stop loop + if (interrupt) { + break; + } + + // Update UI + try { + if (activeProducer != null && activeProducer.Producer.State == PluginState.Running) { + context.Send(delegate { activeProducer.Producer.UpdateUI(simulationState); }, null); + } + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerLoopProducerUIFailed, + activeProducer.Name, + activeProducer.Version), + ex)); + interrupt = true; + break; + } + + foreach (PluginItem item in activeConsumers.Values) { + try { + if (item.Consumer.State == PluginState.Running) { + context.Send(delegate { item.Consumer.UpdateUI(simulationState); }, null); + interrupt |= item.Consumer.Interrupt; + } + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerLoopConsumerUIFailed, item.Name, item.Version), + ex)); + interrupt = true; + break; + } + } + + // On interrupt stop loop + if (interrupt) { + break; + } + + // Save state for statistics + lastSimulationState = simulationState; + + // Framelimiter + if (FrameLimiterEnabled) { + while (watch.ElapsedMilliseconds < frameLimitMs) { + Thread.Sleep(1); + } + } + + // calculation of frame-time + FrameRate = watch.ElapsedMilliseconds > 0 ? 1000/watch.ElapsedMilliseconds : 0; + } + else { + Thread.Sleep(20); + } + } + + // Interrupt + if (interrupt) { + try { + context.Send(delegate { activeProducer.Producer.Stop(); }, null); + } + catch (Exception ex) { + exceptions.Add( + new Exception( + string.Format( + Resource.PluginManagerLoopInterruptFailed, + activeProducer.Name, + activeProducer.Version), + ex)); + } + } + + requestThread = null; + + watch.Reset(); + } + + #endregion + } +} \ No newline at end of file diff --git a/AntMe/Plugins.Designer.cs b/AntMe/Plugins.Designer.cs new file mode 100644 index 0000000..2046bcf --- /dev/null +++ b/AntMe/Plugins.Designer.cs @@ -0,0 +1,146 @@ +namespace AntMe.Gui { + partial class Plugins + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Plugins)); + this.pluginListView = new System.Windows.Forms.ListView(); + this.nameColumn = new System.Windows.Forms.ColumnHeader(); + this.versionColumn = new System.Windows.Forms.ColumnHeader(); + this.descriptionColumn = new System.Windows.Forms.ColumnHeader(); + this.cancelButton = new System.Windows.Forms.Button(); + this.addPluginButton = new System.Windows.Forms.Button(); + this.descriptionLabel = new System.Windows.Forms.Label(); + this.openFileDialog = new System.Windows.Forms.OpenFileDialog(); + this.SuspendLayout(); + // + // pluginListView + // + this.pluginListView.AccessibleDescription = null; + this.pluginListView.AccessibleName = null; + resources.ApplyResources(this.pluginListView, "pluginListView"); + this.pluginListView.BackgroundImage = null; + this.pluginListView.CheckBoxes = true; + this.pluginListView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.nameColumn, + this.versionColumn, + this.descriptionColumn}); + this.pluginListView.Font = null; + this.pluginListView.Groups.AddRange(new System.Windows.Forms.ListViewGroup[] { + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("pluginListView.Groups"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("pluginListView.Groups1")))}); + this.pluginListView.MultiSelect = false; + this.pluginListView.Name = "pluginListView"; + this.pluginListView.ShowItemToolTips = true; + this.pluginListView.UseCompatibleStateImageBehavior = false; + this.pluginListView.View = System.Windows.Forms.View.Details; + this.pluginListView.ItemCheck += new System.Windows.Forms.ItemCheckEventHandler(this.pluginListView_ItemCheck); + // + // nameColumn + // + resources.ApplyResources(this.nameColumn, "nameColumn"); + // + // versionColumn + // + resources.ApplyResources(this.versionColumn, "versionColumn"); + // + // descriptionColumn + // + resources.ApplyResources(this.descriptionColumn, "descriptionColumn"); + // + // cancelButton + // + this.cancelButton.AccessibleDescription = null; + this.cancelButton.AccessibleName = null; + resources.ApplyResources(this.cancelButton, "cancelButton"); + this.cancelButton.BackgroundImage = null; + this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.OK; + this.cancelButton.Font = null; + this.cancelButton.Name = "cancelButton"; + this.cancelButton.UseVisualStyleBackColor = true; + // + // addPluginButton + // + this.addPluginButton.AccessibleDescription = null; + this.addPluginButton.AccessibleName = null; + resources.ApplyResources(this.addPluginButton, "addPluginButton"); + this.addPluginButton.BackgroundImage = null; + this.addPluginButton.Font = null; + this.addPluginButton.Name = "addPluginButton"; + this.addPluginButton.UseVisualStyleBackColor = true; + this.addPluginButton.Click += new System.EventHandler(this.addPluginButton_Click); + // + // descriptionLabel + // + this.descriptionLabel.AccessibleDescription = null; + this.descriptionLabel.AccessibleName = null; + resources.ApplyResources(this.descriptionLabel, "descriptionLabel"); + this.descriptionLabel.Font = null; + this.descriptionLabel.Name = "descriptionLabel"; + // + // openFileDialog + // + this.openFileDialog.FileName = "openFileDialog1"; + resources.ApplyResources(this.openFileDialog, "openFileDialog"); + this.openFileDialog.Multiselect = true; + // + // Plugins + // + this.AcceptButton = this.cancelButton; + this.AccessibleDescription = null; + this.AccessibleName = null; + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackgroundImage = null; + this.CancelButton = this.cancelButton; + this.Controls.Add(this.descriptionLabel); + this.Controls.Add(this.addPluginButton); + this.Controls.Add(this.cancelButton); + this.Controls.Add(this.pluginListView); + this.Font = null; + this.Icon = null; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "Plugins"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.ListView pluginListView; + private System.Windows.Forms.Button cancelButton; + private System.Windows.Forms.ColumnHeader nameColumn; + private System.Windows.Forms.ColumnHeader versionColumn; + private System.Windows.Forms.ColumnHeader descriptionColumn; + private System.Windows.Forms.Button addPluginButton; + private System.Windows.Forms.Label descriptionLabel; + private System.Windows.Forms.OpenFileDialog openFileDialog; + } +} \ No newline at end of file diff --git a/AntMe/Plugins.cs b/AntMe/Plugins.cs new file mode 100644 index 0000000..98f7280 --- /dev/null +++ b/AntMe/Plugins.cs @@ -0,0 +1,119 @@ +using System; +using System.Collections.Generic; +using System.Windows.Forms; + +namespace AntMe.Gui { + /// + /// Window, to manage the plugins + /// + internal sealed partial class Plugins : Form { + private readonly PluginManager manager; + private readonly ListViewGroup consumerGroup; + private readonly ListViewGroup producerGroup; + + private bool ignoreChecks = false; + + public Plugins(PluginManager manager) { + InitializeComponent(); + + // Save Manager + this.manager = manager; + + // prepareing list + producerGroup = pluginListView.Groups["producer"]; + consumerGroup = pluginListView.Groups["consumer"]; + UpdateList(); + } + + private void UpdateList() { + // fill list + pluginListView.Items.Clear(); + + // Producer + foreach (PluginItem plugin in manager.ProducerPlugins) { + ListViewItem item = pluginListView.Items.Add(plugin.Name); + item.Tag = plugin; + item.Checked = (manager.ActiveProducerPlugin == plugin); + item.Group = producerGroup; + item.ToolTipText = plugin.Description; + item.SubItems.Add(plugin.Version.ToString()); + item.SubItems.Add(plugin.Description); + } + + // Consumer + List activeConsumer = new List(manager.ActiveConsumerPlugins); + foreach (PluginItem plugin in manager.ConsumerPlugins) { + ListViewItem item = pluginListView.Items.Add(plugin.Name); + item.Tag = plugin; + item.Checked = (activeConsumer.Contains(plugin)); + item.Group = consumerGroup; + item.ToolTipText = plugin.Description; + item.SubItems.Add(plugin.Version.ToString()); + item.SubItems.Add(plugin.Description); + } + } + + private void addPluginButton_Click(object sender, EventArgs e) { + openFileDialog.InitialDirectory = Application.ExecutablePath; + openFileDialog.FileName = string.Empty; + if (openFileDialog.ShowDialog(this) == DialogResult.OK) { + try { + foreach (string filename in openFileDialog.FileNames) { + manager.CheckForPlugin(filename); + } + if (manager.Exceptions.Count > 0) { + ExceptionViewer problems = new ExceptionViewer(manager.Exceptions); + problems.ShowDialog(this); + manager.Exceptions.Clear(); + } + UpdateList(); + } + catch (Exception ex) { + MessageBox.Show(this, ex.Message); + } + } + } + + private void pluginListView_ItemCheck(object sender, ItemCheckEventArgs e) { + // Ignore automatic checks + if (ignoreChecks) { + return; + } + + ignoreChecks = true; + + // Producer has changed + if (pluginListView.Items[e.Index].Group == producerGroup) { + // Prevent from uncheck + if (e.NewValue == CheckState.Unchecked) { + e.NewValue = CheckState.Checked; + } + else { + foreach (ListViewItem item in pluginListView.Items) { + if (item.Index != e.Index && item.Group == producerGroup) { + item.Checked = false; + } + } + + PluginItem plugin = (PluginItem) pluginListView.Items[e.Index].Tag; + manager.ActivateProducer(plugin.Guid); + } + } + + // Consumer has changed + if (pluginListView.Items[e.Index].Group == consumerGroup) { + PluginItem plugin = (PluginItem) pluginListView.Items[e.Index].Tag; + if (e.NewValue == CheckState.Checked) { + // Activate + manager.ActivateConsumer(plugin.Guid); + } + else { + // Deactivate + manager.DeactivateConsumer(plugin.Guid); + } + } + + ignoreChecks = false; + } + } +} \ No newline at end of file diff --git a/AntMe/Plugins.de.resx b/AntMe/Plugins.de.resx new file mode 100644 index 0000000..8693040 --- /dev/null +++ b/AntMe/Plugins.de.resx @@ -0,0 +1,168 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Beschreibung + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAdRdWVsbGVuBfz///8oU3lzdGVtLldpbmRvd3MuRm9ybXMuSG9yaXpvbnRhbEFsaWdubWVudAEA + AAAHdmFsdWVfXwAIAgAAAAAAAAAKBgUAAAAIcHJvZHVjZXIL + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAtWZXJicmF1Y2hlcgX8////KFN5c3RlbS5XaW5kb3dzLkZvcm1zLkhvcml6b250YWxBbGlnbm1l + bnQBAAAAB3ZhbHVlX18ACAIAAAAAAAAACgYFAAAACGNvbnN1bWVyCw== + + + + + 566, 289 + + + 493, 360 + + + Schließen + + + 2, 360 + + + 135, 23 + + + Plugins hinzufügen... + + + Hier sind alle verfügbaren Plugins für AntMe! aufgelistet. Aktiviere hier die Plugins, die Du zur Simulation verwenden willst. + + + 570, 394 + + \ No newline at end of file diff --git a/AntMe/Plugins.resx b/AntMe/Plugins.resx new file mode 100644 index 0000000..902bcdd --- /dev/null +++ b/AntMe/Plugins.resx @@ -0,0 +1,317 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Plugins + + + System.Windows.Forms.Form, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + 12, 12 + + + 100, 23 + + + descriptionColumn + + + 0 + + + 2, 65 + + + System.Windows.Forms.OpenFileDialog, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + Top, Bottom, Left, Right + + + Name + + + openFileDialog + + + 580, 430 + + + AntMe! Plugins + + + Bottom, Right + + + nameColumn + + + versionColumn + + + 75, 23 + + + Close + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 2, 369 + + + addPluginButton + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + This is a list of all the available plugins. Activate the ones you want to use with AntMe!. + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 6, 13 + + + Description + + + $this + + + Bottom, Left + + + 2 + + + $this + + + + 1 + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Load Plugin... + + + 564, 394 + + + 525, 40 + + + cancelButton + + + Version + + + AntMe-Plugins|*.dll + + + pluginListView + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAhQcm9kdWNlcgX8////KFN5c3RlbS5XaW5kb3dzLkZvcm1zLkhvcml6b250YWxBbGlnbm1lbnQB + AAAAB3ZhbHVlX18ACAIAAAAAAAAACgYFAAAACHByb2R1Y2VyCw== + + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ListView, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 346 + + + 2 + + + 487, 369 + + + $this + + + 134 + + + 0 + + + CenterParent + + + descriptionLabel + + + $this + + + 3 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAhDb25zdW1lcgX8////KFN5c3RlbS5XaW5kb3dzLkZvcm1zLkhvcml6b250YWxBbGlnbm1lbnQB + AAAAB3ZhbHVlX18ACAIAAAAAAAAACgYFAAAACGNvbnN1bWVyCw== + + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 3 + + + 71 + + + 560, 299 + + + 1 + + + True + + + 17, 17 + + \ No newline at end of file diff --git a/AntMe/Program.cs b/AntMe/Program.cs new file mode 100644 index 0000000..cd2c0a8 --- /dev/null +++ b/AntMe/Program.cs @@ -0,0 +1,40 @@ +using System; +using System.Globalization; +using System.Threading; +using System.Windows.Forms; + +using AntMe.Gui.Properties; + +namespace AntMe.Gui { + internal sealed class Program { + [STAThread] + public static void Main(string[] parameter) { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + + bool restart = true; + + while (restart) { + + // Language-Settings + switch (Settings.Default.culture) + { + case "de": + Thread.CurrentThread.CurrentUICulture = new CultureInfo("de"); + Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE"); + break; + case "en": + Thread.CurrentThread.CurrentUICulture = new CultureInfo("en"); + Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US"); + break; + } + + // Run + using (Main form = new Main(parameter)) { + Application.Run(form); + restart = form.Restart; + } + } + } + } +} \ No newline at end of file diff --git a/AntMe/Properties/AssemblyInfo.cs b/AntMe/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..e7a7081 --- /dev/null +++ b/AntMe/Properties/AssemblyInfo.cs @@ -0,0 +1,35 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("AntMe!")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("AntMe! GmbH")] +[assembly: AssemblyProduct("AntMe!")] +[assembly: AssemblyCopyright("Copyright © 2014 AntMe! GmbH")] +[assembly: AssemblyTrademark("AntMe!")] +[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("443ecf28-521f-4641-9ae6-3d8cd1db09f0")] + +// 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 Revision and Build Numbers +// by using the '*' as shown below: +[assembly: AssemblyVersion("1.7.1.331")] +[assembly: AssemblyFileVersion("1.7.1.331")] diff --git a/AntMe/Properties/Resources.Designer.cs b/AntMe/Properties/Resources.Designer.cs new file mode 100644 index 0000000..66a67fb --- /dev/null +++ b/AntMe/Properties/Resources.Designer.cs @@ -0,0 +1,248 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Gui.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("AntMe.Gui.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; + } + } + + /// + /// Looks up a localized string similar to \AntMe\. + /// + internal static string ConfiguationPath { + get { + return ResourceManager.GetString("ConfiguationPath", resourceCulture); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap connection { + get { + object obj = ResourceManager.GetObject("connection", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap debug_messages_32x32 { + get { + object obj = ResourceManager.GetObject("debug_messages_32x32", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap downarrow { + get { + object obj = ResourceManager.GetObject("downarrow", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap error_48X48 { + get { + object obj = ResourceManager.GetObject("error_48X48", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized string similar to AntMe17.conf. + /// + internal static string GlobalSettingsFileName { + get { + return ResourceManager.GetString("GlobalSettingsFileName", resourceCulture); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap offline { + get { + object obj = ResourceManager.GetObject("offline", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap online { + get { + object obj = ResourceManager.GetObject("online", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap pause { + get { + object obj = ResourceManager.GetObject("pause", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap play { + get { + object obj = ResourceManager.GetObject("play", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized string similar to *.dll. + /// + internal static string PluginSearchFilter { + get { + return ResourceManager.GetString("PluginSearchFilter", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to \\plugins. + /// + internal static string PluginSearchFolder { + get { + return ResourceManager.GetString("PluginSearchFolder", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to .conf. + /// + internal static string PluginSettingsFileExtension { + get { + return ResourceManager.GetString("PluginSettingsFileExtension", resourceCulture); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap security_32x32 { + get { + object obj = ResourceManager.GetObject("security_32x32", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap speed { + get { + object obj = ResourceManager.GetObject("speed", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap stop { + get { + object obj = ResourceManager.GetObject("stop", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap uparrow { + get { + object obj = ResourceManager.GetObject("uparrow", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap warning { + get { + object obj = ResourceManager.GetObject("warning", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap welcome { + get { + object obj = ResourceManager.GetObject("welcome", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/AntMe/Properties/Resources.resx b/AntMe/Properties/Resources.resx new file mode 100644 index 0000000..0426194 --- /dev/null +++ b/AntMe/Properties/Resources.resx @@ -0,0 +1,183 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\Resources\welcome.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + \\plugins + Additional Plugin-path for autmated plugin-search (PluginManager.cs) + + + ..\Resources\uparrow.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\downarrow.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\error_48X48.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + .conf + FileExtension for plugin-settings-files (PluginManager.cs) + + + ..\Resources\play.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + AntMe17.conf + Filename of settings-file for global settings (PluginManager.cs) + + + *.dll + Searchpattern for automated plugin-search (PluginManager.cs) + + + \AntMe\ + Path in AppData-Folder of User-Documents + + + ..\Resources\stop.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\pause.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\security_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\debug_messages_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\speed.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\connection.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\offline.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\online.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\warning.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/AntMe/Properties/Settings.Designer.cs b/AntMe/Properties/Settings.Designer.cs new file mode 100644 index 0000000..5d5393a --- /dev/null +++ b/AntMe/Properties/Settings.Designer.cs @@ -0,0 +1,98 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Gui.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "12.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.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("")] + public string culture { + get { + return ((string)(this["culture"])); + } + set { + this["culture"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("0, 0")] + public global::System.Drawing.Point windowPosition { + get { + return ((global::System.Drawing.Point)(this["windowPosition"])); + } + set { + this["windowPosition"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("0, 0")] + public global::System.Drawing.Size windowSize { + get { + return ((global::System.Drawing.Size)(this["windowSize"])); + } + set { + this["windowSize"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Normal")] + public global::System.Windows.Forms.FormWindowState windowState { + get { + return ((global::System.Windows.Forms.FormWindowState)(this["windowState"])); + } + set { + this["windowState"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("2008-01-01")] + public global::System.DateTime lastUpdateCheck { + get { + return ((global::System.DateTime)(this["lastUpdateCheck"])); + } + set { + this["lastUpdateCheck"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("")] + public string updateLink { + get { + return ((string)(this["updateLink"])); + } + set { + this["updateLink"] = value; + } + } + } +} diff --git a/AntMe/Properties/Settings.settings b/AntMe/Properties/Settings.settings new file mode 100644 index 0000000..8013c19 --- /dev/null +++ b/AntMe/Properties/Settings.settings @@ -0,0 +1,24 @@ + + + + + + + + + 0, 0 + + + 0, 0 + + + Normal + + + 2008-01-01 + + + + + + \ No newline at end of file diff --git a/AntMe/Resource.Designer.cs b/AntMe/Resource.Designer.cs new file mode 100644 index 0000000..d9b4ce2 --- /dev/null +++ b/AntMe/Resource.Designer.cs @@ -0,0 +1,522 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Gui { + 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 Resource { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resource() { + } + + /// + /// 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("AntMe.Gui.Resource", typeof(Resource).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; + } + } + + /// + /// Looks up a localized string similar to http://www.antme.net. + /// + internal static string MainAntspielLink { + get { + return ResourceManager.GetString("MainAntspielLink", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to .\\english\\Classes.chm. + /// + internal static string MainClassDescriptionPath { + get { + return ResourceManager.GetString("MainClassDescriptionPath", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to http://antme.net/de/hilfe. + /// + internal static string MainForumLink { + get { + return ResourceManager.GetString("MainForumLink", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to {0} fps. + /// + internal static string MainFramesPerSecond { + get { + return ResourceManager.GetString("MainFramesPerSecond", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to No Class-Description available.. + /// + internal static string MainMessageBoxNoClassdescriptionMessage { + get { + return ResourceManager.GetString("MainMessageBoxNoClassdescriptionMessage", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Class description. + /// + internal static string MainMessageBoxNoClassdescriptionTitle { + get { + return ResourceManager.GetString("MainMessageBoxNoClassdescriptionTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to No help available.. + /// + internal static string MainMessageBoxNoTutorialMessage { + get { + return ResourceManager.GetString("MainMessageBoxNoTutorialMessage", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Tutorials. + /// + internal static string MainMessageBoxNoTutorialTitle { + get { + return ResourceManager.GetString("MainMessageBoxNoTutorialTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Maximum. + /// + internal static string MainSpeedMaximal { + get { + return ResourceManager.GetString("MainSpeedMaximal", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 0.0 fps. + /// + internal static string MainStateFramesPerSecond { + get { + return ResourceManager.GetString("MainStateFramesPerSecond", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Not ready. + /// + internal static string MainStateNotReady { + get { + return ResourceManager.GetString("MainStateNotReady", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Paused. + /// + internal static string MainStatePaused { + get { + return ResourceManager.GetString("MainStatePaused", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Ready. + /// + internal static string MainStateReady { + get { + return ResourceManager.GetString("MainStateReady", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to {0} of {1}. + /// + internal static string MainStateRoundIndicator { + get { + return ResourceManager.GetString("MainStateRoundIndicator", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Simulating. + /// + internal static string MainStateRunning { + get { + return ResourceManager.GetString("MainStateRunning", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to .\\english\\Tutorials.chm. + /// + internal static string MainTutorialPath { + get { + return ResourceManager.GetString("MainTutorialPath", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to http://www.antme.net. + /// + internal static string MainWebsiteLink { + get { + return ResourceManager.GetString("MainWebsiteLink", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to /english/Welcome.htm. + /// + internal static string MainWelcomePagePath { + get { + return ResourceManager.GetString("MainWelcomePagePath", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The name of the plugin is empty.. + /// + internal static string PluginItemConstructorPluginHasNoName { + get { + return ResourceManager.GetString("PluginItemConstructorPluginHasNoName", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to No plugin was passed to the contructor.. + /// + internal static string PluginItemConstructorPluginIsNull { + get { + return ResourceManager.GetString("PluginItemConstructorPluginIsNull", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The plugin is not in the list of loaded plugins.. + /// + internal static string PluginManagerActivateConsumerNotInList { + get { + return ResourceManager.GetString("PluginManagerActivateConsumerNotInList", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The plugin is not in the list of loaded plugins.. + /// + internal static string PluginManagerActivateProducerNotInList { + get { + return ResourceManager.GetString("PluginManagerActivateProducerNotInList", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There were problems loading plugin {0} ({1}).. + /// + internal static string PluginManagerConsumerPluginCommonProblems { + get { + return ResourceManager.GetString("PluginManagerConsumerPluginCommonProblems", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Two different versions are available for plugin {0} ({1}). The one with the higher version number will be loaded.. + /// + internal static string PluginManagerConsumerPluginNewerVersion { + get { + return ResourceManager.GetString("PluginManagerConsumerPluginNewerVersion", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to A higher version of plugin {0} ({1}) is already loaded.. + /// + internal static string PluginManagerConsumerPluginNewerVersionLoaded { + get { + return ResourceManager.GetString("PluginManagerConsumerPluginNewerVersionLoaded", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The settings for plugin {0} ({1}) could not be loaded.. + /// + internal static string PluginManagerConsumerPluginSettingsLoadFailed { + get { + return ResourceManager.GetString("PluginManagerConsumerPluginSettingsLoadFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There was a problem when saving settings of plugin {0} ({1}).. + /// + internal static string PluginManagerConsumerPluginSettingsSaveFailed { + get { + return ResourceManager.GetString("PluginManagerConsumerPluginSettingsSaveFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to A problem occured in Plugin {0} ({1}).. + /// + internal static string PluginManagerConsumerVisibilitySetFailed { + get { + return ResourceManager.GetString("PluginManagerConsumerVisibilitySetFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The plugin is not in the list of currently loaded plugins.. + /// + internal static string PluginManagerDeactivateConsumerNotInList { + get { + return ResourceManager.GetString("PluginManagerDeactivateConsumerNotInList", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The value has to be greater than 0.. + /// + internal static string PluginManagerFrameRateTooLow { + get { + return ResourceManager.GetString("PluginManagerFrameRateTooLow", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There was a problem in plugin {0} ({1}).. + /// + internal static string PluginManagerLoopConsumer1Failed { + get { + return ResourceManager.GetString("PluginManagerLoopConsumer1Failed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There was a problem in plugin {0} ({1}).. + /// + internal static string PluginManagerLoopConsumer2Failed { + get { + return ResourceManager.GetString("PluginManagerLoopConsumer2Failed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There was a problem in plugin {0} ({1}).. + /// + internal static string PluginManagerLoopConsumer3Failed { + get { + return ResourceManager.GetString("PluginManagerLoopConsumer3Failed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Problems occured when refreshing the display in plugin {0} ({1}).. + /// + internal static string PluginManagerLoopConsumerUIFailed { + get { + return ResourceManager.GetString("PluginManagerLoopConsumerUIFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There was a problem in plugin {0} ({1}).. + /// + internal static string PluginManagerLoopInterruptFailed { + get { + return ResourceManager.GetString("PluginManagerLoopInterruptFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There was a problem in plugin {0} ({1}).. + /// + internal static string PluginManagerLoopProducerFailed { + get { + return ResourceManager.GetString("PluginManagerLoopProducerFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Problems occured when refreshing the display in plugin {0} ({1}).. + /// + internal static string PluginManagerLoopProducerUIFailed { + get { + return ResourceManager.GetString("PluginManagerLoopProducerUIFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The plugin could not be loaded. Missing references of plugin {0}.. + /// + internal static string PluginManagerMissingReferences { + get { + return ResourceManager.GetString("PluginManagerMissingReferences", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There were problems loading plugin {0} ({1}).. + /// + internal static string PluginManagerProducerPluginCommonProblems { + get { + return ResourceManager.GetString("PluginManagerProducerPluginCommonProblems", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Two versions of plugin {0} ({1}) were found. The one with the higher version number will be loaded.. + /// + internal static string PluginManagerProducerPluginNewerVersion { + get { + return ResourceManager.GetString("PluginManagerProducerPluginNewerVersion", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to A higher version of plugin {0} ({1}) has already been loaded.. + /// + internal static string PluginManagerProducerPluginNewerVersionLoaded { + get { + return ResourceManager.GetString("PluginManagerProducerPluginNewerVersionLoaded", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The settings of plugin {0} ({1}) could not be loaded.. + /// + internal static string PluginManagerProducerPluginSettingsLoadFailed { + get { + return ResourceManager.GetString("PluginManagerProducerPluginSettingsLoadFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Problems occurred when attempting to save the settings of plugin {0} ({1}).. + /// + internal static string PluginManagerProducerPluginSettingsSaveFailed { + get { + return ResourceManager.GetString("PluginManagerProducerPluginSettingsSaveFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There was a problem in plugin {0} ({1}).. + /// + internal static string PluginManagerProducerVisibilitySetFailed { + get { + return ResourceManager.GetString("PluginManagerProducerVisibilitySetFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The configuration could not be loaded. This is likely due to an old version.. + /// + internal static string PluginManagerSettingsLoadFailed { + get { + return ResourceManager.GetString("PluginManagerSettingsLoadFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There are problems to reach the AntMe! Update Service. Please check your internet connection. + /// + internal static string UpdateErrorMessage { + get { + return ResourceManager.GetString("UpdateErrorMessage", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There is a newer Version of AntMe! available. Do you want to download it?. + /// + internal static string UpdateNewerMessage { + get { + return ResourceManager.GetString("UpdateNewerMessage", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to You are using the newest Version of AntMe!. + /// + internal static string UpdateNewestMessage { + get { + return ResourceManager.GetString("UpdateNewestMessage", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to No internet connection. + /// + internal static string UpdateNoConnection { + get { + return ResourceManager.GetString("UpdateNoConnection", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to AntMe! Update. + /// + internal static string UpdateTitle { + get { + return ResourceManager.GetString("UpdateTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Need to Login again. + /// + internal static string UpdateTokenInvalid { + get { + return ResourceManager.GetString("UpdateTokenInvalid", resourceCulture); + } + } + } +} diff --git a/AntMe/Resource.de.Designer.cs b/AntMe/Resource.de.Designer.cs new file mode 100644 index 0000000..e69de29 diff --git a/AntMe/Resource.de.resx b/AntMe/Resource.de.resx new file mode 100644 index 0000000..5d04509 --- /dev/null +++ b/AntMe/Resource.de.resx @@ -0,0 +1,360 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + http://www.antme.net + Link to the Antspiel-Website (go-link, please) + + + .\\deutsch\\Klassen.chm + Path to the Class-Description-File + + + http://antme.net/de/hilfe + Link to the AntMe-Forum (go-link, please) + + + {0} fps + Short string for frames per second (Main.cs) +0: Number of frames + + + Es ist keine Klassenbeschreibung verfügbar. + Message of messagebox to inform about missing class-description (Main.cs) + + + Klassenbeschreibung + Title of messagebox to inform about missing class-description (Main.cs) + + + Es ist keine Hilfe verfügbar. + Message of messagebox to inform about missing tutorials (Main.cs) + + + Tutorials + Title of messagebox to inform about missing tutorials (Main.cs) + + + Maximum + string for maximal speed without limit (Main.cs) + + + 0.0 fps + format-string for framerate-float in status-bar (Main.cs) + + + Nicht bereit + State-string for not ready in status-bar (Main.cs) + + + Pausiert + State-string for paused in status-bar (Main.cs) + + + Bereit + State-string for ready in status-bar (Main.cs) + + + {0} von {1} + String to count rounds in status-bar (Main.cs) +0: current round +1: total rounds + + + Simuliert + State-string for running in status-bar (Main.cs) + + + .\\deutsch\\Tutorial.chm + Path to Tutorial-file + + + http://www.antme.net + Link to the AntMe-Website (go-link, please) + + + /deutsch/Willkommen.htm + Path to the Welcome-Page + + + Der Name des angegebenen Plugins ist leer + if the given plugin has no name. (PluginItem.cs) + + + Es wurde kein Plugin angegeben + if the plugin-parameter for constructor is null (PluginItem.cs, 21 & 31) + + + Das angegebene Plugin befindet sich nicht in der Liste der geladenen Plugins + if the plugin, that should be activated, is not in List (PluginManager.cs) + + + Das angegebene Plugin befindet sich nicht in der Liste der geladenen Plugins + if the plugin, that should be activated, is not in List (PluginManager.cs) + + + Probleme beim Laden des Plugins {0} ({1}) + if there are common problems to load the consumer-plugin (PluginManager.cs) +0: Typename (full classname) +1: Filename + + + Zwei verschiedene Versionen des Plugins {0} ({1}) wurden gefunden. Es wird die höhere Version geladen. + if a newer version of consumer-plugin was found. (PluginManager.cs) +0: Pluginname +1: Version + + + Eine höhere Version des Plugins {0} ({1}) wurde bereits geladen. + if a newer version of consumer-plugin is still loaded. (PluginManager.cs) +0: Pluginname +1: Version + + + Einstellungen für Plugin {0} ({1}) konnten nicht geladen werden. + if loading of consumer-plugin-settings failed. (PluginManager.cs) +0: Pluginname +1: Version + + + Probleme bei der Speicherung der Einstellungen des Plugins {0} ({1}) + Exception at saveing plugin-settings. (PluginManager.cs) +0: Pluginname +1: Version + + + Es gab ein Problem in Plugin {0} ({1}) + Exeption at setting the visibility of a plugin (PluginManager.cs) +0: Pluginname +1: Version + + + Das angegebene Plugin befindet sich nicht in der Liste der geladenen Plugins + if the plugin, that should be deactivated, is not in List (PluginManager.cs) + + + Der Wert muss größer 0 sein + if new framerate is to low (PluginManager.cs) + + + Es gab ein Problem in Plugin {0} ({1}) + call of first consumer-loop-method throws Exception (PluginManager.cs) +0: Pluginname +1: Version + + + Es gab ein Problem in Plugin {0} ({1}) + call of second consumer-loop-method throws Exception (PluginManager.cs) +0: Pluginname +1: Version + + + Es gab ein Problem in Plugin {0} ({1}) + call of third consumer-loop-method throws Exception (PluginManager.cs) +0: Pluginname +1: Version + + + Es kam zu Problemen bei der Aktualisierung der Anzeige in Plugin {0} ({1}) + If there was an Exception during UpdateUI()-Method (PluginManager.cs) +0: Plugin-Name +1: Plugin-Version + + + Es gab ein Problem in Plugin {0} ({1}) + Exception, during interrupt (PluginManager.cs) +0: Pluginname +1: Version + + + Es gab ein Problem in Plugin {0} ({1}) + call of producer-loop-method throws Exception (PluginManager.cs) +0: Pluginname +1: Version + + + Es kam zu Problemen bei der Aktualisierung der Anzeige in Plugin {0} ({1}) + If there was an Exception during UpdateUI()-Method (PluginManager.cs) +0: Plugin-Name +1: Plugin-Version + + + Plugin konnte nicht geladen werden. Es fehlen Verweise des Plugins {0}. + if the ant-assembly references lost files. (PluginManager.cs, 143, 150) +0: Pluginname + + + Probleme beim laden des Plugins {0} ({1}) + if there are common problems to load the producer- plugin (PluginManager.cs) +0: Typename (full classname) +1: Filename + + + Zwei verschiedene Versionen des Plugins {0} ({1}) wurden gefunden. Es wird die höhere Version geladen. + if a newer version of producer-plugin was found. (PluginManager.cs) +0: Pluginname +1: Version + + + Eine höhere Version des Plugins {0} ({1}) wurde bereits geladen. + if a newer version of producer-plugin is still loaded. (PluginManager.cs) +0: Pluginname +1: Version + + + Einstellungen für Plugin {0} ({1}) konnten nicht geladen werden. + if loading of producer-plugin-settings failed. (PluginManager.cs) +0: Pluginname +1: Version + + + Probleme bei der Speicherung der Einstellungen des Plugins {0} ({1}) + Exception at saveing plugin-settings. (PluginManager.cs) +0: Pluginname +1: Version + + + Es gab ein Problem in Plugin {0} ({1}) + Exeption at setting the visibility of a plugin (PluginManager.cs) +0: Pluginname +1: Version + + + Konfiguration konnte nicht geladen werden. Vermutlich handelt es sich um eine veraltete Version. + global settings-file couldn't been deserialized (PluginManager.cs) + + + Es gab Probleme bei der Verbindung zum Update Service. Bitte überprüfe deine Internet Verbindung + + + Es gibt eine neuere AntMe! Version. Willst du die neue Version herunterladen? + + + Du benutzt bereits die neuste Version von AntMe! + + + Keine Internetverbindung + + + AntMe! Aktualisierung + + + Erneuter Login erforderlich + + \ No newline at end of file diff --git a/AntMe/Resource.resx b/AntMe/Resource.resx new file mode 100644 index 0000000..511e1ca --- /dev/null +++ b/AntMe/Resource.resx @@ -0,0 +1,360 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + http://www.antme.net + Link to the Antspiel-Website (go-link, please) + + + .\\english\\Classes.chm + Path to the Class-Description-File + + + http://antme.net/de/hilfe + Link to the AntMe-Forum (go-link, please) + + + {0} fps + Short string for frames per second (Main.cs) +0: Number of frames + + + No Class-Description available. + Message of messagebox to inform about missing class-description (Main.cs) + + + Class description + Title of messagebox to inform about missing class-description (Main.cs) + + + No help available. + Message of messagebox to inform about missing tutorials (Main.cs) + + + Tutorials + Title of messagebox to inform about missing tutorials (Main.cs) + + + Maximum + string for maximal speed without limit (Main.cs) + + + 0.0 fps + format-string for framerate-float in status-bar (Main.cs) + + + Not ready + State-string for not ready in status-bar (Main.cs) + + + Paused + State-string for paused in status-bar (Main.cs) + + + Ready + State-string for ready in status-bar (Main.cs) + + + {0} of {1} + String to count rounds in status-bar (Main.cs) +0: current round +1: total rounds + + + Simulating + State-string for running in status-bar (Main.cs) + + + .\\english\\Tutorials.chm + Path to Tutorial-file + + + http://www.antme.net + Link to the AntMe-Website (go-link, please) + + + /english/Welcome.htm + Path to the Welcome-Page + + + The name of the plugin is empty. + if the given plugin has no name. (PluginItem.cs) + + + No plugin was passed to the contructor. + if the plugin-parameter for constructor is null (PluginItem.cs, 21 & 31) + + + The plugin is not in the list of loaded plugins. + if the plugin, that should be activated, is not in List (PluginManager.cs) + + + The plugin is not in the list of loaded plugins. + if the plugin, that should be activated, is not in List (PluginManager.cs) + + + There were problems loading plugin {0} ({1}). + if there are common problems to load the consumer-plugin (PluginManager.cs) +0: Typename (full classname) +1: Filename + + + Two different versions are available for plugin {0} ({1}). The one with the higher version number will be loaded. + if a newer version of consumer-plugin was found. (PluginManager.cs) +0: Pluginname +1: Version + + + A higher version of plugin {0} ({1}) is already loaded. + if a newer version of consumer-plugin is still loaded. (PluginManager.cs) +0: Pluginname +1: Version + + + The settings for plugin {0} ({1}) could not be loaded. + if loading of consumer-plugin-settings failed. (PluginManager.cs) +0: Pluginname +1: Version + + + There was a problem when saving settings of plugin {0} ({1}). + Exception at saveing plugin-settings. (PluginManager.cs) +0: Pluginname +1: Version + + + A problem occured in Plugin {0} ({1}). + Exeption at setting the visibility of a plugin (PluginManager.cs) +0: Pluginname +1: Version + + + The plugin is not in the list of currently loaded plugins. + if the plugin, that should be deactivated, is not in List (PluginManager.cs) + + + The value has to be greater than 0. + if new framerate is to low (PluginManager.cs) + + + There was a problem in plugin {0} ({1}). + call of first consumer-loop-method throws Exception (PluginManager.cs) +0: Pluginname +1: Version + + + There was a problem in plugin {0} ({1}). + call of second consumer-loop-method throws Exception (PluginManager.cs) +0: Pluginname +1: Version + + + There was a problem in plugin {0} ({1}). + call of third consumer-loop-method throws Exception (PluginManager.cs) +0: Pluginname +1: Version + + + Problems occured when refreshing the display in plugin {0} ({1}). + If there was an Exception during UpdateUI()-Method (PluginManager.cs) +0: Plugin-Name +1: Plugin-Version + + + There was a problem in plugin {0} ({1}). + Exception, during interrupt (PluginManager.cs) +0: Pluginname +1: Version + + + There was a problem in plugin {0} ({1}). + call of producer-loop-method throws Exception (PluginManager.cs) +0: Pluginname +1: Version + + + Problems occured when refreshing the display in plugin {0} ({1}). + If there was an Exception during UpdateUI()-Method (PluginManager.cs) +0: Plugin-Name +1: Plugin-Version + + + The plugin could not be loaded. Missing references of plugin {0}. + if the ant-assembly references lost files. (PluginManager.cs, 143, 150) +0: Pluginname + + + There were problems loading plugin {0} ({1}). + if there are common problems to load the producer- plugin (PluginManager.cs) +0: Typename (full classname) +1: Filename + + + Two versions of plugin {0} ({1}) were found. The one with the higher version number will be loaded. + if a newer version of producer-plugin was found. (PluginManager.cs) +0: Pluginname +1: Version + + + A higher version of plugin {0} ({1}) has already been loaded. + if a newer version of producer-plugin is still loaded. (PluginManager.cs) +0: Pluginname +1: Version + + + The settings of plugin {0} ({1}) could not be loaded. + if loading of producer-plugin-settings failed. (PluginManager.cs) +0: Pluginname +1: Version + + + Problems occurred when attempting to save the settings of plugin {0} ({1}). + Exception while saving plugin-settings. (PluginManager.cs) +0: Pluginname +1: Version + + + There was a problem in plugin {0} ({1}). + Exeption at setting the visibility of a plugin (PluginManager.cs) +0: Pluginname +1: Version + + + The configuration could not be loaded. This is likely due to an old version. + global settings-file couldn't been deserialized (PluginManager.cs) + + + There are problems to reach the AntMe! Update Service. Please check your internet connection + + + There is a newer Version of AntMe! available. Do you want to download it? + + + You are using the newest Version of AntMe! + + + No internet connection + + + AntMe! Update + + + Need to Login again + + \ No newline at end of file diff --git a/AntMe/Resources/connection.png b/AntMe/Resources/connection.png new file mode 100644 index 0000000..681e2c9 Binary files /dev/null and b/AntMe/Resources/connection.png differ diff --git a/AntMe/Resources/debug_messages_32x32.png b/AntMe/Resources/debug_messages_32x32.png new file mode 100644 index 0000000..0acb34c Binary files /dev/null and b/AntMe/Resources/debug_messages_32x32.png differ diff --git a/AntMe/Resources/downarrow.png b/AntMe/Resources/downarrow.png new file mode 100644 index 0000000..e0770a5 Binary files /dev/null and b/AntMe/Resources/downarrow.png differ diff --git a/AntMe/Resources/error_48X48.png b/AntMe/Resources/error_48X48.png new file mode 100644 index 0000000..1a35bbf Binary files /dev/null and b/AntMe/Resources/error_48X48.png differ diff --git a/AntMe/Resources/offline.png b/AntMe/Resources/offline.png new file mode 100644 index 0000000..6fbb96a Binary files /dev/null and b/AntMe/Resources/offline.png differ diff --git a/AntMe/Resources/online.png b/AntMe/Resources/online.png new file mode 100644 index 0000000..0a67df3 Binary files /dev/null and b/AntMe/Resources/online.png differ diff --git a/AntMe/Resources/pause.png b/AntMe/Resources/pause.png new file mode 100644 index 0000000..d728e5e Binary files /dev/null and b/AntMe/Resources/pause.png differ diff --git a/AntMe/Resources/play.png b/AntMe/Resources/play.png new file mode 100644 index 0000000..79a476e Binary files /dev/null and b/AntMe/Resources/play.png differ diff --git a/AntMe/Resources/security_32x32.png b/AntMe/Resources/security_32x32.png new file mode 100644 index 0000000..23327cb Binary files /dev/null and b/AntMe/Resources/security_32x32.png differ diff --git a/AntMe/Resources/speed.png b/AntMe/Resources/speed.png new file mode 100644 index 0000000..afe0441 Binary files /dev/null and b/AntMe/Resources/speed.png differ diff --git a/AntMe/Resources/stop.png b/AntMe/Resources/stop.png new file mode 100644 index 0000000..0cf1aed Binary files /dev/null and b/AntMe/Resources/stop.png differ diff --git a/AntMe/Resources/uparrow.png b/AntMe/Resources/uparrow.png new file mode 100644 index 0000000..3428bb8 Binary files /dev/null and b/AntMe/Resources/uparrow.png differ diff --git a/AntMe/Resources/warning.png b/AntMe/Resources/warning.png new file mode 100644 index 0000000..c8964c4 Binary files /dev/null and b/AntMe/Resources/warning.png differ diff --git a/AntMe/Resources/welcome.png b/AntMe/Resources/welcome.png new file mode 100644 index 0000000..093b6c1 Binary files /dev/null and b/AntMe/Resources/welcome.png differ diff --git a/AntMe/WebBrowserEx.cs b/AntMe/WebBrowserEx.cs new file mode 100644 index 0000000..56b83f4 --- /dev/null +++ b/AntMe/WebBrowserEx.cs @@ -0,0 +1,129 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Windows.Forms; + +namespace AntMe.Gui +{ + internal class WebBrowserEx : WebBrowser + { + private AxHost.ConnectionPointCookie cookie; + private WebBrowser2EventHelper helper; + + protected override void CreateSink() + { + base.CreateSink(); + + // Create an instance of the client that will handle the event + // and associate it with the underlying ActiveX control. + helper = new WebBrowser2EventHelper(this); + cookie = new AxHost.ConnectionPointCookie( + this.ActiveXInstance, helper, typeof(DWebBrowserEvents2)); + } + + protected override void DetachSink() + { + if (cookie != null) + { + cookie.Disconnect(); + cookie = null; + } + + base.DetachSink(); + } + + public event WebBrowserNavigateErrorEventHandler NavigateError; + + // Raises the NavigateError event. + protected virtual void OnNavigateError( + WebBrowserNavigateErrorEventArgs e) + { + if (this.NavigateError != null) + { + this.NavigateError(this, e); + } + } + + private class WebBrowser2EventHelper : + StandardOleMarshalObject, DWebBrowserEvents2 + { + private WebBrowserEx parent; + + public WebBrowser2EventHelper(WebBrowserEx parent) + { + this.parent = parent; + } + + public void NavigateError(object pDisp, ref object url, + ref object frame, ref object statusCode, ref bool cancel) + { + // Raise the NavigateError event. + this.parent.OnNavigateError( + new WebBrowserNavigateErrorEventArgs( + (String)url, (String)frame, (Int32)statusCode, cancel)); + } + } + } + + // Represents the method that will handle the WebBrowser2.NavigateError event. + internal delegate void WebBrowserNavigateErrorEventHandler(object sender, + WebBrowserNavigateErrorEventArgs e); + + // Provides data for the WebBrowser2.NavigateError event. + public class WebBrowserNavigateErrorEventArgs : EventArgs + { + private String urlValue; + private String frameValue; + private Int32 statusCodeValue; + private Boolean cancelValue; + + public WebBrowserNavigateErrorEventArgs( + String url, String frame, Int32 statusCode, Boolean cancel) + { + urlValue = url; + frameValue = frame; + statusCodeValue = statusCode; + cancelValue = cancel; + } + + public String Url + { + get { return urlValue; } + set { urlValue = value; } + } + + public String Frame + { + get { return frameValue; } + set { frameValue = value; } + } + + public Int32 StatusCode + { + get { return statusCodeValue; } + set { statusCodeValue = value; } + } + + public Boolean Cancel + { + get { return cancelValue; } + set { cancelValue = value; } + } + } + + // Imports the NavigateError method from the OLE DWebBrowserEvents2 + // interface. + [ComImport, Guid("34A715A0-6587-11D0-924A-0020AFC7AC4D"), + InterfaceType(ComInterfaceType.InterfaceIsIDispatch), + TypeLibType(TypeLibTypeFlags.FHidden)] + internal interface DWebBrowserEvents2 + { + [DispId(271)] + void NavigateError( + [In, MarshalAs(UnmanagedType.IDispatch)] object pDisp, + [In] ref object URL, [In] ref object frame, + [In] ref object statusCode, [In, Out] ref bool cancel); + } +} diff --git a/AntMe/antme.ico b/AntMe/antme.ico new file mode 100644 index 0000000..aebbe09 Binary files /dev/null and b/AntMe/antme.ico differ diff --git a/AntMe/deutsch/Befehlsliste.pdf b/AntMe/deutsch/Befehlsliste.pdf new file mode 100644 index 0000000..6c8e6b5 Binary files /dev/null and b/AntMe/deutsch/Befehlsliste.pdf differ diff --git a/AntMe/deutsch/Tutorial.chm b/AntMe/deutsch/Tutorial.chm new file mode 100644 index 0000000..e631ccd Binary files /dev/null and b/AntMe/deutsch/Tutorial.chm differ diff --git a/AntMe/deutsch/Willkommen.htm b/AntMe/deutsch/Willkommen.htm new file mode 100644 index 0000000..b160aaf --- /dev/null +++ b/AntMe/deutsch/Willkommen.htm @@ -0,0 +1,76 @@ + + + + + +Willkommen + + + + + +
+AntMe! Titelgrafik +

Programmieren lernen einmal anders: „AntMe!“ ist ein kleines, aber feines Spiel, bei dem die Programmierung von künstlicher Intelligenz (KI) das zentrale Spieleprinzip ist. Eine prima Möglichkeit, die Sprachen C# oder Visual Basic .NET zu lernen, nebenher etwas über die „eingebaute Intelligenz“ von Computerspielen zu erfahren und dabei jede Menge Spaß zu haben.

+

Mehr über AntMe… »


+ +
+ +AntMe! im Web + +

+ + HipHop Ameise + + Der Treffpunkt für Ameisenfans: Tipps & Tricks, Problemlösungen, Hintergrundinfos, neue Versionen, Bonus-Downloads, ein Webforum und vieles mehr findet Ihr auf der AntMe!-Homepage. Also nichts wie hin! +

+ +

Zur AntMe!-Homepage »

+
+ +Schnellstart + +

Ihr wollt gleich loslegen? Kein Problem! Einfach im Menü „Hilfe“ den Punkt „Tutorial“ wählen – diese Schnellstart-Anleitung hilft Euch dabei, Schritt für Schritt Euer erstes Ameisenvolk zu programmieren. Viel Erfolg!

+ +Mehr über AntMe! + +

Samurai Ameise Jeder Spieler kontrolliert ein Ameisenvolk, das in einem virtuellen Wald auf Nahrungssuche geht. Wie im echten Leben ist die Menge an Futter begrenzt und überall lauern Feinde in Form von ameisenvertilgenden Käfern.

+ +

Der Clou: Das Verhalten der eigenen Ameisen wird durch ein kleines Programm gesteuert, welches jeder Spieler vor Spielbeginn selbst schreibt. Dabei kann er durch Programmcode auf verschiedene Ereignisse reagieren, beispielsweise darauf, dass die Ameise gerade einen Gegner sieht oder soeben Nahrung erspäht hat. Im Code wird dann festgelegt, wie die Ameise auf diese Ereignisse reagiert – soll sie einen Gegner attackieren oder lieber wegrennen? Soll sie andere Ameisen in der Nähe um Hilfe rufen? Und was, wenn nicht genug Kollegen in Reichweite sind? Durch clevere Programmierung und ausgefeilte Strategie-Routinen kann jeder Spieler seinem Volk zu einem Vorteil verhelfen.

+ +
+ + + + diff --git a/AntMe/deutsch/images/Thumbs.db b/AntMe/deutsch/images/Thumbs.db new file mode 100644 index 0000000..823baf5 Binary files /dev/null and b/AntMe/deutsch/images/Thumbs.db differ diff --git a/AntMe/deutsch/images/antme_im_web.png b/AntMe/deutsch/images/antme_im_web.png new file mode 100644 index 0000000..d80f98b Binary files /dev/null and b/AntMe/deutsch/images/antme_im_web.png differ diff --git a/AntMe/deutsch/images/header.png b/AntMe/deutsch/images/header.png new file mode 100644 index 0000000..bfa1326 Binary files /dev/null and b/AntMe/deutsch/images/header.png differ diff --git a/AntMe/deutsch/images/hiphop.png b/AntMe/deutsch/images/hiphop.png new file mode 100644 index 0000000..d00d474 Binary files /dev/null and b/AntMe/deutsch/images/hiphop.png differ diff --git a/AntMe/deutsch/images/mehr_ueber_antme.png b/AntMe/deutsch/images/mehr_ueber_antme.png new file mode 100644 index 0000000..5c1ad7e Binary files /dev/null and b/AntMe/deutsch/images/mehr_ueber_antme.png differ diff --git a/AntMe/deutsch/images/samurai.png b/AntMe/deutsch/images/samurai.png new file mode 100644 index 0000000..62789b5 Binary files /dev/null and b/AntMe/deutsch/images/samurai.png differ diff --git a/AntMe/deutsch/images/schnellstart.png b/AntMe/deutsch/images/schnellstart.png new file mode 100644 index 0000000..a6a7d8e Binary files /dev/null and b/AntMe/deutsch/images/schnellstart.png differ diff --git a/AntMe/english/Commandlist.pdf b/AntMe/english/Commandlist.pdf new file mode 100644 index 0000000..6c8e6b5 Binary files /dev/null and b/AntMe/english/Commandlist.pdf differ diff --git a/AntMe/english/Tutorials.chm b/AntMe/english/Tutorials.chm new file mode 100644 index 0000000..b217064 Binary files /dev/null and b/AntMe/english/Tutorials.chm differ diff --git a/AntMe/english/Welcome.htm b/AntMe/english/Welcome.htm new file mode 100644 index 0000000..68913a9 --- /dev/null +++ b/AntMe/english/Welcome.htm @@ -0,0 +1,82 @@ + + + + + +Welcome to AntMe! + + + + + +
+AntMe! title image +

An entirely new approach to learning programming: "AntMe!" is a simple but + sophisticated game centered around programming artificial intelligence (AI). It + is a great way to learn C# or Visual Basic, discover some of the "magic" of + computer games and have lots of fun along the way!

+

Learn more ...»

+ +
+ +AntMe! on the Web + +

+ + HipHop Ant + + The hub of activity of all things AntMe! as well as the right place to meet other players. Tips and tricks, solutions to common problems, background information, bonus-downloads, a forum – the AntMe! website has it all and more. +

+ +

Visit the AntMe! website »

+
+ +quickstart +

Ready to get going? Open the "Help" menu and click on "AntMe! Tutorials". The + step-by-step quickstart will show you everything you need to know to create your + first ant colony. Don't worry: this isn't rocket science and you'll be up and running in no + time.

+ +More on AntMe! + +

Samurai antEach player controls an ant colony searching for food in a virtual forest. Just like in real life, the amount of food is limited and there's a bunch of enemies, a.k.a. bugs, constantly on the lookout for their next meal – your ants.

+ +

If this doesn't yet sound all that exciting, how about this: the ants' behavior is based on a small program written by the player – i.e. you – before the game starts. Ants can be made to react to events in their environment such as spotting an enemy or discovering food. In the code you determine an ant's reaction to these events: should it attack the enemy or run away? Call other ants for help? What if there are none around?

+

Clever programming and sophisticated strategies go a long way in helping your ants survive as best they can. After all, they're looking up to you to guide them in their daily lives.

+ +
+ + + + diff --git a/AntMe/english/images/antme_im_web_en.png b/AntMe/english/images/antme_im_web_en.png new file mode 100644 index 0000000..03c7bf2 Binary files /dev/null and b/AntMe/english/images/antme_im_web_en.png differ diff --git a/AntMe/english/images/header_en.png b/AntMe/english/images/header_en.png new file mode 100644 index 0000000..e7b3949 Binary files /dev/null and b/AntMe/english/images/header_en.png differ diff --git a/AntMe/english/images/hiphop.png b/AntMe/english/images/hiphop.png new file mode 100644 index 0000000..d00d474 Binary files /dev/null and b/AntMe/english/images/hiphop.png differ diff --git a/AntMe/english/images/mehr_ueber_antme_en.png b/AntMe/english/images/mehr_ueber_antme_en.png new file mode 100644 index 0000000..400e628 Binary files /dev/null and b/AntMe/english/images/mehr_ueber_antme_en.png differ diff --git a/AntMe/english/images/samurai.png b/AntMe/english/images/samurai.png new file mode 100644 index 0000000..62789b5 Binary files /dev/null and b/AntMe/english/images/samurai.png differ diff --git a/AntMe/english/images/schnellstart_en.png b/AntMe/english/images/schnellstart_en.png new file mode 100644 index 0000000..b4cd040 Binary files /dev/null and b/AntMe/english/images/schnellstart_en.png differ diff --git a/DemoAmeisen/DemoAMeisen.cs b/DemoAmeisen/DemoAMeisen.cs new file mode 100644 index 0000000..5e2eac1 --- /dev/null +++ b/DemoAmeisen/DemoAMeisen.cs @@ -0,0 +1,154 @@ +using AntMe.Deutsch; + +namespace AntMe.Spieler.WolfgangGallo { + [Spieler( + Volkname = "Demo-A-Meisen", + Vorname = "Wolfgang", + Nachname = "Gallo" + )] + public class DemoAMeise : Basisameise { + private bool laufeWeg = false; + + #region Fortbewegung + + /// + /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie + /// hingehen soll. + /// + public override void Wartet() { + laufeWeg = false; + if (AktuelleEnergie < MaximaleEnergie/2) { + GeheZuBau(); + } + else { + DreheUmWinkel(Zufall.Zahl(-36, 36)); + GeheGeradeaus(Zufall.Zahl(20, 40)); + } + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Drittel ihrer maximalen + /// Reichweite überschritten hat. + /// + public override void WirdMüde() { + if (Ziel == null) { + GeheZuBau(); + } + } + + #endregion + + #region Nahrung + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen + /// Zuckerhaufen sieht. + /// + /// Der nächstgelegene Zuckerhaufen. + public override void Sieht(Zucker zucker) { + if (!laufeWeg) { + int entfernung = Koordinate.BestimmeEntfernung(this, zucker); + SprüheMarkierung(Koordinate.BestimmeRichtung(this, zucker), entfernung); + if (Ziel == null && AktuelleLast < MaximaleLast) { + GeheZuZiel(zucker); + } + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein + /// Obststück sieht. + /// + /// Das nächstgelegene Obststück. + public override void Sieht(Obst obst) { + if (!laufeWeg && Ziel == null && AktuelleLast == 0 && BrauchtNochTräger(obst)) { + GeheZuZiel(obst); + } + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise einen Zuckerhaufen als Ziel + /// hat und bei diesem ankommt. + /// + /// Der Zuckerhaufen. + public override void ZielErreicht(Zucker zucker) { + Nimm(zucker); + if (AktuelleLast == MaximaleLast) { + GeheZuBau(); + } + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und + /// bei diesem ankommt. + /// + /// Das Obstück. + public override void ZielErreicht(Obst obst) { + if (BrauchtNochTräger(obst)) { + Nimm(obst); + GeheZuBau(); + } + } + + #endregion + + #region Kommunikation + + /// + /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben + /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut + /// gerochen. + /// + /// Die nächste neue Markierung. + public override void RiechtFreund(Markierung markierung) { + if (!laufeWeg && Ziel == null) { + DreheInRichtung(markierung.Information); + GeheGeradeaus(10); + } + } + + #endregion + + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer + /// sieht. + /// + /// Der nächstgelegene Käfer. + public override void SiehtFeind(Wanze wanze) { + laufeWeg = true; + LasseNahrungFallen(); + GeheGeradeaus(40); + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen + /// wird. + /// + /// Der angreifende Käfer. + public override void WirdAngegriffen(Wanze wanze) { + laufeWeg = true; + LasseNahrungFallen(); + GeheGeradeaus(40); + } + + #endregion + + #region Sonstiges + + /// + /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen. + /// + public override void Tick() { + if (Ziel is Obst && !BrauchtNochTräger((Obst) Ziel)) { + BleibStehen(); + } + else if (Ziel is Bau && AktuelleLast > 0 && GetragenesObst == null) { + SprüheMarkierung(Richtung + 180); + } + } + + #endregion + } +} \ No newline at end of file diff --git a/DemoAmeisen/DemoAmeisen.csproj b/DemoAmeisen/DemoAmeisen.csproj new file mode 100644 index 0000000..f67a540 --- /dev/null +++ b/DemoAmeisen/DemoAmeisen.csproj @@ -0,0 +1,111 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {B53ECAD8-961B-4179-BB46-993DA25DA6DF} + Library + Properties + AntMe.DemoAmeisen + AntMe.DemoAmeisen + v4.0 + 512 + SAK + SAK + SAK + SAK + + + 3.5 + + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + + true + ..\bin\ + DEBUG;TRACE + full + x86 + true + GlobalSuppressions.cs + prompt + AllRules.ruleset + + + ..\bin\ + TRACE + true + pdbonly + x86 + true + GlobalSuppressions.cs + prompt + + + AllRules.ruleset + + + + + + + + + + + + + + + + + + + + {35753E72-07F3-4F18-916C-479850EC375F} + SimulationCore + + + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + true + + + False + Windows Installer 3.1 + true + + + + + \ No newline at end of file diff --git a/DemoAmeisen/DemoBMeisen.cs b/DemoAmeisen/DemoBMeisen.cs new file mode 100644 index 0000000..befb740 --- /dev/null +++ b/DemoAmeisen/DemoBMeisen.cs @@ -0,0 +1,304 @@ +using System.Collections.Generic; +using AntMe.Deutsch; + +namespace AntMe.Spieler.WolfgangGallo +{ + + [Spieler( + Volkname = "Demo-B-Meisen", + Vorname = "Wolfgang", + Nachname = "Gallo" + )] + + [Kaste( + Name = "Sammler", + GeschwindigkeitModifikator = 1, + DrehgeschwindigkeitModifikator = 0, + LastModifikator = 2, + ReichweiteModifikator = -1, + SichtweiteModifikator = -1, + EnergieModifikator = 0, + AngriffModifikator = -1 + )] + [Kaste( + Name = "Krieger", + GeschwindigkeitModifikator = -1, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = -1, + ReichweiteModifikator = -1, + SichtweiteModifikator = 0, + EnergieModifikator = 2, + AngriffModifikator = 2 + )] + [Kaste( + Name = "Kundschafter", + GeschwindigkeitModifikator = 1, + DrehgeschwindigkeitModifikator = 1, + LastModifikator = -1, + ReichweiteModifikator = -1, + SichtweiteModifikator = 2, + EnergieModifikator = -1, + AngriffModifikator = -1 + )] + + public class DemoBMeise : Basisameise + { + /// + /// Bestimmt den Typ einer neuen Ameise. + /// + /// Die Anzahl der von jedem Typ bereits + /// vorhandenen Ameisen. + /// Der Name des Typs der Ameise. + public override string BestimmeKaste(Dictionary anzahl) + { + if (anzahl["Krieger"] < 5) + return "Krieger"; + if (anzahl["Kundschafter"] < 5) + return "Kundschafter"; + if (anzahl["Sammler"] < 5) + return "Sammler"; + if (anzahl["Krieger"] < 15) + return "Krieger"; + if (anzahl["Kundschafter"] < 15) + return "Kundschafter"; + if (anzahl["Sammler"] < 25) + return "Sammler"; + if (anzahl["Krieger"] < 30) + return "Krieger"; + return "Sammler"; + } + + #region Fortbewegung + + /// + /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie + /// hingehen soll. + /// + public override void Wartet() + { + + if (IstMüde || AktuelleEnergie < MaximaleEnergie / 4) + GeheZuBau(); + else + switch (Kaste) + { + + case "Kundschafter": + DreheUmWinkel(Zufall.Zahl(-8, 8)); + GeheGeradeaus(Zufall.Zahl(40, 80)); + break; + + case "Sammler": + DreheUmWinkel(Zufall.Zahl(-32, 32)); + GeheGeradeaus(Zufall.Zahl(20, 40)); + break; + + case "Krieger": + DreheUmWinkel(Zufall.Zahl(-64, 64)); + GeheGeradeaus(Zufall.Zahl(80, 160)); + break; + + } + + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Drittel ihrer maximalen + /// Reichweite überschritten hat. + /// + public override void WirdMüde() + { + if (Ziel == null) + GeheZuBau(); + } + + #endregion + #region Nahrung + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen + /// Zuckerhaufen sieht. + /// + /// Der nächstgelegene Zuckerhaufen. + public override void Sieht(Zucker zucker) + { + switch (Kaste) + { + + case "Sammler": + if (Ziel == null && AktuelleLast < MaximaleLast) + GeheZuZiel(zucker); + goto case "Kundschafter"; + + case "Kundschafter": + int entfernung = Koordinate.BestimmeEntfernung(this, zucker); + if (entfernung > 50) + entfernung = 50; + SprüheMarkierung + ((ushort)Koordinate.BestimmeRichtung(this, zucker), entfernung); + break; + + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein + /// Obststück sieht. + /// + /// Das nächstgelegene Obststück. + public override void Sieht(Obst obst) + { + switch (Kaste) + { + + case "Sammler": + if (Ziel == null && AktuelleLast == 0) + GeheZuZiel(obst); + goto case "Kundschafter"; + + case "Kundschafter": + int entfernung = Koordinate.BestimmeEntfernung(this, obst); + if (entfernung > 50) + entfernung = 50; + SprüheMarkierung + ((ushort)Koordinate.BestimmeRichtung(this, obst), entfernung); + break; + + } + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise einen Zuckerhaufen als Ziel + /// hat und bei diesem ankommt. + /// + /// Der Zuckerhaufen. + public override void ZielErreicht(Zucker zucker) + { + Nimm(zucker); + if (AktuelleLast == MaximaleLast) + GeheZuBau(); + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und + /// bei diesem ankommt. + /// + /// Das Obstück. + public override void ZielErreicht(Obst obst) + { + + if (BrauchtNochTräger(obst)) + { + Nimm(obst); + GeheZuBau(); + } + else + BleibStehen(); + + } + + #endregion + #region Kommunikation + + /// + /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben + /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut + /// gerochen. + /// + /// Die nächste neue Markierung. + public override void RiechtFreund(Markierung markierung) + { + switch (Kaste) + { + + case "Sammler": + if (markierung.Information != -1 && Ziel == null) + { + DreheInRichtung(markierung.Information); + GeheGeradeaus(20); + } + break; + + case "Krieger": + if (markierung.Information == -1 && Ziel == null) + { + int entfernung = Koordinate.BestimmeEntfernung(this, markierung); + if (entfernung > 50) + entfernung = 50; + SprüheMarkierung(-1, entfernung); + GeheZuZiel(markierung); + } + break; + + } + } + + #endregion + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer + /// sieht. + /// + /// Der nächstgelegene Käfer. + public override void SiehtFeind(Wanze wanze) + { + switch (Kaste) + { + + case "Sammler": + LasseNahrungFallen(); + goto case "Kundschafter"; + + case "Kundschafter": + GeheGeradeaus(Zufall.Zahl(20, 40)); + break; + + case "Krieger": + SprüheMarkierung(-1, 50); + if (Ziel == null) + GreifeAn(wanze); + break; + + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen + /// wird. + /// + /// Der angreifende Käfer. + public override void WirdAngegriffen(Wanze wanze) + { + if (AktuelleEnergie < MaximaleEnergie / 4) + GeheZuBau(); + } + + #endregion + #region Sonstiges + + /// + /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen. + /// + public override void Tick() + { + + if (Ziel is Obst && !BrauchtNochTräger((Obst)Ziel)) + BleibStehen(); + + else if (Ziel is Bau && AktuelleLast > 0 && GetragenesObst == null) + SprüheMarkierung(Richtung + 180); + + else if (Ziel is Wanze) + { + int entfernung = Koordinate.BestimmeEntfernung(this, Ziel); + SprüheMarkierung(-1, entfernung); + } + + } + + #endregion + + } + +} \ No newline at end of file diff --git a/DemoAmeisen/DemoCMeisen.cs b/DemoAmeisen/DemoCMeisen.cs new file mode 100644 index 0000000..e9568c8 --- /dev/null +++ b/DemoAmeisen/DemoCMeisen.cs @@ -0,0 +1,355 @@ +using System.Collections.Generic; +using AntMe.Deutsch; + +namespace AntMe.Spieler.WolfgangGallo +{ + + /// + /// Demoameisen, die sich auf das Sammeln von Zucker und das Verteidigen von + /// Zuckeraufen spezialisiert. Es gibt Kundschafter, die Zuckerhaufen + /// auskundschaften und Markierungen sprühen, die zum Zucker hin weisen, + /// Sammler, die den Zucker in den Bau tragen und Krieger, die um den + /// Zuckerhaufen herum patroullieren und Feinde angreifen. + /// + + [Spieler( + Volkname = "Demo-C-Meisen", + Vorname = "Wolfgang", + Nachname = "Gallo" + )] + + [Kaste( + Name = "Kundschafter", + GeschwindigkeitModifikator = 2, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = -1, + ReichweiteModifikator = 0, + SichtweiteModifikator = 2, + EnergieModifikator = -1, + AngriffModifikator = -1 + )] + + [Kaste( + Name = "Sammler", + GeschwindigkeitModifikator = -1, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = 2, + ReichweiteModifikator = 0, + SichtweiteModifikator = -1, + EnergieModifikator = 2, + AngriffModifikator = -1 + )] + + [Kaste( + Name = "Krieger", + GeschwindigkeitModifikator = -1, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = -1, + ReichweiteModifikator = 0, + SichtweiteModifikator = -1, + EnergieModifikator = 2, + AngriffModifikator = 2 + )] + + public class DemoCMeise : Basisameise + { + /// + /// Bestimmt den Typ einer neuen Ameise. + /// + /// Die Anzahl der von jedem Typ bereits + /// vorhandenen Ameisen. + /// Der Name des Typs der Ameise. + public override string BestimmeKaste(Dictionary anzahl) + { + + // Wir wollen genau 5 Kundschafter haben. + if (anzahl["Kundschafter"] < 5) + return "Kundschafter"; + + // Das Verhältnis von Sammlern zu Kriegern soll 4 zu 1 betragen. + if ((anzahl["Sammler"] + anzahl["Krieger"]) % 5 == 0) + return "Krieger"; + return "Sammler"; + + } + + #region Fortbewegung + + // Für Kundschafter. + private bool stehenbleiben = false; + + // Für Krieger. + private bool verteidigen = false; + private int entfernung; + private int winkel; + + /// + /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie + /// hingehen soll. + /// + public override void Wartet() + { + switch (Kaste) + { + + case "Kundschafter": + if (!stehenbleiben) + GeheGeradeaus(); + break; + + case "Sammler": + if (IstMüde) + GeheZuBau(); + else + GeheGeradeaus(); + break; + + case "Krieger": + if (verteidigen) + { + DreheUmWinkel(winkel); + GeheGeradeaus(entfernung); + } + else + GeheGeradeaus(); + break; + + } + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Drittel ihrer maximalen + /// Reichweite überschritten hat. + /// + public override void WirdMüde() + { + switch (Kaste) + { + + case "Kundschafter": + if (!stehenbleiben) + GeheZuBau(); + break; + + case "Sammler": + if (Ziel == null) + GeheZuBau(); + break; + + case "Krieger": + GeheZuBau(); + break; + + } + } + + #endregion + #region Nahrung + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen + /// Zuckerhaufen sieht. + /// + /// Der nächstgelegene Zuckerhaufen. + public override void Sieht(Zucker zucker) + { + switch (Kaste) + { + + case "Kundschafter": + GeheZuZiel(zucker); + break; + + case "Sammler": + if (Ziel == null) + GeheZuZiel(zucker); + break; + + case "Krieger": + if (!verteidigen) + { + verteidigen = true; + int richtung = Koordinate.BestimmeRichtung(this, zucker); + entfernung = Koordinate.BestimmeEntfernung(this, zucker) * 3; + // Der Winkel führt dazu, daß die Krieger sternförmig um den Zucker + // patroullieren. + winkel = Zufall.Zahl(180, 215); + DreheInRichtung(richtung); + GeheGeradeaus(entfernung); + } + break; + + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein + /// Obststück sieht. + /// + /// Das nächstgelegene Obststück. + public override void Sieht(Obst obst) + { + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise einen Zuckerhaufen als Ziel + /// hat und bei diesem ankommt. + /// + /// Der Zuckerhaufen. + public override void ZielErreicht(Zucker zucker) + { + switch (Kaste) + { + + case "Kundschafter": + SprüheMarkierung(0, EntfernungZuBau + 40); + stehenbleiben = true; + break; + + case "Sammler": + Nimm(zucker); + GeheZuBau(); + break; + + } + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und + /// bei diesem ankommt. + /// + /// Das Obstück. + public override void ZielErreicht(Obst obst) + { + } + + #endregion + #region Kommunikation + + /// + /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben + /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut + /// gerochen. + /// + /// Die nächste neue Markierung. + public override void RiechtFreund(Markierung markierung) + { + switch (Kaste) + { + + case "Kundschafter": + GeheWegVon(markierung); + break; + + case "Sammler": + if (Ziel == null) + GeheZuZiel(markierung); + break; + + case "Krieger": + if (!verteidigen) + GeheZuZiel(markierung); + break; + + } + + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens eine Ameise des + /// selben Volkes sieht. + /// + /// Die nächstgelegene befreundete Ameise. + public override void SiehtFreund(Ameise ameise) + { + } + + #endregion + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer + /// sieht. + /// + /// Der nächstgelegene Käfer. + public override void SiehtFeind(Wanze wanze) + { + switch (Kaste) + { + + case "Krieger": + if (verteidigen) + GreifeAn(wanze); + break; + + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines + /// anderen Volkes sieht. + /// + /// Die nächstgelegen feindliche Ameise. + public override void SiehtFeind(Ameise ameise) + { + switch (Kaste) + { + + case "Krieger": + if (verteidigen) + GreifeAn(ameise); + break; + + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen + /// wird. + /// + /// Der angreifende Käfer. + public override void WirdAngegriffen(Wanze wanze) + { + GreifeAn(wanze); + } + + /// + /// Wird wiederholt aufgerufen in der die Ameise von einer Ameise eines + /// anderen Volkes Ameise angegriffen wird. + /// + /// Die angreifende feindliche Ameise. + public override void WirdAngegriffen(Ameise ameise) + { + switch (Kaste) + { + + case "Krieger": + GreifeAn(ameise); + break; + + } + } + + #endregion + #region Sonstiges + + /// + /// Wird einmal aufgerufen, wenn die Ameise gestorben ist. + /// + /// Die Todesart der Ameise + public override void IstGestorben(Todesart todesart) + { + } + + /// + /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen. + /// + public override void Tick() + { + } + + #endregion + + } + +} \ No newline at end of file diff --git a/DemoAmeisen/DynamischeAmeisen.cs b/DemoAmeisen/DynamischeAmeisen.cs new file mode 100644 index 0000000..a8a64d2 --- /dev/null +++ b/DemoAmeisen/DynamischeAmeisen.cs @@ -0,0 +1,339 @@ +using System; +using System.Collections.Generic; + +using AntMe.Deutsch; + +namespace AntMe.Spieler.WolfgangGallo +{ + + [Spieler( + Volkname = "DynamischeAmeisen", + Vorname = "Wolfgang", + Nachname = "Gallo" + )] + + [Kaste( + Name = "Sammler1", + GeschwindigkeitModifikator = 2, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = 2, + ReichweiteModifikator = -1, + SichtweiteModifikator = 0, + EnergieModifikator = -1, + AngriffModifikator = -1 + )] + [Kaste( + Name = "Sammler2", + GeschwindigkeitModifikator = 1, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = 2, + ReichweiteModifikator = -1, + SichtweiteModifikator = 0, + EnergieModifikator = 0, + AngriffModifikator = -1 + )] + [Kaste( + Name = "Sammler3", + GeschwindigkeitModifikator = 0, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = 2, + ReichweiteModifikator = -1, + SichtweiteModifikator = 0, + EnergieModifikator = 1, + AngriffModifikator = -1 + )] + [Kaste( + Name = "Sammler4", + GeschwindigkeitModifikator = 0, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = 2, + ReichweiteModifikator = -1, + SichtweiteModifikator = -1, + EnergieModifikator = 2, + AngriffModifikator = -1 + )] + [Kaste( + Name = "Krieger1", + GeschwindigkeitModifikator = -1, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = -1, + ReichweiteModifikator = 0, + SichtweiteModifikator = -1, + EnergieModifikator = 2, + AngriffModifikator = 2 + )] + [Kaste( + Name = "Krieger2", + GeschwindigkeitModifikator = 0, + DrehgeschwindigkeitModifikator = 0, + LastModifikator = -1, + ReichweiteModifikator = 0, + SichtweiteModifikator = -1, + EnergieModifikator = 1, + AngriffModifikator = 1 + )] + [Kaste( + Name = "Krieger3", + GeschwindigkeitModifikator = 1, + DrehgeschwindigkeitModifikator = 0, + LastModifikator = -1, + ReichweiteModifikator = -1, + SichtweiteModifikator = -1, + EnergieModifikator = 1, + AngriffModifikator = 1 + )] + + public class DynamischeAmeise : Basisameise + { + + private static bool erzeugeSammler = false; + private static int kriegerTyp = 1; + private static int sammlerTyp = 1; + + /// + /// Bestimmt den Typ einer neuen Ameise. + /// + /// Die Anzahl der von jedem Typ bereits vorhandenen + /// Ameisen. + /// Der Name des Typs der Ameise. + public override string BestimmeKaste(Dictionary anzahl) + { + erzeugeSammler = !erzeugeSammler; + if (erzeugeSammler) + return "Sammler" + sammlerTyp; + return "Krieger" + kriegerTyp; + } + + #region Fortbewegung + + /// + /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie + /// hingehen soll. + /// + public override void Wartet() + { + if (Ziel == null && gemerkterZucker != null) + GeheZuZiel(gemerkterZucker); + else + GeheGeradeaus(); + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Drittel ihrer maximalen + /// Reichweite überschritten hat. + /// + public override void WirdMüde() {} + + #endregion + #region Nahrung + + private Zucker gemerkterZucker; + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen + /// Zuckerhaufen sieht. + /// + /// Der nächstgelegene Zuckerhaufen. + public override void Sieht(Zucker zucker) + { + if (gemerkterZucker == null) + gemerkterZucker = zucker; + + SprüheMarkierung(0, 60); + + if (Kaste.Substring(0, 7) == "Sammler" && Ziel == null) + GeheZuZiel(zucker); + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein + /// Obststück sieht. + /// + /// Das nächstgelegene Obststück. + public override void Sieht(Obst obst) + { + if (BrauchtNochTräger(obst)) + { + SprüheMarkierung + (Koordinate.BestimmeRichtung(this, obst), + Koordinate.BestimmeEntfernung(this, obst)); + + if (Kaste.Substring(0, 7) == "Sammler" && Ziel == null) + GeheZuZiel(obst); + } + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise einen Zuckerhaufen als Ziel + /// hat und bei diesem ankommt. + /// + /// Der Zuckerhaufen. + public override void ZielErreicht(Zucker zucker) + { + Nimm(zucker); + GeheZuBau(); + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und + /// bei diesem ankommt. + /// + /// Das Obstück. + public override void ZielErreicht(Obst obst) + { + if (BrauchtNochTräger(obst)) + { + Nimm(obst); + GeheZuBau(); + } + } + + #endregion + #region Kommunikation + + /// + /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben + /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut + /// gerochen. + /// + /// Die nächste neue Markierung. + public override void RiechtFreund(Markierung markierung) + { + if (Ziel == null) + GeheZuZiel(markierung); + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens eine Ameise des + /// selben Volkes sieht. + /// + /// Die nächstgelegene befreundete Ameise. + public override void SiehtFreund(Ameise ameise) {} + + #endregion + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer + /// sieht. + /// + /// Der nächstgelegene Käfer. + public override void SiehtFeind(Wanze wanze) + { + SprüheMarkierung(0, 60); + + if (Kaste.Substring(0, 7) == "Krieger" && Ziel == null) + GreifeAn(wanze); + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines + /// anderen Volkes sieht. + /// + /// Die nächstgelegen feindliche Ameise. + public override void SiehtFeind(Ameise ameise) + { + if (Kaste.Substring(0, 7) == "Krieger" && Ziel == null) + GreifeAn(ameise); + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen + /// wird. + /// + /// Der angreifende Käfer. + public override void WirdAngegriffen(Wanze wanze) + { + if (Kaste.Substring(0, 7) == "Krieger" && Ziel == null) + GreifeAn(wanze); + } + + /// + /// Wird wiederholt aufgerufen in der die Ameise von einer Ameise eines + /// anderen Volkes Ameise angegriffen wird. + /// + /// Die angreifende feindliche Ameise. + public override void WirdAngegriffen(Ameise ameise) + { + if (Kaste.Substring(0, 7) == "Krieger" && Ziel == null) + GreifeAn(ameise); + } + + #endregion + #region Sonstiges + + private static int erfolgloseKrieger = 0; + private static int erfolgloseSammler = 0; + private static int erfolgreicheKrieger = 0; + private static int erfolgreicheSammler = 0; + private int letzteLast = 0; + private bool zielWarInsekt = false; + + private static void aktualisiereSammler() + { + sammlerTyp = 1 + (int)Math.Round + (3f * erfolgloseSammler / + (erfolgloseSammler + erfolgreicheSammler)); + } + + private static void aktualisiereKrieger() + { + kriegerTyp = 1 + (int)Math.Round + (2f * erfolgloseKrieger / + (erfolgloseKrieger + erfolgreicheKrieger)); + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise gestorben ist. + /// + /// Die Todesart der Ameise + public override void IstGestorben(Todesart todesart) + { + if (todesart == Todesart.Verhungert) + return; + + if (Kaste.Substring(0, 7) == "Sammler") + { + if (letzteLast > 0) + { + erfolgloseSammler++; + aktualisiereSammler(); + } + } + else + { + erfolgloseKrieger++; + aktualisiereKrieger(); + } + } + + /// + /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen. + /// + public override void Tick() + { + if (Kaste.Substring(0, 7) == "Sammler") + { + if (letzteLast > 0 && AktuelleLast == 0) + { + erfolgreicheSammler++; + aktualisiereSammler(); + } + letzteLast = AktuelleLast; + } + else + { + if (zielWarInsekt && Ziel == null) + { + erfolgreicheKrieger++; + aktualisiereKrieger(); + } + zielWarInsekt = Ziel is Insekt; + } + } + + #endregion + + } + +} \ No newline at end of file diff --git a/DemoAmeisen/GruppenAmeisen.cs b/DemoAmeisen/GruppenAmeisen.cs new file mode 100644 index 0000000..20d05cf --- /dev/null +++ b/DemoAmeisen/GruppenAmeisen.cs @@ -0,0 +1,329 @@ +using System; +using System.Collections.Generic; + +using AntMe.Deutsch; + +namespace AntMe.Spieler.WolfgangGallo +{ + + [Spieler( + Volkname = "GruppenAmeisen", + Vorname = "Wolfgang", + Nachname = "Gallo" + )] + + [Kaste( + Name = "", + GeschwindigkeitModifikator = 0, + DrehgeschwindigkeitModifikator = 0, + LastModifikator = 0, + ReichweiteModifikator = 0, + SichtweiteModifikator = 0, + EnergieModifikator = 0, + AngriffModifikator = 0 + )] + + public class GruppenAmeise : Basisameise + { + + // Speichert wieviele Ameisen bereits insgesamt erzeugt wurden. + private static int anzahlGesamt = 0; + + // Speichert die Gruppenführer aller Gruppen. + private static GruppenAmeise[] gruppenführer = new GruppenAmeise[10]; + + // Speichert zu welcher Gruppe die Ameise gehört. + private int gruppe; + + /// + /// Der Konstruktor. + /// + public GruppenAmeise() + { + // Die Ameisen eins bis zehn kommen in die erste Gruppe, die Ameisen elf + // bis 20 kommen in die zweite Gruppe, u.s.w. Ameise 101 kommt wieder in + // Gruppe eins, Ameise 102 in Gruppe zwei, u.s.w. + if (anzahlGesamt < 100) + gruppe = anzahlGesamt / 10; + else + gruppe = anzahlGesamt % 10; + + anzahlGesamt++; + } + + /// + /// Bestimmt den Typ einer neuen Ameise. + /// + /// Die Anzahl der von jedem Typ bereits vorhandenen + /// Ameisen. + /// Der Name des Typs der Ameise. + public override string BestimmeKaste(Dictionary anzahl) + { + return ""; + } + + #region Fortbewegung + + /// + /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie + /// hingehen soll. + /// + public override void Wartet() + { + // Wenn die Ameise der Gruppenführer ist, dann lege die Bewegung fest. + if (gruppenführer[gruppe] == this) + if (IstMüde || AktuelleEnergie < MaximaleEnergie / 2) + GeheZuBau(); + else + GeheGeradeaus(); + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Drittel ihrer maximalen + /// Reichweite überschritten hat. + /// + public override void WirdMüde() {} + + #endregion + #region Nahrung + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen + /// Zuckerhaufen sieht. + /// + /// Der nächstgelegene Zuckerhaufen. + public override void Sieht(Zucker zucker) + { + // Eine Markierung darf jede Ameise sprühen. + int richtung = Koordinate.BestimmeRichtung(this, zucker); + int entfernung = Koordinate.BestimmeEntfernung(this, zucker); + SprüheMarkierung(richtung, entfernung); + + // Ein Ziel darf nur der Gruppenführer vorgeben. + if (gruppenführer[gruppe] == this && (Ziel == null || Ziel is Insekt)) + GeheZuZiel(zucker); + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein + /// Obststück sieht. + /// + /// Das nächstgelegene Obststück. + public override void Sieht(Obst obst) + { + // Eine Markierung darf jede Ameise sprühen. + int richtung = Koordinate.BestimmeRichtung(this, obst); + int entfernung = Koordinate.BestimmeEntfernung(this, obst); + SprüheMarkierung(richtung, entfernung); + + // Ein Ziel darf nur der Gruppenführer vorgeben. + if (gruppenführer[gruppe] == this && (Ziel == null || Ziel is Insekt)) + GeheZuZiel(obst); + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise einen Zuckerhaufen als Ziel + /// hat und bei diesem ankommt. + /// + /// Der Zuckerhaufen. + public override void ZielErreicht(Zucker zucker) + { + // Das Ziel Ameisenbau hat der Gruppenführer dadurch vorgegeben, dass er + // zuvor das Ziel auf den Zucker gesetzt hat. + Nimm(zucker); + GeheZuBau(); + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und + /// bei diesem ankommt. + /// + /// Das Obstück. + public override void ZielErreicht(Obst obst) + { + // Das Ziel Ameisenbau hat der Gruppenführer dadurch vorgegeben, dass er + // zuvor das Ziel auf das Obst gesetzt hat. + Nimm(obst); + GeheZuBau(); + } + + #endregion + #region Kommunikation + + /// + /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben + /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut + /// gerochen. + /// + /// Die nächste neue Markierung. + public override void RiechtFreund(Markierung markierung) + { + if (gruppenführer[gruppe] == this && Ziel == null) + { + DreheInRichtung(markierung.Information); + GeheGeradeaus(20); + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens eine Ameise des + /// selben Volkes sieht. + /// + /// Die nächstgelegene befreundete Ameise. + public override void SiehtFreund(Ameise ameise) {} + + #endregion + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer + /// sieht. + /// + /// Der nächstgelegene Käfer. + public override void SiehtFeind(Wanze wanze) + { + if (gruppenführer[gruppe] == this && 10 * MaximaleEnergie > wanze.AktuelleEnergie) + { + LasseNahrungFallen(); + GreifeAn(wanze); + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines + /// anderen Volkes sieht. + /// + /// Die nächstgelegen feindliche Ameise. + public override void SiehtFeind(Ameise ameise) + { + if (gruppenführer[gruppe] == this && Ziel == null && + 10 * MaximaleEnergie > ameise.AktuelleEnergie && + MaximaleGeschwindigkeit > ameise.MaximaleGeschwindigkeit) + { + LasseNahrungFallen(); + GreifeAn(ameise); + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen + /// wird. + /// + /// Der angreifende Käfer. + public override void WirdAngegriffen(Wanze wanze) { } + + /// + /// Wird wiederholt aufgerufen in der die Ameise von einer Ameise eines + /// anderen Volkes Ameise angegriffen wird. + /// + /// Die angreifende feindliche Ameise. + public override void WirdAngegriffen(Ameise ameise) {} + + #endregion + #region Sonstiges + + // Speichert ob die Ameise nahe bei der Gruppe ist oder zu weit weg. Wird + // von Gruppenführern und Gruppenmitgliedern unterschiedlich verwendet. + private bool istBeiGruppe = false; + + /// + /// Wird einmal aufgerufen, wenn die Ameise gestorben ist. + /// + /// Die Todesart der Ameise + public override void IstGestorben(Todesart todesart) {} + + /// + /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen. + /// + public override void Tick() + { + // Ameisenstraße wie gehabt. + if (Ziel is Bau && AktuelleLast > 0 && GetragenesObst == null) + SprüheMarkierung(Richtung + 180); + + // Wenn die Stelle frei ist, dann bestimme die Ameise zum Gruppenführer. + if (gruppenführer[gruppe] == null || gruppenführer[gruppe].AktuelleEnergie <= 0) + gruppenführer[gruppe] = this; + + // Wenn die Ameise der Gruppenführer ist, dann warte ggf. auf die Gruppe. + if (gruppenführer[gruppe] == this) + { + if (!istBeiGruppe) + { + BleibStehen(); + istBeiGruppe = true; + } + return; + } + + // Wenn das Ziel ein Insekt ist und tot, dann bleib stehen. + if (Ziel is Insekt && ((Insekt)Ziel).AktuelleEnergie <= 0) + BleibStehen(); + + // Brich ab, wenn die Ameise ein Ziel hat. + if (Ziel != null) + return; + + // Wenn der Gruppenführer einen Feind angreift, dann lasse die Nahrung + // fallen und greife ebenfalls an. + if (gruppenführer[gruppe].Ziel is Insekt) + { + LasseNahrungFallen(); + GreifeAn((Insekt)gruppenführer[gruppe].Ziel); + return; + } + + // Wenn der Gruppenführer einen Apfel trägt oder zu einem Apfel oder zu + // einem Zuckerhaufen geht, dann gehe auch dort hin. + if (gruppenführer[gruppe].GetragenesObst != null) + { + GeheZuZiel(gruppenführer[gruppe].GetragenesObst); + return; + } + if (gruppenführer[gruppe].Ziel is Nahrung) + { + GeheZuZiel(gruppenführer[gruppe].Ziel); + return; + } + + int entfernung = + Koordinate.BestimmeEntfernung(this, gruppenführer[gruppe]); + + // Prüfe ob die Ameise den Anschluß zur Gruppe verloren hat. + if (istBeiGruppe && entfernung > 64) + istBeiGruppe = false; + + // Prüfe ob die Ameise den Anschluß zur Gruppe wiedergefunden hat. + if (!istBeiGruppe && entfernung < 16) + istBeiGruppe = true; + + // Gehe zum Gruppenführer und sag ihm, dass er warten soll. + if (!istBeiGruppe) + { + int richtung = Koordinate.BestimmeRichtung(this, gruppenführer[gruppe]); + DreheInRichtung(richtung); + GeheGeradeaus(entfernung); + gruppenführer[gruppe].istBeiGruppe = false; + return; + } + + // Drehe die Ameise in die Richtung in die der Gruppenführer zeigt. + // Wenn die Ameise weniger als 32 Schritte vom Gruppenführer entfernt + // ist und ihre Richtung mehr als 135 Grad von der des Gruppenführers + // abweicht, dann ist dieser sehr wahrscheinlich vom Spielfeldrand + // abgeprallt. In diesem Fall stelle den alten RestWinkel wieder her, + // damit die Ameise ebenfalls abprallen kann. Das geht schneller, als + // sich in die Richtung des Gruppenführers zu drehen. + int restWinkel = RestWinkel; + DreheInRichtung(gruppenführer[gruppe].Richtung); + if (entfernung < 32 && Math.Abs(RestWinkel) > 135) + DreheUmWinkel(restWinkel); + + GeheGeradeaus(gruppenführer[gruppe].RestStrecke); + } + + #endregion + + } + +} \ No newline at end of file diff --git a/DemoAmeisen/KreisAmeisen.cs b/DemoAmeisen/KreisAmeisen.cs new file mode 100644 index 0000000..7605e5d --- /dev/null +++ b/DemoAmeisen/KreisAmeisen.cs @@ -0,0 +1,319 @@ +using System; +using System.Collections.Generic; + +using AntMe.Deutsch; + +namespace AntMe.Spieler.WolfgangGallo +{ + + [Spieler( + Volkname = "KreisAmeisen", + Vorname = "Wolfgang", + Nachname = "Gallo" + )] + + [Kaste( + Name = "Wächter", + GeschwindigkeitModifikator = -1, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = -1, + ReichweiteModifikator = 1, + SichtweiteModifikator = -1, + EnergieModifikator = 2, + AngriffModifikator = 1 + )] + [Kaste( + Name = "Sammler", + GeschwindigkeitModifikator = 0, + DrehgeschwindigkeitModifikator = 0, + LastModifikator = 0, + ReichweiteModifikator = 0, + SichtweiteModifikator = 0, + EnergieModifikator = 0, + AngriffModifikator = 0 + )] + + public class KreisAmeise : Basisameise + { + + // Variablen die ein n-Eck beschreiben. + private static bool erzeugeWächter = true; + private bool aufEntfernungGehen = true; + private Zucker gemerkterZucker = null; + private bool imKreisGehen = false; + private int innenWinkel; + private int rückwärtsFaktor; + private int seitenLänge; + private int umkreisRadius; + + /// + /// Der Konstruktor. + /// + public KreisAmeise() + { + // TODO: reparieren - funktioniert so nämlich nicht mehr! + if (Kaste == "Wächter") + { + umkreisRadius = Zufall.Zahl(10, Sichtweite * 2); + rückwärtsFaktor = Zufall.Zahl(2) == 0 ? 1 : -1; + + // Der Kreis um den Zuckerhaufen wird durch ein n-Eck angenähert. + int n = umkreisRadius / 2; + seitenLänge = (int)(2 * umkreisRadius * Math.Sin(Math.PI / n)); + innenWinkel = 180 * (n - 2) / n; + } + } + + /// + /// Bestimmt den Typ einer neuen Ameise. + /// + /// Die Anzahl der von jedem Typ bereits vorhandenen + /// Ameisen. + /// Der Name des Typs der Ameise. + public override string BestimmeKaste(Dictionary anzahl) + { + if (erzeugeWächter) + { + erzeugeWächter = false; + return "Wächter"; + } + + erzeugeWächter = true; + return "Sammler"; + } + + #region Fortbewegung + + /// + /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie + /// hingehen soll. + /// + public override void Wartet() + { + if (Kaste == "Wächter") + if (gemerkterZucker != null && aufEntfernungGehen) + { + // Bestimme die Entfernung zu der Kreisbahn. + int entfernung = + Koordinate.BestimmeEntfernung(this, gemerkterZucker) - umkreisRadius; + + // Gehe in Richtung Zucker bzw. vom Zucker weg auf die Kreisbahn. + if (entfernung > 0) + { + DreheZuZiel(gemerkterZucker); + GeheGeradeaus(entfernung); + } + else + { + DreheInRichtung + (Koordinate.BestimmeRichtung(this, gemerkterZucker) + 180); + GeheGeradeaus(-entfernung); + } + + aufEntfernungGehen = false; + imKreisGehen = true; + } + else if (gemerkterZucker != null && imKreisGehen) + { + // Bestimme die Richtung zum Zucker und zähle den halben Innenwinkel + // dazu. Das ergibt die Gehrichtung. + int richtung = Koordinate.BestimmeRichtung(this, gemerkterZucker) + + rückwärtsFaktor * innenWinkel / 2; + + DreheInRichtung(richtung); + GeheGeradeaus(seitenLänge); + } + else + GeheGeradeaus(); + else if (AktuelleLast > 0) + GeheZuBau(); + else if (gemerkterZucker != null) + GeheZuZiel(gemerkterZucker); + else + GeheGeradeaus(); + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Drittel ihrer maximalen + /// Reichweite überschritten hat. + /// + public override void WirdMüde() {} + + #endregion + #region Nahrung + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen + /// Zuckerhaufen sieht. + /// + /// Der nächstgelegene Zuckerhaufen. + public override void Sieht(Zucker zucker) + { + SprüheMarkierung + (Koordinate.BestimmeRichtung(this, zucker), + Koordinate.BestimmeEntfernung(this, zucker)); + + if (Kaste == "Wächter") + { + if (gemerkterZucker == null) + { + // Dieser Aufruf ist nötig, damit in der nächsten Runde Wartet() + // aufgerufen wird. + BleibStehen(); + + gemerkterZucker = zucker; + aufEntfernungGehen = true; + } + } + else + { + if (gemerkterZucker == null) + gemerkterZucker = zucker; + + if (Ziel == null) + GeheZuZiel(zucker); + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein + /// Obststück sieht. + /// + /// Das nächstgelegene Obststück. + public override void Sieht(Obst obst) {} + + /// + /// Wird einmal aufgerufen, wenn die Ameise einen Zuckerhaufen als Ziel + /// hat und bei diesem ankommt. + /// + /// Der Zuckerhaufen. + public override void ZielErreicht(Zucker zucker) + { + Nimm(zucker); + GeheZuBau(); + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und + /// bei diesem ankommt. + /// + /// Das Obstück. + public override void ZielErreicht(Obst obst) {} + + #endregion + #region Kommunikation + + /// + /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben + /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut + /// gerochen. + /// + /// Die nächste neue Markierung. + public override void RiechtFreund(Markierung markierung) + { + if (Kaste == "Wächter") + { + if (gemerkterZucker == null) + { + DreheInRichtung(markierung.Information); + GeheGeradeaus(); + } + } + else if (Ziel == null) + { + DreheInRichtung(markierung.Information); + GeheGeradeaus(); + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens eine Ameise des + /// selben Volkes sieht. + /// + /// Die nächstgelegene befreundete Ameise. + public override void SiehtFreund(Ameise ameise) {} + + #endregion + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer + /// sieht. + /// + /// Der nächstgelegene Käfer. + public override void SiehtFeind(Wanze wanze) + { + if (Kaste == "Wächter" && gemerkterZucker != null) + GreifeAn(wanze); + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines + /// anderen Volkes sieht. + /// + /// Die nächstgelegen feindliche Ameise. + public override void SiehtFeind(Ameise ameise) + { + if (Kaste == "Wächter" && gemerkterZucker != null) + GreifeAn(ameise); + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen + /// wird. + /// + /// Der angreifende Käfer. + public override void WirdAngegriffen(Wanze wanze) { } + + /// + /// Wird wiederholt aufgerufen in der die Ameise von einer Ameise eines + /// anderen Volkes Ameise angegriffen wird. + /// + /// Die angreifende feindliche Ameise. + public override void WirdAngegriffen(Ameise ameise) {} + + #endregion + #region Sonstiges + + /// + /// Wird einmal aufgerufen, wenn die Ameise gestorben ist. + /// + /// Die Todesart der Ameise + public override void IstGestorben(Todesart todesart) {} + + /// + /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen. + /// + public override void Tick() + { + if (gemerkterZucker != null) + { + if (Ziel is Insekt) + { + int entfernung = Koordinate.BestimmeEntfernung(this, Ziel); + if (entfernung > Sichtweite * 3) + BleibStehen(); + } + + if (Kaste == "Wächter") + SprüheMarkierung + (Koordinate.BestimmeRichtung(this, gemerkterZucker), + Math.Min(Sichtweite, Koordinate.BestimmeEntfernung(this, gemerkterZucker))); + + if (gemerkterZucker.Menge <= 0) + { + gemerkterZucker = null; + if (Kaste == "Wächter") + { + imKreisGehen = false; + aufEntfernungGehen = false; + } + } + } + } + + #endregion + + } + +} \ No newline at end of file diff --git a/DemoAmeisen/Properties/AssemblyInfo.cs b/DemoAmeisen/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..05dfaf8 --- /dev/null +++ b/DemoAmeisen/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// Allgemeine Informationen über eine Assembly werden über die folgenden +// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern, +// die mit einer Assembly verknüpft sind. +[assembly: AssemblyTitle("AntMe! Demoants")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("AntMe! GmbH")] +[assembly: AssemblyProduct("AntMe!")] +[assembly: AssemblyCopyright("Copyright © 2014 AntMe! GmbH")] +[assembly: AssemblyTrademark("AntMe!")] +[assembly: AssemblyCulture("")] + +// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar +// für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von +// COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest. +[assembly: ComVisible(false)] + +// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird +[assembly: Guid("a3750b1e-64a2-4cb1-9268-0901dc9dc6e3")] + +// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +// +// Hauptversion +// Nebenversion +// Buildnummer +// Revision +// +// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern +// übernehmen, indem Sie "*" eingeben: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.7.1.41")] +[assembly: AssemblyFileVersion("1.7.1.41")] diff --git a/DemoAmeisen/aTomApfelmeisen.cs b/DemoAmeisen/aTomApfelmeisen.cs new file mode 100644 index 0000000..29c225f --- /dev/null +++ b/DemoAmeisen/aTomApfelmeisen.cs @@ -0,0 +1,225 @@ +using System.Collections.Generic; +using AntMe.Deutsch; + +namespace AntMe.DemoAmeisen { + /// + /// Ameisendemo die sich darauf konzentriert effizient Äpfel einzusammeln. + /// Andere Nahrungsmittel werden ignoriert und den Käfern wird nur versucht + /// auszuweichen. + /// + + [Spieler( + Volkname = "aTom Apfelmeisen", + Vorname = "Tom", + Nachname = "Wendel" + )] + + [Kaste( + Name = "Sammler", + GeschwindigkeitModifikator = 2, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = 2, + ReichweiteModifikator = -1, + SichtweiteModifikator = 0, + EnergieModifikator = -1, + AngriffModifikator = -1 + )] + + public class aTomApfelameise : Basisameise + { + /// + /// Bestimmt den Typ einer neuen Ameise. + /// + /// Die Anzahl der von jedem Typ bereits + /// vorhandenen Ameisen. + /// Der Name des Typs der Ameise. + public override string BestimmeKaste(Dictionary anzahl) + { + // Erzeuge nur Sammler + return "Sammler"; + } + + #region Fortbewegung + + /// + /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie + /// hingehen soll. + /// + public override void Wartet() + { + + // Sollte die Ameise außerhalb des Nahrungsmittelradiuses liegen... + if (EntfernungZuBau > 400) + { + // ... soll sie wieder heim gehen. + GeheZuBau(); + } + else + { + // ... ansonsten soll sie sich ein bischen drehen (zufälliger Winkel + // zwischen -10 und 10 Grad) und wieder ein paar Schritte laufen. + DreheUmWinkel(Zufall.Zahl(-10, 10)); + GeheGeradeaus(20); + } + + // Wenn die restliche verfügbare Strecke der Ameise (minus einem Puffer + // von 50 Schritten) kleiner als die Entfernung zum Bau ist... + if (Reichweite - ZurückgelegteStrecke - 50 < EntfernungZuBau) + { + // ... soll sie nach Hause gehen um nicht zu sterben. + GeheZuBau(); + } + + } + + #endregion + #region Nahrung + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein + /// Obststück sieht. + /// + /// Das nächstgelegene Obststück. + public override void Sieht(Obst obst) + { + // Sofern der Apfel noch Träger braucht soll die Ameise zum Apfel. + if (BrauchtNochTräger(obst)) + { + GeheZuZiel(obst); + } + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und + /// bei diesem ankommt. + /// + /// Das Obstück. + public override void ZielErreicht(Obst obst) + { + // Die Ameise soll nochmal prüfen ob der Apfel überhaupt noch Träger + // braucht. + if (BrauchtNochTräger(obst)) + { + // Wenn noch Träger gebraucht werden soll die Ameise eine Markierung + // sprühen die als Information die Menge benötigter Ameisen hat. Da die + // benötigte Menge nicht genau ermittelt werden kann wird hier nur + // geschätzt. Es wird erwartet, dass 20 gebraucht werden und dass in + // "AnzahlInSichtweite" etwa die Zahl tragenden Ameisen steckt. + SprüheMarkierung(20 - AnzahlAmeisenInSichtweite, 200); + Nimm(obst); + GeheZuBau(); + } + } + + #endregion + #region Kommunikation + + /// + /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben + /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut + /// gerochen. + /// + /// Die nächste neue Markierung. + public override void RiechtFreund(Markierung markierung) + { + // Sollte die Ameise nicht schon Obst im Auge haben oder auf dem Weg zum + // Bau sein soll sie, wenn die angeforderte Menge Ameisen die Ameisenmenge + // der gerade in Sichtweite befindlichen Ameisen übersteigt, zum + // Markierungsmittelpunkt gehen um dort hoffentlich den Apfel zu sehen. + if (!(Ziel is Obst) && + !(Ziel is Bau) && + AnzahlAmeisenInSichtweite < markierung.Information) + { + GeheZuZiel(markierung); + // Sollte die Entfernung mehr als 50 schritte zum Mittelpunkt betragen, + // soll eine Folgemarkierung gesprüht werden um denn Effektradius zu + // erhöhen. + if (Koordinate.BestimmeEntfernung(this, markierung) > 50) + { + SprüheMarkierung( + Koordinate.BestimmeRichtung(this, markierung), + Koordinate.BestimmeEntfernung(this, markierung)); + } + } + else + { + // In allen anderen Fällen soll sie kurz stehen bleiben um zu + // verhindern, dass die Ameise dem Apfel ewig hinterher läuft. + BleibStehen(); + } + } + + #endregion + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer + /// sieht. + /// + /// Der nächstgelegene Wanze. + public override void SiehtFeind(Wanze wanze) + { + // Bei Käfersicht wird ermittelt ob die Ameise evtl. kollidiert, wenn sie + // geradeaus weitergeht. + int relativeRichtung = + Koordinate.BestimmeRichtung(this, wanze) - Richtung; + if (relativeRichtung > -15 && relativeRichtung < 15) + { + // Wenn ja, soll sie erstmal die Nahrung fallen lassen um schneller zu + // laufen und dann, je nachdem auf welcher Seite der Käfer ist, in einem + // 20 Grad-Winkel in die andere Richtung weggehen. + LasseNahrungFallen(); + if (relativeRichtung < 0) + { + DreheUmWinkel(20 + relativeRichtung); + } + else + { + DreheUmWinkel(-20 - relativeRichtung); + } + GeheGeradeaus(100); + } + } + + #endregion + #region Sonstiges + + /// + /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen. + /// + public override void Tick() + { + + // Sollte die Ameise gerade mit Nahrung unterwegs sein... + if (Ziel != null && GetragenesObst != null) + { + // ... und noch Helfer für den Apfel gebraucht werden... + if (BrauchtNochTräger(GetragenesObst)) + { + // ... soll sie eine Markierung sprühen die die Information enthält, + // wie viele Ameisen noch beim Tragen helfen sollen. + SprüheMarkierung(20 - AnzahlAmeisenInSichtweite, 200); + } + } + + // Sollte die Ameise, wärend sie Obst trägt, das Ziel "Bau" verlieren, + // wird das Ziel neu gesetzt. + if (GetragenesObst != null) + { + GeheZuBau(); + } + + // Sollte die Ameise einem Stück Obst hinterher laufen das garkeine Träger + // mehr braucht soll sie stehen bleiben um anschließend durch "wartet" + // wieder umher geschickt zu werden. + if (Ziel is Obst && !BrauchtNochTräger((Obst)Ziel)) + { + BleibStehen(); + } + + } + + #endregion + + } +} \ No newline at end of file diff --git a/DemoAmeisen/aTomGruppenmeisen.cs b/DemoAmeisen/aTomGruppenmeisen.cs new file mode 100644 index 0000000..e955e83 --- /dev/null +++ b/DemoAmeisen/aTomGruppenmeisen.cs @@ -0,0 +1,300 @@ +using System.Collections.Generic; +using AntMe.Deutsch; + +namespace AntMe.Spieler.TomWendel +{ + + /// + /// Diese Demoameise zeigt die Aufteilung der Ameisen in 2 Typen um + /// verschiedene Aufgaben wahr zu nehmen. Einerseits gibt es die Sammler die + /// möglichst viel tragen und schnell laufen können. Andererseits gibt es + /// die Wächter die auf den Ameisenstraßen mitpatroullieren um Käfer + /// abzuwehren. + /// + + [Spieler( + Volkname = "aTom Gruppenmeisen", + Vorname = "Tom", + Nachname = "Wendel" + )] + + [Kaste( + Name = "Sammler", + GeschwindigkeitModifikator = 2, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = 2, + ReichweiteModifikator = -1, + SichtweiteModifikator = 0, + EnergieModifikator = -1, + AngriffModifikator = -1 + )] + [Kaste( + Name = "Kämpfer", + GeschwindigkeitModifikator = -1, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = -1, + ReichweiteModifikator = -1, + SichtweiteModifikator = 0, + EnergieModifikator = 2, + AngriffModifikator = 2 + )] + + public class aTomGruppenmeise : Basisameise + { + /// + /// Bestimmt den Typ einer neuen Ameise. + /// + /// Die Anzahl der von jedem Typ bereits + /// vorhandenen Ameisen. + /// Der Name des Typs der Ameise. + public override string BestimmeKaste(Dictionary anzahl) + { + // Sollten noch keine Sammler existieren soll ein Sammler erzeugt werden. + // Diese Vorabfrage soll nur eine Null-Division bei der folgenden + // Entscheidung verhindern. + if (anzahl["Sammler"] == 0) + { + return "Sammler"; + } + else + { + // Sollte das Verhältnis Kämpfer/Sammler über 1 steigen (also mehr + // Kämpfer als Sammler) werden Sammler produziert, ansonsten Kämpfer. + return (float)anzahl["Kämpfer"] / anzahl["Sammler"] > 1.0f + ? "Sammler" : "Kämpfer"; + } + } + + #region Fortbewegung + + public override void Wartet() + { + + // Befindet sich die Ameise außerhalb des Nahrungsradius soll sie nach + // Hause gehen. + if (EntfernungZuBau > 400) + { + GeheZuBau(); + } + else + { + // ansonsten zufällig umherlaufen + DreheUmWinkel(Zufall.Zahl(-10, 10)); + GeheGeradeaus(20); + } + + // Wenn die Ameise am Limit ihrer Reichweite ist (abzüglich Entfernung zum + // Bau und einem Puffer) soll sie nach Hause gehen. + if (Reichweite - ZurückgelegteStrecke - 50 < EntfernungZuBau) + { + GeheZuBau(); + } + + } + + #endregion + #region Nahrung + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen + /// Zuckerhaufen sieht. + /// + /// Der nächstgelegene Zuckerhaufen. + public override void Sieht(Zucker zucker) + { + // Wenn Zucker in der Nähe ist soll eine Markierung gesprüht werden. Der + // Radius dieser Markierung richtet sich nach der Entfernung der Ameise + // zum Zucker damit die Markierung nicht über den Zucker hinaus zeigt. + SprüheMarkierung( + Koordinate.BestimmeRichtung(this, zucker), + Koordinate.BestimmeEntfernung(this, zucker)); + // Wenn die Ameise nichts trägt soll sie zum Zucker hin. + if (AktuelleLast == 0) + { + GeheZuZiel(zucker); + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein + /// Obststück sieht. + /// + /// Das nächstgelegene Obststück. + public override void Sieht(Obst obst) + { + // Sollte die betroffene Ameise ein Sammler sein, lastlos UND sollte das + // gefundene Obst noch Träger brauchen, geh hin. + if (AktuelleLast == 0 && Kaste == "Sammler" && + BrauchtNochTräger(obst)) + { + GeheZuZiel(obst); + } + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise einen Zuckerhaufen als Ziel + /// hat und bei diesem ankommt. + /// + /// Der Zuckerhaufen. + public override void ZielErreicht(Zucker zucker) + { + // Zucker nehmen und damit nach Hause laufen. + Nimm(zucker); + GeheZuBau(); + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und + /// bei diesem ankommt. + /// + /// Das Obstück. + public override void ZielErreicht(Obst obst) + { + // Da nur Sammler überhaupt zum Zucker gehen braucht hier keine + // Unterscheidung mehr stattzufinden aber alle Sammler nehmen das Obst + // mit, sofern dieses Obst noch Träger braucht. + if (BrauchtNochTräger(obst)) + { + Nimm(obst); + GeheZuBau(); + } + } + + #endregion + #region Kommunikation + + /// + /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben + /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut + /// gerochen. + /// + /// Die nächste neue Markierung. + public override void RiechtFreund(Markierung markierung) + { + // Auf Markierungen wird nur reagiert, wenn das Ziel nicht der Bau oder + // Zucker ist. + if (!(Ziel is Zucker) && !(Ziel is Bau)) + { + // Die Richtung aus der Markierung auslesen und über die Doppelte sichtweite loslaufen + DreheInRichtung(markierung.Information); + GeheGeradeaus(Sichtweite * 2); + + // Sollte die Entfernung mehr als 50 schritte zum Mittelpunkt betragen + // soll eine Folgemarkierung gesprüht werden um denn Effektradius zu + // erhöhen. + if (Koordinate.BestimmeEntfernung(this, markierung) > 50) + { + SprüheMarkierung( + Koordinate.BestimmeRichtung(this, markierung), + Koordinate.BestimmeEntfernung(this, markierung)); + } + } + } + + + #endregion + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer + /// sieht. + /// + /// Der nächstgelegene Käfer. + public override void SiehtFeind(Wanze wanze) + { + if (Kaste == "Sammler") + { + // Bei Käfersicht wird ermittelt ob die Sammlerameise evtl. kollidiert, + // wenn sie geradeaus weitergeht. + int relativeRichtung = + Koordinate.BestimmeRichtung(this, wanze) - Richtung; + if (relativeRichtung > -15 && relativeRichtung < 15) + { + LasseNahrungFallen(); + if (relativeRichtung < 0) + { + DreheUmWinkel(20 + relativeRichtung); + } + else + { + DreheUmWinkel(-20 - relativeRichtung); + } + GeheGeradeaus(100); + } + } + else + { + // Kämpfer greifen sofort an. + LasseNahrungFallen(); + GreifeAn(wanze); + } + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen + /// wird. + /// + /// Der angreifende Käfer. + public override void WirdAngegriffen(Wanze wanze) + { + // Wenn die Ameise direkt angegriffen wird lässt sie erst mal ihre Nahrung + // fallen. + LasseNahrungFallen(); + if (Kaste == "Sammler") + { + // Sammler flüchten. + GeheWegVon(wanze, 100); + } + else + { + // Kämpfer hauen drauf. + GreifeAn(wanze); + } + } + + #endregion + #region Sonstiges + + /// + /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen. + /// + public override void Tick() + { + + // Markierungshandling. + if (Ziel is Bau && + AktuelleLast > 0 && + GetragenesObst == null && + Kaste == "Sammler") + { + // Sammler, die mit Nahrung auf dem Rücken richtung Bau laufen sollen + // fortwährend Markierungen sprühen um eine Ameisenstrasse zu erzeugen. + if (Koordinate.BestimmeEntfernung(this, Ziel) < 100) + { + SprüheMarkierung( + Koordinate.BestimmeRichtung(Ziel, this), + 100 - Koordinate.BestimmeEntfernung(Ziel, this)); + } + else + { + SprüheMarkierung( + Koordinate.BestimmeRichtung(Ziel, this), + 20); + } + } + + // Sollten Kämpfer einen Käfer über größere Strecken verfolgen muss der + // Kampf iregendwann auch abgebrochen werden. Dies geschieht, wenn weniger + // als 3 Ameisen in der Nähe sind. Das sollte der Fall sein, wenn sich der + // Käfer nicht mehr in der Nähe einer Ameisenstrasse befindet. + if (Ziel is Wanze && AnzahlAmeisenInSichtweite < 3) + { + BleibStehen(); + } + } + + #endregion + + } + +} \ No newline at end of file diff --git a/DemoAmeisen/aTomKampfmeisen.cs b/DemoAmeisen/aTomKampfmeisen.cs new file mode 100644 index 0000000..fc6b89e --- /dev/null +++ b/DemoAmeisen/aTomKampfmeisen.cs @@ -0,0 +1,148 @@ +using System.Collections.Generic; +using AntMe.Deutsch; + +namespace AntMe.Spieler.TomWendel +{ + + /// + /// Demoameise die sich ausschließlich mit der Bekämpfung von gegnerischen + /// Käfern beschäftigt. Eine Ameise die einen Käfer sieht holt sofort mit + /// einem großen Markierungs-Ping möglichst viel Hilfe aus der Umgebung. Nach + /// einiger Zeit bilden sich dadurch kleine Jagdrudel die sehr effizient + /// Käfer töten + /// + + [Spieler( + Volkname = "aTom Kampfmeisen", + Vorname = "Tom", + Nachname = "Wendel" + )] + + [Kaste( + Name = "Killer", + GeschwindigkeitModifikator = -1, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = -1, + ReichweiteModifikator = -1, + SichtweiteModifikator = 0, + EnergieModifikator = 2, + AngriffModifikator = 2 + )] + + public class aTomKampfmeisen : Basisameise + { + /// + /// Bestimmt den Typ einer neuen Ameise. + /// + /// Die Anzahl der von jedem Typ bereits + /// vorhandenen Ameisen. + /// Der Name des Typs der Ameise. + public override string BestimmeKaste(Dictionary anzahl) + { + // Erzeuge immer eine Ameise vom Typ "Killer". + return "Killer"; + } + + #region Fortbewegung + + /// + /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie + /// hingehen soll. + /// + public override void Wartet() + { + // Ameise soll möglichst gut gestreut aber ziellos umherirren um möglichst + // schnell Käfer zu finden. + GeheGeradeaus(40); + DreheUmWinkel(Zufall.Zahl(-10, 10)); + } + + #endregion + #region Kommunikation + + /// + /// Wird wiederholt aufgerufen in der die Ameise mindestens eine + /// Markierung des selben Volkes riecht. + /// + /// Die nächstgelegene neue Markierung. + public override void RiechtFreund(Markierung markierung) + { + // Die Ameise soll, sofern sie nicht schon ein Ziel wie "Käfer", + // "Markierung" oder "Bau" hat auf direktem Weg zum Markierungsmittelpunkt + // laufen von wo aus man hoffentlich weitere Markierungen oder direkt den + // Käfer sieht. + if (Ziel == null) + { + GeheZuZiel(markierung); + } + } + + #endregion + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer + /// sieht. + /// + /// Der nächstgelegene Käfer. + public override void SiehtFeind(Wanze wanze) + { + // Wenn ein Käfer gesehen wird muss eine angemessen große Markierung + // gesprüht werden. Ist diese Markierung zu klein kommt zu wenig Hilfe, + // ist sie zu groß haben die weit entfernten Ameisen eine zu große Strecke + // und kommen erst nach dem Kampf an. + SprüheMarkierung(0, 150); + GreifeAn(wanze); + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines + /// anderen Volkes sieht. + /// + /// Die nächstgelegen feindliche Ameise. + public override void SiehtFeind(Ameise ameise) + { + // Feindliche Ameisen werden bedingungslos angegriffen! + GreifeAn(ameise); + } + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen + /// wird. + /// + /// Der angreifende Käfer. + public override void WirdAngegriffen(Wanze wanze) + { + // Wenn der Käfer angreift: Zurückschlagen. + GreifeAn(wanze); + } + + #endregion + #region Sonstiges + + public override void Tick() + { + + // Sollte die Ameise am Ende ihrer Reichweite sein (Abzüglich einem Puffer + // und der Strecke die sie noch zum Bau zurücklegen muss) soll sie nach + // Hause gehen um aufzuladen. + if (Reichweite - ZurückgelegteStrecke - 100 < + EntfernungZuBau) + { + GeheZuBau(); + } + + // Sollte eine Ameise durch den Kampf unter die 2/3-Marke ihrer Energie + // fallen soll sie nach Hause gehen um aufzuladen. + if (AktuelleEnergie < MaximaleEnergie * 2 / 3) + { + GeheZuBau(); + } + + } + + #endregion + + } + +} \ No newline at end of file diff --git a/DemoAmeisen/aTomZuckermeisen.cs b/DemoAmeisen/aTomZuckermeisen.cs new file mode 100644 index 0000000..3d05036 --- /dev/null +++ b/DemoAmeisen/aTomZuckermeisen.cs @@ -0,0 +1,217 @@ +using System.Collections.Generic; +using AntMe.Deutsch; + +namespace AntMe.Spieler.TomWendel +{ + + /// + /// Demonstrationsameise die sich nur mit dem Sammeln von Zucker beschäftigt. + /// Strategie dieser Ameise ist die möglichst schnelle Publikation neuer + /// Zuckerhaufen um dort durch effiziente Ameisenstraßen alle restlichen + /// Ameisen für den Zuckertransport zu binden. Obst wird komplett ignoriert + /// und Käfern wird ausgewichen. + /// + + [Spieler( + Volkname = "aTom Zuckermeisen", + Vorname = "Tom", + Nachname = "Wendel" + )] + + [Kaste( + Name = "Sammler", + GeschwindigkeitModifikator = 2, + DrehgeschwindigkeitModifikator = -1, + LastModifikator = 2, + ReichweiteModifikator = -1, + SichtweiteModifikator = 0, + EnergieModifikator = -1, + AngriffModifikator = -1 + )] + + public class aTomZuckermeise : Basisameise + { + /// + /// Bestimmt den Typ einer neuen Ameise. + /// + /// Die Anzahl der von jedem Typ bereits + /// vorhandenen Ameisen. + /// Der Name des Typs der Ameise. + public override string BestimmeKaste(Dictionary anzahl) + { + // Erzeugt immer den Standardtyp "Sammler". + return "Sammler"; + } + + #region Fortbewegung + + /// + /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie + /// hingehen soll. + /// + public override void Wartet() + { + + // Sollte die Ameise außerhalb des Nahrungsmittelradiuses liegen... + if (EntfernungZuBau > 400) + { + // ... soll sie wieder heim gehen. + GeheZuBau(); + } + else + { + // ... ansonsten soll sie sich ein bischen drehen (zufälliger Winkel + // zwischen -10 und 10 Grad) und wieder ein paar Schritte laufen. + DreheUmWinkel(Zufall.Zahl(-10, 10)); + GeheGeradeaus(20); + } + + // Wenn die restliche verfügbare Strecke der Ameise (minus einem Puffer + // von 50 Schritten) kleiner als die Entfernung zum Bau ist... + if (Reichweite - ZurückgelegteStrecke - 50 < EntfernungZuBau) + { + // ... soll sie nach Hause gehen um nicht zu sterben. + GeheZuBau(); + } + + } + + #endregion + #region Nahrung + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen + /// Zuckerhaufen sieht. + /// + /// Der nächstgelegene Zuckerhaufen. + public override void Sieht(Zucker zucker) + { + + // Wenn Zucker in der Nähe ist soll eine Markierung gesprüht werden. Der + // Radius dieser Markierung richtet sich nach der Entfernung der Ameise + // zum Zucker damit die Markierung nicht über den Zucker hinaus zeigt. + SprüheMarkierung( + Koordinate.BestimmeRichtung(this, zucker), + Koordinate.BestimmeEntfernung(this, zucker)); + + // Gebe Debug-Nachricht aus + Denke("Wow! Zucker!"); + + // Wenn die Ameise nichts trägt soll sie zum Zucker hin. + if (AktuelleLast == 0) + { + GeheZuZiel(zucker); + } + + } + + /// + /// Wird einmal aufgerufen, wenn die Ameise einen Zuckerhaufen als Ziel + /// hat und bei diesem ankommt. + /// + /// Der Zuckerhaufen. + public override void ZielErreicht(Zucker zucker) + { + // Zucker nehmen und damit nach Hause laufen. + Nimm(zucker); + GeheZuBau(); + } + + #endregion + #region Kommunikation + + /// + /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben + /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut + /// gerochen. + /// + /// Die nächste neue Markierung. + public override void RiechtFreund(Markierung markierung) + { + // Auf Markierungen wird nur reagiert, wenn das Ziel nicht der Bau oder + // Zucker ist. + if (!(Ziel is Zucker) && !(Ziel is Bau)) + { + + // Die Richtung aus der Markierung auslesen und über die doppelte + // Sichtweite loslaufen. + DreheInRichtung(markierung.Information); + GeheGeradeaus(Sichtweite * 2); + + // Sollte die Entfernung mehr als 50 schritte zum Mittelpunkt betragen + // soll eine Folgemarkierung gesprüht werden um denn Effektradius zu + // erhöhen. + if (Koordinate.BestimmeEntfernung(this, markierung) > 50) + { + SprüheMarkierung( + Koordinate.BestimmeRichtung(this, markierung), + Koordinate.BestimmeEntfernung(this, markierung)); + } + } + } + + #endregion + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer + /// sieht. + /// + /// Der nächstgelegene Käfer. + public override void SiehtFeind(Wanze wanze) + { + // Bei Käfersicht wird ermittelt ob die Ameise evtl. kollidiert, wenn sie + // geradeaus weitergeht. + int relativeRichtung = + Koordinate.BestimmeRichtung(this, wanze) - Richtung; + if (relativeRichtung > -15 && relativeRichtung < 15) + { + // Wenn ja, soll sie erstmal die Nahrung fallen lassen um schneller zu + // laufen und dann, je nachdem auf welcher Seite der Käfer ist, in einem + // 20 Grad-Winkel in die andere Richtung weggehen. + LasseNahrungFallen(); + if (relativeRichtung < 0) + { + DreheUmWinkel(20 + relativeRichtung); + } + else + { + DreheUmWinkel(-20 - relativeRichtung); + } + GeheGeradeaus(100); + } + } + + #endregion + #region Sonstiges + + /// + /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen. + /// + public override void Tick() + { + // Sollte die Ameise gerade mit Nahrung unterwegs sein... + if (Ziel != null && AktuelleLast > 0) + { + // ... Ist die Ameise näher als 100 Schritte am Zeil werden die + // Markierungen stetig größer um die Ameisen abzugreifen die am anderen + // Ende des Baus weglaufen. + if (Koordinate.BestimmeEntfernung(this, Ziel) < 100) + { + SprüheMarkierung(Koordinate.BestimmeRichtung(Ziel, this), + 100 - Koordinate.BestimmeEntfernung(Ziel, this)); + } + else + { + // ... ansonsten eine möglichst dünne Ameisenstraße um präzise genug + // leiten zu können. + SprüheMarkierung(Koordinate.BestimmeRichtung(Ziel, this), 20); + } + } + } + + #endregion + + } + +} diff --git a/GdiPlusPlugin/AntInfoBox.cs b/GdiPlusPlugin/AntInfoBox.cs new file mode 100644 index 0000000..95eed8c --- /dev/null +++ b/GdiPlusPlugin/AntInfoBox.cs @@ -0,0 +1,108 @@ +using System; +using System.Drawing; +using System.Windows.Forms; + +using AntMe.SharedComponents.States; +using AntMe.SharedComponents.Tools; + +namespace AntMe.Plugin.GdiPlusPlugin +{ + + /// + /// Information-Kontrollelement für Ameisen. + /// + internal class AntInfoBox : InfoBox + { + + private AntState ant; + private int colonyId; + private Brush brush; + private PointF[] arrow = new PointF[3]; + private string casteColony; + + /// + /// Erzeugt eine AntInfoBox-Instanz. + /// + /// Die Ameise. + /// Der Pinsel mit dem gezeichnet werden soll. + public AntInfoBox(AntState ant, int colonyId, string colonyName, string casteName, Brush brush) + { + // Setze Größe und Randabstand. + Width = 150; + Height = 73; + Margin = new Padding(0); + + // Erzeuge die Hintergrund-Grafik und hole ihre Zeichenfläche. + bitmap = new Bitmap(Width, Height); + graphics = Graphics.FromImage(bitmap); + + this.ant = ant; + this.colonyId = colonyId; + this.brush = brush; + + name = string.Format(Resource.AntName, NameHelper.GetFemaleName(ant.Id)); + if (!string.IsNullOrEmpty(casteName)) + casteColony = casteName + ", " + colonyName; + else + casteColony = colonyName; + } + + public int ColonyId + { + get { return colonyId; } + } + + /// + /// Die Id der Ameise zu der Informationen dargestellt werden sollen. + /// + public override int Id + { + get { return ant.Id; } + } + + /// + /// Die Ameise zu der Informationen dargestellt werden sollen. + /// + public AntState Ant + { + set + { + ant = value; + OnPaint(new PaintEventArgs(CreateGraphics(), ClientRectangle)); + } + } + + /// + /// Zeichnet die Informationen neu. + /// + /// Ereignisargumente + protected override void OnPaint(PaintEventArgs e) + { + // Lösche die Zeichenfläche. + graphics.Clear(Color.White); + + float y = 0f; + + // Zeichne den Namen, die Kaste und das Volk. + graphics.DrawString(name, boldFont, Brushes.Black, 0f, y); + y += 15f; + graphics.DrawString(casteColony, defaultFont, Brushes.Black, 0f, y); + y += 15f; + + // Berechne und zeichne den Richtungspfeil. + float xx, yy; + xx = 5f * (float)Math.Cos(ant.Direction * Math.PI / 180d); + yy = 5f * (float)Math.Sin(ant.Direction * Math.PI / 180d); + arrow[0] = new PointF(15f + 3f * xx, y + 15f + 3f * yy); + arrow[1] = new PointF(15f - 3f * xx + yy, y + 15f - 3f * yy - xx); + arrow[2] = new PointF(15f - 3f * xx - yy, y + 15f - 3f * yy + xx); + graphics.FillPolygon(brush, arrow); + + // Zeichne Energie und Last. + graphics.DrawString(ant.Vitality.ToString(), bigFont, Brushes.Red, 40f, y); + graphics.DrawString(ant.Load.ToString(), bigFont, Brushes.Green, 100f, y); + + base.OnPaint(e); + } + } +} \ No newline at end of file diff --git a/GdiPlusPlugin/AntMe.snk b/GdiPlusPlugin/AntMe.snk new file mode 100644 index 0000000..cdd75a4 Binary files /dev/null and b/GdiPlusPlugin/AntMe.snk differ diff --git a/GdiPlusPlugin/BugInfoBox.cs b/GdiPlusPlugin/BugInfoBox.cs new file mode 100644 index 0000000..039271d --- /dev/null +++ b/GdiPlusPlugin/BugInfoBox.cs @@ -0,0 +1,86 @@ +using System; +using System.Drawing; +using System.Windows.Forms; + +using AntMe.SharedComponents.States; +using AntMe.SharedComponents.Tools; + +namespace AntMe.Plugin.GdiPlusPlugin +{ + + /// + /// Information-Kontrollelement für Wanze. + /// + internal class BugInfoBox : InfoBox + { + + private BugState bug; + private PointF[] arrow = new PointF[3]; + + /// + /// Erzeugt eine BugInfoBox-Instanz. + /// + /// Die Wanze. + public BugInfoBox(BugState bugState) + { + // Setze Größe und Randabstand. + Width = 150; + Height = 63; + Margin = new Padding(0); + + // Erzeuge die Hintergrund-Grafik und hole ihre Zeichenfläche. + bitmap = new Bitmap(Width, Height); + graphics = Graphics.FromImage(bitmap); + + bug = bugState; + name = string.Format(Resource.BugName, NameHelper.GetMaleName(bugState.Id)); + } + + /// + /// Die Id der Wanze zu der Informationen dargestellt werden sollen. + /// + public override int Id + { + get { return bug.Id; } + } + + /// + /// Die Wanze deren Werte dargestellt werden sollen. + /// + public BugState Bug + { + set + { + bug = value; + OnPaint(new PaintEventArgs(CreateGraphics(), ClientRectangle)); + } + } + + /// + /// Zeichnet die Informationen neu. + /// + /// Ereignisargumente + protected override void OnPaint(PaintEventArgs e) + { + // Lösche die Zeichenfläche. + graphics.Clear(Color.White); + + // Zeichne den Namen. + graphics.DrawString(name, boldFont, Brushes.Black, 0f, 0f); + + // Berechne und zeichne den Richtungspfeil. + float x, y; + x = 5f * (float)Math.Cos(bug.Direction * Math.PI / 180d); + y = 5f * (float)Math.Sin(bug.Direction * Math.PI / 180d); + arrow[0] = new PointF(15f + 3f * x, 30f + 3f * y); + arrow[1] = new PointF(15f - 3f * x + y, 30f - 3f * y - x); + arrow[2] = new PointF(15f - 3f * x - y, 30f - 3f * y + x); + graphics.FillPolygon(Playground.bugBrush, arrow); + + // Zeichne die Energie. + graphics.DrawString(bug.Vitality.ToString(), bigFont, Brushes.Red, 40f, 15f); + + base.OnPaint(e); + } + } +} \ No newline at end of file diff --git a/GdiPlusPlugin/GdiPlusPlugin.csproj b/GdiPlusPlugin/GdiPlusPlugin.csproj new file mode 100644 index 0000000..ce8d973 --- /dev/null +++ b/GdiPlusPlugin/GdiPlusPlugin.csproj @@ -0,0 +1,153 @@ + + + + Debug + AnyCPU + 9.0.21022 + 2.0 + {4083B1E6-5EB5-4E51-BB09-EEC4B489F355} + Library + Properties + AntMe.Plugin.GdiPlusPlugin + AntMe.Plugin.GdiPlusPlugin + v4.0 + 512 + SAK + SAK + SAK + SAK + + + 3.5 + + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + + true + ..\bin\ + DEBUG;TRACE + full + x86 + true + GlobalSuppressions.cs + prompt + AllRules.ruleset + + + ..\bin\ + TRACE + true + pdbonly + x86 + true + GlobalSuppressions.cs + prompt + + + AllRules.ruleset + + + true + + + AntMe.snk + + + + + + + + + + + Component + + + Component + + + True + True + Resource.resx + + + Form + + + Component + + + + + Component + + + Window.cs + + + + + ResXFileCodeGenerator + Resource.Designer.cs + Designer + + + Window.cs + Designer + + + Window.cs + Designer + + + + + {415F50C3-BD70-4634-B1F7-A15B42F0B0C6} + SharedComponents + + + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + true + + + False + Windows Installer 3.1 + true + + + + + + + + \ No newline at end of file diff --git a/GdiPlusPlugin/InfoBox.cs b/GdiPlusPlugin/InfoBox.cs new file mode 100644 index 0000000..72b4976 --- /dev/null +++ b/GdiPlusPlugin/InfoBox.cs @@ -0,0 +1,63 @@ +using System.Drawing; +using System.Windows.Forms; + +namespace AntMe.Plugin.GdiPlusPlugin +{ + + /// + /// Basisklasse für alle Information-Kontrollelemente. + /// + internal abstract class InfoBox : Control + { + + /// + /// Schriftart zur Anzeige der Informationen. + /// + protected static Font boldFont, bigFont; + + /// + /// Schriftart zur Anzeige der Informationen. + /// + protected static Font defaultFont; + + /// + /// Der Name des Insekts. + /// + protected string name; + + /// + /// Der statische Konstruktor. + /// + static InfoBox() + { + // Erzeuge die Schriftarten. + defaultFont = new Font("Microsoft Sans Serif", 8.25f); + boldFont = new Font(defaultFont, FontStyle.Bold); + bigFont = new Font("Microsoft Sans Serif", 20f); + } + + public InfoBox() + { + // Sage Windows, daß wir das Puffern beim Zeichnen selbst übernehmen. + SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint, true); + UpdateStyles(); + } + + /// + /// Die Id des Insekts zu dem Informationen dargestellt werden sollen. + /// + public abstract int Id { get; } + + // Die Hintergrund-Grafik und ihre Zeichenfläche. + protected Bitmap bitmap; + protected Graphics graphics; + + protected override void OnPaint(PaintEventArgs e) + { + // Zeichne die Hintergrund-Grafik. + e.Graphics.DrawImageUnscaled(bitmap, 0, 0); + } + + } + +} \ No newline at end of file diff --git a/GdiPlusPlugin/Playground.cs b/GdiPlusPlugin/Playground.cs new file mode 100644 index 0000000..af713d4 --- /dev/null +++ b/GdiPlusPlugin/Playground.cs @@ -0,0 +1,611 @@ +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Windows.Forms; + +using AntMe.SharedComponents.Tools; +using AntMe.SharedComponents.States; + +namespace AntMe.Plugin.GdiPlusPlugin +{ + + /// + /// Kontrollelement, das ein Spielfeld zeichnet. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + internal class Playground : Control + { + // Verweis auf das übergeordnete Fenster. Der Verweis kann auch über + // (Fenster)Control.Parent geholt werden, das geht aber erst wenn das + // Kontrollelement dem Fenster hinzugefügt wurde. So ist es einfacher. + private Window window; + + // Zeichenflächen für die Hintergrund-Grafik und das + // Spielfeld-Kontrollelement. + private Bitmap bitmap; + private Graphics bitmapGraphics, controlGraphics; + + /// + /// Gibt zurück oder legt fest ob die Punktetabelle angezeigt wird. + /// + public bool ShowScore; + + #region Statischer Teil + + public static Color[] playerColors = { + Color.Black, + Color.Red, + Color.Green, + Color.Blue, + Color.Orange, + Color.Cyan, + Color.Fuchsia, + Color.White + }; + + private static Color skyColor = Color.FromArgb(51, 153, 255); + private static Color playgroundColor = Color.FromArgb(162, 162, 104); + private static Color sugarColor = Color.White; + private static Color fruitColor = Color.FromArgb(0, 224, 0); + private static Color bugColor = Color.FromArgb(0, 0, 150); + private static Color anthillColor = Color.FromArgb(97, 97, 63); + private static Color markerColor = Color.Yellow; + private static Color boxColor = Color.FromArgb(255, 255, 255, 128); + + private static SolidBrush anthillBrush = new SolidBrush(anthillColor); + public static SolidBrush bugBrush = new SolidBrush(bugColor); + private static SolidBrush fruitBrush = new SolidBrush(fruitColor); + private static SolidBrush playgroundBrush = new SolidBrush(playgroundColor); + private static SolidBrush sugarBrush = new SolidBrush(sugarColor); + private static SolidBrush markerBrush = new SolidBrush(Color.FromArgb(21, Color.Yellow)); + private static SolidBrush[] markerBrushes; + public static SolidBrush[] playerBrushes; + + private static Font bigBoldFont = new Font("Courier New", 30f, FontStyle.Bold); + private static Font smallFont = new Font("MS Sans Serif", 10f); + private static Font smallBoldFont = new Font("MS Sans Serif", 10f, FontStyle.Bold); + + private static SolidBrush selectionBrush = new SolidBrush(Color.FromArgb(128, SystemColors.Highlight)); + private static SolidBrush scoreBrush = new SolidBrush(Color.FromArgb(192, 255, 255, 255)); + + private static Pen selectionPen = new Pen(SystemColors.Highlight); + private static Pen bugPen = new Pen(bugColor, 6f); + private static Pen sugarPen = new Pen(sugarColor); + private static Pen[] playerPens; + + private Rectangle playgroundRectangle; + + private static readonly float[] cos1 = new float[360]; + private static readonly float[] cos2 = new float[360]; + private static readonly float[] cos4 = new float[360]; + private static readonly float[] sin1 = new float[360]; + private static readonly float[] sin2 = new float[360]; + private static readonly float[] sin4 = new float[360]; + + static Playground() + { + playerBrushes = new SolidBrush[playerColors.Length]; + markerBrushes = new SolidBrush[playerColors.Length]; + playerPens = new Pen[playerColors.Length]; + for (int i = 0; i < playerColors.Length; i++) + { + playerBrushes[i] = new SolidBrush(playerColors[i]); + markerBrushes[i] = new SolidBrush(Color.FromArgb(16, playerColors[i])); + playerPens[i] = new Pen(playerBrushes[i], 2f); + } + + for (int angle = 0; angle < 360; angle++) + { + cos1[angle] = (float)Math.Cos(angle * Math.PI / 180d); + sin1[angle] = (float)Math.Sin(angle * Math.PI / 180d); + cos2[angle] = 2f * cos1[angle]; + sin2[angle] = 2f * sin1[angle]; + cos4[angle] = 4f * cos1[angle]; + sin4[angle] = 4f * sin1[angle]; + } + } + + #endregion + + /// + /// Erzeugt eine Playground-Instanz. + /// + /// Das übergeordnete Fenster + public Playground(Window window) + { + this.window = window; + + // Sage Windows, daß wir das Puffern beim Zeichnen selbst übernehmen. + SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint, true); + UpdateStyles(); + + KeyDown += playground_KeyDown; + KeyUp += playground_KeyUp; + MouseWheel += playground_MouseWheel; + MouseDown += playground_MouseDown; + MouseMove += playground_MouseMove; + MouseUp += playground_MouseUp; + MouseDoubleClick += playground_MouseDoubleClick; + } + + #region Ereignisbehandlung + + private List selectedAnts = new List(); + private List selectedBugs = new List(); + + private int selectionX0, selectionY0, selectionX1, selectionY1; + private int deltaX, deltaY; + private int mouseX, mouseY; + + private bool shiftPressed; + private bool controlPressed; + + private Matrix transform; + private Matrix transformOld; + + private long timeStamp; + + private void startTransform() + { + transformOld = transform.Clone(); + mouseX = -1; + } + + private void playground_KeyUp(object sender, KeyEventArgs e) + { + switch (e.KeyCode) + { + // Skalieren des Spielfelds mit der Maus. + case Keys.ShiftKey: + if (shiftPressed) + { + startTransform(); + shiftPressed = false; + } + break; + + // Drehen des Spielfelds mit der Maus. + case Keys.ControlKey: + if (controlPressed) + { + startTransform(); + controlPressed = false; + } + break; + } + } + + private void playground_KeyDown(object sender, KeyEventArgs e) + { + switch (e.KeyCode) + { + // Skalieren des Spielfelds mit der Maus. + case Keys.ShiftKey: + if (!shiftPressed) + { + startTransform(); + shiftPressed = true; + } + break; + + // Drehen des Spielfelds mit der Maus. + case Keys.ControlKey: + if (!controlPressed) + { + startTransform(); + controlPressed = true; + } + break; + } + } + + private void playground_MouseDown(object sender, MouseEventArgs e) + { + Focus(); + + if (e.Button == MouseButtons.Left) + mouseX = -1; + + else if (e.Button == MouseButtons.Right) + startTransform(); + } + + private void playground_MouseMove(object sender, MouseEventArgs e) + { + if (mouseX == -1) + { + mouseX = e.X; + mouseY = e.Y; + } + + // Bestimme wie weit die Maus bewegt wurde. + deltaX = e.X - mouseX; + deltaY = e.Y - mouseY; + + if (e.Button == MouseButtons.Left) + { + if (deltaX >= 0) + { + selectionX0 = mouseX; + selectionX1 = mouseX + deltaX; + } + else + { + selectionX1 = mouseX; + selectionX0 = mouseX + deltaX; + } + + if (deltaY >= 0) + { + selectionY0 = mouseY; + selectionY1 = mouseY + deltaY; + } + else + { + selectionY1 = mouseY; + selectionY0 = mouseY + deltaY; + } + + // Zeichne nur dann, wenn der letzte Zeichenvorgang lange genug zurückliegt. + if (DateTime.Now.Ticks - timeStamp > 400000) + Draw(); + } + else if (e.Button == MouseButtons.Right) + { + // Stelle die gesicherte Transformationsmatrix wieder her. + transform = transformOld.Clone(); + + // Die neue Transformationsmatrix ergibt sich aus der alten Matrix und der + // Bewegung seit Beginn der Transformation. Das ist genauer und numerisch + // stabiler (d.h. weniger Rechenfehler durch Zahlen nahe bei der Null) + // als die Matrix immer nur ein klein wenig zu verändern. + + // Skaliere das Spielfeld. + if (shiftPressed) + { + float factor = (float)Math.Pow(1.01d, deltaX); + transform.Translate(-Width / 2f, -Height / 2f, MatrixOrder.Append); + transform.Scale(factor, factor, MatrixOrder.Append); + transform.Translate(Width / 2f, Height / 2f, MatrixOrder.Append); + } + + // Drehe das Spielfeld. + else if (controlPressed) + transform.RotateAt(deltaX, new PointF(Width / 2f, Height / 2f), MatrixOrder.Append); + + // Verschiebe das Spielfeld. + else + transform.Translate(deltaX, deltaY, MatrixOrder.Append); + + // Zeichne nur dann, wenn der letzte Zeichenvorgang lange genug zurückliegt. + if (DateTime.Now.Ticks - timeStamp > 400000) + Draw(); + } + } + + private void playground_MouseUp(object sender, MouseEventArgs e) + { + if (e.Button == MouseButtons.Left) + { + PointF[] points; + selectedAnts.Clear(); + selectedBugs.Clear(); + + // Erzeuge ein Array für die Koordinaten aller Käfer. + points = new PointF[window.State.BugStates.Count]; + + // Kopiere die Koordinaten in das Array. + for (int k = 0; k < points.Length; k++) + points[k] = new PointF(window.State.BugStates[k].PositionX, window.State.BugStates[k].PositionY); + + // Transfomiere die Koordinaten. + transform.TransformPoints(points); + + // Füge alle Käfer die sich innerhalb des Auswahlrechtecks befinden + // der Liste der ausgewählten Käfer hinzu. + for (int k = 0; k < points.Length; k++) + if (points[k].X >= selectionX0 && points[k].X <= selectionX1 && points[k].Y >= selectionY0 && + points[k].Y <= selectionY1) + selectedBugs.Add(window.State.BugStates[k].Id); + + // Das selbe für die Ameisen aller Völker. + + for (int v = 0; v < window.State.ColonyStates.Count; v++) + { + points = new PointF[window.State.ColonyStates[v].AntStates.Count]; + + for (int a = 0; a < points.Length; a++) + points[a] = + new PointF + (window.State.ColonyStates[v].AntStates[a].PositionX, + window.State.ColonyStates[v].AntStates[a].PositionY); + + transform.TransformPoints(points); + + for (int a = 0; a < points.Length; a++) + if (points[a].X >= selectionX0 && points[a].X <= selectionX1 && points[a].Y >= selectionY0 && + points[a].Y <= selectionY1) + selectedAnts.Add(window.State.ColonyStates[v].AntStates[a].Id); + } + + // Gib die Auswahl an das übergeordnete Fenster weiter. + window.ShowInformation(selectedBugs, selectedAnts); + + selectionX0 = -1; + } + + Draw(); + } + + private void playground_MouseWheel(object sender, MouseEventArgs e) + { + float factor = (float)Math.Pow(1.01d, e.Delta / 10d); + transform.Translate(-Width / 2f, -Height / 2f, MatrixOrder.Append); + transform.Scale(factor, factor, MatrixOrder.Append); + transform.Translate(Width / 2f, Height / 2f, MatrixOrder.Append); + + // Zeichne nur dann, wenn der letzte Zeichenvorgang lange genug zurückliegt. + if (DateTime.Now.Ticks - timeStamp > 400000) + Draw(); + } + + private void playground_MouseDoubleClick(object sender, MouseEventArgs e) + { + if (e.Button == MouseButtons.Left) + ResetSelection(); + + // Zeichne nur dann, wenn der letzte Zeichenvorgang lange genug zurückliegt. + Draw(); + } + + public void ResetSelection() + { + selectedAnts.Clear(); + selectedBugs.Clear(); + selectionX0 = -1; + } + + #endregion + + /// + /// Zeichnet das Spielfeld in die Hintergrund-Grafik und diese auf das + /// Kontrollelement. + /// + public void Draw() + { + + // Brich ab, falls die Hintergrund-Zeichenfläche noch nicht existiert. + if (bitmapGraphics == null) + return; + + int a, b, k, m, o, v, z; + + // Erzeuge in der ersten Runde nötige Objekte. + if (window.State.CurrentRound == 1) + { + playgroundRectangle = new Rectangle(0, 0, window.State.PlaygroundWidth, window.State.PlaygroundHeight); + ResetView(); + } + + // Setze die Transformationsmatrix für das Spielfeld. Dadurch können wir + // in Spielfeldkoordinaten zeichnen, egal wie das Fenster aussieht. + bitmapGraphics.Transform = transform.Clone(); + + // Zeichne den Himmel und das Spielfeld. + bitmapGraphics.Clear(skyColor); + bitmapGraphics.FillRectangle(playgroundBrush, playgroundRectangle); + + // Zeichne die Markierungen aller Völker. + for (v = 0; v < window.State.ColonyStates.Count; v++) + { + SolidBrush brush = window.State.ColonyStates.Count == 1 + ? markerBrush : markerBrushes[v]; + + for (m = 0; m < window.State.ColonyStates[v].MarkerStates.Count; m++) + bitmapGraphics.FillEllipse + (brush, + window.State.ColonyStates[v].MarkerStates[m].PositionX - + window.State.ColonyStates[v].MarkerStates[m].Radius, + window.State.ColonyStates[v].MarkerStates[m].PositionY - + window.State.ColonyStates[v].MarkerStates[m].Radius, + window.State.ColonyStates[v].MarkerStates[m].Radius * 2f, + window.State.ColonyStates[v].MarkerStates[m].Radius * 2f); + } + + // Zeichne die Bauten aller Völker. + for (v = 0; v < window.State.ColonyStates.Count; v++) + for (b = 0; b < window.State.ColonyStates[v].AnthillStates.Count; b++) + { + bitmapGraphics.FillEllipse + (anthillBrush, + window.State.ColonyStates[v].AnthillStates[b].PositionX - window.State.ColonyStates[v].AnthillStates[b].Radius, + window.State.ColonyStates[v].AnthillStates[b].PositionY - window.State.ColonyStates[v].AnthillStates[b].Radius, + window.State.ColonyStates[v].AnthillStates[b].Radius * 2f, + window.State.ColonyStates[v].AnthillStates[b].Radius * 2f); + + if (window.State.ColonyStates.Count > 1) + bitmapGraphics.DrawString + ((v + 1).ToString(), bigBoldFont, playerBrushes[v], + window.State.ColonyStates[v].AnthillStates[b].PositionX - 18f, + window.State.ColonyStates[v].AnthillStates[b].PositionY - 20f); + } + + // Zeichne alle Zuckerhaufen. + for (z = 0; z < window.State.SugarStates.Count; z++) + bitmapGraphics.FillEllipse + (sugarBrush, window.State.SugarStates[z].PositionX - window.State.SugarStates[z].Radius, + window.State.SugarStates[z].PositionY - window.State.SugarStates[z].Radius, + window.State.SugarStates[z].Radius * 2f, window.State.SugarStates[z].Radius * 2f); + + // Markiere die ausgewählten Wanzen. + if (selectedBugs.Count > 0) + for (k = 0; k < window.State.BugStates.Count; k++) + if (selectedBugs.Contains(window.State.BugStates[k].Id)) + bitmapGraphics.FillEllipse + (selectionBrush, window.State.BugStates[k].PositionX - 12f, + window.State.BugStates[k].PositionY - 12f, 24f, 24f); + + // Zeichne alle Wanzen. + for (k = 0; k < window.State.BugStates.Count; k++) + bitmapGraphics.DrawLine + (bugPen, window.State.BugStates[k].PositionX - cos4[window.State.BugStates[k].Direction], + window.State.BugStates[k].PositionY - sin4[window.State.BugStates[k].Direction], + window.State.BugStates[k].PositionX + cos4[window.State.BugStates[k].Direction], + window.State.BugStates[k].PositionY + sin4[window.State.BugStates[k].Direction]); + + // Markiere die ausgewählten Ameisen. + if (selectedAnts.Count > 0) + for (v = 0; v < window.State.ColonyStates.Count; v++) + for (a = 0; a < window.State.ColonyStates[v].AntStates.Count; a++) + if (selectedAnts.Contains(window.State.ColonyStates[v].AntStates[a].Id)) + bitmapGraphics.FillEllipse + (selectionBrush, window.State.ColonyStates[v].AntStates[a].PositionX - 8f, + window.State.ColonyStates[v].AntStates[a].PositionY - 8f, 16f, 16f); + + // Zeichne die Ameisen aller Völker. + for (v = 0; v < window.State.ColonyStates.Count; v++) + for (a = 0; a < window.State.ColonyStates[v].AntStates.Count; a++) + { + bitmapGraphics.DrawLine + (playerPens[v], + window.State.ColonyStates[v].AntStates[a].PositionX - + cos2[window.State.ColonyStates[v].AntStates[a].Direction], + window.State.ColonyStates[v].AntStates[a].PositionY - + sin2[window.State.ColonyStates[v].AntStates[a].Direction], + window.State.ColonyStates[v].AntStates[a].PositionX + + cos2[window.State.ColonyStates[v].AntStates[a].Direction], + window.State.ColonyStates[v].AntStates[a].PositionY + + sin2[window.State.ColonyStates[v].AntStates[a].Direction]); + + if (window.State.ColonyStates[v].AntStates[a].LoadType == LoadType.Sugar) + bitmapGraphics.DrawLine + (sugarPen, + window.State.ColonyStates[v].AntStates[a].PositionX - + cos1[window.State.ColonyStates[v].AntStates[a].Direction], + window.State.ColonyStates[v].AntStates[a].PositionY - + sin1[window.State.ColonyStates[v].AntStates[a].Direction], + window.State.ColonyStates[v].AntStates[a].PositionX + + cos1[window.State.ColonyStates[v].AntStates[a].Direction], + window.State.ColonyStates[v].AntStates[a].PositionY + + sin1[window.State.ColonyStates[v].AntStates[a].Direction]); + } + + // Zeichne alle Obststücke. + for (o = 0; o < window.State.FruitStates.Count; o++) + bitmapGraphics.FillEllipse + (fruitBrush, window.State.FruitStates[o].PositionX - window.State.FruitStates[o].Radius, + window.State.FruitStates[o].PositionY - window.State.FruitStates[o].Radius, + window.State.FruitStates[o].Radius * 2, window.State.FruitStates[o].Radius * 2); + + // Setze die Einheitsmatrix als Transformationsmatrix. Damit zeichnen + // wir jetzt wieder in Fensterkoordinaten. + bitmapGraphics.Transform = new Matrix(); + + // Auswahlrechteck. + if (selectionX0 > -1) + { + bitmapGraphics.FillRectangle + (selectionBrush, selectionX0, selectionY0, selectionX1 - selectionX0, selectionY1 - selectionY0); + bitmapGraphics.DrawRectangle + (selectionPen, selectionX0, selectionY0, selectionX1 - selectionX0, selectionY1 - selectionY0); + } + + if (ShowScore) + { + // Zeichne den Hintergrund des Punktekastens. + bitmapGraphics.FillRectangle + (scoreBrush, 10f, 10f, 250f, window.State.ColonyStates.Count * 16f + 18f); + + // Speichert die Y-Koordinate der aktuellen Textzeile. + float x, y; + + // Zeichne die Ãœberschriften des Punktekastens. + y = 20f; + + // Zeichne die Punkte aller Völker. + for (v = 0; v < window.State.ColonyStates.Count; v++) + { + bitmapGraphics.DrawString(window.State.ColonyStates[v].ColonyName, smallFont, Brushes.Black, 37f, y); + string s = window.State.ColonyStates[v].Points.ToString(); + x = bitmapGraphics.MeasureString(s, smallBoldFont).Width; + bitmapGraphics.DrawString(s, smallBoldFont, Brushes.Black, 250f - x, y); + bitmapGraphics.FillRectangle(playerBrushes[v], 20f, y + 2f, 11f, 11f); + y += 16f; + } + } + + timeStamp = DateTime.Now.Ticks; + + // Zeichne die Hintergrund-Grafik auf das Fenster. + OnPaint(new PaintEventArgs(controlGraphics, ClientRectangle)); + } + + /// + /// Zeichnet die Hintergrund-Grafik auf das Kontrollelement. + /// + /// + protected override void OnPaint(PaintEventArgs e) + { + // Zeichne die Hintergrund-Grafik auf das Fenster. + if (bitmap != null) + e.Graphics.DrawImageUnscaled(bitmap, 0, 0); + } + + // Die Hintergrund-Grafik in die das Spielfeld gezeichnet wird. Durch das + // Verwenden eines Puffers wird das Flimmern beim Neuzeichnen verhindert. + + /// + /// Erzwingt das Resize Ereignis. + /// + public void DoResize() + { + OnResize(null); + } + + /// + /// Passt die Größe des Spielfeldes innerhalb des Kontrollelementes an. + /// + /// + protected override void OnResize(EventArgs e) + { + // Brich ab, falls noch kein Zustand übergeben wurde. + if (window.State == null) + return; + + // Erzeuge die Zeichenfläche des Kontrollelements. + controlGraphics = CreateGraphics(); + + // Erzeuge die Hintergrund-Grafik und die zugehörige Zeichenfläche. + bitmap = new Bitmap(Width, Height); + bitmapGraphics = Graphics.FromImage(bitmap); + + // Schalte das Anti-Aliasing ein bzw. aus. + bitmapGraphics.SmoothingMode = + window.UseAntiAliasing ? SmoothingMode.HighQuality : SmoothingMode.HighSpeed; + + // Zeichne das Spielfeld neu. + Draw(); + } + + /// + /// Setzt die Ansicht des Spielfeldes zurück. + /// + public void ResetView() + { + // Berechne den Skalierungsfaktor und den linken und oberen Versatz. + float xScale = Width / (float)window.State.PlaygroundWidth; + float yScale = Height / (float)window.State.PlaygroundHeight; + float scale = Math.Min(xScale, yScale); + float width = window.State.PlaygroundWidth * scale; + float height = window.State.PlaygroundHeight * scale; + float xOffset = (Width - width) / 2f; + float yOffset = (Height - height) / 2f; + + // Berechne die Transformationsmatrix für das Spielfeld. + transform = new Matrix(); + transform.Translate(xOffset, yOffset); + transform.Scale(scale, scale); + } + } +} \ No newline at end of file diff --git a/GdiPlusPlugin/Plugin.cs b/GdiPlusPlugin/Plugin.cs new file mode 100644 index 0000000..6be942d --- /dev/null +++ b/GdiPlusPlugin/Plugin.cs @@ -0,0 +1,175 @@ +using System; +using System.Drawing; +using System.Windows.Forms; + +using AntMe.SharedComponents.Plugin; +using AntMe.SharedComponents.States; + +namespace AntMe.Plugin.GdiPlusPlugin +{ + + /// + /// AntMe! Verbraucher-Plugin das ein Spiel in einer GDI+ basierten 2D-Ansicht darstellt. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + public class Plugin : IConsumerPlugin + { + + private Window window; + + /// + /// Erzeugt eine neue Instanz der Plugin-Klasse. + /// + public Plugin() + { + window = new Window(); + } + + #region IPlugin + + private PluginState pluginStatus = PluginState.Ready; + + /// + /// Funktionsaufruf zum Starten des Plugin-Betriebs. + /// + public void Start() + { + window.Start(); + pluginStatus = PluginState.Running; + } + + /// + /// Funktionsaufruf zum Stoppen des Plugin-Betriebs. + /// + public void Stop() + { + window.Stop(); + pluginStatus = PluginState.Ready; + } + + /// + /// Hält den Betrieb des Plugins an. + /// + public void Pause() + { + pluginStatus = PluginState.Paused; + } + + /// + /// Gibt den Namen des Plugins zurück. + /// + public string Name + { + get { return "2D-Visualisierung"; } + } + + /// + /// Gibt einen Beschreibungstext dieses Plugins zurück. + /// + public string Description + { + get { return "Zeigen Sie die Simulation in einer 2D-Welt an"; } + } + + /// + /// Gibt die Versionsnummer dieses Plugins zurück. + /// + public Version Version + { + get { return new Version(1, 7); } + } + + /// + /// Gibt die GUID dieses Plugins zurück. + /// + public Guid Guid + { + get { return new Guid("BBBD7C7A-FD3A-4656-B6DC-6A88463B2815"); } + } + + /// + /// Liefert den aktuellen Status des Plugins zurück. + /// + public PluginState State + { + get { return pluginStatus; } + } + + /// + /// Liefert einen Verweis auf ein UserControl das im Hauptfenster + /// angezeigt wird. + /// + public Control Control + { + get { return null; } + } + + /// + /// Gibt einen Bytearray aus serialisierten Konfigurationsdaten dieses + /// Plugins zurück oder legt diesen fest. + /// + public byte[] Settings + { + get + { + return new byte[2] + { + window.UseAntiAliasing ? (byte)1 : (byte)0, + window.ShowScore ? (byte)1 : (byte)0 + }; + } + set + { + if (value.Length == 2) + { + window.UseAntiAliasing = value[0] == 0 ? false : true; + window.ShowScore = value[1] == 0 ? false : true; + } + } + } + + public void StartupParameter(string[] parameter) + { + } + + public void SetVisibility(bool visible) + { + } + + public void UpdateUI(SimulationState state) + { + window.Update(state); + } + + #endregion + + #region IConsumerPlugin + + public bool Interrupt + { + get + { + // Wenn das Spiel läuft oder pausiert ist (also nicht nur bereit) + // und das Fenster nicht sichtbar, dann wurde es geschlossen und + // die Simulation kann abgebrochen werden. + return (pluginStatus != PluginState.Ready && !window.Visible); + } + } + + public void CreateState(ref SimulationState state) + { + } + + public void CreatingState(ref SimulationState state) + { + } + + public void CreatedState(ref SimulationState state) + { + } + + #endregion + + } + +} \ No newline at end of file diff --git a/GdiPlusPlugin/Properties/AssemblyInfo.cs b/GdiPlusPlugin/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..060db4c --- /dev/null +++ b/GdiPlusPlugin/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// Allgemeine Informationen über eine Assembly werden über die folgenden +// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern, +// die mit einer Assembly verknüpft sind. +[assembly: AssemblyTitle("AntMe! GDI+ Plugin")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("AntMe! GmbH")] +[assembly: AssemblyProduct("AntMe!")] +[assembly: AssemblyCopyright("Copyright © 2014 AntMe! GmbH")] +[assembly: AssemblyTrademark("AntMe!")] +[assembly: AssemblyCulture("")] + +// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar +// für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von +// COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest. +[assembly: ComVisible(false)] + +// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird +[assembly: Guid("c0877b8a-2c25-4460-9529-c94db32a4c76")] + +// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +// +// Hauptversion +// Nebenversion +// Buildnummer +// Revision +// +// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern +// übernehmen, indem Sie "*" eingeben: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.7.1.93")] +[assembly: AssemblyFileVersion("1.7.1.93")] diff --git a/GdiPlusPlugin/Resource.Designer.cs b/GdiPlusPlugin/Resource.Designer.cs new file mode 100644 index 0000000..bee26c7 --- /dev/null +++ b/GdiPlusPlugin/Resource.Designer.cs @@ -0,0 +1,81 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Plugin.GdiPlusPlugin { + 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 Resource { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resource() { + } + + /// + /// 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("AntMe.Plugin.GdiPlusPlugin.Resource", typeof(Resource).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; + } + } + + /// + /// Looks up a localized string similar to Ameise {0}. + /// + internal static string AntName { + get { + return ResourceManager.GetString("AntName", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Wanze {0}. + /// + internal static string BugName { + get { + return ResourceManager.GetString("BugName", resourceCulture); + } + } + } +} diff --git a/GdiPlusPlugin/Resource.resx b/GdiPlusPlugin/Resource.resx new file mode 100644 index 0000000..7b6c0e4 --- /dev/null +++ b/GdiPlusPlugin/Resource.resx @@ -0,0 +1,130 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Ameise {0} + Name of an ant (AntInfoBox.cs) +0: Female name + + + Wanze {0} + Name of a bug (BugInfoBox.cs) +0: Male name + + \ No newline at end of file diff --git a/GdiPlusPlugin/Window.Designer.cs b/GdiPlusPlugin/Window.Designer.cs new file mode 100644 index 0000000..4f9f6ad --- /dev/null +++ b/GdiPlusPlugin/Window.Designer.cs @@ -0,0 +1,160 @@ +namespace AntMe.Plugin.GdiPlusPlugin { + partial class Window { + /// + /// Erforderliche Designervariable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Verwendete Ressourcen bereinigen. + /// + /// True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False. + protected override void Dispose(bool disposing) { + if (disposing && (components != null)) { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Vom Windows Form-Designer generierter Code + + /// + /// Erforderliche Methode für die Designerunterstützung. + /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden. + /// + private void InitializeComponent() { + System.Windows.Forms.Label label4; + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Window)); + System.Windows.Forms.Label label1; + this.splitContainer = new System.Windows.Forms.SplitContainer(); + this.btnResetView = new System.Windows.Forms.Button(); + this.cbUseAntiAliasing = new System.Windows.Forms.CheckBox(); + this.cbShowScore = new System.Windows.Forms.CheckBox(); + this.insectsPanel = new System.Windows.Forms.FlowLayoutPanel(); + label4 = new System.Windows.Forms.Label(); + label1 = new System.Windows.Forms.Label(); + this.splitContainer.Panel2.SuspendLayout(); + this.splitContainer.SuspendLayout(); + this.SuspendLayout(); + // + // label4 + // + label4.AccessibleDescription = null; + label4.AccessibleName = null; + resources.ApplyResources(label4, "label4"); + label4.BackColor = System.Drawing.SystemColors.ActiveCaption; + label4.ForeColor = System.Drawing.SystemColors.ActiveCaptionText; + label4.Name = "label4"; + // + // splitContainer + // + this.splitContainer.AccessibleDescription = null; + this.splitContainer.AccessibleName = null; + resources.ApplyResources(this.splitContainer, "splitContainer"); + this.splitContainer.BackgroundImage = null; + this.splitContainer.Font = null; + this.splitContainer.Name = "splitContainer"; + // + // splitContainer.Panel1 + // + this.splitContainer.Panel1.AccessibleDescription = null; + this.splitContainer.Panel1.AccessibleName = null; + resources.ApplyResources(this.splitContainer.Panel1, "splitContainer.Panel1"); + this.splitContainer.Panel1.BackgroundImage = null; + this.splitContainer.Panel1.Font = null; + // + // splitContainer.Panel2 + // + this.splitContainer.Panel2.AccessibleDescription = null; + this.splitContainer.Panel2.AccessibleName = null; + resources.ApplyResources(this.splitContainer.Panel2, "splitContainer.Panel2"); + this.splitContainer.Panel2.BackColor = System.Drawing.Color.White; + this.splitContainer.Panel2.BackgroundImage = null; + this.splitContainer.Panel2.Controls.Add(this.btnResetView); + this.splitContainer.Panel2.Controls.Add(this.cbUseAntiAliasing); + this.splitContainer.Panel2.Controls.Add(label1); + this.splitContainer.Panel2.Controls.Add(label4); + this.splitContainer.Panel2.Controls.Add(this.cbShowScore); + this.splitContainer.Panel2.Controls.Add(this.insectsPanel); + this.splitContainer.Panel2.Font = null; + // + // btnResetView + // + this.btnResetView.AccessibleDescription = null; + this.btnResetView.AccessibleName = null; + resources.ApplyResources(this.btnResetView, "btnResetView"); + this.btnResetView.BackgroundImage = null; + this.btnResetView.Font = null; + this.btnResetView.Name = "btnResetView"; + this.btnResetView.UseVisualStyleBackColor = true; + this.btnResetView.Click += new System.EventHandler(this.resetButton_Click); + // + // cbUseAntiAliasing + // + this.cbUseAntiAliasing.AccessibleDescription = null; + this.cbUseAntiAliasing.AccessibleName = null; + resources.ApplyResources(this.cbUseAntiAliasing, "cbUseAntiAliasing"); + this.cbUseAntiAliasing.BackgroundImage = null; + this.cbUseAntiAliasing.Font = null; + this.cbUseAntiAliasing.Name = "cbUseAntiAliasing"; + this.cbUseAntiAliasing.UseVisualStyleBackColor = true; + this.cbUseAntiAliasing.CheckedChanged += new System.EventHandler(this.antialiasingCheckbox_CheckedChanged); + // + // label1 + // + label1.AccessibleDescription = null; + label1.AccessibleName = null; + resources.ApplyResources(label1, "label1"); + label1.BackColor = System.Drawing.SystemColors.ActiveCaption; + label1.ForeColor = System.Drawing.SystemColors.ActiveCaptionText; + label1.Name = "label1"; + // + // cbShowScore + // + this.cbShowScore.AccessibleDescription = null; + this.cbShowScore.AccessibleName = null; + resources.ApplyResources(this.cbShowScore, "cbShowScore"); + this.cbShowScore.BackgroundImage = null; + this.cbShowScore.Font = null; + this.cbShowScore.Name = "cbShowScore"; + this.cbShowScore.UseVisualStyleBackColor = true; + this.cbShowScore.CheckedChanged += new System.EventHandler(this.showPointsCheckbox_CheckedChanged); + // + // insectsPanel + // + this.insectsPanel.AccessibleDescription = null; + this.insectsPanel.AccessibleName = null; + resources.ApplyResources(this.insectsPanel, "insectsPanel"); + this.insectsPanel.BackgroundImage = null; + this.insectsPanel.Font = null; + this.insectsPanel.Name = "insectsPanel"; + // + // Window + // + this.AccessibleDescription = null; + this.AccessibleName = null; + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackgroundImage = null; + this.Controls.Add(this.splitContainer); + this.Font = null; + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.SizableToolWindow; + this.Name = "Window"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.Window_FormClosing); + this.splitContainer.Panel2.ResumeLayout(false); + this.splitContainer.Panel2.PerformLayout(); + this.splitContainer.ResumeLayout(false); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.SplitContainer splitContainer; + private System.Windows.Forms.FlowLayoutPanel insectsPanel; + private System.Windows.Forms.CheckBox cbUseAntiAliasing; + private System.Windows.Forms.CheckBox cbShowScore; + private System.Windows.Forms.Button btnResetView; + + } +} \ No newline at end of file diff --git a/GdiPlusPlugin/Window.cs b/GdiPlusPlugin/Window.cs new file mode 100644 index 0000000..c8da3e1 --- /dev/null +++ b/GdiPlusPlugin/Window.cs @@ -0,0 +1,291 @@ +using System; +using System.Collections.Generic; +using System.Windows.Forms; + +using AntMe.Plugin.GdiPlusPlugin; +using AntMe.SharedComponents.States; + +namespace AntMe.Plugin.GdiPlusPlugin +{ + + /// + /// Fenster für die 2D-Anzeige. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + internal partial class Window : Form + { + + // Das Spielfeld-Kontrollelement. + private Playground playground; + + /// + /// Stellt dem Spielfeld-Kontrollelement den Zustand zur Verfügung. + /// + public SimulationState State = null; + + /// + /// Der Fenster-Konstruktor. + /// + public Window() + { + // Initialisiert das Fenster wie im Designer in Visual Studio festgelegt. + InitializeComponent(); + + // Sage Windows, daß wir das Puffern beim Zeichnen selbst übernehmen. + SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint, true); + UpdateStyles(); + + // Erzeuge das Spielfeld-Kontrollelement und füge es dem Fenster hinzu. + playground = new Playground(this); + playground.Dock = DockStyle.Fill; + splitContainer.Panel1.Controls.Add(playground); + } + + /// + /// Gibt an und legt fest, ob mit eingeschaltetem Anti-Aliasing gezeichnet + /// werden soll. + /// + public bool UseAntiAliasing + { + get { return cbUseAntiAliasing.Checked; } + set { cbUseAntiAliasing.Checked = value; } + } + + /// + /// Gibt an und legt fest, ob die Punkte der Spieler angezeigt werden sollen. + /// + public bool ShowScore + { + get { return cbShowScore.Checked; } + set { cbShowScore.Checked = value; } + } + + /// + /// Startet das Zeichnen des Spiels. + /// + public void Start() + { + playground.ResetSelection(); + Show(); + } + + /// + /// Stoppt das Zeichnen des Spiels. + /// + public void Stop() + { + Hide(); + insectsPanel.Controls.Clear(); + } + + /// + /// Stellt einen Zustand auf dem Spielfeld und in den Infokästen dar. + /// + /// + public void Update(SimulationState state) + { + // Wird zum ersten Mal gezeichnet? + bool doResize = State == null; + + // Speichere den Zustand. + State = state; + + // Erzwinge das Erzeugen einer neuen Hintergrund-Grafik, wenn zum ersten + // Mal gezeichnet wird. + if (doResize) + playground.DoResize(); + + // Aktualisiere die Informationen und zeichne das Spielfeld. + updateInformation(); + playground.Draw(); + + // Lass Windows Ereignisse bearbeiten. + Application.DoEvents(); + } + + /// + /// Aktualisiert die dargestellten InfoKasten Objekte. + /// + private void updateInformation() + { + // Die aktuellen Werte aller Insekten sind als Klassen im Zustand + // gespeichert. Hier in der 2D-Anzeige werden diese Werte auf das Spiel- + // feld gezeichnet und in Informationskästen angezeigt. Diese Kästen sind + // für Windows Kontrollemente und ihre Erzeugung ist teuer, d.h. sie + // kostet relativ viel Zeit. Daher werden sie nicht in jeder Runde neu + // erzeugt, sondern so lange weiterverwendet, wie das zugehörende Insekt + // am Leben ist. + + // Um die Kästen zu aktualisieren, müssen die Strukturen im Zustand mit + // den Objekten von hier abgeglichen werden. Der Abgleich erfolgt über + // die eindeutige Id aller Insekten. Die folgende Schleife ist dafür + // zuständig, diese Aktualisierung möglichst schnell durchzuführen. Sie + // läuft dazu gleichzeitig über die vorhandenen InfoKästen und die + // Insekten im Zustand. Pro Durchlauf der Schleife wird in einer oder in + // beiden Listen zum Nächsten Element übergegangen. + + // Vorraussetzung für diesen Algorithmus ist es, daß die Ids in beiden + // Listen aufsteigend sortiert sind, und das ein neues Insekt eine Id + // hat, die noch nicht verwendet wurde und höher ist als alle bisher + // verwendeten Ids. Die Simulation erfüllt diese Vorraussetzungen. + + // In der WPF-Anzeige ist dieser Algorithmus in sehr änhlicher Form + // ebenfalls enthalten und erfüllt die selbe Aufgabe. + + AntInfoBox antbox; + BugInfoBox bugbox; + + int i = 0; // Index der InfoBox + int a = 0; // Index der Ameise im Zustand + int b = 0; // Index der Wanze im Zustand + + // Aktualisiere die BugInfoBox-Instanzen. + while (i < insectsPanel.Controls.Count && b < State.BugStates.Count) + { + // Wandle das aktuelle Kontrollelement in einen BugInfoBox um. + bugbox = insectsPanel.Controls[i] as BugInfoBox; + + // Wenn es keine BugInfoBox ist, muß es eine AntInfoBox sein. Also + // weiter zur nächsten Schleife. + if (bugbox == null) + break; + + if (bugbox.Id < State.BugStates[b].Id) + insectsPanel.Controls.RemoveAt(i); + else if (bugbox.Id == State.BugStates[b].Id) + { + bugbox.Bug = State.BugStates[b]; + i++; + b++; + } + else + b++; + } + + for (int c = 0; c < State.ColonyStates.Count; c++) + { + a = 0; + + // Aktualisiere die AmeisenKästen. + while (i < insectsPanel.Controls.Count && a < State.ColonyStates[c].AntStates.Count) + { + // Wandle das aktuelle Kontrollelement in einen AmeisenKasten um. + // Hier kann es nur noch ein AmeisenKasten sein. + antbox = (AntInfoBox)insectsPanel.Controls[i]; + + // Wenn der Kasten zu einem neuen Volk gehört, dann weiter zur nächsten + // Schleife. + if (antbox.ColonyId != State.ColonyStates[c].Id) + break; + + // Wenn die Id des AmeisenKasten kleiner ist als die Id der aktuellen + // Ameise im Zustand, dann ist die Ameise für die der Kasten + // Informationen liefert, nicht mehr um Zustand enthalten, d.h. die + // Ameise ist gestorben. Der Kasten kann also entfernt werden. Dadurch + // rücken die folgenden Kästen nach vorne, der Index muß also nicht + // erhöht werden. + if (antbox.Id < State.ColonyStates[c].AntStates[a].Id) + insectsPanel.Controls.RemoveAt(i); + + // Wenn die Ids übereinstimmen, dann aktualisiere die Informationen + // und rücke in beiden Listen zum nächsten Element vor. + else if (antbox.Id == State.ColonyStates[c].AntStates[a].Id) + { + antbox.Ant = State.ColonyStates[c].AntStates[a]; + i++; + a++; + } + + // Ansonten fahre mit der nächsten Ameise im Zustand fort. + else + a++; + } + } + } + + /// + /// Erzeugt InfoKasten Objekte zur Anzeige von Informationen und stellt + /// diese dar. + /// + public void ShowInformation(List selectedBugs, List selectedAnts) + { + // Brich ab, falls noch kein Zustand übergeben wurde. + if (State == null) + return; + + // Sage Windows, daß wir jetzt größere Änderungen an den Kontroll- + // elementen in dem Panel vornehmen. + insectsPanel.SuspendLayout(); + insectsPanel.Controls.Clear(); + + // Erzeuge InfoKästen für alle Insekten, die innerhalb des Auswahl- + // rechtecks liegen. + + if (selectedBugs.Count > 0) + for (int b = 0; b < State.BugStates.Count; b++) + if (selectedBugs.Contains(State.BugStates[b].Id)) + insectsPanel.Controls.Add(new BugInfoBox(State.BugStates[b])); + + int v = 0; + if (selectedAnts.Count > 0) + for (int c = 0; c < State.ColonyStates.Count; c++) + { + for (int a = 0; a < State.ColonyStates[c].AntStates.Count; a++) + if (selectedAnts.Contains(State.ColonyStates[c].AntStates[a].Id)) + { + string casteName = string.Empty; + for (int d = 0; d < State.ColonyStates[c].CasteStates.Count; d++) + if (State.ColonyStates[c].CasteStates[d].Id == State.ColonyStates[c].AntStates[a].CasteId) + { + casteName = State.ColonyStates[c].CasteStates[d].Name; + break; + } + + insectsPanel.Controls.Add(new AntInfoBox + (State.ColonyStates[c].AntStates[a], State.ColonyStates[c].Id, + State.ColonyStates[c].ColonyName, casteName, Playground.playerBrushes[v])); + } + v++; + } + + // Sage Windows, daß die Änderungen abgeschlossen sind. + insectsPanel.ResumeLayout(); + } + + // Wird aufgerufen, wenn der Schließen Knopf des Fensters gedrückt wurde. + private void Window_FormClosing(object sender, FormClosingEventArgs e) + { + // Verhindere, daß das Fenster geschlossen, d.h. das Fenster-Objekt + // zerstört wird. Verstecke das Fenster stattdessen. + e.Cancel = true; + Hide(); + } + + // Wird aufgerufen, wenn die Checkbox für das Anti-Aliasing ihren Status + // geändert hat. + private void antialiasingCheckbox_CheckedChanged(object s, EventArgs e) + { + // Erzwinge das Erzeugen einer neuen Hintergrund-Grafik, damit die + // Anti-Aliasing Einstellung übernommen wird. + playground.DoResize(); + } + + // Wird aufgerufen, wenn die Checkbox für das Zeigen der Punktetabelle + // ihren Status geändert hat. + private void showPointsCheckbox_CheckedChanged(object sender, EventArgs e) + { + playground.ShowScore = cbShowScore.Checked; + playground.DoResize(); + } + + // Wird aufgerufen, wenn der Knopf für das Zurücksetzen der Ansicht + // gedrückt wurde. + private void resetButton_Click(object sender, EventArgs e) + { + playground.ResetView(); + playground.DoResize(); + } + + } + +} \ No newline at end of file diff --git a/GdiPlusPlugin/Window.de.resx b/GdiPlusPlugin/Window.de.resx new file mode 100644 index 0000000..54793e2 --- /dev/null +++ b/GdiPlusPlugin/Window.de.resx @@ -0,0 +1,4157 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + 140, 21 + + + Ausgewählte Insekten + + + 8, 13 + + + Ansicht zurücksetzen + + + 8, 541 + + + 125, 17 + + + Benutze Anti-Aliasing + + + 8, 499 + + + 91, 21 + + + Einstellungen + + + 8, 524 + + + 90, 17 + + + Zeige Punkte + + + 170, 423 + + + + AAABABAAgIAAAAEACAAoTAAABgEAAEBAAAABAAgAKBYAAC5NAAAwMAAAAQAIAKgOAABWYwAAICAAAAEA + CACoCAAA/nEAABAQAAABAAgAaAUAAKZ6AACAgAAAAQAYACjIAAAOgAAAQEAAAAEAGAAoMgAANkgBADAw + AAABABgAqBwAAF56AQAgIAAAAQAYAKgMAAAGlwEAEBAAAAEAGABoAwAArqMBAAAAAAABACAAHHoAABan + AQCAgAAAAQAgACgIAQAyIQIAQEAAAAEAIAAoQgAAWikDADAwAAABACAAqCUAAIJrAwAgIAAAAQAgAKgQ + AAAqkQMAEBAAAAEAIABoBAAA0qEDACgAAACAAAAAAAEAAAEACAAAAAAAAEAAAAAAAAAAAAAAAAEAAAAB + AAAAAAAAPz9fABkZZQAWFm0AGBhqAA8PegAUFHMAHBxzABISewAfH3oAISFjACoqYgAtLW0ANDRjAD4+ + YAAyMmoAOztsACYmcQArK3MAIiJ9ACwsewA0NHUAPDx0ADw8fABBQWQASUllAENDbQBMTG8AU1NnAFRU + bABcXGsARERzAEtLcwBHR30ATU1/AFZWcQBZWXIAVVV+AFpafwBmZmYAYGBpAGtrawBnZ3IAZ2d4AHJy + cgBycn8Ae3t7AA4OhAAODowAEhKDABkZhAAREYsAGhqLAA0NkwAGBp4ADAybABERkwAbG5IAEBCZABAQ + nQAWFp0AGxuaACQkhAAtLYIAIyOMACwsiwAyMoQAOzuFADMziwA7O4wAJCSSACsrkQAiIpsALCycADQ0 + lAA9PZIAMzOcADw8mwA4OJ8APj6dAAYGpgALC6IABgaqAAkJqQAMDKkACgqtAAwMrQAQEKEAFRWiABAQ + pQAVFaUAGhqkABAQqQAVFaoAFRWtABoaqwAFBbMACQmxAAwMsQAJCbUADAy0AAUFugAKCrkAEhKyABsb + swAUFLwAGRm5AB0duQAYGL0AHh69ACQkpAAoKKEALy+hACwspAAiIqsAKSmtADMzogA6OqQAMTGsADo6 + rAAjI7MAKyu0ACMjvAArK7sAMTG0ADo6tAAzM7sAOzu8AEJChwBKSoUARESLAElJiwBcXIIAU1OMAFxc + igBDQ5EATEyTAENDmwBOTpoAVFSTAFpakgBTU54AXFyYAGFhhQBra4UAYmKKAGxsiwB3d4MAeHiEAHFx + iAB+fooAY2OTAGtrkwBiYpsAbGyaAHNzlQB7e5IAdHSaAEFBpABKSqQAQUGsAEpKrABXV6QAW1uiAFVV + qQBZWawARESyAEpKtQBERLwAS0u7AFFRswBVVbwAXFy+AGdnoQBqaqEAZGSuAGtrqgB2dqEAcHClAH9/ + ogBycqwAe3uoAH5+qQB9fawAYWGxAGRksgBiYrUAa2u2AGNjvQBpabwAdXW1AHR0ugB9fbgAFBTAABsb + wwAcHMkAJCTDACsrwgAlJckALCzKADQ0wwA8PMIAMzPKADw8ygA8PNAAQ0PDAEtLxABDQ8sAS0vLAFRU + wwBcXMIAU1PMAFpaywBERNIAS0vRAFNT0QBbW9MAWlraAGJiwwBqasEAZGTKAG5uzQB2dsMAdHTLAHt7 + ygBgYNMAYWHVAGVl1gBoaNIAYmLaAGtr2QBzc9EAfHzSAHFx2gB2dtgAcHDdAHl52gBoaOEAcnLiAH19 + 4wCCgpkAgICjAICArQCAgLgAjY3JAJSUzwCEhNUAiIjVAICA2wCIiNkAgYHjAISE6ACQkOQAAAAAAAAA + AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFy6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrXFm3AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtkWXAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRZ + O7IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA4lxZTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAZFk7sgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKXFlOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRcO4kAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+lxcOwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7 + jQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAADXXFk5AAAAAAAAAAAAAAAAAAAAAAD2pwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABkXDuZAAAAAAAAAAAAAAAAAAAAAFw7TgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRcO0YAAAAAAAAAAAAAAAAAAAAAXDs4nAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA72RZOJkAAAAAAAAAAAAAAAAAAABcOziMAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7SgAAAAAAAAAAAAAAAAAAAFw7 + OIIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXXFk4mwAAAAAAAAAA + AAAAAAAAXFk4QgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTuH + AAAAAAAAAAAAAAAAAABcWThBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAGlcOzmWAAAAAAAAAAAAAAAAAGRZNTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAA62Q7OIsAAAAAAAAAAAAAAAAAXFk4NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7QAAAAAAAAAAAAAAAAOxhWTU0AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKXDs4lwAAAAAAAAAAAAAA7FxQODQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACbgRcSEgwSGiQsLC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTVFAAAAAAAAAAAAAADrZFk1NAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAACiMjExMQcGBgMDAwoQJCwuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRcOzSSAAAAAAAAAAAA + AOxcWTUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAPTQwMTExMTExBwYDAwMCDR4sLgAAAAAAAAAAAAAAAAAAAAAAAAAA12E7NYIA + AAAAAAAAAAAA7GFZNUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAHI7NTU0MDAxMTExMTEDAwMCAhgpLAAAAAAAAAAAAAAAAAAAAAAA + AAAAYVk7OS4AAAAAAAAAAADsYVk1QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+Wzs7NjU1OzU7NTU0LzExAwMCAgsdLC4AAAAAAAAA + AAAAAAAAAAAAAABpXDs0hQAAAAAAAAAAAOxhWTVBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+XhcUDY2NjY2Njs2OzYwNDExBwYDAgoZ + KS4AAAAAAAAAAAAAAAAAAAAAAOJkOzVBLgAAAAAAAAAA7GRZNUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQeGdcUlJZUFBQNjY2OzY7 + NTA0MQMDAgIYKS4AAAAAAAAAAAAAAAAAAAAAAGRZNTSQAAAAAAAAAADsXFI4QQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGtraVJhUlJQ + UFBQUFBQNjY7NjAwMQYDAgINKSwAAAAAAAAAAAAAAAAAAAAAxFk7MIAAAAAAAAAAAOtkWTWIAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + wmtpYWFSUlBQUFBQUFBQUDY7NjU0MTECAgINKS4AAAAAAAAAAAAAAAAAAADmWTs0MgAAAAAAAAAA7FxZ + NYgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADCwmlhZVJSUlBQUFBQUFBQUFA7NjUwMQYDAgINKS4AAAAAAAAAAAAAAAAAAABcNjQ0AAAA + AAAAAADsYVk1iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAMLCwmVhYVJSUFBQUFBQUFBQUDY2NjU1MTEDAgIZKQAAAAAAAAAAAAAAAAAA + AFk2MDAAAAAAAAAAAOxcXDWLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1cLCZWFhUlJSUFBQUFBQUFBQUFA7NjUwMQYDAgIcLAAAAAAA + AAAAAAAAAAAAWTswQAAAAAAAAAAA7GRZNZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiwsJmZWFhUlBQUFBQUFBQUFBQUFBQOzswMQYD + AgoeLAAAAAAAAAAAAAAAANFQNTRFAAAAAAAAAADsXFk1lwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDwsJlYWFSUlJQUFBQUFBQUFBQ + UFA2OzYwMQYDAgspLgAAAAAAAAAAAAAAXDs1MJcAAAAAAAAAAOxcWTWXAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfCwmZlYVJSUlBQ + UFBQUFBQUFBQUFA2OzU0MQYDAhgpAAAAAAAAAAAAAABZOzU0AAAAAAAAAAAA61xQNIIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7cPC + wWVhYVJSUlBQUFBQUFBQUFBQUFA2OzYxMQMCAh4uAAAAAP8AAAAAqFk1NUQAAAAAAAAAAADsXFk1gQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAw8PCZmVhYVJSUFBQUFBQUFBQUFBQUFA2NTUxMQMCDSkAAAAAAAAAAABcNjU4lwAAAAAAAAAA + AOxkWTVDLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADtw8LCZWVhUlJSUFBQUFBQUFBQUFBQUDY7NTAxBwMCHS4AAAAAAAAA6Fk7NTkA + AAAAAAAAAAAA7FxZND4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDw8LBZWFhUlJSUFBQUFBQUFBQUFBQUFA7NS8xAwILKQAAAAAA + AAB4WTswRQAAAAAAAAAAAADsYVk1MSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPvDwsJmZWFhUlJQUFBQUFBQUFBQUFBQUDY7MDEG + AwIdLgAAAAAAAFw2NTWdAAAAAAAAAAAAAO9hUjsxJS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbGxsJmZWFSUlJSUFBQUFBQUFBQ + UFBQNjY1NAUDAw0sAAAAAADcWTs1OQAAAAAAAAAAAAAA72ZcOzRDLAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfGx8RmZWFSUlJS + UFBQUFBQUFBQUFBQOzYwMQYDAyoAAAAAAHhZNjWLAAAAAAAAAAAAAAAAZWFZNTIsAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfH + x8dpYWVSUlJSUFBQUFBQUFBQUFA2OzUwMQMDGwAAAAAAXFA1OPAAAAAAAAAAAAAAAABlZVw7NCUuAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA7szKysfBYWFhUlJSUFBQUFBQUFBQUFA2OzAxBwMQLgAAAABZWTVKAAAAAAAAAAAAAAAAAOJm + YTs1RC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA5czMysrCZWFSUlJSUlBQUFBQUFBQUDY7MDExAxEuAAAA31k7NYwAAAAAAAAA + AAAAAAAAAMZlXDs4lwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2czMzMzHZGFhUlJSUlBQUFBQUFBQUDs1MAYGPywAAACsNjs4 + lgAAAAAAAAAAAAAAAAAAAGVkWThKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2dXPz8vLwmFhYVJSUlJQUFBQUFBQNjUwMRQ/ + LAAAAKA7NTkAAAAAAAAAAAAAAAAAAAAAAGFcWTiYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA79fVz8/PymlhYVJSUlJSUlBS + UFA7NjRBQUIsAAAAoDUwMZIAAAAAAAAAAAAAAAAAAAAA4mVZO0oAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+9fX19DXz8xr + ZmFhUlJSUlJSUFludEpERCwAAACiNTQvIi4AAAAAAAAAAAAAAAAAAAAAylxZOJkAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ANfW19fQ0NDPy8RrZ2dna3h+fX2gdUtFHS4AAIswLzEVLgAAAAAAAAAAAAAAAAAAAAAAaVk4OS4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAO/X19fX19PQztDQ0M7Oy6jOf32eTjISLC4AjzExBgYsAAAAAAAAAAAAAAAAAAAAAAD4 + WTs0gi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAADt2djX19fX09PQ0NDOz86oqaZGMRUgMTEkLzEGAx0uAAAAAAAAAAAA + AAAAAAAAAABbNTQxj5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mR5AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7eLi2NjX09jT09DTzs6pcjs1KzAvLzExMQYHDSkA + AAAAAAAAAAAAAAAAAAAAAKo7MDEVLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADX + ZWRcpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPri4uLY1NTU09PTzmdcUEo7NTU1 + MDAxMQMCKCwAAAAAAAAAAAAAAAAAAAAAtDA0MTGPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADHZGRcWaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/Pjq6t3f6vd/ + UlK+WVk2Ozs7NDAxAwMBJywAAAAAAAAAAAAAAAAAAACYNTAxMUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAz2RkXFm9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAqFxcUlJQNjY5MTExBAIKGSkuAAAAAAAAAI+PhISEhIA0NTQ0QQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9kXFxZqgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABrUFJSUlJZWVk4MDEGAwIDDSkpLiUXEzExBzExMDA1NTU1NTWfAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADPZGRcWaDAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKlfUmFhUmt2WTs1MDExAwMDDRkDBjEGMTExNDU1Ozs2Ozs7 + PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mRkXFlyugAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuqzOfn6of1lQNjs1MDExBgYGBjExMTExNDU1 + Ozs2Njs2WW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOJk + ZFxZWXWwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACXh0E4NDU4OUWFkC6TutrU0WtSUlBQNjs1NTAxMTEx + MTEvNTU2Njs2UFBZUl/dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADiZGRcWVk9n64AAAAAAAAAAAAAAAAAAAAAAJuHQDg4NTU1NTg4Ozs7OEuPk4ZSUlJSUFBQ + UDs7NTU1MDAwMDA1NTU2NlBZXNEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA4mRkXFlZOzmKnQAAAAAAAAAAAAAAAItANDU1ODU7OztZWVk2WVBZUFBZ + XGRhUlJSUFBQNjY2Ozs2NTU1MDAwNkam4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO1rYVxZWTs4RoiSAAAAAAAAjEQ4NDU1OzU7WVlQeVxS + UmRSUlJhYWRhYWFhUlJQUFBQUFA2Njs2NS8RFYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADvaWRcXFk7ODhHhZWGRDQ1ODU7OzY7 + WVB54AAAAADtyGZlZWVhZWVhZWFSUlJQUFBQUFBQNjswMAwnLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRhXFxZOzs1Ozg1 + OzU7OzZZUGvaAAAAAAAAAAAAAADXZWVmZWVhYWFSUlJQUFBQUFA2NjAvBQwpLAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADE + ZWFcXFlZWVk2WVBZXNEAAAAAAAAAAAAAAAAAAAAAAMZmZWVlYWFSUlBQUFBQUDs2MC8FBg0oLC4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA1WVhYWFSUlxn0QAAAAAAAAAAAAAAAAAAAAAAAAAA+8NmZWVhYVJSUlBQUFBQNjs2LwUG + Bg0cHSAfIYGBlwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAANnBZsTiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMbBZmFhUlJSUlBS + UFBQNjUwLzEGBgYGBjEGMTExMYecAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAx8fE + Z2ZhUlJSUlBQUDY7NjUwMTExMQYxBjEGMTE0NDSJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAfn5+xGdhUlJSUlJQUFA7NjU1MDExMTExBjExODU7NThAmAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACbmIiNh0pKdLsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADcfn5+xHhcYVJSUlJSUDZZNjs1NTU0LwwdkAAAbjs7Ozg0iAAAAAAAAAAAAAAA + AAAAAJyXiERGODg4ODg7O1lZbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRkeH5+eXhkYWFhUlJQUFA2Njs7NjAvLx0uAAAA31k7Ozg0OZcA + AAAAAAAAAJuMh0c5NDU4ODg7OztZO1lZc9sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADTUlJSXH19fnlkYWFhUlJSUFBQUDY1NTAxCiwAAAAA + AHY7NTU0NEScmJeIS0c4ODg4ODs7OztZWVlZWVx/3wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRhUlA7PaV9f35pYWVSUlJQUFA2OzY1 + MTExJAAAAAAAALo1ODUwNTg4ODg7NTU7OztZO1BZUFxczt8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYVJSNjaXANvOy37CYWFh + UlJQUFBQNTUvMQMQLgAAAAAAAABKNTU4Ozs7WTtZWVlSXFJSy9wAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtkUlk2NAAA + AN/Oy8vHZGFSUlJSUFA7NTAxBhApLgCSly4uLgCuRjU7WVlQXFJry98AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAK6Yl5ePl4+Pj4+Pj4+Xj4+Xj4+Xj5eQLpYAAAAAAAAAAAAAAAAAAAAA + zmFSUDtBAAAAAOzQzsvLxFxSUlJQUDY1MDEHFScaETExMRIkLC4At7q73wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhkXFk7ODg0MDQwNDQwNDg0NDA0NDA0NDA0MTQ0MTE0P5cuAAAA + AAAAAAAAAADMUlw2NYAAAAAAAOzT0M7Lf35rZ1xcXFlIR0AaDQYxBjEGMTEQKS4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVZmZkXFxZWTtZOzs7Ozs7Ozs7Ozs7NTs7NTs1OzU1 + ODQwMUUuAAAAAAAAAAAAAMtcUDswgQAAAAAAAMzU087Oy3/IfsRzcm5IRhMFBQUvLwUxAwYMKS4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6xmZlZFJcUlxSXFJcUlxSXFJZUFlQ + WVBZXFBZWVlZOzs4NEabAAAAAAAAAAAAf1k7NTCEAAAAAADqYczS09HOzst/fn55cm49ODAwMDAwMQUx + AwYNKS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO/PaWVhZWFhZWRh + YWFhYWFhYWFhZGFhYWFhUlJcXFk7ODmdAAAAAAAAAABzWTYwNI8AAAAAANBhYX7c0tHOzs7Lf35+czs7 + NTs1NTU1NAUGAwMQLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO3EXFJZOziiAAAAAAAAADs2MDQvAAAAAAAAxGFSWbLa3NTU + 0M6of6BwUFA2NlA7OzYwLzEGAwIdLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxGRcWTuJAAAAAAAANTUwMDIAAAAAAABh + YVJwAAD04NTU0dKmW1JZUFBQNlA2OzYwLwYDAwspAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7WRcWTs9jZwALi41MDA0 + PwAAAAAAAGVhUE4AAAAAAAAAv1JSUlJQUFBQUFA2OzUwMQYDAhksAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGlkXFk7 + Oz1HRjU1MDCIAAAAAAAAZVJZigAAAAAAAABSUlJSUlJSUFBQUFA2OzUwMQMCCiwAAAAAAAAAAACworMA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAANVlZFJZUFk2OzU1OAAAAAAAAABmZFmfAAAAAAAAUlJSUlJSUlBQUFBQUFA2OzAxBgMCGSwAAAAA + APJ1Ozs4OfEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAO9mYWFhUlxQOzt0AAAAAAAAAMpkWTsAAAAAANFhYWFhUlJSUFBQUFBQUFA7NjEx + BgMNKS4AAK1IO1k7Ozs7SgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGZWVlUlxSWwAAAAAAAAAA72RcO4oAAAAAX2FhYWFhUlJSUFBQ + UFBQUDY1NTExAwMeLIREODtZW9oAX1k7pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6wWVlZsQAAAAAAAAAAAAAZVxZOwAAAAB4a2lh + ZWFSUlJQUFBQUFBQUDs1MDEGBhAHNDU7WawAAAAAXFk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiZFk7 + jQAAAH15xMRraWRSUlJQUFBQUFBQNjs1MDExMTEwO6YAAAAAAADrXFl1AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABmXFk4AAAAu35+x37ExHhrXFxcUFBQUFBQNjU1LzExNHAAAAAAAAAAAABrXFm3AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAOJkXDuKAAAAf8t+yMjIfn5+xHJ4a19cXFlZPT1GRkCZAAAAAAAAAAAAAO9kWXQA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZSWTsAAADeqMvLy8jLyH5+fn55eXl5c3Nub0hG8AAAAAAAAAAA + AAAAAGtcO7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mRZO44AAADdzs/Pz8zLy39/f39+fn5+dnZ0Sk4A + AAAAAAAAAAAAAAAA72RZdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFJZOQAAAADr09DQ0M7PzsvLqH+o + fX2goHSgtAAAAAAAAAAAAAAAAAAAZFw7twAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYXFk7jAAAAAD819fX + 19DQ0M7Ozqiopn2moKYAAAAAAAAAAAAAAAAAAADYZFmeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcNjVL + AAAAAAAA4tnX19TT086pqampp6enAAAAAAAAAAAAAAAAAAAAAABkWTsAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAFxZO0cAAAAAAAAAAO3i2NTS0tLRrKurrAAAAAAAAAAAAAAAAAAAAAAAAM9kWaEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAUjs1hwAAAAAAAAAAAAD45tza0r3Su/UAAAAAAAAAAAAAAAAAAAAAAAAAAGRcWQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABcOzWOAAAAAAAAAAAAAAAAeV9yuAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAxGRkuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Fw7NZ0AAAAAAAAAAAAAAN9cWVsAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAZmTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+WTs4AAAAAAAAAAAAAAAAXFxQtwAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAADiws8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxQO4cAAAAAAAAAAAAAANJc + UHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFk1rQAAAAAA + AAAAAAAAXFk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABS + WTUAAAAAAAAAAAAAAH1ZNokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA1Fw7SAAAAAAAAAAAAAAAXDs4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB+WTuiAAAAAAAAAAAAAGdcO4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxSOwAAAAAAAAAAAAAAZFJZAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFk9AAAAAAAAAAAAAMpmXKcAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOpcWaEAAAAAAAAAAAAA7mZkeQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf1w7AAAAAAAAAAAAAAAA + ymZkWaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnWW8AAAAA + AAAAAAAAAAAA4mZkWVmhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFxZugAAAAAAAAAAAAAAAAAAAGtkXFk7nwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADcXFkAAAAAAAAAAAAAAAAAAAAAANdmZFlZO58AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAH5coAAAAAAAAAAAAAAAAAAAAAAAAADEZFxcWTuiAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxGRcWVk9sAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANxkXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA72tk + XFlZdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxFzaAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAO9rXFxcXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmawAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAADva2Rc0wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1WbqAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADCwQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP////////////////////////////////////////////////////////////////// + ///////////////////////////+P////////////////////h////////////////////4f//////// + ////////////D////////////////////w////////////////////+H////////////////////h/// + /////////////////8f////////////////////D////////////////////w/////////////////// + /+H////////////////////h//8/////////////////8P//H/////////////////D//w////////// + ///////wf/8P////////////////+H//D/////////////////g//w/////////////////8P/8P//// + /////////////B//D/////////////////wf/w/////////////////+H/4P/////////////////g/+ + D///////////8AD///8P/g///////////8AAP///B/4P//////////+AAA///wf+D///////////AAAH + //+D/g///////////gAAAf//g/4P//////////wAAAD//4H+D//////////8AAAAf//B/g////////// + /AAAAD//wf4P//////////wAAAAf/8H+D//////////8AAAAD//h/g///////////AAAAA//4f4P//// + //////wAAAAH/+H+D//////////8AAAAA//B/g///////////gAAAAH/wf4P//////////4AAAAB/8P+ + D//////////+AAAAAPeD/g///////////wAAAAD/g/4H//////////8AAAAAfwf+B///////////gAAA + AH8H/gf//////////4AAAAA/B/4D///////////AAAAAPg/+A///////////4AAAAD4P/wP///////// + //AAAAA+D/8B///////////wAAAAHh//Af//////////+AAAABwf/4H///////////wAAAAcH//B//// + ///////+AAAAHD//4P///////////wAAABwf/+D///////////+AAAAcD//wf///////////4AAADA// + +D////////////AAAAQP//gf///////////8AAAAB//8D/////+P/////wAAAAf//A//////g//////A + AAAD//wP/////8D/////+AAAAf/8D//////wP//////+AAB/AA///////A///////gAAAAAP//////8B + //////4AAAAAH///////wH/////+AAAAAD////////AP///gAAAAAAB////////8Af//AAAAAAAD//// + /////wA//AAAAAAAH//////////AB+AAAAAAAf//////////8AAAA8AAAAH///////////4AAB/8AAAA + ////////////gAD//4AAAD///////////+AH//+AAAAA///////////4P///wAAAAB////////////// + /+AAAAAP///////////////wAAAAA///8Af/////////8AAAAwH//AAH//////////AAAAOAf4AAD/// + ///////gAAAD4AAAAH//////////4AAAA/AAAAf//////////+BAAAH8AAD////////////A4AAAggAf + /////4AAAD//wPAAAACH//////AAAAAB/8D4AAAAf//////gAAAAAP/A/AAAAD//////8AAAAAB/wPgA + AAAf//////4AAAAAP8D4AAAAH///////////4B/B+AAAAA////////////wPwfhgAAAP///////////+ + AQH4fwAAB////////////4AB+H8AAAf8f//////////AA/h+AAAD4D//////////4AP4fAAAAYA///// + //////gH+DwAAAACH//////////8D/w8AAAADx/////////////8HAAAAD8P/////////////hwAAAD/ + h/////////////4OAAAB/4f/////////////DgAAA//D/////////////wcAAAf/w/////////////+H + gAAH/+H/////////////g8AAD//h/////////////8PwAB//8f/////////////D/AA///D///////// + ////w/8Af//4/////////////8P/w///+H////////////+D/4f///x/////////////h/+H///8f/// + /////////4f/D/////////////////+H/x//////////////////j/4f/////////////////w/+P/// + //////////////8P/D//////////////////H/x//////////////////x/4f/////////////////4f + +H/////////////////+P/wf/////////////////j/+B/////////////////4//4H///////////// + ///8f//Af////////////////H//8B////////////////x///wH///////////////4///+A/////// + ////////+P///4H///////////////n////g///////////////x////////////////////8/////// + ////////////////////////KAAAAEAAAACAAAAAAQAIAAAAAAAAEAAAAAAAAAAAAAAAAQAAAAEAAAAA + AABMTHgAXl5/AHp6egB+fn4ABgaOAAgIiwANDYoACQmNABwchwAQEIoAFBSJABAQjgAYGI4AHh6PAAYG + kQAGBpQACQmQAAwMkgALC5QADAyWAAYGmgAGBp4ACAiaAA0NmQAICJ4ADg6dABERkQAVFZEAExOWABYW + lgAdHZAAGhqWAB4elQAWFpkAFxecABgYmQAeHpkAGRmcAB0dnAAjI4oAJiaKACgoiAAtLYgAPDyHADEx + jgA2No8APj6LADg4jQA/P44AIyOQACYmkgAlJZQAKSmTACoqlgAhIZkAISGdACUlnQAqKpoALi6ZACkp + nQA1NZAAOzuQAD09kwAxMZgAMTGdADQ0ngA+PpwABgahAAYGpgAJCaAADg6hAAoKpgAODqYADg6oABIS + ogAWFqEAEhKlABYWpwAZGaIAHh6jABoapwATE6oAFBSqABcXrQAbG6kAHR2oAB4erQAiIqIAJyejACUl + pgApKaAALS2hACUlqQAoKKoALi6oACkprQAyMqAANDShADAwpQA2NqUAOTmjADw8ogA4OKUAPDylADEx + qQA0NKkAMDCsADU1rgA5OakAPDyrADs7rwA/P64AIyOxACkpsQA3N7IAMzO1AD4+swA/P7QAOTm/AE1N + hwBFRYoAUFCBAFFRiQBUVIsAQ0OWAExMlABGRpoAQ0OfAExMmQBQUJ4AZWWHAGxshQBmZooAdXWBAHh4 + hQBycosAaWmWAG5ulwBgYJsAZGScAG5unAB1dZAAcXGUAHV1ngBERKIAQ0OkAEVFpwBMTKIASEimAE9P + pgBCQqkARUWpAEBArgBFRa4ASUmoAExMqgBKSq0ATk6sAFdXpgBRUakAV1epAFFRrgBUVK4AWVmqAEJC + sgBFRbIAQUG0AEpKsABNTbEASkq0AE9PtQBFRbsATU24AFNTswBVVbAAUFC1AFlZsQBdXbEAWVm1AF1d + tQBQULgAXl6+AGFhogBra6MAYGCqAGlpqQBsbK0AcXGgAHp6pQBxcagAdnarAHt7qgB+fq0AY2OyAGZm + sQBgYLUAZWW1AGlpsQBsbLIAaGi3AGFhugBlZboAaWm6AG1tuQBoaL4AcXGxAHZ2sQBycrQAdXW3AHp6 + sgB7e7QAcHC8AHl5uwBGRsQAXl7AAFtbxABeXsQAZWXCAGtrxABgYMgAbGzLAG5uzwBycsMAdXXCAHNz + xQB0dMUAeXnBAH9/wgB4eMYAfn7HAHFxzQB4eMgAfn7IAHp6zQBvb9MAe3vRAH192QCAgKwAgICwAIiI + ugCSkr0Ag4PGAISExACEhMoAiIjNAJSUxwCEhNcAk5PVAKWl3AAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASeMAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKdaAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGtEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFpaAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADq + GtIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAABpkAAAAAAAAAABKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAC1GgAAAAAAAAAAGqIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAABqbAAAAAAAAABpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABaGgAAAAAAAAAUYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA2xSkAAAAAAAAGmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAC6gTY/fo4AAAAAAAAAAAAAAAAaOAAAAAAAABRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPMeFBQRFBEULYcAAAAAAAAAAAAAZBq+AAAAAAAaYQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAnEQUVFRUUBREeewAAAAAAAAAAAAAUZAAAAAAAFGEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAADjHhQVRUVFFRUPBREwAAAAAAAAAAAAFBQAAAAAABpkAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAtR4VRUVFRUVFFQ8RES0AAAAAAAAAAKgUuQAAAAAUZAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOMnGkVFRUVFRUUVBRERMAAAAAAAAADMFKQAAAAAGpYAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBQVRUVFRUVFRRUFERF8AAAAAAAAXBrvAAAAABqk + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgeFUVFRUVFRUVFFQURG4cAAAAAABQnAAAA + AAAUmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNOBQVRUVFRUVFRUUVFBEwAAD/AM0U + gAAAAAAAGmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEgD0VFRUVFRUVFRRURFIgA + AAA4FO8AAAAAABQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4YSAVRUVFRUVFRUVF + BREwAAAAGjgAAAAAAAAUFLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN9lOBpFRUVF + RUVFRRUUDgAAzBSkAAAAAAAAJxSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtJhk + FBVFRUVFRUVFBR4AAG0aAAAAAAAAAAAUFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADNqIBaGkVFRUVFFRQ4jgBkFAAAAAAAAAAAthqbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAPW0oqg8UFNTVHJlZYcANhSMAAAAAAAAAABkGsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAMy0pLSwta21mCd7eSwULQAAAAAAAAAAABQ8AAAAAAAAAAAAAAAAAAAAAAAAANZy + AAAAAAAAAAAAAAAAAAAAAAAA+fTFxba0sDgODg8RERsEAAAAAAAAAAAgFLcAAAAAAAAAAAAAAAAAAAAA + AAAA3El1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACbfRUaFAcHKoQAAAAAvoqKMxRlAAAAAAAAAAAAAAAA + AAAAAAAAAAAA3VBd3wAAAAAAAAAAAAAAAAAAAAAAAAAAwCcVU1EPEREbei0eFBERFBEUxQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA7GBJmOMAAAAAAAAAAAAAAAC6pGWfvQDFtnRFRQ8PEREREQcRERE4AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAaGpjOAAAAAAAAumUYGhQUFBQbLTZFRUVFRRUUBQcRQMUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKcaGhRlur6AGBgeFGQAALUgFBERFUVFRUVFFQ8BAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALYnGhQaFBhk3wAAAAAAAACiHg9FRUVFRUUF + GwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtcPMAAAAAAAAAAAAAAGUgGkVF + RUVFBREKKB4UPKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + mGBLFUVFRRUFBRERHiAaJ7oAAAAAAAAAAAAAANK0xd8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAADxkZTgPFUVFRRUPG4YAxRQaZAAAAADvpGU4GhoaGl3nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAREYGYPBQVRUVFSQV5AAAAYRQYZRoaFBoUGmTNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAC1EREA8KJkS0VFRRUUKgSJigCMOBQncMXqAAAAAAAAAAAAAAAAAAAAAOuncGRhYWFh + YWFhYWRhYWSAAAAAAAAAZRE2AAD2tLV0UFNLHioJEREOgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdBoU + FBQUFBQUFBQUFBQUFBjvAAAAAGUUQAAAAFzFtKiYbVwUBQUFBRGFAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAADj398AAAAAAAAA9JgaGM4AAABAFIIAAOMUgc7FtJg8GhVFFRERKAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAG0aZL6QIBG6AADnHsAAAPE2FUVFRUUaBRQwAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAthoUEREeAAAA6hrSAACoEUVFRUVFRQURGwQAANRdUAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJx4UtgAAAAAaZAAAIBEVRUVFRUUVERF6glBa + 321LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApxoAAGVkUEtKRUVFFQUR + ERjNAAAAUM0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaZADOZXBldHJx + UVAgIIAAAAAAAOoaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmBrAAMWi + qICnp3VkYWQAAAAAAAAAGrQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa + mwAA88W0oqKoqJvOAAAAAAAAANdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAFGQAAAAA487FxcXjAAAAAAAAAAAAGswAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABqAAAAAAAAAOL4AAAAAAAAAAAAAAKxRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAN8a0QAAAAAAcFoAAAAAAAAAAAAAAAAA7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC1GgAAAAAAABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAWmQAAAAAAFpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAABrMAAAAAAAaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJAAAAAAAAULUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADabQAAAAAAAABdGrAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXd8AAAAAAAAAAOoaGrUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAANcaUN8AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOvXAAAAAAAAAAAAAAAAANdK9wAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//////////////////////////f/////////8//////////z//////// + //n/////////+f/////////4//////////z/f////////P8////////+fz////////5/P////////j8/ + /////A//Pz/////wA/8fP/////AB/58/////4AD/nz/////gAH+PP////+AAP48/////8AAfjz/////w + AA+fP/////AADR8/////+AAHHz/////4AAc/H/////wABj8f/////gAGf5//////AAJ/j/////+AAj/H + /////+AAP+f//z//8AAf4///j///4A8D///h///gAAP///g//BAAD////wfgAAA/////wAGAAf/////w + B/AA//////4/+AAH///////8AAH/w/////wAEPAD/////AAcAD/////4gAID//wAAfjAAP///gAAeOAA + f///4/g4wAB//////wDGAD//////gcYAGP/////h5gAAf//////mAAc///////IAHz//////8QA/n/// + ///5gD+f//////ngf8//////+fn/z//////x8//v//////P3////////8+f////////z7/////////fn + ////////5/H////////n+H///////+/+H///////z/+P///////f//////////////8oAAAAMAAAAGAA + AAABAAgAAAAAAAAJAAAAAAAAAAAAAAABAAAAAQAAAAAAACUlXgAqKl4AMTFXADc3VwA1NVgANzddABkZ + ZgAWFm4AGBhoABwcagAZGW0AExNzABYWcAATE3YAFBR1ABoadAASEnkAFBR7ABISfgAVFX0AHx99ACEh + YAAlJWAAIiJmAC0taQAyMmAAOTlkADExbgA7O28APz9uACYmdAAvL3YAIyN7ACEhfQApKXoAKyt+AC0t + fAAxMXMANjZwADQ0dAA8PHMANTV5ADExfQA1NX4AOjp5AEJCXQBJSVoASUleAE1NXQBAQGEATExkAEVF + bABLS2sATU1rAEhIbABUVGsAWFhqAFpabQBDQ3EASkp1AEJCegBRUXAAW1twAFNTegBfX3gAY2NvAGdn + cQBiYnYAZWV1AG1tcABubnUAY2N7AGZmegBhYX0Aa2t+AHFxcwBycnQAd3d3AHZ2eABxcX4Aenp8AA0N + hQAODokACgqOAA0NjQAREYIAFRWAABERhQAXF4QAGhqEABAQiAAVFYoAEBCMABcXjAAaGokADQ2QAAsL + lgANDZUACgqZAA0NmQAJCZ0ADQ2dABISkwAaGpAAHByRAB4elwAQEJgAFRWZABISngAXF50AGRmdACMj + gAAmJoEAIiKEAC0tgwAgII4AKyuLADIygQA7O4UAMTGIADY2jwA/P4sAIyOVACEhnQAoKJgAMzOSADk5 + kAAHB6IABQWlAAgIoQAMDKIACgqmAA4OpAAFBagABQWtAAwMqgAQEKEAERGmABQUpAAaGqMAEBCpABUV + rAAbG6wABQWxAAUFtQAKCrMADQ28ABMTsAAVFbEAFBS1ABgYsgAeHrIAGhq0AB4etgAQELoAHR29ACUl + pAAqKqIAIiKqAC0tqQAwMKkAPDyuACQksAArK7MAICC/ACgouAAtLbsAKSm+ACwsvQA1NbYAPT2yADIy + ugA2NrsAMTG9ADg4uQA9PboAODi+AEBAggBDQ4oASkqJAF1dhQBeXokAYWGAAG5uhABgYIoAd3eFAHx8 + gAB9fYgAYmKfAHV1kAB7e5EAe3ubAE9PpABRUaEASkq1AEFBuwBBQb8ARUW8AFZWsgBdXbQAUlK+AFhY + uAB1daIAeHilAGVltQBvb7QAZWW6AGJivQB/f7cAEhLAABYWwAAdHcYAIiLAACYmygA0NMMAODjCADU1 + zAA6OsoAQ0PDAEVFwgBCQsUASEjBAE5OwABPT8cAQkLIAExMywBQUMUAVVXEAFhYxABTU80AWVnIAERE + 0ABMTNEAV1fRAFxc0wBlZckAcHDAAHd3zQB5ec8AZGTRAGpq0QBoaNsAcnLSAHt70wB8fNMAf3/WAH9/ + 3gCCgsIAgoLGAIGB2QCHh+UAkJDnAKGh6AAAAAAA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJhJAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPN4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACKRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADgLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbUcA + AAAAAPhBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApikAAAAAAMkmAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9mhPAAAAAMYhAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIU3AAAAALAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC/HRka + ME0AAAAAAAAAAN1wAAAAALAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJgXVsTDRYwAAAAAAAAAABt + OQAAAK0hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSBhYBlYBMJBU0AAAAAAACOHAAAAKYkAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAJuHgYGBgWVYCwVPAAAAAADkWAAAAKYsAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAANOQh4GBgYWAWAgEAAAAAADQWgAAAKYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANSSh4GB + gYGBZVgJMAAAAACMLQAAAKYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPLTkIeBgYeBgWATFk0AAABg + uAAAANcfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADWk4eHgYGBgYFgCC4AAMNeAAAAALBYUQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA1puHgYeBgYFlExYAAIU9AAAAAOlrMwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA+9mch4GHgYGFXQtRAGVPAAAAAACUJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzo + 15SHh4GBayxHAFtEAAAAAAAAijkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6+nhraaton45SRMu + AAAAAAAA5SFPAAAAAAAAAAAAAAAAAMi2AAAAAAAAAAAAAAAAAP3y6ubpxm1aWBMCUQAAAAAAAFsyAAAA + AAAAAAAAAAAAAADknrYAAAAAAAAAAAAAAAAAAAAAAJiFZVsLBEcAuj8+O1ssAAAAAAAAAAAAAAAAAAAA + AOyfs0sAAAAAAAAAAAAAAE+6AKKYn2VbDRgQWF1gZW8AAAAAAAAAAAAAAAAAAAAAAAAA9phoLT8AAAAA + AEBwYGVgXix7gYWBZWBdXW3DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA14VeHTQka2Wh+ADx1ZCHkIeB + gWVSMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpiIWf7QAAAAAAAADTkIeBgWVdCzA5OUQAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD3nIiHhYFgWBMNWFssQgAAAAAAAAAAvElJAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAmKaUkIeBZWAQTQCeWzdRAEs8LFprbZ3NAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADwgXfDpZCHgWATMAAAsmtbbWWKquwAAAAAAAAAAAAAwDw7Ox00HTQpNDQ3QwAAAADYZUsA + 8NeXiIVaGyYQMkfLAAAAAAAAAAAAAAAAAAAA6ZSIhYWFhYWFhYVlWjcAAAChWwAA7t3esKadWFtYDRoA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA54o9UQB7WAAA3XXM8OCMhYFlWAswAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACYbSFbLAAA2C0AAKGHgYGFYBMWuwAAtUAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA4ZOIAAAA8WhRAJCQh4GBgV0LMD18zp9JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AIg8vqaclIiHgWVYE70AAAB8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOxou8fa2K2kpKF7 + vwAAAACtQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKPgD26eHdxqLCAAAAAAAAewAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACXPAAAAPrlyNEAAAAAAAAAmLcAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABtSwAAAACKAAAAAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABrAAAAAMK0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO54AAAAAG0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMa1AAAA8H8AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIwAAAAAANd+SQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAH4AAAAAAAD6jnVEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + 0L8AAAAAAAAAAPGXfwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAogAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /////wAA///5////AAD///n///8AAP///P///wAA///8////AAD///58//8AAP///nz//wAA///+PP// + AAD///88//8AAP/A/zz//wAA/4B/nP//AAD/gB+c//8AAP+AD5z//wAA/4APnP//AAD/gAec//8AAP+A + A5z//wAA/8ADPH//AAD/4AM8f/8AAP/gAT5//wAA//ABPz//AAD//AA/H/8AAD/+AB+f/wAAj//4CB// + AADh/8gAP/8AAPg+AAD//wAA/wAgA///AAD/wfwAP/8AAP///AAP8QAA///+AEIBAAD///wAYB8AAPgA + PEAD/wAA+AAcwAf/AAD//4TAA/8AAP//4MwBnwAA///xxAAPAAD////gAO8AAP///+AB5wAA////8gP3 + AAD////zh/MAAP////Pf+wAA////95//AAD////nv/8AAP///+c//wAA////74//AAD////vw/8AAP// + /8/x/wAA////3///AAD///////8AACgAAAAgAAAAQAAAAAEACAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAB + AAAAAAAANTVZADMzXwA7O1oAGxtpABYWcQAVFXcAGxt2ABwcdAAUFHgAERF9ABcXfwAbG34AKipgACAg + agAkJG0AKipoADY2YwAxMWcAPz9lACEhdgApKXIALCxyACgodQAsLHYALy94ACoqfwA1NXMAMDB2ADU1 + dgAwMHkANzd7ADU1fQA/P3sAQ0NfAEdHXQBAQGsARkZtAFhYZgBBQXAASUlyAEtLdgBPT3oASEh8AFZW + dgBeXnMAUlJ7AFxcfwBlZW4AYWF3AGxsdgBycn4ADg6LAA0NjgASEoMAEBCHABgYgAAREYoAEhKOABoa + jwAdHY4ACwuTAA0NkgAMDJUACgqaAAkJnQAODp8AEhKQABcXkQAbG5EAHx+RABERmQAUFJgAFxefAB8f + nQAhIYIAKiqGACcniwAlJY8AMzOBADIyhwA0NIgAMDCOAD8/iwAoKJEAKSmUAD09mwAHB6IABgamAAgI + ogAICKYABQWpAAUFrAAJCagAGRmgABwcoQAQEKsAFhaqABkZrAAdHa0ABga2AAoKtQAODrkAERGwABsb + sgAWFrgAHh67ABwcvAAhIacALS2nACIirgAlJa8AKSmoACkprQAtLawANzelADg4pgAyMqkAMDCtADs7 + rwAgILUAJSW6ADAwtgAzM7wANze+ADs7uQA8PL0AQECGAFZWgQBTU4UAWlqDAFBQiwBUVI0AQ0OaAFxc + nwBnZ4cAd3eFAHp6hgB/f4YAdnaKAHt7iAB/f4sAb2+QAHl5kQBBQa0AX1+hAE5OswBERLsAQEC9AFpa + tQBSUrwAYWGvAGJitwBqarEAeXm2ABUVwQAvL8wANzfAADs7xwA9PckAPDzNAE5OwwBSUsEAUFDEAFVV + xQBbW8IAXV3CAF5exQBYWMkAV1fUAGdnyQBzc8cAZ2fSAGpq0ABiYtoAenrTAICAgwCAgJAAgYG8AIGB + zgCRkdIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJMAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvKAAAAHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA8AAAAdowAAAAAAAAAAAAAAAAAAAAAAB0PAjAAAAAAAJMtAABwjQAAAAAAAAAAAAAAAAAAAABhQUE0 + BQMAAAAAABgAAG8AAAAAAAAAAAAAAAAAAAAAAGZYWFhBCQIAAAAAQwAAbgAAAAAAAAAAAAAAAAAAAAAA + m1xYWFhBBSMAAABLAABuAAAAAAAAAAAAAAAAAAAAAACuZVxYWFg/BLAAmIIAAHAzAAAAAAAAAAAAAAAA + AAAAAACcZVhYWFg2IwBeAAAAeyQAAAAAAAAAAAAAAAAAAAAAAACgaVxYWD8SAEsAAAAARQAAAAAAAAAA + AAAAAAAAAAAAAACunnlvcCEzDAAAAACrJwAAAAAAAAAAAJWHAAAAAAAAAAAAr6qkXjoJJgAAAAAMAAAA + AAAAAAAAAACSgQAAAAAAAAAAAABvYj8FEhgJQ1UAAAAAAAAAAAAAAAAAoU0oAACPT0heSE5aWEE/DIYA + AAAAAAAAAAAAAAAAAAAAAK1hSJAAAAAAqWRYWD8EMokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfmdc + WjQJGFUnAAAAALEvKwAAAAAAAAAAAAAAAAAAAABhVmpcWD8TAH9LGjxslgAAAAAAAJkgIBodGh0dJAAA + AEEAtHtoSRgUEDEAAAAAAAAAAAAAAAAAAAAAAACiTLAAOgAAhad9QUE2EAAAAAAAAAAAAAAAAAAAAAAA + AAAAYkVPALMoAGJYWEEFJgCDLgAAAAAAAAAAAAAAAAAAAAAAAAAAAE6LamddWD8IhgCnMwAAAAAAAAAA + AAAAAAAAAAAAAAAApC6Ynn56bY4AAABRAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAArJaaAAAAAKIAAAAA + AAAAAAAAAAAAAAAAAAAAAACBAACyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApwAAAFEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB0AAAAUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMAAAAAdi4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP///////f////7////+/////nf///9z//4fM//8D7f//Ae3//wDt//8ATP//gFz//8B + e///gHn/P+A9/8/8Af/xgAf//DwD///+APH//gIH4A6Af//iwH//+JAn///AE///wDv//+x7///t//// + 3f///93////ef////7//////KAAAABAAAAAgAAAAAQAIAAAAAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAA + AAAcHHoAGRl+ACMjcgAlJXMAISF1AExMbABaWnIAFBSEABAQiAAMDJUAIyOaAD09kwAGBqUACAihAAgI + pAAHB6sAGxugABgYpgASEq8AHR2rAAsLtAAbG7QAIiKwAD09swBCQo0AX1+CAFdXiABVVZEAUlKWAFtb + kQBcXJIAYWGNAGlpiABsbIsAd3ePAGpqkwBra5UAYGCZAHl5kQB+fpAAenqZAFdXpABYWKQAXFykAFpa + rQBubqYAZWWtAG1tqgB2dqAAdnauAH19rABjY7MAZGS2AGxsuABxcbkAdXW/AEhIwQB8fM4AZmbXAGFh + 2ACGhr8AgoLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /wAAAAAAAAA1AAAAAAAAAAAAAAAAAAAAAD4AAAAAAAAAAAAAAAAAAAAAJwAeAAAAAAAAAAAMAQcAACoA + HAAAAAAAAAAAFQ0KBgA4AB4AAAAAAAAAADwQDQkAJgAZAAAAAAAANQAAOxYSGiEAADUAAAAAAAA1AAAA + MRIDKCAkAAAAAAAAABweODoXDQgpAAAAAAAAAAAAAAAAABQOBRshJC4AAAA1LTUrACsAGAsBJwAANQAA + AAAAADU2ACQTDQUAKQAAAAAAAAAAAAAvPTkzAAAAAAAAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAAA1MAAA + AAAAAAAAAAAAAAAAAAAAAAAA/f8AAP7/AAD/XwAA418AAOFfAADhXwAAsG8AANwPAADgHwAA/wEAAMKG + AAD8hQAA/4cAAP+/AAD/zwAA//8AACgAAACAAAAAAAEAAAEAGAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODrMQEKpjY7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbG7kPD6sREaJ+fqwA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABxcdwODq8QEKQvL6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMPD6gSEp1wcKUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABiYtYNDa4QEKM4OJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMPD6cREZx3d6MAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NsgNDa0Q + EKA3N50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMODqYSEpoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ78NDasQEJ9GRp4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAACAgOIMDLAPD6QSEpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UODqkREZxWVp4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABT + U9IMDK4QEKEbG5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACEhNVISLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7MODqcREZpjY50AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEKoSEp89PZ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJsANDasQEJ8k + JJUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPD6gSEp0TE5N5 + eZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACAgOIMDLEPD6QSEpZmZpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAODqkREZ0TE5FZWZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UNDakREZs1NZYAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDasQEJ4TE5FERI0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABSUtEMDK4PD6ATE5Rzc5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAMDKwPD6ETE5IwMIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7MODqYSEphCQpQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDK4PD6ESEpMuLogAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGLwM + DKsQEJ0bG5B/f4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC64ODqISEpMa + God/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABwcN0LC7APD6ISEpVWVpQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAALC68ODqIREZMUFIl/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrUNDagREZkjI48A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCq8NDaMREZQTE4l/f38AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA1NcgMDKwPD58TE5FhYZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoKCq8NDaMREZQTE4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcJdMTIc7O3wt + LXUtLXItLW8uLm9ERHBYWHNwcHB2dnZ+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7IODqUSEpY5OY4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaMQEJQTE4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABYWKAZGYgTE4ITE30UFHoVFXgWFnUWFnIXF3AYGG0ZGWoeHmg2NmZdXW5wcHB6enoAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAKCrcMDKkQEJsTE45ycokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQQEJUT + E4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHJoQEJAREYkREYQSEoETE4ETE4ATE34UFHsUFHYV + FXMXF24YGGsZGWkaGmc2NmNcXGxwcHB9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSUtILC68ODqASEpNFRY4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edsKCrANDaQQEJUoKIsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIqgODpkODpMP + D5AQEIwPD4wQEIwQEIsQEIoREYcSEoQTE38UFHoVFXQWFm4YGGkaGmYbG2ZAQGNpaWl1dXUAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrMNDaUR + EZYbG4t+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQQEJUuLosAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA2NrgaGqcLC5wMDJoMDJkMDJgMDJcMDJcMDJYNDZYNDZMODpEPD40REYgTE4IUFHsV + FXQXF2wZGWcaGmUpKWFWVmtvb29/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAXF7wMDKsQEJwTE45XV4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edsKCrANDaUREZUuLowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIiNkhIbQVFasJCaQJCaMJCaIKCqAKCp8KCp4K + Cp4KCp0KCpwLC5oMDJcNDZMPD48REYkTE4EUFHgWFnAYGGkaGmUgIGNMTGVra2t8fHwAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYdgLC7AODqASEpIqKol9fX0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQREZYuLowAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTMkf + H7gTE7EICKoICKoHB6gICKUICKQHB6MICKMICKIICKEJCaAJCZ4KCpwMDJgNDZMPD44REYUTE34VFXQY + GGwZGWUbG2M/P2FpaWl5eXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAKCrMNDaUREZYUFIpvb4YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoKCrANDaQREZYv + L4wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAeHr8eHrsTE7UGBrAGBq4HB6sHB6gHB6YGBqYHB6YHB6YHB6UHB6QI + CKMICKEJCZ8KCpwMDJcODpEQEIoTE4AUFHYXF20ZGWYbG2M2NmFoaGh4eHgAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJb4MDKgQEJgTE4xDQ4gAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edoKCrANDaQREZZLS48AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeHsIdHb0SErgGBrQGBrEG + Bq0GBqoGBqgGBqcGBqcGBqcGBqcGBqYHB6YHB6UHB6MICKEKCp4LC5oNDZQQEI0SEoMUFHgXF20YGGYb + G2M2NmBpaWl6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtbdgM + DKkPD5oSEo4hIYYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC68NDaQQEJZMTJEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAcHMQcHMAVFbwFBbYFBbMGBq4GBqoGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6YHB6QI + CKIJCZ8KCpwMDJYPD44SEoQUFHgWFm4YGGYbG2M2NmBqamp9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6kODpsSEo8UFIhvb5AAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoLC68NDaQREZZMTJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMUcHMIaGr8FBbcFBbQFBa8GBqsGBqgGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6UHB6MICKEKCpwMDJYPD48SEoQUFHkWFm4ZGWYaGmNJSWNt + bW0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6gODpsSEo8TE4kA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC68ODqQREZVUVJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQNEc + HMQcHMEHB7sFBbYFBbEGBqwGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UHB6MICKEK + Cp0MDJcODo8SEoQUFHgXF20ZGWYbG2RRUWdwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAALC6YODpkREY8hIYkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqMREZVo + aJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABnZ94cHMQcHMIODrwFBbcFBbMGBq0GBqoGBqgGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcGBqYHB6YHB6QICKEKCp0MDJcPD48SEoMUFHgXF24ZGWYgIGNbW2t1dXUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABWVsILC6MODpcREY89PY0AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edoLC64ODqMREZRmZo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMccHMMaGsAFBbkF + BbQFBbAGBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6QICKEKCp0MDJYP + D44SEoMUFHYYGGwaGmUpKWFpaWl8fHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFqsN + DZ4PD5UREY1kZJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqESEpNlZY4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAnJ8scHMUcHMMLC70FBbcFBbIGBq0GBqoGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcHB6YHB6QICKEKCpwNDZUQEIwTE4AVFXQYGGkbG2RAQGNubm4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC6YNDZwQEJISEo0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoLC64ODqESEpJJSYsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaOEcHMgcHMQVFcAFBboFBbQFBbAGBqwG + BqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UHB6MJCaALC5sNDZMQEIoTE34W + FnAZGWcbG2VbW2t4eHgAAAAAAAAAAAAAAAD///8AAAAAAAAAAAAAAABISL0MDKINDZgQEJA1NY4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqESEpFISIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAcHMobG8UcHMQMDL0FBbcFBbIGBq4GBqoGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqYHB6UICKMJCZ8LC5oODpEREYUUFHkXF20aGmYtLWJtbW0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALC6kMDJ8ODpUREY9kZJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsLC64ODqESEpE7 + O4V9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaOEbG8kbG8QZGcEGBrkFBbYFBbEGBqwGBqoGBqgGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKIKCp4MDJcPD44TE4EVFXQYGGkaGmZT + U2p4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f9ALC6YNDZsPD5MYGI0AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edsLC7AODqISEpInJ4N4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMsbG8cc + HMQTE8AFBbgFBbMFBbAGBqwGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YH + B6QICKEKCpwNDZQQEIoTE3wXF28ZGWcsLGRubm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAiIrMMDKINDZkQ + EJI+PpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6etwKCrINDaUREZQUFIZzc3MAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACEhOgfH8odHcUcHMMODr0FBbcFBbIFBa8GBqsGBqkGBqgGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6MJCZ8LC5kODpASEoMUFHYXF2saGmdUVG18fHwAAAAA + AAAAAAAAAAAAAAAAAAALC6oMDKAODpYQEJB1dZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8 + fN8KCrUMDKgQEJcTE4hTU319fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHR9YkJMohIccfH8MODrwF + BbYFBbEGBq4GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKEKCp0N + DZUQEIsTE30XF28ZGWkxMWVzc3MAAAAAAAAAAAAAAAAAAABmZskLC6cNDZ0PD5UgII8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+fuMJCbgLC60PD5sTE4w+Pn93d3cAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAsLM4oKMooKMUmJsQQELwFBbYFBbIGBq4GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcHB6YHB6QJCaALC5oODpASEoMVFXYYGG0ZGWtnZ3IAAAAAAAAAAAAAAAAAAAAj + I7MLC6QNDZsPD5NVVZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLsKCrENDaIS + EpIaGoR0dHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMM4uLsotLcgrK8UTE70FBbYFBbIG + Bq4GBqsGBqkGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UICKEKCpwNDZQQEIoUFHsW + FnAYGGxMTG8AAAAAAAAAAAAAAAAAAAALC6kMDKIODpkREZJ/f5cAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAHB78JCbYMDKkQEJkTE4tZWYV9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABzc+M0NM8zM8wyMsowMMgXF78FBbYFBbIGBq4GBqsGBqoGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqcHB6YHB6MJCZ8MDJgPD48TE4EVFXUXF242Nmx8fHwAAAAAAAAAAAAAAAALC6YMDKAPD5g2NpEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYN0ICLoKCq8ODqASEpIxMYp9fX0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYN46OtA4OM43N8s1NckiIsEFBbYFBbIFBa8GBqwG + BqoGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UICKELC5sODpISEoUUFHkXF3EoKHN6enoA + AAAAAAAAAAB0dMkMDKQNDZ0QEJVbW5MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAlJcgJCbYMDKkQEJsTE49mZo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZWdo/ + P9E+Ps89Pc07O8svL8QODrgFBbMFBbAGBq0GBqsGBqkGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcHB6YI + CKIKCpwNDZUREYgUFHwXF3QqKn93d3cAAAAAAAAAAABaWr4MDKAODpkYGJF9fYoAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLwLC7EODqMREZYzM5EAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcXNtERNJDQ89BQc0/P8o7O8ggIL8FBbQFBbIFBa8GBqwGBqoG + BqkGBqgGBqgGBqcGBqcGBqcGBqcGBqYHB6MKCp4MDJcQEIsVFYAmJn8sLIB0dHQAAAAAAAAAAAA/P7AN + DZwPD5UZGY4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ + CbgMDKwPD6ATE5NubpYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6euRKStNISNFH + R85ERM1DQ8w7O8gbG70FBbMFBbEGBq4GBqwGBqsGBqoGBqkGBqgGBqgGBqgGBqgHB6UJCZ8MDJgTE48s + LI4xMYYwMINxcXEAAAAAAAAAAAA9PacODpYQEJATE4hpaYcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtsKCrQNDagREZo2NpYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACFheZQUNROTtJLS9BLS89JSc1HR8s9PccgIL0NDbQFBbEFBa8GBq0GBqwG + BqsGBqoGBqoGBqoHB6cREaYlJac1NaI2NpY2Now2Nohubm4AAAAAAAAAAABXV6UPD5AREYoTE4JNTX9/ + f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NcgLC68PD6ET + E5VgYJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYWNZTU9RRUdJQUNBO + Ts5MTM1LS8xKSso7O8QqKr0cHLkUFLUTE7MUFLIbG7QkJLY1Nbk5Obg6OrM7O6o8PKA9PZM2NotXV3F6 + enoAAAAAAABVVZUPD4sSEoUUFH0zM3Z4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAZGbYODqUREZgcHIx+fooAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB7e+JYWNZWVtRVVdJTU9BRUc9QUM5OTs1MTMtMTMpKSslISMdGRsdERMRCQsRB + QcJBQb9AQLpBQbJBQak+PpwaGoIrK3Vzc3N8fHwAAABkZIQQEIUSEoIVFXgXF3JwcHAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f9sNDaYQEJgTE4xISIp+fn4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZtpcXNZaWtRXV9JWVtFV + VdBUVM9SUs5QUM1OTsxMTMtMTMpKSslISMdHR8NGRr9GRrpGRrIgIJgREYU1NXdNTXQPD4IUFIBWVnEP + D4QSEn8VFXUXF29QUG55eXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAaGqgQEJgTE4sVFYFlZYJ+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABjY9gODrQnJ7MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABoaNtgYNZeXtVcXNRaWtFYWNFWVs9WVs9UVM5SUsxQUMtPT8pNTchNTcRMTMAj + I6wMDJsODpBnZ3gODogODogODocSEoMUFIESEoAUFHYXF242NmVubm4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUVLQPD5UTE4oVFYEuLnt3d3cAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRtEMDLgNDbIPD6tFRbIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDg+JlZdZiYtRgYNNeXtFc + XM9bW85ZWcxXV8xWVstUVMpOTsUUFLEJCakKCqM0NJcNDZkMDJUNDZQMDJINDZAODowREYYTE3kWFm4e + HmZgYGlycnIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABycq0P + D5ISEosUFIIWFn5dXYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAoKMYMDLgNDbIODqwQEKZRUbMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACRkeKBgdtzc9RxcdBwcNBvb89zc9CIiNU4OL0GBq0HB6p1dbUSEqMLC6ML + C6ALC5wKCpoMDJgXF4oQEIsTE4AUFHMYGGk/P19lZWVwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABra5MODpAREYwTE4YVFYI3N4UAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRc0MDLQNDa8PD6oQEKVmZrkAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABGRrsSEqsICKsICKoJCagJCaUKCqIKCp8bG4sYGIgREYcTE3oVFW0YGGcjI2NJSWZt + bW16enoAAAAAAAAAAAAAAAAAAAAAAAAAAABnZ4NeXoFdXYBaWn9aWn9aWoBISIQODpIQEJASEowTE4gz + M5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABFRcwMDLMODq8PD6oQEKVSUrUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdHbAGBqkICKwHB60ICKwHB6kICKYREaUZ + GaQMDJcPD48SEoIUFHcWFm0YGGgZGWc2NmJnZ2dwcHB4eHhXV389PXshIXkVFXwVFXwUFH0TE4IREYgQ + EI0NDZIMDJMMDJUNDZQODpUREZESEpFLS6MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRcwMDLQNDa8ODqoQEKY8PK+AgLgA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABL + S7sYGK0HB6wHB68HB64GBqskJLI1NbQJCaIKCp0NDZUPD4wSEoETE3kVFXEWFm0XF2s9PWBDQ2QaGnAU + FHYTE3oTE34TE4ATE4MSEoUREYoPD5AODpYMDJkLC5sLC5oMDJoNDZoPD5kbG5wAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABhYdcMDLQNDbAODqsQEKYlJahgYLIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYbFaWsBMTMExMbwwMLxGRsA7O7sMDKkICKQJCaEKCpsNDZUP + D44REYUTE34TE3cUFHQTE3QTE3cTE3kSEn0REYMQEIcPD4oPD48ODpINDZYNDZoMDJ8KCqAKCqEKCqAL + C6ENDaIlJaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtgMDLUNDbAODqwPD6YQEKE4OKZr + a6oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABkZJVDQ5EmJo4REZAREZAREZAREZAeHpA5OY9SUotuboV8fHx3d4NiYrRjY8dgYMpT + U8UgILUHB6sHB6gHB6YICKMJCaAKCpwMDJcODpIPD4sQEIYREYQREYIREYMREYUPD4gPD4sODo4MDJIM + DJYLC5kLC54KCqEKCqQJCaYKCqcKCqgjI69wcMkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABiYtgMDLUMDLEODqsPD6YQEKEcHJ1ISKJsbKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2dpdERJEfH40REY8QEJAQEJIQEJMPD5QPD5UPD5UPD5cO + DpgNDZkLC5oYGJg7O5JjY4Vycn9eXooGBq8GBq0GBqsGBqkHB6gHB6YICKMICKEKCp0LC5oMDJcNDZMO + DpEODpAODo8ODo4ODo0MDI4MDJALC5MLC5gLC5wKCqEJCaUKCqgWFq1XV8MAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYdkLC7YMDLENDasODqYQEKEREZwb + G5ZMTJt1dZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUVJMmJo0REY4QEJAPD5IP + D5QODpYODpkNDZwNDZ4NDaANDaEMDKMMDKMLC6MKCqMJCaQICKUHB6kWFqgUFKoGBrEGBq8GBqwGBqoG + BqkHB6cHB6UHB6MICKIJCaAKCp4KCpwLC5sLC5oLC5YMDJMLC40LC4wLC4sLC44LC5MhIZ5GRrF+fsoA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABxcd0YGLsLC7INDa0ODqcPD6AREZsSEpYjI5JISJJubo8AAAAAAAAAAAAAAAAAAAAAAABb + W5M1NY4REY8QEJAPD5IODpQODpcNDZkNDZ0MDKELC6QLC6gwMLQKCq0KCq4JCa8KCq8JCa4ICK4HB68H + B7AGBrEGBrMFBbMGBrQGBrAGBq4GBqsGBqkGBqgGBqYHB6YHB6UHB6QICKIICKEJCaAKCp4KCpoLC5IL + C4ksLHM8PHRiYoMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+MYGLwLC7MMDK4NDagPD6IQEJsS + EpYSEpEqKpBRUY5xcYhbW4ozM4sREY4REZAQEJIPD5UODpcNDZoMDJ0MDKALC6QLC6gwMLV+ftAAAAAA + AAAAAAAAAABtbdkyMscICLoHB7kGBrkGBrgGBrcFBbcFBbcFBbYGBrQFBbEGBq0GBqoGBqkGBqgGBqcG + BqYHB6YHB6UHB6QICKIICKEKCpoLC5EMDIUtLWxlZWV0dHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAlJcMKCrQMDK8MDKkODqQPD54QEJoQEJcQEJYQEJUQEJUPD5YODpcNDZsMDJ4MDKEL + C6QLC6giIrFjY8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTtUFBb8FBb0PD7wEBLkF + BbgFBbcFBbMFBbAGBqwGBqoGBqgGBqcGBqcGBqcGBqcHB6YHB6QICKEKCpsMDI8NDYMPD3owMGpoaGh2 + dnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcMKCrYKCrELC60MDKkNDaYN + DaQNDaIMDKEMDKEMDKILC6ULC6gWFq1WVsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAiIsUSEr8EBLsFBbkFBbcFBbEGBq4GBqoGBqkGBqgGBqcGBqcGBqcHB6YH + B6QICKEKCpoMDJAODoMREXkSEnMyMmdnZ2dxcXF8fHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABDQ88JCbgJCbUKCrMKCrEKCq8KCq0KCq0WFrFWVsUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhOYeHsUQEL8EBLoFBbgFBbQF + Ba8GBqwGBqkGBqgGBqcGBqcGBqcHB6YHB6QICKEKCpwMDJMPD4cREX0SEnUUFHAzM2NVVWdVVW5JSXJF + RXdHR31JSYJMTIdiYo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYNgWFr8JCbokJMBoaNIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA0NM0kJMUZGb4MDLgFBbQFBbEGBq0GBqoGBqkGBqgGBqgGBqgGBqYHB6UICKIJCZ0LC5cO + Do4QEIMSEnsTE3UUFHMVFXMVFXIVFXUVFXYVFXgUFHwUFIAUFIMVFYZDQ5B7e5MAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvL8kpKcEjI70cHLoREbQFBa8GBqwGBqoG + BqkGBqkGBqkGBqgHB6YHB6MJCaAKCpsMDJUODo0QEIYSEoETE34UFHwUFHoUFHsTE3oTE3sTE34TE4QT + E4kTE40TE44TE41LS5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA0NMMuLr4qKrwkJLsZGbYJCa4GBqwGBqwGBqsGBqsGBqoHB6gHB6UICKIJCZ8KCpsMDJcODpIPD40Q + EIkREYgSEoUSEoESEn4SEn0SEoEQEIgQEJAQEJUQEJcSEpYTE5MkJI9ubpYAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzc5Vra5ZOTpZP + T5hCQpg0NJg1NZw3N6Fra7YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZMkzM741Nb4uLrwpKbohIbUKCq4FBa4FBa4GBq0GBqwG + BqsHB6gHB6UICKIJCaAKCp0LC5oMDJcNDZQODpEQEIwREYYqKnBUVG9qaoQAAAAAAAAoKKMODp0PD50R + EZkSEpQTE41MTJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6epFj + Y5RNTZM3N48hIY8SEpASEpISEpMREZUREZYSEpgSEpoSEp0SEqEdHacAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQELMKCq8mJrc6 + Ors1NbkuLrYmJrUQELAFBa8FBbEFBa8GBq0GBqsHB6gHB6YHB6MICKEJCaAKCp0LC5oMDJYODo8QEIcP + D4FWVmt6enoAAAAAAAAAAAB4eMsNDaIODp8QEJkSEpMTE4wcHIlmZpUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABzc5VbW5NFRZEuLpAYGI4REZAREZIREZMQEJQQEJYPD5kPD5oPD5wPD58PD6APD6IQEKQoKK1n + Z8kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABUVMkGBrAGBqsFBagVFao4OLQ6OrUzM7UtLbgSErQFBbMFBbMFBbAGBq0GBqoGBqgH + B6cHB6UHB6MICKEKCp0LC5kNDZAQEIcQEH4mJnFycnIAAAAAAAAAAAAAAAAAAAAyMq0ODpwQEJYREZES + Eo0TE4o0NI98fJNra5NiYpNNTZM/P5InJ5ASEpAREZEREZMREZQQEJYQEJcPD5kODpsODp0NDaANDaIN + DaQMDKYNDagMDKo+Prt1dc8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHB7UHB64GBqkGBqMGBp4gIJlZWaw+Prk4 + OLsxMb0aGrkFBbUFBbMFBa8GBqwGBqoGBqgGBqYHB6UHB6MJCaALC5sNDZIQEIgREX0TE3lbW3IAAAAA + AAAAAAAAAAAAAAAAAABjY7EPD5cQEJMREZAREY8SEpASEpEREZMREZQQEJUQEJcPD5cPD5kODpsODpwO + Dp4NDaEMDKMMDKUMDKcMDKkLC6sXF7BLS8J1ddEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH + B7QHB60HB6cICJ8ICJphYYwAAABpacFERME9PcI3N8IfH7wICLUFBbIGBq4GBqsGBqkGBqgGBqYHB6QI + CKEKCpwNDZIQEIcREX0TE3Y/P2x4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAzM5cPD5EPD5IPD5UPD5gP + D50ODp8NDaENDaIMDKMMDKUMDKYLC6gLC6oLC60KCq49Pb9nZ80AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB3d9gICLMICKwICKUJCZwWFpIAAAAAAAAAAAB1ddFISMhCQsc9PcUt + LcEQELYFBbAGBqwGBqoGBqkGBqgHB6YICKIKCp0NDZQQEIoSEn0TE3UvL2tubm57e3sAAABubopmZol9 + fX17e3t/f38AAABra5ogIJUNDZYNDZwNDaEMDKYLC6kLC6wKCq4jI7c+PsB1ddMAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABubpppaZNmZo9jY4xiYohhYYhh + YYdhYYdhYYdgYIZgYIZgYIZgYIZhYYdhYYdhYYdhYYhhYYhhYYhiYohiYohiYohpaYh/f39/f38AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQMgICLMJCasKCqILC5ks + LIsAAAAAAAAAAAAAAAB7e9tOTsxISMpBQcg8PMUnJ7wQELIGBqwGBqsGBqoHB6gICKQKCqAMDJgPD40U + FIMgIH82NnJmZmZHR20fH3YSEn0REYAQEIEsLHhZWXFwcHB+fn4AAAB/f6hkZLJtbcF0dMwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NcUNDbIODqsP + D6QQEJ0REZgSEpQSEpISEpETE5ATE48TE44TE40TE40TE40TE40TE40TE40TE40TE40TE40TE40TE40T + E40TE40TE40TE4sTE4sTE4oTE4gUFIgVFYYvL4VhYYh9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA/P8YJCbAKCqkLC58NDZVCQocAAAAAAAAAAAAAAAAAAAB7e9pTU85NTcxISMlBQcU8PMEv + L7wdHbUTE7IODq8ODqoQEKYYGKIgIJwmJpMnJ4hAQG0yMmYTE3UTE3gSEnwREX4REX4REXwREXs7O21q + amp6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABGRtMLC7wLC7gMDLMMDK0NDagNDaMODqAODp4PD54PD50PD50PD5wQEJsQEJsQEJsQ + EJsQEJsQEJsQEJsQEJoPD5oPD5kPD5kPD5kPD5kQEJgQEJgQEJYQEJUQEJQSEpITE5ATE4wUFIg+Pol4 + eIQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/P8IJCawLC6QNDZoPD5BKSoUAAAAAAAAAAAAA + AAAAAAAAAAA8PMlYWM5TU8tMTMhHR8RAQMI7O8A1Nb8wML0qKrgmJrMgIKwiIqMkJJslJZEhIX4QEHwQ + EH0QEIAQEIIQEIMQEIAREXwSEncSEnYxMWtpaWl6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOYlJccKCroKCrcKCrIKCrALC60L + C6sLC6sMDKsMDKsMDKsMDKsMDKoMDKoMDKoMDKoMDKoMDKoMDKgMDKcMDKcMDKYMDKcMDKcMDKcMDKYM + DKUMDKQNDaMODqAPD54QEJoSEpUTE48rK45xcZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+PrwK + CqYMDJ4PD5QQEItgYIUAAAAAAAAAAAAAAAAAAAB1ddgFBbhAQMdeXsxYWMlTU8VMTMRGRsNAQMQ7O8I1 + Nb4wMLoqKrMmJqsiIqQeHpsODo4ODosPD4oPD4sPD4wPD4wQEIgREYASEnkTE3MTE3EyMmhqamp+fn4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB9feJBQcwWFr0ICLcJCbYJCbUJCbUJCbUJCbUJCbQJCbQJCbMJCbMJCbMJCbMJCbMJ + CbMJCbIJCbIKCrIKCrIKCrIKCrIKCrIKCrIKCrEKCrEKCq8MDKwNDagODqMQEJwSEpYcHJFxcZsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAuLq4LC6ANDZoQEI4SEohoaIcAAAAAAAAAAAAAAAAAAABLS8sFBbYF + BbAuLrljY8hdXcdWVsVQUMVLS8dFRcU/P8I6Or01NbkwMLMoKK0QEKALC5oLC5cMDJcMDJcMDJYNDZQO + DpAQEIgSEn8TE3YUFG8WFm1CQmZubm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB7e90AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABt + bdgmJr4LC7AMDKsODqQQEJwSEpZeXqAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC50LC5kNDZMREYoTE4YA + AAAAAAAAAAAAAAAAAAAAAAAhIb4GBrMHB6sWFqR1daBkZMFjY8hcXMlXV8pQUMlKSsRFRb8/P7s7O7Ux + MZ8ICKYJCaIJCaEJCaAJCZ4KCp0LC5sMDJYODpAQEIcTE3wUFHIWFmsYGGpWVmt2dnYAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJsAMDLEODqoQEKIREZo/P54AAAAAAAAAAAAA + AAAAAAAAAAAMDJUNDZMPD48SEogZGYUAAAAAAAAAAAAAAAAAAAAAAAAHB7gHB7AICKgpKaAAAAAAAACN + jcl3d85cXMtcXMxWVshXV8FHR7UdHaYGBqkICKgHB6YHB6QHB6QICKMICKIJCaAKCpwMDJcODo8REYUT + E3kXF24ZGWgoKGRra2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABw + cN4LC7UMDK4ODqYPD58bG5pTU515eZAAAAB+fn58fHwMDJENDZAPD40SEokuLogAAAAAAAAAAAAAAAAA + AAAAAAAICLcICLAJCaZCQpwAAAAAAAAAAAAAAAAAAAAAAAAAAAB0dLoFBagGBqoGBqoHB6oHB6gHB6cH + B6YHB6YHB6UHB6QICKEKCpwMDJYPD40TE4EVFXQYGGkaGmZJSWZ1dXUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGL0LC7MMDKsNDaUODp8ODpscHJkoKJMlJZAMDJQN + DZEPD44REYxPT5UAAAAAAAAAAAAAAAAAAAAAAAAICLgJCa8LC6VNTZ0AAAAAAAAAAAAAAAAAAAAAAAAA + AAAFBasFBakGBqsGBqwGBqoGBqkGBqgGBqcGBqcGBqcHB6YHB6QICKEKCpwNDZQQEIoTE3wWFnAZGWcj + I2NsbGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABra6pXV6N/f6IAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERNAK + CrcKCrELC6wLC6cKCqQKCqIKCp4LC5oNDZUPD5IREZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCboKCrAM + DKVQUJ8AAAAAAAAAAAAAAAAAAAAAAAAGBq8GBq0FBasGBqwFBasGBqsGBqkGBqcGBqcGBqcGBqcGBqcH + B6UHB6MJCZ8LC5kODpESEoQUFHcXF2wZGWdKSmd1dXUAAAAAAAAAAAAAAAAAAACAgK0/P6QSEpsSEpkT + E5YcHJSAgKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+UICLsJCbcJCbMJCbAJCa0JCaoLC6MMDJ4ODps2NqIAAAAA + AAAAAAAAAAAAAAAAAAAAAAA0NMoKCrIMDKYXF50AAAAAAAAAAAAAAAAAAABVVcMGBq8GBq4FBa8GBq4F + Ba0GBqsGBqgGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKIKCp0MDJYQEIsTE38VFXIXF2swMGRra2t5eXkA + AAAAAABnZ6EiIpoQEJ0PD6APD6AQEKAREZ0SEpkwMJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcgHB7wH + B7oICLYJCbEKCqwMDKgZGacAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+MKCrUMDKkODp5PT5kAAAAA + AAAAAAAAAAAcHK8HB68GBrEFBbIGBrIFBa8GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcHB6YHB6QJCaAL + C5sODpIREYYTE3oVFXEWFm5fX2lwcHBdXYcwMI0REZQPD5wODqMYGKlfX8EAAAAcHKoQEKESEpxVVakA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB/f+YVFcIHB70ICLkKCrUlJbkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAJCbkMDK0ODqIZGZkAAAAAAAAAAAAAAAAlJbIfH7YVFbkKCrcFBbUFBbEGBq0GBqoGBqgG + BqcGBqcGBqcGBqcGBqcGBqcHB6UICKIKCp4MDJcPD44SEoMTE3kTE3Q5OW0fH3oSEoYREZEPD5oODqNe + XsAAAAAAAAAAAAAAAAAODqsQEKQSEpwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtoLC7INDacPD51PT5kAAAAAAAAAAAA8PLYq + KrkoKL0mJsAgIL4VFbgNDbIGBqwGBqkGBqgGBqgGBqcGBqcGBqcGBqcHB6YHB6QJCaALC5sNDZMQEIoR + EYESEnwSEn0SEoMREY4PD5hGRrEAAAAAAAAAAAAAAAAAAAAAAABxcdoNDawQEKM6OqUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK + CrgMDK0ODqIZGZoAAAAAAAAAAABoaLszM7swML8uLsEsLMIrK8ApKbwnJ7kbG7MVFa8NDasICKkGBqcG + BqcGBqcGBqcHB6UICKIKCp4LC5gODpEPD4cSEoQTE4UQEIstLZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAaGrkODqsREaB/f6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtkLC7MMDKgODp5PT5sAAAAAAAAAAAA8PLw5OcA2NsM0NMMy + MsUxMcIvL74uLrwtLbkrK7cqKrQjI7IdHbAZGa0UFKwUFKoUFKcUFKMWFp8cHJkiIpQlJZIiIoppaaMA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOINDbEPD6UvL6MAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrgLC60NDaMX + F5wAAAAAAAAAAAB2dsNBQcI/P8U9Pcg7O8g6Osg5OcQ3N8I1Nb80NLwyMrowMLcuLrYsLLUqKrQqKrIp + KbAoKKwnJ6UnJ54nJ5gmJpWCgpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGboO + DqsREZ9+fqsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABiYtgKCrEMDKcODp5cXJkAAAAAAAAAAABubsxISMlFRctERMtCQstAQMs/P8k9 + PcU8PME6Or85Ob03N7s2Nro0NLkzM7YyMrMxMa8xMagwMKEvL548PJsAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACAgOIMDLAPD6Q4OKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrQLC6kNDZ8eHpgAAAAAAAAA + AAAAAAB4eNdPT89MTNBKSs9JSc5HR8xFRcpERMhCQsVAQMI/P8E+Pr89Pbw7O7k6OrY6OrE5Oas5OaY4 + OKVzc6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UODqkREZ57e6gA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABfX9MLC6wNDaEODphhYZQAAAAAAAAAAAAAAACQkOZVVdNTU9NRUdFQUM9OTs5MTMxMTMpKSsdI + SMRHR8BFRb1ERLtDQ7dBQbNCQq9BQa1JSa4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABhYdcNDa8QEKRBQaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6wNDaAPD5c8PJQAAAAAAAAAAAAAAAAAAAAA + AABgYNlaWtZYWNNWVtBVVc5TU8xSUshRUcRPT8FOTr5MTLtMTLhKSrVLS7VOTrUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7QODqkREZ8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6wO + DqAQEJcvL5MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaNpgYNReXtFcXM1bW8lZWcRXV8BWVr5VVbxV + VbtUVLteXr4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABERM4MDLAPD6ZLS6sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC6sODp8QEJU/P5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACAgNxmZs9jY8tiYsVhYcJgYL9gYMBra76UlM8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7YODq0QEKUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKkODp0REZVdXZgAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArK7QeHq0gIKpjY64AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8UMDLQO + Dq5pacEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABaWsoMDKgODpwREZR3d5oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2dsgICKoK + CqUcHKEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC7oNDbU1Nb0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMbsMDKYPD5oZGZMAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAUFK4KCqcMDKJ8fKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYt0ZGb9FRcsAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC64NDaMQ + EJpBQZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcXMELC6cMDKIxMaEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALC6wNDaIQEJliYp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAALC6gNDaEODp0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6oODqAQEJgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5ObYNDaMODpxERJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABaWsoMDKkODp8pKZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKkODp8XF5cAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMrsNDacPD51cXKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAXF7QMDKkODp5PT5sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC68NDaUPD50A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrQMDKsXF6EAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAMDK0ODqMhIZ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Nc0KCrcM + DK5LS68AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1ddEMDKsODqJPT6cAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABxceEJCbsLC7MwMLMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9 + Pb8NDakPD6EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Nc0KCrkMDLEODqhQULEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGLAODqYsLKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABiYtwKCrgMDLIODqkQEKJMTKsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKwODqVlZa8AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGL0MDLMNDawPD6UREZ5KSqUA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABlZcwNDaoPD6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABTU9MLC7YMDLAODqkQEKMREZxJSaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMrsODqlBQa4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8QLC7QNDa0PD6cQEKESEptaWqYA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLAO + Dqh9fbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAmJsIMDLMNDawPD6YREaAcHJxsbKsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABmZs8NDa8iIq4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOQZGbsMDLIODqsPD6YREaAwMKUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJL0NDbFlZb8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB/f+IZGboNDbAPD6wQEKgdHagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALC7kYGLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+IaGrkODrIODrBQUMYAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERNELC7t1ddUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGcUZGcAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////// + /////////////////////////////////j////////////////////4f///////////////////+H/// + /////////////////w////////////////////8P////////////////////h/////////////////// + /4f////////////////////H////////////////////w////////////////////8P///////////// + ///////h////////////////////4f//P/////////////////D//x/////////////////w//8P//// + ////////////8H//D/////////////////h//w/////////////////4P/8P/////////////////D// + D/////////////////wf/wf////////////////8H/8H/////////////////h/+B/////////////// + //4P/g////////////AA////D/4P///////////AAD///wf+D///////////gAAP//8H/g////////// + /wAAB///g/4P//////////4AAAH//4P+D//////////8AAAA//+B/g///////////AAAAH//wf4P//// + //////wAAAA//8H+D//////////8AAAAH//B/g///////////AAAAA//4P4P//////////wAAAAP/+H+ + D//////////8AAAAB//h/g///////////AAAAAP/wf4P//////////4AAAAB/8H+D//////////+AAAA + Af/D/g///////////gAAAAD3g/4P//////////8AAAAA/4P+B///////////AAAAAH8H/gf///////// + /4AAAAB/B/4H//////////+AAAAAPwf+A///////////wAAAAD4P/gP//////////+AAAAA+D/8D//// + ///////wAAAAPg//Af//////////8AAAAB4f/wH///////////gAAAAcH/+B///////////8AAAAHB// + wf///////////gAAABw//+D///////////8AAAAcH//g////////////gAAAHA//8H///////////+AA + AAwP//g////////////wAAAED//4H////////////AAAAAf//A//////j/////8AAAAH//wP/////4P/ + ////wAAAA//8D//////A//////gAAAH//A//////8D///////gAAfwAP//////wP//////4AAAAAD/// + ////Af/////+AAAAAB///////8B//////gAAAAA////////wD///4AAAAAAAf////////AH//wAAAAAA + A/////////8AP/wAAAAAAB//////////wAfgAAAAAAH///////////AAAAPAAAAB///////////+AAAf + /AAAAP///////////4AA//+AAAA////////////gB///gAAAAP//////////+D///8AAAAAf//////// + ///////gAAAAD///////////////8AAAAAP///AH//////////AAAAMB//wAB//////////wAAADgH+A + AA//////////4AAAA+AAAAB//////////+AAAAPwAAAH///////////gQAAB/AAA////////////wOAA + AIIAH/////+AAAA//8DwAAAAh//////wAAAAAf/A+AAAAH//////4AAAAAD/wPwAAAA///////AAAAAA + f8D4AAAAH//////+AAAAAD/A+AAAAB////////+//+AfwfgAAAAP///////////8D8H4YAAAD/////// + /////gEB+H8AAAf///////////+AAfh/AAAH/H//////////wAP4fgAAA+A//////////+AD+HwAAAGA + P//////////4B/g8AAAAAh///////////A/8PAAAAA8f/////////////BwAAAA/D/////////////4c + AAAA/4f////////////+DgAAAf+H/////////////w4AAAP/w/////////////8HAAAH/8P///////// + ////h4AAB//h/////////////4PAAA//4f/////////////D8AAf//H/////////////w/wAP//w//// + /////////8P/AH//+P/////////////D/8P///h/////////////g/+H///8f////////////4f/h/// + /H////////////+H/w//////////////////h/8f/////////////////4/+H/////////////////8P + /j//////////////////D/w//////////////////x/8f/////////////////8f+H////////////// + ///+H/h//////////////////j/8H/////////////////4//gf////////////////+P/+B//////// + /////////H//wH////////////////x///Af///////////////8f//8B///////////////+P///gP/ + //////////////j///+B///////////////5////4P//////////////8f////////////////////P/ + /////////////////////////////ygAAABAAAAAgAAAAAEAGAAAAAAAADAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxccwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODqV7e8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABCQrUkJKYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp11dbcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ6YiIqMAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6eswNDZt7 + e7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAANDZs3N6YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODqgAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABQULgNDZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp5RUa0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODppJSakAAAAAAAAAAAAAAAAAAAAAAAAA + AAANDZkzM6IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ6MODpoAAAAAAAAA + AAAAAAAAAAAAAAAAAAANDZgzM6EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABr + a8QNDZhZWaoAAAAAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABoaKlMTJkqKpY9PZNMTJR1dZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAANDZghIZ4AAAAAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhMQWFpcLC5EKCpIJCZIJCZELC5AMDJMyMo94eIUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0NKgNDZhxcakAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdHZwKCo4HB5EICJsHB58ICJsICJMI + CI8KCo8REZFTU4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZczM6AAAAAAAAAAAAAAAAAA + AAANDZgzM6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eMYWFpUICJEGBp0G + BqUGBqcGBqUGBqEHB5sHB5EJCYwLC5E4OI4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZgNDZgA + AAAAAAAAAAAAAAAAAAANDZg0NKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABN + TbIXF5cICJsGBqUGBqcGBqcGBqcGBqcGBqUGBp0GBpAICIsLC48xMY4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABLS68NDZdgYKoAAAAAAAAAAAAAAAANDZk0NKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB+fsgcHJoICJsGBqUGBqcGBqcGBqcGBqcGBqcGBqUGBp0GBpEICIsLC5A+PosAAAAA + AAAAAAAAAAAAAAAAAAAAAABtbboNDZdYWKoAAAAAAAAAAAAAAAANDZlSUqoAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIpoLC5QGBqEGBqcGBqcGBqcGBqcGBqcGBqcGBqUGBp0G + BpEICIsMDJFUVIsAAAAAAAAAAAAAAAAAAAAAAAAvL6INDZiAgLAAAAAAAAAAAAAAAAAODppaWqsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjI50VFZUHB5sGBqUGBqcGBqcGBqcG + BqcGBqcGBqcGBqUGBp0GBpEJCY0REZF5eYYAAAAAAAAAAAAAAAAAAAANDZgXF5oAAAAAAAAAAAAAAAAA + AAANDZlPT6YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaL8hIZkKCpIG + Bp0GBqUGBqcGBqcGBqcGBqcGBqcGBqcGBqUGBp0HB5EKCpA5OY0AAAAAAAD///8AAABhYbkNDZdFRaMA + AAAAAAAAAAAAAAAAAAANDZgxMZ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAwMKEbG5UGBpIGBqEGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqUHB5sICI8MDJNycosAAAAAAAAA + AAAkJJ4NDZeBgbEAAAAAAAAAAAAAAAAAAAAMDJYNDZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACTk9UwMKAbG5cHB5sGBqUGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqEHB5IK + CpA7O5AAAAAAAAAAAAANDZggIJ0AAAAAAAAAAAAAAAAAAAAAAAANDZUMDJRra6MAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzc8M5OaQjI50HB5sGBqEGBqUGBqcGBqcGBqcG + BqcGBqcGBqUHB5sJCZAfH5AAAAAAAABoaLkNDZhZWaoAAAAAAAAAAAAAAAAAAAAAAAAaGpwMDJNDQ58A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdXbdERKg0NKINDZUG + Bp0GBqUGBqcGBqcGBqcGBqcGBqcGBp8ICJATE5YAAAAAAAA5OagNDZkAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAMDJYNDZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABkZLtPT6xFRaclJZ4KCpwGBqEGBqUGBqcGBqcGBqcGBp8ODpMnJ51xcZQAAAA1NaINDZgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABfX78NDZhJSagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACIiM1ZWbJUVK5LS6wsLKIbG6MVFacUFKoXF60qKq43N6c3N6N4eIQAAAAu + LpgNDZVkZJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0NKgNDZl7e6oAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqartgYLVcXLFXV7FTU7NQULdNTbhJSbVF + Ra4eHplQUIhERIs8PIcLC5A2NpEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZcoKJwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRsQoKLEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAClpdyDg8ZnZ7lj + Y7dgYLddXbZYWLQmJp0aGo8YGI4KCpIODosKCo4SEo97e3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe + HpYNDZVhYaIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABgYMgODqM+PrMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTKJDQ5YICJkICJ4HB5kNDYkKCowoKIhsbIUAAAAAAAAAAAAA + AABxcaBubpxubpcjI5AMDJM7O6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbMsbG6cmJqp2dsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2drEYGJoICJ4TE6obG6kGBpQICI4KCo4Q + EI1QUIE2No8TE5MMDJMMDJIMDJELC5ELC5ENDZZlZbkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7e9EoKKwODqBHR7J5ebsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbK1XV6c8PKNXV6Z6eqUAAABmZrFeXr4zM7UG + BqUGBqEHB5sHB5IICJAKCpAJCY4JCY0KCo0LC48LC5AMDJMjI54AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAoKKoODp0ODpxCQqpwcLEAAAAAAAAAAAAAAAAAAAAAAABsbK08PKENDZgNDZcNDZcNDZcMDJYMDJQV + FZE1NZAmJpIHB6UGBqcGBqcGBqUGBqEHB58HB5kHB44KCosLC5AyMpljY7IAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABCQrINDZsNDZkNDZk+PqNqaqlxcahERKIWFpkNDZcNDZYNDZgwMKQA + AAAAAABMTLEZGZsMDJMKCpAICJIHB50GBqUGBqcGBqcGBqcGBqcHB58HB5BMTHgAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdXb4ZGZ0NDZgNDZcNDZcNDZcNDZgw + MKV5ecIAAAAAAAAAAAAAAAAAAAAAAAAAAABSUq8QEJEICJMHB6EGBqcGBqcGBqcGBqcHB58HB48QEIle + Xn8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1 + Nas/P65+fscAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8PKYYGJgJCaAGBqcGBqcGBqcG + BqcGBqEHB5IJCYwQEIsjI4oSEpMNDZknJ51XV6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERKku + LqgSEqMGBp8GBqEGBqUGBqUHB50GBpIHB48JCY8LC5ATE5EeHpgNDZkYGJxtba4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB6erNeXrJhYbdzc8UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAqKpo3N6Q8PKYfH5oGBpMGBp0GBqUGBqUGBqEHB58HB5kUFIl1dYEAAABjY7INDZkNDZkz + M6EAAAAAAAAAAAAAAACBgbBaWqs9PaQgIJ4NDZsNDZsODpwODp4mJqtxcc4AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC5AKCoxGRppISKgqKpsJCZMGBqEGBqcGBqcGBqcICJ8JCZJHR4kA + AAAAAAAAAAA0NJ4NDZcWFpk0NKANDZoNDZoNDZkNDZkNDZkODpoxMadiYrsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS7ALC5ALC5AAAACIiLpSUq44OKUTE6MGBqcGBqcG + BqcHB58JCZEmJop5eXlpaZZqapYAAABgYJsfH5oNDZoZGZw8PKtiYrp+fskAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvb9NAQLQ6Oqo2NqM0NKAyMp4xMZwxMZ0xMZ0y + Mp4yMp8zM6AzM6AzM6AzM6AyMqBDQ6QAAAAAAAAAAAAAAAAAAAAAAAA9PacMDJElJZQAAAAAAACUlMdd + XbRPT7U3N7EdHagXF6cTE6EYGJctLYgcHIcLC5ALC5AYGI1lZYcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3N7MODpwNDZkNDZcM + DJYNDZUNDZUNDZYNDZcNDZgNDZgNDZgNDZgNDZcMDJYNDZYXF5t+fq0AAAAAAAAAAAAAAAA5OaMMDJIv + L5oAAAAAAAAAAAAuLqBgYLVaWrNNTa5BQao1NagpKaAPD5IHB5AHB5AICI8KCo4QEI5mZooAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB4eMh1dcV0dMUAAAAAAAAAAAAAAAAAAAAAAAAAAACEhMtAQK0NDZgODppoaLEAAAAA + AAAAAAAwMJgMDJNSUp8AAAAAAAB+fscMDJRQUJ9sbLJmZrdaWrFLS64qKp4HB58HB58GBp8HB5sHB5EJ + CY4eHo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA1NasODpo4OKV2dqt1dZ4cHJEMDJNqaqsAAAAAAAB0dMYNDZeBgawAAAAAAACSkr0pKZMICJ8HB6cG + BqcGBqcGBqUHB5sICI4LC48/P44AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABfX8ANDZkMDJQLC5ELC5ANDZcAAAAAAAAAAAB5ecwNDZl6erEAAAAAAABQ + UKgJCZEHB58GBqcGBqcGBqcGBqcGBqEGBpMJCYwQEI9+fn4AAAAAAABwcLwkJKgYGKMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbG50NDZUNDZdgYLoAAAAAAAAAAAAAAAAN + DZs3N6YAAAAAAAAWFpkLC5IHB58GBqcGBqcGBqcGBqcGBqUGBpsICI4KCo1NTYdQUJ4YGKIkJKd5ecMx + MakZGaMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABDQ7IODpoAAAAAAAA9PaYxMaEeHqMSEqUKCqYGBqcGBqcGBqcGBp8GBo8JCYsMDJIX + F5xmZrsAAAAAAAAAAAAaGqFmZroAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODpo3N6IAAABqarFDQ6g8PKU5Oac1Na4rK7IjI7EeHq0W + FqEbG5YeHpU+PpwAAAAAAAAAAAAAAAAAAAB6es0ODp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQa8NDZmAgKwAAABgYLVRUa1LS6lH + R6tERLI/P7Q7O684OKU1NaA1NaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp9aWrYAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZlISKYA + AAAAAACEhMlfX7VaWrFUVLBRUa9OTqxMTKpKSqxtbbgAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsAaGqEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAANDZk0NKMAAAAAAAAAAAAAAAB6esFoaLdkZLRhYbRgYLV/f8IAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAODp9pab0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAANDZpISKkAAAAAAAAAAAAAAAAAAAAAAAAjI55zc7IAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABFRbsbG6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxccMODppycrQAAAAAAAAAAAAAAAAAAAA7O6oiIqEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fdkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS7QODpwAAAAAAAAAAAAAAAAAAAAA + AAAODp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJqY4OKkAAAAA + AAAAAAAAAAAAAAAmJqc3N6cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODp9ubroAAAAAAAAAAAAAAAAAAAAODp0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAODqAAAAAAAAAAAAAAAAAAAAAAAAAbG6NJSbEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlZcIwMKwAAAAAAAAAAAAAAAAAAAAAAAAAAAApKaoODp5RUbQA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJqp1dcIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB7e88ODp4ODp5OTrEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGqcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsEODp4aGqN0dMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABubs9b + W8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsQODqeEhNcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA5Ob8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////// + ////////////9//////////z//////////P/////////+f/////////5//////////j//////////P9/ + ///////8/z////////5/P////////n8////////+Pz/////8D/8/P/////AD/x8/////8AH/nz/////g + AP+fP////+AAf48/////4AA/jz/////wAB+PP/////AAD58/////8AANHz/////4AAcfP/////gABz8f + /////AAGPx/////+AAZ/n/////8AAn+P/////4ACP8f/////4AA/5///P//wAB/j//+P///gDwP//+H/ + /+AAA///+D/8EAAP////B+AAAD/////AAYAB//////AH8AD//////j/4AAf///////wAAf/D/////AAQ + 8AP////8ABwAP/////iAAgP//AAB+MAA///+AAB44AB////j+DjAAH//////AMYAP/////+BxgAY//// + /+HmAAB//////+YABz//////8gAfP//////xAD+f//////mAP5//////+eB/z//////5+f/P//////Hz + /+//////8/f////////z5/////////Pv////////9+f////////n8f///////+f4f///////7/4f//// + ///P/4///////9///////////////ygAAAAwAAAAYAAAAAEAGAAAAAAAABsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7FlZXoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAByctIxMYgA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAASEqdjY3UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPT8c1NX4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAASEp5tbXUAAAAAAAAAAAAAAAAAAACCgsJfX3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKLg8PHMAAAAAAAAAAAAAAAAAAABSUr4x + MXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/ + f9YaGpB2dnkAAAAAAAAAAAAAAABGRr0jI3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODqVISGwAAAAAAAAAAAAAAAA9PbofH30AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAB7e5I7O28tLWkyMmBISF5ycnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCQsUjI4AAAAAA + AAAAAAAAAAA4OLkgIH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSUqMODpAPD4sQEIgSEn8WFnAhIWFISFoAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAQEJlYWGoAAAAAAAAAAAA2NrsjI30AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATE7AHB6YH + B6IICKAJCZwNDZETE38YGGg1NVh3d3cAAAAAAAAAAAAAAAAAAAAAAAAUFKwxMW4AAAAAAAAAAAArK74o + KHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAREbsFBa4GBqcGBqYGBqYHB6MKCpoREYcYGGwxMVd3d3gAAAAAAAAAAAAA + AAAAAABVVcQXF4QAAAAAAAAAAAAsLL0vL3YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFsAFBbEGBqgFBaYFBaYGBqYG + BqQKCpwQEIkYGGw3N1cAAAAAAAAAAAAAAAAAAABiYr0ZGYYAAAAAAAAAAAAsLL00NHQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAdHcYICLcFBasFBacFBaYFBaYGBqYGBqUKCpwREYUZGWZLS1oAAAAAAAAAAAAAAAAbG6A3N3kA + AAAAAAAAAAAsLLwyMnMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaN4TE8AFBbEGBqgGBqcGBqcGBqcGBqYGBqQLC5gU + FH0hIWBxcXMAAAAAAAAAAAAODpVvb4YAAAAAAAAAAAAwML0mJnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcsN + DbwFBa4FBagFBaYGBqcFBaYGBqYHB6IODpAXF25CQlsAAAAAAABLS7YZGYkAAAAAAAAAAAAAAAA4OL4Y + GIN4eHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8kQELoFBa0FBagGBqcFBaYFBaYGBqUKCpsTE34lJWAAAAAA + AAAPD6RDQ3wAAAAAAAAAAAAAAABNTc4QEJhPT2YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHh+U1NcwcHL4GBq4F + BakGBqcGBqcGBqYICKEPD4sbG297e38AAAANDZpubn4AAAAAAAAAAAAAAAAAAAATE7EqKnsAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACQkOdERNA0NMYVFbYGBqwFBagGBqcHB6QVFZUsLIBvb3UAAAAQEI1jY28AAAAA + AAAAAAAAAAAAAAAAAAAQEKFXV24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABaWtdNTc9CQsgyMr8tLbsz + M7o8PLE2NpFRUWhoaHwTE3xDQ18AAAAAAAAAAAAAAAAAAAAAAABYWMIjI4F3d3gAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbW7deXokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAChoehpadlXV9FTU81PT8pBQb8XF50bG4IREYISEnoqKl5/f38AAAAAAAAAAAAAAAAA + AAAAAAASEodAQGIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUMUqKqFg + YIoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7IICKcK + Cp8UFIoXF202NlhtbXAAAAB3d4VaWnFSUnFGRnIQEIgyMnwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlZcogIKpDQ4pqan8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABxcX55eX4AAAA8PK4kJLAgIK8KCp0PD4kUFHUiImYZGXUREYIPD4oMDJUKCpoZGZ0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8fNMdHbMe + Hpc8PHlcXHAAAAAAAAAAAAAAAAAAAABUVH0iIoQPD5EODpUNDZgbG4kyMoEkJJQGBqYGBqUJCZ8LC5cM + DJEMDI0KCo4aGp1KSrQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLr4ODqIcHIo2NnBHR24rK34QEJIMDJswMKmCgsYAAABp + adEiIsAFBbIEBK4FBa0GBqgGBqYHB6QICJ4NDYVLS2MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTMoL + C60LC6YjI6pwcMAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEsEEBLUFBasFBacGBqYICJ8PD4gcHGpOTl9a + Wm1UVGxnZ3MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f94e + HrwODrAGBqkGBqgHB6MLC5YQEIQSEngTE3MWFn4TE4wtLXxkZG8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAB9fYhnZ3tgYH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGrQqKrQWFrIFBbAGBqoHB6MJCZ0MDJIYGHVubnYAAAArK6QX + F4xFRWx4eHsAAABqan9NTXc0NHkfH4YTE5MPD5omJqdlZbUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZtAGBqQ7O4VLS7UgIL8G + BrEGBqgGBqQLC5cSEntMTGMAAAAAAABAQIIREZATE5EPD5gNDZ4ODqU1NbZmZsgAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAB4eJ5MTHdFRW9AQHA/P24/P24/P24/P24/P29DQ2tFRWtLS2tnZ3AAAAAA + AAAAAAAAAAA4OMELC5lubn8AAABiYtE0NMEYGLIMDKsODp4aGoU5OWQxMW4fH3NAQGFlZXV1daIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS8kUFLULC6gLC6UMDKMMDKIM + DKMMDKMMDKMMDKMNDaIPD5sXF4pNTWsAAAAAAAAAAAAvL7AQEI0AAAAAAAB3d81GRsJISME4OMErK7ck + JKITE4UODokQEIYTE3Y3N10AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZWcgREaJAQHp4eHoAAAAgII4W + FoEAAAAAAABDQ8MqKox4eKVnZ9FOTsAbG6sICKMICKEKCpoREYYYGGlMTFwAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAeHrYWFpkmJoEQEI0wMH4AAAAAAAA6OsY4OHkAAAAAAAAtLakFBasGBqgGBqYHB6QL + C5gUFHslJV5+fn4AAAAAAABcXIZUVHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRdAHB7YQEKkAAAAAAAAAAABpadEd + HZB7e30AAAAICLQFBa8GBqgFBaYGBqYICKEODo4WFm9KSl9ERHohIZ1vb7QkJKhjY34AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDapKSnB1dZAoKL4fH70VFbANDaoHB6cGBqUKCpoREYUVFYBi + Yp8AAAAAAAAAAAAjI5cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfX9AcHJJ8fIBWVrI6 + Oso2NsQyMrsuLrYpKbInJ6ooKJh7e5AAAAAAAAAAAAAAAAAyMr1SUnoAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAQEKVRUXAAAAB7e9NMTNFISMpERMNBQbs/P7FRUaAAAAAAAAAAAAAAAAAAAAAA + AAAjI5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH6pISHcAAAAAAAAAAACAgNpYWMZY + WLh/f7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7ZhYYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODp1tbYMAAAAAAAAAAAAAAAAUFKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfX7IAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEpcAAAAAAAAAAAAAAABPT6RKSokAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5ec8uLoYAAAAAAAAA + AAAAAAAUFJkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABFRbxfX4UAAAAAAAAAAABiYtM5OZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGaYAAAAAAAAAAAAAAAAAAAA1NcMxMZNj + Y3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2 + No8AAAAAAAAAAAAAAAAAAAAAAACCgtgYGK8tLYtiYncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABlZbp+fpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtbdMXF6w/P4sA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9PbUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///////8AAP//+f///wAA///5////AAD///z///8AAP///P///wAA///+fP// + AAD///58//8AAP///jz//wAA////PP//AAD/wP88//8AAP+Af5z//wAA/4AfnP//AAD/gA+c//8AAP+A + D5z//wAA/4AHnP//AAD/gAOc//8AAP/AAzx//wAA/+ADPH//AAD/4AE+f/8AAP/wAT8//wAA//wAPx// + AAA//gAfn/8AAI//+Agf/wAA4f/IAD//AAD4PgAA//8AAP8AIAP//wAA/8H8AD//AAD///wAD/EAAP// + /gBCAQAA///8AGAfAAD4ADxAA/8AAPgAHMAH/wAA//+EwAP/AAD//+DMAZ8AAP//8cQADwAA////4ADv + AAD////gAecAAP////ID9wAA////84fzAAD////z3/sAAP////ef/wAA////57//AAD////nP/8AAP// + /++P/wAA////78P/AAD////P8f8AAP///9///wAA////////AAAoAAAAIAAAAEAAAAABABgAAAAAAAAM + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCzAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWlq+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAPT22AAAAAAAAAAAATU27AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT22AAAAAAAAAAAAPT22AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGC7Hx+rEhKo + UFC1AAAAAAAAAAAAAAAAAAAAAAAAWVm+AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjIzIBganBganBganBganBganhobCAAAAAAAAAAAAAAAABgan + AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + iorFBganBganBganBganBganBganhobCAAAAAAAAAAAAPDy1AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABganBganBganBganBganBganBgan + AAAAAAAAAAAAFBSqAAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAXV24BganBganBganBganBganBganQkKwAAAAf3/GWVm9AAAAAAAAPDy1gYHH + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyutBgan + BganBganBganBganBganAAAAOjqzAAAAAAAAAAAAdHTFPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyutBganBganBganBganBgankZG5NzevAAAA + AAAAAAAAAAAAPDy0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAg4O/Hh6pBganBganBganMjKqERGodna8AAAAAAAAAAAAAAAAISGtAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXV3Ba2vFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + goK0BganBganERGoc3O5eHi+bW2+YWG8BganAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAeHjIPj63aGjCAAAAAAAAAAAAAAAAVVW5ExOqLCyuQECvJiaoBganBganBganBganNjavXl65 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALy+xIiKuFBSq + Skq5AAAAAAAAAAAAXFy4BganBganBganBganJiaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZWW1BganBgan + BganBganBganKSmrLCyvf3/FAAAAAAAAAAAAAAAAAAAAh4fNfHzLAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFC1KCiqEBCnBganBganBganSEitAAAAW1u3ICCsOzuz + FBSqLy+xWVm+AAAAAAAAAAAAAAAAAAAAAAAAAAAAXV3BPj63PT21PDy1PDy1PDy1PDy1PT21AAAAAAAA + AAAAOTmxZ2e4nJy7BganBganBganGxunHBynNDSsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT21cnLCAAAAOjqzk5PFAAAANTWtR0etJSWnEBCm + BganBganNTWtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAgYHHBganExOqAAAAAAAAOTmxAAAAEBCnBganBganBganBganhYXAgIDGPz+3AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + OzuzAAAAERGoBganBganBganBganLCyuAAAAAAAATU27AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU1O4AAAAERGoBganBganBganAAAA + AAAAAAAAAAAAeXnKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAPDy0AAAAAAAAW1u2ODiwAAAAAAAAAAAAAAAAAAAAT0+9AAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGjCAAAAAAAA + SEi3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeHjIAAAAAAAAAAAAZ2fCAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + TU28AAAAAAAAAAAAWlq/aGjCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPz+3e3vL + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////////////7////+/////3f///93//4f + t//8B7f//AO3//4Dt//+ATP//wFz//+Ae///wD3/z/wB//HgA//+HA////4A+f/+AgfwDgD///JAf//4 + 0A///9A3///oe///7Pv//+3////d////3P////8///////////8oAAAAEAAAACAAAAABABgAAAAAAAAD + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAeXmRAAAAW1uRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT2THBx6Wlpy + AAAAAAAAV1ekAAAAVVWRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwu0BgamDAyVTExsAAAAdXW/AAAA + XFySAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWHYBwerBgamEBCIAAAAYGCZAAAAQkKNAAAAAAAAAAAA + AAAAAAAAAAAAgoLJAAAAAAAAZmbXGxu0GBimX1+CaWmIAAAAAAAAgoLJAAAAAAAAAAAAAAAAAAAAAAAA + goLJAAAAAAAAAAAAdnagGxugIyNyfn6QYWGNamqTAAAAAAAAAAAAAAAAAAAAAAAAAAAAUlKWXV2ScXG5 + fHzOIiKwBwekFBSEenqaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHR2rCAih + ISF1V1eIbGyLa2uVbm6mAAAAAAAAAAAAZGS2WlqtY2OzWFikAAAAXFykAAAAPT2zIyOaGRl+d3ePAAAA + goLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoLJbGy4AAAAa2uTEhKvCAikJSVzAAAAenqZAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAZWWthoa/SEjBfX2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAdnauAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + goLJbW2qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA//8AAP7/AAD/XwAA418AAOFfAADhXwAAsG8AANwPAADgHwAA/wEAAMKFAAD8hQAA/4cAAP+/ + AAD/zwAA//8AAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAIABJREFUeJzsvWe0HNd1 + JvrtU1XdfQMuLiJJMOAyCiRNEhQpUhITJIuyRHFI2JQt2ZoRMbZH4zDrkeuNxpb9bJOzbI2X7PGS9GRL + shwo28p6HjGIpChRBDMYACIwIud8cUPnrnDO+3FqV+2q7otwcUEE9l6rVufuqur6vp33AbrSla50pStd + 6UpXutKVrnSlK11pl1U9PfdtKBaXAKAOW1e60pVTVdaWSnc91dtrnuzrM1s8790AXABevLkAHHSJ4KQT + dbx3oCsnvgy77sJ9St1rAGgAWwqF+wAUAfQAKAEooEsCJ6V0CaArhxTPmFENDBoABkBAdPlPi8XfBDAt + 3vpgicCDvaa6JHCSSJcAunJImR5FW/uM+Re2ADSA0PP+EMAggBkApgPoh7UKXJzCBDDqukN7PG/h8d6P + qZIuAXTlsGRWGH5Zw1oAGoAmOvMrhcKnAMwGMBPAAKxLUMAp6ArUlRpc3tv7pRd6eja/UiqtfHhgwDw+ + bdpTq0qlO9A5FnJSHP9JsZNdOSHEebK3d2mL6IaICBERmsC+X61UfgdAA8AYgAMARgFUAfiwXHFSS12p + wbXF4t37HeeukGgwIrIkGN8aIri12o23BcGrAKJ4C+Nb5swTVroWQFcOV8iLom9zHEADUERz/59i8RZY + V2AQNh5wSlgBdaUGV/X03PtsT8/m3Y5zT4to0CdCAMAnQhBvIVB+VmvAHv8ATrJ4SJcAunK4Yq5rtb6t + gTLHAQyAC4rFj8D6/wOwBNALGws4KQlg1HWHXurp+eYzPT2juxznnpZSg75S8InsphSC+HFAhD2t1pf/ + KooiAHMBzELqCnk4Cc6Bc7x3oCsnjRAA507XPStS6ipNBE0Eh2igFEVb1mg9Amv6+gBaSM3gE9oEZhl1 + 3aE7isUvbfK8+2pEC0PW8LwpZbfY/QmJqpuaza/9YaOxHBb0vbCgNziJ3IAuAXTlSIRuJxp1Xfc/6xgI + mgj9jkM/9f3XYC92JgAfFgQnNADqSg3+WrH4uQ2ue19VqfdGRAhisAe88XPxbRPY/Mj4+N9+3fe3w2ZA + +mDBD9hj5uMP4scn7PG7x3sHunJSif54EKx8qFB4HcClBBsEO811r5lP9KOtxrRg3YAKgBpSS4BDByeM + 1JUaXF8o3P28Uja4B7BmT27lfQ787Wi17v/zavUJWI0/B9YyasEeXw0ngdkvpWsBdOVIhT7tONMCpT7I + kXANYA5Qey4MtyHVgNIKiI7f7maFNf46z/tumegjIVEpiE38vMYPhNk/bszafxsb+7vvtVpbkWr9AizY + AwB12OxHOb5twJ6DE9oN6loAXTkSMQCivUHw4HTX/Qup5i4oFm9As/kUrGbsj29rAJo4QUhgbbG45CXH + uacFDEVCu0eABTpiK0ApRPHzTWB4Za32wL82m5tgg3szYBWngQV+ExbwFaSWTzN+7YQGP3ASmSpdOWHE + AVB8oK/vpUCpSzlQponwcK329R/YfPg+ALsA7AEwAqsdAxwnMGwrFBZtct37fGCIzfrIpvAyZn4kSMAH + 6huazce+UqsthwU+VzkCqZVTAzAOe4wjsHUQY/FzDVgL6IQmga4F0JUjFVsJrPXDIdGlBIDI6pErisWr + fxAE62C1fx9S4MhYwNsmo6479Ibn3fcW0SIOWIYdgC/9fR+ob2+1nvpOrbZ8lzEEm9/3YJVliNTcr8AC + fTTeGPgVpBbACR0ABboE0JUjF+v2h+ED5Dh/oACQsdf4HMe59Gxg2nar/SQBeEgtgGMOiIZSg+sKhbtX + KHVPJqAHtAX3+H4rBf5Lu4xxYIt5XNhaGc5uNJCa+2NiY+DXYcmOzf8TvhKy6wJ0ZTKiAJTu7+9/KwDO + DuPAWUSEF5vNH3692XwOwDCAHQB2w5rGXB58TAlgR6GwaIPr3ucTDUVAsl+dNH7IGt/3n/x2tfryLmMU + UsJi4LOfz1q/jBT04/Fx1ZCa/CdV/UPXAujKZMQACAvGPBsR/ToZk7gBFxaLV6HZfBlW+0sr4JgGAxtK + Db5VKNz7lk3rdQR7CCQBPt+Y+jbfX/rtavWlnVbjc/UeA58zGTK6X0Y78KXWl0WSJ4V0CaArkxEDQBei + 6Omm6/46AVDGgAAMKnXeVUrNWaF1E5YAuDTYQ9ogNKUA2ee6C5d73n3NuIKPwc/pPGn6+0S17b7/xL9l + gV+ABb5BFvg1WNCzv88pPk7zsa9/whc8TSRdAujKZEWv9/37z3CcrykSnqQxuK5YvHRFo7EPFvy9SJtj + HEyxeby+WFzymlL3tWl7zudzcI+otrPVevyb1eoLO+x1z5YJA58rGBn4bO7zJk39JtIIPx/PSQd+oEsA + XZm8mN/VeuQhYFtozDmKKLGdzy0U3o1G41m0uwENWI05JbKmWPzSdqXukuY+F/KwBeAT1Xb5/mP/XK0u + 226v9z6kzUoyl99AO/AryAJflviedOZ+J+kSQFcmKwaAcY151if6Dc4EEBH6lTp9oVJzVmXdALYCpsQN + WFUs3ndAqSVagl9svlLV3b7/yD/Was9uMaaAlIj4mg9gAX0kwD8pGnyORLoE0JWjEV3S+ummUr9BsLZ0 + ZAxAhI/29LxvVa0m3YAirK/NwcBJA+jVYvGLB4iW6PiLpL8fEGFE6599eXz8B5ss8LlTj8t2uWPxHQ18 + li4BdOVoRCMIlpLjJJMviAhkDE73vAUAHoXVur1orwmYVI58l+ctWk90N3cjckVfBKBpzPqf1mp/+50w + HEc6oKSENPYQIAt8Bv87DvgsXQLoylHJB6Joy0PAtgg4hxAXBRGhRDS4yHHOfDKK6shmA7i4hjAJUO1U + 6h5uQErmb9nxZOuXlMt/ADuUYzbSZh3AArqJrsZvk+5EoK4cjRgA2jXmWRiTWgFxPGBBsXguLOhlNoDX + EJhUEVpENKiJMgSgAURKzRsimo90Kk8xfqkOW6q7F7Y/YWe87Y6fG4Yt7OlUyXdKgx/oEkBXjl5MUevV + XBKcrBVmDM4rFC6HBbx0A5gAJnXt9RnzL/FUYkg3gIC+m4vF62DBX4IFL4N/Hyzgd8KSwDse+CxdAujK + 0Yru1XolAz+ZgkmEfqLTLldqFiwg83GASQ3MnB0E32QXgJPvbAVcUip9OP4tgjXlK7BlyHthOxP3oQv8 + jHQJoCtHLe/1/aeIXYDYCkDsBlxbKi1AuowYLyXGM/SPmADO0LpcAL4lpxMjvl8imv7Jnp7LkFb0VZF2 + 7I2gC/w26RJAV45WbD0A8GriAoh4wHmFwmXIugEyDjCp66/m+59PSu+IYIyx943BlaXSe5EaBpzuq8e3 + HOh7xwOfpUsAXZkK0UVjnk56AoxJLIBpSs29LHUD2ALIZwOOSG6Joq1kzPcBwLDFEUsv0cCvWyuAvRK5 + otk7IrJ/JNIlgK5Mheii1qsZiDIQSACuKZXehZQAZHPQZAZoGgDm4Wbzjw1QTn7TmIR8riiVrou/v5D7 + rZNqYOfbIV0C6MqUSEHrVQxAOSTEADjN8+bDgnCq3IDoq8Yc0Fr/Mwce2ZRQxqAPmP7bvb03Ip1MlG9I + 6pJALF0C6MpUiLk2CFYlWQCRDoQxOM11zz+diJcNk9mAybgBbNIHH280vgBjdqlY+zvxpozBpYXCorOI + 5qB9xaJJxx5ORemeiK5MlRgXeFZxU5DYYAzeWygMIZsN4N6AyWhkbgNoDQfBZxUAN0cCRaB4R2/vIqTL + lvUjO/SjawWgSwBdmTrRnjGrgdQk50AgAJxfLF4IC3iuCThakzwC0Po931+qtb5fan++vdjzFr1bqXNg + CaDTwp3veOmehK5MlZhSXBGo4ixAUhoMYJbrnoWUADgbUMDkNDK7ASGA5vcbjT8joOLCWgKSDBb39S1G + SgDsCpz0qxdPlXQJoCtTJlwRCIhYQGwF9BANXJKmA3ljn3wyK1Qluf77jdnbCsO/dbVOwM8EcAbRgl/2 + vMthV/PhFX3kxN93NAl0CaArUyXmqiBYLcuB88i6uqdHugH5OMBkrsVkau+nW62vamNWuMakVoDWUABu + LJVuQ2oF8HwAJp+TngBGXXdoR6GwqKHU4JF+tksAXZlK0a4xz8oaALYE4nTgWbAmvySASZcFI3UFfACN + LUFwLxOAG7sgSmtMB07/TLF4A1IrgDMSJ21AcHVPzxef6Oszj/f3m5dLpc2vFYtLN3jeVbDHxBsT64TH + 1yWArkylGA/YIkuBORBIAGY6zpmwF2YRqRsg6wEmA8QkI/C5MFwRav2AozUUb1wc5Hk3n0M0FykB8GzA + k84K2Od5Cw8Q3c3rF/JMxGHH+UXY45JzGA96brsE0JWpFFM0ZrWcCyDrcT2geK3rzkPqBkgCmOxK1Rkr + 4JUg+GsCKg5bAfHWa8zgJ0qlm5FaAZwWPOkCgptc94vJTAQxE7FsCW4w3vKuTkesdwmgK1MqvVqvAnLF + QEgrAy8sFs9GOwFIc3UykgQEv6D1ulYU/UuSiTAGpDXIGFyg1PvPSq0ATgueVMVB2wuFRVWiRYnmR7rm + wbi1hObCTkSagXQ2woSuzklx0F05acRc7ftPTdQTQABO9zx2AyQJcBzgaAiAA4Ktt6Lo29wbAB03DBuD + gjGlT5dKt8ACQ8YCeGGQE94K2Oa698hFTnkQqg9U/1e9vhTAmQDmwRLBdFgrYMK6h+5MwK5MtRgXeDYA + ru+UDRhQajaycYB8JmBSswLjz0TLFy26IOzru6UVBMMolWbz2DB4Hpy+PpwxOvq+i7WeuXdkZM1rO3c+ + 9s1t215AOgeQLYkTsltwR6Gw6E1gEa9+FLAFAGAkipa/Zcw0WEz7sOeYlzCfMM7RJYCuTLWYgjGrG0TX + cx0AEUEZAw2g1/YEuEhJQGYCJmUBjN9yy6UjM2b8341i8RcDovnKGDgAdPybId83BoWZMzHPmHedOWvW + u9594YW/+infHw2q1edbw8P/8MsvvPBzZNctkPNGjrtscZx7OPCXLH6iFEIifLtcfhx2HqJCumQZL4DS + KSsLoEsAXZl6sa3BKsWyvPLIGHzA885eGgQVpASQjwMc1gKiu2677XOVYvG/7Jo27TxtDCKtoXkWgZhJ + IEuSjTF2I4Kx7sGMwrRpHyv193/sZ6ed9jqGh79w83PPPQAkylWuAHTciGDUdYdeVmoRz0DkacgBEfaF + 4fMvaG1gXRsmrnxgs+O+dwmgK1MvUfQkuW42BmAHdwIAepXiSjzu15eZgIP64bVarVD+rd/6HxWl7ip7 + 3hytNUwQQDP4geSWSSD5QkEKOh5fbuLnIgDkupfSaaf9609uvvlHP1+79k/+etu23bCalCcIMTG97USw + 3vPukSm/UCyB9vNabRnSgGaA1JWR+91xn7tBwK5MtZgbw3ALkLU75bSg0113DizY2Q2QLsCEBLD7Yx/7 + g12/+Zvby677F5pojvZ96CCwWxjCRBFMGAJhCASB3cIQFAQg8djE9/nzURhChyGiIEAYhkBPzy8vWrDg + kc+fe+7VyLYSH5fCobpSg2Wixfmof0iEca3X/TSKxpFd+YgXP+ERaGzJtEnXAujKlMtrxeIN68TjTEEQ + EVa3Wlthrz3e8hN7MoHA0Q9/+KaRmTO/UlbqMqM1dBAkcwA1m/Rig5gRmEhcFgz+4piMNFKLQapIct35 + l1100QP/3fc/8Tc7d76GdK6gXBz0bbEE1hcKdwVEg4n5z6shEWFZtfozpKsfhUgXQJEEMOH+dgmgK1Mu + e5T6s8wTHAgE0NK6tTwMR2A1qYPU9Gf/P2OVbr3llq/unTbtd6E1dBQlIGdfPwGv1qlvnyMBfpyQUAx8 + ADZNSGSJBHa9AZMGL3uuvfDCr36gUvntpeUyk1Yt/iSvHnTMSeCAUkuiXOFPRIQGcODffX8PrO8PWKDX + Yachy+nHXQugK2+PbC4UFr1BdJN8TsYBNofhW7mPdOwfGlu06JJ9s2Z9twZcjjBMAK6BBNQMbA0kpGBy + wI8EGZhcbMAga50kC44gHTZKwFmfOP/8zy5dufLPkXUBGkgDbseMBN4qFu/cQjQkgc+xgDfr9ceQdjZG + sNqfwc8WgI+DBFW7BNCVKZU9St2Zn9kPIAHZ443GGmQBI6PrBgB23377B3YQPYgo6suDPWPuI43qswYH + kAQEmSwkMfB9JiX5w0wwrNZ1HLic3tv7oY9On/7Qo+PjrwEZT8IgtQSOiex3nKz2R7IW4vDfNxqvw5b9 + Alntz+sd8krME5JUlwC6MmUy4rpDL8fLdhuyytzE0XYiwkgUbVurdRXpar0RUgBFAPQbN930f+015guk + tTXPBfATTa51gj5JBFpskihYo7MFIAkhiRXw/gJJXIBRQ8bgg2efveTR8fG/km/JbVNuBezxvIWr47Lf + UPj/mgg7ff8lpL6/Rlr0wwueHlL7A10C6MoUyoa4TDVBiAAVjMEzrdYyWPOZy3Z92Au3BSB84brrfqfe + 3//nKgyBKEq1tNT+QEdwS+Dzc0AK9onuS3Iw8b4bYxJTm98/p1S68rr+/kueq1aZtDgYmK8VmDLZ6rp3 + SeBz4K8F1L9Trb4Im53gZdDqSJc8ryHr+0+4X10C6MqUyG7PW/harP2ZBAxSS6BizJ6fBcEeWK0VwoKH + V+tpPvae93ya+vv/1Pg+dByEk9F6aQFI8CbAR3scgAOF+QxBJo6AbJUPWyzSHaD4u949ffp7n6tWdyFL + XFxG3DHINlkZdd2hl5Rawv6+XAh1p+8v3WkMweL3UNr/oKTUJYCuTIlscpwvyiCaXLobAFb7/grYIJpB + dsmu+lfnz39P38DAn+ogSDr4khRebO4DQtMDWY1/OMCPP4+c+6DFbRIz4EBbfF/DWiLn9PZeCeDnYt/Z + z2awTVksYKPn3RVK4APJ7eO12mrYugRCSqQy+Cf3qUsAXTm2st3zFq0lWiQvVGkF1I0Z+3artQ628457 + 9+sAqjdOm+ZcMn/+XyMME6AZY2DiFl5AmOiwoMz7+5rN9/hz0k3IBxGBNO+fcQPsDyVEQPH+RyJW0KPU + 7DNdd87OMORgWxkp4KasNqCu1OBzSi3hwB9nADQRhsPw+Ve0bsIWKBlktX8+8n/IfekSQFeOWrY5zj2s + 7WWxCoPpZd9/DrZSDUg1Vg1A9Q8vueQeaN2njZ3jF8Vaug38RFYja51YAPkYQKdiIFkDkLEGkA0m5hcO + jGDdFxOTGstHBwev/8fh4QOwAOxHSgKcijtqAlhXKNwVAoMS/EyuD1YqP0fa5MNVf6z9qzhCMuoSQFeO + SqT25x51af7H2n89rO8v/dXq54eGfqGk1DUmCADEuffIwi2T4kNq8ksLwKA9BoAcccgMgg4CmDBMQS9i + AFqAXXseyHVt9iJ+L+LXLi4Wr/2jgYHT32y17r+/1RqDrcGXQTeZ1jxiqSs1+Lzj3B1KzQ9LrAfC8LkV + WreQNv20kAb/qjiMwp+8dAmgK0clWx3ni3lNJTXW8lT75+vUy1dMn/47JgytXx4DlWKQc/uw9PsjSQiw + +f68ua/jGv+o1bKVg1EEEwTc+QcgDU7yLROADLb5SiF0HESuCxQKQLEI1/MQEmHAceZf39t717uLxetf + qtX+5sdRxATAxgJbAkdMBOuKxbsCof0lCdxvtT+n/vKFP6z9D9v8B7oE0JWjkHWFwp1biRbKAhVp/leB + sW83m+uR+v6JxvrsOefM9xxnyMR1/UnkX2tQbO7ntb8WZKCNgY4iC/RWC2GrlQD9kFc+pb08CRnEz8n9 + j4xB4PsIgwBRvQ6lFBzHji4kY9Cv1FUf6e//zk1R9E9P1Gpfe9SY7UgDc4dMweWlrtTgs0rdLZt9IoB9 + /+dWWN9/evx2H6nvf1hlv52kSwBdmbTsUepenQN/cvECeKXZ7KT9KwDK7ykWP51of9jx3ZnIPVI/PxLg + 91stRI0GIt9H5PsAcmWERyBGbDJ9qWNLQMv7cb9AFIZwiKCIEBo7/bjXcX5r8cDAJ/5DEHz+9+r1f0W2 + aUiGFg4qbxWLdwVEg2FO+wdA7YFKRTb9RPJc4ghTf1K6BNCVSUms/YfkxSrN1Row9p1mcwPsRcvmag2x + yVpy3fNkjb+Jy3d5ihBr+UhrhI0G/EYDURAgkmk8sT+He8XLz7Lm503nj0WppFSRyYFjAsm6B3GcQBnT + X3Ddv7yvv39JLQj+539rtZbGx8xa+aBuwYjrDr3gOHcHgkSDeD92+f7PllvffyLtn89EHLZ0CeAkl7pS + g7scZ3GFaFGLaKhJdIUDrA6JqBd4aiCKHrjY91cjqyiPKlAFpNpflqlypVpIhJWNxvOwef+89h8HUHG0 + Pl/H0X5jDEwU2dSb1tBaI2o0ELRaCJrNJAiWKdgR+3JEByKqEzPaH6m2l5ZMYExCagZxetCYpLw5swAK + AFLqXQOFwnf+zfN+/lajcc/no2gd2guG2s7/mmLxiwHRYECUDPqM7Idq/1Kt8sCPTtq/gsMs++14Oo70 + A105MWTMcYa2KnVvlej2CBiUc+Lz912ihyvN5uc+EYabkZqksk7niDC0uVC4faPj3O8rhRaR3ZSCTwSf + CFVg7A9HR/8VaeS/AmAYwG4AO+4eHPRunjXrMdLaLt/F0f9m0wbwms1Mak6mFI8G/BzNz5v2+Sk7vlJ2 + A+DHxMYWwG6tt/cAhXlEp3nG2PHGxqBgDLx4K5h0dSKj9b/+uNH4wneM2Yu0N1/66eb1np7F61z3R6EA + P29vNhr/+P/W6xthtb8DC/YDAHYB2AlgL4BRWCuApwEdtkx2MYauHCdpKjX4G677ua1K/ahFtDAESrIC + j0dGS1O2RXQRPO8/fsiYZT/WehSHGBR5KPmk5329RTSUXKjxYMpAKUREeKnZXPpaGFZgFaMPSwAjAPYD + OPBGobD9VwqFu0lrwPehKxWE5TJMq5Wk6eRUTgZfXo7YhCFqM/8TElAqQwBhTGZB/FpEBBDhuXr9pSfK + 5TVbfX/9tELBm0k0SwHJvAM5AQkAlFJXLPC8T9/huoP9Ybh2tT0fyXlfXywufMPzfhQSlSQBhESoGvP6 + X5TLj8CCvwDLh1VYAtgfn9MybADwiMEPdAngpJJdrrtoreM8WiVaLFW41PiZuXFZMii6hcLiuu8/uNF+ + LD8O7rAunjHHGdrmOF+SWlNOp60DY1+sVJ6ENf817MU5DnuxDgMYabVa45/0vP8RVSrQ1WoCet4JI4Da + 1ltwJDubOziZ+suAXxJATgMH4nUQYdn4+IqWMWFZ6+arzebm7b7/xoxCwZuh1JzMIigkuJWoSEpde6Hn + 3flxzzvnKmO2/lzryt8rNb3a2/vDllJD/NsyiPp4ufzV9Vo7SJt+GgDGYAlgGFbzV5CmII+YALoxgJNE + 1hQKX9oA3JVoerFlqtnYL0fqm/OFboim/crAwDceGx//DOyF4yENIAGHcRHtct3bjfze3H6sbDaXxd8L + pFV/ie8PTldVKmtgzOXceMMNNwyc5Lio3UiZDPg7+f4y4i9Jk2fuB3EQMFIKhgg7g2D7uA3G8cBNf2MU + jW8cG3vwYqWWfqS///r5jnO5VgpRfEyGbPbAAUBE0whYMr+3d8m3jXkRRP01oktl8JFTf7t9/98fDsMy + 7Ao/CvYvrcNqfHkuJ+X7s3QJ4ASXMccZest1fzQCLOSccDKwAnGhDKUtuGwVsKMZIufsK7XwM4XCL33D + 959BdsUYySMTYmw8tj6SKjwRIKsbM/bdRkNW/WUi/0jTVUHJmKebwOUM74mikkddVwsc1PTvBL5AWDZc + g08Advj+jvhrePZe0hD0ptb73yyXt1yu1JyP9ffffLbjLJRhf84gJJWFSl3LBGQgSqjtF2/+vC36mQ1r + +mtkiXQcaeHPEdcbSOkSwAksmwuFxauVui8CBjkQJf9tHryR1MojW4/PSWi+iPniP7ev7z/B99cjjQV0 + Mig6SgNYlNGi8W/DGKxstZ5Dek1NrP2BsD+Kvuw7zn9LWnzFj7LmTDoCj0LyAcO89pfgT3zwGPz8mokJ + YFOlsh0pvzbi4xqDJYEQgFqj9eiacnnHlUrNu7Wv78NnO86VTJJcWsySqTWIvzgkqn3lwIEvw/r9pfh0 + tGABPxZv+cj/pE9UlwBOUHm1WLx3k1L3MKBljT0XnMsQPg+z1IIIEgIwBlopq8mIUCS66D1KvetlWx7L + 5qxcCKMjCezxvIWvi9+Wb6obM/adZnMdrL96MO3vA9DXRdHWnzjOdwLgN/LANLBmiQGAvD+Nw187jE3/ + TtpfTtdh/1/2M0j3iQBsC4JN41oz4LibsQzri5fj41WwjTrTVmpdXVmp7LxSqZ/e1tf34bmue7EHlKJ4 + nwD7v0oyCoyp/2xs7EvbjCnBpv3c+D+pISWbTtp/0tIlgBNM6koNri4UfrQ312DD5ml+/Ixc4CJT146U + MKLYD2VzUwG4uq/vAy9XKsOIF9QU24Qz7nxgOmv9ZFGNWFNvDsM1ODztz/xELwTBH17lujcCOEsSGvfk + A5PPU+fB31bll9P8fI6TqD9/JiaArdXqxngXeRoQE8AobICzEb9eip+fBmBgpda1lZXKzjOBGbeUSldc + VCq9v0+p02WAky25N+r1hx4LQ2728ZDm/Pl3OOgnff+jMpO6BHACyXbPW/Si6/6Iy0GlJgpyoJYz7WRk + XLaz5jMEDDANYMDzzocdKJmfI88FK20kEBANJg8E+AnAGY4zBOC1+Od54MdEE2oNAHOvMWNfi6LfnKfU + vxPRNHksBEAGCI94xdC85s+diyhHAslim+z3x+8nAMNhuHddvb4PKQGw/88BubH4cQQLXB7MWUFMBDuB + 2j80m6NoNl9YqNTc95VKl84pFM517CpJeKlaffJh398F22Ism33GkZLMWPy9k47656VLACeIrC6V7l2r + 1D1y5ZdAaCcZpOLg37DW27dH0Z7tUTRe1To0POUawK8Vi78kA3UyWAgiDBCdDWtmDiCtKmOgduwnd40Z + kz6/rIQrpP5qhLTpJ08s8qI1AMLf1Xob88+HAAAgAElEQVTVN4H/NeA4fwnxAuIvIwFkGTCciBDazH6k + RJgHPqf5QiCb8ovfz6b62nJ5DbLaX7o3PIGX4wAushODJBFMA9C/Suv6qnp9D+p1uSaiXBpNxhhGYNN+ + oxBBVHQJ4NSQvZ63cK3r3reXaGEe+JIAWCvVjRl90/eXP9hobNyfzoVjbCTBvF8rFpPfYG3Kb2CtuKhY + vPDJVqsGq3X6YS+4AuwF3oaxkH+HS2Hjzj0FYIZdj54JgEFSR1oPn79o2VAJlmj93T8DRi9R6m/IklJG + OCiYzPyXz4vHHcFP7Tl/rl/gAp98Dj4x/Y3BgTDcuzbV/oE4LgY+r77DBMfDTuU5kETQD0sEfbDxkh5k + F0dF/NkqLOiHYQlgPP4euXrxUUuXAI6jrC6V7n1VqbtCYFBegIEAP1+wTWMaa5vNJ/6+Xn8d6UXDK+my + yc7BvEjBXiUOkPTZZ0ZfG4Mzi8X5aLXWwl6IvbBanBfqDCba78yCn6IW/mKl+t/UehjtQEiaYYY/9rFL + G8CCplIXtoBzA98v7x0ff/2Zfft2PbZ58903OM6f9BPN5/3M/rCYMhyLyQUJO4E/M1QzBr00+dkKkP0G + B9H+7NrIARxyEU7OqshzIEmjF5YE+pAlgSKyQz4lAXCm4YjbfQ8lXQI4DvJWsbhkt1L37BYrvrRpftEQ + sl/rV78xNvbwHmM8pE0hrJHkhNqk1txBugSWI7R/kjkgQtFxBmEB3xNvkgDalulOovJAxv/nbR7RwJu2 + RJV/KgKgf3bFFR+ftWDBYioUrtzuOHPAC3lGEXShgMGeHnx07lz4F1xwYO/IyIbhtWvHZ7dalye/iSyw + M8/nwA+IysE8+AWhdjL9k6afmNh2+P6mDtpfmv6devCT3cDBiYDPORMvEwDHUGrIFv1M6JodjXQJ4G2U + N4vFJfuVunOLGKApy2jzFoAP1F+u1X74vWZzOyzwubeeLygeq11HunhlC0Dgxr56iHT5q0hobU2EHqWm + wZqeBaQXYX6l3uRi642iVXDtJZNph43vn6vULETRRn7/N2+66VMXzJ9/R9HzZuoosrP+fR+SAIzWyX1l + zKzTBwZmzb3qKozt318e2by5MT2KTmNQAqL2IP6NZOeE6Q+0R/sz+X6R5+e4ShS7GFDKTiUi8l8eHl6O + VPtzXIOHgR5q8Y2JiKCFlEiKSJdHLyA22HK/x27UlPn9UroEcIxlS6GwaL9Si8eI7txCNBgXe7TV6yc1 + 9TFoa8CO742Ofn+N1iGsz8j/VQvpWK0Ksj3hySAKD9bMVwBCraGVgivGacEYDBDNir+3gOzFyASQkXla + jz8OjJMx04koIRa2AErGFAGo/3rRRZd9/JprPtff0zMNQYDI96G0BsULfhieA8BWQHwLrWHCENoYTJs2 + baBwySWl5du2rT5vfHyBBxRl/KJjAFBo/o7tvSLXz+TLBVacTuVjWVWprBjL5v1lWpMJ4HAq8SYiAu7s + Y8LlICDHLZnkZY3GlIIfOEEJYLvnLfKJBqvAQgOgRrQojhhRBFwepeuhtZ2RCc8QERxgtbJ/YJsUgNUF + Y8YyH4m/rmTMatf6YQAAt8PPVIhuiv85ahEN+cCQT3Tjm2hPP3WqOw+VSvzQ4Sh67Z+sye/CmohsjrNv + KEtCuSecNYUPIPJEURCfF43Ud1f2mFnrsBXAFoBcrTej3TxjVkfAjRSTi4K1AgyA+cC8r1x33UcXXnzx + RYgihK0WlNZQQYAoikBRBBWDHLFFwAQAre0sgNgq0FEER+vC5WeccfGuVqsy4PtF2RTEx9QpM9CJAPKm + fzxpJ+MWEQDSGnvCcPvK8fFNyKb9mHClSS4HgR5K+D2yHZvjCgrZlZFlZeZhTxSajBx3Atjrugv3KbW4 + TrSwCVwRAkNrO/zRE91OmAoC2irIQuCK/Pv5HQ1jbmyrOMs9zn9mot+VmqoT+Dt16/H9Ta3WE18rl1+C + 9Q9lYQ1Pf+W88CiyRTZyIGToGZNEpJKGlLgphesIQIT3F4tnPd9qVZGSAGujNgsAAFxj1hDRjawpFQDH + GFCxiKtvvnmeNzgI7ftArPF1rPFJazgM9g7gl8A3UYRIa0Rag6KoMHfWrFm1vXsTpElGkn6KJAAmAY7q + 501+VtsRxzKsgkDdmNozw8PLkDX9ZSWeNP8n65PLDKXsIKYO7wGOEfiB40QA6wuFJaNKLW4AN70ODGZ6 + vyFMOc45x3KwM3LEZygPbqIJgd3x46JOPeOfCvKSWqhtYi4/RkoOq+r1B79Xq62HNfk5kC8vQC4IGcHE + 4NcAtAeMK2OmE5DUADiwYFWURrtNqnlcWBJgC4Cfl3gzJWBVXcQSFAAqFjHrQx+CMzAAHQQZgFNMAIgi + RFEEJQggit0AHQM/iqcBhWFoR4FpjUBrC9aBAbQqlYxFA6QEoMR/KsmXYy1BDvxJg5TWQGwRBVr7z4yP + PzVmTL7kl4mXS3HlFOCjBecxB/nB5G0jgHHHGdrieXeXgTt3EA3KTrLMRu3lm1ISEhCvHQkZSG3R6bWJ + JF98QuJiS78gbfrIlORSe9WZLDjxgebDo6Pff9G2f3IenCvByrAXHheEyIowGYXOmIolYHUTuBFAov1d + YxDE97k46DTPm41WiwtR5CbnWySijFktwe/OmIGZH/oQjOPABAF0GALxsM82IohJgH191vhRTAJRTAIh + b1GEABa8UW8vAt+H7/uZwiB2QQhiuIU8/+I/aCulZs0fp0lfajZXbG61RpH66ez3j8GSL5/3YxaUe7vl + mBNAQ6nBtYXCl1YR3ZkpU1Uq4+BEOTLoRABsL+WDQJ3uT2Tqy/umw2v8+GCkkrHTcpaEJDGp/WV9vpxB + X9Z63/0jI4+ssyOfS/FPsclfRgr8YaSaX0agOwahHGPgxPvhxhkAJoEodg8MEQrW71dIYwEcjJJTg5Lv + vjKKVj/uuuMETC/MmIHBD3wAAOyE3hjoiM15Br+JXQHkn4sJQMfmfhjfBlGEMJ7Fx2PGIgAYHIQ/OmpJ + ROycA0sCkrGSNCDSa0s63waAirMJBOC5VmvZ8kplE1LfnGfuM/hHkU7fkWsAnNRyzAngtWLxRyKIl/rD + QIaZ5fP8XvbjWCbS/BORwcGkE+iT7yCxIkxs6h8suChjDhKJbfP54ls2Tze3Wqu/OTb2IiwAuflDmvw8 + RYc1v+wEkxqobfccWOAzEXFbGWs71pYDjsPuBpOAKx53Moq0Czyjpk+/dfpNN9nv932r4a3PbiP6QvvL + rY0AcuCPtLaBUTmWKz7YgAj+tGl+WC4XeMd4p2UUTV4nMpLGG2DBDwAwBi8HwYqXLfhl0I/NflmKy8G/ + o+rBP5HkmBPANGPur8Z57yT0KZg5zD1mDZmxBOLvkr52p1tM8FjKhGZ+hxhA3uy3T6aPkr51pBonuS+O + g1tA2SKoG1N5pVx+4fFGYwfSgQ9caMJaJw9+uRClHDPdURRgElAYu9KOw2a7CBBOs1VpEvzSBegUCDSl + 3t7nCjfeeKs2Jgn4JdqdU30c5Ov0PAM/tgwirRHx9F1hMcliHR/2+tin1PhupcoXGXM+/wdufIxssigg + s/R3YpXFxy/duKeazWUv1moMfvkfjMfnnsFfxhT14J9IcswJYDAIHthZKn0pM0IayKRjkucFEWSCaOL7 + ZKQ9/9xEj6VMRAD58GsnMrBv7EwUQEoAMg4gXRlDhE2t1huPjo+vPmBMgGx6T/qbEvx50/OwtI8MjiX3 + Y5AoY+wfbwwGsgQgm1LkR5Pf2r9o0ZxdAwOfiYwBeK09kcLjIh8t8/yxzx9Vq4iaTeggSGb8J/+x60Ir + BVMsQhcKaR+EUml9MxFOK5XmfGPz5p98Ytas/jOA03hWlhMD3BE7KwuGOGjLfRGB1v4Tvr9sZb2+A50J + mN2uA0hLcZs4hcAPvA0EcHoUbX0tDO8YUerqClAMHeeGBpHXNMZrAZ4POH2Oc36YIwip/WVkHWgH3EFT + gbEcToQ/854JptHkYwFGEIIBEBjjjxkzYsTnR6No1DfGX16pbNykdRXpoXFlGEeaJfg52Jfv/z4s01PJ + Wn0iawUg9pVFDr+fqB8io4d2FyA5LaOLFl2yva/vQQ2cq+PcPi/uwYDXWkPHJBD5PvzxcQSVCsJqNdk3 + +Z8mcZIgsBZhs2krIT0PUU8PdE8PQs/LxE+Gpk+f9cjo6NIbBwevvkipC3gJMSKb7kzKkyktV5bW3G6t + 9z5WrS7bGYZVZM1+WX+/H+ngzSkZv3UiytuSBfiFVuvHAJbCjjn6LoDTAMyBHXg4gLS5hbWPjELTLKLi + As+babiqdYLfmcy/ciSpPwBY5vt7D/JzExkjJrfJQFNe848gm+PPt38e1mEWbRbgJkA07yC1AiIOEhqD + K113zkqbgZBuQGZ0+N4PfOCGrf39jxqt+7TvZ/x6LQggiiKE1Spa+/ejVS5nDlqelCTOg/ZAcEiEIIrg + 1+toNhoIi0VQqQSnpweGCCXXLVS0bj48MvLk/mnTtr+vUHh/CSgmtQlMAtICAFAFai/7/pqn63U2+Ttq + /gVEtVsKhbPf5Tg392i9YiawdwYQuEGw8tooGp3gPz4p5XjUAeQLHpiBAXstZFK7AOiAMdXnfP9A7nP5 + 7zke0skwyd/X4pY1f76zjHP8HHHOL/d0xGanA4zJnn3AakTSGorINgjFmvNspWavBLYgSwCJFbD7xhuv + 39nT8yiCoE9qeeTA75fLaO7Zg7Bez4y7aiMAytVKIFstyZZBYhVy+q9eR7G/H07KG8FLlcrqjUqtuaa/ + /xcudJzLZgBzlbACAGBbFG3fEIY7ljYaEviybbkKYPzDrtt/U6n06zOJrikY0+/CWkxsgjlK4UcAPGCN + a8x4yZinS8CWojFbrmy1nhL/8UThqRNO3k4CkBc+d0W5sH8Et7ZKszMhgNwtxHs6vfZ2SCfNfrDX8rVO + 3MHHzSX5sl65uOSkTM6iMau5Y4/jFqz9ndhU5i89nWg20mIgGQtQr7/vfdfv7O19EEHQl6T2tE4Kfvh+ + c88etEZGsjGPg5wgGalP3AG0Z4P4+wiA0RrNchlBo8EegQ+gcUDr+qPl8uOPAk8A8K4rFi/SQLGmtV4T + BOPIxjLyBFy7tVic875C4Y5B4GIulpL7KdPPjiXNy30iNIlu4IvwoZ4eKGCbA2wrGvN0AdhSiqJVVwXB + KpzAxPB2EQAzNrc5csqrDpv75vHUhMMjgbx/erwIQOdu89d6Hvh88Unfn6fJyMKeI/L3O0mvMZu5YSfZ + 4ipAGQMgAOfb/nsGflIN+KMrrnhfub//+xQEfZzmQ+z3c2Vf1Gigvm0boiDoCPpOJ4RvJ4rvmNzzsiJU + GYN9zeYIUiLlhUda8du952xpcx9S15LdGSPOf+MKxyne1tv7K3OIFiYXUPxb/KfJfSJkTVTKxRsIOIeA + c5pE1xMAUgoPeh4cY14tAGuKxqzu1XrV1b7/5CFO09smbwcByIAXT5ph8Mv2U3mtTgTwid5zPAggr90P + puwkEbD/z+eDN+7nZ+12VBfFBWG45qeFwjiA6fnhHVwJiHhHphnTf5XjnLYiisYQE8C/XHHFHTNmzvyj + MAx7ldYJ6JNbrRHs34/m/v0ZlpLFWxP5RBPKBGleIAVb3Zha3KUng3dcnx/Cgr0H6cAN7rNnAgjOIlJ3 + 9Pa+f77rftAFemW1E6cL+c/iAiMOJipBRJJgwWXRYn9Zeymiy3zgshrRp0aVwoOum5CCZ8yaHq1XXWtJ + 4WDX0jGRt8sCkH4+k0Ed2brzPLiBzvU6nd7X6b3HSiYK7HX6wzq9zueCy015ayvnPVrxgGci4FY2/1Xu + VscXtwGwSKkrVthefu9/X3LJx8+cNes3uXHHRJFt5Y2beqA1mjt3IqxUDqn1Ox3IhAcnNH2SRYktFnZn + 9kcRB2H5PMrpOc346wtICYAtTAKgP1koXPDeUum/uMCcfH0JYP8AiuMRDGyh4VOtL4gA8ePkPtLyZEkE + 8jERXdYCLiOiT40phQdcFw7watGYZ4rGrI7C8KkP2MVc28phJjp9k5G30wXgP4xvVW4D2jV9XuTzB4sR + HEvJX9sTmf/o8HzeHZAVqlP9B5teYx5sEd0qn5Qlf8kBGIOLiBZ8SKnzrjrvvF+4ZM6c26I40o+4Y0+F + IVTs77e2b4cWNfnJQVF770ab0KH/JiPMcCAb2d/Wam0XP5nv1a8i7bUvQWSXLiOa9tv9/Z8tEl3P+8lA + R7zvEOckSSHGz0s3ih/z60rcz4C8w6aE1dC2tDhwWYvoMjIGqlDA/YXCeBF41jNmTTGKnrrB95eKY58S + K+F4RNE7AbiTpj/Y5zu5Bm+nTBjXOsj78+891kEh+meiuWd63trQmOlsXiQMTOkqQxwQLJ59tj/jzDML + FEVwGPRRZDMHYQjU6wiGh6FbLQDpVZgwmCh+6uTX50d182dki7QfLzPeIlsGzJkAECE0xv/iyMgPYbU+ + L8qxE8B2AHuQxgKAtL3Z+1Kp9OFpnveXhmhasrqSqMxMTP+DnUx0AL+4n1zMMi7Q4X4mwCVfj19Djjzy + vnBsJTzbE0VP7Q6CJz9pV3uetJVwPAhgKuRE2+/jEsA5hBAA73HP+2YA/Lr0MTgSxmaH6utD33nnwenp + sQ09DPwogsudfI0Ggj17rAuArObnAh2pmoDOJdwZAhAkEOYJAEiqAJk8VgXBmscqldVI5+XvB7ADwDZY + AhhFukCH+6dKzbykt/drIdEtstpUrvrDPScyz1oFdj8+Pv7oC2E4Ppuo/xLPO22m4wwMOM7ALNed5REV + 5ip1Bp9kCGJgkpBgnpAg4vd1IgdpRSSxBPl6/JwDvFow5tlSFD293/eXHikhnGhA6srUivstpRbMdpxX + eaZUKKPcrovi6aejOG+e7crjJp4whCMm+KDRQLhvn633jyUT2cxpfo7uA+1XoGzwklo4IQDekE7tiWcb + +v80Nnb/mDE8B3EUwF5Y7b89vj8WvxY93du7eJdS/6SBwU7j12RDGpNXC2iub7We+Xal8hrSwjSOD0pA + AQBdpNTAeYXCnNNdd9ZM153dR9Q/XalZE5HCRATRyWI4pKWAHBnEroULPNcbRT92g+Cpm31/JbLuZpul + 2iWAU1scAKVHXfd/auC/yyijN306es49F8Z1kyk8XNdPce0+RRF0pQI9Pp5ofhYJ9E7gl1bAROY/vy/j + ApBtAmohnuYTBwCfC4IVT9VqbyJNJR8AsBsW/Dtg3YHxFx2nZ3dPzz82gcWyuCjMjV1nN4CrD/drvfYn + o6NPv2UzDAx8mbZlI4pPhAynyBFqzk2FwlnzPG/2LNedPajUrIQUcGgySF5DzjKQ5BBndBDfcmYiTwgO + sL03ih5Wrda3brVkIJeVjPgzXTl1hQAUf49o3kcd58cALo5cF8V581CYOzczlFOO5OIpPrpaRTQ+3vEi + 6VTsk38uTwZ54Odn93HLbwAk/r82BgeA0b8fH38E6ZCUcaT+/w5YIjjwk97eD44q9Q0DDHL3ZdJ1SmL6 + MlJ3oG7M2Cu12tJHbGcm16Owl8Sl2nLxD0kA+Q7KfCl1UlR1tevOOcfz5sx23TmDrjtrjnQhkCMGZAEP + dCAEdLAAYjLIWwsKQEHr53t8/+u3NhoPxMdWl7/flVNTYqsQvV8met8FM2b8sGf+/H7jukl0PynnlbX9 + UYSoUkFUrSYXkuHbDsAHDg7+PPD5vclshPg5bv1llRsD1P9Wvf7IviCoIE0fj8Ca/DsB7Pwj1/UW9PT8 + FYDreTQY/07HgaDx4p9bg+Cl/zM+vny/BR9nxOTin3JlY16VJxkpgLSGhd0FTzyXv82ThHO16849x/Pm + DDjOwFzPm9cHTOtVqj8P+uS+fF48lpZDQg6ULfiKZzeWPzU6ehksme2VB92VU1MYi8G7L7tssS4W+3UU + wfDQzhjsPMWHc/5RtYqo0ciY7fxlnVIXsmU7ATaywM+AHin45eCXjF8eP98Cglt6e9/vEJlxrfdD60of + UC8asy+Iolcu9rxfmqbUpwJjBjKzDtkCoLTNnMFfN2bs2XL5Jz/3/WGkWp8rC7k3gBfl4BJtnr3IBCBL + piX4k+wD0nn/+eddAO7yMBxfbnP9icUwm6jnUs+bO8/zZvcrNTDLdWcNKDUrnuDcMU/eKZ2WdH4iNVXK + vv/vsEu41RETQNcCOMVl3xVXzNmh1HcbwC/yrD0Ic9/wIh1aQxuD1tiYrfPPSad8JQNNEoNs5tE5Tdy2 + Oi+QyQSww51kKShdgpxnGGRsbmPaZpgThDVC2RkTIRG2BMFL/5/V+oR0jKCc/isHgPIQUNmfwVxHyJr5 + vGtS80sSyG/y9U6WgnQjFAC1qFA4q4eoeIbnzfKUKs5wnFkKwCyl5vEOdWoBdwDAmPpfjYzcvQnYB0to + S4GuBXBKS/3KK2evM+bpwJgFRkT4eYAHa3wAiFot+JWK7eyLP98pd3SwgoY8+A82Ej0//Um6DgkpGAOj + VKKeo/ji5ggWF97IeQDsroDSuRIRESrG7Hm+XH7y8azWzw//5AGs3JnJI9g6rcuXn7nSiQykdcCuQt5C + KE7wvPycA8B90vcrAJx4iGvbzIa5gHe5580mQCu7RQqIpivlusaEm+zwFxN/P4AuAZzSsjUMvxoCC+Qs + Popn8ZkY6MYYhJUKwkYj48cDnQlAPi+bZtry+0Lrty2CIjVz7vNAXJUXpyspfg8HtyLKTmRiwsn7xZKI + NrRaz/xDubwCKdiA7Eq/DHwJfjn/X05elqelLaWPLBnIQOFEpJB3FfJWQp4MpKWQ+a19gHrcdj9mTgNS + ousR9wG8gwmgrtTgXsdZFBANlozZck4QPNXhbSdigc9hyZaLL/7jkSj6VbkGH4/rAhEQhogaDYTNpp3P + T2mxTqfbvLS9T3xeavL8wqd+HIDjIB+/D7AaH7CanEuGuelGTvpJOqViktDINYXExDSm9ZYHR0Yee0Nr + vvg5tZefxSAn/7LJL+cxHM4koLx7nrcQGKyd2q7zcYS8C5GPL+TXcMhnHaR1wH8L9+BkSOwdFQOoKzW4 + 03UXjxEtrhLdnq/ucIFneoEHKQyfviYMV4mX8/GvE1rKCxZcuMmY5WEUDURRhDCK7CjwMETUbCJoNqHD + MFMdIpfGPtiBZoAvLID8Utyy6CagOL8fV/YFQKYaj+fzc6Yhr83Z2ZY+Lc/zl2OLuH6/rPWWFZXKsp/7 + /j6kgJKpPfb1pcbnQSwTaf3J/vf5Q8q7DXn3oVM6UWr9TpZAfn1BOdBF9trIWMf/4Z075WXEcYa2Oc7d + Y0R3RkSDmVQV2gNZsYy7wCOFKHrog77/ALJNO8ekM2uq5K3zzvtezZhP8EIbkTEI6nWE1SrkgizS/JaD + WIHDswA65fMTPz8GfhCX9iYkACCIK/E0VyXmTHgZyc5Uw8WgT2YaEGW67faE4Wtra7U3lrZae5Bd3kw2 + DXGEP+/rs9afknkMh5COh4jOxJC3GPIkkX++U3GSzObyLIpn5Y6ckrK+UFhygOhOXpcgQa/QdklZKpBo + NCA+MbHZCaDsAY94Wj/04VaLyeBYdfEdlYyfffb5G5TaEEaRBbvW8MtlRM1mtvAG7U08eV/8YAeUGesl + Unuassudt5RCK9b8TAShNP2J8FyzuWzN+PimC3t75/Yo5c3yvBk9RIWZSs1QAIpEhUGlZrIl0DCm2tS6 + oo1plYNg+EAQDP+s0dgc71re7JXTl/IRfh66KrX+lMxjmIQcjguRJ4hOZOFM8FkWrgpfL3/0lJExxxna + 4rp3jxLdGQGD0rztuOYAp5rQ/m/zGQQyNFp2jHnU0/qhj1oykBW2x50MNs6b9wcHiL4QAXaVnbExu2qP + TMmJne0UiZ8MAeTXQPRjf7/F2l+ppL6fawAMEZ5vNpetSlfi5V2Sa3h08gwkyJPYIdK/lS/yFtpX9pXb + lE5hOkaST/dLcHeyHjq9xt+TJGxgS6lPHQLY4XmLdil1d5Xodr6o5a1cmUcDyYKZ8t/m22TVGIgzKsow + JRm4xjwaheHf/XIQcK31cSODLY6zeP+sWV/2C4VzTBTBHx21I7rjXHqeADoRIu/wQcEPZPz/fNFNEG9N + Yf6zFaABaKUAIjzbbC5bWS4z+LkA0Ee65Blr4k6aEMhe1Fp8D2v9BlLwc5pPLqfeaXm1Ewn8B5ND1QR1 + egykx9jKv3BSyrpCYck+pe5qEi2UF3Wy0pBMN/GFimy/ZPKPcxQ6131FItiUn6cnnt/uGvO9A0HwrSV2 + so7suD1mWmWf4yzcRXR3Dbg9BAbV4CBQLCIYHbWaX/xwYqrjKLU/MCEBcMQ/sQAAtIRLwK7W076/7JUU + /Ax8BqwMwkkCyK8CxiLBzz5uA+nMRS7prSEFfsdFVU8xORi+zaHecMLKmOMMbXPdJQeI7gqJBmXKKQE+ + 0uqvxK5kUxXZXIgkgIQ6xWx5JW4VUhLIEEN2e92Loq+vCoIH/kTrA8gtSoujvNj2Oc7CPURL6kS3+8AQ + F8JoAKq/3x5ftZqAjScDSzaarO+fvD6RBQAkPf3N+D5bBGz6P+X7y1aka/FxPr6GtPyWNTSPA2CulasW + ycCWNPtZ+3OOvyE2nr14uKm9U15OKgLY7nmL9jjOkvF4pWFp1if13jnwSzKYaM1BFjImIYFMv7aYo5e3 + AjJkIKLSInz7ExVF3741Gy+IxM8f1gW42fMWjwKL60Q3hcYMSbAmVXMA4HnJEtz2oDrk59FZ8x82AeS/ + UwQBuaW3JW6l9v95GC5bUa3mwc/5eF6Ik5fi4tLbfLWd9G2BbOyAM43s17fEfSaJk83cP2ZyUhDAumJx + yX6l7qwDi2TNeERZ01MSAHd8dVpwVANoAJWNrdb6F+r1jRu0rn+oWDz7/FLpnLMd55wCUCBjsrPd5FBN + 2Zsd35d5akkOTvr5sgv8xI2ihz7m+/fjEPGCA647tEepxVVgUY3odhmoTK7cWPNn0prGZIDMM+2Qf98R + mv7J8znwy4L0AjUAACAASURBVHQgE7EPWAJAagFERPhpGC5b3nkhTl6Lj5fjGkNqAfC5SUoA0NkCkCTA + rkDSWIisqf+OBz7LCUsAdaUGt3ve4t1K3eMTDUkQ86rC+dpy+Vy+1FQToWZMZVcQbHmlXt+wMgy5ZDKj + GAHoXyqVhi4uld41T6lzSbgCGdALzZ+4AOK+MwEZxI+3e1o/2oqib90RBK8AiFa67lnacW6sE93kAzeG + xgwB2SvcAGlALwZ6cvXLxxzEFODPRIEoW8KLDreZ+wL08jUJfohzH8ASADv2IREejqJlL6cr8+TBz2vx + 7YO1AtgFCMXPStDLwJfcHfk/njR1G8dTTjgCGHWcoW2et2SY6K6IaLAtmNfJxBcmpnQBNICaMeVdYbj5 + lVpt4ythOIbUdMwHjvJ+Ic0l6r2+p2fBfM+7YJ7jnIcY+PkAoXQNJBkkwcIs+PNLWW+Pv/PsTiFbAMhr + f9b8/JqOnzMxMXCBjfyuBD0dLIIJwS/Ajdz72kqHBTknOX9jEBChDvivGbNpn9Yj+6JoeEMQ7EIKfgb+ + PqTmP6fmOBXIkgc+82OnQzpcj+YdLScMAezxvIXbXPfusdi/7xjJ76DpeS35ZOItEerGjO8Kw80rarX1 + y62m5+ufg+DsK/LyW01k009AWoFVAFC8WKk57+7pufi8QuHS6USzEccLJGiZDPjDSXwAbaBvyyZI6yIv + DHqTv8/EkNP+8urPZDKIkjHWEwIbaDPzk/sdQJ8nAFa9gSAAGconAIoIo1pvDYC9PvBWK4pWrQuCF57W + ehssMXCg7h0fpDvWctwJYGOhsHiX49zVIFqU99dZqwc5X19D+PjxVgPG94ThhpdrtfUvW00vBzrydclR + YgY9p4s4QiyXgHaQtmv2AOiFnTVfutZ1z76yp+fyc1z3kgJR0cSWQbKIBZCJH+SDh5msQX4UFESVi3gt + MesF6PlxxioQ1gFHzxAfjBeDv5P9zO9vGwIy0ePc8/w9Ms0aGJPO3hPnhEt5XUrr+eOFOF8vAmt6tF49 + YMzKm5vNJ5H127v++xTLcSOAt4rFJbsc554AGMoU7eS1PDr49WzeA2O7g2D9S/X62hetppf136ztO4Fe + pojqyOaGOfXETRglWPDLrSfeSv+hVLrkwmLx8jMc5zz7q2kqMR876BQ36AR8ylsB/J38vNYJKSTkEBPB + ZmO2vRFF2zYaM/b7rnsrkEbPXKJMGJ1PkjT3OwX38qO8gGwQEbnvYgLK5z55ue58r2yS34utFBk/cYHn + SsDTXhQ9mJty2yWEKZC3lQDqSg2uKxbvHhb5+4OBPE8KEYCKMbs2tVqvvtFq7X4+Bb1c/JG1/eGAnh+z + 9uc4gIG9/rj9kleZYQLoQ44M5hJNv7FUunhBqXT1dLvabpYMhGsA5AAvNwF+Et+RpChztz7gb9F662tR + tP3lKNp3wB63AWDuct3rFhBdyL6MlyOAvFmfAHgC4E90y5+Xt/k4BRNA3gLi1XiVAL6be484P+Me0SPF + KJI9Gd1A31HI20IAo647tN7z7i0rdXsADHYq0+2k4TnIVzVm59ZWa+UzjcamV7VuITuzHbB/er4Q5GCg + 52mvTA7s/8tGkERxInUFSshaBH252x4ApYuVmntTX9+1p7vuBX1E0+wetl+XMpHdyWpoAz8ApTVqxlS3 + RNG2jVG05ydhuIPPwVUzZ06/8Zxzzpzd19cPIhO0WtHZGzZcFlarGQJgUOW1PqcHGdw6d1+L+5H8jPgT + 5HEgZ/20EYBwCZxcOnUCArDfbUmr7AKPIAz/7nZrGZywDVonshxTAthWKCza7bpLxkThTqZ4B1nwy+fr + xmzf7Psrnm40NqzWuol0JWGpwGThh6z/5u1wQC9zxfLiAbIkIAcylJDGBqQ10IcsGRTjeMEVZ7ju+b1M + BkJksM4+ka4mw89prf09Wu/ZEYZ7Xvb97Ru1romP676+Pnz+mmtuvOy88843UWTdAWOAeOpPbfNmVF9/ + HajXE8DJ8HlSGCUAnwztFOCPxOPEvGcrQJBUknmQxVEyRQoRGJ0gjSrjJW15P85wpLfLEARf+NVW60lk + szndvP8h5JgQwMZicfEux7mrRrSoY1NOTtNHcUCvaczwviha83C1uuwVq+l5Zdd8b7dsHJFLbB8N6Dtp + DZlFY+Up57t1sgo6EUEP4kzCxcXiubMdZ+6g686ZTjSrQFSQPxga449qPTIaRSPlKKquC4K9q8JwRLxF + BttDANF3brvtk3OnT5+TAN8YOwGIXQWtgSBAY+NG1LdsAYIgo7Uz7bwQWp7BLi20+HGyvl4+6xAH9QA7 + tJMLp+IgX7ZSUsZC+L1Am5WQj4kkw0MEERARjDEvVH3/Tz/j+6+gW/l3WDKlBPBWqbRkp+Pc4xMNJVdp + Tnvku/J8YN9wGK58rtFY8WgYjsKChrV9Pn0n/foG2rV9PqI/GdBPJEkWC2mKUM50YzJgwEsSYFJgsuDZ + dHKKS6cmFyBbuZyvdAs+/5733HDt+effmGQDYgsg0chap7PljUFUr6Py1lvwh4cTkz/i29x/FSqVne5D + acVlMlsq/oycXy+rI9mv52h/cqBCwyduidZtlZUyLqKApBAKSOMXPEJMxbcmDL9yZ632BXRr/w8pR00A + daUG1xaLdw8rdVcYF+5kTEaIOny+eIiq42G4fL3vr/n7ZnM90hQbzz/j/ZIXex70eU3Pf/ZUgn4ikWTA + 17Uc6MjugSQDJoHEIkCWCPITXHgf88CXHW/+Q7fd9vmS500jY6BbLbR270Zzxw6E1SpMEABE8EollM44 + Az1nngk4Vj/XtmxBdfv2bFMQA1x07+VX1Ako23TF5r8B4Bvj9wAFWfeQmVIhtLwokU4Pmi0ArbPVkzkr + ILnHgEdKAmwNaGOW3l8uf/ZhY/Ygm+E5HsM+TliZNAGMuu7QukLh3nGi22VEPw9+aUrWoujVrb7/7A+a + zde3GKOQ1fY8oFT69gzqeodNmvYMelnR93ZEiKWLkI8XTEQGmTQi2q0BaQXkzf1MZuP35s8/944rrvhL + aI3W3r0ov/46EM/0VwwMubeeh9JZZ6F4+ukwxmDszTfhV6uZ/4nX0ONxXgx47uiTVgCzE9md8u8fHX3k + /N7es6/0vMt6gILU5pluSqTsmZw8jhPEcQFHgN8VBMCpRB4jZpgEYuBLEoii6JnfHx//fWSHfHKFYdca + wCQIgAN7o0R3ysUV5X0J/gDYMxwETzxSr7/wlNYNpFqQL/q8b89+PWt67uHOm/gc9GPA88bX5dsdCc7H + C/JkUBQbWwAl8RwHGTtZABL8CeF9+eKLr/mF+fO/WF23Ds0dO9KaA8qOzk4c4Pj/cfv7UZw/35LA+vUI + tU60fyBn+fEor/iWLQPZX8Gm0Mpmc8XLo6NvAdBnuG7vNdOnX3GWUueUgIIsiZYnK18nIYmA4wdMBknR + VPwdXLQkSQBEMErZakeyRU/jvv9vf1ypfAXtc/+6LgGOYCz4xmJx8U7XvesNokX5YJ6h9kBfXevnNjSb + T/9Ns/k6UhN4NiwYOE7EjSGs1Thtx4Mc8qDniz8P+hMh4su/y/iQpno+XtBp/ru0ADq5ALJnwQcQnKbU + aLBrF4Lt25My3ySFCGRKdZMdJEKrVoO/di0K8+bBmzED/shIVvsL8PNIryB+nf9nxN9FxmBLEGxi8AMI + d4fhyAMHDvx0FpFzeX//eWcXCuef4Tjnmfj98sCSlW3jugHOUmhj4PDaBUhjBgnomUz4GCkdMwZBTKVC + 4Q4AP0SaQZKn4x3vChySAN4qlZbscpx71pPtyGuL4mfBXy2H4U/vr9V++oTWdVjgz0U2qAekAOYpMNKn + ryHr60vQS+CfCKCfSGRqnZC6NC20z4LPLwOVyXghGwOQcYBoruPUKtu2pdFwAKREDJEo0Zj5XL/WGtWd + O+FMnw4UCnZMuDT3Ebf0xmSQn6rELPVGq7XmuQMHXkVK5klm5oAxraWVym4AywB47yuVzptVKMwbdN25 + PUQDvUpN6yHqT06ajPYTgZRCJIKYhmwJsUaaATAAjFKphSMIIZ4i3LukVPrIN5vNx4GkDaJbTRhLRwJo + xIG9EaXu3CKAn48S8/3QmN17ff+Bf67Xn19vfXsGvkzhxUH/TL5eavp8Sa70608G0E8kHNNgl0TBHpeM + G2TiYmiv1JWWAN8a/dprSyPXbffjKDevH2lbnUz5GQDNchk/dpxX3kP0rl6iPmkF8DDPENb859n/ADAc + hntfPnBg2e4gqCEFP0/2qSKdtBvFx1dc1myW0WyuxUGCn1cXi/MIoES/y9oCQRAvBsHez/b3/9LpRKcn + pMbuKNIYQUSEXs97F5rN1UgLxuQ1JYdDveMkQwBjjjO0uVC4+3ml7gyAwY5FOtK/N2b99mbzoXsbjRdh + 1x0bgPVvpbnFwJeVeTWkwJcz4GQEv1P0/mT+o6SLAExQCQy04VnW6wCAXuF5i6vAFQHR4DTgMzuN2V9S + 6o8KwDUMUmYNGayThCD/z2la93qOU8hE/mEj/hFS8GsiDIfh3rWVypoNtdo+8bVs3ciVdniqT4iYAJBN + i8o18ZJU6PJWq3oY58SeSGPq9gym5j/vLxOAIkKDqARgJtKFQaRLKdf7e8eJC1jgbywU7l2h1J0M7hBI + Wm3zo7V8Y1atqtW+/3e+vxX2Tz0NadGODOrJgF4tt+UDerJw45Qt6awqNVi+9dZfrLvuNaFSgy3gvfA8 + xctiZcxgYwwFwS4nCLa6QfCK2r//ja2vvvrnO4Gb5FCPfqXKe4FvENH4bKKb5bivzImMzed8We9FSp3t + EHk+pak+Tv2xmzdqzOjq8fHlm6tVCXz5H9dgwT8KO9RjFJYQAlgA5ysnuSaijQSQTRZkqoDludQ2qMf3 + M8VlHCRUAHYFQRnANGSX/q7Ev+sjrTV5x4kLAKuLxZVhbvgG530jNgGJ0DRm9cpa7QdfS4Ev/Xv+c/Lz + 2HnjVVY5b59P3Z2SoK/fcstpw0Hwn1ozZnzIV+rKrb29cw3iBhlRuZdU8YnXAACOc1lUKNgOn+nTUQQQ + rFuHyPcTXxdEA3OIPrvbmCc2EL1wDtF7k6ABZacHtdX3E6GPqE8u2hGK1ziotqFef0uAn4HPrhyDisE/ + AksGNaQLUXpISaCELAFIEpBukUwQADkCmEnUq+L9zIw9F8/5xviPNRo7kW3m4t+VWah3pLgAEBIN5ift + cDAo1vh7X6rV/vbr7cCX/r0cxyz9QAZ+viT3lK3Zrt9yy2ljhcJ/rpdKt23r7X0fAx7G2IU6JfiRAzyX + 7vJ9QQ7GGJSGhuDMmIEDL74IHQSZSTyzlPrgXmOe2ku0Zxpwer5YR57kxFVgoqfcUFUgeT0A/NdGRzch + zW5I4POCG3KNPV50o4F0wEq+PiK/6GUnC2AiSwAA0EfkOIBdVJTSl4wggF1BsAPtKVkP7UVX70hxgWy5 + rlzGuQXs3dho/ODPm81XkJr6shMvQrtvzxcFr7qS1/h5E/+UAD0A7Lvhhttqp5/+u9uKxY/A8yyo4yW6 + TA7I/3973xokx3Wd993ueewuHlyAAN9FgpREitQLoUQpFEULFu3YkWgTpaRsJakU6DhKyZUH6cRJ/qRK + +qH8kkuSU46dVCm0VFSicuISY5miLYqRCNEkRUIkXiQIgFwsgQWwWOxj3tM9Pd335kf36T73Ts9isTOz + wMz0V9U179mZ2T7feZ+TJvC8r98U/Pi6ELA2b8b2Bx/EyoEDaDUaWunu7cCnnw+CZ3fb9jYbKJKpDwDx + LEEWI6CAIG+l4+k0ALjQbs9B1/y0UrvEDnPHHi3dIIuOaoLMJZZpm225wJszTOIA6RbgDjIdKUXIA5UK + wEvl8pGUf1XXuMK4IQewk4CZ/wvt9vf+S6Ox/1TIlqTxKVJNgk+RfBJ6Enwy9c2RzCOn7QFg8bOf/QeV + zZu/XJqa+pCKGnEUNdzQbWaGK6bhuXDHGj96jF+PZ/+TJrdtbPnoR+EdOgS/0Yhz9R6Ae/P5v/fHjca3 + /sXU1D+n1Wc8rUCXCoCrlJdTqmBWbtJ8QWFZeLtSeQtJBN1F+H+mKb7LCE3+KvRqO7PsViCJwHPtbq6z + Ng/T/BcA8MTk5K8RI1EPgJYtsCycarWOzwZBHZ31FKO+EGTNyAHAlFJ/XLGsf6WEQEup179Tq/3pj6SU + ALYh1Pz56PkSnSuXKKCS5uOP9I+98PDDX6xu3fqfV3K5nbHQq3AoJx/dpQytzrW8qeHpNXzun2IEECAh + ASkENn/4w3COHoXXbIbbeBCa8b80NfXA3wTBc7+cy/0KF46YAITAW1Keut22b+HxAEpRIBL+plL1065b + QpLNcRD+z1cQTvNdQmgBUIVdt8YbngUJoFdO8kszO4K021tt+6EaOpcEUDlwWynv+VKJVrxTzQmfFcHj + TmOLHAA82Gj8x69b1revyef/7u+2WscA3ICwao9SekD4g3FtX0Ei/Fzw+XCNkTPzAaD8hS88tOT7Xy9P + THxYSRn64ikCn6bdlSH8QKfAm5aBAhBExMJ7LgKlEAiBzffcg/rx4zEJtAHcZtt3P12vvygnJ5/bk8v9 + isU1JIATUs78wvOO3zU1dUc8AYh/yej5C60WDRwhIaINPjzaX4U+T3EtFp6ZFg1SnpNqpp+x7emXgIdt + IK77jz+zCteIv91svr6sFAk5xad42pms0pGyRi8XcR3Av5XyHMKBCjcgIVQK4NA/nm9YrSLx8+kH5UsY + Ru6HbX7mM9ctbN367QUh/r7K5aCixZvSFH5TiMMHO4kB6QIfm/zcbYBOApSloeUbm++6C7WTJ9FynJAg + lMJNxeKOFxqNt6oTE+VPF4ufvlapnQ2g9mq7/frzjjPzq1NTH4w+eBJEE0lJMYTAhWaT/H8K/tGabW75 + OUhmKfbzf576XhcLhd+0gGnBSI1POapLufh0tXoMoYHAhZ8HpMe+BgDQC4F4/TqZ+MSQDtK1vtlmOZKC + DwAXP//5L83lcn+ohNikgiB0Ks2g3iU0vIQu8B3Cbvj9RCyxyY/EkaXcKZXttoXA1K23oj4zAz8IoITA + zlzuOgBnD7vu3GHX/TYSXzwPwL7dtnfaCN0B3rAjlIJtWWgp5b3ZbC5Ar/S7ooJUs+3p/Zb1Fb7fIEZE + CK9XKi9G9/CgJc//mw1BYwsiAN5+S66VFz0ukRAAj+7zneojK/jOZz5z3fy2bd9fse0H4gAf8/O1CD/Q + odW5H88Fn5MHjOeAvzcMAgj9WwRUqqtU6PtLCVUoYNPNN2P5zBlYAOZarQsIBZ5iN6SlLQDWTsvaTlE4 + RE+yoydAKSyF0X8F/fwwS7Y3VIhOFAqPSWAXgLgDMG4HVgpn2+1fvBh+70L02ShdSZZrDYnFOtZlwEBC + ABTgaSKpVaeoP0X8zR58Xkc9kj/iwkMP/e6ZrVv/SAKbNHOfCz4SgZFMyLm2l9HRLpUg22349TqCVguB + 48RNLABgT00Btg17agr21BREPp9YGoA2Lt33/TjyT0TgA7A3bcLE9DTeXFmZedvzytFXof8hLdwEAGwF + rqGdBtwKsCPzf9nzLkBvR+bnwYYv71jJ5Xa9IsRXKE3J3SOEH8b9Qbl8APp5y7cOk9uaaf8InADI9JcI + hZyq+4j902r0R1LwAWDuN37jT0u53JekUrGvb2r0S932ajW0l5bQKpfRrlSSE5blqbUwebWqfQYxMQF7 + yxbkpqdhbdqkrTrnE3radFsIKClR2bJl6amZmZejt+H/W6rO8397YuLufBRE5IJEn0cohTdrNbIAeOdm + GgFsCI7k80/FnahIgqEKoWV0rNn88aJSZMhQ0Jpc1zJCAmgi0/4xOAEACTO2kAQCyQQkxhzpH865//6d + 56anf1QX4u9IP4yBkrbnGt5M41GO3nddeEtLcM6dQ+C6ejtfiuCbP6RGCK0W2q0WguVlqFwOue3bYW3b + BpnPJ5N5iAgQhdGVwvZ8/hr2dkQAVLxTBuDsBHbGC0Ki7xUg1P5KCNSkXF5Riqbn8CpPsgI3NI12pFj8 + 8rwQu8kNijMh0e/QkHL+fzcaJxGmrcnl4c1JVKew4cR1NYOP4eJxJirWoMfocbo9kig9+OCnzmze/BeB + bV+vWAWfJvxAapTeK5XgLCzAu3gxNo3iqjqkC/1qwk+34/cKAjSXluCvrMDauhXWjh0I8vlwSAdlBgAa + vZVnL+eluzWEwlB7by53Yx5J7k2pcFUXuS0Lrdbp6CE+2ISGtvDCroGfD6cKhb0zlvUVczgp7R2UQuDn + 1epzCP1+QCe8NN9/pK3XywHPAqwlLzuyWPrUp35zYdOm/ymBzZL5+2nmPaJLCaBVLsM5cwbtanVVwU8T + +rUQAGdfuu7W6/CaTWDbNojpaW1YAhCP3uIJA54GqwKoXgMU20rFxUF81ZcCMO+6F5BYf7yr0ySAgaJs + 27sOWdafsYGyyWDS6Jj3/YPPet4iwroVcmG59ifXh9cqZMBljAQbZZx/8MHfvzg19XUlZRywo7SddsmI + oN1ooDk7Gwt+LPwpgn85Qp/2WHxpvLdbqcB3HNg7dkBGU3EkQAtHuevWMXlpCmg3IgKgyUFkSUil8PMw + kg7oU354vcfABcmxrOlD+fxTbSGmtenENLcQQAtwvlsuP48waE2ft4lE8/PGJF6enAEZAeD8Jz/5++Vi + 8evS95MAHtDh75MVEPg+nLk5OAsLmt/UTfgJq5FAGtKEn25zK8P3fTQWF1HYtg0oFMzSOV7bwYO47aJS + 0o3eU6poJ18UFCwHwbno9UQg3PzfMB/6rXz+G01gt8+0fjuaVUi3Zz3v1YvhFCqK/FMqmzoUue8/Vlbt + WjDWBHD+/vsfL01MdGp+5u9zN8AtleC8+y4C39fHFBnmM1IuzeuXBKvMo9cquh2lweK/rxScahUT27cD + lkXBG9OD4A1/Mp6yS3dEJrYNoOr7S9Gn4Bkg3tE58CzQ8ULhsXkhHuUjyeMjsgQaSpWfqtXeQOL781Jl + CvyZab9M+zOMLQGc+/jHHy8Vi9+QUX++VIbPj0TryyBAY3YWXqWiCf5q5v66Bd94HfnnaX+H++5+EMBp + NDC5ZQtaUvKyXF5AGHNGAShTAZCNsMyYRnJfa9s72Gv4KHKz2WcgOJ3P750V4pua5qd6B0p7AnjDcV5a + VIrajHmjEm9Nzop+VsFYEsC5++57rFQsfkP5fqfgs8i+UgpevY7mqVPwg6DD3OdafxCC33Gdpb44KcTL + WBwHxU2bUG63yylvq2F7EBwq2zZUZP7bItkcvMOybr7TsjafDCc78yzAwDs7y7a96w3L+jNKb/ok9NEl + kUEDqPyfZnMWYcaD0n5m0Q8v+c2EPwVjRwDnPvaxf1PK57/JI/2Sa3wkZn9rYQHOwoKu9dHd1++W3rts + MLMfQDyggxMOz4NzK6HVbKIRnvgcHR9NIHIBotdxC8AWAvdOTt56stGgSkA+knyguf+Ttv1UO5pQ1aH5 + mUVwpNl8FUmxGhU6mRV/lLHItH8XjNU8tMV77/3cim3/kfR9yCBAEASQQRCO6fJ9qCCA9H0EnofGzIwm + /Hwbjub/o7sF0AtioaZKN3abr1/TSEkItF0XS2H/Pr0Nz07Gb32f6/4snsChkiWctH3nPYXCXfz5ffxq + XfFWPv9lR4jd8dQOnvNnkf+aUtWnGo1Z6CW/lOIkAqB+lSzwtwrGhgBKu3ffvyDE92Qk9NL3kyO6L/B9 + +K4bpvcaDT1yRtVn6L/Jz5GWPeAaPh7cCkZI3B1QCudKpSXoRkvabAZlA6dJ+C2DBKYt69pPhN2E1G27 + 2gbjnrGYy+1eEuIrvNSZB/3ikmfLwqznnURivfI5FVXok4mywN8lMBYE4N5557XzwBNSyi1c4PnhBwH8 + ZhPN2Vn4rpuq9Vcz+ft2hhlRf27+S6b9aZ03381ICzKPOg4V8cTyhM6uTWUDR7TZWypZwiEA7J6augeh + oKVN7u3rTL3TlvUNXtrLq/3ilVDRhOpna7Xj0WfgjWqk/Snnn5n+a8BYEMBssfjDtlLvDwztr4IASkoE + QYCgVoNz9mzoFmB14R+EyU/vlSr40AOAsYBAN/+jKbhz0dtx4Tc3JisAmFDqMKUDNUsgcgNuzefvRjLO + m8Z4cxLoC07l8/scYA9v8kldTy4ETvv+28tK0fcg35/PpMwq/i4DI08A795999c8pT6hmfqR309mf7tU + gnP+/JqFn9B31WJqfySCT8IfGKRA7gkFMM+FI7xM4Te7OAEAm4Jgf9roXSKCAlB8eGLiAwgJgNaaEwnE + vUS9oizE3sD4joHQC3+o9Pe1UPsDSdEPdfxx4c8q/taIkSaAxfe979crQvyBqflBZOD78MtleEtLXYN9 + GyX8qdqfRfjThIMWePAR3ueTCT5pbdyaFfCA5+23lKrwtdymg3/X5OQHkb5Uw0afzp8AmI79FdHZ7EO3 + 60rVj4QpToUkNclH0VPgL0v7rREjSwDunXdee8G2vyV9H4oF/BRlAHwfXrWK1sqKtnHzUsI/iHC4AtK1 + P/RNTYEhELwfHkJgOQgWzvp+HXoJ8GoFPMoG/lbbuhG5ADQe7HrLes8NQkwjIQDa60dr4Hq2AnwhpnmQ + 1UwBUtBzttWaiV5CDUp8CQ3X/lngb40YWQJ41/e/67fbN5PgB3QZBfwC1w0n9KAzx7+a8A8ELIqvpfqM + ACA3k/l+P3rtGcc5hU7hX62EV01K+Vfc7CfBp9mECsBDmzbtRrLXj9wAsgJ6hgvspg9Fm4nibUXMzTlY + r9P3MzsceeAv8/0vAyNJAPO33fYFR8pf536/khJSyvDSdeEtL2tan06yjRb+1JQfDO1PQTCg0/wHgPAx + 70ClwglgLS286u12+y+56W8ZwUChFG4vFD6IUOg3ISGBvu3W4+a/tpGakVxdqcZsEJiryPl6eU5ymfZf + I0aOANybb96+CHxNRgJPKb4gqvkPggBeqZRs2AE6LjdM8wNdtX8sAIb/z3vh4+IgAHOuyPJMoAAAGb9J + REFUS8K/2gSfDgL4PSlLNvBMHAcAI4Ho820RYsf9udytCM1/2u5LbkDPwUC+lITXAfAsx7w+oJRvJM7G + fPeAkSOAOaW+2vb9W2QQhAQQmbIkaO1SKRnhBd307xbwGxSUKfyAJvS0mp2EwTeEn0aMCQDHy+Xj0VuZ + 8/toYUs8NYx/BACyIOXTcRyAFQRRPEAB+NDU1Eegr/cmK6BnAoiLmBjZ8aWnCsC86/Lx5Gnfj+8hzLBG + jBQBVO+4471VIX6PCzF3eNuVShgMxOrCz7FRpn9HmbER8eemP9f+AHDW806dD4N/5vhubh53C47JI+32 + XwqlqnGpH4sFECHcms/fg9ANICuACICCgT39FvTBzIAsPfaC41B6k48448LPp1RnWCNGigBOO863AeZD + I4mw+44Tj+HmdbHxVFkkZ86G+P2rBP7MVF9sEhtBMUTv88bKyhEk2t9c0X6p4Jj891Ku5IBntJpfIoHo + SXZSE8DdAKoJ6CkbEGt/JLGPeH05gGXfN1ObpnvD13xluAyMDAEs3Hjjr3qW9QDX7AQZBPBrtdjPTPP7 + CVfE7+efh5n+nAS8qB6e5/4FgLOt1qnzvt+ALhw8NcbLYrshsILgu7QTQJgWQGQFvHdy8kNIdwN6CgZy + F6BjiKoQWEwIgO8nuCIDSkcNI0MAF4EvA52mvxICfrWqTfC9lN8/yLOoq+nPI+CWFW7+saww8BfVwJP2 + J4uBaX9uGpPpv9bcuAIgP+d5+4VSczRdw1IqvoyGjFJNwDXQSaCnmoDz+fzuePoR0i2xekhwZLyRi5Np + /z5gJAjA1P5cuwaui6DV6myJu1LCfxmmf7z4QySFMWQqCwAnms0j84nvT4ExvgNvrdFxCcDPKfXfKQ4Q + Cz90yX5gcvJu6HGAnmoCPCGuSYu/KPY3L7RaK0i3ALI13z1iJAjgIvBlfgLFs+6ljE1/0zLgRLERMIWf + b7SRTPNrZbAiGYThW1ZsLQgAPuAdK5V45J9v7jW39q4lOBYstds/4M1BWqNQZAXcUizeiQHWBNC8w/gm + gCO+zwkgrbox6/lfJ4aeAJanp+/1bDvW/rHwC4Gg2QwLgcA0P3TTHymX/Uaq5kcS+NK23JimPwsESpEs + w3yzVnutLCX59mnaXzP/FS006P4R5e8EwSmh1N9wC4C7AQLADZZ1xz2WdT10K6CIPrUJk+anceWOlHUk + 5n+8ER16g9NGcvlIYegJ4OLk5L/jSzpjYZYSfrPZOU57g03/NOE303xavl+E/e8e1/4sNw4AK+32wsFy + mZfFUlEMDcQwh2FCpO7T1iAB+AUpn9YmfxjZAADYPTX1fiQpQbNB6LIIwAdEt99eKIWmUiYBkLXDU3+Z + +b9ODD0BOEI8zAN7QHS2NJth2S/0nPKGqwqDcCj+wE1/n2l+Mvc9dp1rfx/wDiwvv4zOwF/aPLzLbYyR + n2u1nhRKVW3S/tHB3YBbi8UPIJ0AcujRAoi1v36dfjre4TjwAaXjgKEmgDM33fRFaVlbO/x5IcKcP1N6 + V0T7R39P+/tM65t+vzkFp8P0B3Cy0Tg6325Txx8NxKBFGL3Mw4u1bB74a14LYLYJbxVixw1CbEV6NmBd + lYHd/geVxP+Pq4TZkWn/HjHUBFAD9tIgjNj3B8KiH2O4RzftvxHCH2cdhOjI83O/n/L9XnSfH8UCYtM/ + CBYOrKwch27682GYNBJrvfPwFADf9f3/SnEA28gE0C7BT05O9s0NSAO9QTuMc3AXIG26UWYBrBNDTQBN + 4LNm3lgJAem6wBq1/yCQJvwduX7D7Ce/X1t+Cd30/9mFC/uRaEI+B7+EZA1WL/PwFIDgt9rtgwI4S5rf + rAcAgFuKxfchFHoaFsLHhfVlUpAAIIQwyzf4qvrM/O8RQ0sAZ6+77h+CLcQkyCBA0Gp1pPo2QvvzCD/Q + KfxayysJvkgm35L2p8IfXvF3sFx+uRJqQ4kk6k/rvvu5AVcB8PNSfs+cFBR3CCqF62z7doQaf5IdlA1Y + txWgDSeJ/hb0GABvF8i0f48YWgJwbPteLcJOqbVWq8P3Tjv6jY48PzqFn0x6nwt9dNki0580v2XFVsys + 6x4/VqtRMww3/cvQtX8TvffEK4Q1AU/aWH0W+J5C4Xbo8wJ5VWA/wX9Ws08oQw8YWgJoCvFL3PcHEAf/ + AN1m5MFAQj9JoCPVh0sIPzf9iQSA+DHT79+/uPga9Kg/F/4VJNq/H/PwqCZgxgLe1AqDWIEQhMB7Jiff + h2RiMK8K7EtREHM5uFFltntkFkAPGFoC8IT4kBnJV1JCttupDT6D0v5pwi/XIPyU54/z/dH9vEy5ImXp + hdX9/hWERLDetF83SABBXqkXyOyPg4BRTEIB2JrL7UQo8D0RAKdnPoeAPca1/UYkcMYGQ0kATcualkJs + jc+CSFtKz9Oe103w+3XWpBb5sFQfBfq6Cj9dp+o/6EG/g8vLpt9P+f6V6CDTv4H+jsNSAALl+0/GKUAR + Lh3hwrrNtm9CsjeAjwy/7KrAtCcKANtzue3G56LLTPj7gKEkgMpNN33MdAAVIgJIMcX7jTjmwH1+kT68 + U4v2M+Hn/j+NvybhFwBeXFx87rTrriAp9aU6f9L8pP0HtQFXzgfBbCzFXSqJ78vnb4S+OOSy6gH4u6Y9 + OS9EIeUp/f+njimGkgAIWsANYQagW/Cvn3/TDPbxxp6Ojj7D14+Dfuy+eN13RFYHa7WXT4cLPnnQj4R/ + OTpK0X2D2oGnPlAofJYCkVzi+HefFGIS+vYgcgHWnAlYw4fWEgPsdkYEPWIo14Pz4B8X8sDIAJiv6YUM + uODH7yeS0Vy8r9+P0nw0xJO0PDf7ufDzdN+hWu3lw2GdP+W7W0jSfcsAlhBq/15z/pf8yjUh/jXoewu9 + p4LuP9ZulxCeR0QCNCaMEgiXrEZcoxTzJUYZ+oSh/jG1PL9SiUCif9o/diNStD4Jv9nNR1rfY7n9juur + Cz9F/EnzlxEKPgk/j/oPZA7eUi63KwA+ot3JCVAIVIJgZUkpHwkBkP9Pwr/uWgDCFsu6FsbWMuhZycwK + 6AFDaQF4SgllCKTyvERLG/7qeqSDa7luWl8haeU1G3sCCu4BHeZ/+9LCb+b6SfNvhOkPADhv249wra8N + W4nuf7fVegfQaoT4GvHLEsxuTy6EMQB6mAt/Zg30AUNJAGSSKqVi9RdPygUT0lVb4NNBJBJfZ+9ppvno + 78YtvXygR1TNxzV/nOcH1ir85PMvIiSADRF+AFgW4lHw78qP6P7Djcbc6u9ymWAbibT7EmE32xKAzALo + CUPJoLvOnn2OR+K1OnsYmsqI1nc9zBMcRk4/uk6+PTf34/bd6JKq+lqWBZcCftHBU30W1qT5LyIkAF7r + P9AR2Bfy+d2eELu5O6VtTRICC75/+lQ4rIPX6PNjTVV64hIkzR41zf++7CUcdwwlAQCAAI7xkd5akXgX + Mljt0CYGgaXz6P0i7a75+cbRioTdEwJuJPxpZj+EQBvwLiH8S0iEn/x+GvE10CGY5yxrHw9qaiPVoutn + XPdM9HQ+qqvvU3oUgHtzuR3oJIAsC9AHDKcLAMCS8oiy7XuUZUEqFQt97LNHQUF+0lLrcAcMPx9A52sZ + GZg5fm2IJ4v4UzDQNPnbgBfl+UtIov3dhH8ZofDzHv+BFsHUhNjLSZHv6VPh528902jQpl4SfBrT3W0T + 8SVhSrOK7pu0rALStX9GAj1iaAlgAniyKcQXzPQbEEmHZYUkED1O96emCM3Ho5MdSHEB2N+idB+v46eg + HzX18GAfAJSlLL2ysLDfGOphCv8iEr/fjPgPtAHmTD6/54QQu9KsIPoec553EqDZpNqijste0tlNervc + nxYDyNADhpUA1EfPnXvux7fddk4JcbNE2D0XRIFBaVnhTjtGAoppYH5WdtP8sfY3BCBtTRdv66VhnvQa + /nfnPO/Ua4uLv2DDPLsF/Ljm3zDhB4CLtr2PiEvb1IvENTpcr89EP5G5h5AvIr08SyWy2OKbdCW8zxT8 + LA7QJwwrAQCAyvv+17xC4ZsKAAoFLRgYm/URKXAzv+ON6NIw9xUz31PXdbEy3oCZ+2km/7Fa7bVDib/P + N9zyIh/S+mm5/g1pfa0Ae83BJXyWQTUIlg75fhl6rULaHsLLdlXMUj/C9YXCtfC8d9A9DmDyeoY1YpgJ + QO45d+6JH9522z+Bbd8nAahCAX67nfirkRUQpwNFurLQMgHQo/+k/fhePsr10+IOChDGZcEiqemvBEHp + 4MrKy+8m/j519fGBHiT8y0iq/LjPvyHCf6pQeOQdIaY7wvrRd1cAjjvOm9HTJZIFHSYBrDlIOaXUu90e + I6mOagHMGEDmCvQBw0wACkDw9vLyv7ztuut+IoTYLAqFcA8gEi0MRMM1IojIIhDR4wKsz5QF/rSAHxIh + oDXdfGtvnG1gvr5AuLnnpeXlo/RZkZT2NtBZ27+EkAz4Rp8NHXq5aFmP0vfWZhYibkdsvdxsUu6ffP8m + QheGb+pds/a/0fdP/3Uu10HO9GJDurkLwC8zrBPDTgD+4/X6zB8Wi//01unp71oTE5uU68apPNLKZv06 + aWj+Rjz4x31eTQiYYEh2GxFR0Nm57PsLR8rl195NGnq4yc/7+Un4yeQn4d/wdVdNy5p+SYi92sxC5gIE + QmCu3T6xHJb+rmcN+ZpBtQHGG5j+f6b9+4BhJgAgUkx/sLx84D9J+cW7rr32WyKXm5LRPoBYmJXqGAoa + hpaiPXucKMjkh+4GmDUG3NRXUc+8I2XjeLN5hC3t4FN8aHNPBXpLbwn6PL91+c+9Yi6XeySOd8BIdyL8 + XV6oVo9FT+duTAPJFuK17CFMRTdJNn6E1VKBWQxgHRhmAogVPQD3q6XSgU84zuf/8datX7U972N8co2W + ykJnOpDn+7WdfdBTfzwzQBAAAsA73mgcfSXZ1UfuM9eS5hivEhKTv2/ac71YtKxHO9wdFgRdDoJz70jZ + jJ5ufi/KAPT189OvfF2hcAM6G4KEcWRYB4aZAIBE2FoAGq+47tlXXPc/fGli4nN3TE7+jgVs53X9vMyX + hDt+LHqcCz5ZCPEAOuY6CCHgStk4Xq8fea1SOYWEkEjwKUBGJj/X/GUkG3x4S+8VEf6VXG7Xa0LsMaso + SfglgBnH4bl//t3SzP/LgbqU9FIIF51uQIYeMSoEQLnoKoD8f3PdH8F1D/6jiYlfvmVi4oFttv1+8tH5 + FGFAr/nX+gD480QyCssHvHnPO3u60Zg51mxehF4LT3lxrh1J+Pn4blreaabMrogZO2/bj5i5f5+5AA2l + qj9oNmcQdvqZgUwy/9fvunTJzqDzzdLqATLt3wOGnQCAhARchCdDPInme677/+C6B28U4oZ7Jybu3lEs + 3rHJtq+fDmfZxYE7hSg7wCL4fBJOOQhKS+32wmKrtfB6vU7juYk7aE0V7a0nv5jWdJPQ8629pPUH2tSz + Vixa1uPc34+LnhB+yTnPO45kuAcPZtJB1X89WzBcmo1GoNVcgAzrxKgQAC9KEcZ93rxSrR86TgmOcwTR + /PodQmy6o1i8QQLWjkJhR862ixIQZL/Ou+4FAOKw4yxALxjkKfI29Fp4EgjS/KT96+jMk18Viy3n8/nd + R4Fd5P/zCkcKgv68Xn8nejq5WxT5Jxdm3cE/AGHLL7cC0i2CblWAGQn0gFEgACCxAszbfHtuA8AWRDvt + l5SqLbnuMoAcXNecYmNGl+P6IPa+JPi8Dr4eHaT9SfBJSMjXv+Jan3DWth8zg388zXnR92feDoN/UVFj + THRm7n8jySwT/D5hVAgA0EmAWwC8WGVzdJibbPgs+7Qac1P4PSRan4Sfa/8mksh4muBfFcIPAFUh9pLw + a9WOCAngYL1+FOHvwdOZ/Hv2pv0Jq8QB6BmrHBnWiVEiACAhATMiTyctCT4ts+RjrPk8e4ojcAuABJi0 + PkXCHejNMA57nLfFXnFz38QMlf4yzc/rHJpSVn/meRcR/i4mmfJYRl8tmkswZCb0fcSoEQCQCD+dRzwy + 30Co7WmENWl/En7aa0cbbulEI2uCCICOlnHQ/byS76oTfAKV/vqG4JP5/0aj8SrC3yOqBNYKf8j87zn3 + b76wi4Tzu82nZISwTowiAQC63841twtd2Ok6xQD4PkzTBaD34Tvq2+ygbMBQ7K1vWtb0i5a116x2pOKf + tlLuC45zGonvz6sZef1Cz+Z/DjjcBj7SrR8gw+AwqgRA4EQAJNYACbkp9JeKAcRVwkjIgGt6yZ5/VWM2 + n9/HBT4OAkaXZ9rtY0tKBQh/C+5Gkfnft7JlC6jwYizQJSvUyjAYjDoBEOgcImH1kZ5T7pZa4lkAPjqQ + k8tQnacXo9y/Vv3HzP/9tRoF/3jdP2l/0/zvCeb6NoWwIUgwEsgwGIwLAXCYAkuZA9OnTCMA8z2GEvP5 + /O6jQuwyo//kDiwGwdsnpHSQBP946s/U/v2AMn/c+AdXCpUgWEEn2Y7M/+NKYhwJoBvG5oSas+3HuPDH + bc7Rfa/X64eRBP/M6kZOAP0LcLJuTRjmvxeOUCNc1bGVYUPWUDGGqEbBP7PvPxACjlKVn3reApLGH9L+ + aWXMfRN+ANpAlRQpN+M55u0M60BGAGOGE8XivgCYTtviIQG82Wy+hDAoqqCnT7n539fKPx78A5KgAvVk + 1IKgZrzkqs+yDAsyAhgzLFrWo2lTf6M8qfvTMPXHg39N6Nq/P5V/DAXgMG/XJneAmrXK4Qh1MxDLSSAj + gnUiI4Axwkout6spxJ60qb+BEDjXbh9dVIoEOy3111vbbxfYQJkvYCHQtRPtNgUBeev1VV1kNSzICGCM + MJvLPWZG/uNxZ0LgJ7XaYYTmPw/+UerPDP71HWY6EOEf85aV8tCp/TMLoA/ICGCMUKKxX0b+XwKYb7cP + vxWm/gB96MegUn86UgKBAFAPgiWkd2OaxVcZ1oGMAMYEM4XCIwEw3dH6G10/2mweQ5gWVtCbfgaX+oug + DPOfgn8CwJLnnYdu+vMKzKuuu3LYkBHAmOCibT/K9xrEAz8BlJV698dJ6o8H/8yuv4FsJd4s5aH4RkQC + VJL5luPMQu/F4L0XmQXQIzICGAOs5HK7asbMfz7teMZxjiJsjAKSrj/T9x/Y0I+CUmXS+PxoSVk54PuL + 0IWfiIiPU8ssgHUiI4AxwFwuty+t7j8A0FSq9L+azZPQU39U+NPfoR9dEHv8EQmQ9r/Qah2BPt2JCMBs + uc6wTmQEMAZYtqxH+UqzePAngDnPO4JE+/vQU391bMCyEsvzDgnDAoBSzvcbjVegCz8NYeFzFTPt3wMy + AhhxnCgW93lC7JKG+R/1RTtP1euHkFT+mcE/vu57YJr2/VJWJqT8K9L+NoAj9fqTF5RqolP4iQCuyAal + UUPWDDTiuMgWfvKhHxLAYhAcXwgLf8y6fz7FmEZ+DRLq4Wr1t/+ZELd8fGLit+akzP+PVuscgJ1IOhL5 + 58oIoE/ICGCEsZLL7TogxB4z5Udtv89Uqy8hOQc86Np/o9eVqSeUKj3hOH8B4AYAt0SfhUx92q0w0JTk + uCEjgBHGbC6XjPyGbgUsB8GxN8PCn0kki1V46o9r/40QMnORahWhR1CM7qcdCwOvSBwnZAQwwljp0vgj + hcDrjcYBdKb++C6DDdX+0AmghnBYazu69JFsWWpgY4lppJERwIjiRLG4bzZl5LcEUJFy5hnPu4BwSQrV + /ZOPzc3/gaX+UkATnB2Eml9Fn8lGKOxUm0CWSWb+9wEZAYwo5m378XjopzHxZ8ZxDiPUrDTxN23g50Zr + WW4BIPrbDehjyWn8+kYS00gjI4ARxJlCYc8xYHfasE9XqZXvNJvHEa5JI+1PPf807tvFlREyIgGyBmhB + CxUDUeQ/M//7hIwARhAXbLuj8o8sgGOO8xN0an8y/YkABtf11x28tdec3Gw+lgl/n5AVAo0YmpY1XRbi + Uc3sR6j9W4DzI8eZQRj8o5FffKkpH/d9pWrseekvX8KSaf4BILMARgwnC4XHeM6fE8FZz/vbeaWo4I5S + f2bd/9UUYb8aPsNII7MARgzLlvUo7/bj+/7+vF7/BfTUH9f+G536y3AVICOAEcLxqO4/beDnQhAcmA/X + b1BajXf9Ud1/C1eP9s+wAcgIYIRAQz94+o8yAE9Xq/sRBv+AUMt3m/iTEcAYISOAEcGZQmFPk9X907Yf + CWAhCF45LKULfeAn9/0HOvEnw9WLjABGBOdzuX08+Bev/ALww2r1eSSpP6q2M1N/WXXdGCIjgBFAKZfb + VbKsR81R3wGAspSHD4ban1J/Gz7xJ8PVi4wARgDvFAqPUaWfWf33WqPxEsKOum7a/0qU/Wa4SpARwJCj + aVnTK1Hqj+f9pRCoKXXy/4ZNP7zwp4GwtZYH/zLtP6bICGDIMVMs7guo6w+Ih31IAK/W6z9GqP2p8Idr + fz7ue6PLfjNcJcgIYMixYNuPk+anrToKQEPKE9/3vHnohT/c988KfzJkBDDMOFUsPuIJsYuklzS/AvBs + tfoDABNICn942S8V/lDkP8OYIiOAIcZiLrc3XqtN67UAnGg2v/VsEKwgTP2Zvn82Vy9DjKwZaIhhA2Uu + +FLKkwcc5zt/4nllhBN1KfJPwl9BVvabgaFzH3OGYYI4WCg8NC/ExE99v/K1IAgA3AzgRgDbEPr/HoAV + ABcAnAdwEUAJyWy9zAUYY2QEMNwQCM38zQC2A7gewE0Itf+m6PEmgGUACwhJYAWhFeAiswDGHpkLMDqg + QRot6PP06wgJgAQ/K/vNECMjgOEHjcmi0d7V6HYOYZCvjtD3J7M/8/0zZMiQIQPw/wGcCGmdjgnpvgAA + AABJRU5ErkJggigAAACAAAAAAAEAAAEAIAAAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAABwAAAA0AAAASAAAAFAAAABAAAAAKAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAUAAAANAAAAGAAAACQAAAAnAAAAIwAAABcAAAAMAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAABMAAAAlAAAAOAAAAEAAAAA7AAAAKwAA + ABcAAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAGBASnQAEBQTcAAABEAAAAUwAAAFEAAABAAAAAJgAAABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYG1UMODrP/EBCq/wwMj6MAAABcAAAAYAAA + AFIAAAA3AAAAHQAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAw0NtfAPD6v/ERGi/wYGX4QAAABoAAAAYAAAAEgAAAAqAAAAEgAAAAUAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCgrDkw4Or/8QEKT/EhKT3wAA + AGgAAABoAAAAVgAAADgAAAAdAAAACgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAEBNQkDAyz/w8PqP8SEp3/CAhkkwAAAGsAAABiAAAARwAAACgAAAASAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKCsCjDQ2u/xAQ + o/8REY3VAAAAagAAAGkAAABVAAAANgAAABsAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQYG1UQMDLP/Dw+n/xERnP8GBleLAAAAbQAAAGEAAABEAAAAJgAA + ABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoK + vNENDa3/EBCg/xERi9YAAABtAAAAaQAAAFMAAAAzAAAAGAAAAAgAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAwAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBwfPYwwMs/8ODqb/EhKa/wICNnsAAABuAAAAXwAA + AEIAAAAjAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAADAAAABwAAAAoAAAALAAAACAAAAAUAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADCwu34Q0Nq/8QEJ//Dw+BxAAAAG8AAABpAAAAUAAAADAAAAAWAAAABwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAgAAAAQAAAAGAAAABoAAAAWAAAADgAA + AAcAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMiDDAyw/w8PpP8SEpj/AQEcdgAA + AG8AAABdAAAAPgAAACEAAAAMAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAFAAAAEAAAAB4AAAAtAAAAMQAAACoAAAAcAAAADQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAQE0yQLC7X/Dg6p/xERnP8NDXWyAAAAcQAAAGgAAABNAAAALQAAABQAAAAGAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAXAAAALQAAAEMAAABKAAAAQAAA + ACwAAAAWAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoKv7IMDK7/EBCh/xIS + kvUAAABxAAAAcAAAAFsAAAA7AAAAHgAAAAsAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAACgoKrIAODp7BAQEkXwAAAF4AAABVAAAAPAAAAB8AAAAMAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABBwfPVAsLs/8ODqf/ERGa/woKZqIAAAB0AAAAaAAAAEoAAAAqAAAAEgAA + AAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAMEBCq/xISn/8QEIfOAAAAbQAA + AGQAAABJAAAAKAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCgq44Q0N + q/8QEJ//EhKN6wAAAHQAAABwAAAAWQAAADgAAAAbAAAACQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQEBghwPD6j/EhKd/xMTk/8CAjCHAAAAbwAAAFMAAAAuAAAAFAAAAAUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMiDDAyx/w8PpP8SEpb/CAhZnQAAAHUAAABmAAAARgAA + ACYAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBga7Sg4Oqf8REZ3/ExOR/woK + XKwAAAB0AAAAWQAAADMAAAAXAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE + 0yQLC7X/DQ2p/xERm/8SEoTZAAAAdgAAAG8AAABVAAAAMwAAABgAAAAHAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIGBrtKDQ2r/xAQnv8TE5H/Dw9txgAAAHgAAABeAAAANwAAABoAAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJvrMMDK7/Dw+g/xMTlP8EBEGOAAAAdgAA + AGIAAABBAAAAIgAAAA0AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgYGuEsMDKz/Dw+h/xMT + kv8TE3jfAAAAewAAAGIAAAA6AAAAHAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAADAAAABAAAAAUAAAAHAAAABwAAAAcAAAAGAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABBwfOVAsLs/8ODqb/EhKY/xAQeMkAAAB4AAAAbQAAAFAAAAAuAAAAFQAAAAYAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADBQW3TAwMrv8PD6H/EhKT/xISeOAAAAB+AAAAZQAAADwAAAAdAAAACQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAGAAAACgAAAA4AAAASAAAAFQAAABgAAAAZAAAAGAAA + ABYAAAATAAAADwAAAAoAAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCgq48AwMq/8QEJ3/ExOM9gEB + GYAAAAB1AAAAXgAAADwAAAAeAAAACwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGBrNNCwuu/w4O + ov8SEpP/ExOE9wAAAIAAAABmAAAAPQAAAB4AAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAHAAAADQAA + ABQAAAAdAAAAJAAAACwAAAAwAAAAMwAAADUAAAA0AAAAMQAAACwAAAAmAAAAHgAAABYAAAAPAAAACAAA + AAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEICMWTCwuw/w8Pov8SEpX/DAxlsQAAAHoAAABqAAAASgAAACoAAAASAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAABAUFs00LC6//Dg6i/xERk/8UFIn/AAAAgAAAAGcAAAA9AAAAHgAA + AAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAEAAAACgAAABQAAAAfAAAALQAAADoAAABFAAAATwAAAFUAAABZAAAAWwAA + AFoAAABXAAAATwAAAEYAAAA8AAAAMAAAACQAAAAZAAAAEAAAAAgAAAAEAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUF1TQKCrX/DQ2o/xER + mf8TE4ftAAAAfAAAAHQAAABZAAAANwAAABoAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAEBwe8iQoK + r/8NDaP/ERGU/xMTif8AAACAAAAAZgAAAD0AAAAdAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAoAAAAXAAAAKAAA + ADsAAABOAAAAXgAAAGsAAABzAAAAeAAAAHwAAAB9AAAAfAAAAHoAAAB0AAAAbAAAAGEAAABTAAAARAAA + ADQAAAAkAAAAFwAAAA4AAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwkJvNEMDKz/Dw+f/xMTkf8JCVOjAAAAegAAAGcAAABFAAAAJAAA + AA8AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUHB7uJCgqv/w0No/8REZT/ExOK/wAAAH8AAABkAAAAOwAA + AB0AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMAAAAJAAAAFwAAACsAAABDAAAAWwcHTJMPD16+EhJh0hQUZeMVFWLkFRVf5BYW + XuQSEkrJCQkyrQAAAI8AAACJAAAAgQAAAHUAAABnAAAAVgAAAEMAAAAwAAAAIAAAABIAAAAJAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBwfKdAsL + sv8ODqX/EhKW/xEReNQAAAB+AAAAcgAAAFQAAAAxAAAAFwAAAAcAAAABAAAAAAAAAAAAAAAAAAAABQcH + vIkKCrD/DQ2j/xAQlP8TE4r/AAAAfQAAAGIAAAA5AAAAGwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAAABIAAAAmAQEtTQ0N + dq8SEoX3ExOC/xMTff8UFHr/FRV4/xYWdf8WFnL/Fxdw/xgYbf8ZGWr/GRll+RUVTdoEBB6kAAAAjwAA + AIUAAAB2AAAAZQAAAFEAAAA7AAAAKAAAABcAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAroVCgq3/wwMqf8QEJv/ExOO/wICLI4AAAB6AAAAYgAA + AD4AAAAgAAAADAAAAAIAAAAAAAAAAAAAAAAAAAAFBwe8iQoKsP8NDaT/EBCV/xMTi/8AAAB7AAAAXwAA + ADcAAAAaAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAALAAAAHRQUgm4TE5b1EBCQ/xERif8REYT/EhKB/xMTgf8TE4D/ExN+/xQU + e/8UFHb/FRVz/xcXbv8YGGv/GRlp/xoaZ/8VFUrbBAQdpQAAAI8AAACCAAAAcQAAAFsAAABEAAAALgAA + ABwAAAAOAAAABgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAIJCb+zCwuv/w4OoP8SEpP/Dw9txQAAAH8AAABuAAAATQAAACwAAAATAAAABQAAAAAAAAAAAAAAAAAA + AAUHB7yJCgqw/w0NpP8QEJX/EhJ/5wAAAHoAAABdAAAANgAAABkAAAAHAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABEXF4pVIiKo/w4O + mf8ODpP/Dw+Q/xAQjP8PD4z/EBCM/xAQi/8QEIr/ERGH/xIShP8TE3//FBR6/xUVdP8WFm7/GBhp/xoa + Zv8bG2b/ExM/zgAAAJYAAACKAAAAeQAAAGQAAABMAAAANAAAAB8AAAAQAAAABwAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQcH0GMKCrP/DQ2l/xERlv8TE4f2AAAAgQAA + AHgAAABcAAAAOAAAABsAAAAJAAAAAQAAAAAAAAAAAAAABQcHvIkKCrD/DQ2k/xAQlf8REXvfAAAAeAAA + AFsAAAA0AAAAGAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAGDQ1sJiIisecaGqf/Cwuc/wwMmv8MDJn/DAyY/wwMl/8MDJf/DAyW/w0N + lv8NDZP/Dg6R/w8Pjf8REYj/ExOC/xQUe/8VFXT/Fxds/xkZZ/8aGmX/GRlW7QcHJa0AAACQAAAAgAAA + AGoAAABRAAAANwAAACEAAAARAAAABwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABAkJuPAMDKv/EBCc/xMTjv8LC1evAAAAfgAAAGgAAABFAAAAJAAAAA4AAAADAAAAAAAA + AAAAAAAFBwe8iQoKsP8NDaX/ERGV/xERfN8AAAB2AAAAWQAAADMAAAAXAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgbG7eEISG0/xUV + q/8JCaT/CQmj/wkJov8KCqD/Cgqf/woKnv8KCp7/Cgqd/woKnP8LC5r/DAyX/w0Nk/8PD4//ERGJ/xMT + gf8UFHj/FhZw/xgYaf8aGmX/Gxtg+Q0NL7wAAACUAAAAgwAAAG4AAABUAAAAOQAAACIAAAAQAAAABwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCAjCowsLsP8ODqD/EhKS/xMT + feYAAACCAAAAcwAAAFIAAAAuAAAAFAAAAAUAAAAAAAAAAAAAAAUHB7yJCgqw/w0NpP8REZb/ERF83wAA + AHUAAABWAAAAMQAAABUAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACB8fvMsfH7j/ExOx/wgIqv8ICKr/Bweo/wgIpf8ICKT/Bwej/wgI + o/8ICKL/CAih/wkJoP8JCZ7/Cgqc/wwMmP8NDZP/Dw+O/xERhf8TE37/FRV0/xgYbP8ZGWX/Gxtj/xMT + Pc8AAACWAAAAhgAAAHAAAABVAAAAOQAAACEAAAAPAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEGBs9UCgqz/w0Npf8REZb/FBSK/wICK5EAAAB5AAAAXAAAADYAAAAZAAAABwAA + AAAAAAAAAAAABQcHu4kKCrD/DQ2k/xERlv8REXzeAAAAcwAAAFMAAAAvAAAAFAAAAAUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJHh6//x4e + u/8TE7X/Bgaw/wYGrv8HB6v/Bweo/wcHpv8GBqb/Bwem/wcHpv8HB6X/Bwek/wgIo/8ICKH/CQmf/woK + nP8MDJf/Dg6R/xAQiv8TE4D/FBR2/xcXbf8ZGWb/Gxtj/xUVSNsAAACXAAAAhwAAAG8AAABTAAAANgAA + AB4AAAANAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQJCbbhDAyo/xAQ + mP8TE4z/EBBoyAAAAHwAAABiAAAAOwAAAB0AAAAJAAAAAAAAAAAAAAAFBwe7iQoKsP8NDaT/ERGW/w0N + ab0AAABwAAAAUQAAACwAAAATAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgeHsL/HR29/xISuP8GBrT/Bgax/wYGrf8GBqr/Bgao/wYG + p/8GBqf/Bgan/wYGp/8GBqb/Bwem/wcHpf8HB6P/CAih/woKnv8LC5r/DQ2U/xAQjf8SEoP/FBR4/xcX + bf8YGGb/Gxtj/xUVR9sAAACWAAAAhQAAAG0AAABPAAAAMgAAABsAAAALAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwgIvZYMDKn/Dw+a/xISjv8TE37vAAAAfAAAAGIAAAA7AAAAHQAA + AAkAAAAAAAAAAAAAAAUHB7uJCwuv/w0NpP8QEJb/DQ1qvAAAAG4AAABOAAAAKgAAABIAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxwc + xP8cHMD/FRW8/wUFtv8FBbP/Bgau/wYGqv8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgam/wcH + pv8HB6T/CAii/wkJn/8KCpz/DAyW/w8Pjv8SEoT/FBR4/xYWbv8YGGb/Gxtj/xUVR9sAAACVAAAAggAA + AGgAAABKAAAALQAAABYAAAAIAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBASoQAsL + qf8ODpv/EhKP/xQUiP8EBD6SAAAAXgAAADcAAAAaAAAACAAAAAAAAAAAAAAABQcHu4kLC6//DQ2k/xER + lv8NDWq8AAAAbQAAAEwAAAApAAAAEQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFHBzF/xwcwv8aGr//BQW3/wUFtP8FBa//Bgar/wYG + qP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6X/Bwej/wgIof8KCpz/DAyW/w8P + j/8SEoT/FBR5/xYWbv8ZGWb/Ghpj/xAQM8IAAACSAAAAfgAAAGIAAABDAAAAJwAAABIAAAAGAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAZCwuo/w4Om/8SEo//ExOJ/wEBHH4AAABVAAAAMAAA + ABUAAAAFAAAAAAAAAAAAAAAFBwe7iQsLr/8ODqT/ERGV/wwMZLMAAABtAAAATAAAACkAAAAQAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAMcHMnWHBzE/xwcwf8HB7v/BQW2/wUFsf8GBqz/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGpv8HB6X/Bwej/wgIof8KCp3/DAyX/w4Oj/8SEoT/FBR4/xcXbf8ZGWb/Gxtk/woK + KbUAAACPAAAAeAAAAFoAAAA7AAAAIAAAAA0AAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADAYG + oWYLC6b/Dg6Z/xERj/8TE4LvAAAAbQAAAEoAAAAoAAAAEAAAAAMAAAAAAAAAAAAAAAUHB7uJCwuu/w4O + o/8REZX/BgZKmgAAAG0AAABNAAAAKgAAABEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARsbzqkcHMT/HBzC/w4OvP8FBbf/BQWz/wYG + rf8GBqr/Bgao/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpv8HB6b/Bwek/wgI + of8KCp3/DAyX/w8Pj/8SEoP/FBR4/xcXbv8ZGWb/Gxtg+QQEHKYAAACKAAAAcQAAAFEAAAAxAAAAGAAA + AAgAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAASCQmnrwsLo/8ODpf/ERGP/w8Pcs4AAABkAAAAPwAA + ACAAAAALAAAAAQAAAAAAAAAAAAAABQcHu4kLC67/Dg6j/xERlP8GBkicAAAAcAAAAFAAAAAsAAAAEwAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABGBjWWRwcx/8cHMP/GhrA/wUFuf8FBbT/BQWw/wYGq/8GBqn/Bgao/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6b/Bwek/wgIof8KCp3/DAyW/w8Pjv8SEoP/FBR2/xgY + bP8aGmX/GRlW7QAAAJYAAACDAAAAZgAAAEQAAAAmAAAAEAAAAAUAAAABAAAAAAAAAAAAAAABAAAACAAA + ABoKCqfyDQ2e/w8Plf8REY3/CAhVoAAAAFgAAAA0AAAAGAAAAAcAAAABAAAAAAAAAAAAAAAFBwe7iQsL + rv8ODqH/EhKT/wYGSJ0AAABzAAAAVQAAADAAAAAVAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGxvJ8Rwcxf8cHMP/Cwu9/wUF + t/8FBbL/Bgat/wYGqv8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8HB6b/Bwek/wgIof8KCpz/DQ2V/xAQjP8TE4D/FRV0/xgYaf8bG2T/ExM/zgAAAJEAAAB4AAAAWQAA + ADcAAAAbAAAACgAAAAIAAAAAAAAAAAAAAAMAAAAOBwejdgsLpv8NDZz/EBCS/xISjf8AAABtAAAASwAA + ACkAAAARAAAABAAAAAAAAAAAAAAAAAAAAAUHB7uJCwuu/w4Oof8SEpL/DQ1lvwAAAHcAAABaAAAANAAA + ABgAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEaGtKoHBzI/xwcxP8VFcD/BQW6/wUFtP8FBbD/Bgas/wYGqf8GBqj/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/Bwej/wkJoP8LC5v/DQ2T/xAQ + iv8TE37/FhZw/xkZZ/8bG2X/BAQdpgAAAIcAAABrAAAASQAAACkAAAAS/////wAAAAEAAAAAAAAABQAA + ABUJCae9DAyi/w0NmP8QEJD/Dw951gAAAGIAAAA+AAAAHwAAAAsAAAABAAAAAAAAAAAAAAAAAAAABQcH + u4kLC67/Dg6h/xISkf8ODmPBAAAAfAAAAGEAAAA6AAAAHAAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQU3iYcHMr/GxvF/xwc + xP8MDL3/BQW3/wUFsv8GBq7/Bgaq/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGpv8HB6X/CAij/wkJn/8LC5r/Dg6R/xERhf8UFHn/Fxdt/xoaZv8YGFLnAAAAkgAA + AHsAAABaAAAAOAAAABsAAAAKAAAAAQAAAAEAAAAKAwOAOAsLqf8MDJ//Dg6V/xERj/8ICFagAAAAVQAA + ADIAAAAXAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAEBwe8iQsLrv8ODqH/EhKR/xERa9EAAACCAAAAaAAA + AEIAAAAiAAAADAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAARoa0qgbG8n/GxvE/xkZwf8GBrn/BQW2/wUFsf8GBqz/Bgaq/wYG + qP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpv8HB6X/CAii/woK + nv8MDJf/Dw+O/xMTgf8VFXT/GBhp/xoaZv8KCiyzAAAAhwAAAGsAAABIAAAAJwAAABAAAAAEAAAAAwAA + AA8ICKaECwum/w0Nm/8PD5P/ERGK9wAAAGsAAABIAAAAJwAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAQHB7yJCwuw/w4Oov8SEpL/ExN46QAAAIcAAABxAAAATAAAACoAAAARAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBTeJhwc + y/8bG8f/HBzE/xMTwP8FBbj/BQWz/wUFsP8GBqz/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6T/CAih/woKnP8NDZT/EBCK/xMTfP8XF2//GRln/xcX + VOcAAACRAAAAeAAAAFcAAAAzAAAAGAAAAAgAAAAHAAAAFQoKq+UMDKL/DQ2Z/xAQkv8PD3bNAAAAXgAA + ADsAAAAdAAAACgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAwcHv4gKCrL/DQ2l/xERlP8UFIb/AAAAjAAA + AHoAAABXAAAAMwAAABcAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHh7Vix8fyv8dHcX/HBzD/w4Ovf8FBbf/BQWy/wUF + r/8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcH + pv8HB6P/CQmf/wsLmf8ODpD/EhKD/xQUdv8XF2v/Ghpn/woKLrEAAACDAAAAZQAAAEAAAAAhAAAADQAA + AAsFBZZFCwuq/wwMoP8ODpb/EBCQ/wQEQ4wAAABRAAAALgAAABUAAAAGAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACBwfEhgoKtf8MDKj/EBCX/xMTiP8JCUayAAAAggAAAGQAAAA/AAAAIQAAAAwAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADJCTP1iQkyv8hIcf/Hx/D/w4OvP8FBbb/BQWx/wYGrv8GBqv/Bgap/wYGqP8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgam/wcHpf8ICKH/Cgqd/w0Nlf8QEIv/ExN9/xcX + b/8ZGWn/FhZR4QAAAIwAAABwAAAATAAAACkAAAATAAAAEAkJqZ4LC6f/DQ2d/w8Plf8REYjuAAAAZwAA + AEQAAAAkAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEHB8qECQm4/wsLrf8PD5v/ExOM/xAQ + Yc0AAACIAAAAcAAAAE0AAAAsAAAAFAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEnJ+I6LCzO/ygoyv8oKMX/JibE/xAQ + vP8FBbb/BQWy/wYGrv8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bwem/wcHpP8JCaD/Cwua/w4OkP8SEoP/FRV2/xgYbf8ZGWv/AQETmAAAAHgAAABVAAAAMAAA + ABkAAAAVCgqq5AsLpP8NDZv/Dw+T/wsLZ7EAAABbAAAANwAAABsAAAAIAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQUF00QICLv/Cgqx/w0Nov8SEpL/ExOB9wAAAIsAAAB7AAAAXAAAADoAAAAdAAAACgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAExMd5wMDDO/y4uyv8tLcj/KyvF/xMTvf8FBbb/BQWy/wYGrv8GBqv/Bgap/wYG + qP8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bwel/wgIof8KCpz/DQ2U/xAQ + iv8UFHv/FhZw/xgYbP8ODj69AAAAfwAAAF0AAAA2AAAAHgMDfzcLC6n/DAyi/w4Omf8REZL/AgIzgQAA + AFAAAAAtAAAAFAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPbIwcHv/8JCbb/DAyp/xAQ + mf8TE4v/CQlLrAAAAIIAAABrAAAASgAAACoAAAASAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzM9evNDTP/zMz + zP8yMsr/MDDI/xcXv/8FBbb/BQWy/wYGrv8GBqv/Bgaq/wYGqP8GBqj/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8HB6b/Bwej/wkJn/8MDJj/Dw+P/xMTgf8VFXX/Fxdu/xMTU9kAAACDAAAAYwAA + ADoAAAAiBweeZAsLpv8MDKD/Dw+Y/w8PfNUAAABrAAAASQAAACcAAAAQAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABBgbLoggIuv8KCq//Dg6g/xISkv8TE3neAAAAggAAAHYAAABaAAAAOQAA + AB0AAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI5OdbMOjrQ/zg4zv83N8v/NTXJ/yIiwf8FBbb/BQWy/wUF + r/8GBqz/Bgaq/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/CAih/wsL + m/8ODpL/EhKF/xQUef8XF3H/Hh5t8wAAAIUAAABmAAAAPQAAACQKCqGQDAyk/w0Nnf8QEJX/CgpdqgAA + AGkAAABGAAAAJQAAAA4AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAs8TBwfB4AkJ + tv8MDKn/EBCb/xMTj/8GBkicAAAAewAAAGgAAABKAAAAKgAAABMAAAAGAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMz + 2Bg+PtXbPz/R/z4+z/89Pc3/OzvL/y8vxP8ODrj/BQWz/wUFsP8GBq3/Bgar/wYGqf8GBqj/Bgao/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8ICKL/Cgqc/w0Nlf8REYj/FBR8/xcXdP8qKn//AAAAiAAA + AGkAAABAAAAAJwsLn6wMDKD/Dg6Z/xAQjfYBARuCAAAAbAAAAEoAAAAoAAAAEAAAAAMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEBNszCAi8/wsLsf8ODqP/ERGW/xISf9sAAAB6AAAAcwAA + AFoAAAA7AAAAHwAAAAwAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMz2BhCQtbbRETS/0NDz/9BQc3/Pz/K/zs7 + yP8gIL//BQW0/wUFsv8FBa//Bgas/wYGqv8GBqn/Bgao/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgam/wcH + o/8KCp7/DAyX/xAQi/8VFYD/JiZ//ywsgP8AAACLAAAAbgAAAEgAAAAuDAycyQ0NnP8PD5X/ERGK9gAA + AH0AAABxAAAAUQAAAC4AAAAUAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEGBtRjCQm4/wwMrP8PD6D/ExOT/wcHTZUAAAB3AAAAaQAAAE0AAAAuAAAAFgAAAAcAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADAAAABQAAAAcAAAAGAAAABAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAATMz2BhDQ9m0SkrT/0hI0f9HR87/RETN/0NDzP87O8j/Gxu9/wUFs/8FBbH/Bgau/wYG + rP8GBqv/Bgaq/wYGqf8GBqj/Bgao/wYGqP8GBqj/Bwel/wkJn/8MDJj/ExOP/ywsjv8xMYb/MDCD/wAA + AI4AAAB1AAAAUwAAADsNDZLMDg6W/xAQkP8TE4j/BQU3mQAAAHgAAABbAAAANgAAABkAAAAIAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMeiCgq0/w0NqP8REZr/EhKE2AAA + AHUAAABzAAAAXwAAAEAAAAAjAAAADwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAoAAAAQAAAAFAAA + ABQAAAAQAAAACgAAAAUAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJFRdqnUFDU/05O + 0v9LS9D/S0vP/0lJzf9HR8v/PT3H/yAgvf8NDbT/BQWx/wUFr/8GBq3/Bgas/wYGq/8GBqr/Bgaq/wYG + qv8HB6f/ERGm/yUlp/81NaL/NjaW/zY2jP82Noj/AAAAkQAAAH0AAABiAAAATwwMfrAPD5D/ERGK/xMT + gv8ODlK8AAAAgAAAAGYAAABAAAAAIQAAAAwAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMJCb3RCwuv/w8Pof8TE5X/CgpgpQAAAHgAAABuAAAAVAAAADQAAAAZAAAACQAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAAIAAAAEgAAAB8AAAApAAAAKwAAACYAAAAcAAAAEgAAAAkAAAAFAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFEROFmUlLV9VNT1P9RUdL/UFDQ/05Ozv9MTM3/S0vM/0pK + yv87O8T/Kiq9/xwcuf8UFLX/ExOz/xQUsv8bG7T/JCS2/zU1uf85Obj/Ojqz/zs7qv88PKD/PT2T/zY2 + i/8JCTCuAAAAhQAAAHQAAABoDAxosg8Pi/8SEoX/FBR9/xMTYdwAAACHAAAAcQAAAEwAAAAqAAAAEgAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUF2DMLC7LwDg6l/xER + mP8TE4j1AQEZgQAAAHkAAABmAAAARgAAACcAAAARAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAwAAAAbAAAALgAA + AD4AAABFAAAAQQAAADUAAAAnAAAAGgAAABAAAAAIAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAFCQuMtVlbax1hY1v9WVtT/VVXS/1NT0P9RUc//UFDO/05Ozf9MTMv/TEzK/0pKyf9ISMf/RkbH/0RE + xP9CQsT/QUHC/0FBv/9AQLr/QUGy/0FBqf8+Ppz/GhqC/xISZeQAAACMAAAAgwAAAH4ICDufEBCF/xIS + gv8VFXj/Fxdy/wAAAI8AAAB7AAAAWgAAADgAAAAdAAAACgAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAwoKu4UNDab/EBCY/xMTjP8REWfEAAAAgQAAAHUAAABZAAAANgAA + ABoAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAADQQElkcAAAA0AAAASQAAAFUAAABXAAAATgAAAEEAAAAzAAAAJQAA + ABkAAAAQAAAACAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSkriaFlZ1+pcXNb/WlrU/1dX + 0v9WVtH/VVXQ/1RUz/9SUs7/UFDN/05OzP9MTMv/TEzK/0pKyf9ISMf/R0fD/0ZGv/9GRrr/Rkay/yAg + mP8REYX/Dw9d1gsLQboPD4L/Dg59+AgIMK4PD4T/EhJ//xUVdf8XF2//DAw2twAAAIYAAABrAAAASwAA + AC4AAAAYAAAACwAAAAUAAAADAAAAAgAAAAQAAAAGAAAACAAAAAoAAAALAAAADQAAAA4AAAAPAQFsIw0N + o/EQEJj/ExOL/xUVgf8FBTWdAAAAgQAAAGgAAABEAAAAJAAAAA4AAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAILC8KjDg60/w8P + q+UFBXRyAAAAUwAAAFwAAABcAAAAVgAAAEwAAAA/AAAAMQAAACQAAAAZAAAAEAAAAAoAAAAFAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAA01N3ntcXNjrYGDW/15e1f9cXNT/WlrR/1hY0f9WVs//VlbP/1RU + zv9SUsz/UFDL/09Pyv9NTcj/TU3E/0xMwP8jI6z/DAyb/w4OkP8EBCGaDg6I/w4OiP8ODof/DQ2B+Q8P + fvkSEoD/FBR2/xcXbv8UFEvaAAAAkQAAAH0AAABiAAAARgAAAC4AAAAcAAAAEgAAAA0AAAANAAAAEQAA + ABUAAAAaAAAAHgAAACEAAAAjAAAAJAAAACYAAAApDAyVsw8Plf8TE4r/FRWB/xQUa+IAAACIAAAAcQAA + AE0AAAAqAAAAEgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQsLw8EMDLj/DQ2y/w8Pq/8ODpzEAgJFZAAAAFgAAABbAAAAWgAA + AFQAAABKAAAAPgAAADIAAAAmAAAAGwAAABMAAAAMAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA + AANMTN9pVlbYu2Bg1fZiYtT/YGDT/15e0f9cXM//W1vO/1lZzP9XV8z/VlbL/1RUyv9OTsX/FBSx/wkJ + qf8KCqP/CwuD1A0Nmf8MDJX/DQ2U/wwMkv8NDZD/Dg6M/xERhv8TE3n/FhZu/xkZY/kCAhCgAAAAjQAA + AHoAAABkAAAATAAAADcAAAAoAAAAIQAAACMAAAAoAAAAMAAAADcAAAA8AAAAQAAAAEQAAABGAAAARwAA + AEoJCXCSDw+S/xISi/8UFIL/FhZ+/wcHQKYAAABzAAAATwAAACwAAAATAAAABAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQXhMgsL + v+AMDLj/DQ2y/w4OrP8QEKb/Dg6XuAICRWQAAABXAAAAWgAAAFkAAABTAAAASwAAAEAAAAA1AAAAKgAA + AB8AAAAWAAAADwAAAAkAAAAFAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABUhI1VpQUNKfVlbPvVlZ + zNdYWMjYV1fI2FVVx9hRUcXMR0e/pBMTsdcGBq3/Bweq/wYGeo0KCqD2Cwuj/wsLoP8LC5z/Cgqa/wwM + mP8NDYX0EBCL/xMTgP8UFHP/GBhp/xMTOs8AAACaAAAAjwAAAH4AAABrAAAAVwAAAEcAAABAAAAAQgAA + AEoAAABVAAAAXgAAAGQAAABoAAAAawAAAG0AAABvAAAAcAYGSZcODpD/ERGM/xMThv8VFYL/ExNw2AAA + AGkAAABHAAAAJgAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgYG1kQLC77CDAy0/w0Nr/8PD6r/EBCl/wwM + kaACAkVjAAAAVQAAAFkAAABZAAAAVQAAAE8AAABFAAAAOgAAADAAAAAkAAAAGwAAABQAAAANAAAACAAA + AAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMAAAAHAAAADAAAABIAAAAXAAAAHQAAACIAAAAkAAAAJQAAACQAAAAhAAAAHgQE + lFkGBqS9Bwen8wgIq/8ICKr/CQmo/wkJpf8KCqL/Cgqf/wsLg+4ODoP0ERGH/xMTev8VFW3/GBhn/xkZ + XPMPDzXBAAAAkgAAAIUAAAB2AAAAaQAAAGQAAABoAAAAbwAAAHgAAAB/BQU0mwcHPaUHBz2mBgY9qAYG + PqgGBj+oCQlavQ4Okv8QEJD/EhKM/xMTiP8SEn7bAAAAVwAAADgAAAAdAAAADAAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIGBtVECwu9wgwMs/8ODq//Dw+q/xAQpf8ODpi3AgJGYgAAAFUAAABaAAAAXAAA + AFoAAABVAAAATAAAAEIAAAA3AAAALAAAACEAAAAZAAAAEgAAAAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAYAAAAKAAAAEAAAABcAAAAfAAAAJwAA + AC8AAAA1AAAAOgAAADwAAAA9AAAAOwAAADcAAAAxAAAAMB0dsP8GBqn/CAis/wcHrf8ICKz/Bwep/wgI + pv8REaX/GRmk/wwMl/8PD4//EhKC/xQUd/8WFm3/GBho/xkZZ/8VFUnbAAAAmAAAAI8AAACHDQ1IsRMT + XtEUFHHwFRV8/xUVfP8UFH3/ExOC/xERiP8QEI3/DQ2S/wwMk/8MDJX/DQ2U/w4Olf8REZH/EhKR/xAQ + hcAAAAA+AAAAJgAAABIAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACBgbVRAsL + vcIMDLT/DQ2v/w4Oqv8QEKb/Dw+dzwgIdoMAAABWAAAAXQAAAGEAAABgAAAAXAAAAFUAAABLAAAAPwAA + ADQAAAApAAAAHwAAABcAAAAQAAAACgAAAAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAACAAAABQAA + AAgAAAAOAAAAFAAAAB0AAAAmAAAAMQAAAD0AAABIAAAAUwAAAFsAAABiAAAAZAAAAGUAAABjAAAAXgAA + AFcAAABRS0u7/xgYrf8HB6z/Bwev/wcHrv8GBqv/JCSy/zU1tP8JCaL/Cgqd/w0Nlf8PD4z/EhKB/xMT + ef8VFXH/FhZt/xcXa/8SEj3QEBA6yBUVbfkUFHb/ExN6/xMTfv8TE4D/ExOD/xIShf8REYr/Dw+Q/w4O + lv8MDJn/Cwub/wsLmv8MDJr/DQ2a/w8Pmf8REZj0AQE2RQAAACUAAAAVAAAACQAAAAMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgYG1UQKCsGkDAy0/w0NsP8ODqv/EBCm/w8P + n+cLC4mmAgI+bQAAAGIAAABmAAAAZwAAAGQAAABdAAAAVAAAAEkAAAA9AAAAMQAAACcAAAAeAAAAFgAA + ABAAAAAKAAAABwAAAAUAAAAGAAAACAAAAA0AAAATAAAAGgAAACMAAAAuAAAAOgAAAEcAAABUAAAAYAAA + AGsAAABzAAAAeAAAAHoAAAB8AAAAfAAAAHwAAAB6AAAAdgAAAHNJSabdWlrA/0xMwf8xMbz/MDC8/0ZG + wP87O7v/DAyp/wgIpP8JCaH/Cgqb/w0Nlf8PD47/ERGF/xMTfv8TE3f/FBR0/xMTdP8TE3f/ExN5/xIS + ff8REYP/EBCH/w8Piv8PD4//Dg6S/w0Nlv8NDZr/DAyf/woKoP8KCqH/Cgqg/wsLof8NDaL/Dg6h5gUF + fFQAAAAeAAAAEgAAAAkAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIEBNQkCgrDowwMtf8NDbD/Dg6s/w8Ppv8QEKH/Dw+U0wkJcpkBAR9uAAAAawAA + AG0AAABrAAAAZgAAAF4AAABTAAAASAAAADwAAAAwAAAAJgAAAB0AAAAXAAAAFAAAABUAAAAbAAAAIgAA + ACwAAAA3AAAAQwAAAFAAAABeAAAAaQgIVp8MDHHFEBCD5xERkP8REZD/ERGQ/xERkP8PD4nvDAx2zwcH + WbECAiuSAAAAgwwMIo5UVK7pY2PH/2Bgyv9TU8X/ICC1/wcHq/8HB6j/Bwem/wgIo/8JCaD/Cgqc/wwM + l/8ODpL/Dw+L/xAQhv8REYT/ERGC/xERg/8REYX/Dw+I/w8Pi/8ODo7/DAyS/wwMlv8LC5n/Cwue/woK + of8KCqT/CQmm/woKp/8KCqj/Cwun5QkJo5QAAAAdAAAAFAAAAAwAAAAGAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBATUJAoK + w6MMDLX/DAyx/w4Oq/8PD6b/EBCh/xISmfQPD4XCCAhglwAAAG8AAABzAAAAcwAAAG8AAABoAAAAXgAA + AFMAAABGAAAAOwAAADIAAAAuAAAAMAAAADcAAABBAAAATQAAAFoAAABmBARBiw0NccQREYbvERGP/xAQ + kP8QEJL/EBCT/w8PlP8PD5X/Dw+V/w8Pl/8ODpj/DQ2Z/wsLmv8JCZLvBwd1yQICOZ0MDCGTExNTrQYG + r/8GBq3/Bgar/wYGqf8HB6j/Bwem/wgIo/8ICKH/Cgqd/wsLmv8MDJf/DQ2T/w4Okf8ODpD/Dg6P/w4O + jv8ODo3/DAyO/wwMkP8LC5P/CwuY/wsLnP8KCqH/CQml/woKqP8KCqnyCQmorgcHoWUAAAAXAAAAEQAA + AAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQE1CQJCcSjCwu2/wwMsf8NDav/Dg6m/xAQ + of8REZz/EhKS9Q4Oeb0EBEKMAAAAdwAAAHkAAAB3AAAAcQAAAGkAAABfAAAAVwAAAFIAAABVAAAAXAAA + AGYBARx3CwtlshAQgucREY7/EBCQ/w8Pkv8PD5T/Dg6W/w4Omf8NDZz/DQ2e/w0NoP8NDaH/DAyj/wwM + o/8LC6P/Cgqj/wkJpP8ICKX/Bwep/wcHo+8GBqXwBgax/wYGr/8GBqz/Bgaq/wYGqf8HB6f/Bwel/wcH + o/8ICKL/CQmg/woKnv8KCpz/Cwub/wsLmv8LC5b/DAyT/wsLjf8LC4z/CwuL/wsLjv8LC5P/CwuV6AoK + mMAJCZqFBQWOSAAAABcAAAATAAAADwAAAAsAAAAIAAAABQAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEEBNojCQnFkwoKt/ALC7L/DQ2t/w4Op/8PD6D/ERGb/xISlv8SEorsDw9xwgQE + PZMAAAB+AAAAfQAAAHoAAAB2AAAAdQEBGn0KCl2qDw951hERj/8QEJD/Dw+S/w4OlP8ODpf/DQ2Z/w0N + nf8MDKH/Cwuk/wsLqP8LC6fYCgqt/woKrv8JCa//Cgqv/wkJrv8ICK7/Bwev/wcHsP8GBrH/Bgaz/wUF + s/8GBrT/Bgaw/wYGrv8GBqv/Bgap/wYGqP8GBqb/Bwem/wcHpf8HB6T/CAii/wgIof8JCaD/Cgqe/woK + mv8LC5L/CwuJ/woKXNsKClDKBwc7oQEBHXEAAABMAAAANAAAACQAAAAbAAAAFwAAABYAAAAVAAAAFAAA + ABIAAAAPAAAACwAAAAcAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLEFAgI + yYQKCrjwCwuz/wwMrv8NDaj/Dw+i/xAQm/8SEpb/EhKR/xIShOUMDGG2AgIsjwgIT6kPD3fYERGO/xER + kP8QEJL/Dw+V/w4Ol/8NDZr/DAyd/wwMoP8LC6T/Cwuo/wsLqNgICKWFAwOBOQAAABUAAAAQBQW/SggI + wJYHB7zSCAi6/wcHuf8GBrn/Bga4/wYGt/8FBbf/BQW3/wUFtv8GBrT/BQWx/wYGrf8GBqr/Bgap/wYG + qP8GBqf/Bgam/wcHpv8HB6X/Bwek/wgIov8ICKH/Cgqa/wsLkf8MDIX/DAxV3AAAAJoAAACLAAAAdQAA + AFwAAABGAAAANQAAAC4AAAAsAAAALAAAAC0AAAAtAAAAKgAAACUAAAAfAAAAFwAAAA8AAAAIAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQICzhMICM10CQm74QoKtP8MDK//DAyp/w4O + pP8PD57/EBCa/xAQl/8QEJb/EBCV/xAQlf8PD5b/Dg6X/w0Nm/8MDJ7/DAyh/wsLpP8LC6j/Cgqp5QkJ + qaEEBJJJAAAAFwAAABAAAAAKAAAABgAAAAMAAAACAAAAAgAAAAMBAbEWBQXNZgUFxLQFBb//BQW9/w8P + vP8EBLn/BQW4/wUFt/8FBbP/BQWw/wYGrP8GBqr/Bgao/wYGp/8GBqf/Bgan/wYGp/8HB6b/Bwek/wgI + of8KCpv/DAyP/w0Ng/8PD3r/Dw9S2wAAAJcAAACJAAAAdgAAAGQAAABXAAAAUAAAAE8AAABQAAAAUQAA + AFAAAABNAAAARgAAAD0AAAAxAAAAJAAAABgAAAAOAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAABAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAHAAAABQAAAAQAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADBwfQZAkJvOEKCrb/Cgqx/wsLrf8MDKn/DQ2m/w0NpP8NDaL/DAyh/wwM + of8MDKL/Cwul/wsLqP8KCqnyCQmprwYGpGYAAAAYAAAAEQAAAAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAAgICuhUEBMx2FhbC8RISv/8EBLv/BQW5/wUFt/8FBbH/Bgau/wYG + qv8GBqn/Bgao/wYGp/8GBqf/Bgan/wcHpv8HB6T/CAih/woKmv8MDJD/Dg6D/xERef8SEnP/ERFP2wAA + AJgAAACOAAAAgwAAAHoAAAB0AAAAcgAAAHEAAABwAAAAbgAAAGsAAABmAAAAXgAAAFIAAABCAAAAMQAA + ACIAAAAUAAAACwAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIAAAADAAAABQAAAAcAAAAIAAAACwAAAA4AAAAQAAAAEwAAABUAAAAXAAAAFwAA + ABYAAAAUAAAADgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwYG + 0lQICMDCCQm4/wkJtf8KCrP/Cgqx/woKr/8KCq3/Cgqt/woKrfIJCauvBgalZQAAABgAAAASAAAADAAA + AAcAAAAEAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAIgINOMHh7F/xAQv/8EBLr/BQW4/wUFtP8FBa//Bgas/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bwem/wcH + pP8ICKH/Cgqc/wwMk/8PD4f/ERF9/xISdf8UFHD/ExNL3AcHIa4KCi2wDw9GwRAQUcYQEFbEDw9awQ8P + X74KClCjAQEafgAAAHUAAABzAAAAbAAAAGEAAABRAAAAPgAAACwAAAAbAAAAEAAAAAgAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAEAAAABQAAAAgAAAAKAAAADQAAABEAAAAUAAAAGAAA + ABwAAAAgAAAAJAAAACgAAAAsAAAALwAAADEAAAAyAAAALgAAACYAAAAcAAAAEAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIFBdY0CAjDpAgIvPAJCbr/CQm44ggI + tpsGBq9hAAAAFQAAABAAAAALAAAABwAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEh0xYqKsvyJCTF/xkZvv8MDLj/BQW0/wUF + sf8GBq3/Bgaq/wYGqf8GBqj/Bgao/wYGqP8GBqb/Bwel/wgIov8JCZ3/CwuX/w4Ojv8QEIP/EhJ7/xMT + df8UFHP/FRVz/xUVcv8VFXX/FRV2/xUVeP8UFHz/FBSA/xQUg/8VFYb/ERFzyQMDMIUAAAB2AAAAdQAA + AGwAAABcAAAASgAAADYAAAAkAAAAFgAAAAwAAAAHAAAABAAAAAQAAAAFAAAABwAAAAgAAAALAAAADgAA + ABIAAAAVAAAAGgAAAB8AAAAjAAAAKQAAAC4AAAA0AAAAOQAAAD8AAABEAAAASQAAAE0AAABQAAAAUQAA + AE8AAABIAAAAOwAAACoAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAUAAAAHAAAACAAAAAcAAAAFAAAAAwAAAAEAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAS0t218vL8n/KSnB/yMjvf8cHLr/ERG0/wUFr/8GBqz/Bgaq/wYGqf8GBqn/Bgap/wYG + qP8HB6b/Bwej/wkJoP8KCpv/DAyV/w4Ojf8QEIb/EhKB/xMTfv8UFHz/FBR6/xQUe/8TE3r/ExN7/xMT + fv8TE4T/ExOJ/xMTjf8TE47/ExON/w8Pc78BARp+AAAAeAAAAHMAAABmAAAAVQAAAEAAAAAuAAAAIAAA + ABcAAAATAAAAEgAAABQAAAAXAAAAGwAAACAAAAAlAAAAKgAAADAAAAA2AAAAPQAAAEQAAABLAAAAUgAA + AFkAAABeAAAAYwAAAGYAAABoAAAAaAAAAGcAAABkAAAAXwAAAFMAAABDAAAAMAAAABsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABS4uyHk0NMP/Li6+/yoq + vP8kJLv/GRm2/wkJrv8GBqz/Bgas/wYGq/8GBqv/Bgaq/wcHqP8HB6X/CAii/wkJn/8KCpv/DAyX/w4O + kv8PD43/EBCJ/xERiP8SEoX/EhKB/xISfv8SEn3/EhKB/xAQiP8QEJD/EBCV/xAQl/8SEpb/ExOT/xMT + h+wHB02VAAAAeQAAAHcAAABuAAAAXwAAAE0AAAA9AAAAMQAAACwAAAAsAAAALgAAADMAAAA5AAAAPwAA + AEYAAABNAAAAVQAAAFwAAABiAAAAaAAAAGwAAABwAAAAcwQEQY4GBk6XDAxvuQwMcbgPD3zIERGH2RER + i9gREZDWCgqHmgAAADsAAAAoAAAAFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAHAAAAFxgYr6szM77/NTW+/y4uvP8pKbr/ISG1/woKrv8FBa7/BQWu/wYG + rf8GBqz/Bgar/wcHqP8HB6X/CAii/wkJoP8KCp3/Cwua/wwMl/8NDZT/Dg6R/xAQjP8REYb/Dw9e4ggI + L7AGBjKYAAAAYggIZ3EPD5nkDg6d/w8Pnf8REZn/EhKU/xMTjf8QEHC+AQEafgAAAHkAAAB1AAAAagAA + AF4AAABUAAAATwAAAE8AAABTAAAAWQAAAF4AAABkAAAAaQAAAG4AAABxAgIvhggIVqENDWy7EBB61RIS + h+4SEpD/EhKS/xISk/8REZX/ERGW/xISmP8SEpr/EhKd/xISof8REaPyAAAAKAAAABsAAAAOAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAA + AAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAsCAnw6BQWw8woK + r/8mJrf/Ojq7/zU1uf8uLrb/Jia1/xAQsP8FBa//BQWx/wUFr/8GBq3/Bgar/wcHqP8HB6b/Bwej/wgI + of8JCaD/Cgqd/wsLmv8MDJb/Dg6P/xAQh/8PD4H/BgYlrQAAAIUAAABoAAAARQAAACkLC6KNDQ2i/w4O + n/8QEJn/EhKT/xMTjP8TE4X1CQlUngAAAHgAAAB4AAAAdQAAAHAAAABuAAAAbQAAAG8AAABzBARBjgkJ + XqoODnHEEBCA3hERi/cREZD/ERGS/xERk/8QEJT/EBCW/w8Pmf8PD5r/Dw+c/w8Pn/8PD6D/Dw+i/xAQ + pP8QEKTlDQ2poAUFlkgAAAAVAAAADQAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAACAAAABAAAAAcAAAAIAAAACgAAAAsAAAAMAAAADQAAAA4AAAAPAAAADwAA + AA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAA + AA8AAAAPAAAADgAAAA0AAAAMAAAACgAAAAkAAAAIAAAABgAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAAEAUFsa4GBrD/Bgar/wUFqP8VFar/ODi0/zo6tf8zM7X/LS24/xIS + tP8FBbP/BQWz/wUFsP8GBq3/Bgaq/wYGqP8HB6f/Bwel/wcHo/8ICKH/Cgqd/wsLmf8NDZD/EBCH/xAQ + fv8QEGPnAAAAjQAAAHMAAABSAAAANQAAACUGBoZLDAye1w4OnP8QEJb/ERGR/xISjf8TE4r/EhJ82gMD + L4QHB0qYCAhVog0NbLsPD3fMEBCE5hISkP8REZH/ERGT/xERlP8QEJb/EBCX/w8Pmf8ODpv/Dg6d/w0N + oP8NDaL/DQ2k/wwMpv8NDaj/DAyq/wwMqsoLC6qQBQWaRQAAABQAAAAPAAAACgAAAAcAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAgAAAAOAAAAFQAA + ABoAAAAeAAAAIAAAACIAAAAkAAAAJQAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAA + ACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAkAAAAIwAAACEAAAAgAAAAHQAA + ABoAAAAVAAAAEAAAAAoAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBAWsiBwe1/wcH + rv8GBqn/Bgaj/wYGnv8KCo/oNTWa0T4+uf84OLv/MTG9/xoauf8FBbX/BQWz/wUFr/8GBqz/Bgaq/wYG + qP8GBqb/Bwel/wcHo/8JCaD/Cwub/w0Nkv8QEIj/ERF9/xMTef8GBiinAAAAfgAAAGIAAABKAAAAPQAA + ADoAAAA+CgqFog8Pl/8QEJP/ERGQ/xERj/8SEpD/EhKR/xERk/8REZT/EBCV/xAQl/8PD5f/Dw+Z/w4O + m/8ODpz/Dg6e/w0Nof8MDKP/DAyl/wwMp/8MDKn/Cwur/wsLrPIKCqy7CQmujwUFp1MAAAAUAAAAEAAA + AAwAAAAIAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAHAAAADwAAABsAAAApAAAAMwAAADsAAAA/AAAAQgAAAEQAAABGAAAASAAA + AEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAA + AEgAAABIAAAARwAAAEYAAABEAAAAQQAAAD8AAAA8AAAANwAAADAAAAAlAAAAGQAAAA8AAAAHAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAABQUFuG0HB7T/Bwet/wcHp/8ICJ//CAia/wMDSJ8AAABfPDyvw0RE + wf89PcL/NzfC/x8fvP8ICLX/BQWy/wYGrv8GBqv/Bgap/wYGqP8GBqb/Bwek/wgIof8KCpz/DQ2S/xAQ + h/8REX3/ExN2/w8PR8sAAACHAAAAcwAAAGIAAABcAAAAXQAAAGIAAABmAwM2dw0NhNYPD5H/Dw+S/w8P + lf8PD5j/Dw+d/w4On/8NDaH/DQ2i/wwMo/8MDKX/DAym/wsLqP8LC6r/Cwut/woKrv8KCq7JCQmvnQcH + sHADA5UyAAAAEgAAAA4AAAAKAAAABwAAAAUAAAADAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAkAAAAWAAAAKQAA + AD0AAABOAAAAWgAAAGIAAABnAAAAagAAAG0AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbwAA + AG8AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbQAAAGsAAABqAAAAaAAA + AGQAAABeAAAAUwAAAEQAAAAzAAAAIgAAABQAAAAKAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAHBga4iwgI + s/8ICKz/CAil/wkJnP8JCYzxAAAAeAAAAFUAAAAyRETBu0hIyP9CQsf/PT3F/y0twf8QELb/BQWw/wYG + rP8GBqr/Bgap/wYGqP8HB6b/CAii/woKnf8NDZT/EBCK/xISff8TE3X/ExNX4AAAAJEAAACEAAAAewUF + NZMHB0CdAAAAggAAAIQAAACAAAAAdggIVpgNDYzqDQ2W/w0NnP8NDaH/DAym/wsLqf8LC6z/Cgqu/woK + r+QKCq/ICAixjgcHrmEDA5UyAAAAEQAAAA4AAAAKAAAACAAAAAYAAAAEAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAACAAAACgAAABgAAAAuAAAARAAAAFgAAABnBgZRlAYGTJkGBkmcBgZHnwcH + RKEHB0SiBwdDogcHQ6IHB0OiBwdCowcHQqMHB0KjBwdCowcHQ6IHB0OiBwdDogcHRKIHB0SiBwdEogcH + RKEHB0ShBwdEoQUFOZgAAACAAAAAgAAAAH8AAAB/AAAAfgAAAHsAAABzAAAAZgAAAFMAAAA9AAAAKQAA + ABcAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAcICLnFCAiz/wkJq/8KCqL/CwuZ/woKeNsAAAB0AAAATwAA + ACwAAAAUSEjOt05OzP9ISMr/QUHI/zw8xf8nJ7z/EBCy/wYGrP8GBqv/Bgaq/wcHqP8ICKT/Cgqg/wwM + mP8PD43/FBSD/yAgf/8kJGXpAAAAmQ4OQMISEm/xEhJ9/xERgP8QEIH/Dg5l3wUFKqkAAACPAAAAgQAA + AG8HB1eDCwuGoQoKl5cKCqWQBgalUgYGrk8AAAAQAAAADgAAAAwAAAAJAAAABwAAAAUAAAADAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICM9kDAy60w0N + sv8ODqv/Dw+k/xAQnf8REZj/EhKU/xISkv8SEpH/ExOQ/xMTj/8TE47/ExON/xMTjf8TE43/ExON/xMT + jf8TE43/ExON/xMTjf8TE43/ExON/xMTjf8TE43/ExON/xMTjf8TE4v/ExOL/xMTiv8TE4j/FBSI/xUV + hv8TE3XgBwdEogAAAIIAAAB7AAAAbgAAAFsAAABEAAAALgAAABsAAAAOAAAABgAAAAIAAAAAAAAACAgI + tsYJCbD/Cgqp/wsLn/8NDZX/CgpjxAAAAHAAAABKAAAAJwAAABAAAAAJTEzNu1NTzv9NTcz/SEjJ/0FB + xf88PMH/Ly+8/x0dtf8TE7L/Dg6v/w4Oqv8QEKb/GBii/yAgnP8mJpP/JyeI/x4eU9gREU3bExN1/xMT + eP8SEnz/ERF+/xERfv8REXz/ERF7/w0NS84AAACVAAAAhQAAAG8AAABUAAAAOQAAACEAAAARAAAACAAA + AAMAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQoKxcALC7z/Cwu4/wwMs/8MDK3/DQ2o/w0No/8ODqD/Dg6e/w8P + nv8PD53/Dw+d/w8PnP8QEJv/EBCb/xAQm/8QEJv/EBCb/xAQm/8QEJv/EBCa/w8Pmv8PD5n/Dw+Z/w8P + mf8PD5n/EBCY/xAQmP8QEJb/EBCV/xAQlP8SEpL/ExOQ/xMTjP8UFIj/ERFuzgEBGIcAAAB8AAAAcQAA + AGAAAABKAAAAMwAAACEAAAASAAAACQAAAAQAAAAKCAixxgkJrP8LC6T/DQ2a/w8PkP8KClq8AAAAbAAA + AEQAAAAjAAAADQAAAAgDA6tRPDzJ/1hYzv9TU8v/TEzI/0dHxP9AQML/OzvA/zU1v/8wML3/Kiq4/yYm + s/8gIKz/IiKj/yQkm/8lJZH/GBh59BAQfP8QEH3/EBCA/xAQgv8QEIP/EBCA/xERfP8SEnf/EhJ2/xAQ + U9sAAACWAAAAhQAAAGwAAABNAAAAMAAAABgAAAAJAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLbEggI + z4MJCcDhCgq6/woKt/8KCrL/Cgqw/wsLrf8LC6v/Cwur/wwMq/8MDKv/DAyr/wwMq/8MDKr/DAyq/wwM + qv8MDKr/DAyq/wwMqv8MDKj/DAyn/wwMp/8MDKb/DAyn/wwMp/8MDKf/DAym/wwMpf8MDKT/DQ2j/w4O + oP8PD57/EBCa/xISlf8TE4//ExOB5AUFP5AAAAB4AAAAcgAAAGQAAABQAAAAOwAAACgAAAAaAAAAEQAA + ABQJCarICgqm/wwMnv8PD5T/EBCL/wcHQaMAAABnAAAAPwAAACAAAAAKAAAACAUFuIwFBbj/QEDH/15e + zP9YWMn/U1PF/0xMxP9GRsP/QEDE/zs7wv81Nb7/MDC6/yoqs/8mJqv/IiKk/x4em/8ODo7/Dg6L/w8P + iv8PD4v/Dw+M/w8PjP8QEIj/ERGA/xISef8TE3P/ExNx/xERUNsAAACVAAAAgQAAAGYAAABFAAAAKAAA + ABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMFBdZEBwfJhQgIvcQICLnwCAi3/wkJ + tv8JCbX/CQm1/wkJtf8JCbX/CQm0/wkJtP8JCbP/CQmz/wkJs/8JCbP/CQmz/wkJs/8JCbL/CQmy/woK + sv8KCrL/Cgqy/woKsv8KCrL/Cgqy/woKsf8KCrH/Cgqv/wwMrP8NDaj/Dg6j/xAQnP8SEpb/ExON9QYG + UJEAAAB0AAAAcgAAAGgAAABYAAAARgAAADUAAAApAAAAKQoKoNkLC6D/DQ2a/xAQjv8SEoj/BQU5mgAA + AGEAAAA6AAAAHAAAAAgAAAAJBga3uAUFtv8FBbD/Li65/2NjyP9dXcf/VlbF/1BQxf9LS8f/RUXF/z8/ + wv86Or3/NTW5/zAws/8oKK3/EBCg/wsLmv8LC5f/DAyX/wwMl/8MDJb/DQ2U/w4OkP8QEIj/EhJ//xMT + dv8UFG//FhZt/w8PPcgAAACRAAAAeQAAAFoAAAA5AAAAHQAAAAsAAAADAAAAAAAAAAAAAAABAAAAAgAA + AAUAAAAIAAAACwAAAA4AAAANAAAACgAAAAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAUAAAAHBATKRwQEx0gFBcBKBQW/SgUFvUsFBb5bCAjAiAYG + vWsFBbdNBQW3TQUFuUwFBblMBQW6TAUFvUsDA6osAAAADgAAAAwAAAAMAAAACgAAAAoAAAAKAAAACgUF + xUgFBcJJCQm+lwoKtuELC7D/DAyr/w4OpP8QEJz/EhKW/wwMb6gAAABwAAAAcwAAAG4AAABkAAAAVgAA + AEoAAABHCwud/wsLmf8NDZP/ERGK/xMThv8AAAB8AAAAWQAAADMAAAAXAAAABwAAAAkGBrfjBgaz/wcH + q/8GBp7uKChro1xcvvJjY8j/XFzJ/1dXyv9QUMn/SkrE/0VFv/8/P7v/Nze0+RoaleUICKb/CQmi/wkJ + of8JCaD/CQme/woKnf8LC5v/DAyW/w4OkP8QEIf/ExN8/xQUcv8WFmv/GBhq/wcHJq0AAACJAAAAbQAA + AEwAAAAsAAAAFAAAAAYAAAABAAAAAwAAAAYAAAAKAAAAEgAAABkAAAAfAAAAIwAAACEAAAAbAAAAEgAA + AAkAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAgAA + AAIAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABAcHzGUKCrjhDAyx/w4O + qv8QEKL/ERGa/xAQhswBARx2AAAAdQAAAHYAAABzAAAAbAAAAGsMDJX/DQ2T/w8Pj/8SEoj/ExOC+AAA + AHMAAABPAAAALAAAABMAAAAFAAAACQcHuP8HB7D/CAio/wcHkdwAAABxAAAAXEFBpZhXV8POXFzL/1xc + zP9WVsj/TEy97jQ0rucPD6HwBgap/wgIqP8HB6b/Bwek/wcHpP8ICKP/CAii/wkJoP8KCpz/DAyX/w4O + j/8REYX/ExN5/xcXbv8ZGWj/GBhZ7QAAAJQAAAB+AAAAXgAAADsAAAAfAAAADgAAAAgAAAAMAAAAFAAA + AB0AAAAnAAAAMgAAADsAAABAAAAAPgAAADMAAAAkAAAAFQAAAAkAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQICzhMICMeTCwu1/wwMrv8ODqb/Dw+f/xERlvQMDHW0AgIvhwAA + AH4AAACBAAAAgwwMkf8NDZD/Dw+N/xISif8REXjfAAAAZgAAAEIAAAAjAAAADgAAAAMAAAAICAi3/wgI + sP8JCab/Bwd9wgAAAHMAAABeAAAAOwAAAB8AAAARAAAAFQAAACoDA4KMBQWo/wYGqv8GBqr/Bweq/wcH + qP8HB6f/Bwem/wcHpv8HB6X/Bwek/wgIof8KCpz/DAyW/w8Pjf8TE4H/FRV0/xgYaf8aGmb/Dw82wQAA + AIoAAABuAAAATQAAAC8AAAAdAAAAGAAAAB4AAAAqAAAANwAAAEIAAABNAAAAVgAAAFsAAABZAAAATwAA + ADsAAAAmAAAAEwAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEGBtZECgq58AsLs/8MDKv/DQ2l/w4On/8ODpv/DAyS7gsLheAKCoLiDAyU/w0Nkf8PD47/ERGM/wwM + bbgAAABTAAAAMwAAABkAAAAIAAAAAQAAAAcICLj/CQmv/wsLpf8ICHe3AAAAdQAAAGUAAABEAAAAJQAA + ABQAAAAXBASZewUFq/8FBan/Bgar/wYGrP8GBqr/Bgap/wYGqP8GBqf/Bgan/wYGp/8HB6b/Bwek/wgI + of8KCpz/DQ2U/xAQiv8TE3z/FhZw/xkZZ/8ZGVzzAAAAkwAAAH0AAABgAAAARAAAADUAAAAxAAAAOQAA + AEUAAABQAgI/awkJcpkNDXqwBARKggAAAGgAAABhAAAAUAAAADkAAAAhAAAADgAAAAQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAs4TCQnCwQoKt/8KCrH/Cwus/wsL + p/8KCqT/Cgqi/woKnv8LC5r/DQ2V/w8Pkv8REZL/BARQeQAAAD4AAAAjAAAAEAAAAAUAAAAAAAAABQkJ + uv8KCrD/DAyl/wkJeLUAAAB2AAAAbgAAAFIAAAAxAAAAHwQEjEkGBq//Bgat/wUFq/8GBqz/BQWr/wYG + q/8GBqn/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/Bwej/wkJn/8LC5n/Dg6R/xIShP8UFHf/Fxds/xkZ + Z/8PDzbAAAAAigAAAHUAAABeAAAAUQAAAE4AAABSBgZggg8PjswSEpv/EhKZ/xMTlv8TE5D1BARKgQAA + AGgAAABgAAAATAAAADEAAAAZAAAACQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAACBwfNgwgIu/8JCbf/CQmz/wkJsP8JCa3/CQmq/wsLo/8MDJ7/Dg6b/w4O + kNQAAAA+AAAAKAAAABQAAAAIAAAAAgAAAAAAAAADCAi/0QoKsv8MDKb/Dg6Z9QEBGn0AAAB1AAAAYQAA + AEAAAAAqBgaorgYGr/8GBq7/BQWv/wYGrv8FBa3/Bgar/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + pv8HB6X/CAii/woKnf8MDJb/EBCL/xMTf/8VFXL/Fxdr/xUVUOEAAACUAAAAhgAAAHUAAABpCgponhAQ + kusQEJ3/Dw+g/w8PoP8QEKD/ERGd/xISmf8TE47fAAAAYgAAAGYAAABaAAAAQgAAACYAAAARAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQXXRAcH + weAHB7z/Bwe6/wgItv8JCbH/Cgqs/wwMqP8ODqPzBAR2WAAAACMAAAAVAAAACgAAAAMAAAABAAAAAAAA + AAEHB8qDCgq1/wwMqf8ODp7/CwtytwAAAHgAAABtAAAAUQAAADgREazzBwev/wYGsf8FBbL/Bgay/wUF + r/8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6T/CQmg/wsLm/8ODpL/ERGG/xMT + ev8VFXH/FhZu/wEBEaAAAACPCQlJpxAQfNwREZT/Dw+c/w4Oo/8NDaXzCgqgpggImWoPD6bxEBCh/xIS + nP8ODoWzAAAAYwAAAGMAAABRAAAANgAAABwAAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLPEwYG0IMHB7/wBwe9/wgIuf8KCrX/Cwux4wUF + lEgAAAAYAAAAEAAAAAgAAAADAAAAAQAAAAAAAAAAAAAAAAMD2iMJCbn/DAyt/w4Oov8QEJX1AQEafgAA + AHUAAABgAAAARiUlsv8fH7b/FRW5/woKt/8FBbX/BQWx/wYGrf8GBqr/Bgao/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wcHpf8ICKL/Cgqe/wwMl/8PD47/EhKD/xMTef8TE3T/EBBP0xMTc/ESEob/ERGR/w8P + mv8ODqP/CgqfpwEBSTQAAAAZAAAAEAYGtjsODqv/EBCk/xISnP8EBFB4AAAAZgAAAF0AAABGAAAAKQAA + ABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMFBddEBATLRwQEwTkAAAAMAAAACgAAAAgAAAAFAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAQgIxaILC7L/DQ2n/w8Pnf8LC3K3AAAAeAAAAG0AAABTKyuw6ioquf8oKL3/JibA/yAg + vv8VFbj/DQ2y/wYGrP8GBqn/Bgao/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bwem/wcHpP8JCaD/Cwub/w0N + k/8QEIr/ERGB/xISfP8SEn3/EhKD/xERjv8PD5j/DQ2ZwgMDaUUAAAAcAAAAEQAAAAkAAAAEAAAAAwoK + wJMNDaz/EBCj/xAQktIAAABiAAAAZAAAAFQAAAA4AAAAHQAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAA + AAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPaIwoKuP8MDK3/Dg6i/xAQ + lvUBARp+AAAAdQAAAGAvL6K4MzO7/zAwv/8uLsH/LCzC/ysrwP8pKbz/Jye5/xsbs/8VFa//DQ2r/wgI + qf8GBqf/Bgan/wYGp/8GBqf/Bwel/wgIov8KCp7/CwuY/w4Okf8PD4f/EhKE/xMThf8QEIv/Dw+N3wcH + d2sAAAAjAAAAFAAAAAoAAAAFAAAAAgAAAAAAAAAAAgLOEwwMtfAODqv/ERGg/wYGX4MAAABmAAAAXgAA + AEYAAAApAAAAEgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABCAjEogsLs/8MDKj/Dg6e/woKdLcAAAB3AAAAaxMTT2w8PLz/OTnA/zY2 + w/80NMP/MjLF/zExwv8vL77/Li68/y0tuf8rK7f/Kiq0/yMjsv8dHbD/GRmt/xQUrP8UFKr/FBSn/xQU + o/8WFp//HByZ/yIilP8lJZL/FBSD7wkJaJsAAAA+AAAAIwAAABAAAAAGAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAABCQnIgw0Nsf8PD6X/ERGW3gAAAGQAAABmAAAAVAAAADcAAAAcAAAACgAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBNkjCgq4/wsL + rf8NDaP/Dg6Y9QAAAHYAAABzAAAAXDQ0p6xBQcL/Pz/F/z09yP87O8j/OjrI/zk5xP83N8L/NTW//zQ0 + vP8yMrr/MDC3/y4utv8sLLX/Kiq0/yoqsv8pKbD/KCis/ycnpf8nJ57/JyeY/yYmlf8ICDeBAAAASwAA + ACsAAAAUAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAs4TCwu28A4Oq/8REZ//BgZdhAAA + AGgAAABfAAAARgAAACgAAAARAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMOiCgqx/wwMp/8ODp7/BwdkpwAAAHYAAABmAAAASD09 + u75ISMn/RUXL/0REy/9CQsv/QEDL/z8/yf89PcX/PDzB/zo6v/85Ob3/Nze7/zY2uv80NLn/MzO2/zIy + s/8xMa//MTGo/zAwof8vL57/KSmS6AAAAFgAAAA3AAAAHQAAAAsAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEJCciDDAyw/w8PpP8QEJDUAAAAZgAAAGYAAABTAAAANQAAABsAAAAJAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE + 0yQKCrT/Cwup/w0Nn/8NDZHtAAAAeAAAAG0AAABPAAAALkZGyblPT8//TEzQ/0pKz/9JSc7/R0fM/0VF + yv9ERMj/QkLF/0BAwv8/P8H/Pj6//z09vP87O7n/Ojq2/zo6sf85Oav/OTmm/zg4pf8hIXugAAAAQAAA + ACUAAAASAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE1CQLC7X/Dg6p/xER + nv8GBlyHAAAAaQAAAF4AAABEAAAAJgAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwkJu6ULC6z/DQ2h/w4OmP8HB1eiAAAAcAAA + AFMAAAAvAAAAFklJ1ptVVdP/U1PT/1FR0f9QUM//Tk7O/0xMzP9MTMr/SkrH/0hIxP9HR8D/RUW9/0RE + u/9DQ7f/QUGz/0JCr/9BQa3/PT2p7gAAAEAAAAApAAAAFQAAAAgAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJwaMNDa//EBCk/xAQjcoAAABoAAAAZgAAAFEAAAAzAAAAGAAA + AAgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADAwOhLgsLrP8NDaD/Dw+X/wwMeswAAABvAAAAUgAAAC4AAAAUAAAABkVF4FZSUtbpWlrW/1hY + 0/9WVtD/VVXO/1NTzP9SUsj/UVHE/09Pwf9OTr7/TEy7/0xMuP9KSrX/S0u1/0lJs/cjI4BkAAAAJQAA + ABUAAAAKAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBgbVRAsL + tP8ODqn/ERGf/wICOnQAAABoAAAAWgAAAD4AAAAhAAAADAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAASCwus/w4OoP8QEJf/Dw+D3QAA + AGsAAABMAAAAKgAAABEAAAADAAAAAQAAAANMTN57XFzX62Bg1P9eXtH/XFzN/1tbyf9ZWcT/V1fA/1ZW + vv9VVbz/VVW7/1RUu/9LS7fjLCyVWgAAABsAAAARAAAACAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCgq/wgwMsP8PD6b/Dg6PvgAAAGAAAABaAAAAQwAA + ACYAAAAQAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABgQEo0ELC6v/Dg6f/xAQlf8ODnrLAAAAZgAAAEQAAAAkAAAADgAAAAIAAAAAAAAAAAAA + AAEAAAADS0vcalRU0b1hYc72Y2PL/2Jixf9hYcL/YGC//2BgwP9OTrLUQECqjgAAAB0AAAASAAAACgAA + AAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEHB9BjCwu2/w4Orf8QEKX/AgJGZAAAAE8AAAA+AAAAJQAAABEAAAAEAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBwevcAwMqf8ODp3/ERGV/wkJ + Y6cAAABfAAAAPAAAAB0AAAAKAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAFAAAAEQAAACgZGa7qHh6t/yAg + qv8oKJC4AAAASgAAAC8AAAAYAAAACwAAAAUAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMKCr3gDAy0/w4Orv8LC5ucAAAAOwAA + ADEAAAAfAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAsJCbGrDAyo/w4OnP8REZT/BARFigAAAFcAAAAzAAAAFwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAgAAAAoAAAAaBgacjAgIqv8KCqX/Cgqa7AAAAFMAAAA3AAAAHQAAAAsAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQcH1GILC7r/DQ21/w4OsdUAAAAjAAAAHQAAABMAAAAJAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADwoKr9YMDKb/Dw+a/xER + kPYAAABpAAAATAAAACoAAAASAAAABAAAAAAAAAAAAAAAAAAAAAEAAAAGAAAAEgEBQzUJCarzCgqn/wwM + ov8FBWCFAAAARAAAACgAAAASAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQkJyqILC7zwDAy8wwAA + ABAAAAAOAAAACQAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAQAAAASCwuu/w0No/8QEJr/Dg59yQAAAGIAAABCAAAAIgAAAAwAAAACAAAAAAAA + AAAAAAAAAAAAAwAAAAwAAAAeCQmhqAsLp/8MDKL/DAyR2AAAAFAAAAA0AAAAGgAAAAoAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAEAAAABQAAAAUAAAADAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgUFrFALC6z/DQ2i/xAQ + mf8JCWiiAAAAWQAAADcAAAAbAAAACAAAAAEAAAAAAAAAAAAAAAEAAAAGAAAAFAUFjGALC6j/DQ2h/w4O + nf8EBFF6AAAAQQAAACUAAAAQAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAICAixfgsLqv8ODqD/EBCY/wEBIHAAAABOAAAALgAAABQAAAAFAAAAAAAA + AAAAAAAAAAAAAQAAAAoAAAAdCwulzg0No/8ODpz/DQ2ExQAAAFEAAAAzAAAAGQAAAAgAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAwJCbGrDAyp/w4O + n/8PD4/jAAAAXwAAAEQAAAAkAAAADgAAAAMAAAAAAAAAAAAAAAAAAAADAAAADgcHpXYMDKn/Dg6f/w8P + lPYCAjl4AAAASgAAACwAAAAUAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAAEAsLr9YNDaf/Dw+d/woKdKkAAABXAAAAOQAAABwAAAAJAAAAAQAA + AAAAAAAAAAAAAAAAAAMAAAAQCwuw8gwMqf8ODp7/Cwt0twAAAGYAAABMAAAAMAAAABkAAAAKAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAUCwuv/w0N + pf8PD53/AgI8dAAAAE0AAAAvAAAAFQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAwcHw2gKCrT/DAyr/w4O + nvUBAR9zAAAAaAAAAFYAAAA+AAAAKgAAABoAAAAQAAAACQAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACAUFp1IMDK3/Dg6j/w8Pl+sAAABaAAAAQgAAACUAAAAOAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAACCQnC0QoKt/8MDK7/DAyTvAAAAF8AAABnAAAAYQAAAFQAAABEAAAAMwAA + ACYAAAAZAAAAEAAAAAkAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAALCQmujwwM + q/8ODqL/DAyGuAAAAFEAAAA3AAAAHAAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEHB8ySCQm7/wsL + s/8MDKbZAgJGYgAAAFsAAABjAAAAYwAAAFwAAABRAAAAQwAAADQAAAAmAAAAGQAAABAAAAAIAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAABAKCq/JDQ2p/w8Pof8CAkBuAAAASAAAAC0AAAAUAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICzxMJCcPRCgq5/wwMsf8ODqj/Dg6UuQICP2sAAABiAAAAZwAA + AGYAAABeAAAAUgAAAEMAAAAzAAAAJQAAABgAAAAOAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAFQwM + rPIODqb/Dw+Y4AAAAFMAAAA9AAAAIwAAAA4AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIC + zxMICMiiCgq4/wwMsv8ODqn/EBCi/w4Ojr0CAjtyAAAAaAAAAGoAAABoAAAAXwAAAFIAAABCAAAAMQAA + ACMAAAAVAAAADAAAAAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAoFBaJVDAys/w4Opf8KCoCgAAAASgAAADMAAAAZAAAACAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHB9JjCgq58AwMs/8NDaz/Dw+l/xER + nv8PD4jAAgI4dgAAAGoAAABsAAAAaAAAAF4AAABPAAAAPgAAAC4AAAAeAAAAEgAAAAgAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAADwkJ + rp8NDar/Dw+k/wICRWcAAABAAAAAKAAAABIAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEEBNojCQnBsgsLtv8MDLD/Dg6p/xAQo/8REZz/Dw+HwQICN3kAAABrAAAAawAA + AGYAAABaAAAASgAAADcAAAAkAAAAFQAAAAoAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAWDAyv1w4Oqf8NDZjIAAAASwAAADYAAAAeAAAACwAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBgbVRAoK + vOALC7T/DQ2t/w8Pp/8QEKH/EhKb/wwMfa0BAR5vAAAAagAAAGgAAABeAAAATAAAADcAAAAhAAAAEAAA + AAYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAACwIC + gTgMDLD/Dg6o/wcHeIUAAABCAAAAKwAAABUAAAAGAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwcH0GQKCrrhDAyz/w0NrP8PD6b/ERGg/xIS + mPQJCXOYAAAAYgAAAGEAAABVAAAAQgAAACoAAAAVAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAPCQmyng0Nr/8NDaboAAAARwAAADYAAAAgAAAADQAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMICMuDCwu38AwMsv8ODqv/Dw+m/xERoP8REZjdBARZcQAAAE0AAAA+AAAAKgAA + ABcAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAA + ABILC7bkDQ2x/woKmaAAAAA7AAAAKgAAABYAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAs4TCQnIhAsL + tvANDbD/Dw+s/xAQqP8REaTyBARzWgAAAC0AAAAfAAAAEQAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBgbAWgsLuf8MDLLyAQE7QAAAACsAAAAdAAAADQAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLOEwkJyIQMDLXwDg6y/w4OsP8NDbG4AAAAGQAA + ABIAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAMKCsPCCwu7/wkJtY8AAAAhAAAAGgAAABAAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQICzxMICM9kBgbKRwAAAAsAAAAKAAAABwAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLbEgoKwu8LC73wAQF6IAAAABIAAAANAAAACAAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAQAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABBgbbUgYG2EQAAAAHAAAABwAAAAUAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/////////AH///////////////////wA///////////////////8AP////////////////// + /AB///////////////////wAf//////////////////8AD///////////////////AA///////////// + //////4AP//////////////////+AB///////////////////gAf//////////////////8AD/8D//// + ////////////AA/+Af///////////////4AH/gD///////////////+AB/4A////////////////wAP+ + AH///////////////8AD/AB////////////////AA/wAf///////////////4AH8AH////////////// + /+AB/AB////////////////wAPwAf///////////////8AD8AH//////////+AD///AAfAB///////// + /8AAH//4AHwAf/////////8AAAf/+AB8AH/////////+AAAB//wAPAB//////////AAAAH/8ADwAf/// + //////wAAAA//AAcAH/////////4AAAAH/4AHAB/////////+AAAAA/+ABwAf/////////gAAAAH/gAM + AH/////////4AAAAA/8ADAB/////////+AAAAAH/AAwAf/////////gAAAAA/wAMAH/////////4AAAA + AH+ADAB/////////+AAAAAB/gAwAf/////////gAAAAAP4AMAH/////////4AAAAAB8ADAB///////// + +AAAAAAfAAwAf/////////gAAAAADwAMAH/////////4AAAAAAYADAB//////////AAAAAAGABwAf/// + //////wAAAAAAgAcAD/////////+AAAAAAAAHAA//////////gAAAAAAADwAP/////////8AAAAAAAA8 + AB//////////AAAAAAAAfAAf/////////4AAAAAAAHwAD/////////+AAAAAAAB8AA//////////wAAA + AAAA/gAH/////////+AAAAAAAP4AB//////////wAAAAAAD/AAP/////////+AAAAAAA/wAD//////// + //gAAAAAAP+AAf////+Af//8AAAAAAB/wAH/////AD///wAAAAAAf+AA/////wAP//+AAAAAAH/gAH// + //8AA///wAAAAAAfgAB/////AAD///AAAAAAAAAAf////wAAH//4AAAAAAAAAH////8AAAf//gAAAAAA + AAB/////AAAA//+AAAAAAAAAf////4AAAB//gAAAAAAAAH/////gAAAH/AAAAAAAAAB/////+AAAAOAA + AAAAAAAA//////4AAAAAAAAAAAAAAP//////gAAAAAAAAAAAAAH///////AAAAAAAAAAAAAH///////8 + AAAAAAAAAAAAD////////wAAAAAAAAAAAAP////////AAAAAAAAAAAAA////////8AAAAAAAAAAAAD// + +AD///wAAAH4AAAAAAAf/gAA////AAAH/wAAAAAAB8AAAP///8AAP/+AAAAAAAAAAAD////wAf//gAAA + AAAAAAAA/////////8AAAAAAAAAAAP////////+AAAAAAAAAAAD//8AAAB//gAAAAAAAAAAA/+AAAAAA + P4AAAAAAAAAAAP/AAAAAAB+AAAAAAAAAAAf/wAAAAAAHgAAAAAAAAAA//8AAAAAAA4AAAAAAAAAH///A + AAAAAAGAAAAAAAAA////wAAAAAAAgAAAAAAAP////8AAAAAAAAAAAAAAAP/////gAAAAAAAAAAAAAAB8 + D///8AAAAAAAAAAAAAAAYAP///wAAAAAAAAAAAAAAAAB////8AAHwAAAAAAAAAAAAf////////gAAAAA + AAAAAAD////////+AAAAAAAAAAAA/////////wAAEAAAAAAAAH/////////AABAAAAAAAAA///////// + 4AAQAAAAAAAAP/////////AAOAAAAAAAAB/////////8AHgAAAAAAAAf/////////4P8AAAAAAMAD/// + /////////AAAAAAHAA////////////4AAAAAH4AP///////////+AAAAAD+AB////////////wAAAAA/ + wAf///////////8AAAAAf8AD////////////AAAAAH/AA////////////wAAAAD/4AP///////////8A + GAAB/+AD////////////ABwAB//wA////////////gA8AD//8AP///////////4AOAA///gD//////// + ///+ADgAf//8B////////////gAwAH////////////////4AcAD////////////////8AHAA//////// + /////////ABwAH////////////////wA8AAf///////////////8APAAB///////////////+ADwAAH/ + //////////////gB+AAAf//////////////4AfgAAB//////////////8AH+AAAP//////////////AD + /wAAD//////////////gA//AAAf/////////////4AP/4AAH/////////////+AH//gAB/////////// + ///gB//+AAf/////////////4A///4AH/////////////+AP///gD//////////////gH///+D////// + ////////4B////////8oAAAAQAAAAIAAAAABACAAAAAAAABCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABwAAAA4AAAARAAAADAAA + AAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAA + AA4AAAAcAAAAJgAAAB0AAAAPAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIICLxaCgqokwAAADkAAAAzAAAAHQAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBga1Ow4Opf8ICIqIAAAARAAAAC4AAAATAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNDaHHDg6d5wAA + AEwAAAA+AAAAIQAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADCwuqaw4Onf8ICH+OAAAASgAAADAAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAA + AAcAAAAFAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAoODpzkDQ2a6AAAAFEAAAA+AAAAHwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAABwAAABAAAAAXAAAAEwAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDAyiiw0Nm/8GBnOHAAAASwAA + AC0AAAAQAAAAAgAAAAAAAAAAAAAAAQAAAA8AAAAiAAAAMgAAACoAAAAXAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQE + pCwNDZv/DQ2U0gAAAFMAAAA8AAAAGwAAAAUAAAAAAAAAAAAAAAMAAAAWDg6o/wUFcnYAAAA+AAAAIgAA + AAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAHDQ2duA0Nm/8DA1Z0AAAASgAAACkAAAAMAAAAAQAAAAAAAAAEBwefUw4O + nv8LC4y1AAAATAAAACoAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAYAAAAIAAAACgAAAAkAAAAHAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJqFwODpr/DAyMvgAAAFUAAAA5AAAAFwAA + AAQAAAAAAAAABQgIm1MNDZn/DAyR1gAAAFEAAAAsAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACgAAABMAAAAdAAAAJAAA + ACcAAAAlAAAAHwAAABYAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDg6Z5A4O + mv8BASNkAAAASAAAACQAAAAKAAAAAAAAAAUICJpTDQ2Y/wwMj9YAAABTAAAALgAAAA4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADgAA + ACAAAAA0AAAARgAAAFEAAABXAAAAVAAAAEoAAAA7AAAAKQAAABcAAAAKAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABQ0NnpsNDZj/CgqBrAAAAFUAAAAzAAAAEwAAAAMAAAAFCAiZUw0NmP8MDI7WAAAAUwAA + AC4AAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAACwAAACEBAS1NCAhymwoKdLoMDIffCgp2yQgIa7gBATKKAAAAawAAAFUAAAA7AAAAIwAA + ABAAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAEHB6Q+DQ2Y/w0NlekAAABcAAAARAAAAB8AAAAHAAAABQgI + mVMNDZj/DAyO1gAAAFMAAAAuAAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABYWFpCGDQ2T9QsLkf8KCpL/CQmS/wkJkf8LC5D/DAyT/woK + edUAABmHAAAAZwAAAEkAAAAsAAAAFAAAAAcAAAABAAAAAAAAAAAAAAAAAAAACQ4OmNYNDZj/BgZpkQAA + AFIAAAAtAAAADgAAAAYICJlTDQ2Y/wwMjtYAAABTAAAALgAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcODnw9HR2c/woKjv8HB5H/CAib/wcH + n/8ICJv/CAiT/wgIj/8KCo//DAyP+QUFVq8AAAByAAAAUgAAADAAAAAVAAAABwAAAAEAAAAAAAAAAAAA + AAQMDJ99DQ2X/wwMjtYAAABbAAAAOgAAABcAAAAICAiZUw0NmP8MDI7WAAAAUQAAACwAAAANAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJHh6gmBYW + lf8ICJH/Bgad/wYGpf8GBqf/Bgal/wYGof8HB5v/BweR/wkJjP8LC5H/Cgp0zwAAAHgAAABVAAAAMAAA + ABQAAAAFAAAAAAAAAAAAAAABBQWbLg0NmP8NDZj/AgI8cgAAAEIAAAAdAAAACggImlMNDZj/DQ2Q1QAA + AE8AAAArAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACCEhn8wXF5f/CAib/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgal/wYGnf8GBpD/CAiL/wsL + j/8KCnnWAAAAdwAAAFEAAAAqAAAAEAAAAAMAAAAAAAAAAAAAAA4NDZS9DQ2X/wkJfKQAAABEAAAAHgAA + AAoICJtTDQ2Z/w0NkdUAAABLAAAAKAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYjI6KVHBya/wgIm/8GBqX/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqX/Bgad/wYGkf8ICIv/CwuQ/wkJbMgAAABxAAAASAAAACEAAAAKAAAAAQAAAAEAAAASDAyMmQ0N + l/8KCoKtAAAAPgAAABoAAAAICAibUw0Nmf8LC4e0AAAASQAAACcAAAAKAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADHh6pciIimv8LC5T/Bgah/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpf8GBp3/BgaR/wgIi/8MDJH/BQVWrgAAAGYAAAA6AAAAFwAA + AAUAAAAFAAAAGw0Nk9sNDZj/BQVjgQAAADQAAAASAAAABwgIm1MODpr/CgqCqwAAAEwAAAAqAAAACwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARIS + lB0jI53/FRWV/wcHm/8GBqX/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgal/wYGnf8GBpH/CQmN/wwM + j/kAABmGAAAAVAAAACkAAAANAAAADAUFfk8NDZj/Dg6W9QAAAE4AAAAoAAAACwAAAAUICJtTDQ2Z/wsL + hLcAAABVAAAAMAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAFISGhrSEhmf8KCpL/Bgad/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqX/Bgad/wcHkf8KCpD/CgpzzgAAAGwAAAA9/////wAAABcMDJOlDQ2X/wsLh8IAAABBAAAAHAAA + AAYAAAAECAiZUw0NmP8MDIzYAAAAXwAAADsAAAAVAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARkZsC0mJp3zGxuV/wYGkv8GBqH/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpf8HB5v/CAiP/wwMk/8CAjCOAAAAUQAAACkAAAAkDg6V5w0N + l/8FBWSAAAAAMwAAABIAAAACAAAAAwgIn1AMDJb/DQ2X/wAAAGgAAABIAAAAHwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAELy+uhDAw + oP8bG5f/Bweb/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgah/wcHkv8KCpD/Cgp1zAAA + AGEAAAA3CAiIcg0NmP8NDZXqAAAASgAAACYAAAAKAAAAAAAAAAEICKlMDQ2V/wwMlP8GBmSXAAAAVgAA + AC0AAAAOAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAc5Oaq0OTmk/yMjnf8HB5v/Bgah/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + pf8HB5v/CQmQ/wsLh+oAAABrAAAAQgoKjp0NDZj/CgqBrAAAAEAAAAAdAAAABQAAAAAAAAABAwOfGA0N + l/EMDJP/CwuDxAAAAF4AAAA+AAAAGwAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS2zHEVFrd1ERKj/NDSi/w0Nlf8GBp3/Bgal/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgaf/wgIkP8TE5b/AAAAcwAAAEwNDZXQDQ2Z/wICP28AAAA+AAAAGwAA + AAQAAAAAAAAAAAAAAAMMDKZrDAyW/w0Nl/8CAj1wAAAATQAAACwAAAAPAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAACQAA + AAoAAAAHAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIrK60dTk6y309P + rP9FRaf/JSWe/woKnP8GBqH/Bgal/wYGp/8GBqf/Bgan/wYGn/8ODpP/Jyed/w8PSpYAAABZDQ2Q1A0N + mP8BASBtAAAARgAAAB8AAAAGAAAAAAAAAAAAAAABAAAABg0NnqgNDZj/DAyLvgAAAFgAAAA/AAAAHwAA + AAgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAADAAAABcAAAAdAAAAGgAAABAAAAAIAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAhQULatWVmy/1RUrv9LS6z/LCyi/xsbo/8VFaf/FBSq/xcXrf8qKq7/Nzen/zc3 + o/8GBhyKAAAAbQsLh9oNDZX/BgZgngAAAFcAAAAsAAAADgAAAAEAAAAAAAAAAAAAAAMAAAAMDg6Y1g0N + mf8FBV+GAAAAUwAAADEAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBciAAAAAlAAAAMgAAADIAAAAoAAAAHAAAABIAAAAKAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABUJCu2xfX7bsYGC1/1xcsf9XV7H/U1Oz/1BQ + t/9NTbj/SUm1/0VFrv8eHpn/BwdWswkJZsEJCWjKCwuQ/wsLetIAAABtAAAARAAAACIAAAAQAAAADQAA + ABAAAAAUAAAAGwcHgWINDZf/DQ2Q4gAAAGQAAABDAAAAHAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODrLDDg6o4wYGgmYAAAA9AAAAOwAA + ADMAAAAqAAAAIAAAABcAAAAOAAAACAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACFBQ + vIJoaLrQZ2e5/2Njt/9gYLf/XV22/1hYtP8mJp3/CQmH7QkJh+8KCpL/CQmJ+QoKjv8MDIz4AAAAhAAA + AGQAAABEAAAAMAAAACwAAAAxAAAAOQAAAEAAAABNCwuO6w0Nlf8HB22iAAAASQAAACAAAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAS/Jw0N + rKcODqP/DQ2gywcHh3YAAAA9AAAAPQAAADgAAAAxAAAAKAAAAB8AAAAVAAAADgAAAAcAAAADAAAAAQAA + AAAAAAAAAAAAAQAAAAQAAAAKAAAAFR8fYjc6Opd1NzeNfDc3iX8qKn98CwuBuwoKdsMICJn/CAie/wcH + mf8ICIf5CgqM/woKeN8BAS2TAAAAbwAAAGAAAABeAAAAZQQEWJAFBVSTBgZNlAsLhOUMDJP/DAyOzQAA + AD4AAAAbAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAFBASqKwwMqZoODqLxDg6h5QkJlI4CAlFWAAAARAAAAEIAAAA9AAAANAAA + ACoAAAAgAAAAFgAAAA4AAAAKAAAACQAAAA0AAAAVAAAAIAAAACwAAAA5AAAARAAAAEwAAABPAAAAUDQ0 + jKsYGJr/CAie/xMTqv8bG6n/BgaU/wgIjv8KCo7/CwuL+QYGTLMLC3jSDAyQ9wwMk/8MDJL/DAyR/wsL + kf8LC5H/DQ2W/woKkKAAAAAmAAAADwAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAFAgKOGwwMq4oODqLjDg6g/w0N + msEICIOKAQEoVwAAAE4AAABKAAAAQwAAADgAAAAtAAAAJgAAACUAAAAsAAAAOAAAAEYBASVcCAh2lwoK + f64MDIzMCgp9rgYGWIgPDyx1W1us7V5evv8zM7X/Bgal/wYGof8HB5v/BweS/wgIkP8KCpD/CQmO/wkJ + jf8KCo3/CwuP/wsLkP8MDJP/DQ2V5woKjn8AAAAfAAAAEAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAAEAAAACgsLrGwODqDjDg6d/w4OnP8MDJLGCAh5kwEBJGIAAABXAAAAUQAAAEwAAABMAQEmWwgI + dZcMDIrMDQ2Y/w0Nl/8NDZf/DQ2X/wwMlv8MDJT/DAyN9QkJeNEHB4PfBwel/wYGp/8GBqf/Bgal/wYG + of8HB5//BweZ/wcHjv8KCov/CwuQ/wwMh9cLC4aiBwd7aAAAACoAAAAeAAAAEgAAAAcAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACAgIqk0NDZ3HDQ2b/w0Nmf8NDZn/DAyMyggI + cZkGBmaRCwuGww0NlfUNDZf/DQ2W/w0NmP8NDZXaCgqKfwoKkXkNDZa8DQ2W8gwMk/8KCpD/CAiS/wcH + nf8GBqX/Bgan/wYGp/8GBqf/Bgan/wcHn/8HB5D/BgZEtwAAAH4AAABgAAAASQAAAD0AAAA2AAAALgAA + ACIAAAAVAAAACgAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAABgAA + AAcAAAAHAAAABQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABwUF + ny0NDZ6qDQ2Y8g0NmP8NDZf/DQ2X/w0Nl/8NDZj/DQ2W2goKkIsEBHE/AAAAGQAAABAAAAALAAAACgAA + AA0LC6FeFhaUvRAQkf8ICJP/Bweh/wYGp/8GBqf/Bgan/wYGp/8HB5//BweP/wsLh/kDAzeiAAAAegAA + AGsAAABiAAAAWQAAAFAAAABEAAAANAAAACMAAAASAAAABwAAAAIAAAABAAAAAwAAAAUAAAAIAAAADAAA + ABAAAAAUAAAAGQAAAB4AAAAgAAAAHAAAABQAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAABQICjRsLC6RtDg6b1Q0NmsoLC5aGBARzPgAAABgAAAAQAAAACAAA + AAQAAAABAAAAAAAAAAAAAAAAAAAAAx8fkiA0NKL0GBiY/wkJoP8GBqf/Bgan/wYGp/8GBqf/Bgah/wcH + kv8JCYz/CwuJ+QsLfeUMDJD4DQ2Z/w0NkeMJCYKuAAAkYQAAAFEAAABDAAAAMAAAAB4AAAAVAAAAFAAA + ABcAAAAdAAAAJAAAACoAAAAxAAAANQAAADoAAAA9AAAAPAAAADMAAAAjAAAAEAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAcAAAAKAAAACgAA + AAgAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGLi6ZUj4+pvYuLqj/EhKj/wYG + n/8GBqH/Bgal/wYGpf8HB53/BgaS/wcHj/8JCY//CwuQ/wwMjvcMDJDsDQ2Z/w4OmPQICHaWAAAAWQAA + AE8AAABAAAAANwAAADYAAAA5AAAAQAAAAEcAAABNAAAAUgUFZ30GBnKICgqKpwoKkKQICJmQAAAAJgAA + ABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACAAAAAsAAAANAAAADgAAAA4AAAAOAAAADgAA + AA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAANAAAADAAAAAgAAAAEAAAAAQAAAAAAAAAAAAAABwEB + Ti0WFpHpNzek/zw8pv8fH5r/BgaT/wYGnf8GBqX/Bgal/wYGof8HB5//BweZ/wkJhPMBAReKAAAAYAsL + h6MNDZn/DQ2Z/wwMkNYCAjxyAAAAWgAAAFYCAkBrBQVjgAoKgqsMDI3LDQ2W6g0Nm/8NDZv/Dg6c/w4O + nv8ODqLlCgqqkwAAABcAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACgAAABcAAAAjAAAAKwAA + AC4AAAAuAAAALgAAAC4AAAAuAAAALgAAAC4AAAAuAAAALgAAAC4AAAAuAAAALQAAACoAAAAiAAAAFQAA + AAoAAAADAAAAAAAAAAoKCpJ3CwuQ/woKjP8uLo3hSEio/yoqm/8JCZP/Bgah/wYGp/8GBqf/Bgan/wgI + n/8JCZL/CAhhvQAAAG0AAABVBARWcA0Ni9UNDZf/DQ2V9Q0NjtUNDZr/DQ2a/w0Nmf8NDZn/DQ2Z/w4O + mv8NDZjZDAyWpAoKmXgDA3o7AAAAFwAAABAAAAAJAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAA + ABIAAAAnAAAAPAAAAEoAAABRAAAAVAAAAFYAAABXAAAAVgAAAFUAAABUAAAAUwAAAFMAAABTAAAAUwAA + AFMAAABRAAAASAAAADYAAAAhAAAADgAAAAUAAAANDQ2VvQsLkP8LC5D/AAAAZj4+j5xSUq7/ODil/xMT + o/8GBqf/Bgan/wYGp/8HB5//CQmR/w4OfeUAAACGBQVQmQUFT5cAAABzCAhlpAwMkusNDZr/Dg6Y8w0N + l80MDJWkCwuZhgcHklkAAAAbAAAAFAAAAA8AAAAKAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAQLC7WWDQ2hyQ0Nl88NDZHTDQ2O1QwMjdcMDIvYDAyM2AwMjNgMDI3XDAyO1wwM + jtYMDI7WDAyO1gwMjtYMDI/XCwuJxAAAIWkAAABUAAAAQAAAACgAAAAVAAAAFw0NkswMDJH/DAyI5AAA + AFkAAAA1R0efk11dtP9PT7X/Nzex/x0dqP8XF6f/ExOh/xgYl/8ZGX3oCgp+7AsLkP8LC5D/CwuH8QMD + O5sAAABsAAAATAAAACwAAAAYAAAADgAAAAoAAAAHAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCQnAZg4OpNMODpz/DQ2Z/w0Nl/8MDJb/DQ2V/w0N + lf8NDZb/DQ2X/w0NmP8NDZj/DQ2Y/w0NmP8NDZf/DAyW/w0Nlv8NDZf0BQVhgwAAAFUAAABGAAAAMwAA + ADENDY/QDAyS/wwMidoAAABQAAAALAcHgl8uLqD/YGC1/1pas/9NTa7/QUGq/zU1qP8pKaD/Dw+S/wcH + kP8HB5D/CAiP/woKjv8LC4z5AwM+mgAAAF4AAAAzAAAAFAAAAAUAAAAEAAAACAAAAAsAAAAKAAAABwAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAHAAAADggI + qU4ICJtTDQ2djgwMmZAMDJqRCwuXdggIklgICJVWCAiZVQgImlQICJlUCAiWVQwMmYENDZfJDQ2Y/w4O + mv8JCYGcAAAAVQAAAFIAAABUCwuG2AwMk/8KCni0AAAARgAAACULC5WGDAyU/yAghcdaWqniZma3/1pa + sf9LS67/Hx+Z8gcHn/8HB5//Bgaf/wcHm/8HB5H/CQmO/wsLhusAAAB5AAAATwAAACgAAAAVAAAAFQAA + AB4AAAAkAAAAIwAAABcAAAALAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAUAAAAHAAAACAAAAAgAAAAHAAAABQAAAAUAAAAFAAAABQAA + AAUAAAAGAAAACgkJp00ODpvVDg6a/w0NktEHB2eMBgZRjQsLie0MDJP/CAhzmQAAADcAAAAbCwuckQ0N + l/8GBlyBAAAATSMjZ140NIWIDw+G4wgIn/8HB6f/Bgan/wYGp/8GBqX/Bweb/wgIjv8LC4//CQluxgAA + AGsAAABGAAAAMQAAAC8AAAA5AAAAQQAAAD8AAAAxAAAAGwAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwOYGQ0NoKgNDZn/DAyU/wsLkf8LC5D/DQ2X/wIC + T1sAAAAjAAAAEAwMo4wNDZn/BwdtiAAAAE4AAAA/DAyHtwkJkf8HB5//Bgan/wYGp/8GBqf/Bgan/wYG + of8GBpP/CQmM/wsLjfkAAACBAAAAYgEBKFcJCY2UDg6f5w4On/QDA15sAAAARAAAAC4AAAAUAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAGCwurWw4O + mPENDZX/DQ2X/wwMlqYAAAAjAAAAEAAAAAcGBq08DQ2b/w0Nk9IAAABVAAAATRYWmf8LC5L/Bwef/wYG + p/8GBqf/Bgan/wYGp/8GBqX/Bgab/wgIjv8KCo3/BwdXtgoKeLYODp70Dg6e5woKkYsNDZrZDg6f8wEB + K1MAAAA+AAAAIwAAAAwAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMDA58YCAiuTAYGoEEAAAATAAAADAAAAAUAAAABAAAABw0NncYODpr/BQVhfwAA + AFc2NqP2MTGh/x4eo/8SEqX/Cgqm/wYGp/8GBqf/Bgan/wYGn/8GBo//CQmL/wwMkv8ODpj1CgqSnwEB + SzIAAAAXBASJNA4OnPIKCpGfAAAARwAAADMAAAAXAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAEAAAAAAAAAAAAA + AAIICKtMDg6a/w0Nj9IAAABZNzeXvUNDqP88PKX/OTmn/zU1rv8rK7L/IyOx/x4erf8WFqH/GxuW/x4e + lf8XF4jUAQEvUAAAACIAAAANAAAABQAAAAYMDKWLDg6f/wICS14AAABAAAAAJQAAAAwAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACA0NmsgNDZn/BgZeghAQNV1OTq3kUVGt/0tLqf9HR6v/RESy/z8/ + tP87O6//ODil/zU1oP81NaT/Dw9QZwAAACcAAAANAAAAAgAAAAAAAAABAgKNGw4On/8LC5OsAAAASQAA + ADMAAAAWAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUICJhVDQ2Z/wwMicAAAABMGhoaNVFR + s7NfX7X/Wlqx/1RUsP9RUa//Tk6s/0xMqv9KSqz/ODifuwAAACwAAAASAAAABQAAAAAAAAAAAAAAAAAA + AAUNDaGpDg6c8gEBK1IAAAA7AAAAHgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAQFUKg0N + mf8NDZLVAAAASAAAACYAAAAOU1PCT1tbs85oaLf/ZGS0/2FhtP9cXLP4RUWnrwAAACMAAAARAAAABgAA + AAEAAAAAAAAAAAAAAAAAAAACBgatPA4On/8LC5ScAAAANgAAAB8AAAAKAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACAcHkFkNDZr/DAyNvwAAAEAAAAAfAAAABwAAAAUAAAAYFRV/eCMjnv8kJIejAAAANwAA + ABsAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcODqfEDg6l8QAAACQAAAAVAAAACAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLC5iUDg6a/wgIfJEAAAA2AAAAFgAAAAMAAAAKAAAAIA0N + ls4NDZjoAAAAOgAAAB4AAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBAS/JwsL + uIcAAAAQAAAACgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAQDQ2avQ4OnP8BAS1TAAAALAAA + AA4AAAADAAAAEQkJk3wODp//BQVvdgAAADAAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADAAAAAwAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAFQ4O + nOUNDZfRAAAAPQAAACEAAAAIAAAAAwEBZiMODp7lDQ2V0gAAAEsAAAAxAAAAFQAAAAYAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABQEBVykODp//CgqKlgAAADMAAAAYAAAABAAAAAMKCrFqDg6d/wcHdX8AAABMAAAAPgAA + ACoAAAAZAAAADgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoICJtmDg6g/wICU1YAAAAoAAAAEAAAAAEAAAABCAi/Rw4O + nvENDZe/AgJLWwAAAEkAAABDAAAANwAAACgAAAAYAAAADAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAQDAyfoQ0NntoAAAA1AAAAHgAA + AAgAAAAAAAAAAAAAAAMHB7Q6Dg6g4g4Onv8MDJa2AgJIYAAAAEsAAABDAAAAMwAAACEAAAAQAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAFw4O + oeUJCZOPAAAAKgAAABQAAAADAAAAAAAAAAAAAAAAAAAAAwICoBgMDKiKDg6e/w4Onv8MDJS5AgJJYAAA + AEQAAAAyAAAAGwAAAAoAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABwUFmkMODqPyAQFAPAAAAB8AAAAMAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQUF + rCoNDaKpDg6e/w4On/IJCZSQAAAAMwAAAB8AAAANAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMDK+YDAyorAAAACAAAAATAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAABQQEpCwNDaapDg6n/woKsIAAAAAUAAAACAAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDg6y0QMDmDEAAAAQAAAACAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAkAAAAKAAAACAAA + AAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQE + 0iQAAAAHAAAABQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /8B/////////wH/////////AP////////8A/////////4D/////////gHg///////+AeB///////8AwH + ///////wDAf///////gEB/////gD+AQH////4AD8BAf////gAHwAB////8AAHAAH////wAAOAAf////A + AAYAB////8AABgAH////wAADAAf////AAAAAB////8AAAAAH////wAAAAAf////gAAAAA////+AAAAAD + ////8AAABAH////wAAAEAf////gAAAYA//8H/AAABgB//wH+AAADAH//AD8AAAAAf/8AB8AAAAB//wAA + wAAAAH//AAAAAAAAf//AAAAAAAB///AAAAAAAP///AAAAAAAP4D/gAAAAAAAAP/gAOAAAAAA//gH8AAA + AAD4AAAwAAAAAPgAABAAAAAA+AAAAAAAAAP4AAAAAAAAf/gAAAAAAAAf+AAAAAAAAA//gAAAAAAAB/// + /gAAAAAH////AAAAAAP////AAAAAA////+DAAAAB/////+AAAgH/////4AAHAf/////gAAcB/////+AA + D4H/////4AA/gf/////AAH/B/////8AAP///////wAAP///////AAAP//////4DAAf//////gOAB//// + //+A8AH//////4H8Af//////gf8B//////+D////KAAAADAAAABgAAAAAQAgAAAAAACAJQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAh7AQICLzIAAAZNAAACDwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmXCw4Oq+wEBCacAAAAPgAA + AQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsL + sZMMDHPYAAAAcAAAAQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAsLsScODqb6AwMfnQAAADYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7G3Cwtk0wAAAGkAAAELAAAAAAAAAAAAAAAAAAAAAAIC + HggAAAA3AAABEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrNPDw+d+wICEZMAAAAqAAAAAAAA + AAAAAAAAAAAAAAsLiIIFBS2jAAAAOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7EFDAyv4QoK + T8oAAABcAAABBgAAAAAAAAAAAAAAAA4OpbYNDVvZAAAAUQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAACgqyhRAQjPQAAAeJAAABHgAAAAAAAAAAAAAAAAwMqcIPD2/pAAAAWgAAAQMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQoLAAABKQAAAEIAAABKAAAAPAAAABwAAAAFAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAACgq1JA4Opf4HBzi8AAAASgAAAAIAAAAAAAAAAAsLqcoQEHTuAAAAXAAA + AgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEIRUGBjKHDAxMzRAQVN8QEEbaCgonvgEB + BI0AAABXAAAAGgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAoKtMQPD3XpAAABegAAABEAAAAAAAAAAAsL + qc8QEHTtAAAAWAAAAgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBB1BBISgboODpD+Dw+L/xAQ + iP4SEn/+FhZw/hcXWvQKCiK+AAAAewAAAC0AAAADAAAAAAAAAAAAAAAAAAAAAAoKtmgQEJn+BAQfqQAA + ADQAAAAAAAAAAAoKrdEPD3HpAAAAUQAAAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBitRhMT + sP8HB6b/Bwei/wgIoP8JCZz/DQ2R/xMTf/8YGGj+ERE62AAAAYgAAAAyAAAAAwAAAAAAAAAAAAAAAAoK + sxYMDKn2DAxU2AAAAF8AAA0GAAAAAAkJtNsNDWniAAAASQAABAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAGxvIbBERu/8FBa7+Bgan/wYGpv4GBqb+Bwej/goKmv8REYf+GBhs/hMTP94AAAKIAAAAKwAA + AAEAAAAAAAAAAAAAAAALC6uxEhKC+QAAA2wAAA8IAAAAAAoKs9sMDF/aAAAAQQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAGRnLVhYWwP8FBbH+Bgao/wUFpv4FBab+Bgam/gYGpP8KCpz+EBCJ/hgY + bP8QEDbVAAAAeAAAABcAAAAAAAAAAAAAAAAKCpmjERGC9gAAAU4BARUCAAAAAAoKs9sLC1nUAAAAQAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRnLFhoaxvsICLf+BQWr/wUFp/4FBab+BQWm/gYG + pv8GBqX+Cgqc/hERhf8ZGWb+CQkeugAAAFQCAgIGAAAAAAoKhQ4LC5ruDAxc0QAABSgAAAAAAAAAAAoK + stsMDFnXAAAASwAAAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZzqcTE8D/BQWx/wYG + qP8GBqf/Bgan/wYGp/8GBqb/Bgak/wsLmP8UFH3/GBhZ9AEBBI4GBgcoCAg5AwgIhF0ODpX/BgYukwEB + DQ0AAAAAAAAAAAoKsdcODmXlAAAAZAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsb + 0CYcHMn0DQ28/wUFrv4FBaj+BQWm/gYGp/8FBab+Bgam/gcHov8ODpD+Fxdu/gwMLMYAAABOBAQ4AwkJ + m7oPD4T0AAAGSwEBEQIAAAAAAAAAAAoKr88SEoD4AAAEhwAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAlJdNuJyfJ/hAQuv4FBa3+BQWo/gYGp/8FBab+BQWm/gYGpf8KCpv+ExN+/hUV + VO0AAABwAwM6GAsLo/oKClTDAQEJHwAAAAAAAAAAAAAAAAgIu7cQEJj+BgYntAAAAD8AAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKtEBMzPUljU1zP8cHL7/Bgau/wUFqf8GBqf/Bgan/wYG + pv8ICKH/Dw+L/xoabv0DAwuFBARJSA0Nmv4EBCCTAAAIEgAAAAAAAAAAAAAAAAgIvTYLC6/2Dg5q4QAA + AHcAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANzfTAkBA15NERND+NDTG/hUV + tv8GBqz+BQWo/gYGp/8HB6T+FRWV/iwsgP4FBQ+SBAQ8YxAQjf4DAxadAAABJAAAAAAAAAAAAAAAAAAA + AAAJCbpnDw+h/QUFKKsAAABLAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBERUAAABCAAAAHQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEND + 1gFJSdhgUFDV701Nz/9CQsj+MjK//i0tu/8zM7r+PDyx/jY2kf4HByeyBAQmmRMTfP8LCzDEAAAARwAA + AAIAAAAAAAAAAAAAAAAAAAAACwumrhAQduoAAAOIAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJk6oGBkikAAAEcQAAAEsAAAAeAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAUFDXFlNT1YpYWNXlV1fR/lNTzf9PT8r/QUG//xMTnPoMDHrvDAyA+RIS + ev4TE03mAAAAgAAAAC4AAAIHAAABDQAAAxoAAAwgBAQ9WxISh/8KCjbGAAAASAAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJqD4LC6+2DAyU3wYGR6IAAApyAAAAWQAA + ADIAAAASAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLnoHKChsMyQkVVghIVVUEBBzYAgI + qucICKf+Cgqf/hAQiPoWFmz9Dw841QEBBpIBAQZiBQUeigYGKKgGBjOxBQVBvBAQiP4QEGbaAAACMAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqmLwsL + rKANDaPqCQlmwgQEJ5cAAAF1AAAAVQAAAC4AAAASAAAABAAAAAAAAAAAAQELBAQEDxYBAQQ5AQEQbQMD + GY8BAQqGAwMKczY2rPckJLD+ICCv/goKnf8PD4n+FBR1/hERWuwREXD2ERGC/g8Piv8MDJX+Cgqa/w0N + mPIHB0NcBQUqBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCqgbCgquiAwMru0NDZDtCQlWygQEIqUAAAJ+AAAAWAAAATEAAAIyAgIRZQgI + RLANDXjoDw+R/g4Olf8NDZj+CAiA6xAQbNoXF47wBgam/wYGpf8JCZ//CwuX/wwMkf8MDI3/CgqO/gkJ + lu0ICJm6BweCcgUFVBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKrw8KCrRuCwuz2g4Oov4PD4TxCgpR0QYG + O7wLC2vdDg6R/AwMm/4KCprXCQmPgQkJm1sICLSaBga44gUFsv8EBK7+BQWt/gYGqP8GBqb+Bwek/ggI + nv8LC4T8BQUmtwAABloBARQeAQEVIQAADx8AAAsOAAACAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqyBAkJ + t08JCba5Cgqt/QsLpv4KCqHkCAiSkwgIiTkICIsEAAAAAAAAAAAAAAAABwe6BA0NxU8QEMH8BAS1/gUF + q/8FBaf+Bgam/ggIn/8PD4j+EhJk9AcHHrUICCWqCAgrsAQEGJoAAABzAAAAOgAAAAoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAgEAAAEFAAABCwAAABMAAAAaAAAFEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABwezHwgIqywICJgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAiIseTHh68/g4OsP8GBqn/Bgao/wcHo/8LC5b/EBCE/xISeP8TE3P+EhJ8+hISjP0NDWjdAgIUnAAA + AGIAAAAhAAABCwAAAhEAAAIeAAABMgAAAEoAAAZlAwMYgwQEJpoFBTOiAgIXQAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAMDJg1Fxez+yoqtP8WFrL+BQWw/gYGqv8HB6P+CQmd/gwMkv8ODm/0AgIQkgQE + RGINDZjfERGJ+AgIPcAAAAaHAgIQewUFJ5cICEK3Cwtf1A0NfOsPD5H6Dw+a/w8PnuYNDYuiBgZGHAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAEEwAAACYAAAAqAAAALQAAADAAAAAwAAAAMAAAADAAAAAwAAAALwAA + ACsAAAApAAAAIAAAAAkAAAAAAAAAAAAAAAAGBrOcBgak/gwMaM0zM6vgICC//gYGsf8GBqj+Bgak/gsL + l/8SEnv+BwcouAAAAEoBARBeCQlexRAQkP0ODo/5Dg6Y/Q0Nnv4LC6T7Cwun0wsLp58LC6ZoDAyiLQwM + mAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBXgeBQVLiQcHQ7gICEDACQlGxQkJRcYJCUXGCQlFxgkJ + RcYJCUbGCAg9wggIOr8ICDS5AgIRmQAAAGAAAAAZAAAGAQAAAAAGBrLLCwuZ/wMDIZITE0sqQUHI0jQ0 + wf8YGLL/DAyr/w4Onv8aGoX/FBRH1g0NVdkNDWjrBwcyxAICHZsFBVeMBwd9WgkJkjEKCqUIAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBqEvCQm2ugoKsvQLC6j+Cwul/gwM + o/8MDKL+DAyj/wwMo/4MDKP+DAyj/g0Nov8PD5v+EhKI+QcHMrcAAAByAAACKQICOQYICKHWEBCN/gIC + D3gKCjkJExOokkZGwv9ISMH+ODjB/isrt/8kJKL+EhKF/Q4Oif4QEIb+ExN2/wwMOtEAAAB2AQEXFgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJ + twsICLYoCQmvPAkJrD8JCas/CQmtNQkJry0JCbIlCQm1HAoKsiMLC61ICwuvrQ8PofwJCVPFAAAFhwAA + AF0KCoPoEhJ/+gAAAFkEBEIEBgawwAoKe903N3qsT0/K2zs7ueUWFqn5CAij/wgIof8KCpr/ERGG/xgY + af4ICB64AAAATAAAAwMAAAwCAAAEFAAAAC8AAAAaAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK + s1ALC7DrCwuU8wcHcN8MDIv6Dg5p2wAABy0AAAAABwe4ygYGV8sAAABSERFVEAMDmNQFBav+Bgao/wYG + pv4HB6T+CwuY/xQUe/4WFlPuAAABgQAAAigBARFRCAhIqAcHPa8AAABrAAABFQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAICLcjBgbBvgcHtv4LC6f5BgZEYwQEKQYAAAAACAi0mgwMiO0AAASEBwdIcAgI + tP8FBa/+Bgao/wUFpv4GBqb+CAih/w4Ojv4WFm/+BwclugkJUMENDZTpCgqAlRAQoOkFBTGfAAAATQAA + AQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABga/AgcHvSoHB54fAAAAAAAAAAAAAAAACQm0LwwM + qv0GBju5DQ08kSgovv8fH73/FRWw/w0Nqv8HB6f/Bgal/woKmv8REYX/ExN//AoKaaMGBlEgAAAAAAsL + qF8ODo3oAAAFfAAAARwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAkJt6ULC4rtAQEIgzExodA6Osr+NjbE/zIyu/4uLrb+KSmy/ycnqv4oKJj+CwsyiQQE + JwoAAAAAAAAAAAoKqgUMDLHXBwdAsQAAAE4AAAEDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKsSkMDKT6BAQxsAkJHD5ERMK0TEzR/khIyv5ERMP+QUG7/z8/ + sf4zM5DZBQUTIwAAAAAAAAAAAAAAAAAAAAALC7BpDg6L6AAAAXgAAAEXAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqQYNDaPrCAhHvAUFESAnJ24CSkrFUFNT + zrxWVsb7UlK29T4+k6kiIl0jGxtOAQAAAAAAAAAAAAAAAAAAAAAKCrMODQ2x7AUFNqEAAAA1AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqiYODp3+BQUqlAIC + DA4AAAAAAAAAABYWbysJCaDzAgIeYBwcSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgq0eQkJ + iaUBARgSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK + qlcODpX6AQEKXQEBDAMAAAAACQlnAgkJgLYICF66AgITFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAYGgwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAsLqIsLC3LaAAAEMQAAAAAAAAAABweHSg0NlvcBAQ9dAQERBQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqMIGBkGjAQEOEwAAAAAAAAAACAi7ogkJds0AAAFzAAAAQQAA + ABMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqdCQ0NovIBARFcAQESBAAAAAAAAAAACAiyIgoK + t9ILC4DXBAQrngAAAHMAAABBAAAAEgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmQSAoKd9EAAAgoAAAAAAAA + AAAAAAAAAAAAAAkJrgoKCrOCDQ2s8wwMedwEBCafAAAAbwAAAC0AAAIDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmRnwQE + N4MBARYKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqzGwoKtpcODqn1CgprxwAACFIAAAMJAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAICK4QCQmiyQEBESEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrAdCgqieQUF + ThkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAICLAFBQWDKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//8P///wAA///wf/// + AAD///h///8AAP//+D7//wAA///8PH//AAD///w8f/8AAP///Bw//wAA//P+HD//AAD/wH4MP/8AAP+A + Hww//wAA/wAPDD//AAD/AAcEP/8AAP8AA4R//wAA/wADhH//AAD/AAEMP/8AAP+AAAw//wAA/4AADD// + AAD/wAAcH/8AAP/AABwf/wAAv+AAHg//AAAP8AAPD/8AAAP8AAAH/wAAAH8AAA//AADADAAAD/8AAPAA + AAA//wAA/AAAAA//AAD/AHAAB8AAAP/j/AAAAAAA///8AAAAAAD4ABwAAAMAAPAABAAAfwAA8AAAAAH/ + AAD8AAAAAAcAAP//wEAABwAA///gQAADAAD///HAAEMAAP///+AAwQAA////4AHhAAD////gAeEAAP// + /+GH8QAA////4Q/7AAD////jD/8AAP///+MD/wAA////wwD/AAD////HgH8AAP///8fgfwAA////j/j/ + AAD///+f//8AACgAAAAgAAAAQAAAAAEAIAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiaBgQEPm8AAAIvAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ2nxAEB + EHoAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAALC7FbCQlVxgAAAC4AAAAAAAAAAAAAAAAAAAcEAAABBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAoKtgYNDZ3hAAAHbgAAAAMAAAAAAAAAAAgIWG8AAABIAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLr4oICEC6AAAAIAAAAAAAAAAADw+e0AICEXcAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQELAQAA + AhYAAAAvAAAAKwAAAA4AAAAAAAAAAAAAAAAAAAAACgq2KA0Nhu4AAAFaAAAAAQAAAAANDaDaBAQdhgAA + AQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAHBzxbDQ1b1BERYOoQEEPZBQUUnQAAAEIAAAAFAAAAAAAAAAAAAAAADAysyAUFJqQAAAAQAAAAAA0N + od8EBB2CAAABAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAFhagIBAQqfoJCZ7/Cgqa/w4OjP8WFnH+Dg40zwAAAF0AAAAHAAAAAAAAAAAKCrNtDAxi3QAA + ADsAAAAADAyn5QMDGHUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAaGslGDg65/wUFqP8GBqb/Bgak/woKmf8UFHr/EBA71wAAAFYAAAADAAAAAAkJ + qBoQEI/8AAADSAAAAAAMDKfnAgIOZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZzBoUFMH9BQWs/wYGp/8GBqf/Bgam/woKm/8VFXf/DAwpwQAA + AC8AAAAACQmOQw0Nd+cAAAchAAAAAA0NpucBAQxqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoay64KCrf/BQWp/wYGp/8GBqf/Bgal/wwM + lf8XF2f6AgIJgAcHKgoKCo+jCAhFqgEBCwYAAAAADQ2k4gQEGY8AAAAGAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHx/RICIiyfAKCrT/BQWo/wYG + p/8GBqf/Bwei/xISg/8NDTLGAgIlIwwMm/ECAhZSAAAAAAAAAAAKCq/UCQlAxQAAACQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMjLTRDU1 + zPYWFrj/BQWq/wYGp/8GBqb/DQ2T/xcXVOIDAy9WDAx25wAABDIAAAAAAAAAAAgIvFMODovxAAAEaQAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRkAAAAcAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAARETWOExM1N87O8f/JSW6/yAgtf8tLaz/KChx7QMDH4kSEnH1AAAAWgAAAAAAAAAAAAAAAAoK + npEJCUTCAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmSqwUFOpsAAAJRAAAAIAAA + AAUAAAAAAAAAAAAAAAAAAAAATU3OCU1Nw21PT8S+Tk7B2jo6vNsNDZbsCwuK+xMTd/0HBxqqAAAAOgAA + ASAAAAM6AgIjXxMTffoBAQpnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrAFCwuqXwsL + lrgHB0+wAQESdQAAAEMAAAAaAAAABAAAAAAICBkCDQ0lFAgIGkMBAQ9qAwMRWiMjrvsZGaz/DQ2T/hUV + cf0MDELSDg5k4w4Oe/QKCor2DQ2G4QQEJSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAACgqyAQoKrkgMDK25Cwt84QcHQLsCAg9+AAAGUQUFMYgKCmjUDQ2V9wwMm+4JCZX2EBCE6AgI + pv8GBqX/CQmc/wsLk/8JCXTsBgZspgUFalsEBD8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrUuCgqymwwMpfMMDJn4CgqWxQkJkmwICIkVCAiiAgYG + ujgMDMGwBga2/wUFqf8GBqb/CgqZ/w4OXusEBBWVBQUchwEBC3AAAAA0AAAABQAAAAAAAAAAAAAAAAAA + AQEAAAAGAAAADgAAAg0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgaPDQYGihQAAAAAAAAAAAAA + AAAAAAAAAAAAABYWvxEfH7PdEhKw/wUFqv8ICKL/DQ2P/xERff8ODl7fDw+F5AkJSMUAAANnAAAAJwAA + ATABAQtSBAQlgQcHPacJCU+9BQU2aAAAAAAAAAAAAAAAAAAACgkAAAAaAAAAHQAAACAAAAQgAAAEIAAA + ACAAAAAcAAAAFwAAAAQAAAAACgqrDQYGqPQeHovbHh67/gYGrf8HB6T/DQ2P/wkJOscBARRJCQljxQ4O + eesKCmzdDAyJ8A0Nn+kMDKK2DAyifQwMlj0KCnEDAAAAAAAAAAAAAAAABgZ9mAkJY9EKCmHXCwth2AsL + YdkLC2HZCgpd1wsLV9MJCT2/AAACYwAABA4EBH40Cwue/wICFGYuLqqGNzfA/xsbsv8XF5//GBhn7A4O + auoMDFPfAwMmnwUFVU4ICIoZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLcaCAi4XAkJ + sXoJCax/CQmsegkJr3IJCbJpCgqucQwMqbUMDHXfAQEOgAICMm8QEIr9AQEPRAcHk3klJYrbSEi93zEx + tvINDZ/9Cgqb/xAQh/8SEk7lAAACWAAADQEAAAgJAAAAHQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKs1QKCqfrCAiK7w0NcdcCAiEWBwefgQUF + QbcICDYxBASk6wUFqf8GBqb/CQmd/xUVeP8ICB6sAgIXVwkJXLUICEKyAAAAOQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGwR0HB7dyBwdwKAAA + AAAICKwyCwuI6ggILI0cHLz/ERGw/wkJqP8GBqX/DQ2S/xERbvMLC3CnCAhxIw0NpawDAx2JAAABDgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCrCtBQU1rC8vlsE9Pcn/Nze+/zAwtv8tLaf/FBRLnAUFLAQAAAAACgqyKwoK + cNMAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKrFAKCmDSDg4sHEdHvXNSUszfUFC8+js7la4XF0MTAAAAAAAA + AAAAAAAADAyutwICGX0AAAEGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwupdggIR64DAw4HAAAAAA4Of4UEBDx8GhpDAQAA + AAAAAAAAAAAAAAAAAAAKCrA1BgZpUAAAEQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKSpAwMhagAAAAAGBngiCgp51wAA + DRkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLks8AAAsnAAAAAAgI + tlcICGrGAAAFYgAAACMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCZYjBwdZrwEB + DggAAAAAAAAAAAkJs1oMDJnXBwdDtAAAA2EAAAEWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJ + m3gCAiFKAAAAAAAAAAAAAAAAAAAAAAoKtwwLC7J5DAyS0QEBFzQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAABgaTRAMDPQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCaYBAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA//j////8f////HP///wz///+Mf/8HhH//AcR//gDE//4ARP/+AET//wAEf/8ADH//gAw/x8A + OP8HgAD/AIAA/8AAAf/4AABw/nwAAOAEAADgAAAf4AAAA//wAAP/+IAB///AEf//wDj//8R4///I//// + yD///4wf//+eH///n78oAAAAEAAAACAAAAABACAAAAAAAEAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABARTAQUFPncAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC5aCAAACKAAAAAACAhgwAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAMFAAAAFgAAAAMAAAAACAicLAUFMogAAAAACQlbqgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCkwICwt3yg4OcvAKCi6rAAAAGgAAAAAKCnquAgI0EwgIX68AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAADw+AGAsLtP4GBqb/DAyV/wwMN7sCAhcMDAyPkAICNhoHB1qnAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGcevBwer/wYGpv8PD4j9BgYiXQgIYaQDA0kBCQlrwwAA + AAoAAAAAAAAAAAAAAAAAAAAAAAACDQAAAAAAAAAAJyenETc3y8MbG7T/GBim/xERRasHBzuaAAAAAAkJ + lXUCAhJYAAAAAAAAAAAAAAAAAAAAAAgIimsEBDp2AAAELwMDCwcmJmsDLCxyYCMjZ54VFZ74Dw9l6QYG + KoQGBkuhCQlNmgAAAAAAAAAAAAAAAAAAAAAAAAAABweNEgoKp3IICGqyBwdZpgoKhpMJCaOHCgqo5QcH + pP8LC4D1BQVChwICGywAAAABAAAAAAAAAAIAAAAGAAAAAAAADwIBASMOAgJDEwMDPxUBASINAgIzARER + sXwVFaj2CAih/w0NaekJCVGuBgY6lgYGTZcJCWmWCQljWQAAAAAGBposCQmLoAoKhqsKCoiiCwt7rgMD + InQICHaoDg5YajAwru4bG5f2DQ148gYGM4sEBEwJAwM5CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAICLVXCQmJmAUFazIICEuYDg6u+ggIpP8PD2XnBwdVdgYGQYgAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAACQl9nzAwkpRCQr/2JSVzlwMDLwELC6JtAAAGMQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJbo4JCUQKBwdRfAAAAAAAAAAABQV6DQMDShQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFWQkFBUFrBQV2FQcHb5YBARJPAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBpIvAQEbEwAAAAAFBXkDCgqpUwICJA0AAAAAAAAAAPx/ + AAD+XwAA4k8AAMEfAADAHwAA4A8AAGBPAAAADwAAgAQAAIAAAACAAQAA/AAAAP+AAAD/jAAA/wMAAP8j + AAA= + + + + AntMe! - 2D-Visualisierung + + \ No newline at end of file diff --git a/GdiPlusPlugin/Window.resx b/GdiPlusPlugin/Window.resx new file mode 100644 index 0000000..a666ceb --- /dev/null +++ b/GdiPlusPlugin/Window.resx @@ -0,0 +1,4405 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + 8, 68 + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + 4, 4, 4, 4 + + + 400, 300 + + + + 9 + + + splitContainer.Panel2 + + + Show Points + + + 110, 21 + + + cbUseAntiAliasing + + + 0, 4, 0, 8 + + + splitContainer.Panel2 + + + insectsPanel + + + System.Windows.Forms.SplitterPanel, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 784, 566 + + + 0 + + + True + + + splitContainer + + + splitContainer.Panel2 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + AntMe! - 2D-Visualization + + + 0, 0, 0, 0 + + + System.Windows.Forms.SplitContainer, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Selected Insects + + + 6, 13 + + + Microsoft Sans Serif, 8.25pt, style=Bold + + + 2 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 61, 21 + + + 1 + + + splitContainer + + + splitContainer.Panel2 + + + 3 + + + 170, 422 + + + 12 + + + 0, 0 + + + btnResetView + + + 8, 523 + + + 0 + + + 85, 17 + + + splitContainer.Panel2 + + + 3 + + + 8 + + + 8, 540 + + + Window + + + 5 + + + 8, 8, 0, 8 + + + Settings + + + 784, 566 + + + 0, 0, 0, 0 + + + label1 + + + True + + + Bottom, Left + + + 0, 8, 0, 4 + + + splitContainer.Panel1 + + + 0, 0, 0, 0 + + + System.Windows.Forms.Form, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Fill + + + 8, 12 + + + 1 + + + 4 + + + 10 + + + cbShowScore + + + splitContainer.Panel2 + + + NoControl + + + System.Windows.Forms.FlowLayoutPanel, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.SplitterPanel, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + True + + + label4 + + + splitContainer.Panel2 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 0 + + + 0 + + + Bottom, Left + + + 4, 4, 4, 4 + + + 593 + + + 11 + + + True + + + Reset View + + + 105, 17 + + + 8, 498 + + + Microsoft Sans Serif, 8.25pt, style=Bold + + + + AAABABAAgIAAAAEACAAoTAAABgEAAEBAAAABAAgAKBYAAC5NAAAwMAAAAQAIAKgOAABWYwAAICAAAAEA + CACoCAAA/nEAABAQAAABAAgAaAUAAKZ6AACAgAAAAQAYACjIAAAOgAAAQEAAAAEAGAAoMgAANkgBADAw + AAABABgAqBwAAF56AQAgIAAAAQAYAKgMAAAGlwEAEBAAAAEAGABoAwAArqMBAAAAAAABACAAHHoAABan + AQCAgAAAAQAgACgIAQAyIQIAQEAAAAEAIAAoQgAAWikDADAwAAABACAAqCUAAIJrAwAgIAAAAQAgAKgQ + AAAqkQMAEBAAAAEAIABoBAAA0qEDACgAAACAAAAAAAEAAAEACAAAAAAAAEAAAAAAAAAAAAAAAAEAAAAB + AAAAAAAAPz9fABkZZQAWFm0AGBhqAA8PegAUFHMAHBxzABISewAfH3oAISFjACoqYgAtLW0ANDRjAD4+ + YAAyMmoAOztsACYmcQArK3MAIiJ9ACwsewA0NHUAPDx0ADw8fABBQWQASUllAENDbQBMTG8AU1NnAFRU + bABcXGsARERzAEtLcwBHR30ATU1/AFZWcQBZWXIAVVV+AFpafwBmZmYAYGBpAGtrawBnZ3IAZ2d4AHJy + cgBycn8Ae3t7AA4OhAAODowAEhKDABkZhAAREYsAGhqLAA0NkwAGBp4ADAybABERkwAbG5IAEBCZABAQ + nQAWFp0AGxuaACQkhAAtLYIAIyOMACwsiwAyMoQAOzuFADMziwA7O4wAJCSSACsrkQAiIpsALCycADQ0 + lAA9PZIAMzOcADw8mwA4OJ8APj6dAAYGpgALC6IABgaqAAkJqQAMDKkACgqtAAwMrQAQEKEAFRWiABAQ + pQAVFaUAGhqkABAQqQAVFaoAFRWtABoaqwAFBbMACQmxAAwMsQAJCbUADAy0AAUFugAKCrkAEhKyABsb + swAUFLwAGRm5AB0duQAYGL0AHh69ACQkpAAoKKEALy+hACwspAAiIqsAKSmtADMzogA6OqQAMTGsADo6 + rAAjI7MAKyu0ACMjvAArK7sAMTG0ADo6tAAzM7sAOzu8AEJChwBKSoUARESLAElJiwBcXIIAU1OMAFxc + igBDQ5EATEyTAENDmwBOTpoAVFSTAFpakgBTU54AXFyYAGFhhQBra4UAYmKKAGxsiwB3d4MAeHiEAHFx + iAB+fooAY2OTAGtrkwBiYpsAbGyaAHNzlQB7e5IAdHSaAEFBpABKSqQAQUGsAEpKrABXV6QAW1uiAFVV + qQBZWawARESyAEpKtQBERLwAS0u7AFFRswBVVbwAXFy+AGdnoQBqaqEAZGSuAGtrqgB2dqEAcHClAH9/ + ogBycqwAe3uoAH5+qQB9fawAYWGxAGRksgBiYrUAa2u2AGNjvQBpabwAdXW1AHR0ugB9fbgAFBTAABsb + wwAcHMkAJCTDACsrwgAlJckALCzKADQ0wwA8PMIAMzPKADw8ygA8PNAAQ0PDAEtLxABDQ8sAS0vLAFRU + wwBcXMIAU1PMAFpaywBERNIAS0vRAFNT0QBbW9MAWlraAGJiwwBqasEAZGTKAG5uzQB2dsMAdHTLAHt7 + ygBgYNMAYWHVAGVl1gBoaNIAYmLaAGtr2QBzc9EAfHzSAHFx2gB2dtgAcHDdAHl52gBoaOEAcnLiAH19 + 4wCCgpkAgICjAICArQCAgLgAjY3JAJSUzwCEhNUAiIjVAICA2wCIiNkAgYHjAISE6ACQkOQAAAAAAAAA + AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFy6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrXFm3AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtkWXAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRZ + O7IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA4lxZTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAZFk7sgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKXFlOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRcO4kAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+lxcOwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7 + jQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAADXXFk5AAAAAAAAAAAAAAAAAAAAAAD2pwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABkXDuZAAAAAAAAAAAAAAAAAAAAAFw7TgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRcO0YAAAAAAAAAAAAAAAAAAAAAXDs4nAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA72RZOJkAAAAAAAAAAAAAAAAAAABcOziMAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7SgAAAAAAAAAAAAAAAAAAAFw7 + OIIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXXFk4mwAAAAAAAAAA + AAAAAAAAXFk4QgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTuH + AAAAAAAAAAAAAAAAAABcWThBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAGlcOzmWAAAAAAAAAAAAAAAAAGRZNTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAA62Q7OIsAAAAAAAAAAAAAAAAAXFk4NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAZFw7QAAAAAAAAAAAAAAAAOxhWTU0AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKXDs4lwAAAAAAAAAAAAAA7FxQODQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACbgRcSEgwSGiQsLC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkWTVFAAAAAAAAAAAAAADrZFk1NAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAACiMjExMQcGBgMDAwoQJCwuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRcOzSSAAAAAAAAAAAA + AOxcWTUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAPTQwMTExMTExBwYDAwMCDR4sLgAAAAAAAAAAAAAAAAAAAAAAAAAA12E7NYIA + AAAAAAAAAAAA7GFZNUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAHI7NTU0MDAxMTExMTEDAwMCAhgpLAAAAAAAAAAAAAAAAAAAAAAA + AAAAYVk7OS4AAAAAAAAAAADsYVk1QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+Wzs7NjU1OzU7NTU0LzExAwMCAgsdLC4AAAAAAAAA + AAAAAAAAAAAAAABpXDs0hQAAAAAAAAAAAOxhWTVBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+XhcUDY2NjY2Njs2OzYwNDExBwYDAgoZ + KS4AAAAAAAAAAAAAAAAAAAAAAOJkOzVBLgAAAAAAAAAA7GRZNUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQeGdcUlJZUFBQNjY2OzY7 + NTA0MQMDAgIYKS4AAAAAAAAAAAAAAAAAAAAAAGRZNTSQAAAAAAAAAADsXFI4QQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGtraVJhUlJQ + UFBQUFBQNjY7NjAwMQYDAgINKSwAAAAAAAAAAAAAAAAAAAAAxFk7MIAAAAAAAAAAAOtkWTWIAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + wmtpYWFSUlBQUFBQUFBQUDY7NjU0MTECAgINKS4AAAAAAAAAAAAAAAAAAADmWTs0MgAAAAAAAAAA7FxZ + NYgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADCwmlhZVJSUlBQUFBQUFBQUFA7NjUwMQYDAgINKS4AAAAAAAAAAAAAAAAAAABcNjQ0AAAA + AAAAAADsYVk1iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAMLCwmVhYVJSUFBQUFBQUFBQUDY2NjU1MTEDAgIZKQAAAAAAAAAAAAAAAAAA + AFk2MDAAAAAAAAAAAOxcXDWLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1cLCZWFhUlJSUFBQUFBQUFBQUFA7NjUwMQYDAgIcLAAAAAAA + AAAAAAAAAAAAWTswQAAAAAAAAAAA7GRZNZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiwsJmZWFhUlBQUFBQUFBQUFBQUFBQOzswMQYD + AgoeLAAAAAAAAAAAAAAAANFQNTRFAAAAAAAAAADsXFk1lwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDwsJlYWFSUlJQUFBQUFBQUFBQ + UFA2OzYwMQYDAgspLgAAAAAAAAAAAAAAXDs1MJcAAAAAAAAAAOxcWTWXAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfCwmZlYVJSUlBQ + UFBQUFBQUFBQUFA2OzU0MQYDAhgpAAAAAAAAAAAAAABZOzU0AAAAAAAAAAAA61xQNIIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7cPC + wWVhYVJSUlBQUFBQUFBQUFBQUFA2OzYxMQMCAh4uAAAAAP8AAAAAqFk1NUQAAAAAAAAAAADsXFk1gQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAw8PCZmVhYVJSUFBQUFBQUFBQUFBQUFA2NTUxMQMCDSkAAAAAAAAAAABcNjU4lwAAAAAAAAAA + AOxkWTVDLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADtw8LCZWVhUlJSUFBQUFBQUFBQUFBQUDY7NTAxBwMCHS4AAAAAAAAA6Fk7NTkA + AAAAAAAAAAAA7FxZND4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDw8LBZWFhUlJSUFBQUFBQUFBQUFBQUFA7NS8xAwILKQAAAAAA + AAB4WTswRQAAAAAAAAAAAADsYVk1MSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPvDwsJmZWFhUlJQUFBQUFBQUFBQUFBQUDY7MDEG + AwIdLgAAAAAAAFw2NTWdAAAAAAAAAAAAAO9hUjsxJS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbGxsJmZWFSUlJSUFBQUFBQUFBQ + UFBQNjY1NAUDAw0sAAAAAADcWTs1OQAAAAAAAAAAAAAA72ZcOzRDLAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfGx8RmZWFSUlJS + UFBQUFBQUFBQUFBQOzYwMQYDAyoAAAAAAHhZNjWLAAAAAAAAAAAAAAAAZWFZNTIsAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfH + x8dpYWVSUlJSUFBQUFBQUFBQUFA2OzUwMQMDGwAAAAAAXFA1OPAAAAAAAAAAAAAAAABlZVw7NCUuAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA7szKysfBYWFhUlJSUFBQUFBQUFBQUFA2OzAxBwMQLgAAAABZWTVKAAAAAAAAAAAAAAAAAOJm + YTs1RC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA5czMysrCZWFSUlJSUlBQUFBQUFBQUDY7MDExAxEuAAAA31k7NYwAAAAAAAAA + AAAAAAAAAMZlXDs4lwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2czMzMzHZGFhUlJSUlBQUFBQUFBQUDs1MAYGPywAAACsNjs4 + lgAAAAAAAAAAAAAAAAAAAGVkWThKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2dXPz8vLwmFhYVJSUlJQUFBQUFBQNjUwMRQ/ + LAAAAKA7NTkAAAAAAAAAAAAAAAAAAAAAAGFcWTiYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA79fVz8/PymlhYVJSUlJSUlBS + UFA7NjRBQUIsAAAAoDUwMZIAAAAAAAAAAAAAAAAAAAAA4mVZO0oAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+9fX19DXz8xr + ZmFhUlJSUlJSUFludEpERCwAAACiNTQvIi4AAAAAAAAAAAAAAAAAAAAAylxZOJkAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ANfW19fQ0NDPy8RrZ2dna3h+fX2gdUtFHS4AAIswLzEVLgAAAAAAAAAAAAAAAAAAAAAAaVk4OS4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAO/X19fX19PQztDQ0M7Oy6jOf32eTjISLC4AjzExBgYsAAAAAAAAAAAAAAAAAAAAAAD4 + WTs0gi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAADt2djX19fX09PQ0NDOz86oqaZGMRUgMTEkLzEGAx0uAAAAAAAAAAAA + AAAAAAAAAABbNTQxj5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mR5AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7eLi2NjX09jT09DTzs6pcjs1KzAvLzExMQYHDSkA + AAAAAAAAAAAAAAAAAAAAAKo7MDEVLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADX + ZWRcpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPri4uLY1NTU09PTzmdcUEo7NTU1 + MDAxMQMCKCwAAAAAAAAAAAAAAAAAAAAAtDA0MTGPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADHZGRcWaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/Pjq6t3f6vd/ + UlK+WVk2Ozs7NDAxAwMBJywAAAAAAAAAAAAAAAAAAACYNTAxMUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAz2RkXFm9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAqFxcUlJQNjY5MTExBAIKGSkuAAAAAAAAAI+PhISEhIA0NTQ0QQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9kXFxZqgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABrUFJSUlJZWVk4MDEGAwIDDSkpLiUXEzExBzExMDA1NTU1NTWfAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADPZGRcWaDAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKlfUmFhUmt2WTs1MDExAwMDDRkDBjEGMTExNDU1Ozs2Ozs7 + PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mRkXFlyugAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuqzOfn6of1lQNjs1MDExBgYGBjExMTExNDU1 + Ozs2Njs2WW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOJk + ZFxZWXWwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACXh0E4NDU4OUWFkC6TutrU0WtSUlBQNjs1NTAxMTEx + MTEvNTU2Njs2UFBZUl/dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADiZGRcWVk9n64AAAAAAAAAAAAAAAAAAAAAAJuHQDg4NTU1NTg4Ozs7OEuPk4ZSUlJSUFBQ + UDs7NTU1MDAwMDA1NTU2NlBZXNEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA4mRkXFlZOzmKnQAAAAAAAAAAAAAAAItANDU1ODU7OztZWVk2WVBZUFBZ + XGRhUlJSUFBQNjY2Ozs2NTU1MDAwNkam4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO1rYVxZWTs4RoiSAAAAAAAAjEQ4NDU1OzU7WVlQeVxS + UmRSUlJhYWRhYWFhUlJQUFBQUFA2Njs2NS8RFYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADvaWRcXFk7ODhHhZWGRDQ1ODU7OzY7 + WVB54AAAAADtyGZlZWVhZWVhZWFSUlJQUFBQUFBQNjswMAwnLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRhXFxZOzs1Ozg1 + OzU7OzZZUGvaAAAAAAAAAAAAAADXZWVmZWVhYWFSUlJQUFBQUFA2NjAvBQwpLAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADE + ZWFcXFlZWVk2WVBZXNEAAAAAAAAAAAAAAAAAAAAAAMZmZWVlYWFSUlBQUFBQUDs2MC8FBg0oLC4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA1WVhYWFSUlxn0QAAAAAAAAAAAAAAAAAAAAAAAAAA+8NmZWVhYVJSUlBQUFBQNjs2LwUG + Bg0cHSAfIYGBlwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAANnBZsTiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMbBZmFhUlJSUlBS + UFBQNjUwLzEGBgYGBjEGMTExMYecAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAx8fE + Z2ZhUlJSUlBQUDY7NjUwMTExMQYxBjEGMTE0NDSJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAfn5+xGdhUlJSUlJQUFA7NjU1MDExMTExBjExODU7NThAmAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACbmIiNh0pKdLsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADcfn5+xHhcYVJSUlJSUDZZNjs1NTU0LwwdkAAAbjs7Ozg0iAAAAAAAAAAAAAAA + AAAAAJyXiERGODg4ODg7O1lZbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRkeH5+eXhkYWFhUlJQUFA2Njs7NjAvLx0uAAAA31k7Ozg0OZcA + AAAAAAAAAJuMh0c5NDU4ODg7OztZO1lZc9sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADTUlJSXH19fnlkYWFhUlJSUFBQUDY1NTAxCiwAAAAA + AHY7NTU0NEScmJeIS0c4ODg4ODs7OztZWVlZWVx/3wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRhUlA7PaV9f35pYWVSUlJQUFA2OzY1 + MTExJAAAAAAAALo1ODUwNTg4ODg7NTU7OztZO1BZUFxczt8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYVJSNjaXANvOy37CYWFh + UlJQUFBQNTUvMQMQLgAAAAAAAABKNTU4Ozs7WTtZWVlSXFJSy9wAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtkUlk2NAAA + AN/Oy8vHZGFSUlJSUFA7NTAxBhApLgCSly4uLgCuRjU7WVlQXFJry98AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAK6Yl5ePl4+Pj4+Pj4+Xj4+Xj4+Xj5eQLpYAAAAAAAAAAAAAAAAAAAAA + zmFSUDtBAAAAAOzQzsvLxFxSUlJQUDY1MDEHFScaETExMRIkLC4At7q73wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhkXFk7ODg0MDQwNDQwNDg0NDA0NDA0NDA0MTQ0MTE0P5cuAAAA + AAAAAAAAAADMUlw2NYAAAAAAAOzT0M7Lf35rZ1xcXFlIR0AaDQYxBjEGMTEQKS4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVZmZkXFxZWTtZOzs7Ozs7Ozs7Ozs7NTs7NTs1OzU1 + ODQwMUUuAAAAAAAAAAAAAMtcUDswgQAAAAAAAMzU087Oy3/IfsRzcm5IRhMFBQUvLwUxAwYMKS4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6xmZlZFJcUlxSXFJcUlxSXFJZUFlQ + WVBZXFBZWVlZOzs4NEabAAAAAAAAAAAAf1k7NTCEAAAAAADqYczS09HOzst/fn55cm49ODAwMDAwMQUx + AwYNKS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO/PaWVhZWFhZWRh + YWFhYWFhYWFhZGFhYWFhUlJcXFk7ODmdAAAAAAAAAABzWTYwNI8AAAAAANBhYX7c0tHOzs7Lf35+czs7 + NTs1NTU1NAUGAwMQLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO3EXFJZOziiAAAAAAAAADs2MDQvAAAAAAAAxGFSWbLa3NTU + 0M6of6BwUFA2NlA7OzYwLzEGAwIdLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxGRcWTuJAAAAAAAANTUwMDIAAAAAAABh + YVJwAAD04NTU0dKmW1JZUFBQNlA2OzYwLwYDAwspAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7WRcWTs9jZwALi41MDA0 + PwAAAAAAAGVhUE4AAAAAAAAAv1JSUlJQUFBQUFA2OzUwMQYDAhksAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGlkXFk7 + Oz1HRjU1MDCIAAAAAAAAZVJZigAAAAAAAABSUlJSUlJSUFBQUFA2OzUwMQMCCiwAAAAAAAAAAACworMA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAANVlZFJZUFk2OzU1OAAAAAAAAABmZFmfAAAAAAAAUlJSUlJSUlBQUFBQUFA2OzAxBgMCGSwAAAAA + APJ1Ozs4OfEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAO9mYWFhUlxQOzt0AAAAAAAAAMpkWTsAAAAAANFhYWFhUlJSUFBQUFBQUFA7NjEx + BgMNKS4AAK1IO1k7Ozs7SgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGZWVlUlxSWwAAAAAAAAAA72RcO4oAAAAAX2FhYWFhUlJSUFBQ + UFBQUDY1NTExAwMeLIREODtZW9oAX1k7pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6wWVlZsQAAAAAAAAAAAAAZVxZOwAAAAB4a2lh + ZWFSUlJQUFBQUFBQUDs1MDEGBhAHNDU7WawAAAAAXFk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiZFk7 + jQAAAH15xMRraWRSUlJQUFBQUFBQNjs1MDExMTEwO6YAAAAAAADrXFl1AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABmXFk4AAAAu35+x37ExHhrXFxcUFBQUFBQNjU1LzExNHAAAAAAAAAAAABrXFm3AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAOJkXDuKAAAAf8t+yMjIfn5+xHJ4a19cXFlZPT1GRkCZAAAAAAAAAAAAAO9kWXQA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZSWTsAAADeqMvLy8jLyH5+fn55eXl5c3Nub0hG8AAAAAAAAAAA + AAAAAGtcO7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4mRZO44AAADdzs/Pz8zLy39/f39+fn5+dnZ0Sk4A + AAAAAAAAAAAAAAAA72RZdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFJZOQAAAADr09DQ0M7PzsvLqH+o + fX2goHSgtAAAAAAAAAAAAAAAAAAAZFw7twAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYXFk7jAAAAAD819fX + 19DQ0M7Ozqiopn2moKYAAAAAAAAAAAAAAAAAAADYZFmeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcNjVL + AAAAAAAA4tnX19TT086pqampp6enAAAAAAAAAAAAAAAAAAAAAABkWTsAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAFxZO0cAAAAAAAAAAO3i2NTS0tLRrKurrAAAAAAAAAAAAAAAAAAAAAAAAM9kWaEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAUjs1hwAAAAAAAAAAAAD45tza0r3Su/UAAAAAAAAAAAAAAAAAAAAAAAAAAGRcWQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABcOzWOAAAAAAAAAAAAAAAAeV9yuAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAxGRkuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Fw7NZ0AAAAAAAAAAAAAAN9cWVsAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAZmTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+WTs4AAAAAAAAAAAAAAAAXFxQtwAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAADiws8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxQO4cAAAAAAAAAAAAAANJc + UHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFk1rQAAAAAA + AAAAAAAAXFk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABS + WTUAAAAAAAAAAAAAAH1ZNokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA1Fw7SAAAAAAAAAAAAAAAXDs4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB+WTuiAAAAAAAAAAAAAGdcO4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxSOwAAAAAAAAAAAAAAZFJZAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFk9AAAAAAAAAAAAAMpmXKcAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOpcWaEAAAAAAAAAAAAA7mZkeQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf1w7AAAAAAAAAAAAAAAA + ymZkWaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnWW8AAAAA + AAAAAAAAAAAA4mZkWVmhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFxZugAAAAAAAAAAAAAAAAAAAGtkXFk7nwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADcXFkAAAAAAAAAAAAAAAAAAAAAANdmZFlZO58AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAH5coAAAAAAAAAAAAAAAAAAAAAAAAADEZFxcWTuiAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxGRcWVk9sAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANxkXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA72tk + XFlZdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxFzaAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAO9rXFxcXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmawAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAADva2Rc0wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1WbqAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADCwQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP////////////////////////////////////////////////////////////////// + ///////////////////////////+P////////////////////h////////////////////4f//////// + ////////////D////////////////////w////////////////////+H////////////////////h/// + /////////////////8f////////////////////D////////////////////w/////////////////// + /+H////////////////////h//8/////////////////8P//H/////////////////D//w////////// + ///////wf/8P////////////////+H//D/////////////////g//w/////////////////8P/8P//// + /////////////B//D/////////////////wf/w/////////////////+H/4P/////////////////g/+ + D///////////8AD///8P/g///////////8AAP///B/4P//////////+AAA///wf+D///////////AAAH + //+D/g///////////gAAAf//g/4P//////////wAAAD//4H+D//////////8AAAAf//B/g////////// + /AAAAD//wf4P//////////wAAAAf/8H+D//////////8AAAAD//h/g///////////AAAAA//4f4P//// + //////wAAAAH/+H+D//////////8AAAAA//B/g///////////gAAAAH/wf4P//////////4AAAAB/8P+ + D//////////+AAAAAPeD/g///////////wAAAAD/g/4H//////////8AAAAAfwf+B///////////gAAA + AH8H/gf//////////4AAAAA/B/4D///////////AAAAAPg/+A///////////4AAAAD4P/wP///////// + //AAAAA+D/8B///////////wAAAAHh//Af//////////+AAAABwf/4H///////////wAAAAcH//B//// + ///////+AAAAHD//4P///////////wAAABwf/+D///////////+AAAAcD//wf///////////4AAADA// + +D////////////AAAAQP//gf///////////8AAAAB//8D/////+P/////wAAAAf//A//////g//////A + AAAD//wP/////8D/////+AAAAf/8D//////wP//////+AAB/AA///////A///////gAAAAAP//////8B + //////4AAAAAH///////wH/////+AAAAAD////////AP///gAAAAAAB////////8Af//AAAAAAAD//// + /////wA//AAAAAAAH//////////AB+AAAAAAAf//////////8AAAA8AAAAH///////////4AAB/8AAAA + ////////////gAD//4AAAD///////////+AH//+AAAAA///////////4P///wAAAAB////////////// + /+AAAAAP///////////////wAAAAA///8Af/////////8AAAAwH//AAH//////////AAAAOAf4AAD/// + ///////gAAAD4AAAAH//////////4AAAA/AAAAf//////////+BAAAH8AAD////////////A4AAAggAf + /////4AAAD//wPAAAACH//////AAAAAB/8D4AAAAf//////gAAAAAP/A/AAAAD//////8AAAAAB/wPgA + AAAf//////4AAAAAP8D4AAAAH///////////4B/B+AAAAA////////////wPwfhgAAAP///////////+ + AQH4fwAAB////////////4AB+H8AAAf8f//////////AA/h+AAAD4D//////////4AP4fAAAAYA///// + //////gH+DwAAAACH//////////8D/w8AAAADx/////////////8HAAAAD8P/////////////hwAAAD/ + h/////////////4OAAAB/4f/////////////DgAAA//D/////////////wcAAAf/w/////////////+H + gAAH/+H/////////////g8AAD//h/////////////8PwAB//8f/////////////D/AA///D///////// + ////w/8Af//4/////////////8P/w///+H////////////+D/4f///x/////////////h/+H///8f/// + /////////4f/D/////////////////+H/x//////////////////j/4f/////////////////w/+P/// + //////////////8P/D//////////////////H/x//////////////////x/4f/////////////////4f + +H/////////////////+P/wf/////////////////j/+B/////////////////4//4H///////////// + ///8f//Af////////////////H//8B////////////////x///wH///////////////4///+A/////// + ////////+P///4H///////////////n////g///////////////x////////////////////8/////// + ////////////////////////KAAAAEAAAACAAAAAAQAIAAAAAAAAEAAAAAAAAAAAAAAAAQAAAAEAAAAA + AABMTHgAXl5/AHp6egB+fn4ABgaOAAgIiwANDYoACQmNABwchwAQEIoAFBSJABAQjgAYGI4AHh6PAAYG + kQAGBpQACQmQAAwMkgALC5QADAyWAAYGmgAGBp4ACAiaAA0NmQAICJ4ADg6dABERkQAVFZEAExOWABYW + lgAdHZAAGhqWAB4elQAWFpkAFxecABgYmQAeHpkAGRmcAB0dnAAjI4oAJiaKACgoiAAtLYgAPDyHADEx + jgA2No8APj6LADg4jQA/P44AIyOQACYmkgAlJZQAKSmTACoqlgAhIZkAISGdACUlnQAqKpoALi6ZACkp + nQA1NZAAOzuQAD09kwAxMZgAMTGdADQ0ngA+PpwABgahAAYGpgAJCaAADg6hAAoKpgAODqYADg6oABIS + ogAWFqEAEhKlABYWpwAZGaIAHh6jABoapwATE6oAFBSqABcXrQAbG6kAHR2oAB4erQAiIqIAJyejACUl + pgApKaAALS2hACUlqQAoKKoALi6oACkprQAyMqAANDShADAwpQA2NqUAOTmjADw8ogA4OKUAPDylADEx + qQA0NKkAMDCsADU1rgA5OakAPDyrADs7rwA/P64AIyOxACkpsQA3N7IAMzO1AD4+swA/P7QAOTm/AE1N + hwBFRYoAUFCBAFFRiQBUVIsAQ0OWAExMlABGRpoAQ0OfAExMmQBQUJ4AZWWHAGxshQBmZooAdXWBAHh4 + hQBycosAaWmWAG5ulwBgYJsAZGScAG5unAB1dZAAcXGUAHV1ngBERKIAQ0OkAEVFpwBMTKIASEimAE9P + pgBCQqkARUWpAEBArgBFRa4ASUmoAExMqgBKSq0ATk6sAFdXpgBRUakAV1epAFFRrgBUVK4AWVmqAEJC + sgBFRbIAQUG0AEpKsABNTbEASkq0AE9PtQBFRbsATU24AFNTswBVVbAAUFC1AFlZsQBdXbEAWVm1AF1d + tQBQULgAXl6+AGFhogBra6MAYGCqAGlpqQBsbK0AcXGgAHp6pQBxcagAdnarAHt7qgB+fq0AY2OyAGZm + sQBgYLUAZWW1AGlpsQBsbLIAaGi3AGFhugBlZboAaWm6AG1tuQBoaL4AcXGxAHZ2sQBycrQAdXW3AHp6 + sgB7e7QAcHC8AHl5uwBGRsQAXl7AAFtbxABeXsQAZWXCAGtrxABgYMgAbGzLAG5uzwBycsMAdXXCAHNz + xQB0dMUAeXnBAH9/wgB4eMYAfn7HAHFxzQB4eMgAfn7IAHp6zQBvb9MAe3vRAH192QCAgKwAgICwAIiI + ugCSkr0Ag4PGAISExACEhMoAiIjNAJSUxwCEhNcAk5PVAKWl3AAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASeMAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKdaAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGtEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFpaAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADq + GtIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAABpkAAAAAAAAAABKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAC1GgAAAAAAAAAAGqIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAABqbAAAAAAAAABpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABaGgAAAAAAAAAUYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA2xSkAAAAAAAAGmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAC6gTY/fo4AAAAAAAAAAAAAAAAaOAAAAAAAABRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPMeFBQRFBEULYcAAAAAAAAAAAAAZBq+AAAAAAAaYQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAnEQUVFRUUBREeewAAAAAAAAAAAAAUZAAAAAAAFGEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAADjHhQVRUVFFRUPBREwAAAAAAAAAAAAFBQAAAAAABpkAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAtR4VRUVFRUVFFQ8RES0AAAAAAAAAAKgUuQAAAAAUZAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOMnGkVFRUVFRUUVBRERMAAAAAAAAADMFKQAAAAAGpYAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBQVRUVFRUVFRRUFERF8AAAAAAAAXBrvAAAAABqk + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgeFUVFRUVFRUVFFQURG4cAAAAAABQnAAAA + AAAUmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNOBQVRUVFRUVFRUUVFBEwAAD/AM0U + gAAAAAAAGmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEgD0VFRUVFRUVFRRURFIgA + AAA4FO8AAAAAABQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4YSAVRUVFRUVFRUVF + BREwAAAAGjgAAAAAAAAUFLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN9lOBpFRUVF + RUVFRRUUDgAAzBSkAAAAAAAAJxSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtJhk + FBVFRUVFRUVFBR4AAG0aAAAAAAAAAAAUFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADNqIBaGkVFRUVFFRQ4jgBkFAAAAAAAAAAAthqbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAPW0oqg8UFNTVHJlZYcANhSMAAAAAAAAAABkGsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAMy0pLSwta21mCd7eSwULQAAAAAAAAAAABQ8AAAAAAAAAAAAAAAAAAAAAAAAANZy + AAAAAAAAAAAAAAAAAAAAAAAA+fTFxba0sDgODg8RERsEAAAAAAAAAAAgFLcAAAAAAAAAAAAAAAAAAAAA + AAAA3El1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACbfRUaFAcHKoQAAAAAvoqKMxRlAAAAAAAAAAAAAAAA + AAAAAAAAAAAA3VBd3wAAAAAAAAAAAAAAAAAAAAAAAAAAwCcVU1EPEREbei0eFBERFBEUxQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA7GBJmOMAAAAAAAAAAAAAAAC6pGWfvQDFtnRFRQ8PEREREQcRERE4AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAaGpjOAAAAAAAAumUYGhQUFBQbLTZFRUVFRRUUBQcRQMUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKcaGhRlur6AGBgeFGQAALUgFBERFUVFRUVFFQ8BAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALYnGhQaFBhk3wAAAAAAAACiHg9FRUVFRUUF + GwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtcPMAAAAAAAAAAAAAAGUgGkVF + RUVFBREKKB4UPKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + mGBLFUVFRRUFBRERHiAaJ7oAAAAAAAAAAAAAANK0xd8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAADxkZTgPFUVFRRUPG4YAxRQaZAAAAADvpGU4GhoaGl3nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAREYGYPBQVRUVFSQV5AAAAYRQYZRoaFBoUGmTNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAC1EREA8KJkS0VFRRUUKgSJigCMOBQncMXqAAAAAAAAAAAAAAAAAAAAAOuncGRhYWFh + YWFhYWRhYWSAAAAAAAAAZRE2AAD2tLV0UFNLHioJEREOgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdBoU + FBQUFBQUFBQUFBQUFBjvAAAAAGUUQAAAAFzFtKiYbVwUBQUFBRGFAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAADj398AAAAAAAAA9JgaGM4AAABAFIIAAOMUgc7FtJg8GhVFFRERKAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAG0aZL6QIBG6AADnHsAAAPE2FUVFRUUaBRQwAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAthoUEREeAAAA6hrSAACoEUVFRUVFRQURGwQAANRdUAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJx4UtgAAAAAaZAAAIBEVRUVFRUUVERF6glBa + 321LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApxoAAGVkUEtKRUVFFQUR + ERjNAAAAUM0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaZADOZXBldHJx + UVAgIIAAAAAAAOoaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmBrAAMWi + qICnp3VkYWQAAAAAAAAAGrQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa + mwAA88W0oqKoqJvOAAAAAAAAANdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAFGQAAAAA487FxcXjAAAAAAAAAAAAGswAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABqAAAAAAAAAOL4AAAAAAAAAAAAAAKxRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAN8a0QAAAAAAcFoAAAAAAAAAAAAAAAAA7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC1GgAAAAAAABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAWmQAAAAAAFpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAABrMAAAAAAAaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJAAAAAAAAULUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADabQAAAAAAAABdGrAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXd8AAAAAAAAAAOoaGrUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAANcaUN8AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOvXAAAAAAAAAAAAAAAAANdK9wAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//////////////////////////f/////////8//////////z//////// + //n/////////+f/////////4//////////z/f////////P8////////+fz////////5/P////////j8/ + /////A//Pz/////wA/8fP/////AB/58/////4AD/nz/////gAH+PP////+AAP48/////8AAfjz/////w + AA+fP/////AADR8/////+AAHHz/////4AAc/H/////wABj8f/////gAGf5//////AAJ/j/////+AAj/H + /////+AAP+f//z//8AAf4///j///4A8D///h///gAAP///g//BAAD////wfgAAA/////wAGAAf/////w + B/AA//////4/+AAH///////8AAH/w/////wAEPAD/////AAcAD/////4gAID//wAAfjAAP///gAAeOAA + f///4/g4wAB//////wDGAD//////gcYAGP/////h5gAAf//////mAAc///////IAHz//////8QA/n/// + ///5gD+f//////ngf8//////+fn/z//////x8//v//////P3////////8+f////////z7/////////fn + ////////5/H////////n+H///////+/+H///////z/+P///////f//////////////8oAAAAMAAAAGAA + AAABAAgAAAAAAAAJAAAAAAAAAAAAAAABAAAAAQAAAAAAACUlXgAqKl4AMTFXADc3VwA1NVgANzddABkZ + ZgAWFm4AGBhoABwcagAZGW0AExNzABYWcAATE3YAFBR1ABoadAASEnkAFBR7ABISfgAVFX0AHx99ACEh + YAAlJWAAIiJmAC0taQAyMmAAOTlkADExbgA7O28APz9uACYmdAAvL3YAIyN7ACEhfQApKXoAKyt+AC0t + fAAxMXMANjZwADQ0dAA8PHMANTV5ADExfQA1NX4AOjp5AEJCXQBJSVoASUleAE1NXQBAQGEATExkAEVF + bABLS2sATU1rAEhIbABUVGsAWFhqAFpabQBDQ3EASkp1AEJCegBRUXAAW1twAFNTegBfX3gAY2NvAGdn + cQBiYnYAZWV1AG1tcABubnUAY2N7AGZmegBhYX0Aa2t+AHFxcwBycnQAd3d3AHZ2eABxcX4Aenp8AA0N + hQAODokACgqOAA0NjQAREYIAFRWAABERhQAXF4QAGhqEABAQiAAVFYoAEBCMABcXjAAaGokADQ2QAAsL + lgANDZUACgqZAA0NmQAJCZ0ADQ2dABISkwAaGpAAHByRAB4elwAQEJgAFRWZABISngAXF50AGRmdACMj + gAAmJoEAIiKEAC0tgwAgII4AKyuLADIygQA7O4UAMTGIADY2jwA/P4sAIyOVACEhnQAoKJgAMzOSADk5 + kAAHB6IABQWlAAgIoQAMDKIACgqmAA4OpAAFBagABQWtAAwMqgAQEKEAERGmABQUpAAaGqMAEBCpABUV + rAAbG6wABQWxAAUFtQAKCrMADQ28ABMTsAAVFbEAFBS1ABgYsgAeHrIAGhq0AB4etgAQELoAHR29ACUl + pAAqKqIAIiKqAC0tqQAwMKkAPDyuACQksAArK7MAICC/ACgouAAtLbsAKSm+ACwsvQA1NbYAPT2yADIy + ugA2NrsAMTG9ADg4uQA9PboAODi+AEBAggBDQ4oASkqJAF1dhQBeXokAYWGAAG5uhABgYIoAd3eFAHx8 + gAB9fYgAYmKfAHV1kAB7e5EAe3ubAE9PpABRUaEASkq1AEFBuwBBQb8ARUW8AFZWsgBdXbQAUlK+AFhY + uAB1daIAeHilAGVltQBvb7QAZWW6AGJivQB/f7cAEhLAABYWwAAdHcYAIiLAACYmygA0NMMAODjCADU1 + zAA6OsoAQ0PDAEVFwgBCQsUASEjBAE5OwABPT8cAQkLIAExMywBQUMUAVVXEAFhYxABTU80AWVnIAERE + 0ABMTNEAV1fRAFxc0wBlZckAcHDAAHd3zQB5ec8AZGTRAGpq0QBoaNsAcnLSAHt70wB8fNMAf3/WAH9/ + 3gCCgsIAgoLGAIGB2QCHh+UAkJDnAKGh6AAAAAAA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJhJAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPN4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACKRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADgLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbUcA + AAAAAPhBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApikAAAAAAMkmAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9mhPAAAAAMYhAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIU3AAAAALAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC/HRka + ME0AAAAAAAAAAN1wAAAAALAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJgXVsTDRYwAAAAAAAAAABt + OQAAAK0hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSBhYBlYBMJBU0AAAAAAACOHAAAAKYkAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAJuHgYGBgWVYCwVPAAAAAADkWAAAAKYsAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAANOQh4GBgYWAWAgEAAAAAADQWgAAAKYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANSSh4GB + gYGBZVgJMAAAAACMLQAAAKYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPLTkIeBgYeBgWATFk0AAABg + uAAAANcfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADWk4eHgYGBgYFgCC4AAMNeAAAAALBYUQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA1puHgYeBgYFlExYAAIU9AAAAAOlrMwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA+9mch4GHgYGFXQtRAGVPAAAAAACUJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzo + 15SHh4GBayxHAFtEAAAAAAAAijkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6+nhraaton45SRMu + AAAAAAAA5SFPAAAAAAAAAAAAAAAAAMi2AAAAAAAAAAAAAAAAAP3y6ubpxm1aWBMCUQAAAAAAAFsyAAAA + AAAAAAAAAAAAAADknrYAAAAAAAAAAAAAAAAAAAAAAJiFZVsLBEcAuj8+O1ssAAAAAAAAAAAAAAAAAAAA + AOyfs0sAAAAAAAAAAAAAAE+6AKKYn2VbDRgQWF1gZW8AAAAAAAAAAAAAAAAAAAAAAAAA9phoLT8AAAAA + AEBwYGVgXix7gYWBZWBdXW3DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA14VeHTQka2Wh+ADx1ZCHkIeB + gWVSMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpiIWf7QAAAAAAAADTkIeBgWVdCzA5OUQAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD3nIiHhYFgWBMNWFssQgAAAAAAAAAAvElJAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAmKaUkIeBZWAQTQCeWzdRAEs8LFprbZ3NAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAADwgXfDpZCHgWATMAAAsmtbbWWKquwAAAAAAAAAAAAAwDw7Ox00HTQpNDQ3QwAAAADYZUsA + 8NeXiIVaGyYQMkfLAAAAAAAAAAAAAAAAAAAA6ZSIhYWFhYWFhYVlWjcAAAChWwAA7t3esKadWFtYDRoA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA54o9UQB7WAAA3XXM8OCMhYFlWAswAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACYbSFbLAAA2C0AAKGHgYGFYBMWuwAAtUAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA4ZOIAAAA8WhRAJCQh4GBgV0LMD18zp9JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AIg8vqaclIiHgWVYE70AAAB8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOxou8fa2K2kpKF7 + vwAAAACtQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKPgD26eHdxqLCAAAAAAAAewAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACXPAAAAPrlyNEAAAAAAAAAmLcAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABtSwAAAACKAAAAAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABrAAAAAMK0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO54AAAAAG0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMa1AAAA8H8AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIwAAAAAANd+SQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAH4AAAAAAAD6jnVEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + 0L8AAAAAAAAAAPGXfwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAogAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /////wAA///5////AAD///n///8AAP///P///wAA///8////AAD///58//8AAP///nz//wAA///+PP// + AAD///88//8AAP/A/zz//wAA/4B/nP//AAD/gB+c//8AAP+AD5z//wAA/4APnP//AAD/gAec//8AAP+A + A5z//wAA/8ADPH//AAD/4AM8f/8AAP/gAT5//wAA//ABPz//AAD//AA/H/8AAD/+AB+f/wAAj//4CB// + AADh/8gAP/8AAPg+AAD//wAA/wAgA///AAD/wfwAP/8AAP///AAP8QAA///+AEIBAAD///wAYB8AAPgA + PEAD/wAA+AAcwAf/AAD//4TAA/8AAP//4MwBnwAA///xxAAPAAD////gAO8AAP///+AB5wAA////8gP3 + AAD////zh/MAAP////Pf+wAA////95//AAD////nv/8AAP///+c//wAA////74//AAD////vw/8AAP// + /8/x/wAA////3///AAD///////8AACgAAAAgAAAAQAAAAAEACAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAB + AAAAAAAANTVZADMzXwA7O1oAGxtpABYWcQAVFXcAGxt2ABwcdAAUFHgAERF9ABcXfwAbG34AKipgACAg + agAkJG0AKipoADY2YwAxMWcAPz9lACEhdgApKXIALCxyACgodQAsLHYALy94ACoqfwA1NXMAMDB2ADU1 + dgAwMHkANzd7ADU1fQA/P3sAQ0NfAEdHXQBAQGsARkZtAFhYZgBBQXAASUlyAEtLdgBPT3oASEh8AFZW + dgBeXnMAUlJ7AFxcfwBlZW4AYWF3AGxsdgBycn4ADg6LAA0NjgASEoMAEBCHABgYgAAREYoAEhKOABoa + jwAdHY4ACwuTAA0NkgAMDJUACgqaAAkJnQAODp8AEhKQABcXkQAbG5EAHx+RABERmQAUFJgAFxefAB8f + nQAhIYIAKiqGACcniwAlJY8AMzOBADIyhwA0NIgAMDCOAD8/iwAoKJEAKSmUAD09mwAHB6IABgamAAgI + ogAICKYABQWpAAUFrAAJCagAGRmgABwcoQAQEKsAFhaqABkZrAAdHa0ABga2AAoKtQAODrkAERGwABsb + sgAWFrgAHh67ABwcvAAhIacALS2nACIirgAlJa8AKSmoACkprQAtLawANzelADg4pgAyMqkAMDCtADs7 + rwAgILUAJSW6ADAwtgAzM7wANze+ADs7uQA8PL0AQECGAFZWgQBTU4UAWlqDAFBQiwBUVI0AQ0OaAFxc + nwBnZ4cAd3eFAHp6hgB/f4YAdnaKAHt7iAB/f4sAb2+QAHl5kQBBQa0AX1+hAE5OswBERLsAQEC9AFpa + tQBSUrwAYWGvAGJitwBqarEAeXm2ABUVwQAvL8wANzfAADs7xwA9PckAPDzNAE5OwwBSUsEAUFDEAFVV + xQBbW8IAXV3CAF5exQBYWMkAV1fUAGdnyQBzc8cAZ2fSAGpq0ABiYtoAenrTAICAgwCAgJAAgYG8AIGB + zgCRkdIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJMAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvKAAAAHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA8AAAAdowAAAAAAAAAAAAAAAAAAAAAAB0PAjAAAAAAAJMtAABwjQAAAAAAAAAAAAAAAAAAAABhQUE0 + BQMAAAAAABgAAG8AAAAAAAAAAAAAAAAAAAAAAGZYWFhBCQIAAAAAQwAAbgAAAAAAAAAAAAAAAAAAAAAA + m1xYWFhBBSMAAABLAABuAAAAAAAAAAAAAAAAAAAAAACuZVxYWFg/BLAAmIIAAHAzAAAAAAAAAAAAAAAA + AAAAAACcZVhYWFg2IwBeAAAAeyQAAAAAAAAAAAAAAAAAAAAAAACgaVxYWD8SAEsAAAAARQAAAAAAAAAA + AAAAAAAAAAAAAACunnlvcCEzDAAAAACrJwAAAAAAAAAAAJWHAAAAAAAAAAAAr6qkXjoJJgAAAAAMAAAA + AAAAAAAAAACSgQAAAAAAAAAAAABvYj8FEhgJQ1UAAAAAAAAAAAAAAAAAoU0oAACPT0heSE5aWEE/DIYA + AAAAAAAAAAAAAAAAAAAAAK1hSJAAAAAAqWRYWD8EMokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfmdc + WjQJGFUnAAAAALEvKwAAAAAAAAAAAAAAAAAAAABhVmpcWD8TAH9LGjxslgAAAAAAAJkgIBodGh0dJAAA + AEEAtHtoSRgUEDEAAAAAAAAAAAAAAAAAAAAAAACiTLAAOgAAhad9QUE2EAAAAAAAAAAAAAAAAAAAAAAA + AAAAYkVPALMoAGJYWEEFJgCDLgAAAAAAAAAAAAAAAAAAAAAAAAAAAE6LamddWD8IhgCnMwAAAAAAAAAA + AAAAAAAAAAAAAAAApC6Ynn56bY4AAABRAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAArJaaAAAAAKIAAAAA + AAAAAAAAAAAAAAAAAAAAAACBAACyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApwAAAFEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB0AAAAUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMAAAAAdi4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP///////f////7////+/////nf///9z//4fM//8D7f//Ae3//wDt//8ATP//gFz//8B + e///gHn/P+A9/8/8Af/xgAf//DwD///+APH//gIH4A6Af//iwH//+JAn///AE///wDv//+x7///t//// + 3f///93////ef////7//////KAAAABAAAAAgAAAAAQAIAAAAAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAA + AAAcHHoAGRl+ACMjcgAlJXMAISF1AExMbABaWnIAFBSEABAQiAAMDJUAIyOaAD09kwAGBqUACAihAAgI + pAAHB6sAGxugABgYpgASEq8AHR2rAAsLtAAbG7QAIiKwAD09swBCQo0AX1+CAFdXiABVVZEAUlKWAFtb + kQBcXJIAYWGNAGlpiABsbIsAd3ePAGpqkwBra5UAYGCZAHl5kQB+fpAAenqZAFdXpABYWKQAXFykAFpa + rQBubqYAZWWtAG1tqgB2dqAAdnauAH19rABjY7MAZGS2AGxsuABxcbkAdXW/AEhIwQB8fM4AZmbXAGFh + 2ACGhr8AgoLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /wAAAAAAAAA1AAAAAAAAAAAAAAAAAAAAAD4AAAAAAAAAAAAAAAAAAAAAJwAeAAAAAAAAAAAMAQcAACoA + HAAAAAAAAAAAFQ0KBgA4AB4AAAAAAAAAADwQDQkAJgAZAAAAAAAANQAAOxYSGiEAADUAAAAAAAA1AAAA + MRIDKCAkAAAAAAAAABweODoXDQgpAAAAAAAAAAAAAAAAABQOBRshJC4AAAA1LTUrACsAGAsBJwAANQAA + AAAAADU2ACQTDQUAKQAAAAAAAAAAAAAvPTkzAAAAAAAAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAAA1MAAA + AAAAAAAAAAAAAAAAAAAAAAAA/f8AAP7/AAD/XwAA418AAOFfAADhXwAAsG8AANwPAADgHwAA/wEAAMKG + AAD8hQAA/4cAAP+/AAD/zwAA//8AACgAAACAAAAAAAEAAAEAGAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODrMQEKpjY7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbG7kPD6sREaJ+fqwA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABxcdwODq8QEKQvL6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMPD6gSEp1wcKUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABiYtYNDa4QEKM4OJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMPD6cREZx3d6MAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NsgNDa0Q + EKA3N50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAMDLMODqYSEpoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ78NDasQEJ9GRp4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAACAgOIMDLAPD6QSEpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UODqkREZxWVp4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABT + U9IMDK4QEKEbG5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACEhNVISLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7MODqcREZpjY50AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEKoSEp89PZ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJsANDasQEJ8k + JJUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPD6gSEp0TE5N5 + eZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACAgOIMDLEPD6QSEpZmZpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAODqkREZ0TE5FZWZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UNDakREZs1NZYAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDasQEJ4TE5FERI0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABSUtEMDK4PD6ATE5Rzc5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAMDKwPD6ETE5IwMIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7MODqYSEphCQpQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDK4PD6ESEpMuLogAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGLwM + DKsQEJ0bG5B/f4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC64ODqISEpMa + God/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABwcN0LC7APD6ISEpVWVpQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAALC68ODqIREZMUFIl/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrUNDagREZkjI48A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCq8NDaMREZQTE4l/f38AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA1NcgMDKwPD58TE5FhYZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoKCq8NDaMREZQTE4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcJdMTIc7O3wt + LXUtLXItLW8uLm9ERHBYWHNwcHB2dnZ+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7IODqUSEpY5OY4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaMQEJQTE4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABYWKAZGYgTE4ITE30UFHoVFXgWFnUWFnIXF3AYGG0ZGWoeHmg2NmZdXW5wcHB6enoAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAKCrcMDKkQEJsTE45ycokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQQEJUT + E4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHJoQEJAREYkREYQSEoETE4ETE4ATE34UFHsUFHYV + FXMXF24YGGsZGWkaGmc2NmNcXGxwcHB9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSUtILC68ODqASEpNFRY4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edsKCrANDaQQEJUoKIsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIqgODpkODpMP + D5AQEIwPD4wQEIwQEIsQEIoREYcSEoQTE38UFHoVFXQWFm4YGGkaGmYbG2ZAQGNpaWl1dXUAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrMNDaUR + EZYbG4t+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQQEJUuLosAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA2NrgaGqcLC5wMDJoMDJkMDJgMDJcMDJcMDJYNDZYNDZMODpEPD40REYgTE4IUFHsV + FXQXF2wZGWcaGmUpKWFWVmtvb29/f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAXF7wMDKsQEJwTE45XV4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edsKCrANDaUREZUuLowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIiNkhIbQVFasJCaQJCaMJCaIKCqAKCp8KCp4K + Cp4KCp0KCpwLC5oMDJcNDZMPD48REYkTE4EUFHgWFnAYGGkaGmUgIGNMTGVra2t8fHwAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYdgLC7AODqASEpIqKol9fX0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsKCrANDaQREZYuLowAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTMkf + H7gTE7EICKoICKoHB6gICKUICKQHB6MICKMICKIICKEJCaAJCZ4KCpwMDJgNDZMPD44REYUTE34VFXQY + GGwZGWUbG2M/P2FpaWl5eXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAKCrMNDaUREZYUFIpvb4YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoKCrANDaQREZYv + L4wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAeHr8eHrsTE7UGBrAGBq4HB6sHB6gHB6YGBqYHB6YHB6YHB6UHB6QI + CKMICKEJCZ8KCpwMDJcODpEQEIoTE4AUFHYXF20ZGWYbG2M2NmFoaGh4eHgAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJb4MDKgQEJgTE4xDQ4gAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edoKCrANDaQREZZLS48AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeHsIdHb0SErgGBrQGBrEG + Bq0GBqoGBqgGBqcGBqcGBqcGBqcGBqYHB6YHB6UHB6MICKEKCp4LC5oNDZQQEI0SEoMUFHgXF20YGGYb + G2M2NmBpaWl6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtbdgM + DKkPD5oSEo4hIYYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC68NDaQQEJZMTJEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAcHMQcHMAVFbwFBbYFBbMGBq4GBqoGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6YHB6QI + CKIJCZ8KCpwMDJYPD44SEoQUFHgWFm4YGGYbG2M2NmBqamp9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6kODpsSEo8UFIhvb5AAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoLC68NDaQREZZMTJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMUcHMIaGr8FBbcFBbQFBa8GBqsGBqgGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6UHB6MICKEKCpwMDJYPD48SEoQUFHkWFm4ZGWYaGmNJSWNt + bW0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6gODpsSEo8TE4kA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC68ODqQREZVUVJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQNEc + HMQcHMEHB7sFBbYFBbEGBqwGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UHB6MICKEK + Cp0MDJcODo8SEoQUFHgXF20ZGWYbG2RRUWdwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAALC6YODpkREY8hIYkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqMREZVo + aJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABnZ94cHMQcHMIODrwFBbcFBbMGBq0GBqoGBqgGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcGBqYHB6YHB6QICKEKCp0MDJcPD48SEoMUFHgXF24ZGWYgIGNbW2t1dXUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABWVsILC6MODpcREY89PY0AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edoLC64ODqMREZRmZo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMccHMMaGsAFBbkF + BbQFBbAGBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6QICKEKCp0MDJYP + D44SEoMUFHYYGGwaGmUpKWFpaWl8fHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFqsN + DZ4PD5UREY1kZJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqESEpNlZY4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAnJ8scHMUcHMMLC70FBbcFBbIGBq0GBqoGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcHB6YHB6QICKEKCpwNDZUQEIwTE4AVFXQYGGkbG2RAQGNubm4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC6YNDZwQEJISEo0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5 + edoLC64ODqESEpJJSYsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaOEcHMgcHMQVFcAFBboFBbQFBbAGBqwG + BqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UHB6MJCaALC5sNDZMQEIoTE34W + FnAZGWcbG2VbW2t4eHgAAAAAAAAAAAAAAAD///8AAAAAAAAAAAAAAABISL0MDKINDZgQEJA1NY4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edoLC64ODqESEpFISIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAcHMobG8UcHMQMDL0FBbcFBbIGBq4GBqoGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqYHB6UICKMJCZ8LC5oODpEREYUUFHkXF20aGmYtLWJtbW0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALC6kMDJ8ODpUREY9kZJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5edsLC64ODqESEpE7 + O4V9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaOEbG8kbG8QZGcEGBrkFBbYFBbEGBqwGBqoGBqgGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKIKCp4MDJcPD44TE4EVFXQYGGkaGmZT + U2p4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f9ALC6YNDZsPD5MYGI0AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB5edsLC7AODqISEpInJ4N4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHMsbG8cc + HMQTE8AFBbgFBbMFBbAGBqwGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YH + B6QICKEKCpwNDZQQEIoTE3wXF28ZGWcsLGRubm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAiIrMMDKINDZkQ + EJI+PpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6etwKCrINDaUREZQUFIZzc3MAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACEhOgfH8odHcUcHMMODr0FBbcFBbIFBa8GBqsGBqkGBqgGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6YHB6MJCZ8LC5kODpASEoMUFHYXF2saGmdUVG18fHwAAAAA + AAAAAAAAAAAAAAAAAAALC6oMDKAODpYQEJB1dZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8 + fN8KCrUMDKgQEJcTE4hTU319fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHR9YkJMohIccfH8MODrwF + BbYFBbEGBq4GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKEKCp0N + DZUQEIsTE30XF28ZGWkxMWVzc3MAAAAAAAAAAAAAAAAAAABmZskLC6cNDZ0PD5UgII8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+fuMJCbgLC60PD5sTE4w+Pn93d3cAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAsLM4oKMooKMUmJsQQELwFBbYFBbIGBq4GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcG + BqcGBqcGBqcGBqcGBqcHB6YHB6QJCaALC5oODpASEoMVFXYYGG0ZGWtnZ3IAAAAAAAAAAAAAAAAAAAAj + I7MLC6QNDZsPD5NVVZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLsKCrENDaIS + EpIaGoR0dHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMM4uLsotLcgrK8UTE70FBbYFBbIG + Bq4GBqsGBqkGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UICKEKCpwNDZQQEIoUFHsW + FnAYGGxMTG8AAAAAAAAAAAAAAAAAAAALC6kMDKIODpkREZJ/f5cAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAHB78JCbYMDKkQEJkTE4tZWYV9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABzc+M0NM8zM8wyMsowMMgXF78FBbYFBbIGBq4GBqsGBqoGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcG + BqcGBqcHB6YHB6MJCZ8MDJgPD48TE4EVFXUXF242Nmx8fHwAAAAAAAAAAAAAAAALC6YMDKAPD5g2NpEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYN0ICLoKCq8ODqASEpIxMYp9fX0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYN46OtA4OM43N8s1NckiIsEFBbYFBbIFBa8GBqwG + BqoGBqkGBqgGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqcHB6UICKELC5sODpISEoUUFHkXF3EoKHN6enoA + AAAAAAAAAAB0dMkMDKQNDZ0QEJVbW5MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAlJcgJCbYMDKkQEJsTE49mZo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZWdo/ + P9E+Ps89Pc07O8svL8QODrgFBbMFBbAGBq0GBqsGBqkGBqgGBqgGBqcGBqcGBqcGBqcGBqcGBqcHB6YI + CKIKCpwNDZUREYgUFHwXF3QqKn93d3cAAAAAAAAAAABaWr4MDKAODpkYGJF9fYoAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLwLC7EODqMREZYzM5EAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcXNtERNJDQ89BQc0/P8o7O8ggIL8FBbQFBbIFBa8GBqwGBqoG + BqkGBqgGBqgGBqcGBqcGBqcGBqcGBqYHB6MKCp4MDJcQEIsVFYAmJn8sLIB0dHQAAAAAAAAAAAA/P7AN + DZwPD5UZGY4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ + CbgMDKwPD6ATE5NubpYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6euRKStNISNFH + R85ERM1DQ8w7O8gbG70FBbMFBbEGBq4GBqwGBqsGBqoGBqkGBqgGBqgGBqgGBqgHB6UJCZ8MDJgTE48s + LI4xMYYwMINxcXEAAAAAAAAAAAA9PacODpYQEJATE4hpaYcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtsKCrQNDagREZo2NpYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACFheZQUNROTtJLS9BLS89JSc1HR8s9PccgIL0NDbQFBbEFBa8GBq0GBqwG + BqsGBqoGBqoGBqoHB6cREaYlJac1NaI2NpY2Now2Nohubm4AAAAAAAAAAABXV6UPD5AREYoTE4JNTX9/ + f38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NcgLC68PD6ET + E5VgYJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYWNZTU9RRUdJQUNBO + Ts5MTM1LS8xKSso7O8QqKr0cHLkUFLUTE7MUFLIbG7QkJLY1Nbk5Obg6OrM7O6o8PKA9PZM2NotXV3F6 + enoAAAAAAABVVZUPD4sSEoUUFH0zM3Z4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAZGbYODqUREZgcHIx+fooAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB7e+JYWNZWVtRVVdJTU9BRUc9QUM5OTs1MTMtMTMpKSslISMdGRsdERMRCQsRB + QcJBQb9AQLpBQbJBQak+PpwaGoIrK3Vzc3N8fHwAAABkZIQQEIUSEoIVFXgXF3JwcHAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f9sNDaYQEJgTE4xISIp+fn4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZtpcXNZaWtRXV9JWVtFV + VdBUVM9SUs5QUM1OTsxMTMtMTMpKSslISMdHR8NGRr9GRrpGRrIgIJgREYU1NXdNTXQPD4IUFIBWVnEP + D4QSEn8VFXUXF29QUG55eXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAaGqgQEJgTE4sVFYFlZYJ+fn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABjY9gODrQnJ7MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABoaNtgYNZeXtVcXNRaWtFYWNFWVs9WVs9UVM5SUsxQUMtPT8pNTchNTcRMTMAj + I6wMDJsODpBnZ3gODogODogODocSEoMUFIESEoAUFHYXF242NmVubm4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUVLQPD5UTE4oVFYEuLnt3d3cAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRtEMDLgNDbIPD6tFRbIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDg+JlZdZiYtRgYNNeXtFc + XM9bW85ZWcxXV8xWVstUVMpOTsUUFLEJCakKCqM0NJcNDZkMDJUNDZQMDJINDZAODowREYYTE3kWFm4e + HmZgYGlycnIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABycq0P + D5ISEosUFIIWFn5dXYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAoKMYMDLgNDbIODqwQEKZRUbMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACRkeKBgdtzc9RxcdBwcNBvb89zc9CIiNU4OL0GBq0HB6p1dbUSEqMLC6ML + C6ALC5wKCpoMDJgXF4oQEIsTE4AUFHMYGGk/P19lZWVwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABra5MODpAREYwTE4YVFYI3N4UAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRc0MDLQNDa8PD6oQEKVmZrkAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABGRrsSEqsICKsICKoJCagJCaUKCqIKCp8bG4sYGIgREYcTE3oVFW0YGGcjI2NJSWZt + bW16enoAAAAAAAAAAAAAAAAAAAAAAAAAAABnZ4NeXoFdXYBaWn9aWn9aWoBISIQODpIQEJASEowTE4gz + M5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABFRcwMDLMODq8PD6oQEKVSUrUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdHbAGBqkICKwHB60ICKwHB6kICKYREaUZ + GaQMDJcPD48SEoIUFHcWFm0YGGgZGWc2NmJnZ2dwcHB4eHhXV389PXshIXkVFXwVFXwUFH0TE4IREYgQ + EI0NDZIMDJMMDJUNDZQODpUREZESEpFLS6MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRcwMDLQNDa8ODqoQEKY8PK+AgLgA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABL + S7sYGK0HB6wHB68HB64GBqskJLI1NbQJCaIKCp0NDZUPD4wSEoETE3kVFXEWFm0XF2s9PWBDQ2QaGnAU + FHYTE3oTE34TE4ATE4MSEoUREYoPD5AODpYMDJkLC5sLC5oMDJoNDZoPD5kbG5wAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABhYdcMDLQNDbAODqsQEKYlJahgYLIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYbFaWsBMTMExMbwwMLxGRsA7O7sMDKkICKQJCaEKCpsNDZUP + D44REYUTE34TE3cUFHQTE3QTE3cTE3kSEn0REYMQEIcPD4oPD48ODpINDZYNDZoMDJ8KCqAKCqEKCqAL + C6ENDaIlJaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtgMDLUNDbAODqwPD6YQEKE4OKZr + a6oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABkZJVDQ5EmJo4REZAREZAREZAREZAeHpA5OY9SUotuboV8fHx3d4NiYrRjY8dgYMpT + U8UgILUHB6sHB6gHB6YICKMJCaAKCpwMDJcODpIPD4sQEIYREYQREYIREYMREYUPD4gPD4sODo4MDJIM + DJYLC5kLC54KCqEKCqQJCaYKCqcKCqgjI69wcMkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABiYtgMDLUMDLEODqsPD6YQEKEcHJ1ISKJsbKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2dpdERJEfH40REY8QEJAQEJIQEJMPD5QPD5UPD5UPD5cO + DpgNDZkLC5oYGJg7O5JjY4Vycn9eXooGBq8GBq0GBqsGBqkHB6gHB6YICKMICKEKCp0LC5oMDJcNDZMO + DpEODpAODo8ODo4ODo0MDI4MDJALC5MLC5gLC5wKCqEJCaUKCqgWFq1XV8MAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYdkLC7YMDLENDasODqYQEKEREZwb + G5ZMTJt1dZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUVJMmJo0REY4QEJAPD5IP + D5QODpYODpkNDZwNDZ4NDaANDaEMDKMMDKMLC6MKCqMJCaQICKUHB6kWFqgUFKoGBrEGBq8GBqwGBqoG + BqkHB6cHB6UHB6MICKIJCaAKCp4KCpwLC5sLC5oLC5YMDJMLC40LC4wLC4sLC44LC5MhIZ5GRrF+fsoA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABxcd0YGLsLC7INDa0ODqcPD6AREZsSEpYjI5JISJJubo8AAAAAAAAAAAAAAAAAAAAAAABb + W5M1NY4REY8QEJAPD5IODpQODpcNDZkNDZ0MDKELC6QLC6gwMLQKCq0KCq4JCa8KCq8JCa4ICK4HB68H + B7AGBrEGBrMFBbMGBrQGBrAGBq4GBqsGBqkGBqgGBqYHB6YHB6UHB6QICKIICKEJCaAKCp4KCpoLC5IL + C4ksLHM8PHRiYoMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+MYGLwLC7MMDK4NDagPD6IQEJsS + EpYSEpEqKpBRUY5xcYhbW4ozM4sREY4REZAQEJIPD5UODpcNDZoMDJ0MDKALC6QLC6gwMLV+ftAAAAAA + AAAAAAAAAABtbdkyMscICLoHB7kGBrkGBrgGBrcFBbcFBbcFBbYGBrQFBbEGBq0GBqoGBqkGBqgGBqcG + BqYHB6YHB6UHB6QICKIICKEKCpoLC5EMDIUtLWxlZWV0dHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAlJcMKCrQMDK8MDKkODqQPD54QEJoQEJcQEJYQEJUQEJUPD5YODpcNDZsMDJ4MDKEL + C6QLC6giIrFjY8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTtUFBb8FBb0PD7wEBLkF + BbgFBbcFBbMFBbAGBqwGBqoGBqgGBqcGBqcGBqcGBqcHB6YHB6QICKEKCpsMDI8NDYMPD3owMGpoaGh2 + dnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcMKCrYKCrELC60MDKkNDaYN + DaQNDaIMDKEMDKEMDKILC6ULC6gWFq1WVsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAiIsUSEr8EBLsFBbkFBbcFBbEGBq4GBqoGBqkGBqgGBqcGBqcGBqcHB6YH + B6QICKEKCpoMDJAODoMREXkSEnMyMmdnZ2dxcXF8fHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABDQ88JCbgJCbUKCrMKCrEKCq8KCq0KCq0WFrFWVsUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhOYeHsUQEL8EBLoFBbgFBbQF + Ba8GBqwGBqkGBqgGBqcGBqcGBqcHB6YHB6QICKEKCpwMDJMPD4cREX0SEnUUFHAzM2NVVWdVVW5JSXJF + RXdHR31JSYJMTIdiYo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYNgWFr8JCbokJMBoaNIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA0NM0kJMUZGb4MDLgFBbQFBbEGBq0GBqoGBqkGBqgGBqgGBqgGBqYHB6UICKIJCZ0LC5cO + Do4QEIMSEnsTE3UUFHMVFXMVFXIVFXUVFXYVFXgUFHwUFIAUFIMVFYZDQ5B7e5MAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvL8kpKcEjI70cHLoREbQFBa8GBqwGBqoG + BqkGBqkGBqkGBqgHB6YHB6MJCaAKCpsMDJUODo0QEIYSEoETE34UFHwUFHoUFHsTE3oTE3sTE34TE4QT + E4kTE40TE44TE41LS5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA0NMMuLr4qKrwkJLsZGbYJCa4GBqwGBqwGBqsGBqsGBqoHB6gHB6UICKIJCZ8KCpsMDJcODpIPD40Q + EIkREYgSEoUSEoESEn4SEn0SEoEQEIgQEJAQEJUQEJcSEpYTE5MkJI9ubpYAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzc5Vra5ZOTpZP + T5hCQpg0NJg1NZw3N6Fra7YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZMkzM741Nb4uLrwpKbohIbUKCq4FBa4FBa4GBq0GBqwG + BqsHB6gHB6UICKIJCaAKCp0LC5oMDJcNDZQODpEQEIwREYYqKnBUVG9qaoQAAAAAAAAoKKMODp0PD50R + EZkSEpQTE41MTJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6epFj + Y5RNTZM3N48hIY8SEpASEpISEpMREZUREZYSEpgSEpoSEp0SEqEdHacAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQELMKCq8mJrc6 + Ors1NbkuLrYmJrUQELAFBa8FBbEFBa8GBq0GBqsHB6gHB6YHB6MICKEJCaAKCp0LC5oMDJYODo8QEIcP + D4FWVmt6enoAAAAAAAAAAAB4eMsNDaIODp8QEJkSEpMTE4wcHIlmZpUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABzc5VbW5NFRZEuLpAYGI4REZAREZIREZMQEJQQEJYPD5kPD5oPD5wPD58PD6APD6IQEKQoKK1n + Z8kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABUVMkGBrAGBqsFBagVFao4OLQ6OrUzM7UtLbgSErQFBbMFBbMFBbAGBq0GBqoGBqgH + B6cHB6UHB6MICKEKCp0LC5kNDZAQEIcQEH4mJnFycnIAAAAAAAAAAAAAAAAAAAAyMq0ODpwQEJYREZES + Eo0TE4o0NI98fJNra5NiYpNNTZM/P5InJ5ASEpAREZEREZMREZQQEJYQEJcPD5kODpsODp0NDaANDaIN + DaQMDKYNDagMDKo+Prt1dc8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHB7UHB64GBqkGBqMGBp4gIJlZWaw+Prk4 + OLsxMb0aGrkFBbUFBbMFBa8GBqwGBqoGBqgGBqYHB6UHB6MJCaALC5sNDZIQEIgREX0TE3lbW3IAAAAA + AAAAAAAAAAAAAAAAAABjY7EPD5cQEJMREZAREY8SEpASEpEREZMREZQQEJUQEJcPD5cPD5kODpsODpwO + Dp4NDaEMDKMMDKUMDKcMDKkLC6sXF7BLS8J1ddEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH + B7QHB60HB6cICJ8ICJphYYwAAABpacFERME9PcI3N8IfH7wICLUFBbIGBq4GBqsGBqkGBqgGBqYHB6QI + CKEKCpwNDZIQEIcREX0TE3Y/P2x4eHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAzM5cPD5EPD5IPD5UPD5gP + D50ODp8NDaENDaIMDKMMDKUMDKYLC6gLC6oLC60KCq49Pb9nZ80AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB3d9gICLMICKwICKUJCZwWFpIAAAAAAAAAAAB1ddFISMhCQsc9PcUt + LcEQELYFBbAGBqwGBqoGBqkGBqgHB6YICKIKCp0NDZQQEIoSEn0TE3UvL2tubm57e3sAAABubopmZol9 + fX17e3t/f38AAABra5ogIJUNDZYNDZwNDaEMDKYLC6kLC6wKCq4jI7c+PsB1ddMAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABubpppaZNmZo9jY4xiYohhYYhh + YYdhYYdhYYdgYIZgYIZgYIZgYIZhYYdhYYdhYYdhYYhhYYhhYYhiYohiYohiYohpaYh/f39/f38AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQMgICLMJCasKCqILC5ks + LIsAAAAAAAAAAAAAAAB7e9tOTsxISMpBQcg8PMUnJ7wQELIGBqwGBqsGBqoHB6gICKQKCqAMDJgPD40U + FIMgIH82NnJmZmZHR20fH3YSEn0REYAQEIEsLHhZWXFwcHB+fn4AAAB/f6hkZLJtbcF0dMwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NcUNDbIODqsP + D6QQEJ0REZgSEpQSEpISEpETE5ATE48TE44TE40TE40TE40TE40TE40TE40TE40TE40TE40TE40TE40T + E40TE40TE40TE4sTE4sTE4oTE4gUFIgVFYYvL4VhYYh9fX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA/P8YJCbAKCqkLC58NDZVCQocAAAAAAAAAAAAAAAAAAAB7e9pTU85NTcxISMlBQcU8PMEv + L7wdHbUTE7IODq8ODqoQEKYYGKIgIJwmJpMnJ4hAQG0yMmYTE3UTE3gSEnwREX4REX4REXwREXs7O21q + amp6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABGRtMLC7wLC7gMDLMMDK0NDagNDaMODqAODp4PD54PD50PD50PD5wQEJsQEJsQEJsQ + EJsQEJsQEJsQEJsQEJoPD5oPD5kPD5kPD5kPD5kQEJgQEJgQEJYQEJUQEJQSEpITE5ATE4wUFIg+Pol4 + eIQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/P8IJCawLC6QNDZoPD5BKSoUAAAAAAAAAAAAA + AAAAAAAAAAA8PMlYWM5TU8tMTMhHR8RAQMI7O8A1Nb8wML0qKrgmJrMgIKwiIqMkJJslJZEhIX4QEHwQ + EH0QEIAQEIIQEIMQEIAREXwSEncSEnYxMWtpaWl6enoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOYlJccKCroKCrcKCrIKCrALC60L + C6sLC6sMDKsMDKsMDKsMDKsMDKoMDKoMDKoMDKoMDKoMDKoMDKgMDKcMDKcMDKYMDKcMDKcMDKcMDKYM + DKUMDKQNDaMODqAPD54QEJoSEpUTE48rK45xcZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+PrwK + CqYMDJ4PD5QQEItgYIUAAAAAAAAAAAAAAAAAAAB1ddgFBbhAQMdeXsxYWMlTU8VMTMRGRsNAQMQ7O8I1 + Nb4wMLoqKrMmJqsiIqQeHpsODo4ODosPD4oPD4sPD4wPD4wQEIgREYASEnkTE3MTE3EyMmhqamp+fn4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB9feJBQcwWFr0ICLcJCbYJCbUJCbUJCbUJCbUJCbQJCbQJCbMJCbMJCbMJCbMJCbMJ + CbMJCbIJCbIKCrIKCrIKCrIKCrIKCrIKCrIKCrEKCrEKCq8MDKwNDagODqMQEJwSEpYcHJFxcZsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAuLq4LC6ANDZoQEI4SEohoaIcAAAAAAAAAAAAAAAAAAABLS8sFBbYF + BbAuLrljY8hdXcdWVsVQUMVLS8dFRcU/P8I6Or01NbkwMLMoKK0QEKALC5oLC5cMDJcMDJcMDJYNDZQO + DpAQEIgSEn8TE3YUFG8WFm1CQmZubm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB7e90AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABt + bdgmJr4LC7AMDKsODqQQEJwSEpZeXqAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC50LC5kNDZMREYoTE4YA + AAAAAAAAAAAAAAAAAAAAAAAhIb4GBrMHB6sWFqR1daBkZMFjY8hcXMlXV8pQUMlKSsRFRb8/P7s7O7Ux + MZ8ICKYJCaIJCaEJCaAJCZ4KCp0LC5sMDJYODpAQEIcTE3wUFHIWFmsYGGpWVmt2dnYAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJsAMDLEODqoQEKIREZo/P54AAAAAAAAAAAAA + AAAAAAAAAAAMDJUNDZMPD48SEogZGYUAAAAAAAAAAAAAAAAAAAAAAAAHB7gHB7AICKgpKaAAAAAAAACN + jcl3d85cXMtcXMxWVshXV8FHR7UdHaYGBqkICKgHB6YHB6QHB6QICKMICKIJCaAKCpwMDJcODo8REYUT + E3kXF24ZGWgoKGRra2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABw + cN4LC7UMDK4ODqYPD58bG5pTU515eZAAAAB+fn58fHwMDJENDZAPD40SEokuLogAAAAAAAAAAAAAAAAA + AAAAAAAICLcICLAJCaZCQpwAAAAAAAAAAAAAAAAAAAAAAAAAAAB0dLoFBagGBqoGBqoHB6oHB6gHB6cH + B6YHB6YHB6UHB6QICKEKCpwMDJYPD40TE4EVFXQYGGkaGmZJSWZ1dXUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGL0LC7MMDKsNDaUODp8ODpscHJkoKJMlJZAMDJQN + DZEPD44REYxPT5UAAAAAAAAAAAAAAAAAAAAAAAAICLgJCa8LC6VNTZ0AAAAAAAAAAAAAAAAAAAAAAAAA + AAAFBasFBakGBqsGBqwGBqoGBqkGBqgGBqcGBqcGBqcHB6YHB6QICKEKCpwNDZQQEIoTE3wWFnAZGWcj + I2NsbGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABra6pXV6N/f6IAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERNAK + CrcKCrELC6wLC6cKCqQKCqIKCp4LC5oNDZUPD5IREZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCboKCrAM + DKVQUJ8AAAAAAAAAAAAAAAAAAAAAAAAGBq8GBq0FBasGBqwFBasGBqsGBqkGBqcGBqcGBqcGBqcGBqcH + B6UHB6MJCZ8LC5kODpESEoQUFHcXF2wZGWdKSmd1dXUAAAAAAAAAAAAAAAAAAACAgK0/P6QSEpsSEpkT + E5YcHJSAgKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+UICLsJCbcJCbMJCbAJCa0JCaoLC6MMDJ4ODps2NqIAAAAA + AAAAAAAAAAAAAAAAAAAAAAA0NMoKCrIMDKYXF50AAAAAAAAAAAAAAAAAAABVVcMGBq8GBq4FBa8GBq4F + Ba0GBqsGBqgGBqcGBqcGBqcGBqcGBqcGBqYHB6UICKIKCp0MDJYQEIsTE38VFXIXF2swMGRra2t5eXkA + AAAAAABnZ6EiIpoQEJ0PD6APD6AQEKAREZ0SEpkwMJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcgHB7wH + B7oICLYJCbEKCqwMDKgZGacAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+MKCrUMDKkODp5PT5kAAAAA + AAAAAAAAAAAcHK8HB68GBrEFBbIGBrIFBa8GBqsGBqkGBqgGBqcGBqcGBqcGBqcGBqcHB6YHB6QJCaAL + C5sODpIREYYTE3oVFXEWFm5fX2lwcHBdXYcwMI0REZQPD5wODqMYGKlfX8EAAAAcHKoQEKESEpxVVakA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB/f+YVFcIHB70ICLkKCrUlJbkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAJCbkMDK0ODqIZGZkAAAAAAAAAAAAAAAAlJbIfH7YVFbkKCrcFBbUFBbEGBq0GBqoGBqgG + BqcGBqcGBqcGBqcGBqcGBqcHB6UICKIKCp4MDJcPD44SEoMTE3kTE3Q5OW0fH3oSEoYREZEPD5oODqNe + XsAAAAAAAAAAAAAAAAAODqsQEKQSEpwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtoLC7INDacPD51PT5kAAAAAAAAAAAA8PLYq + KrkoKL0mJsAgIL4VFbgNDbIGBqwGBqkGBqgGBqgGBqcGBqcGBqcGBqcHB6YHB6QJCaALC5sNDZMQEIoR + EYESEnwSEn0SEoMREY4PD5hGRrEAAAAAAAAAAAAAAAAAAAAAAABxcdoNDawQEKM6OqUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK + CrgMDK0ODqIZGZoAAAAAAAAAAABoaLszM7swML8uLsEsLMIrK8ApKbwnJ7kbG7MVFa8NDasICKkGBqcG + BqcGBqcGBqcHB6UICKIKCp4LC5gODpEPD4cSEoQTE4UQEIstLZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAaGrkODqsREaB/f6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYtkLC7MMDKgODp5PT5sAAAAAAAAAAAA8PLw5OcA2NsM0NMMy + MsUxMcIvL74uLrwtLbkrK7cqKrQjI7IdHbAZGa0UFKwUFKoUFKcUFKMWFp8cHJkiIpQlJZIiIoppaaMA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOINDbEPD6UvL6MAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrgLC60NDaMX + F5wAAAAAAAAAAAB2dsNBQcI/P8U9Pcg7O8g6Osg5OcQ3N8I1Nb80NLwyMrowMLcuLrYsLLUqKrQqKrIp + KbAoKKwnJ6UnJ54nJ5gmJpWCgpkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGboO + DqsREZ9+fqsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABiYtgKCrEMDKcODp5cXJkAAAAAAAAAAABubsxISMlFRctERMtCQstAQMs/P8k9 + PcU8PME6Or85Ob03N7s2Nro0NLkzM7YyMrMxMa8xMagwMKEvL548PJsAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACAgOIMDLAPD6Q4OKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrQLC6kNDZ8eHpgAAAAAAAAA + AAAAAAB4eNdPT89MTNBKSs9JSc5HR8xFRcpERMhCQsVAQMI/P8E+Pr89Pbw7O7k6OrY6OrE5Oas5OaY4 + OKVzc6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7UODqkREZ57e6gA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABfX9MLC6wNDaEODphhYZQAAAAAAAAAAAAAAACQkOZVVdNTU9NRUdFQUM9OTs5MTMxMTMpKSsdI + SMRHR8BFRb1ERLtDQ7dBQbNCQq9BQa1JSa4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABhYdcNDa8QEKRBQaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6wNDaAPD5c8PJQAAAAAAAAAAAAAAAAAAAAA + AABgYNlaWtZYWNNWVtBVVc5TU8xSUshRUcRPT8FOTr5MTLtMTLhKSrVLS7VOTrUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7QODqkREZ8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6wO + DqAQEJcvL5MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaNpgYNReXtFcXM1bW8lZWcRXV8BWVr5VVbxV + VbtUVLteXr4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABERM4MDLAPD6ZLS6sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC6sODp8QEJU/P5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACAgNxmZs9jY8tiYsVhYcJgYL9gYMBra76UlM8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7YODq0QEKUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKkODp0REZVdXZgAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArK7QeHq0gIKpjY64AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8UMDLQO + Dq5pacEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABaWsoMDKgODpwREZR3d5oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2dsgICKoK + CqUcHKEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC7oNDbU1Nb0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMbsMDKYPD5oZGZMAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAUFK4KCqcMDKJ8fKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYt0ZGb9FRcsAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC64NDaMQ + EJpBQZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcXMELC6cMDKIxMaEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALC6wNDaIQEJliYp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAALC6gNDaEODp0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC6oODqAQEJgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5ObYNDaMODpxERJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABaWsoMDKkODp8pKZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKkODp8XF5cAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMrsNDacPD51cXKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAXF7QMDKkODp5PT5sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC68NDaUPD50A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrQMDKsXF6EAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAMDK0ODqMhIZ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Nc0KCrcM + DK5LS68AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1ddEMDKsODqJPT6cAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABxceEJCbsLC7MwMLMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9 + Pb8NDakPD6EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Nc0KCrkMDLEODqhQULEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGLAODqYsLKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABiYtwKCrgMDLIODqkQEKJMTKsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKwODqVlZa8AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGL0MDLMNDawPD6UREZ5KSqUA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABlZcwNDaoPD6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABTU9MLC7YMDLAODqkQEKMREZxJSaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMrsODqlBQa4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8QLC7QNDa0PD6cQEKESEptaWqYA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDLAO + Dqh9fbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAmJsIMDLMNDawPD6YREaAcHJxsbKsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABmZs8NDa8iIq4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgOQZGbsMDLIODqsPD6YREaAwMKUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJL0NDbFlZb8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB/f+IZGboNDbAPD6wQEKgdHagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALC7kYGLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f+IaGrkODrIODrBQUMYAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERNELC7t1ddUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGcUZGcAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////// + /////////////////////////////////j////////////////////4f///////////////////+H/// + /////////////////w////////////////////8P////////////////////h/////////////////// + /4f////////////////////H////////////////////w////////////////////8P///////////// + ///////h////////////////////4f//P/////////////////D//x/////////////////w//8P//// + ////////////8H//D/////////////////h//w/////////////////4P/8P/////////////////D// + D/////////////////wf/wf////////////////8H/8H/////////////////h/+B/////////////// + //4P/g////////////AA////D/4P///////////AAD///wf+D///////////gAAP//8H/g////////// + /wAAB///g/4P//////////4AAAH//4P+D//////////8AAAA//+B/g///////////AAAAH//wf4P//// + //////wAAAA//8H+D//////////8AAAAH//B/g///////////AAAAA//4P4P//////////wAAAAP/+H+ + D//////////8AAAAB//h/g///////////AAAAAP/wf4P//////////4AAAAB/8H+D//////////+AAAA + Af/D/g///////////gAAAAD3g/4P//////////8AAAAA/4P+B///////////AAAAAH8H/gf///////// + /4AAAAB/B/4H//////////+AAAAAPwf+A///////////wAAAAD4P/gP//////////+AAAAA+D/8D//// + ///////wAAAAPg//Af//////////8AAAAB4f/wH///////////gAAAAcH/+B///////////8AAAAHB// + wf///////////gAAABw//+D///////////8AAAAcH//g////////////gAAAHA//8H///////////+AA + AAwP//g////////////wAAAED//4H////////////AAAAAf//A//////j/////8AAAAH//wP/////4P/ + ////wAAAA//8D//////A//////gAAAH//A//////8D///////gAAfwAP//////wP//////4AAAAAD/// + ////Af/////+AAAAAB///////8B//////gAAAAA////////wD///4AAAAAAAf////////AH//wAAAAAA + A/////////8AP/wAAAAAAB//////////wAfgAAAAAAH///////////AAAAPAAAAB///////////+AAAf + /AAAAP///////////4AA//+AAAA////////////gB///gAAAAP//////////+D///8AAAAAf//////// + ///////gAAAAD///////////////8AAAAAP///AH//////////AAAAMB//wAB//////////wAAADgH+A + AA//////////4AAAA+AAAAB//////////+AAAAPwAAAH///////////gQAAB/AAA////////////wOAA + AIIAH/////+AAAA//8DwAAAAh//////wAAAAAf/A+AAAAH//////4AAAAAD/wPwAAAA///////AAAAAA + f8D4AAAAH//////+AAAAAD/A+AAAAB////////+//+AfwfgAAAAP///////////8D8H4YAAAD/////// + /////gEB+H8AAAf///////////+AAfh/AAAH/H//////////wAP4fgAAA+A//////////+AD+HwAAAGA + P//////////4B/g8AAAAAh///////////A/8PAAAAA8f/////////////BwAAAA/D/////////////4c + AAAA/4f////////////+DgAAAf+H/////////////w4AAAP/w/////////////8HAAAH/8P///////// + ////h4AAB//h/////////////4PAAA//4f/////////////D8AAf//H/////////////w/wAP//w//// + /////////8P/AH//+P/////////////D/8P///h/////////////g/+H///8f////////////4f/h/// + /H////////////+H/w//////////////////h/8f/////////////////4/+H/////////////////8P + /j//////////////////D/w//////////////////x/8f/////////////////8f+H////////////// + ///+H/h//////////////////j/8H/////////////////4//gf////////////////+P/+B//////// + /////////H//wH////////////////x///Af///////////////8f//8B///////////////+P///gP/ + //////////////j///+B///////////////5////4P//////////////8f////////////////////P/ + /////////////////////////////ygAAABAAAAAgAAAAAEAGAAAAAAAADAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxccwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODqV7e8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABCQrUkJKYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp11dbcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ6YiIqMAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6eswNDZt7 + e7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAANDZs3N6YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODqgAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABQULgNDZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp5RUa0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODppJSakAAAAAAAAAAAAAAAAAAAAAAAAA + AAANDZkzM6IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ6MODpoAAAAAAAAA + AAAAAAAAAAAAAAAAAAANDZgzM6EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABr + a8QNDZhZWaoAAAAAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABoaKlMTJkqKpY9PZNMTJR1dZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAANDZghIZ4AAAAAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhMQWFpcLC5EKCpIJCZIJCZELC5AMDJMyMo94eIUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0NKgNDZhxcakAAAAAAAAAAAAAAAAAAAANDZgzM6AAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdHZwKCo4HB5EICJsHB58ICJsICJMI + CI8KCo8REZFTU4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZczM6AAAAAAAAAAAAAAAAAA + AAANDZgzM6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eMYWFpUICJEGBp0G + BqUGBqcGBqUGBqEHB5sHB5EJCYwLC5E4OI4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZgNDZgA + AAAAAAAAAAAAAAAAAAANDZg0NKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABN + TbIXF5cICJsGBqUGBqcGBqcGBqcGBqcGBqUGBp0GBpAICIsLC48xMY4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABLS68NDZdgYKoAAAAAAAAAAAAAAAANDZk0NKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB+fsgcHJoICJsGBqUGBqcGBqcGBqcGBqcGBqcGBqUGBp0GBpEICIsLC5A+PosAAAAA + AAAAAAAAAAAAAAAAAAAAAABtbboNDZdYWKoAAAAAAAAAAAAAAAANDZlSUqoAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIpoLC5QGBqEGBqcGBqcGBqcGBqcGBqcGBqcGBqUGBp0G + BpEICIsMDJFUVIsAAAAAAAAAAAAAAAAAAAAAAAAvL6INDZiAgLAAAAAAAAAAAAAAAAAODppaWqsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjI50VFZUHB5sGBqUGBqcGBqcGBqcG + BqcGBqcGBqcGBqUGBp0GBpEJCY0REZF5eYYAAAAAAAAAAAAAAAAAAAANDZgXF5oAAAAAAAAAAAAAAAAA + AAANDZlPT6YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaL8hIZkKCpIG + Bp0GBqUGBqcGBqcGBqcGBqcGBqcGBqcGBqUGBp0HB5EKCpA5OY0AAAAAAAD///8AAABhYbkNDZdFRaMA + AAAAAAAAAAAAAAAAAAANDZgxMZ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAwMKEbG5UGBpIGBqEGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqUHB5sICI8MDJNycosAAAAAAAAA + AAAkJJ4NDZeBgbEAAAAAAAAAAAAAAAAAAAAMDJYNDZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACTk9UwMKAbG5cHB5sGBqUGBqcGBqcGBqcGBqcGBqcGBqcGBqcGBqEHB5IK + CpA7O5AAAAAAAAAAAAANDZggIJ0AAAAAAAAAAAAAAAAAAAAAAAANDZUMDJRra6MAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzc8M5OaQjI50HB5sGBqEGBqUGBqcGBqcGBqcG + BqcGBqcGBqUHB5sJCZAfH5AAAAAAAABoaLkNDZhZWaoAAAAAAAAAAAAAAAAAAAAAAAAaGpwMDJNDQ58A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdXbdERKg0NKINDZUG + Bp0GBqUGBqcGBqcGBqcGBqcGBqcGBp8ICJATE5YAAAAAAAA5OagNDZkAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAMDJYNDZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABkZLtPT6xFRaclJZ4KCpwGBqEGBqUGBqcGBqcGBqcGBp8ODpMnJ51xcZQAAAA1NaINDZgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABfX78NDZhJSagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACIiM1ZWbJUVK5LS6wsLKIbG6MVFacUFKoXF60qKq43N6c3N6N4eIQAAAAu + LpgNDZVkZJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0NKgNDZl7e6oAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqartgYLVcXLFXV7FTU7NQULdNTbhJSbVF + Ra4eHplQUIhERIs8PIcLC5A2NpEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZcoKJwAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRsQoKLEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAClpdyDg8ZnZ7lj + Y7dgYLddXbZYWLQmJp0aGo8YGI4KCpIODosKCo4SEo97e3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe + HpYNDZVhYaIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABgYMgODqM+PrMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTKJDQ5YICJkICJ4HB5kNDYkKCowoKIhsbIUAAAAAAAAAAAAA + AABxcaBubpxubpcjI5AMDJM7O6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbMsbG6cmJqp2dsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2drEYGJoICJ4TE6obG6kGBpQICI4KCo4Q + EI1QUIE2No8TE5MMDJMMDJIMDJELC5ELC5ENDZZlZbkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7e9EoKKwODqBHR7J5ebsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbK1XV6c8PKNXV6Z6eqUAAABmZrFeXr4zM7UG + BqUGBqEHB5sHB5IICJAKCpAJCY4JCY0KCo0LC48LC5AMDJMjI54AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAoKKoODp0ODpxCQqpwcLEAAAAAAAAAAAAAAAAAAAAAAABsbK08PKENDZgNDZcNDZcNDZcMDJYMDJQV + FZE1NZAmJpIHB6UGBqcGBqcGBqUGBqEHB58HB5kHB44KCosLC5AyMpljY7IAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABCQrINDZsNDZkNDZk+PqNqaqlxcahERKIWFpkNDZcNDZYNDZgwMKQA + AAAAAABMTLEZGZsMDJMKCpAICJIHB50GBqUGBqcGBqcGBqcGBqcHB58HB5BMTHgAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdXb4ZGZ0NDZgNDZcNDZcNDZcNDZgw + MKV5ecIAAAAAAAAAAAAAAAAAAAAAAAAAAABSUq8QEJEICJMHB6EGBqcGBqcGBqcGBqcHB58HB48QEIle + Xn8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1 + Nas/P65+fscAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8PKYYGJgJCaAGBqcGBqcGBqcG + BqcGBqEHB5IJCYwQEIsjI4oSEpMNDZknJ51XV6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERKku + LqgSEqMGBp8GBqEGBqUGBqUHB50GBpIHB48JCY8LC5ATE5EeHpgNDZkYGJxtba4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB6erNeXrJhYbdzc8UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAqKpo3N6Q8PKYfH5oGBpMGBp0GBqUGBqUGBqEHB58HB5kUFIl1dYEAAABjY7INDZkNDZkz + M6EAAAAAAAAAAAAAAACBgbBaWqs9PaQgIJ4NDZsNDZsODpwODp4mJqtxcc4AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAALC5AKCoxGRppISKgqKpsJCZMGBqEGBqcGBqcGBqcICJ8JCZJHR4kA + AAAAAAAAAAA0NJ4NDZcWFpk0NKANDZoNDZoNDZkNDZkNDZkODpoxMadiYrsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS7ALC5ALC5AAAACIiLpSUq44OKUTE6MGBqcGBqcG + BqcHB58JCZEmJop5eXlpaZZqapYAAABgYJsfH5oNDZoZGZw8PKtiYrp+fskAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvb9NAQLQ6Oqo2NqM0NKAyMp4xMZwxMZ0xMZ0y + Mp4yMp8zM6AzM6AzM6AzM6AyMqBDQ6QAAAAAAAAAAAAAAAAAAAAAAAA9PacMDJElJZQAAAAAAACUlMdd + XbRPT7U3N7EdHagXF6cTE6EYGJctLYgcHIcLC5ALC5AYGI1lZYcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3N7MODpwNDZkNDZcM + DJYNDZUNDZUNDZYNDZcNDZgNDZgNDZgNDZgNDZcMDJYNDZYXF5t+fq0AAAAAAAAAAAAAAAA5OaMMDJIv + L5oAAAAAAAAAAAAuLqBgYLVaWrNNTa5BQao1NagpKaAPD5IHB5AHB5AICI8KCo4QEI5mZooAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB4eMh1dcV0dMUAAAAAAAAAAAAAAAAAAAAAAAAAAACEhMtAQK0NDZgODppoaLEAAAAA + AAAAAAAwMJgMDJNSUp8AAAAAAAB+fscMDJRQUJ9sbLJmZrdaWrFLS64qKp4HB58HB58GBp8HB5sHB5EJ + CY4eHo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA1NasODpo4OKV2dqt1dZ4cHJEMDJNqaqsAAAAAAAB0dMYNDZeBgawAAAAAAACSkr0pKZMICJ8HB6cG + BqcGBqcGBqUHB5sICI4LC48/P44AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABfX8ANDZkMDJQLC5ELC5ANDZcAAAAAAAAAAAB5ecwNDZl6erEAAAAAAABQ + UKgJCZEHB58GBqcGBqcGBqcGBqcGBqEGBpMJCYwQEI9+fn4AAAAAAABwcLwkJKgYGKMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbG50NDZUNDZdgYLoAAAAAAAAAAAAAAAAN + DZs3N6YAAAAAAAAWFpkLC5IHB58GBqcGBqcGBqcGBqcGBqUGBpsICI4KCo1NTYdQUJ4YGKIkJKd5ecMx + MakZGaMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABDQ7IODpoAAAAAAAA9PaYxMaEeHqMSEqUKCqYGBqcGBqcGBqcGBp8GBo8JCYsMDJIX + F5xmZrsAAAAAAAAAAAAaGqFmZroAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODpo3N6IAAABqarFDQ6g8PKU5Oac1Na4rK7IjI7EeHq0W + FqEbG5YeHpU+PpwAAAAAAAAAAAAAAAAAAAB6es0ODp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQa8NDZmAgKwAAABgYLVRUa1LS6lH + R6tERLI/P7Q7O684OKU1NaA1NaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAODp9aWrYAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDZlISKYA + AAAAAACEhMlfX7VaWrFUVLBRUa9OTqxMTKpKSqxtbbgAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsAaGqEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAANDZk0NKMAAAAAAAAAAAAAAAB6esFoaLdkZLRhYbRgYLV/f8IAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAODp9pab0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAANDZpISKkAAAAAAAAAAAAAAAAAAAAAAAAjI55zc7IAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABFRbsbG6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxccMODppycrQAAAAAAAAAAAAAAAAAAAA7O6oiIqEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fdkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS7QODpwAAAAAAAAAAAAAAAAAAAAA + AAAODp8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJqY4OKkAAAAA + AAAAAAAAAAAAAAAmJqc3N6cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODp9ubroAAAAAAAAAAAAAAAAAAAAODp0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAODqAAAAAAAAAAAAAAAAAAAAAAAAAbG6NJSbEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlZcIwMKwAAAAAAAAAAAAAAAAAAAAAAAAAAAApKaoODp5RUbQA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJqp1dcIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB7e88ODp4ODp5OTrEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGqcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsEODp4aGqN0dMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABubs9b + W8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeXsQODqeEhNcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAA5Ob8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////// + ////////////9//////////z//////////P/////////+f/////////5//////////j//////////P9/ + ///////8/z////////5/P////////n8////////+Pz/////8D/8/P/////AD/x8/////8AH/nz/////g + AP+fP////+AAf48/////4AA/jz/////wAB+PP/////AAD58/////8AANHz/////4AAcfP/////gABz8f + /////AAGPx/////+AAZ/n/////8AAn+P/////4ACP8f/////4AA/5///P//wAB/j//+P///gDwP//+H/ + /+AAA///+D/8EAAP////B+AAAD/////AAYAB//////AH8AD//////j/4AAf///////wAAf/D/////AAQ + 8AP////8ABwAP/////iAAgP//AAB+MAA///+AAB44AB////j+DjAAH//////AMYAP/////+BxgAY//// + /+HmAAB//////+YABz//////8gAfP//////xAD+f//////mAP5//////+eB/z//////5+f/P//////Hz + /+//////8/f////////z5/////////Pv////////9+f////////n8f///////+f4f///////7/4f//// + ///P/4///////9///////////////ygAAAAwAAAAYAAAAAEAGAAAAAAAABsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7FlZXoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAByctIxMYgA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAASEqdjY3UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPT8c1NX4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAASEp5tbXUAAAAAAAAAAAAAAAAAAACCgsJfX3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKLg8PHMAAAAAAAAAAAAAAAAAAABSUr4x + MXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/ + f9YaGpB2dnkAAAAAAAAAAAAAAABGRr0jI3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODqVISGwAAAAAAAAAAAAAAAA9PbofH30AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAB7e5I7O28tLWkyMmBISF5ycnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCQsUjI4AAAAAA + AAAAAAAAAAA4OLkgIH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSUqMODpAPD4sQEIgSEn8WFnAhIWFISFoAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAQEJlYWGoAAAAAAAAAAAA2NrsjI30AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATE7AHB6YH + B6IICKAJCZwNDZETE38YGGg1NVh3d3cAAAAAAAAAAAAAAAAAAAAAAAAUFKwxMW4AAAAAAAAAAAArK74o + KHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAREbsFBa4GBqcGBqYGBqYHB6MKCpoREYcYGGwxMVd3d3gAAAAAAAAAAAAA + AAAAAABVVcQXF4QAAAAAAAAAAAAsLL0vL3YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFsAFBbEGBqgFBaYFBaYGBqYG + BqQKCpwQEIkYGGw3N1cAAAAAAAAAAAAAAAAAAABiYr0ZGYYAAAAAAAAAAAAsLL00NHQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAdHcYICLcFBasFBacFBaYFBaYGBqYGBqUKCpwREYUZGWZLS1oAAAAAAAAAAAAAAAAbG6A3N3kA + AAAAAAAAAAAsLLwyMnMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoaN4TE8AFBbEGBqgGBqcGBqcGBqcGBqYGBqQLC5gU + FH0hIWBxcXMAAAAAAAAAAAAODpVvb4YAAAAAAAAAAAAwML0mJnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJcsN + DbwFBa4FBagFBaYGBqcFBaYGBqYHB6IODpAXF25CQlsAAAAAAABLS7YZGYkAAAAAAAAAAAAAAAA4OL4Y + GIN4eHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJ8kQELoFBa0FBagGBqcFBaYFBaYGBqUKCpsTE34lJWAAAAAA + AAAPD6RDQ3wAAAAAAAAAAAAAAABNTc4QEJhPT2YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHh+U1NcwcHL4GBq4F + BakGBqcGBqcGBqYICKEPD4sbG297e38AAAANDZpubn4AAAAAAAAAAAAAAAAAAAATE7EqKnsAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACQkOdERNA0NMYVFbYGBqwFBagGBqcHB6QVFZUsLIBvb3UAAAAQEI1jY28AAAAA + AAAAAAAAAAAAAAAAAAAQEKFXV24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABaWtdNTc9CQsgyMr8tLbsz + M7o8PLE2NpFRUWhoaHwTE3xDQ18AAAAAAAAAAAAAAAAAAAAAAABYWMIjI4F3d3gAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbW7deXokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAChoehpadlXV9FTU81PT8pBQb8XF50bG4IREYISEnoqKl5/f38AAAAAAAAAAAAAAAAA + AAAAAAASEodAQGIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUMUqKqFg + YIoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7IICKcK + Cp8UFIoXF202NlhtbXAAAAB3d4VaWnFSUnFGRnIQEIgyMnwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlZcogIKpDQ4pqan8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABxcX55eX4AAAA8PK4kJLAgIK8KCp0PD4kUFHUiImYZGXUREYIPD4oMDJUKCpoZGZ0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8fNMdHbMe + Hpc8PHlcXHAAAAAAAAAAAAAAAAAAAABUVH0iIoQPD5EODpUNDZgbG4kyMoEkJJQGBqYGBqUJCZ8LC5cM + DJEMDI0KCo4aGp1KSrQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLr4ODqIcHIo2NnBHR24rK34QEJIMDJswMKmCgsYAAABp + adEiIsAFBbIEBK4FBa0GBqgGBqYHB6QICJ4NDYVLS2MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTMoL + C60LC6YjI6pwcMAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEsEEBLUFBasFBacGBqYICJ8PD4gcHGpOTl9a + Wm1UVGxnZ3MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f94e + HrwODrAGBqkGBqgHB6MLC5YQEIQSEngTE3MWFn4TE4wtLXxkZG8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAB9fYhnZ3tgYH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGrQqKrQWFrIFBbAGBqoHB6MJCZ0MDJIYGHVubnYAAAArK6QX + F4xFRWx4eHsAAABqan9NTXc0NHkfH4YTE5MPD5omJqdlZbUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZtAGBqQ7O4VLS7UgIL8G + BrEGBqgGBqQLC5cSEntMTGMAAAAAAABAQIIREZATE5EPD5gNDZ4ODqU1NbZmZsgAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAB4eJ5MTHdFRW9AQHA/P24/P24/P24/P24/P29DQ2tFRWtLS2tnZ3AAAAAA + AAAAAAAAAAA4OMELC5lubn8AAABiYtE0NMEYGLIMDKsODp4aGoU5OWQxMW4fH3NAQGFlZXV1daIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS8kUFLULC6gLC6UMDKMMDKIM + DKMMDKMMDKMMDKMNDaIPD5sXF4pNTWsAAAAAAAAAAAAvL7AQEI0AAAAAAAB3d81GRsJISME4OMErK7ck + JKITE4UODokQEIYTE3Y3N10AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZWcgREaJAQHp4eHoAAAAgII4W + FoEAAAAAAABDQ8MqKox4eKVnZ9FOTsAbG6sICKMICKEKCpoREYYYGGlMTFwAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAeHrYWFpkmJoEQEI0wMH4AAAAAAAA6OsY4OHkAAAAAAAAtLakFBasGBqgGBqYHB6QL + C5gUFHslJV5+fn4AAAAAAABcXIZUVHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFRdAHB7YQEKkAAAAAAAAAAABpadEd + HZB7e30AAAAICLQFBa8GBqgFBaYGBqYICKEODo4WFm9KSl9ERHohIZ1vb7QkJKhjY34AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDapKSnB1dZAoKL4fH70VFbANDaoHB6cGBqUKCpoREYUVFYBi + Yp8AAAAAAAAAAAAjI5cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfX9AcHJJ8fIBWVrI6 + Oso2NsQyMrsuLrYpKbInJ6ooKJh7e5AAAAAAAAAAAAAAAAAyMr1SUnoAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAQEKVRUXAAAAB7e9NMTNFISMpERMNBQbs/P7FRUaAAAAAAAAAAAAAAAAAAAAAA + AAAjI5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH6pISHcAAAAAAAAAAACAgNpYWMZY + WLh/f7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAfH7ZhYYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAODp1tbYMAAAAAAAAAAAAAAAAUFKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfX7IAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEpcAAAAAAAAAAAAAAABPT6RKSokAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5ec8uLoYAAAAAAAAA + AAAAAAAUFJkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABFRbxfX4UAAAAAAAAAAABiYtM5OZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGaYAAAAAAAAAAAAAAAAAAAA1NcMxMZNj + Y3sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2 + No8AAAAAAAAAAAAAAAAAAAAAAACCgtgYGK8tLYtiYncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABlZbp+fpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtbdMXF6w/P4sA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9PbUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///////8AAP//+f///wAA///5////AAD///z///8AAP///P///wAA///+fP// + AAD///58//8AAP///jz//wAA////PP//AAD/wP88//8AAP+Af5z//wAA/4AfnP//AAD/gA+c//8AAP+A + D5z//wAA/4AHnP//AAD/gAOc//8AAP/AAzx//wAA/+ADPH//AAD/4AE+f/8AAP/wAT8//wAA//wAPx// + AAA//gAfn/8AAI//+Agf/wAA4f/IAD//AAD4PgAA//8AAP8AIAP//wAA/8H8AD//AAD///wAD/EAAP// + /gBCAQAA///8AGAfAAD4ADxAA/8AAPgAHMAH/wAA//+EwAP/AAD//+DMAZ8AAP//8cQADwAA////4ADv + AAD////gAecAAP////ID9wAA////84fzAAD////z3/sAAP////ef/wAA////57//AAD////nP/8AAP// + /++P/wAA////78P/AAD////P8f8AAP///9///wAA////////AAAoAAAAIAAAAEAAAAABABgAAAAAAAAM + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCzAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWlq+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAPT22AAAAAAAAAAAATU27AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT22AAAAAAAAAAAAPT22AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGC7Hx+rEhKo + UFC1AAAAAAAAAAAAAAAAAAAAAAAAWVm+AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjIzIBganBganBganBganBganhobCAAAAAAAAAAAAAAAABgan + AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + iorFBganBganBganBganBganBganhobCAAAAAAAAAAAAPDy1AAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABganBganBganBganBganBganBgan + AAAAAAAAAAAAFBSqAAAAAAAAPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAXV24BganBganBganBganBganBganQkKwAAAAf3/GWVm9AAAAAAAAPDy1gYHH + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyutBgan + BganBganBganBganBganAAAAOjqzAAAAAAAAAAAAdHTFPDy1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyutBganBganBganBganBgankZG5NzevAAAA + AAAAAAAAAAAAPDy0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAg4O/Hh6pBganBganBganMjKqERGodna8AAAAAAAAAAAAAAAAISGtAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXV3Ba2vFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + goK0BganBganERGoc3O5eHi+bW2+YWG8BganAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAeHjIPj63aGjCAAAAAAAAAAAAAAAAVVW5ExOqLCyuQECvJiaoBganBganBganBganNjavXl65 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALy+xIiKuFBSq + Skq5AAAAAAAAAAAAXFy4BganBganBganBganJiaoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZWW1BganBgan + BganBganBganKSmrLCyvf3/FAAAAAAAAAAAAAAAAAAAAh4fNfHzLAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFC1KCiqEBCnBganBganBganSEitAAAAW1u3ICCsOzuz + FBSqLy+xWVm+AAAAAAAAAAAAAAAAAAAAAAAAAAAAXV3BPj63PT21PDy1PDy1PDy1PDy1PT21AAAAAAAA + AAAAOTmxZ2e4nJy7BganBganBganGxunHBynNDSsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT21cnLCAAAAOjqzk5PFAAAANTWtR0etJSWnEBCm + BganBganNTWtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAgYHHBganExOqAAAAAAAAOTmxAAAAEBCnBganBganBganBganhYXAgIDGPz+3AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + OzuzAAAAERGoBganBganBganBganLCyuAAAAAAAATU27AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU1O4AAAAERGoBganBganBganAAAA + AAAAAAAAAAAAeXnKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAPDy0AAAAAAAAW1u2ODiwAAAAAAAAAAAAAAAAAAAAT0+9AAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGjCAAAAAAAA + SEi3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeHjIAAAAAAAAAAAAZ2fCAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + TU28AAAAAAAAAAAAWlq/aGjCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPz+3e3vL + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////////////7////+/////3f///93//4f + t//8B7f//AO3//4Dt//+ATP//wFz//+Ae///wD3/z/wB//HgA//+HA////4A+f/+AgfwDgD///JAf//4 + 0A///9A3///oe///7Pv//+3////d////3P////8///////////8oAAAAEAAAACAAAAABABgAAAAAAAAD + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAeXmRAAAAW1uRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPT2THBx6Wlpy + AAAAAAAAV1ekAAAAVVWRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwu0BgamDAyVTExsAAAAdXW/AAAA + XFySAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWHYBwerBgamEBCIAAAAYGCZAAAAQkKNAAAAAAAAAAAA + AAAAAAAAAAAAgoLJAAAAAAAAZmbXGxu0GBimX1+CaWmIAAAAAAAAgoLJAAAAAAAAAAAAAAAAAAAAAAAA + goLJAAAAAAAAAAAAdnagGxugIyNyfn6QYWGNamqTAAAAAAAAAAAAAAAAAAAAAAAAAAAAUlKWXV2ScXG5 + fHzOIiKwBwekFBSEenqaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHR2rCAih + ISF1V1eIbGyLa2uVbm6mAAAAAAAAAAAAZGS2WlqtY2OzWFikAAAAXFykAAAAPT2zIyOaGRl+d3ePAAAA + goLJAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoLJbGy4AAAAa2uTEhKvCAikJSVzAAAAenqZAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAZWWthoa/SEjBfX2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAdnauAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + goLJbW2qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA//8AAP7/AAD/XwAA418AAOFfAADhXwAAsG8AANwPAADgHwAA/wEAAMKFAAD8hQAA/4cAAP+/ + AAD/zwAA//8AAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAIABJREFUeJzsvWe0HNd1 + JvrtU1XdfQMuLiJJMOAyCiRNEhQpUhITJIuyRHFI2JQt2ZoRMbZH4zDrkeuNxpb9bJOzbI2X7PGS9GRL + shwo28p6HjGIpChRBDMYACIwIud8cUPnrnDO+3FqV+2q7otwcUEE9l6rVufuqur6vp33AbrSla50pStd + 6UpXutKVrnSlK11pl1U9PfdtKBaXAKAOW1e60pVTVdaWSnc91dtrnuzrM1s8790AXABevLkAHHSJ4KQT + dbx3oCsnvgy77sJ9St1rAGgAWwqF+wAUAfQAKAEooEsCJ6V0CaArhxTPmFENDBoABkBAdPlPi8XfBDAt + 3vpgicCDvaa6JHCSSJcAunJImR5FW/uM+Re2ADSA0PP+EMAggBkApgPoh7UKXJzCBDDqukN7PG/h8d6P + qZIuAXTlsGRWGH5Zw1oAGoAmOvMrhcKnAMwGMBPAAKxLUMAp6ArUlRpc3tv7pRd6eja/UiqtfHhgwDw+ + bdpTq0qlO9A5FnJSHP9JsZNdOSHEebK3d2mL6IaICBERmsC+X61UfgdAA8AYgAMARgFUAfiwXHFSS12p + wbXF4t37HeeukGgwIrIkGN8aIri12o23BcGrAKJ4C+Nb5swTVroWQFcOV8iLom9zHEADUERz/59i8RZY + V2AQNh5wSlgBdaUGV/X03PtsT8/m3Y5zT4to0CdCAMAnQhBvIVB+VmvAHv8ATrJ4SJcAunK4Yq5rtb6t + gTLHAQyAC4rFj8D6/wOwBNALGws4KQlg1HWHXurp+eYzPT2juxznnpZSg75S8InsphSC+HFAhD2t1pf/ + KooiAHMBzELqCnk4Cc6Bc7x3oCsnjRAA507XPStS6ipNBE0Eh2igFEVb1mg9Amv6+gBaSM3gE9oEZhl1 + 3aE7isUvbfK8+2pEC0PW8LwpZbfY/QmJqpuaza/9YaOxHBb0vbCgNziJ3IAuAXTlSIRuJxp1Xfc/6xgI + mgj9jkM/9f3XYC92JgAfFgQnNADqSg3+WrH4uQ2ue19VqfdGRAhisAe88XPxbRPY/Mj4+N9+3fe3w2ZA + +mDBD9hj5uMP4scn7PG7x3sHunJSif54EKx8qFB4HcClBBsEO811r5lP9KOtxrRg3YAKgBpSS4BDByeM + 1JUaXF8o3P28Uja4B7BmT27lfQ787Wi17v/zavUJWI0/B9YyasEeXw0ngdkvpWsBdOVIhT7tONMCpT7I + kXANYA5Qey4MtyHVgNIKiI7f7maFNf46z/tumegjIVEpiE38vMYPhNk/bszafxsb+7vvtVpbkWr9AizY + AwB12OxHOb5twJ6DE9oN6loAXTkSMQCivUHw4HTX/Qup5i4oFm9As/kUrGbsj29rAJo4QUhgbbG45CXH + uacFDEVCu0eABTpiK0ApRPHzTWB4Za32wL82m5tgg3szYBWngQV+ExbwFaSWTzN+7YQGP3ASmSpdOWHE + AVB8oK/vpUCpSzlQponwcK329R/YfPg+ALsA7AEwAqsdAxwnMGwrFBZtct37fGCIzfrIpvAyZn4kSMAH + 6huazce+UqsthwU+VzkCqZVTAzAOe4wjsHUQY/FzDVgL6IQmga4F0JUjFVsJrPXDIdGlBIDI6pErisWr + fxAE62C1fx9S4MhYwNsmo6479Ibn3fcW0SIOWIYdgC/9fR+ob2+1nvpOrbZ8lzEEm9/3YJVliNTcr8AC + fTTeGPgVpBbACR0ABboE0JUjF+v2h+ED5Dh/oACQsdf4HMe59Gxg2nar/SQBeEgtgGMOiIZSg+sKhbtX + KHVPJqAHtAX3+H4rBf5Lu4xxYIt5XNhaGc5uNJCa+2NiY+DXYcmOzf8TvhKy6wJ0ZTKiAJTu7+9/KwDO + DuPAWUSEF5vNH3692XwOwDCAHQB2w5rGXB58TAlgR6GwaIPr3ucTDUVAsl+dNH7IGt/3n/x2tfryLmMU + UsJi4LOfz1q/jBT04/Fx1ZCa/CdV/UPXAujKZMQACAvGPBsR/ToZk7gBFxaLV6HZfBlW+0sr4JgGAxtK + Db5VKNz7lk3rdQR7CCQBPt+Y+jbfX/rtavWlnVbjc/UeA58zGTK6X0Y78KXWl0WSJ4V0CaArkxEDQBei + 6Omm6/46AVDGgAAMKnXeVUrNWaF1E5YAuDTYQ9ogNKUA2ee6C5d73n3NuIKPwc/pPGn6+0S17b7/xL9l + gV+ABb5BFvg1WNCzv88pPk7zsa9/whc8TSRdAujKZEWv9/37z3CcrykSnqQxuK5YvHRFo7EPFvy9SJtj + HEyxeby+WFzymlL3tWl7zudzcI+otrPVevyb1eoLO+x1z5YJA58rGBn4bO7zJk39JtIIPx/PSQd+oEsA + XZm8mN/VeuQhYFtozDmKKLGdzy0U3o1G41m0uwENWI05JbKmWPzSdqXukuY+F/KwBeAT1Xb5/mP/XK0u + 226v9z6kzUoyl99AO/AryAJflviedOZ+J+kSQFcmKwaAcY151if6Dc4EEBH6lTp9oVJzVmXdALYCpsQN + WFUs3ndAqSVagl9svlLV3b7/yD/Was9uMaaAlIj4mg9gAX0kwD8pGnyORLoE0JWjEV3S+ummUr9BsLZ0 + ZAxAhI/29LxvVa0m3YAirK/NwcBJA+jVYvGLB4iW6PiLpL8fEGFE6599eXz8B5ss8LlTj8t2uWPxHQ18 + li4BdOVoRCMIlpLjJJMviAhkDE73vAUAHoXVur1orwmYVI58l+ctWk90N3cjckVfBKBpzPqf1mp/+50w + HEc6oKSENPYQIAt8Bv87DvgsXQLoylHJB6Joy0PAtgg4hxAXBRGhRDS4yHHOfDKK6shmA7i4hjAJUO1U + 6h5uQErmb9nxZOuXlMt/ADuUYzbSZh3AArqJrsZvk+5EoK4cjRgA2jXmWRiTWgFxPGBBsXguLOhlNoDX + EJhUEVpENKiJMgSgAURKzRsimo90Kk8xfqkOW6q7F7Y/YWe87Y6fG4Yt7OlUyXdKgx/oEkBXjl5MUevV + XBKcrBVmDM4rFC6HBbx0A5gAJnXt9RnzL/FUYkg3gIC+m4vF62DBX4IFL4N/Hyzgd8KSwDse+CxdAujK + 0Yru1XolAz+ZgkmEfqLTLldqFiwg83GASQ3MnB0E32QXgJPvbAVcUip9OP4tgjXlK7BlyHthOxP3oQv8 + jHQJoCtHLe/1/aeIXYDYCkDsBlxbKi1AuowYLyXGM/SPmADO0LpcAL4lpxMjvl8imv7Jnp7LkFb0VZF2 + 7I2gC/w26RJAV45WbD0A8GriAoh4wHmFwmXIugEyDjCp66/m+59PSu+IYIyx943BlaXSe5EaBpzuq8e3 + HOh7xwOfpUsAXZkK0UVjnk56AoxJLIBpSs29LHUD2ALIZwOOSG6Joq1kzPcBwLDFEUsv0cCvWyuAvRK5 + otk7IrJ/JNIlgK5Mheii1qsZiDIQSACuKZXehZQAZHPQZAZoGgDm4Wbzjw1QTn7TmIR8riiVrou/v5D7 + rZNqYOfbIV0C6MqUSEHrVQxAOSTEADjN8+bDgnCq3IDoq8Yc0Fr/Mwce2ZRQxqAPmP7bvb03Ip1MlG9I + 6pJALF0C6MpUiLk2CFYlWQCRDoQxOM11zz+diJcNk9mAybgBbNIHH280vgBjdqlY+zvxpozBpYXCorOI + 5qB9xaJJxx5ORemeiK5MlRgXeFZxU5DYYAzeWygMIZsN4N6AyWhkbgNoDQfBZxUAN0cCRaB4R2/vIqTL + lvUjO/SjawWgSwBdmTrRnjGrgdQk50AgAJxfLF4IC3iuCThakzwC0Po931+qtb5fan++vdjzFr1bqXNg + CaDTwp3veOmehK5MlZhSXBGo4ixAUhoMYJbrnoWUADgbUMDkNDK7ASGA5vcbjT8joOLCWgKSDBb39S1G + SgDsCpz0qxdPlXQJoCtTJlwRCIhYQGwF9BANXJKmA3ljn3wyK1Qluf77jdnbCsO/dbVOwM8EcAbRgl/2 + vMthV/PhFX3kxN93NAl0CaArUyXmqiBYLcuB88i6uqdHugH5OMBkrsVkau+nW62vamNWuMakVoDWUABu + LJVuQ2oF8HwAJp+TngBGXXdoR6GwqKHU4JF+tksAXZlK0a4xz8oaALYE4nTgWbAmvySASZcFI3UFfACN + LUFwLxOAG7sgSmtMB07/TLF4A1IrgDMSJ21AcHVPzxef6Oszj/f3m5dLpc2vFYtLN3jeVbDHxBsT64TH + 1yWArkylGA/YIkuBORBIAGY6zpmwF2YRqRsg6wEmA8QkI/C5MFwRav2AozUUb1wc5Hk3n0M0FykB8GzA + k84K2Od5Cw8Q3c3rF/JMxGHH+UXY45JzGA96brsE0JWpFFM0ZrWcCyDrcT2geK3rzkPqBkgCmOxK1Rkr + 4JUg+GsCKg5bAfHWa8zgJ0qlm5FaAZwWPOkCgptc94vJTAQxE7FsCW4w3vKuTkesdwmgK1MqvVqvAnLF + QEgrAy8sFs9GOwFIc3UykgQEv6D1ulYU/UuSiTAGpDXIGFyg1PvPSq0ATgueVMVB2wuFRVWiRYnmR7rm + wbi1hObCTkSagXQ2woSuzklx0F05acRc7ftPTdQTQABO9zx2AyQJcBzgaAiAA4Ktt6Lo29wbAB03DBuD + gjGlT5dKt8ACQ8YCeGGQE94K2Oa698hFTnkQqg9U/1e9vhTAmQDmwRLBdFgrYMK6h+5MwK5MtRgXeDYA + ru+UDRhQajaycYB8JmBSswLjz0TLFy26IOzru6UVBMMolWbz2DB4Hpy+PpwxOvq+i7WeuXdkZM1rO3c+ + 9s1t215AOgeQLYkTsltwR6Gw6E1gEa9+FLAFAGAkipa/Zcw0WEz7sOeYlzCfMM7RJYCuTLWYgjGrG0TX + cx0AEUEZAw2g1/YEuEhJQGYCJmUBjN9yy6UjM2b8341i8RcDovnKGDgAdPybId83BoWZMzHPmHedOWvW + u9594YW/+infHw2q1edbw8P/8MsvvPBzZNctkPNGjrtscZx7OPCXLH6iFEIifLtcfhx2HqJCumQZL4DS + KSsLoEsAXZl6sa3BKsWyvPLIGHzA885eGgQVpASQjwMc1gKiu2677XOVYvG/7Jo27TxtDCKtoXkWgZhJ + IEuSjTF2I4Kx7sGMwrRpHyv193/sZ6ed9jqGh79w83PPPQAkylWuAHTciGDUdYdeVmoRz0DkacgBEfaF + 4fMvaG1gXRsmrnxgs+O+dwmgK1MvUfQkuW42BmAHdwIAepXiSjzu15eZgIP64bVarVD+rd/6HxWl7ip7 + 3hytNUwQQDP4geSWSSD5QkEKOh5fbuLnIgDkupfSaaf9609uvvlHP1+79k/+etu23bCalCcIMTG97USw + 3vPukSm/UCyB9vNabRnSgGaA1JWR+91xn7tBwK5MtZgbw3ALkLU75bSg0113DizY2Q2QLsCEBLD7Yx/7 + g12/+Zvby677F5pojvZ96CCwWxjCRBFMGAJhCASB3cIQFAQg8djE9/nzURhChyGiIEAYhkBPzy8vWrDg + kc+fe+7VyLYSH5fCobpSg2Wixfmof0iEca3X/TSKxpFd+YgXP+ERaGzJtEnXAujKlMtrxeIN68TjTEEQ + EVa3Wlthrz3e8hN7MoHA0Q9/+KaRmTO/UlbqMqM1dBAkcwA1m/Rig5gRmEhcFgz+4piMNFKLQapIct35 + l1100QP/3fc/8Tc7d76GdK6gXBz0bbEE1hcKdwVEg4n5z6shEWFZtfozpKsfhUgXQJEEMOH+dgmgK1Mu + e5T6s8wTHAgE0NK6tTwMR2A1qYPU9Gf/P2OVbr3llq/unTbtd6E1dBQlIGdfPwGv1qlvnyMBfpyQUAx8 + ADZNSGSJBHa9AZMGL3uuvfDCr36gUvntpeUyk1Yt/iSvHnTMSeCAUkuiXOFPRIQGcODffX8PrO8PWKDX + Yachy+nHXQugK2+PbC4UFr1BdJN8TsYBNofhW7mPdOwfGlu06JJ9s2Z9twZcjjBMAK6BBNQMbA0kpGBy + wI8EGZhcbMAga50kC44gHTZKwFmfOP/8zy5dufLPkXUBGkgDbseMBN4qFu/cQjQkgc+xgDfr9ceQdjZG + sNqfwc8WgI+DBFW7BNCVKZU9St2Zn9kPIAHZ443GGmQBI6PrBgB23377B3YQPYgo6suDPWPuI43qswYH + kAQEmSwkMfB9JiX5w0wwrNZ1HLic3tv7oY9On/7Qo+PjrwEZT8IgtQSOiex3nKz2R7IW4vDfNxqvw5b9 + Alntz+sd8krME5JUlwC6MmUy4rpDL8fLdhuyytzE0XYiwkgUbVurdRXpar0RUgBFAPQbN930f+015guk + tTXPBfATTa51gj5JBFpskihYo7MFIAkhiRXw/gJJXIBRQ8bgg2efveTR8fG/km/JbVNuBezxvIWr47Lf + UPj/mgg7ff8lpL6/Rlr0wwueHlL7A10C6MoUyoa4TDVBiAAVjMEzrdYyWPOZy3Z92Au3BSB84brrfqfe + 3//nKgyBKEq1tNT+QEdwS+Dzc0AK9onuS3Iw8b4bYxJTm98/p1S68rr+/kueq1aZtDgYmK8VmDLZ6rp3 + SeBz4K8F1L9Trb4Im53gZdDqSJc8ryHr+0+4X10C6MqUyG7PW/harP2ZBAxSS6BizJ6fBcEeWK0VwoKH + V+tpPvae93ya+vv/1Pg+dByEk9F6aQFI8CbAR3scgAOF+QxBJo6AbJUPWyzSHaD4u949ffp7n6tWdyFL + XFxG3DHINlkZdd2hl5Rawv6+XAh1p+8v3WkMweL3UNr/oKTUJYCuTIlscpwvyiCaXLobAFb7/grYIJpB + dsmu+lfnz39P38DAn+ogSDr4khRebO4DQtMDWY1/OMCPP4+c+6DFbRIz4EBbfF/DWiLn9PZeCeDnYt/Z + z2awTVksYKPn3RVK4APJ7eO12mrYugRCSqQy+Cf3qUsAXTm2st3zFq0lWiQvVGkF1I0Z+3artQ628457 + 9+sAqjdOm+ZcMn/+XyMME6AZY2DiFl5AmOiwoMz7+5rN9/hz0k3IBxGBNO+fcQPsDyVEQPH+RyJW0KPU + 7DNdd87OMORgWxkp4KasNqCu1OBzSi3hwB9nADQRhsPw+Ve0bsIWKBlktX8+8n/IfekSQFeOWrY5zj2s + 7WWxCoPpZd9/DrZSDUg1Vg1A9Q8vueQeaN2njZ3jF8Vaug38RFYja51YAPkYQKdiIFkDkLEGkA0m5hcO + jGDdFxOTGstHBwev/8fh4QOwAOxHSgKcijtqAlhXKNwVAoMS/EyuD1YqP0fa5MNVf6z9qzhCMuoSQFeO + SqT25x51af7H2n89rO8v/dXq54eGfqGk1DUmCADEuffIwi2T4kNq8ksLwKA9BoAcccgMgg4CmDBMQS9i + AFqAXXseyHVt9iJ+L+LXLi4Wr/2jgYHT32y17r+/1RqDrcGXQTeZ1jxiqSs1+Lzj3B1KzQ9LrAfC8LkV + WreQNv20kAb/qjiMwp+8dAmgK0clWx3ni3lNJTXW8lT75+vUy1dMn/47JgytXx4DlWKQc/uw9PsjSQiw + +f68ua/jGv+o1bKVg1EEEwTc+QcgDU7yLROADLb5SiF0HESuCxQKQLEI1/MQEmHAceZf39t717uLxetf + qtX+5sdRxATAxgJbAkdMBOuKxbsCof0lCdxvtT+n/vKFP6z9D9v8B7oE0JWjkHWFwp1biRbKAhVp/leB + sW83m+uR+v6JxvrsOefM9xxnyMR1/UnkX2tQbO7ntb8WZKCNgY4iC/RWC2GrlQD9kFc+pb08CRnEz8n9 + j4xB4PsIgwBRvQ6lFBzHji4kY9Cv1FUf6e//zk1R9E9P1Gpfe9SY7UgDc4dMweWlrtTgs0rdLZt9IoB9 + /+dWWN9/evx2H6nvf1hlv52kSwBdmbTsUepenQN/cvECeKXZ7KT9KwDK7ykWP51of9jx3ZnIPVI/PxLg + 91stRI0GIt9H5PsAcmWERyBGbDJ9qWNLQMv7cb9AFIZwiKCIEBo7/bjXcX5r8cDAJ/5DEHz+9+r1f0W2 + aUiGFg4qbxWLdwVEg2FO+wdA7YFKRTb9RPJc4ghTf1K6BNCVSUms/YfkxSrN1Row9p1mcwPsRcvmag2x + yVpy3fNkjb+Jy3d5ihBr+UhrhI0G/EYDURAgkmk8sT+He8XLz7Lm503nj0WppFSRyYFjAsm6B3GcQBnT + X3Ddv7yvv39JLQj+539rtZbGx8xa+aBuwYjrDr3gOHcHgkSDeD92+f7PllvffyLtn89EHLZ0CeAkl7pS + g7scZ3GFaFGLaKhJdIUDrA6JqBd4aiCKHrjY91cjqyiPKlAFpNpflqlypVpIhJWNxvOwef+89h8HUHG0 + Pl/H0X5jDEwU2dSb1tBaI2o0ELRaCJrNJAiWKdgR+3JEByKqEzPaH6m2l5ZMYExCagZxetCYpLw5swAK + AFLqXQOFwnf+zfN+/lajcc/no2gd2guG2s7/mmLxiwHRYECUDPqM7Idq/1Kt8sCPTtq/gsMs++14Oo70 + A105MWTMcYa2KnVvlej2CBiUc+Lz912ihyvN5uc+EYabkZqksk7niDC0uVC4faPj3O8rhRaR3ZSCTwSf + CFVg7A9HR/8VaeS/AmAYwG4AO+4eHPRunjXrMdLaLt/F0f9m0wbwms1Mak6mFI8G/BzNz5v2+Sk7vlJ2 + A+DHxMYWwG6tt/cAhXlEp3nG2PHGxqBgDLx4K5h0dSKj9b/+uNH4wneM2Yu0N1/66eb1np7F61z3R6EA + P29vNhr/+P/W6xthtb8DC/YDAHYB2AlgL4BRWCuApwEdtkx2MYauHCdpKjX4G677ua1K/ahFtDAESrIC + j0dGS1O2RXQRPO8/fsiYZT/WehSHGBR5KPmk5329RTSUXKjxYMpAKUREeKnZXPpaGFZgFaMPSwAjAPYD + OPBGobD9VwqFu0lrwPehKxWE5TJMq5Wk6eRUTgZfXo7YhCFqM/8TElAqQwBhTGZB/FpEBBDhuXr9pSfK + 5TVbfX/9tELBm0k0SwHJvAM5AQkAlFJXLPC8T9/huoP9Ybh2tT0fyXlfXywufMPzfhQSlSQBhESoGvP6 + X5TLj8CCvwDLh1VYAtgfn9MybADwiMEPdAngpJJdrrtoreM8WiVaLFW41PiZuXFZMii6hcLiuu8/uNF+ + LD8O7rAunjHHGdrmOF+SWlNOp60DY1+sVJ6ENf817MU5DnuxDgMYabVa45/0vP8RVSrQ1WoCet4JI4Da + 1ltwJDubOziZ+suAXxJATgMH4nUQYdn4+IqWMWFZ6+arzebm7b7/xoxCwZuh1JzMIigkuJWoSEpde6Hn + 3flxzzvnKmO2/lzryt8rNb3a2/vDllJD/NsyiPp4ufzV9Vo7SJt+GgDGYAlgGFbzV5CmII+YALoxgJNE + 1hQKX9oA3JVoerFlqtnYL0fqm/OFboim/crAwDceGx//DOyF4yENIAGHcRHtct3bjfze3H6sbDaXxd8L + pFV/ie8PTldVKmtgzOXceMMNNwyc5Lio3UiZDPg7+f4y4i9Jk2fuB3EQMFIKhgg7g2D7uA3G8cBNf2MU + jW8cG3vwYqWWfqS///r5jnO5VgpRfEyGbPbAAUBE0whYMr+3d8m3jXkRRP01oktl8JFTf7t9/98fDsMy + 7Ao/CvYvrcNqfHkuJ+X7s3QJ4ASXMccZest1fzQCLOSccDKwAnGhDKUtuGwVsKMZIufsK7XwM4XCL33D + 959BdsUYySMTYmw8tj6SKjwRIKsbM/bdRkNW/WUi/0jTVUHJmKebwOUM74mikkddVwsc1PTvBL5AWDZc + g08Advj+jvhrePZe0hD0ptb73yyXt1yu1JyP9ffffLbjLJRhf84gJJWFSl3LBGQgSqjtF2/+vC36mQ1r + +mtkiXQcaeHPEdcbSOkSwAksmwuFxauVui8CBjkQJf9tHryR1MojW4/PSWi+iPniP7ev7z/B99cjjQV0 + Mig6SgNYlNGi8W/DGKxstZ5Dek1NrP2BsD+Kvuw7zn9LWnzFj7LmTDoCj0LyAcO89pfgT3zwGPz8mokJ + YFOlsh0pvzbi4xqDJYEQgFqj9eiacnnHlUrNu7Wv78NnO86VTJJcWsySqTWIvzgkqn3lwIEvw/r9pfh0 + tGABPxZv+cj/pE9UlwBOUHm1WLx3k1L3MKBljT0XnMsQPg+z1IIIEgIwBlopq8mIUCS66D1KvetlWx7L + 5qxcCKMjCezxvIWvi9+Wb6obM/adZnMdrL96MO3vA9DXRdHWnzjOdwLgN/LANLBmiQGAvD+Nw187jE3/ + TtpfTtdh/1/2M0j3iQBsC4JN41oz4LibsQzri5fj41WwjTrTVmpdXVmp7LxSqZ/e1tf34bmue7EHlKJ4 + nwD7v0oyCoyp/2xs7EvbjCnBpv3c+D+pISWbTtp/0tIlgBNM6koNri4UfrQ312DD5ml+/Ixc4CJT146U + MKLYD2VzUwG4uq/vAy9XKsOIF9QU24Qz7nxgOmv9ZFGNWFNvDsM1ODztz/xELwTBH17lujcCOEsSGvfk + A5PPU+fB31bll9P8fI6TqD9/JiaArdXqxngXeRoQE8AobICzEb9eip+fBmBgpda1lZXKzjOBGbeUSldc + VCq9v0+p02WAky25N+r1hx4LQ2728ZDm/Pl3OOgnff+jMpO6BHACyXbPW/Si6/6Iy0GlJgpyoJYz7WRk + XLaz5jMEDDANYMDzzocdKJmfI88FK20kEBANJg8E+AnAGY4zBOC1+Od54MdEE2oNAHOvMWNfi6LfnKfU + vxPRNHksBEAGCI94xdC85s+diyhHAslim+z3x+8nAMNhuHddvb4PKQGw/88BubH4cQQLXB7MWUFMBDuB + 2j80m6NoNl9YqNTc95VKl84pFM517CpJeKlaffJh398F22Ism33GkZLMWPy9k47656VLACeIrC6V7l2r + 1D1y5ZdAaCcZpOLg37DW27dH0Z7tUTRe1To0POUawK8Vi78kA3UyWAgiDBCdDWtmDiCtKmOgduwnd40Z + kz6/rIQrpP5qhLTpJ08s8qI1AMLf1Xob88+HAAAgAElEQVTVN4H/NeA4fwnxAuIvIwFkGTCciBDazH6k + RJgHPqf5QiCb8ovfz6b62nJ5DbLaX7o3PIGX4wAushODJBFMA9C/Suv6qnp9D+p1uSaiXBpNxhhGYNN+ + oxBBVHQJ4NSQvZ63cK3r3reXaGEe+JIAWCvVjRl90/eXP9hobNyfzoVjbCTBvF8rFpPfYG3Kb2CtuKhY + vPDJVqsGq3X6YS+4AuwF3oaxkH+HS2Hjzj0FYIZdj54JgEFSR1oPn79o2VAJlmj93T8DRi9R6m/IklJG + OCiYzPyXz4vHHcFP7Tl/rl/gAp98Dj4x/Y3BgTDcuzbV/oE4LgY+r77DBMfDTuU5kETQD0sEfbDxkh5k + F0dF/NkqLOiHYQlgPP4euXrxUUuXAI6jrC6V7n1VqbtCYFBegIEAP1+wTWMaa5vNJ/6+Xn8d6UXDK+my + yc7BvEjBXiUOkPTZZ0ZfG4Mzi8X5aLXWwl6IvbBanBfqDCba78yCn6IW/mKl+t/UehjtQEiaYYY/9rFL + G8CCplIXtoBzA98v7x0ff/2Zfft2PbZ58903OM6f9BPN5/3M/rCYMhyLyQUJO4E/M1QzBr00+dkKkP0G + B9H+7NrIARxyEU7OqshzIEmjF5YE+pAlgSKyQz4lAXCm4YjbfQ8lXQI4DvJWsbhkt1L37BYrvrRpftEQ + sl/rV78xNvbwHmM8pE0hrJHkhNqk1txBugSWI7R/kjkgQtFxBmEB3xNvkgDalulOovJAxv/nbR7RwJu2 + RJV/KgKgf3bFFR+ftWDBYioUrtzuOHPAC3lGEXShgMGeHnx07lz4F1xwYO/IyIbhtWvHZ7dalye/iSyw + M8/nwA+IysE8+AWhdjL9k6afmNh2+P6mDtpfmv6devCT3cDBiYDPORMvEwDHUGrIFv1M6JodjXQJ4G2U + N4vFJfuVunOLGKApy2jzFoAP1F+u1X74vWZzOyzwubeeLygeq11HunhlC0Dgxr56iHT5q0hobU2EHqWm + wZqeBaQXYX6l3uRi642iVXDtJZNph43vn6vULETRRn7/N2+66VMXzJ9/R9HzZuoosrP+fR+SAIzWyX1l + zKzTBwZmzb3qKozt318e2by5MT2KTmNQAqL2IP6NZOeE6Q+0R/sz+X6R5+e4ShS7GFDKTiUi8l8eHl6O + VPtzXIOHgR5q8Y2JiKCFlEiKSJdHLyA22HK/x27UlPn9UroEcIxlS6GwaL9Si8eI7txCNBgXe7TV6yc1 + 9TFoa8CO742Ofn+N1iGsz8j/VQvpWK0Ksj3hySAKD9bMVwBCraGVgivGacEYDBDNir+3gOzFyASQkXla + jz8OjJMx04koIRa2AErGFAGo/3rRRZd9/JprPtff0zMNQYDI96G0BsULfhieA8BWQHwLrWHCENoYTJs2 + baBwySWl5du2rT5vfHyBBxRl/KJjAFBo/o7tvSLXz+TLBVacTuVjWVWprBjL5v1lWpMJ4HAq8SYiAu7s + Y8LlICDHLZnkZY3GlIIfOEEJYLvnLfKJBqvAQgOgRrQojhhRBFwepeuhtZ2RCc8QERxgtbJ/YJsUgNUF + Y8YyH4m/rmTMatf6YQAAt8PPVIhuiv85ahEN+cCQT3Tjm2hPP3WqOw+VSvzQ4Sh67Z+sye/CmohsjrNv + KEtCuSecNYUPIPJEURCfF43Ud1f2mFnrsBXAFoBcrTej3TxjVkfAjRSTi4K1AgyA+cC8r1x33UcXXnzx + RYgihK0WlNZQQYAoikBRBBWDHLFFwAQAre0sgNgq0FEER+vC5WeccfGuVqsy4PtF2RTEx9QpM9CJAPKm + fzxpJ+MWEQDSGnvCcPvK8fFNyKb9mHClSS4HgR5K+D2yHZvjCgrZlZFlZeZhTxSajBx3Atjrugv3KbW4 + TrSwCVwRAkNrO/zRE91OmAoC2irIQuCK/Pv5HQ1jbmyrOMs9zn9mot+VmqoT+Dt16/H9Ta3WE18rl1+C + 9Q9lYQ1Pf+W88CiyRTZyIGToGZNEpJKGlLgphesIQIT3F4tnPd9qVZGSAGujNgsAAFxj1hDRjawpFQDH + GFCxiKtvvnmeNzgI7ftArPF1rPFJazgM9g7gl8A3UYRIa0Rag6KoMHfWrFm1vXsTpElGkn6KJAAmAY7q + 501+VtsRxzKsgkDdmNozw8PLkDX9ZSWeNP8n65PLDKXsIKYO7wGOEfiB40QA6wuFJaNKLW4AN70ODGZ6 + vyFMOc45x3KwM3LEZygPbqIJgd3x46JOPeOfCvKSWqhtYi4/RkoOq+r1B79Xq62HNfk5kC8vQC4IGcHE + 4NcAtAeMK2OmE5DUADiwYFWURrtNqnlcWBJgC4Cfl3gzJWBVXcQSFAAqFjHrQx+CMzAAHQQZgFNMAIgi + RFEEJQggit0AHQM/iqcBhWFoR4FpjUBrC9aBAbQqlYxFA6QEoMR/KsmXYy1BDvxJg5TWQGwRBVr7z4yP + PzVmTL7kl4mXS3HlFOCjBecxB/nB5G0jgHHHGdrieXeXgTt3EA3KTrLMRu3lm1ISEhCvHQkZSG3R6bWJ + JF98QuJiS78gbfrIlORSe9WZLDjxgebDo6Pff9G2f3IenCvByrAXHheEyIowGYXOmIolYHUTuBFAov1d + YxDE97k46DTPm41WiwtR5CbnWySijFktwe/OmIGZH/oQjOPABAF0GALxsM82IohJgH191vhRTAJRTAIh + b1GEABa8UW8vAt+H7/uZwiB2QQhiuIU8/+I/aCulZs0fp0lfajZXbG61RpH66ez3j8GSL5/3YxaUe7vl + mBNAQ6nBtYXCl1YR3ZkpU1Uq4+BEOTLoRABsL+WDQJ3uT2Tqy/umw2v8+GCkkrHTcpaEJDGp/WV9vpxB + X9Z63/0jI4+ssyOfS/FPsclfRgr8YaSaX0agOwahHGPgxPvhxhkAJoEodg8MEQrW71dIYwEcjJJTg5Lv + vjKKVj/uuuMETC/MmIHBD3wAAOyE3hjoiM15Br+JXQHkn4sJQMfmfhjfBlGEMJ7Fx2PGIgAYHIQ/OmpJ + ROycA0sCkrGSNCDSa0s63waAirMJBOC5VmvZ8kplE1LfnGfuM/hHkU7fkWsAnNRyzAngtWLxRyKIl/rD + QIaZ5fP8XvbjWCbS/BORwcGkE+iT7yCxIkxs6h8suChjDhKJbfP54ls2Tze3Wqu/OTb2IiwAuflDmvw8 + RYc1v+wEkxqobfccWOAzEXFbGWs71pYDjsPuBpOAKx53Moq0Czyjpk+/dfpNN9nv932r4a3PbiP6QvvL + rY0AcuCPtLaBUTmWKz7YgAj+tGl+WC4XeMd4p2UUTV4nMpLGG2DBDwAwBi8HwYqXLfhl0I/NflmKy8G/ + o+rBP5HkmBPANGPur8Z57yT0KZg5zD1mDZmxBOLvkr52p1tM8FjKhGZ+hxhA3uy3T6aPkr51pBonuS+O + g1tA2SKoG1N5pVx+4fFGYwfSgQ9caMJaJw9+uRClHDPdURRgElAYu9KOw2a7CBBOs1VpEvzSBegUCDSl + 3t7nCjfeeKs2Jgn4JdqdU30c5Ov0PAM/tgwirRHx9F1hMcliHR/2+tin1PhupcoXGXM+/wdufIxssigg + s/R3YpXFxy/duKeazWUv1moMfvkfjMfnnsFfxhT14J9IcswJYDAIHthZKn0pM0IayKRjkucFEWSCaOL7 + ZKQ9/9xEj6VMRAD58GsnMrBv7EwUQEoAMg4gXRlDhE2t1huPjo+vPmBMgGx6T/qbEvx50/OwtI8MjiX3 + Y5AoY+wfbwwGsgQgm1LkR5Pf2r9o0ZxdAwOfiYwBeK09kcLjIh8t8/yxzx9Vq4iaTeggSGb8J/+x60Ir + BVMsQhcKaR+EUml9MxFOK5XmfGPz5p98Ytas/jOA03hWlhMD3BE7KwuGOGjLfRGB1v4Tvr9sZb2+A50J + mN2uA0hLcZs4hcAPvA0EcHoUbX0tDO8YUerqClAMHeeGBpHXNMZrAZ4POH2Oc36YIwip/WVkHWgH3EFT + gbEcToQ/854JptHkYwFGEIIBEBjjjxkzYsTnR6No1DfGX16pbNykdRXpoXFlGEeaJfg52Jfv/z4s01PJ + Wn0iawUg9pVFDr+fqB8io4d2FyA5LaOLFl2yva/vQQ2cq+PcPi/uwYDXWkPHJBD5PvzxcQSVCsJqNdk3 + +Z8mcZIgsBZhs2krIT0PUU8PdE8PQs/LxE+Gpk+f9cjo6NIbBwevvkipC3gJMSKb7kzKkyktV5bW3G6t + 9z5WrS7bGYZVZM1+WX+/H+ngzSkZv3UiytuSBfiFVuvHAJbCjjn6LoDTAMyBHXg4gLS5hbWPjELTLKLi + As+babiqdYLfmcy/ciSpPwBY5vt7D/JzExkjJrfJQFNe848gm+PPt38e1mEWbRbgJkA07yC1AiIOEhqD + K113zkqbgZBuQGZ0+N4PfOCGrf39jxqt+7TvZ/x6LQggiiKE1Spa+/ejVS5nDlqelCTOg/ZAcEiEIIrg + 1+toNhoIi0VQqQSnpweGCCXXLVS0bj48MvLk/mnTtr+vUHh/CSgmtQlMAtICAFAFai/7/pqn63U2+Ttq + /gVEtVsKhbPf5Tg392i9YiawdwYQuEGw8tooGp3gPz4p5XjUAeQLHpiBAXstZFK7AOiAMdXnfP9A7nP5 + 7zke0skwyd/X4pY1f76zjHP8HHHOL/d0xGanA4zJnn3AakTSGorINgjFmvNspWavBLYgSwCJFbD7xhuv + 39nT8yiCoE9qeeTA75fLaO7Zg7Bez4y7aiMAytVKIFstyZZBYhVy+q9eR7G/H07KG8FLlcrqjUqtuaa/ + /xcudJzLZgBzlbACAGBbFG3fEIY7ljYaEviybbkKYPzDrtt/U6n06zOJrikY0+/CWkxsgjlK4UcAPGCN + a8x4yZinS8CWojFbrmy1nhL/8UThqRNO3k4CkBc+d0W5sH8Et7ZKszMhgNwtxHs6vfZ2SCfNfrDX8rVO + 3MHHzSX5sl65uOSkTM6iMau5Y4/jFqz9ndhU5i89nWg20mIgGQtQr7/vfdfv7O19EEHQl6T2tE4Kfvh+ + c88etEZGsjGPg5wgGalP3AG0Z4P4+wiA0RrNchlBo8EegQ+gcUDr+qPl8uOPAk8A8K4rFi/SQLGmtV4T + BOPIxjLyBFy7tVic875C4Y5B4GIulpL7KdPPjiXNy30iNIlu4IvwoZ4eKGCbA2wrGvN0AdhSiqJVVwXB + KpzAxPB2EQAzNrc5csqrDpv75vHUhMMjgbx/erwIQOdu89d6Hvh88Unfn6fJyMKeI/L3O0mvMZu5YSfZ + 4ipAGQMgAOfb/nsGflIN+KMrrnhfub//+xQEfZzmQ+z3c2Vf1Gigvm0boiDoCPpOJ4RvJ4rvmNzzsiJU + GYN9zeYIUiLlhUda8du952xpcx9S15LdGSPOf+MKxyne1tv7K3OIFiYXUPxb/KfJfSJkTVTKxRsIOIeA + c5pE1xMAUgoPeh4cY14tAGuKxqzu1XrV1b7/5CFO09smbwcByIAXT5ph8Mv2U3mtTgTwid5zPAggr90P + puwkEbD/z+eDN+7nZ+12VBfFBWG45qeFwjiA6fnhHVwJiHhHphnTf5XjnLYiisYQE8C/XHHFHTNmzvyj + MAx7ldYJ6JNbrRHs34/m/v0ZlpLFWxP5RBPKBGleIAVb3Zha3KUng3dcnx/Cgr0H6cAN7rNnAgjOIlJ3 + 9Pa+f77rftAFemW1E6cL+c/iAiMOJipBRJJgwWXRYn9Zeymiy3zgshrRp0aVwoOum5CCZ8yaHq1XXWtJ + 4WDX0jGRt8sCkH4+k0Ed2brzPLiBzvU6nd7X6b3HSiYK7HX6wzq9zueCy015ayvnPVrxgGci4FY2/1Xu + VscXtwGwSKkrVthefu9/X3LJx8+cNes3uXHHRJFt5Y2beqA1mjt3IqxUDqn1Ox3IhAcnNH2SRYktFnZn + 9kcRB2H5PMrpOc346wtICYAtTAKgP1koXPDeUum/uMCcfH0JYP8AiuMRDGyh4VOtL4gA8ePkPtLyZEkE + 8jERXdYCLiOiT40phQdcFw7watGYZ4rGrI7C8KkP2MVc28phJjp9k5G30wXgP4xvVW4D2jV9XuTzB4sR + HEvJX9sTmf/o8HzeHZAVqlP9B5teYx5sEd0qn5Qlf8kBGIOLiBZ8SKnzrjrvvF+4ZM6c26I40o+4Y0+F + IVTs77e2b4cWNfnJQVF770ab0KH/JiPMcCAb2d/Wam0XP5nv1a8i7bUvQWSXLiOa9tv9/Z8tEl3P+8lA + R7zvEOckSSHGz0s3ih/z60rcz4C8w6aE1dC2tDhwWYvoMjIGqlDA/YXCeBF41jNmTTGKnrrB95eKY58S + K+F4RNE7AbiTpj/Y5zu5Bm+nTBjXOsj78+891kEh+meiuWd63trQmOlsXiQMTOkqQxwQLJ59tj/jzDML + FEVwGPRRZDMHYQjU6wiGh6FbLQDpVZgwmCh+6uTX50d182dki7QfLzPeIlsGzJkAECE0xv/iyMgPYbU+ + L8qxE8B2AHuQxgKAtL3Z+1Kp9OFpnveXhmhasrqSqMxMTP+DnUx0AL+4n1zMMi7Q4X4mwCVfj19Djjzy + vnBsJTzbE0VP7Q6CJz9pV3uetJVwPAhgKuRE2+/jEsA5hBAA73HP+2YA/Lr0MTgSxmaH6utD33nnwenp + sQ09DPwogsudfI0Ggj17rAuArObnAh2pmoDOJdwZAhAkEOYJAEiqAJk8VgXBmscqldVI5+XvB7ADwDZY + AhhFukCH+6dKzbykt/drIdEtstpUrvrDPScyz1oFdj8+Pv7oC2E4Ppuo/xLPO22m4wwMOM7ALNed5REV + 5ip1Bp9kCGJgkpBgnpAg4vd1IgdpRSSxBPl6/JwDvFow5tlSFD293/eXHikhnGhA6srUivstpRbMdpxX + eaZUKKPcrovi6aejOG+e7crjJp4whCMm+KDRQLhvn633jyUT2cxpfo7uA+1XoGzwklo4IQDekE7tiWcb + +v80Nnb/mDE8B3EUwF5Y7b89vj8WvxY93du7eJdS/6SBwU7j12RDGpNXC2iub7We+Xal8hrSwjSOD0pA + AQBdpNTAeYXCnNNdd9ZM153dR9Q/XalZE5HCRATRyWI4pKWAHBnEroULPNcbRT92g+Cpm31/JbLuZpul + 2iWAU1scAKVHXfd/auC/yyijN306es49F8Z1kyk8XNdPce0+RRF0pQI9Pp5ofhYJ9E7gl1bAROY/vy/j + ApBtAmohnuYTBwCfC4IVT9VqbyJNJR8AsBsW/Dtg3YHxFx2nZ3dPzz82gcWyuCjMjV1nN4CrD/drvfYn + o6NPv2UzDAx8mbZlI4pPhAynyBFqzk2FwlnzPG/2LNedPajUrIQUcGgySF5DzjKQ5BBndBDfcmYiTwgO + sL03ih5Wrda3brVkIJeVjPgzXTl1hQAUf49o3kcd58cALo5cF8V581CYOzczlFOO5OIpPrpaRTQ+3vEi + 6VTsk38uTwZ54Odn93HLbwAk/r82BgeA0b8fH38E6ZCUcaT+/w5YIjjwk97eD44q9Q0DDHL3ZdJ1SmL6 + MlJ3oG7M2Cu12tJHbGcm16Owl8Sl2nLxD0kA+Q7KfCl1UlR1tevOOcfz5sx23TmDrjtrjnQhkCMGZAEP + dCAEdLAAYjLIWwsKQEHr53t8/+u3NhoPxMdWl7/flVNTYqsQvV8met8FM2b8sGf+/H7jukl0PynnlbX9 + UYSoUkFUrSYXkuHbDsAHDg7+PPD5vclshPg5bv1llRsD1P9Wvf7IviCoIE0fj8Ca/DsB7Pwj1/UW9PT8 + FYDreTQY/07HgaDx4p9bg+Cl/zM+vny/BR9nxOTin3JlY16VJxkpgLSGhd0FTzyXv82ThHO16849x/Pm + DDjOwFzPm9cHTOtVqj8P+uS+fF48lpZDQg6ULfiKZzeWPzU6ehksme2VB92VU1MYi8G7L7tssS4W+3UU + wfDQzhjsPMWHc/5RtYqo0ciY7fxlnVIXsmU7ATaywM+AHin45eCXjF8eP98Cglt6e9/vEJlxrfdD60of + UC8asy+Iolcu9rxfmqbUpwJjBjKzDtkCoLTNnMFfN2bs2XL5Jz/3/WGkWp8rC7k3gBfl4BJtnr3IBCBL + piX4k+wD0nn/+eddAO7yMBxfbnP9icUwm6jnUs+bO8/zZvcrNTDLdWcNKDUrnuDcMU/eKZ2WdH4iNVXK + vv/vsEu41RETQNcCOMVl3xVXzNmh1HcbwC/yrD0Ic9/wIh1aQxuD1tiYrfPPSad8JQNNEoNs5tE5Tdy2 + Oi+QyQSww51kKShdgpxnGGRsbmPaZpgThDVC2RkTIRG2BMFL/5/V+oR0jKCc/isHgPIQUNmfwVxHyJr5 + vGtS80sSyG/y9U6WgnQjFAC1qFA4q4eoeIbnzfKUKs5wnFkKwCyl5vEOdWoBdwDAmPpfjYzcvQnYB0to + S4GuBXBKS/3KK2evM+bpwJgFRkT4eYAHa3wAiFot+JWK7eyLP98pd3SwgoY8+A82Ej0//Um6DgkpGAOj + VKKeo/ji5ggWF97IeQDsroDSuRIRESrG7Hm+XH7y8azWzw//5AGs3JnJI9g6rcuXn7nSiQykdcCuQt5C + KE7wvPycA8B90vcrAJx4iGvbzIa5gHe5580mQCu7RQqIpivlusaEm+zwFxN/P4AuAZzSsjUMvxoCC+Qs + Popn8ZkY6MYYhJUKwkYj48cDnQlAPi+bZtry+0Lrty2CIjVz7vNAXJUXpyspfg8HtyLKTmRiwsn7xZKI + NrRaz/xDubwCKdiA7Eq/DHwJfjn/X05elqelLaWPLBnIQOFEpJB3FfJWQp4MpKWQ+a19gHrcdj9mTgNS + ousR9wG8gwmgrtTgXsdZFBANlozZck4QPNXhbSdigc9hyZaLL/7jkSj6VbkGH4/rAhEQhogaDYTNpp3P + T2mxTqfbvLS9T3xeavL8wqd+HIDjIB+/D7AaH7CanEuGuelGTvpJOqViktDINYXExDSm9ZYHR0Yee0Nr + vvg5tZefxSAn/7LJL+cxHM4koLx7nrcQGKyd2q7zcYS8C5GPL+TXcMhnHaR1wH8L9+BkSOwdFQOoKzW4 + 03UXjxEtrhLdnq/ucIFneoEHKQyfviYMV4mX8/GvE1rKCxZcuMmY5WEUDURRhDCK7CjwMETUbCJoNqHD + MFMdIpfGPtiBZoAvLID8Utyy6CagOL8fV/YFQKYaj+fzc6Yhr83Z2ZY+Lc/zl2OLuH6/rPWWFZXKsp/7 + /j6kgJKpPfb1pcbnQSwTaf3J/vf5Q8q7DXn3oVM6UWr9TpZAfn1BOdBF9trIWMf/4Z075WXEcYa2Oc7d + Y0R3RkSDmVQV2gNZsYy7wCOFKHrog77/ALJNO8ekM2uq5K3zzvtezZhP8EIbkTEI6nWE1SrkgizS/JaD + WIHDswA65fMTPz8GfhCX9iYkACCIK/E0VyXmTHgZyc5Uw8WgT2YaEGW67faE4Wtra7U3lrZae5Bd3kw2 + DXGEP+/rs9afknkMh5COh4jOxJC3GPIkkX++U3GSzObyLIpn5Y6ckrK+UFhygOhOXpcgQa/QdklZKpBo + NCA+MbHZCaDsAY94Wj/04VaLyeBYdfEdlYyfffb5G5TaEEaRBbvW8MtlRM1mtvAG7U08eV/8YAeUGesl + Unuassudt5RCK9b8TAShNP2J8FyzuWzN+PimC3t75/Yo5c3yvBk9RIWZSs1QAIpEhUGlZrIl0DCm2tS6 + oo1plYNg+EAQDP+s0dgc71re7JXTl/IRfh66KrX+lMxjmIQcjguRJ4hOZOFM8FkWrgpfL3/0lJExxxna + 4rp3jxLdGQGD0rztuOYAp5rQ/m/zGQQyNFp2jHnU0/qhj1oykBW2x50MNs6b9wcHiL4QAXaVnbExu2qP + TMmJne0UiZ8MAeTXQPRjf7/F2l+ppL6fawAMEZ5vNpetSlfi5V2Sa3h08gwkyJPYIdK/lS/yFtpX9pXb + lE5hOkaST/dLcHeyHjq9xt+TJGxgS6lPHQLY4XmLdil1d5Xodr6o5a1cmUcDyYKZ8t/m22TVGIgzKsow + JRm4xjwaheHf/XIQcK31cSODLY6zeP+sWV/2C4VzTBTBHx21I7rjXHqeADoRIu/wQcEPZPz/fNFNEG9N + Yf6zFaABaKUAIjzbbC5bWS4z+LkA0Ee65Blr4k6aEMhe1Fp8D2v9BlLwc5pPLqfeaXm1Ewn8B5ND1QR1 + egykx9jKv3BSyrpCYck+pe5qEi2UF3Wy0pBMN/GFimy/ZPKPcxQ6131FItiUn6cnnt/uGvO9A0HwrSV2 + so7suD1mWmWf4yzcRXR3Dbg9BAbV4CBQLCIYHbWaX/xwYqrjKLU/MCEBcMQ/sQAAtIRLwK7W076/7JUU + /Ax8BqwMwkkCyK8CxiLBzz5uA+nMRS7prSEFfsdFVU8xORi+zaHecMLKmOMMbXPdJQeI7gqJBmXKKQE+ + 0uqvxK5kUxXZXIgkgIQ6xWx5JW4VUhLIEEN2e92Loq+vCoIH/kTrA8gtSoujvNj2Oc7CPURL6kS3+8AQ + F8JoAKq/3x5ftZqAjScDSzaarO+fvD6RBQAkPf3N+D5bBGz6P+X7y1aka/FxPr6GtPyWNTSPA2CulasW + ycCWNPtZ+3OOvyE2nr14uKm9U15OKgLY7nmL9jjOkvF4pWFp1if13jnwSzKYaM1BFjImIYFMv7aYo5e3 + AjJkIKLSInz7ExVF3741Gy+IxM8f1gW42fMWjwKL60Q3hcYMSbAmVXMA4HnJEtz2oDrk59FZ8x82AeS/ + UwQBuaW3JW6l9v95GC5bUa3mwc/5eF6Ik5fi4tLbfLWd9G2BbOyAM43s17fEfSaJk83cP2ZyUhDAumJx + yX6l7qwDi2TNeERZ01MSAHd8dVpwVANoAJWNrdb6F+r1jRu0rn+oWDz7/FLpnLMd55wCUCBjsrPd5FBN + 2Zsd35d5akkOTvr5sgv8xI2ihz7m+/fjEPGCA647tEepxVVgUY3odhmoTK7cWPNn0prGZIDMM+2Qf98R + mv7J8znwy4L0AjUAACAASURBVHQgE7EPWAJAagFERPhpGC5b3nkhTl6Lj5fjGkNqAfC5SUoA0NkCkCTA + rkDSWIisqf+OBz7LCUsAdaUGt3ve4t1K3eMTDUkQ86rC+dpy+Vy+1FQToWZMZVcQbHmlXt+wMgy5ZDKj + GAHoXyqVhi4uld41T6lzSbgCGdALzZ+4AOK+MwEZxI+3e1o/2oqib90RBK8AiFa67lnacW6sE93kAzeG + xgwB2SvcAGlALwZ6cvXLxxzEFODPRIEoW8KLDreZ+wL08jUJfohzH8ASADv2IREejqJlL6cr8+TBz2vx + 7YO1AtgFCMXPStDLwJfcHfk/njR1G8dTTjgCGHWcoW2et2SY6K6IaLAtmNfJxBcmpnQBNICaMeVdYbj5 + lVpt4ythOIbUdMwHjvJ+Ic0l6r2+p2fBfM+7YJ7jnIcY+PkAoXQNJBkkwcIs+PNLWW+Pv/PsTiFbAMhr + f9b8/JqOnzMxMXCBjfyuBD0dLIIJwS/Ajdz72kqHBTknOX9jEBChDvivGbNpn9Yj+6JoeEMQ7EIKfgb+ + PqTmP6fmOBXIkgc+82OnQzpcj+YdLScMAezxvIXbXPfusdi/7xjJ76DpeS35ZOItEerGjO8Kw80rarX1 + y62m5+ufg+DsK/LyW01k009AWoFVAFC8WKk57+7pufi8QuHS6USzEccLJGiZDPjDSXwAbaBvyyZI6yIv + DHqTv8/EkNP+8urPZDKIkjHWEwIbaDPzk/sdQJ8nAFa9gSAAGconAIoIo1pvDYC9PvBWK4pWrQuCF57W + ehssMXCg7h0fpDvWctwJYGOhsHiX49zVIFqU99dZqwc5X19D+PjxVgPG94ThhpdrtfUvW00vBzrydclR + YgY9p4s4QiyXgHaQtmv2AOiFnTVfutZ1z76yp+fyc1z3kgJR0cSWQbKIBZCJH+SDh5msQX4UFESVi3gt + MesF6PlxxioQ1gFHzxAfjBeDv5P9zO9vGwIy0ePc8/w9Ms0aGJPO3hPnhEt5XUrr+eOFOF8vAmt6tF49 + YMzKm5vNJ5H127v++xTLcSOAt4rFJbsc554AGMoU7eS1PDr49WzeA2O7g2D9S/X62hetppf136ztO4Fe + pojqyOaGOfXETRglWPDLrSfeSv+hVLrkwmLx8jMc5zz7q2kqMR876BQ36AR8ylsB/J38vNYJKSTkEBPB + ZmO2vRFF2zYaM/b7rnsrkEbPXKJMGJ1PkjT3OwX38qO8gGwQEbnvYgLK5z55ue58r2yS34utFBk/cYHn + SsDTXhQ9mJty2yWEKZC3lQDqSg2uKxbvHhb5+4OBPE8KEYCKMbs2tVqvvtFq7X4+Bb1c/JG1/eGAnh+z + 9uc4gIG9/rj9kleZYQLoQ44M5hJNv7FUunhBqXT1dLvabpYMhGsA5AAvNwF+Et+RpChztz7gb9F662tR + tP3lKNp3wB63AWDuct3rFhBdyL6MlyOAvFmfAHgC4E90y5+Xt/k4BRNA3gLi1XiVAL6be484P+Me0SPF + KJI9Gd1A31HI20IAo647tN7z7i0rdXsADHYq0+2k4TnIVzVm59ZWa+UzjcamV7VuITuzHbB/er4Q5GCg + 52mvTA7s/8tGkERxInUFSshaBH252x4ApYuVmntTX9+1p7vuBX1E0+wetl+XMpHdyWpoAz8ApTVqxlS3 + RNG2jVG05ydhuIPPwVUzZ06/8Zxzzpzd19cPIhO0WtHZGzZcFlarGQJgUOW1PqcHGdw6d1+L+5H8jPgT + 5HEgZ/20EYBwCZxcOnUCArDfbUmr7AKPIAz/7nZrGZywDVonshxTAthWKCza7bpLxkThTqZ4B1nwy+fr + xmzf7Psrnm40NqzWuol0JWGpwGThh6z/5u1wQC9zxfLiAbIkIAcylJDGBqQ10IcsGRTjeMEVZ7ju+b1M + BkJksM4+ka4mw89prf09Wu/ZEYZ7Xvb97Ru1romP676+Pnz+mmtuvOy88843UWTdAWOAeOpPbfNmVF9/ + HajXE8DJ8HlSGCUAnwztFOCPxOPEvGcrQJBUknmQxVEyRQoRGJ0gjSrjJW15P85wpLfLEARf+NVW60lk + szndvP8h5JgQwMZicfEux7mrRrSoY1NOTtNHcUCvaczwviha83C1uuwVq+l5Zdd8b7dsHJFLbB8N6Dtp + DZlFY+Up57t1sgo6EUEP4kzCxcXiubMdZ+6g686ZTjSrQFSQPxga449qPTIaRSPlKKquC4K9q8JwRLxF + BttDANF3brvtk3OnT5+TAN8YOwGIXQWtgSBAY+NG1LdsAYIgo7Uz7bwQWp7BLi20+HGyvl4+6xAH9QA7 + tJMLp+IgX7ZSUsZC+L1Am5WQj4kkw0MEERARjDEvVH3/Tz/j+6+gW/l3WDKlBPBWqbRkp+Pc4xMNJVdp + Tnvku/J8YN9wGK58rtFY8WgYjsKChrV9Pn0n/foG2rV9PqI/GdBPJEkWC2mKUM50YzJgwEsSYFJgsuDZ + dHKKS6cmFyBbuZyvdAs+/5733HDt+effmGQDYgsg0chap7PljUFUr6Py1lvwh4cTkz/i29x/FSqVne5D + acVlMlsq/oycXy+rI9mv52h/cqBCwyduidZtlZUyLqKApBAKSOMXPEJMxbcmDL9yZ632BXRr/w8pR00A + daUG1xaLdw8rdVcYF+5kTEaIOny+eIiq42G4fL3vr/n7ZnM90hQbzz/j/ZIXex70eU3Pf/ZUgn4ikWTA + 17Uc6MjugSQDJoHEIkCWCPITXHgf88CXHW/+Q7fd9vmS500jY6BbLbR270Zzxw6E1SpMEABE8EollM44 + Az1nngk4Vj/XtmxBdfv2bFMQA1x07+VX1Ako23TF5r8B4Bvj9wAFWfeQmVIhtLwokU4Pmi0ArbPVkzkr + ILnHgEdKAmwNaGOW3l8uf/ZhY/Ygm+E5HsM+TliZNAGMuu7QukLh3nGi22VEPw9+aUrWoujVrb7/7A+a + zde3GKOQ1fY8oFT69gzqeodNmvYMelnR93ZEiKWLkI8XTEQGmTQi2q0BaQXkzf1MZuP35s8/944rrvhL + aI3W3r0ov/46EM/0VwwMubeeh9JZZ6F4+ukwxmDszTfhV6uZ/4nX0ONxXgx47uiTVgCzE9md8u8fHX3k + /N7es6/0vMt6gILU5pluSqTsmZw8jhPEcQFHgN8VBMCpRB4jZpgEYuBLEoii6JnfHx//fWSHfHKFYdca + wCQIgAN7o0R3ysUV5X0J/gDYMxwETzxSr7/wlNYNpFqQL/q8b89+PWt67uHOm/gc9GPA88bX5dsdCc7H + C/JkUBQbWwAl8RwHGTtZABL8CeF9+eKLr/mF+fO/WF23Ds0dO9KaA8qOzk4c4Pj/cfv7UZw/35LA+vUI + tU60fyBn+fEor/iWLQPZX8Gm0Mpmc8XLo6NvAdBnuG7vNdOnX3GWUueUgIIsiZYnK18nIYmA4wdMBknR + VPwdXLQkSQBEMErZakeyRU/jvv9vf1ypfAXtc/+6LgGOYCz4xmJx8U7XvesNokX5YJ6h9kBfXevnNjSb + T/9Ns/k6UhN4NiwYOE7EjSGs1Thtx4Mc8qDniz8P+hMh4su/y/iQpno+XtBp/ru0ADq5ALJnwQcQnKbU + aLBrF4Lt25My3ySFCGRKdZMdJEKrVoO/di0K8+bBmzED/shIVvsL8PNIryB+nf9nxN9FxmBLEGxi8AMI + d4fhyAMHDvx0FpFzeX//eWcXCuef4Tjnmfj98sCSlW3jugHOUmhj4PDaBUhjBgnomUz4GCkdMwZBTKVC + 4Q4AP0SaQZKn4x3vChySAN4qlZbscpx71pPtyGuL4mfBXy2H4U/vr9V++oTWdVjgz0U2qAekAOYpMNKn + ryHr60vQS+CfCKCfSGRqnZC6NC20z4LPLwOVyXghGwOQcYBoruPUKtu2pdFwAKREDJEo0Zj5XL/WGtWd + O+FMnw4UCnZMuDT3Ebf0xmSQn6rELPVGq7XmuQMHXkVK5klm5oAxraWVym4AywB47yuVzptVKMwbdN25 + PUQDvUpN6yHqT06ajPYTgZRCJIKYhmwJsUaaATAAjFKphSMIIZ4i3LukVPrIN5vNx4GkDaJbTRhLRwJo + xIG9EaXu3CKAn48S8/3QmN17ff+Bf67Xn19vfXsGvkzhxUH/TL5eavp8Sa70608G0E8kHNNgl0TBHpeM + G2TiYmiv1JWWAN8a/dprSyPXbffjKDevH2lbnUz5GQDNchk/dpxX3kP0rl6iPmkF8DDPENb859n/ADAc + hntfPnBg2e4gqCEFP0/2qSKdtBvFx1dc1myW0WyuxUGCn1cXi/MIoES/y9oCQRAvBsHez/b3/9LpRKcn + pMbuKNIYQUSEXs97F5rN1UgLxuQ1JYdDveMkQwBjjjO0uVC4+3ml7gyAwY5FOtK/N2b99mbzoXsbjRdh + 1x0bgPVvpbnFwJeVeTWkwJcz4GQEv1P0/mT+o6SLAExQCQy04VnW6wCAXuF5i6vAFQHR4DTgMzuN2V9S + 6o8KwDUMUmYNGayThCD/z2la93qOU8hE/mEj/hFS8GsiDIfh3rWVypoNtdo+8bVs3ciVdniqT4iYAJBN + i8o18ZJU6PJWq3oY58SeSGPq9gym5j/vLxOAIkKDqARgJtKFQaRLKdf7e8eJC1jgbywU7l2h1J0M7hBI + Wm3zo7V8Y1atqtW+/3e+vxX2Tz0NadGODOrJgF4tt+UDerJw45Qt6awqNVi+9dZfrLvuNaFSgy3gvfA8 + xctiZcxgYwwFwS4nCLa6QfCK2r//ja2vvvrnO4Gb5FCPfqXKe4FvENH4bKKb5bivzImMzed8We9FSp3t + EHk+pak+Tv2xmzdqzOjq8fHlm6tVCXz5H9dgwT8KO9RjFJYQAlgA5ysnuSaijQSQTRZkqoDludQ2qMf3 + M8VlHCRUAHYFQRnANGSX/q7Ev+sjrTV5x4kLAKuLxZVhbvgG530jNgGJ0DRm9cpa7QdfS4Ev/Xv+c/Lz + 2HnjVVY5b59P3Z2SoK/fcstpw0Hwn1ozZnzIV+rKrb29cw3iBhlRuZdU8YnXAACOc1lUKNgOn+nTUQQQ + rFuHyPcTXxdEA3OIPrvbmCc2EL1wDtF7k6ABZacHtdX3E6GPqE8u2hGK1ziotqFef0uAn4HPrhyDisE/ + AksGNaQLUXpISaCELAFIEpBukUwQADkCmEnUq+L9zIw9F8/5xviPNRo7kW3m4t+VWah3pLgAEBIN5ift + cDAo1vh7X6rV/vbr7cCX/r0cxyz9QAZ+viT3lK3Zrt9yy2ljhcJ/rpdKt23r7X0fAx7G2IU6JfiRAzyX + 7vJ9QQ7GGJSGhuDMmIEDL74IHQSZSTyzlPrgXmOe2ku0Zxpwer5YR57kxFVgoqfcUFUgeT0A/NdGRzch + zW5I4POCG3KNPV50o4F0wEq+PiK/6GUnC2AiSwAA0EfkOIBdVJTSl4wggF1BsAPtKVkP7UVX70hxgWy5 + rlzGuQXs3dho/ODPm81XkJr6shMvQrtvzxcFr7qS1/h5E/+UAD0A7Lvhhttqp5/+u9uKxY/A8yyo4yW6 + TA7I/3973xokx3Wd993ueewuHlyAAN9FgpREitQLoUQpFEULFu3YkWgTpaRsJakU6DhKyZUH6cRJ/qRK + +qH8kkuSU46dVCm0VFSicuISY5miLYqRCNEkRUIkXiQIgFwsgQWwWOxj3tM9Pd335kf36T73Ts9isTOz + wMz0V9U179mZ2T7feZ+TJvC8r98U/Pi6ELA2b8b2Bx/EyoEDaDUaWunu7cCnnw+CZ3fb9jYbKJKpDwDx + LEEWI6CAIG+l4+k0ALjQbs9B1/y0UrvEDnPHHi3dIIuOaoLMJZZpm225wJszTOIA6RbgDjIdKUXIA5UK + wEvl8pGUf1XXuMK4IQewk4CZ/wvt9vf+S6Ox/1TIlqTxKVJNgk+RfBJ6Enwy9c2RzCOn7QFg8bOf/QeV + zZu/XJqa+pCKGnEUNdzQbWaGK6bhuXDHGj96jF+PZ/+TJrdtbPnoR+EdOgS/0Yhz9R6Ae/P5v/fHjca3 + /sXU1D+n1Wc8rUCXCoCrlJdTqmBWbtJ8QWFZeLtSeQtJBN1F+H+mKb7LCE3+KvRqO7PsViCJwHPtbq6z + Ng/T/BcA8MTk5K8RI1EPgJYtsCycarWOzwZBHZ31FKO+EGTNyAHAlFJ/XLGsf6WEQEup179Tq/3pj6SU + ALYh1Pz56PkSnSuXKKCS5uOP9I+98PDDX6xu3fqfV3K5nbHQq3AoJx/dpQytzrW8qeHpNXzun2IEECAh + ASkENn/4w3COHoXXbIbbeBCa8b80NfXA3wTBc7+cy/0KF46YAITAW1Keut22b+HxAEpRIBL+plL1065b + QpLNcRD+z1cQTvNdQmgBUIVdt8YbngUJoFdO8kszO4K021tt+6EaOpcEUDlwWynv+VKJVrxTzQmfFcHj + TmOLHAA82Gj8x69b1revyef/7u+2WscA3ICwao9SekD4g3FtX0Ei/Fzw+XCNkTPzAaD8hS88tOT7Xy9P + THxYSRn64ikCn6bdlSH8QKfAm5aBAhBExMJ7LgKlEAiBzffcg/rx4zEJtAHcZtt3P12vvygnJ5/bk8v9 + isU1JIATUs78wvOO3zU1dUc8AYh/yej5C60WDRwhIaINPjzaX4U+T3EtFp6ZFg1SnpNqpp+x7emXgIdt + IK77jz+zCteIv91svr6sFAk5xad42pms0pGyRi8XcR3Av5XyHMKBCjcgIVQK4NA/nm9YrSLx8+kH5UsY + Ru6HbX7mM9ctbN367QUh/r7K5aCixZvSFH5TiMMHO4kB6QIfm/zcbYBOApSloeUbm++6C7WTJ9FynJAg + lMJNxeKOFxqNt6oTE+VPF4ufvlapnQ2g9mq7/frzjjPzq1NTH4w+eBJEE0lJMYTAhWaT/H8K/tGabW75 + OUhmKfbzf576XhcLhd+0gGnBSI1POapLufh0tXoMoYHAhZ8HpMe+BgDQC4F4/TqZ+MSQDtK1vtlmOZKC + DwAXP//5L83lcn+ohNikgiB0Ks2g3iU0vIQu8B3Cbvj9RCyxyY/EkaXcKZXttoXA1K23oj4zAz8IoITA + zlzuOgBnD7vu3GHX/TYSXzwPwL7dtnfaCN0B3rAjlIJtWWgp5b3ZbC5Ar/S7ooJUs+3p/Zb1Fb7fIEZE + CK9XKi9G9/CgJc//mw1BYwsiAN5+S66VFz0ukRAAj+7zneojK/jOZz5z3fy2bd9fse0H4gAf8/O1CD/Q + odW5H88Fn5MHjOeAvzcMAgj9WwRUqqtU6PtLCVUoYNPNN2P5zBlYAOZarQsIBZ5iN6SlLQDWTsvaTlE4 + RE+yoydAKSyF0X8F/fwwS7Y3VIhOFAqPSWAXgLgDMG4HVgpn2+1fvBh+70L02ShdSZZrDYnFOtZlwEBC + ABTgaSKpVaeoP0X8zR58Xkc9kj/iwkMP/e6ZrVv/SAKbNHOfCz4SgZFMyLm2l9HRLpUg22349TqCVguB + 48RNLABgT00Btg17agr21BREPp9YGoA2Lt33/TjyT0TgA7A3bcLE9DTeXFmZedvzytFXof8hLdwEAGwF + rqGdBtwKsCPzf9nzLkBvR+bnwYYv71jJ5Xa9IsRXKE3J3SOEH8b9Qbl8APp5y7cOk9uaaf8InADI9JcI + hZyq+4j902r0R1LwAWDuN37jT0u53JekUrGvb2r0S932ajW0l5bQKpfRrlSSE5blqbUwebWqfQYxMQF7 + yxbkpqdhbdqkrTrnE3radFsIKClR2bJl6amZmZejt+H/W6rO8397YuLufBRE5IJEn0cohTdrNbIAeOdm + GgFsCI7k80/FnahIgqEKoWV0rNn88aJSZMhQ0Jpc1zJCAmgi0/4xOAEACTO2kAQCyQQkxhzpH865//6d + 56anf1QX4u9IP4yBkrbnGt5M41GO3nddeEtLcM6dQ+C6ejtfiuCbP6RGCK0W2q0WguVlqFwOue3bYW3b + BpnPJ5N5iAgQhdGVwvZ8/hr2dkQAVLxTBuDsBHbGC0Ki7xUg1P5KCNSkXF5Riqbn8CpPsgI3NI12pFj8 + 8rwQu8kNijMh0e/QkHL+fzcaJxGmrcnl4c1JVKew4cR1NYOP4eJxJirWoMfocbo9kig9+OCnzmze/BeB + bV+vWAWfJvxAapTeK5XgLCzAu3gxNo3iqjqkC/1qwk+34/cKAjSXluCvrMDauhXWjh0I8vlwSAdlBgAa + vZVnL+eluzWEwlB7by53Yx5J7k2pcFUXuS0Lrdbp6CE+2ISGtvDCroGfD6cKhb0zlvUVczgp7R2UQuDn + 1epzCP1+QCe8NN9/pK3XywHPAqwlLzuyWPrUp35zYdOm/ymBzZL5+2nmPaJLCaBVLsM5cwbtanVVwU8T + +rUQAGdfuu7W6/CaTWDbNojpaW1YAhCP3uIJA54GqwKoXgMU20rFxUF81ZcCMO+6F5BYf7yr0ySAgaJs + 27sOWdafsYGyyWDS6Jj3/YPPet4iwroVcmG59ifXh9cqZMBljAQbZZx/8MHfvzg19XUlZRywo7SddsmI + oN1ooDk7Gwt+LPwpgn85Qp/2WHxpvLdbqcB3HNg7dkBGU3EkQAtHuevWMXlpCmg3IgKgyUFkSUil8PMw + kg7oU354vcfABcmxrOlD+fxTbSGmtenENLcQQAtwvlsuP48waE2ft4lE8/PGJF6enAEZAeD8Jz/5++Vi + 8evS95MAHtDh75MVEPg+nLk5OAsLmt/UTfgJq5FAGtKEn25zK8P3fTQWF1HYtg0oFMzSOV7bwYO47aJS + 0o3eU6poJ18UFCwHwbno9UQg3PzfMB/6rXz+G01gt8+0fjuaVUi3Zz3v1YvhFCqK/FMqmzoUue8/Vlbt + WjDWBHD+/vsfL01MdGp+5u9zN8AtleC8+y4C39fHFBnmM1IuzeuXBKvMo9cquh2lweK/rxScahUT27cD + lkXBG9OD4A1/Mp6yS3dEJrYNoOr7S9Gn4Bkg3tE58CzQ8ULhsXkhHuUjyeMjsgQaSpWfqtXeQOL781Jl + CvyZab9M+zOMLQGc+/jHHy8Vi9+QUX++VIbPj0TryyBAY3YWXqWiCf5q5v66Bd94HfnnaX+H++5+EMBp + NDC5ZQtaUvKyXF5AGHNGAShTAZCNsMyYRnJfa9s72Gv4KHKz2WcgOJ3P750V4pua5qd6B0p7AnjDcV5a + VIrajHmjEm9Nzop+VsFYEsC5++57rFQsfkP5fqfgs8i+UgpevY7mqVPwg6DD3OdafxCC33Gdpb44KcTL + WBwHxU2bUG63yylvq2F7EBwq2zZUZP7bItkcvMOybr7TsjafDCc78yzAwDs7y7a96w3L+jNKb/ok9NEl + kUEDqPyfZnMWYcaD0n5m0Q8v+c2EPwVjRwDnPvaxf1PK57/JI/2Sa3wkZn9rYQHOwoKu9dHd1++W3rts + MLMfQDyggxMOz4NzK6HVbKIRnvgcHR9NIHIBotdxC8AWAvdOTt56stGgSkA+knyguf+Ttv1UO5pQ1aH5 + mUVwpNl8FUmxGhU6mRV/lLHItH8XjNU8tMV77/3cim3/kfR9yCBAEASQQRCO6fJ9qCCA9H0EnofGzIwm + /Hwbjub/o7sF0AtioaZKN3abr1/TSEkItF0XS2H/Pr0Nz07Gb32f6/4snsChkiWctH3nPYXCXfz5ffxq + XfFWPv9lR4jd8dQOnvNnkf+aUtWnGo1Z6CW/lOIkAqB+lSzwtwrGhgBKu3ffvyDE92Qk9NL3kyO6L/B9 + +K4bpvcaDT1yRtVn6L/Jz5GWPeAaPh7cCkZI3B1QCudKpSXoRkvabAZlA6dJ+C2DBKYt69pPhN2E1G27 + 2gbjnrGYy+1eEuIrvNSZB/3ikmfLwqznnURivfI5FVXok4mywN8lMBYE4N5557XzwBNSyi1c4PnhBwH8 + ZhPN2Vn4rpuq9Vcz+ft2hhlRf27+S6b9aZ03381ICzKPOg4V8cTyhM6uTWUDR7TZWypZwiEA7J6augeh + oKVN7u3rTL3TlvUNXtrLq/3ilVDRhOpna7Xj0WfgjWqk/Snnn5n+a8BYEMBssfjDtlLvDwztr4IASkoE + QYCgVoNz9mzoFmB14R+EyU/vlSr40AOAsYBAN/+jKbhz0dtx4Tc3JisAmFDqMKUDNUsgcgNuzefvRjLO + m8Z4cxLoC07l8/scYA9v8kldTy4ETvv+28tK0fcg35/PpMwq/i4DI08A795999c8pT6hmfqR309mf7tU + gnP+/JqFn9B31WJqfySCT8IfGKRA7gkFMM+FI7xM4Te7OAEAm4Jgf9roXSKCAlB8eGLiAwgJgNaaEwnE + vUS9oizE3sD4joHQC3+o9Pe1UPsDSdEPdfxx4c8q/taIkSaAxfe979crQvyBqflBZOD78MtleEtLXYN9 + GyX8qdqfRfjThIMWePAR3ueTCT5pbdyaFfCA5+23lKrwtdymg3/X5OQHkb5Uw0afzp8AmI79FdHZ7EO3 + 60rVj4QpToUkNclH0VPgL0v7rREjSwDunXdee8G2vyV9H4oF/BRlAHwfXrWK1sqKtnHzUsI/iHC4AtK1 + P/RNTYEhELwfHkJgOQgWzvp+HXoJ8GoFPMoG/lbbuhG5ADQe7HrLes8NQkwjIQDa60dr4Hq2AnwhpnmQ + 1UwBUtBzttWaiV5CDUp8CQ3X/lngb40YWQJ41/e/67fbN5PgB3QZBfwC1w0n9KAzx7+a8A8ELIqvpfqM + ACA3k/l+P3rtGcc5hU7hX62EV01K+Vfc7CfBp9mECsBDmzbtRrLXj9wAsgJ6hgvspg9Fm4nibUXMzTlY + r9P3MzsceeAv8/0vAyNJAPO33fYFR8pf536/khJSyvDSdeEtL2tan06yjRb+1JQfDO1PQTCg0/wHgPAx + 70ClwglgLS286u12+y+56W8ZwUChFG4vFD6IUOg3ISGBvu3W4+a/tpGakVxdqcZsEJiryPl6eU5ymfZf + I0aOANybb96+CHxNRgJPKb4gqvkPggBeqZRs2AE6LjdM8wNdtX8sAIb/z3vh4+IgAHOuyPJMoAAAGb9J + REFUS8K/2gSfDgL4PSlLNvBMHAcAI4Ho820RYsf9udytCM1/2u5LbkDPwUC+lITXAfAsx7w+oJRvJM7G + fPeAkSOAOaW+2vb9W2QQhAQQmbIkaO1SKRnhBd307xbwGxSUKfyAJvS0mp2EwTeEn0aMCQDHy+Xj0VuZ + 8/toYUs8NYx/BACyIOXTcRyAFQRRPEAB+NDU1Eegr/cmK6BnAoiLmBjZ8aWnCsC86/Lx5Gnfj+8hzLBG + jBQBVO+4471VIX6PCzF3eNuVShgMxOrCz7FRpn9HmbER8eemP9f+AHDW806dD4N/5vhubh53C47JI+32 + XwqlqnGpH4sFECHcms/fg9ANICuACICCgT39FvTBzIAsPfaC41B6k48448LPp1RnWCNGigBOO863AeZD + I4mw+44Tj+HmdbHxVFkkZ86G+P2rBP7MVF9sEhtBMUTv88bKyhEk2t9c0X6p4Jj891Ku5IBntJpfIoHo + SXZSE8DdAKoJ6CkbEGt/JLGPeH05gGXfN1ObpnvD13xluAyMDAEs3Hjjr3qW9QDX7AQZBPBrtdjPTPP7 + CVfE7+efh5n+nAS8qB6e5/4FgLOt1qnzvt+ALhw8NcbLYrshsILgu7QTQJgWQGQFvHdy8kNIdwN6CgZy + F6BjiKoQWEwIgO8nuCIDSkcNI0MAF4EvA52mvxICfrWqTfC9lN8/yLOoq+nPI+CWFW7+saww8BfVwJP2 + J4uBaX9uGpPpv9bcuAIgP+d5+4VSczRdw1IqvoyGjFJNwDXQSaCnmoDz+fzuePoR0i2xekhwZLyRi5Np + /z5gJAjA1P5cuwaui6DV6myJu1LCfxmmf7z4QySFMWQqCwAnms0j84nvT4ExvgNvrdFxCcDPKfXfKQ4Q + Cz90yX5gcvJu6HGAnmoCPCGuSYu/KPY3L7RaK0i3ALI13z1iJAjgIvBlfgLFs+6ljE1/0zLgRLERMIWf + b7SRTPNrZbAiGYThW1ZsLQgAPuAdK5V45J9v7jW39q4lOBYstds/4M1BWqNQZAXcUizeiQHWBNC8w/gm + gCO+zwkgrbox6/lfJ4aeAJanp+/1bDvW/rHwC4Gg2QwLgcA0P3TTHymX/Uaq5kcS+NK23JimPwsESpEs + w3yzVnutLCX59mnaXzP/FS006P4R5e8EwSmh1N9wC4C7AQLADZZ1xz2WdT10K6CIPrUJk+anceWOlHUk + 5n+8ER16g9NGcvlIYegJ4OLk5L/jSzpjYZYSfrPZOU57g03/NOE303xavl+E/e8e1/4sNw4AK+32wsFy + mZfFUlEMDcQwh2FCpO7T1iAB+AUpn9YmfxjZAADYPTX1fiQpQbNB6LIIwAdEt99eKIWmUiYBkLXDU3+Z + +b9ODD0BOEI8zAN7QHS2NJth2S/0nPKGqwqDcCj+wE1/n2l+Mvc9dp1rfx/wDiwvv4zOwF/aPLzLbYyR + n2u1nhRKVW3S/tHB3YBbi8UPIJ0AcujRAoi1v36dfjre4TjwAaXjgKEmgDM33fRFaVlbO/x5IcKcP1N6 + V0T7R39P+/tM65t+vzkFp8P0B3Cy0Tg6325Txx8NxKBFGL3Mw4u1bB74a14LYLYJbxVixw1CbEV6NmBd + lYHd/geVxP+Pq4TZkWn/HjHUBFAD9tIgjNj3B8KiH2O4RzftvxHCH2cdhOjI83O/n/L9XnSfH8UCYtM/ + CBYOrKwch27682GYNBJrvfPwFADf9f3/SnEA28gE0C7BT05O9s0NSAO9QTuMc3AXIG26UWYBrBNDTQBN + 4LNm3lgJAem6wBq1/yCQJvwduX7D7Ce/X1t+Cd30/9mFC/uRaEI+B7+EZA1WL/PwFIDgt9rtgwI4S5rf + rAcAgFuKxfchFHoaFsLHhfVlUpAAIIQwyzf4qvrM/O8RQ0sAZ6+77h+CLcQkyCBA0Gp1pPo2QvvzCD/Q + KfxayysJvkgm35L2p8IfXvF3sFx+uRJqQ4kk6k/rvvu5AVcB8PNSfs+cFBR3CCqF62z7doQaf5IdlA1Y + txWgDSeJ/hb0GABvF8i0f48YWgJwbPteLcJOqbVWq8P3Tjv6jY48PzqFn0x6nwt9dNki0580v2XFVsys + 6x4/VqtRMww3/cvQtX8TvffEK4Q1AU/aWH0W+J5C4Xbo8wJ5VWA/wX9Ws08oQw8YWgJoCvFL3PcHEAf/ + AN1m5MFAQj9JoCPVh0sIPzf9iQSA+DHT79+/uPga9Kg/F/4VJNq/H/PwqCZgxgLe1AqDWIEQhMB7Jiff + h2RiMK8K7EtREHM5uFFltntkFkAPGFoC8IT4kBnJV1JCttupDT6D0v5pwi/XIPyU54/z/dH9vEy5ImXp + hdX9/hWERLDetF83SABBXqkXyOyPg4BRTEIB2JrL7UQo8D0RAKdnPoeAPca1/UYkcMYGQ0kATcualkJs + jc+CSFtKz9Oe103w+3XWpBb5sFQfBfq6Cj9dp+o/6EG/g8vLpt9P+f6V6CDTv4H+jsNSAALl+0/GKUAR + Lh3hwrrNtm9CsjeAjwy/7KrAtCcKANtzue3G56LLTPj7gKEkgMpNN33MdAAVIgJIMcX7jTjmwH1+kT68 + U4v2M+Hn/j+NvybhFwBeXFx87rTrriAp9aU6f9L8pP0HtQFXzgfBbCzFXSqJ78vnb4S+OOSy6gH4u6Y9 + OS9EIeUp/f+njimGkgAIWsANYQagW/Cvn3/TDPbxxp6Ojj7D14+Dfuy+eN13RFYHa7WXT4cLPnnQj4R/ + OTpK0X2D2oGnPlAofJYCkVzi+HefFGIS+vYgcgHWnAlYw4fWEgPsdkYEPWIo14Pz4B8X8sDIAJiv6YUM + uODH7yeS0Vy8r9+P0nw0xJO0PDf7ufDzdN+hWu3lw2GdP+W7W0jSfcsAlhBq/15z/pf8yjUh/jXoewu9 + p4LuP9ZulxCeR0QCNCaMEgiXrEZcoxTzJUYZ+oSh/jG1PL9SiUCif9o/diNStD4Jv9nNR1rfY7n9juur + Cz9F/EnzlxEKPgk/j/oPZA7eUi63KwA+ot3JCVAIVIJgZUkpHwkBkP9Pwr/uWgDCFsu6FsbWMuhZycwK + 6AFDaQF4SgllCKTyvERLG/7qeqSDa7luWl8haeU1G3sCCu4BHeZ/+9LCb+b6SfNvhOkPADhv249wra8N + W4nuf7fVegfQaoT4GvHLEsxuTy6EMQB6mAt/Zg30AUNJAGSSKqVi9RdPygUT0lVb4NNBJBJfZ+9ppvno + 78YtvXygR1TNxzV/nOcH1ir85PMvIiSADRF+AFgW4lHw78qP6P7Djcbc6u9ymWAbibT7EmE32xKAzALo + CUPJoLvOnn2OR+K1OnsYmsqI1nc9zBMcRk4/uk6+PTf34/bd6JKq+lqWBZcCftHBU30W1qT5LyIkAF7r + P9AR2Bfy+d2eELu5O6VtTRICC75/+lQ4rIPX6PNjTVV64hIkzR41zf++7CUcdwwlAQCAAI7xkd5akXgX + Mljt0CYGgaXz6P0i7a75+cbRioTdEwJuJPxpZj+EQBvwLiH8S0iEn/x+GvE10CGY5yxrHw9qaiPVoutn + XPdM9HQ+qqvvU3oUgHtzuR3oJIAsC9AHDKcLAMCS8oiy7XuUZUEqFQt97LNHQUF+0lLrcAcMPx9A52sZ + GZg5fm2IJ4v4UzDQNPnbgBfl+UtIov3dhH8ZofDzHv+BFsHUhNjLSZHv6VPh528902jQpl4SfBrT3W0T + 8SVhSrOK7pu0rALStX9GAj1iaAlgAniyKcQXzPQbEEmHZYUkED1O96emCM3Ho5MdSHEB2N+idB+v46eg + HzX18GAfAJSlLL2ysLDfGOphCv8iEr/fjPgPtAHmTD6/54QQu9KsIPoec553EqDZpNqijste0tlNervc + nxYDyNADhpUA1EfPnXvux7fddk4JcbNE2D0XRIFBaVnhTjtGAoppYH5WdtP8sfY3BCBtTRdv66VhnvQa + /nfnPO/Ua4uLv2DDPLsF/Ljm3zDhB4CLtr2PiEvb1IvENTpcr89EP5G5h5AvIr08SyWy2OKbdCW8zxT8 + LA7QJwwrAQCAyvv+17xC4ZsKAAoFLRgYm/URKXAzv+ON6NIw9xUz31PXdbEy3oCZ+2km/7Fa7bVDib/P + N9zyIh/S+mm5/g1pfa0Ae83BJXyWQTUIlg75fhl6rULaHsLLdlXMUj/C9YXCtfC8d9A9DmDyeoY1YpgJ + QO45d+6JH9522z+Bbd8nAahCAX67nfirkRUQpwNFurLQMgHQo/+k/fhePsr10+IOChDGZcEiqemvBEHp + 4MrKy+8m/j519fGBHiT8y0iq/LjPvyHCf6pQeOQdIaY7wvrRd1cAjjvOm9HTJZIFHSYBrDlIOaXUu90e + I6mOagHMGEDmCvQBw0wACkDw9vLyv7ztuut+IoTYLAqFcA8gEi0MRMM1IojIIhDR4wKsz5QF/rSAHxIh + oDXdfGtvnG1gvr5AuLnnpeXlo/RZkZT2NtBZ27+EkAz4Rp8NHXq5aFmP0vfWZhYibkdsvdxsUu6ffP8m + QheGb+pds/a/0fdP/3Uu10HO9GJDurkLwC8zrBPDTgD+4/X6zB8Wi//01unp71oTE5uU68apPNLKZv06 + aWj+Rjz4x31eTQiYYEh2GxFR0Nm57PsLR8rl195NGnq4yc/7+Un4yeQn4d/wdVdNy5p+SYi92sxC5gIE + QmCu3T6xHJb+rmcN+ZpBtQHGG5j+f6b9+4BhJgAgUkx/sLx84D9J+cW7rr32WyKXm5LRPoBYmJXqGAoa + hpaiPXucKMjkh+4GmDUG3NRXUc+8I2XjeLN5hC3t4FN8aHNPBXpLbwn6PL91+c+9Yi6XeySOd8BIdyL8 + XV6oVo9FT+duTAPJFuK17CFMRTdJNn6E1VKBWQxgHRhmAogVPQD3q6XSgU84zuf/8datX7U972N8co2W + ykJnOpDn+7WdfdBTfzwzQBAAAsA73mgcfSXZ1UfuM9eS5hivEhKTv2/ac71YtKxHO9wdFgRdDoJz70jZ + jJ5ufi/KAPT189OvfF2hcAM6G4KEcWRYB4aZAIBE2FoAGq+47tlXXPc/fGli4nN3TE7+jgVs53X9vMyX + hDt+LHqcCz5ZCPEAOuY6CCHgStk4Xq8fea1SOYWEkEjwKUBGJj/X/GUkG3x4S+8VEf6VXG7Xa0LsMaso + SfglgBnH4bl//t3SzP/LgbqU9FIIF51uQIYeMSoEQLnoKoD8f3PdH8F1D/6jiYlfvmVi4oFttv1+8tH5 + FGFAr/nX+gD480QyCssHvHnPO3u60Zg51mxehF4LT3lxrh1J+Pn4blreaabMrogZO2/bj5i5f5+5AA2l + qj9oNmcQdvqZgUwy/9fvunTJzqDzzdLqATLt3wOGnQCAhARchCdDPInme677/+C6B28U4oZ7Jybu3lEs + 3rHJtq+fDmfZxYE7hSg7wCL4fBJOOQhKS+32wmKrtfB6vU7juYk7aE0V7a0nv5jWdJPQ8629pPUH2tSz + Vixa1uPc34+LnhB+yTnPO45kuAcPZtJB1X89WzBcmo1GoNVcgAzrxKgQAC9KEcZ93rxSrR86TgmOcwTR + /PodQmy6o1i8QQLWjkJhR862ixIQZL/Ou+4FAOKw4yxALxjkKfI29Fp4EgjS/KT96+jMk18Viy3n8/nd + R4Fd5P/zCkcKgv68Xn8nejq5WxT5Jxdm3cE/AGHLL7cC0i2CblWAGQn0gFEgACCxAszbfHtuA8AWRDvt + l5SqLbnuMoAcXNecYmNGl+P6IPa+JPi8Dr4eHaT9SfBJSMjXv+Jan3DWth8zg388zXnR92feDoN/UVFj + THRm7n8jySwT/D5hVAgA0EmAWwC8WGVzdJibbPgs+7Qac1P4PSRan4Sfa/8mksh4muBfFcIPAFUh9pLw + a9WOCAngYL1+FOHvwdOZ/Hv2pv0Jq8QB6BmrHBnWiVEiACAhATMiTyctCT4ts+RjrPk8e4ojcAuABJi0 + PkXCHejNMA57nLfFXnFz38QMlf4yzc/rHJpSVn/meRcR/i4mmfJYRl8tmkswZCb0fcSoEQCQCD+dRzwy + 30Co7WmENWl/En7aa0cbbulEI2uCCICOlnHQ/byS76oTfAKV/vqG4JP5/0aj8SrC3yOqBNYKf8j87zn3 + b76wi4Tzu82nZISwTowiAQC63841twtd2Ok6xQD4PkzTBaD34Tvq2+ygbMBQ7K1vWtb0i5a116x2pOKf + tlLuC45zGonvz6sZef1Cz+Z/DjjcBj7SrR8gw+AwqgRA4EQAJNYACbkp9JeKAcRVwkjIgGt6yZ5/VWM2 + n9/HBT4OAkaXZ9rtY0tKBQh/C+5Gkfnft7JlC6jwYizQJSvUyjAYjDoBEOgcImH1kZ5T7pZa4lkAPjqQ + k8tQnacXo9y/Vv3HzP/9tRoF/3jdP2l/0/zvCeb6NoWwIUgwEsgwGIwLAXCYAkuZA9OnTCMA8z2GEvP5 + /O6jQuwyo//kDiwGwdsnpHSQBP946s/U/v2AMn/c+AdXCpUgWEEn2Y7M/+NKYhwJoBvG5oSas+3HuPDH + bc7Rfa/X64eRBP/M6kZOAP0LcLJuTRjmvxeOUCNc1bGVYUPWUDGGqEbBP7PvPxACjlKVn3reApLGH9L+ + aWXMfRN+ANpAlRQpN+M55u0M60BGAGOGE8XivgCYTtviIQG82Wy+hDAoqqCnT7n539fKPx78A5KgAvVk + 1IKgZrzkqs+yDAsyAhgzLFrWo2lTf6M8qfvTMPXHg39N6Nq/P5V/DAXgMG/XJneAmrXK4Qh1MxDLSSAj + gnUiI4Axwkout6spxJ60qb+BEDjXbh9dVIoEOy3111vbbxfYQJkvYCHQtRPtNgUBeev1VV1kNSzICGCM + MJvLPWZG/uNxZ0LgJ7XaYYTmPw/+UerPDP71HWY6EOEf85aV8tCp/TMLoA/ICGCMUKKxX0b+XwKYb7cP + vxWm/gB96MegUn86UgKBAFAPgiWkd2OaxVcZ1oGMAMYEM4XCIwEw3dH6G10/2mweQ5gWVtCbfgaX+oug + DPOfgn8CwJLnnYdu+vMKzKuuu3LYkBHAmOCibT/K9xrEAz8BlJV698dJ6o8H/8yuv4FsJd4s5aH4RkQC + VJL5luPMQu/F4L0XmQXQIzICGAOs5HK7asbMfz7teMZxjiJsjAKSrj/T9x/Y0I+CUmXS+PxoSVk54PuL + 0IWfiIiPU8ssgHUiI4AxwFwuty+t7j8A0FSq9L+azZPQU39U+NPfoR9dEHv8EQmQ9r/Qah2BPt2JCMBs + uc6wTmQEMAZYtqxH+UqzePAngDnPO4JE+/vQU391bMCyEsvzDgnDAoBSzvcbjVegCz8NYeFzFTPt3wMy + AhhxnCgW93lC7JKG+R/1RTtP1euHkFT+mcE/vu57YJr2/VJWJqT8K9L+NoAj9fqTF5RqolP4iQCuyAal + UUPWDDTiuMgWfvKhHxLAYhAcXwgLf8y6fz7FmEZ+DRLq4Wr1t/+ZELd8fGLit+akzP+PVuscgJ1IOhL5 + 58oIoE/ICGCEsZLL7TogxB4z5Udtv89Uqy8hOQc86Np/o9eVqSeUKj3hOH8B4AYAt0SfhUx92q0w0JTk + uCEjgBHGbC6XjPyGbgUsB8GxN8PCn0kki1V46o9r/40QMnORahWhR1CM7qcdCwOvSBwnZAQwwljp0vgj + hcDrjcYBdKb++C6DDdX+0AmghnBYazu69JFsWWpgY4lppJERwIjiRLG4bzZl5LcEUJFy5hnPu4BwSQrV + /ZOPzc3/gaX+UkATnB2Eml9Fn8lGKOxUm0CWSWb+9wEZAYwo5m378XjopzHxZ8ZxDiPUrDTxN23g50Zr + WW4BIPrbDehjyWn8+kYS00gjI4ARxJlCYc8xYHfasE9XqZXvNJvHEa5JI+1PPf807tvFlREyIgGyBmhB + CxUDUeQ/M//7hIwARhAXbLuj8o8sgGOO8xN0an8y/YkABtf11x28tdec3Gw+lgl/n5AVAo0YmpY1XRbi + Uc3sR6j9W4DzI8eZQRj8o5FffKkpH/d9pWrseekvX8KSaf4BILMARgwnC4XHeM6fE8FZz/vbeaWo4I5S + f2bd/9UUYb8aPsNII7MARgzLlvUo7/bj+/7+vF7/BfTUH9f+G536y3AVICOAEcLxqO4/beDnQhAcmA/X + b1BajXf9Ud1/C1eP9s+wAcgIYIRAQz94+o8yAE9Xq/sRBv+AUMt3m/iTEcAYISOAEcGZQmFPk9X907Yf + CWAhCF45LKULfeAn9/0HOvEnw9WLjABGBOdzuX08+Bev/ALww2r1eSSpP6q2M1N/WXXdGCIjgBFAKZfb + VbKsR81R3wGAspSHD4ban1J/Gz7xJ8PVi4wARgDvFAqPUaWfWf33WqPxEsKOum7a/0qU/Wa4SpARwJCj + aVnTK1Hqj+f9pRCoKXXy/4ZNP7zwp4GwtZYH/zLtP6bICGDIMVMs7guo6w+Ih31IAK/W6z9GqP2p8Idr + fz7ue6PLfjNcJcgIYMixYNuPk+anrToKQEPKE9/3vHnohT/c988KfzJkBDDMOFUsPuIJsYuklzS/AvBs + tfoDABNICn942S8V/lDkP8OYIiOAIcZiLrc3XqtN67UAnGg2v/VsEKwgTP2Zvn82Vy9DjKwZaIhhA2Uu + +FLKkwcc5zt/4nllhBN1KfJPwl9BVvabgaFzH3OGYYI4WCg8NC/ExE99v/K1IAgA3AzgRgDbEPr/HoAV + ABcAnAdwEUAJyWy9zAUYY2QEMNwQCM38zQC2A7gewE0Itf+m6PEmgGUACwhJYAWhFeAiswDGHpkLMDqg + QRot6PP06wgJgAQ/K/vNECMjgOEHjcmi0d7V6HYOYZCvjtD3J7M/8/0zZMiQIQPw/wGcCGmdjgnpvgAA + AABJRU5ErkJggigAAACAAAAAAAEAAAEAIAAAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAABwAAAA0AAAASAAAAFAAAABAAAAAKAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAUAAAANAAAAGAAAACQAAAAnAAAAIwAAABcAAAAMAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAABMAAAAlAAAAOAAAAEAAAAA7AAAAKwAA + ABcAAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAGBASnQAEBQTcAAABEAAAAUwAAAFEAAABAAAAAJgAAABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYG1UMODrP/EBCq/wwMj6MAAABcAAAAYAAA + AFIAAAA3AAAAHQAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAw0NtfAPD6v/ERGi/wYGX4QAAABoAAAAYAAAAEgAAAAqAAAAEgAAAAUAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCgrDkw4Or/8QEKT/EhKT3wAA + AGgAAABoAAAAVgAAADgAAAAdAAAACgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAEBNQkDAyz/w8PqP8SEp3/CAhkkwAAAGsAAABiAAAARwAAACgAAAASAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKCsCjDQ2u/xAQ + o/8REY3VAAAAagAAAGkAAABVAAAANgAAABsAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQYG1UQMDLP/Dw+n/xERnP8GBleLAAAAbQAAAGEAAABEAAAAJgAA + ABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoK + vNENDa3/EBCg/xERi9YAAABtAAAAaQAAAFMAAAAzAAAAGAAAAAgAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAwAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBwfPYwwMs/8ODqb/EhKa/wICNnsAAABuAAAAXwAA + AEIAAAAjAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAADAAAABwAAAAoAAAALAAAACAAAAAUAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADCwu34Q0Nq/8QEJ//Dw+BxAAAAG8AAABpAAAAUAAAADAAAAAWAAAABwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAgAAAAQAAAAGAAAABoAAAAWAAAADgAA + AAcAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMiDDAyw/w8PpP8SEpj/AQEcdgAA + AG8AAABdAAAAPgAAACEAAAAMAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAFAAAAEAAAAB4AAAAtAAAAMQAAACoAAAAcAAAADQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAQE0yQLC7X/Dg6p/xERnP8NDXWyAAAAcQAAAGgAAABNAAAALQAAABQAAAAGAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAXAAAALQAAAEMAAABKAAAAQAAA + ACwAAAAWAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoKv7IMDK7/EBCh/xIS + kvUAAABxAAAAcAAAAFsAAAA7AAAAHgAAAAsAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAACgoKrIAODp7BAQEkXwAAAF4AAABVAAAAPAAAAB8AAAAMAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABBwfPVAsLs/8ODqf/ERGa/woKZqIAAAB0AAAAaAAAAEoAAAAqAAAAEgAA + AAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAMEBCq/xISn/8QEIfOAAAAbQAA + AGQAAABJAAAAKAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCgq44Q0N + q/8QEJ//EhKN6wAAAHQAAABwAAAAWQAAADgAAAAbAAAACQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQEBghwPD6j/EhKd/xMTk/8CAjCHAAAAbwAAAFMAAAAuAAAAFAAAAAUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMiDDAyx/w8PpP8SEpb/CAhZnQAAAHUAAABmAAAARgAA + ACYAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBga7Sg4Oqf8REZ3/ExOR/woK + XKwAAAB0AAAAWQAAADMAAAAXAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE + 0yQLC7X/DQ2p/xERm/8SEoTZAAAAdgAAAG8AAABVAAAAMwAAABgAAAAHAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIGBrtKDQ2r/xAQnv8TE5H/Dw9txgAAAHgAAABeAAAANwAAABoAAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJvrMMDK7/Dw+g/xMTlP8EBEGOAAAAdgAA + AGIAAABBAAAAIgAAAA0AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgYGuEsMDKz/Dw+h/xMT + kv8TE3jfAAAAewAAAGIAAAA6AAAAHAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAADAAAABAAAAAUAAAAHAAAABwAAAAcAAAAGAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABBwfOVAsLs/8ODqb/EhKY/xAQeMkAAAB4AAAAbQAAAFAAAAAuAAAAFQAAAAYAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADBQW3TAwMrv8PD6H/EhKT/xISeOAAAAB+AAAAZQAAADwAAAAdAAAACQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAGAAAACgAAAA4AAAASAAAAFQAAABgAAAAZAAAAGAAA + ABYAAAATAAAADwAAAAoAAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCgq48AwMq/8QEJ3/ExOM9gEB + GYAAAAB1AAAAXgAAADwAAAAeAAAACwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGBrNNCwuu/w4O + ov8SEpP/ExOE9wAAAIAAAABmAAAAPQAAAB4AAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAHAAAADQAA + ABQAAAAdAAAAJAAAACwAAAAwAAAAMwAAADUAAAA0AAAAMQAAACwAAAAmAAAAHgAAABYAAAAPAAAACAAA + AAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEICMWTCwuw/w8Pov8SEpX/DAxlsQAAAHoAAABqAAAASgAAACoAAAASAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAABAUFs00LC6//Dg6i/xERk/8UFIn/AAAAgAAAAGcAAAA9AAAAHgAA + AAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAEAAAACgAAABQAAAAfAAAALQAAADoAAABFAAAATwAAAFUAAABZAAAAWwAA + AFoAAABXAAAATwAAAEYAAAA8AAAAMAAAACQAAAAZAAAAEAAAAAgAAAAEAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUF1TQKCrX/DQ2o/xER + mf8TE4ftAAAAfAAAAHQAAABZAAAANwAAABoAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAEBwe8iQoK + r/8NDaP/ERGU/xMTif8AAACAAAAAZgAAAD0AAAAdAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAoAAAAXAAAAKAAA + ADsAAABOAAAAXgAAAGsAAABzAAAAeAAAAHwAAAB9AAAAfAAAAHoAAAB0AAAAbAAAAGEAAABTAAAARAAA + ADQAAAAkAAAAFwAAAA4AAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwkJvNEMDKz/Dw+f/xMTkf8JCVOjAAAAegAAAGcAAABFAAAAJAAA + AA8AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUHB7uJCgqv/w0No/8REZT/ExOK/wAAAH8AAABkAAAAOwAA + AB0AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMAAAAJAAAAFwAAACsAAABDAAAAWwcHTJMPD16+EhJh0hQUZeMVFWLkFRVf5BYW + XuQSEkrJCQkyrQAAAI8AAACJAAAAgQAAAHUAAABnAAAAVgAAAEMAAAAwAAAAIAAAABIAAAAJAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBwfKdAsL + sv8ODqX/EhKW/xEReNQAAAB+AAAAcgAAAFQAAAAxAAAAFwAAAAcAAAABAAAAAAAAAAAAAAAAAAAABQcH + vIkKCrD/DQ2j/xAQlP8TE4r/AAAAfQAAAGIAAAA5AAAAGwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAAABIAAAAmAQEtTQ0N + dq8SEoX3ExOC/xMTff8UFHr/FRV4/xYWdf8WFnL/Fxdw/xgYbf8ZGWr/GRll+RUVTdoEBB6kAAAAjwAA + AIUAAAB2AAAAZQAAAFEAAAA7AAAAKAAAABcAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAroVCgq3/wwMqf8QEJv/ExOO/wICLI4AAAB6AAAAYgAA + AD4AAAAgAAAADAAAAAIAAAAAAAAAAAAAAAAAAAAFBwe8iQoKsP8NDaT/EBCV/xMTi/8AAAB7AAAAXwAA + ADcAAAAaAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAALAAAAHRQUgm4TE5b1EBCQ/xERif8REYT/EhKB/xMTgf8TE4D/ExN+/xQU + e/8UFHb/FRVz/xcXbv8YGGv/GRlp/xoaZ/8VFUrbBAQdpQAAAI8AAACCAAAAcQAAAFsAAABEAAAALgAA + ABwAAAAOAAAABgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAIJCb+zCwuv/w4OoP8SEpP/Dw9txQAAAH8AAABuAAAATQAAACwAAAATAAAABQAAAAAAAAAAAAAAAAAA + AAUHB7yJCgqw/w0NpP8QEJX/EhJ/5wAAAHoAAABdAAAANgAAABkAAAAHAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABEXF4pVIiKo/w4O + mf8ODpP/Dw+Q/xAQjP8PD4z/EBCM/xAQi/8QEIr/ERGH/xIShP8TE3//FBR6/xUVdP8WFm7/GBhp/xoa + Zv8bG2b/ExM/zgAAAJYAAACKAAAAeQAAAGQAAABMAAAANAAAAB8AAAAQAAAABwAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQcH0GMKCrP/DQ2l/xERlv8TE4f2AAAAgQAA + AHgAAABcAAAAOAAAABsAAAAJAAAAAQAAAAAAAAAAAAAABQcHvIkKCrD/DQ2k/xAQlf8REXvfAAAAeAAA + AFsAAAA0AAAAGAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAGDQ1sJiIisecaGqf/Cwuc/wwMmv8MDJn/DAyY/wwMl/8MDJf/DAyW/w0N + lv8NDZP/Dg6R/w8Pjf8REYj/ExOC/xQUe/8VFXT/Fxds/xkZZ/8aGmX/GRlW7QcHJa0AAACQAAAAgAAA + AGoAAABRAAAANwAAACEAAAARAAAABwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABAkJuPAMDKv/EBCc/xMTjv8LC1evAAAAfgAAAGgAAABFAAAAJAAAAA4AAAADAAAAAAAA + AAAAAAAFBwe8iQoKsP8NDaX/ERGV/xERfN8AAAB2AAAAWQAAADMAAAAXAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgbG7eEISG0/xUV + q/8JCaT/CQmj/wkJov8KCqD/Cgqf/woKnv8KCp7/Cgqd/woKnP8LC5r/DAyX/w0Nk/8PD4//ERGJ/xMT + gf8UFHj/FhZw/xgYaf8aGmX/Gxtg+Q0NL7wAAACUAAAAgwAAAG4AAABUAAAAOQAAACIAAAAQAAAABwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCAjCowsLsP8ODqD/EhKS/xMT + feYAAACCAAAAcwAAAFIAAAAuAAAAFAAAAAUAAAAAAAAAAAAAAAUHB7yJCgqw/w0NpP8REZb/ERF83wAA + AHUAAABWAAAAMQAAABUAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACB8fvMsfH7j/ExOx/wgIqv8ICKr/Bweo/wgIpf8ICKT/Bwej/wgI + o/8ICKL/CAih/wkJoP8JCZ7/Cgqc/wwMmP8NDZP/Dw+O/xERhf8TE37/FRV0/xgYbP8ZGWX/Gxtj/xMT + Pc8AAACWAAAAhgAAAHAAAABVAAAAOQAAACEAAAAPAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEGBs9UCgqz/w0Npf8REZb/FBSK/wICK5EAAAB5AAAAXAAAADYAAAAZAAAABwAA + AAAAAAAAAAAABQcHu4kKCrD/DQ2k/xERlv8REXzeAAAAcwAAAFMAAAAvAAAAFAAAAAUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJHh6//x4e + u/8TE7X/Bgaw/wYGrv8HB6v/Bweo/wcHpv8GBqb/Bwem/wcHpv8HB6X/Bwek/wgIo/8ICKH/CQmf/woK + nP8MDJf/Dg6R/xAQiv8TE4D/FBR2/xcXbf8ZGWb/Gxtj/xUVSNsAAACXAAAAhwAAAG8AAABTAAAANgAA + AB4AAAANAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQJCbbhDAyo/xAQ + mP8TE4z/EBBoyAAAAHwAAABiAAAAOwAAAB0AAAAJAAAAAAAAAAAAAAAFBwe7iQoKsP8NDaT/ERGW/w0N + ab0AAABwAAAAUQAAACwAAAATAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgeHsL/HR29/xISuP8GBrT/Bgax/wYGrf8GBqr/Bgao/wYG + p/8GBqf/Bgan/wYGp/8GBqb/Bwem/wcHpf8HB6P/CAih/woKnv8LC5r/DQ2U/xAQjf8SEoP/FBR4/xcX + bf8YGGb/Gxtj/xUVR9sAAACWAAAAhQAAAG0AAABPAAAAMgAAABsAAAALAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwgIvZYMDKn/Dw+a/xISjv8TE37vAAAAfAAAAGIAAAA7AAAAHQAA + AAkAAAAAAAAAAAAAAAUHB7uJCwuv/w0NpP8QEJb/DQ1qvAAAAG4AAABOAAAAKgAAABIAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxwc + xP8cHMD/FRW8/wUFtv8FBbP/Bgau/wYGqv8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgam/wcH + pv8HB6T/CAii/wkJn/8KCpz/DAyW/w8Pjv8SEoT/FBR4/xYWbv8YGGb/Gxtj/xUVR9sAAACVAAAAggAA + AGgAAABKAAAALQAAABYAAAAIAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBASoQAsL + qf8ODpv/EhKP/xQUiP8EBD6SAAAAXgAAADcAAAAaAAAACAAAAAAAAAAAAAAABQcHu4kLC6//DQ2k/xER + lv8NDWq8AAAAbQAAAEwAAAApAAAAEQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFHBzF/xwcwv8aGr//BQW3/wUFtP8FBa//Bgar/wYG + qP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6X/Bwej/wgIof8KCpz/DAyW/w8P + j/8SEoT/FBR5/xYWbv8ZGWb/Ghpj/xAQM8IAAACSAAAAfgAAAGIAAABDAAAAJwAAABIAAAAGAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAZCwuo/w4Om/8SEo//ExOJ/wEBHH4AAABVAAAAMAAA + ABUAAAAFAAAAAAAAAAAAAAAFBwe7iQsLr/8ODqT/ERGV/wwMZLMAAABtAAAATAAAACkAAAAQAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAMcHMnWHBzE/xwcwf8HB7v/BQW2/wUFsf8GBqz/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGpv8HB6X/Bwej/wgIof8KCp3/DAyX/w4Oj/8SEoT/FBR4/xcXbf8ZGWb/Gxtk/woK + KbUAAACPAAAAeAAAAFoAAAA7AAAAIAAAAA0AAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADAYG + oWYLC6b/Dg6Z/xERj/8TE4LvAAAAbQAAAEoAAAAoAAAAEAAAAAMAAAAAAAAAAAAAAAUHB7uJCwuu/w4O + o/8REZX/BgZKmgAAAG0AAABNAAAAKgAAABEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARsbzqkcHMT/HBzC/w4OvP8FBbf/BQWz/wYG + rf8GBqr/Bgao/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpv8HB6b/Bwek/wgI + of8KCp3/DAyX/w8Pj/8SEoP/FBR4/xcXbv8ZGWb/Gxtg+QQEHKYAAACKAAAAcQAAAFEAAAAxAAAAGAAA + AAgAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAASCQmnrwsLo/8ODpf/ERGP/w8Pcs4AAABkAAAAPwAA + ACAAAAALAAAAAQAAAAAAAAAAAAAABQcHu4kLC67/Dg6j/xERlP8GBkicAAAAcAAAAFAAAAAsAAAAEwAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABGBjWWRwcx/8cHMP/GhrA/wUFuf8FBbT/BQWw/wYGq/8GBqn/Bgao/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6b/Bwek/wgIof8KCp3/DAyW/w8Pjv8SEoP/FBR2/xgY + bP8aGmX/GRlW7QAAAJYAAACDAAAAZgAAAEQAAAAmAAAAEAAAAAUAAAABAAAAAAAAAAAAAAABAAAACAAA + ABoKCqfyDQ2e/w8Plf8REY3/CAhVoAAAAFgAAAA0AAAAGAAAAAcAAAABAAAAAAAAAAAAAAAFBwe7iQsL + rv8ODqH/EhKT/wYGSJ0AAABzAAAAVQAAADAAAAAVAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGxvJ8Rwcxf8cHMP/Cwu9/wUF + t/8FBbL/Bgat/wYGqv8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8HB6b/Bwek/wgIof8KCpz/DQ2V/xAQjP8TE4D/FRV0/xgYaf8bG2T/ExM/zgAAAJEAAAB4AAAAWQAA + ADcAAAAbAAAACgAAAAIAAAAAAAAAAAAAAAMAAAAOBwejdgsLpv8NDZz/EBCS/xISjf8AAABtAAAASwAA + ACkAAAARAAAABAAAAAAAAAAAAAAAAAAAAAUHB7uJCwuu/w4Oof8SEpL/DQ1lvwAAAHcAAABaAAAANAAA + ABgAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEaGtKoHBzI/xwcxP8VFcD/BQW6/wUFtP8FBbD/Bgas/wYGqf8GBqj/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/Bwej/wkJoP8LC5v/DQ2T/xAQ + iv8TE37/FhZw/xkZZ/8bG2X/BAQdpgAAAIcAAABrAAAASQAAACkAAAAS/////wAAAAEAAAAAAAAABQAA + ABUJCae9DAyi/w0NmP8QEJD/Dw951gAAAGIAAAA+AAAAHwAAAAsAAAABAAAAAAAAAAAAAAAAAAAABQcH + u4kLC67/Dg6h/xISkf8ODmPBAAAAfAAAAGEAAAA6AAAAHAAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQU3iYcHMr/GxvF/xwc + xP8MDL3/BQW3/wUFsv8GBq7/Bgaq/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGpv8HB6X/CAij/wkJn/8LC5r/Dg6R/xERhf8UFHn/Fxdt/xoaZv8YGFLnAAAAkgAA + AHsAAABaAAAAOAAAABsAAAAKAAAAAQAAAAEAAAAKAwOAOAsLqf8MDJ//Dg6V/xERj/8ICFagAAAAVQAA + ADIAAAAXAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAEBwe8iQsLrv8ODqH/EhKR/xERa9EAAACCAAAAaAAA + AEIAAAAiAAAADAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAARoa0qgbG8n/GxvE/xkZwf8GBrn/BQW2/wUFsf8GBqz/Bgaq/wYG + qP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpv8HB6X/CAii/woK + nv8MDJf/Dw+O/xMTgf8VFXT/GBhp/xoaZv8KCiyzAAAAhwAAAGsAAABIAAAAJwAAABAAAAAEAAAAAwAA + AA8ICKaECwum/w0Nm/8PD5P/ERGK9wAAAGsAAABIAAAAJwAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAQHB7yJCwuw/w4Oov8SEpL/ExN46QAAAIcAAABxAAAATAAAACoAAAARAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBTeJhwc + y/8bG8f/HBzE/xMTwP8FBbj/BQWz/wUFsP8GBqz/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6T/CAih/woKnP8NDZT/EBCK/xMTfP8XF2//GRln/xcX + VOcAAACRAAAAeAAAAFcAAAAzAAAAGAAAAAgAAAAHAAAAFQoKq+UMDKL/DQ2Z/xAQkv8PD3bNAAAAXgAA + ADsAAAAdAAAACgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAwcHv4gKCrL/DQ2l/xERlP8UFIb/AAAAjAAA + AHoAAABXAAAAMwAAABcAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHh7Vix8fyv8dHcX/HBzD/w4Ovf8FBbf/BQWy/wUF + r/8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcH + pv8HB6P/CQmf/wsLmf8ODpD/EhKD/xQUdv8XF2v/Ghpn/woKLrEAAACDAAAAZQAAAEAAAAAhAAAADQAA + AAsFBZZFCwuq/wwMoP8ODpb/EBCQ/wQEQ4wAAABRAAAALgAAABUAAAAGAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACBwfEhgoKtf8MDKj/EBCX/xMTiP8JCUayAAAAggAAAGQAAAA/AAAAIQAAAAwAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADJCTP1iQkyv8hIcf/Hx/D/w4OvP8FBbb/BQWx/wYGrv8GBqv/Bgap/wYGqP8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgam/wcHpf8ICKH/Cgqd/w0Nlf8QEIv/ExN9/xcX + b/8ZGWn/FhZR4QAAAIwAAABwAAAATAAAACkAAAATAAAAEAkJqZ4LC6f/DQ2d/w8Plf8REYjuAAAAZwAA + AEQAAAAkAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEHB8qECQm4/wsLrf8PD5v/ExOM/xAQ + Yc0AAACIAAAAcAAAAE0AAAAsAAAAFAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEnJ+I6LCzO/ygoyv8oKMX/JibE/xAQ + vP8FBbb/BQWy/wYGrv8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bwem/wcHpP8JCaD/Cwua/w4OkP8SEoP/FRV2/xgYbf8ZGWv/AQETmAAAAHgAAABVAAAAMAAA + ABkAAAAVCgqq5AsLpP8NDZv/Dw+T/wsLZ7EAAABbAAAANwAAABsAAAAIAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQUF00QICLv/Cgqx/w0Nov8SEpL/ExOB9wAAAIsAAAB7AAAAXAAAADoAAAAdAAAACgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAExMd5wMDDO/y4uyv8tLcj/KyvF/xMTvf8FBbb/BQWy/wYGrv8GBqv/Bgap/wYG + qP8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bwel/wgIof8KCpz/DQ2U/xAQ + iv8UFHv/FhZw/xgYbP8ODj69AAAAfwAAAF0AAAA2AAAAHgMDfzcLC6n/DAyi/w4Omf8REZL/AgIzgQAA + AFAAAAAtAAAAFAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPbIwcHv/8JCbb/DAyp/xAQ + mf8TE4v/CQlLrAAAAIIAAABrAAAASgAAACoAAAASAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzM9evNDTP/zMz + zP8yMsr/MDDI/xcXv/8FBbb/BQWy/wYGrv8GBqv/Bgaq/wYGqP8GBqj/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wYGp/8HB6b/Bwej/wkJn/8MDJj/Dw+P/xMTgf8VFXX/Fxdu/xMTU9kAAACDAAAAYwAA + ADoAAAAiBweeZAsLpv8MDKD/Dw+Y/w8PfNUAAABrAAAASQAAACcAAAAQAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABBgbLoggIuv8KCq//Dg6g/xISkv8TE3neAAAAggAAAHYAAABaAAAAOQAA + AB0AAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI5OdbMOjrQ/zg4zv83N8v/NTXJ/yIiwf8FBbb/BQWy/wUF + r/8GBqz/Bgaq/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/CAih/wsL + m/8ODpL/EhKF/xQUef8XF3H/Hh5t8wAAAIUAAABmAAAAPQAAACQKCqGQDAyk/w0Nnf8QEJX/CgpdqgAA + AGkAAABGAAAAJQAAAA4AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAs8TBwfB4AkJ + tv8MDKn/EBCb/xMTj/8GBkicAAAAewAAAGgAAABKAAAAKgAAABMAAAAGAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMz + 2Bg+PtXbPz/R/z4+z/89Pc3/OzvL/y8vxP8ODrj/BQWz/wUFsP8GBq3/Bgar/wYGqf8GBqj/Bgao/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8ICKL/Cgqc/w0Nlf8REYj/FBR8/xcXdP8qKn//AAAAiAAA + AGkAAABAAAAAJwsLn6wMDKD/Dg6Z/xAQjfYBARuCAAAAbAAAAEoAAAAoAAAAEAAAAAMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEBNszCAi8/wsLsf8ODqP/ERGW/xISf9sAAAB6AAAAcwAA + AFoAAAA7AAAAHwAAAAwAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMz2BhCQtbbRETS/0NDz/9BQc3/Pz/K/zs7 + yP8gIL//BQW0/wUFsv8FBa//Bgas/wYGqv8GBqn/Bgao/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgam/wcH + o/8KCp7/DAyX/xAQi/8VFYD/JiZ//ywsgP8AAACLAAAAbgAAAEgAAAAuDAycyQ0NnP8PD5X/ERGK9gAA + AH0AAABxAAAAUQAAAC4AAAAUAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEGBtRjCQm4/wwMrP8PD6D/ExOT/wcHTZUAAAB3AAAAaQAAAE0AAAAuAAAAFgAAAAcAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADAAAABQAAAAcAAAAGAAAABAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAATMz2BhDQ9m0SkrT/0hI0f9HR87/RETN/0NDzP87O8j/Gxu9/wUFs/8FBbH/Bgau/wYG + rP8GBqv/Bgaq/wYGqf8GBqj/Bgao/wYGqP8GBqj/Bwel/wkJn/8MDJj/ExOP/ywsjv8xMYb/MDCD/wAA + AI4AAAB1AAAAUwAAADsNDZLMDg6W/xAQkP8TE4j/BQU3mQAAAHgAAABbAAAANgAAABkAAAAIAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMeiCgq0/w0NqP8REZr/EhKE2AAA + AHUAAABzAAAAXwAAAEAAAAAjAAAADwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAoAAAAQAAAAFAAA + ABQAAAAQAAAACgAAAAUAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJFRdqnUFDU/05O + 0v9LS9D/S0vP/0lJzf9HR8v/PT3H/yAgvf8NDbT/BQWx/wUFr/8GBq3/Bgas/wYGq/8GBqr/Bgaq/wYG + qv8HB6f/ERGm/yUlp/81NaL/NjaW/zY2jP82Noj/AAAAkQAAAH0AAABiAAAATwwMfrAPD5D/ERGK/xMT + gv8ODlK8AAAAgAAAAGYAAABAAAAAIQAAAAwAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMJCb3RCwuv/w8Pof8TE5X/CgpgpQAAAHgAAABuAAAAVAAAADQAAAAZAAAACQAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAAIAAAAEgAAAB8AAAApAAAAKwAAACYAAAAcAAAAEgAAAAkAAAAFAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFEROFmUlLV9VNT1P9RUdL/UFDQ/05Ozv9MTM3/S0vM/0pK + yv87O8T/Kiq9/xwcuf8UFLX/ExOz/xQUsv8bG7T/JCS2/zU1uf85Obj/Ojqz/zs7qv88PKD/PT2T/zY2 + i/8JCTCuAAAAhQAAAHQAAABoDAxosg8Pi/8SEoX/FBR9/xMTYdwAAACHAAAAcQAAAEwAAAAqAAAAEgAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUF2DMLC7LwDg6l/xER + mP8TE4j1AQEZgQAAAHkAAABmAAAARgAAACcAAAARAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAwAAAAbAAAALgAA + AD4AAABFAAAAQQAAADUAAAAnAAAAGgAAABAAAAAIAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAFCQuMtVlbax1hY1v9WVtT/VVXS/1NT0P9RUc//UFDO/05Ozf9MTMv/TEzK/0pKyf9ISMf/RkbH/0RE + xP9CQsT/QUHC/0FBv/9AQLr/QUGy/0FBqf8+Ppz/GhqC/xISZeQAAACMAAAAgwAAAH4ICDufEBCF/xIS + gv8VFXj/Fxdy/wAAAI8AAAB7AAAAWgAAADgAAAAdAAAACgAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAwoKu4UNDab/EBCY/xMTjP8REWfEAAAAgQAAAHUAAABZAAAANgAA + ABoAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAADQQElkcAAAA0AAAASQAAAFUAAABXAAAATgAAAEEAAAAzAAAAJQAA + ABkAAAAQAAAACAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSkriaFlZ1+pcXNb/WlrU/1dX + 0v9WVtH/VVXQ/1RUz/9SUs7/UFDN/05OzP9MTMv/TEzK/0pKyf9ISMf/R0fD/0ZGv/9GRrr/Rkay/yAg + mP8REYX/Dw9d1gsLQboPD4L/Dg59+AgIMK4PD4T/EhJ//xUVdf8XF2//DAw2twAAAIYAAABrAAAASwAA + AC4AAAAYAAAACwAAAAUAAAADAAAAAgAAAAQAAAAGAAAACAAAAAoAAAALAAAADQAAAA4AAAAPAQFsIw0N + o/EQEJj/ExOL/xUVgf8FBTWdAAAAgQAAAGgAAABEAAAAJAAAAA4AAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAILC8KjDg60/w8P + q+UFBXRyAAAAUwAAAFwAAABcAAAAVgAAAEwAAAA/AAAAMQAAACQAAAAZAAAAEAAAAAoAAAAFAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAA01N3ntcXNjrYGDW/15e1f9cXNT/WlrR/1hY0f9WVs//VlbP/1RU + zv9SUsz/UFDL/09Pyv9NTcj/TU3E/0xMwP8jI6z/DAyb/w4OkP8EBCGaDg6I/w4OiP8ODof/DQ2B+Q8P + fvkSEoD/FBR2/xcXbv8UFEvaAAAAkQAAAH0AAABiAAAARgAAAC4AAAAcAAAAEgAAAA0AAAANAAAAEQAA + ABUAAAAaAAAAHgAAACEAAAAjAAAAJAAAACYAAAApDAyVsw8Plf8TE4r/FRWB/xQUa+IAAACIAAAAcQAA + AE0AAAAqAAAAEgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQsLw8EMDLj/DQ2y/w8Pq/8ODpzEAgJFZAAAAFgAAABbAAAAWgAA + AFQAAABKAAAAPgAAADIAAAAmAAAAGwAAABMAAAAMAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA + AANMTN9pVlbYu2Bg1fZiYtT/YGDT/15e0f9cXM//W1vO/1lZzP9XV8z/VlbL/1RUyv9OTsX/FBSx/wkJ + qf8KCqP/CwuD1A0Nmf8MDJX/DQ2U/wwMkv8NDZD/Dg6M/xERhv8TE3n/FhZu/xkZY/kCAhCgAAAAjQAA + AHoAAABkAAAATAAAADcAAAAoAAAAIQAAACMAAAAoAAAAMAAAADcAAAA8AAAAQAAAAEQAAABGAAAARwAA + AEoJCXCSDw+S/xISi/8UFIL/FhZ+/wcHQKYAAABzAAAATwAAACwAAAATAAAABAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQXhMgsL + v+AMDLj/DQ2y/w4OrP8QEKb/Dg6XuAICRWQAAABXAAAAWgAAAFkAAABTAAAASwAAAEAAAAA1AAAAKgAA + AB8AAAAWAAAADwAAAAkAAAAFAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABUhI1VpQUNKfVlbPvVlZ + zNdYWMjYV1fI2FVVx9hRUcXMR0e/pBMTsdcGBq3/Bweq/wYGeo0KCqD2Cwuj/wsLoP8LC5z/Cgqa/wwM + mP8NDYX0EBCL/xMTgP8UFHP/GBhp/xMTOs8AAACaAAAAjwAAAH4AAABrAAAAVwAAAEcAAABAAAAAQgAA + AEoAAABVAAAAXgAAAGQAAABoAAAAawAAAG0AAABvAAAAcAYGSZcODpD/ERGM/xMThv8VFYL/ExNw2AAA + AGkAAABHAAAAJgAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgYG1kQLC77CDAy0/w0Nr/8PD6r/EBCl/wwM + kaACAkVjAAAAVQAAAFkAAABZAAAAVQAAAE8AAABFAAAAOgAAADAAAAAkAAAAGwAAABQAAAANAAAACAAA + AAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMAAAAHAAAADAAAABIAAAAXAAAAHQAAACIAAAAkAAAAJQAAACQAAAAhAAAAHgQE + lFkGBqS9Bwen8wgIq/8ICKr/CQmo/wkJpf8KCqL/Cgqf/wsLg+4ODoP0ERGH/xMTev8VFW3/GBhn/xkZ + XPMPDzXBAAAAkgAAAIUAAAB2AAAAaQAAAGQAAABoAAAAbwAAAHgAAAB/BQU0mwcHPaUHBz2mBgY9qAYG + PqgGBj+oCQlavQ4Okv8QEJD/EhKM/xMTiP8SEn7bAAAAVwAAADgAAAAdAAAADAAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIGBtVECwu9wgwMs/8ODq//Dw+q/xAQpf8ODpi3AgJGYgAAAFUAAABaAAAAXAAA + AFoAAABVAAAATAAAAEIAAAA3AAAALAAAACEAAAAZAAAAEgAAAAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAYAAAAKAAAAEAAAABcAAAAfAAAAJwAA + AC8AAAA1AAAAOgAAADwAAAA9AAAAOwAAADcAAAAxAAAAMB0dsP8GBqn/CAis/wcHrf8ICKz/Bwep/wgI + pv8REaX/GRmk/wwMl/8PD4//EhKC/xQUd/8WFm3/GBho/xkZZ/8VFUnbAAAAmAAAAI8AAACHDQ1IsRMT + XtEUFHHwFRV8/xUVfP8UFH3/ExOC/xERiP8QEI3/DQ2S/wwMk/8MDJX/DQ2U/w4Olf8REZH/EhKR/xAQ + hcAAAAA+AAAAJgAAABIAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACBgbVRAsL + vcIMDLT/DQ2v/w4Oqv8QEKb/Dw+dzwgIdoMAAABWAAAAXQAAAGEAAABgAAAAXAAAAFUAAABLAAAAPwAA + ADQAAAApAAAAHwAAABcAAAAQAAAACgAAAAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAACAAAABQAA + AAgAAAAOAAAAFAAAAB0AAAAmAAAAMQAAAD0AAABIAAAAUwAAAFsAAABiAAAAZAAAAGUAAABjAAAAXgAA + AFcAAABRS0u7/xgYrf8HB6z/Bwev/wcHrv8GBqv/JCSy/zU1tP8JCaL/Cgqd/w0Nlf8PD4z/EhKB/xMT + ef8VFXH/FhZt/xcXa/8SEj3QEBA6yBUVbfkUFHb/ExN6/xMTfv8TE4D/ExOD/xIShf8REYr/Dw+Q/w4O + lv8MDJn/Cwub/wsLmv8MDJr/DQ2a/w8Pmf8REZj0AQE2RQAAACUAAAAVAAAACQAAAAMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgYG1UQKCsGkDAy0/w0NsP8ODqv/EBCm/w8P + n+cLC4mmAgI+bQAAAGIAAABmAAAAZwAAAGQAAABdAAAAVAAAAEkAAAA9AAAAMQAAACcAAAAeAAAAFgAA + ABAAAAAKAAAABwAAAAUAAAAGAAAACAAAAA0AAAATAAAAGgAAACMAAAAuAAAAOgAAAEcAAABUAAAAYAAA + AGsAAABzAAAAeAAAAHoAAAB8AAAAfAAAAHwAAAB6AAAAdgAAAHNJSabdWlrA/0xMwf8xMbz/MDC8/0ZG + wP87O7v/DAyp/wgIpP8JCaH/Cgqb/w0Nlf8PD47/ERGF/xMTfv8TE3f/FBR0/xMTdP8TE3f/ExN5/xIS + ff8REYP/EBCH/w8Piv8PD4//Dg6S/w0Nlv8NDZr/DAyf/woKoP8KCqH/Cgqg/wsLof8NDaL/Dg6h5gUF + fFQAAAAeAAAAEgAAAAkAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIEBNQkCgrDowwMtf8NDbD/Dg6s/w8Ppv8QEKH/Dw+U0wkJcpkBAR9uAAAAawAA + AG0AAABrAAAAZgAAAF4AAABTAAAASAAAADwAAAAwAAAAJgAAAB0AAAAXAAAAFAAAABUAAAAbAAAAIgAA + ACwAAAA3AAAAQwAAAFAAAABeAAAAaQgIVp8MDHHFEBCD5xERkP8REZD/ERGQ/xERkP8PD4nvDAx2zwcH + WbECAiuSAAAAgwwMIo5UVK7pY2PH/2Bgyv9TU8X/ICC1/wcHq/8HB6j/Bwem/wgIo/8JCaD/Cgqc/wwM + l/8ODpL/Dw+L/xAQhv8REYT/ERGC/xERg/8REYX/Dw+I/w8Pi/8ODo7/DAyS/wwMlv8LC5n/Cwue/woK + of8KCqT/CQmm/woKp/8KCqj/Cwun5QkJo5QAAAAdAAAAFAAAAAwAAAAGAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBATUJAoK + w6MMDLX/DAyx/w4Oq/8PD6b/EBCh/xISmfQPD4XCCAhglwAAAG8AAABzAAAAcwAAAG8AAABoAAAAXgAA + AFMAAABGAAAAOwAAADIAAAAuAAAAMAAAADcAAABBAAAATQAAAFoAAABmBARBiw0NccQREYbvERGP/xAQ + kP8QEJL/EBCT/w8PlP8PD5X/Dw+V/w8Pl/8ODpj/DQ2Z/wsLmv8JCZLvBwd1yQICOZ0MDCGTExNTrQYG + r/8GBq3/Bgar/wYGqf8HB6j/Bwem/wgIo/8ICKH/Cgqd/wsLmv8MDJf/DQ2T/w4Okf8ODpD/Dg6P/w4O + jv8ODo3/DAyO/wwMkP8LC5P/CwuY/wsLnP8KCqH/CQml/woKqP8KCqnyCQmorgcHoWUAAAAXAAAAEQAA + AAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQE1CQJCcSjCwu2/wwMsf8NDav/Dg6m/xAQ + of8REZz/EhKS9Q4Oeb0EBEKMAAAAdwAAAHkAAAB3AAAAcQAAAGkAAABfAAAAVwAAAFIAAABVAAAAXAAA + AGYBARx3CwtlshAQgucREY7/EBCQ/w8Pkv8PD5T/Dg6W/w4Omf8NDZz/DQ2e/w0NoP8NDaH/DAyj/wwM + o/8LC6P/Cgqj/wkJpP8ICKX/Bwep/wcHo+8GBqXwBgax/wYGr/8GBqz/Bgaq/wYGqf8HB6f/Bwel/wcH + o/8ICKL/CQmg/woKnv8KCpz/Cwub/wsLmv8LC5b/DAyT/wsLjf8LC4z/CwuL/wsLjv8LC5P/CwuV6AoK + mMAJCZqFBQWOSAAAABcAAAATAAAADwAAAAsAAAAIAAAABQAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEEBNojCQnFkwoKt/ALC7L/DQ2t/w4Op/8PD6D/ERGb/xISlv8SEorsDw9xwgQE + PZMAAAB+AAAAfQAAAHoAAAB2AAAAdQEBGn0KCl2qDw951hERj/8QEJD/Dw+S/w4OlP8ODpf/DQ2Z/w0N + nf8MDKH/Cwuk/wsLqP8LC6fYCgqt/woKrv8JCa//Cgqv/wkJrv8ICK7/Bwev/wcHsP8GBrH/Bgaz/wUF + s/8GBrT/Bgaw/wYGrv8GBqv/Bgap/wYGqP8GBqb/Bwem/wcHpf8HB6T/CAii/wgIof8JCaD/Cgqe/woK + mv8LC5L/CwuJ/woKXNsKClDKBwc7oQEBHXEAAABMAAAANAAAACQAAAAbAAAAFwAAABYAAAAVAAAAFAAA + ABIAAAAPAAAACwAAAAcAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLEFAgI + yYQKCrjwCwuz/wwMrv8NDaj/Dw+i/xAQm/8SEpb/EhKR/xIShOUMDGG2AgIsjwgIT6kPD3fYERGO/xER + kP8QEJL/Dw+V/w4Ol/8NDZr/DAyd/wwMoP8LC6T/Cwuo/wsLqNgICKWFAwOBOQAAABUAAAAQBQW/SggI + wJYHB7zSCAi6/wcHuf8GBrn/Bga4/wYGt/8FBbf/BQW3/wUFtv8GBrT/BQWx/wYGrf8GBqr/Bgap/wYG + qP8GBqf/Bgam/wcHpv8HB6X/Bwek/wgIov8ICKH/Cgqa/wsLkf8MDIX/DAxV3AAAAJoAAACLAAAAdQAA + AFwAAABGAAAANQAAAC4AAAAsAAAALAAAAC0AAAAtAAAAKgAAACUAAAAfAAAAFwAAAA8AAAAIAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQICzhMICM10CQm74QoKtP8MDK//DAyp/w4O + pP8PD57/EBCa/xAQl/8QEJb/EBCV/xAQlf8PD5b/Dg6X/w0Nm/8MDJ7/DAyh/wsLpP8LC6j/Cgqp5QkJ + qaEEBJJJAAAAFwAAABAAAAAKAAAABgAAAAMAAAACAAAAAgAAAAMBAbEWBQXNZgUFxLQFBb//BQW9/w8P + vP8EBLn/BQW4/wUFt/8FBbP/BQWw/wYGrP8GBqr/Bgao/wYGp/8GBqf/Bgan/wYGp/8HB6b/Bwek/wgI + of8KCpv/DAyP/w0Ng/8PD3r/Dw9S2wAAAJcAAACJAAAAdgAAAGQAAABXAAAAUAAAAE8AAABQAAAAUQAA + AFAAAABNAAAARgAAAD0AAAAxAAAAJAAAABgAAAAOAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAABAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAHAAAABQAAAAQAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADBwfQZAkJvOEKCrb/Cgqx/wsLrf8MDKn/DQ2m/w0NpP8NDaL/DAyh/wwM + of8MDKL/Cwul/wsLqP8KCqnyCQmprwYGpGYAAAAYAAAAEQAAAAsAAAAHAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAAgICuhUEBMx2FhbC8RISv/8EBLv/BQW5/wUFt/8FBbH/Bgau/wYG + qv8GBqn/Bgao/wYGp/8GBqf/Bgan/wcHpv8HB6T/CAih/woKmv8MDJD/Dg6D/xERef8SEnP/ERFP2wAA + AJgAAACOAAAAgwAAAHoAAAB0AAAAcgAAAHEAAABwAAAAbgAAAGsAAABmAAAAXgAAAFIAAABCAAAAMQAA + ACIAAAAUAAAACwAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAIAAAADAAAABQAAAAcAAAAIAAAACwAAAA4AAAAQAAAAEwAAABUAAAAXAAAAFwAA + ABYAAAAUAAAADgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwYG + 0lQICMDCCQm4/wkJtf8KCrP/Cgqx/woKr/8KCq3/Cgqt/woKrfIJCauvBgalZQAAABgAAAASAAAADAAA + AAcAAAAEAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAIgINOMHh7F/xAQv/8EBLr/BQW4/wUFtP8FBa//Bgas/wYGqf8GBqj/Bgan/wYGp/8GBqf/Bwem/wcH + pP8ICKH/Cgqc/wwMk/8PD4f/ERF9/xISdf8UFHD/ExNL3AcHIa4KCi2wDw9GwRAQUcYQEFbEDw9awQ8P + X74KClCjAQEafgAAAHUAAABzAAAAbAAAAGEAAABRAAAAPgAAACwAAAAbAAAAEAAAAAgAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAEAAAABQAAAAgAAAAKAAAADQAAABEAAAAUAAAAGAAA + ABwAAAAgAAAAJAAAACgAAAAsAAAALwAAADEAAAAyAAAALgAAACYAAAAcAAAAEAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIFBdY0CAjDpAgIvPAJCbr/CQm44ggI + tpsGBq9hAAAAFQAAABAAAAALAAAABwAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEh0xYqKsvyJCTF/xkZvv8MDLj/BQW0/wUF + sf8GBq3/Bgaq/wYGqf8GBqj/Bgao/wYGqP8GBqb/Bwel/wgIov8JCZ3/CwuX/w4Ojv8QEIP/EhJ7/xMT + df8UFHP/FRVz/xUVcv8VFXX/FRV2/xUVeP8UFHz/FBSA/xQUg/8VFYb/ERFzyQMDMIUAAAB2AAAAdQAA + AGwAAABcAAAASgAAADYAAAAkAAAAFgAAAAwAAAAHAAAABAAAAAQAAAAFAAAABwAAAAgAAAALAAAADgAA + ABIAAAAVAAAAGgAAAB8AAAAjAAAAKQAAAC4AAAA0AAAAOQAAAD8AAABEAAAASQAAAE0AAABQAAAAUQAA + AE8AAABIAAAAOwAAACoAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAUAAAAHAAAACAAAAAcAAAAFAAAAAwAAAAEAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAS0t218vL8n/KSnB/yMjvf8cHLr/ERG0/wUFr/8GBqz/Bgaq/wYGqf8GBqn/Bgap/wYG + qP8HB6b/Bwej/wkJoP8KCpv/DAyV/w4Ojf8QEIb/EhKB/xMTfv8UFHz/FBR6/xQUe/8TE3r/ExN7/xMT + fv8TE4T/ExOJ/xMTjf8TE47/ExON/w8Pc78BARp+AAAAeAAAAHMAAABmAAAAVQAAAEAAAAAuAAAAIAAA + ABcAAAATAAAAEgAAABQAAAAXAAAAGwAAACAAAAAlAAAAKgAAADAAAAA2AAAAPQAAAEQAAABLAAAAUgAA + AFkAAABeAAAAYwAAAGYAAABoAAAAaAAAAGcAAABkAAAAXwAAAFMAAABDAAAAMAAAABsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABS4uyHk0NMP/Li6+/yoq + vP8kJLv/GRm2/wkJrv8GBqz/Bgas/wYGq/8GBqv/Bgaq/wcHqP8HB6X/CAii/wkJn/8KCpv/DAyX/w4O + kv8PD43/EBCJ/xERiP8SEoX/EhKB/xISfv8SEn3/EhKB/xAQiP8QEJD/EBCV/xAQl/8SEpb/ExOT/xMT + h+wHB02VAAAAeQAAAHcAAABuAAAAXwAAAE0AAAA9AAAAMQAAACwAAAAsAAAALgAAADMAAAA5AAAAPwAA + AEYAAABNAAAAVQAAAFwAAABiAAAAaAAAAGwAAABwAAAAcwQEQY4GBk6XDAxvuQwMcbgPD3zIERGH2RER + i9gREZDWCgqHmgAAADsAAAAoAAAAFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAHAAAAFxgYr6szM77/NTW+/y4uvP8pKbr/ISG1/woKrv8FBa7/BQWu/wYG + rf8GBqz/Bgar/wcHqP8HB6X/CAii/wkJoP8KCp3/Cwua/wwMl/8NDZT/Dg6R/xAQjP8REYb/Dw9e4ggI + L7AGBjKYAAAAYggIZ3EPD5nkDg6d/w8Pnf8REZn/EhKU/xMTjf8QEHC+AQEafgAAAHkAAAB1AAAAagAA + AF4AAABUAAAATwAAAE8AAABTAAAAWQAAAF4AAABkAAAAaQAAAG4AAABxAgIvhggIVqENDWy7EBB61RIS + h+4SEpD/EhKS/xISk/8REZX/ERGW/xISmP8SEpr/EhKd/xISof8REaPyAAAAKAAAABsAAAAOAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAA + AAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAsCAnw6BQWw8woK + r/8mJrf/Ojq7/zU1uf8uLrb/Jia1/xAQsP8FBa//BQWx/wUFr/8GBq3/Bgar/wcHqP8HB6b/Bwej/wgI + of8JCaD/Cgqd/wsLmv8MDJb/Dg6P/xAQh/8PD4H/BgYlrQAAAIUAAABoAAAARQAAACkLC6KNDQ2i/w4O + n/8QEJn/EhKT/xMTjP8TE4X1CQlUngAAAHgAAAB4AAAAdQAAAHAAAABuAAAAbQAAAG8AAABzBARBjgkJ + XqoODnHEEBCA3hERi/cREZD/ERGS/xERk/8QEJT/EBCW/w8Pmf8PD5r/Dw+c/w8Pn/8PD6D/Dw+i/xAQ + pP8QEKTlDQ2poAUFlkgAAAAVAAAADQAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAACAAAABAAAAAcAAAAIAAAACgAAAAsAAAAMAAAADQAAAA4AAAAPAAAADwAA + AA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAA + AA8AAAAPAAAADgAAAA0AAAAMAAAACgAAAAkAAAAIAAAABgAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAAEAUFsa4GBrD/Bgar/wUFqP8VFar/ODi0/zo6tf8zM7X/LS24/xIS + tP8FBbP/BQWz/wUFsP8GBq3/Bgaq/wYGqP8HB6f/Bwel/wcHo/8ICKH/Cgqd/wsLmf8NDZD/EBCH/xAQ + fv8QEGPnAAAAjQAAAHMAAABSAAAANQAAACUGBoZLDAye1w4OnP8QEJb/ERGR/xISjf8TE4r/EhJ82gMD + L4QHB0qYCAhVog0NbLsPD3fMEBCE5hISkP8REZH/ERGT/xERlP8QEJb/EBCX/w8Pmf8ODpv/Dg6d/w0N + oP8NDaL/DQ2k/wwMpv8NDaj/DAyq/wwMqsoLC6qQBQWaRQAAABQAAAAPAAAACgAAAAcAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAgAAAAOAAAAFQAA + ABoAAAAeAAAAIAAAACIAAAAkAAAAJQAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAA + ACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAmAAAAJgAAACYAAAAkAAAAIwAAACEAAAAgAAAAHQAA + ABoAAAAVAAAAEAAAAAoAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBAWsiBwe1/wcH + rv8GBqn/Bgaj/wYGnv8KCo/oNTWa0T4+uf84OLv/MTG9/xoauf8FBbX/BQWz/wUFr/8GBqz/Bgaq/wYG + qP8GBqb/Bwel/wcHo/8JCaD/Cwub/w0Nkv8QEIj/ERF9/xMTef8GBiinAAAAfgAAAGIAAABKAAAAPQAA + ADoAAAA+CgqFog8Pl/8QEJP/ERGQ/xERj/8SEpD/EhKR/xERk/8REZT/EBCV/xAQl/8PD5f/Dw+Z/w4O + m/8ODpz/Dg6e/w0Nof8MDKP/DAyl/wwMp/8MDKn/Cwur/wsLrPIKCqy7CQmujwUFp1MAAAAUAAAAEAAA + AAwAAAAIAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAHAAAADwAAABsAAAApAAAAMwAAADsAAAA/AAAAQgAAAEQAAABGAAAASAAA + AEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAA + AEgAAABIAAAARwAAAEYAAABEAAAAQQAAAD8AAAA8AAAANwAAADAAAAAlAAAAGQAAAA8AAAAHAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAABQUFuG0HB7T/Bwet/wcHp/8ICJ//CAia/wMDSJ8AAABfPDyvw0RE + wf89PcL/NzfC/x8fvP8ICLX/BQWy/wYGrv8GBqv/Bgap/wYGqP8GBqb/Bwek/wgIof8KCpz/DQ2S/xAQ + h/8REX3/ExN2/w8PR8sAAACHAAAAcwAAAGIAAABcAAAAXQAAAGIAAABmAwM2dw0NhNYPD5H/Dw+S/w8P + lf8PD5j/Dw+d/w4On/8NDaH/DQ2i/wwMo/8MDKX/DAym/wsLqP8LC6r/Cwut/woKrv8KCq7JCQmvnQcH + sHADA5UyAAAAEgAAAA4AAAAKAAAABwAAAAUAAAADAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAkAAAAWAAAAKQAA + AD0AAABOAAAAWgAAAGIAAABnAAAAagAAAG0AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbwAA + AG8AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbwAAAG8AAABvAAAAbQAAAGsAAABqAAAAaAAA + AGQAAABeAAAAUwAAAEQAAAAzAAAAIgAAABQAAAAKAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAHBga4iwgI + s/8ICKz/CAil/wkJnP8JCYzxAAAAeAAAAFUAAAAyRETBu0hIyP9CQsf/PT3F/y0twf8QELb/BQWw/wYG + rP8GBqr/Bgap/wYGqP8HB6b/CAii/woKnf8NDZT/EBCK/xISff8TE3X/ExNX4AAAAJEAAACEAAAAewUF + NZMHB0CdAAAAggAAAIQAAACAAAAAdggIVpgNDYzqDQ2W/w0NnP8NDaH/DAym/wsLqf8LC6z/Cgqu/woK + r+QKCq/ICAixjgcHrmEDA5UyAAAAEQAAAA4AAAAKAAAACAAAAAYAAAAEAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAACAAAACgAAABgAAAAuAAAARAAAAFgAAABnBgZRlAYGTJkGBkmcBgZHnwcH + RKEHB0SiBwdDogcHQ6IHB0OiBwdCowcHQqMHB0KjBwdCowcHQ6IHB0OiBwdDogcHRKIHB0SiBwdEogcH + RKEHB0ShBwdEoQUFOZgAAACAAAAAgAAAAH8AAAB/AAAAfgAAAHsAAABzAAAAZgAAAFMAAAA9AAAAKQAA + ABcAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAcICLnFCAiz/wkJq/8KCqL/CwuZ/woKeNsAAAB0AAAATwAA + ACwAAAAUSEjOt05OzP9ISMr/QUHI/zw8xf8nJ7z/EBCy/wYGrP8GBqv/Bgaq/wcHqP8ICKT/Cgqg/wwM + mP8PD43/FBSD/yAgf/8kJGXpAAAAmQ4OQMISEm/xEhJ9/xERgP8QEIH/Dg5l3wUFKqkAAACPAAAAgQAA + AG8HB1eDCwuGoQoKl5cKCqWQBgalUgYGrk8AAAAQAAAADgAAAAwAAAAJAAAABwAAAAUAAAADAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICM9kDAy60w0N + sv8ODqv/Dw+k/xAQnf8REZj/EhKU/xISkv8SEpH/ExOQ/xMTj/8TE47/ExON/xMTjf8TE43/ExON/xMT + jf8TE43/ExON/xMTjf8TE43/ExON/xMTjf8TE43/ExON/xMTjf8TE4v/ExOL/xMTiv8TE4j/FBSI/xUV + hv8TE3XgBwdEogAAAIIAAAB7AAAAbgAAAFsAAABEAAAALgAAABsAAAAOAAAABgAAAAIAAAAAAAAACAgI + tsYJCbD/Cgqp/wsLn/8NDZX/CgpjxAAAAHAAAABKAAAAJwAAABAAAAAJTEzNu1NTzv9NTcz/SEjJ/0FB + xf88PMH/Ly+8/x0dtf8TE7L/Dg6v/w4Oqv8QEKb/GBii/yAgnP8mJpP/JyeI/x4eU9gREU3bExN1/xMT + eP8SEnz/ERF+/xERfv8REXz/ERF7/w0NS84AAACVAAAAhQAAAG8AAABUAAAAOQAAACEAAAARAAAACAAA + AAMAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQoKxcALC7z/Cwu4/wwMs/8MDK3/DQ2o/w0No/8ODqD/Dg6e/w8P + nv8PD53/Dw+d/w8PnP8QEJv/EBCb/xAQm/8QEJv/EBCb/xAQm/8QEJv/EBCa/w8Pmv8PD5n/Dw+Z/w8P + mf8PD5n/EBCY/xAQmP8QEJb/EBCV/xAQlP8SEpL/ExOQ/xMTjP8UFIj/ERFuzgEBGIcAAAB8AAAAcQAA + AGAAAABKAAAAMwAAACEAAAASAAAACQAAAAQAAAAKCAixxgkJrP8LC6T/DQ2a/w8PkP8KClq8AAAAbAAA + AEQAAAAjAAAADQAAAAgDA6tRPDzJ/1hYzv9TU8v/TEzI/0dHxP9AQML/OzvA/zU1v/8wML3/Kiq4/yYm + s/8gIKz/IiKj/yQkm/8lJZH/GBh59BAQfP8QEH3/EBCA/xAQgv8QEIP/EBCA/xERfP8SEnf/EhJ2/xAQ + U9sAAACWAAAAhQAAAGwAAABNAAAAMAAAABgAAAAJAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLbEggI + z4MJCcDhCgq6/woKt/8KCrL/Cgqw/wsLrf8LC6v/Cwur/wwMq/8MDKv/DAyr/wwMq/8MDKr/DAyq/wwM + qv8MDKr/DAyq/wwMqv8MDKj/DAyn/wwMp/8MDKb/DAyn/wwMp/8MDKf/DAym/wwMpf8MDKT/DQ2j/w4O + oP8PD57/EBCa/xISlf8TE4//ExOB5AUFP5AAAAB4AAAAcgAAAGQAAABQAAAAOwAAACgAAAAaAAAAEQAA + ABQJCarICgqm/wwMnv8PD5T/EBCL/wcHQaMAAABnAAAAPwAAACAAAAAKAAAACAUFuIwFBbj/QEDH/15e + zP9YWMn/U1PF/0xMxP9GRsP/QEDE/zs7wv81Nb7/MDC6/yoqs/8mJqv/IiKk/x4em/8ODo7/Dg6L/w8P + iv8PD4v/Dw+M/w8PjP8QEIj/ERGA/xISef8TE3P/ExNx/xERUNsAAACVAAAAgQAAAGYAAABFAAAAKAAA + ABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMFBdZEBwfJhQgIvcQICLnwCAi3/wkJ + tv8JCbX/CQm1/wkJtf8JCbX/CQm0/wkJtP8JCbP/CQmz/wkJs/8JCbP/CQmz/wkJs/8JCbL/CQmy/woK + sv8KCrL/Cgqy/woKsv8KCrL/Cgqy/woKsf8KCrH/Cgqv/wwMrP8NDaj/Dg6j/xAQnP8SEpb/ExON9QYG + UJEAAAB0AAAAcgAAAGgAAABYAAAARgAAADUAAAApAAAAKQoKoNkLC6D/DQ2a/xAQjv8SEoj/BQU5mgAA + AGEAAAA6AAAAHAAAAAgAAAAJBga3uAUFtv8FBbD/Li65/2NjyP9dXcf/VlbF/1BQxf9LS8f/RUXF/z8/ + wv86Or3/NTW5/zAws/8oKK3/EBCg/wsLmv8LC5f/DAyX/wwMl/8MDJb/DQ2U/w4OkP8QEIj/EhJ//xMT + dv8UFG//FhZt/w8PPcgAAACRAAAAeQAAAFoAAAA5AAAAHQAAAAsAAAADAAAAAAAAAAAAAAABAAAAAgAA + AAUAAAAIAAAACwAAAA4AAAANAAAACgAAAAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAUAAAAHBATKRwQEx0gFBcBKBQW/SgUFvUsFBb5bCAjAiAYG + vWsFBbdNBQW3TQUFuUwFBblMBQW6TAUFvUsDA6osAAAADgAAAAwAAAAMAAAACgAAAAoAAAAKAAAACgUF + xUgFBcJJCQm+lwoKtuELC7D/DAyr/w4OpP8QEJz/EhKW/wwMb6gAAABwAAAAcwAAAG4AAABkAAAAVgAA + AEoAAABHCwud/wsLmf8NDZP/ERGK/xMThv8AAAB8AAAAWQAAADMAAAAXAAAABwAAAAkGBrfjBgaz/wcH + q/8GBp7uKChro1xcvvJjY8j/XFzJ/1dXyv9QUMn/SkrE/0VFv/8/P7v/Nze0+RoaleUICKb/CQmi/wkJ + of8JCaD/CQme/woKnf8LC5v/DAyW/w4OkP8QEIf/ExN8/xQUcv8WFmv/GBhq/wcHJq0AAACJAAAAbQAA + AEwAAAAsAAAAFAAAAAYAAAABAAAAAwAAAAYAAAAKAAAAEgAAABkAAAAfAAAAIwAAACEAAAAbAAAAEgAA + AAkAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAgAA + AAIAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABAcHzGUKCrjhDAyx/w4O + qv8QEKL/ERGa/xAQhswBARx2AAAAdQAAAHYAAABzAAAAbAAAAGsMDJX/DQ2T/w8Pj/8SEoj/ExOC+AAA + AHMAAABPAAAALAAAABMAAAAFAAAACQcHuP8HB7D/CAio/wcHkdwAAABxAAAAXEFBpZhXV8POXFzL/1xc + zP9WVsj/TEy97jQ0rucPD6HwBgap/wgIqP8HB6b/Bwek/wcHpP8ICKP/CAii/wkJoP8KCpz/DAyX/w4O + j/8REYX/ExN5/xcXbv8ZGWj/GBhZ7QAAAJQAAAB+AAAAXgAAADsAAAAfAAAADgAAAAgAAAAMAAAAFAAA + AB0AAAAnAAAAMgAAADsAAABAAAAAPgAAADMAAAAkAAAAFQAAAAkAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQICzhMICMeTCwu1/wwMrv8ODqb/Dw+f/xERlvQMDHW0AgIvhwAA + AH4AAACBAAAAgwwMkf8NDZD/Dw+N/xISif8REXjfAAAAZgAAAEIAAAAjAAAADgAAAAMAAAAICAi3/wgI + sP8JCab/Bwd9wgAAAHMAAABeAAAAOwAAAB8AAAARAAAAFQAAACoDA4KMBQWo/wYGqv8GBqr/Bweq/wcH + qP8HB6f/Bwem/wcHpv8HB6X/Bwek/wgIof8KCpz/DAyW/w8Pjf8TE4H/FRV0/xgYaf8aGmb/Dw82wQAA + AIoAAABuAAAATQAAAC8AAAAdAAAAGAAAAB4AAAAqAAAANwAAAEIAAABNAAAAVgAAAFsAAABZAAAATwAA + ADsAAAAmAAAAEwAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEGBtZECgq58AsLs/8MDKv/DQ2l/w4On/8ODpv/DAyS7gsLheAKCoLiDAyU/w0Nkf8PD47/ERGM/wwM + bbgAAABTAAAAMwAAABkAAAAIAAAAAQAAAAcICLj/CQmv/wsLpf8ICHe3AAAAdQAAAGUAAABEAAAAJQAA + ABQAAAAXBASZewUFq/8FBan/Bgar/wYGrP8GBqr/Bgap/wYGqP8GBqf/Bgan/wYGp/8HB6b/Bwek/wgI + of8KCpz/DQ2U/xAQiv8TE3z/FhZw/xkZZ/8ZGVzzAAAAkwAAAH0AAABgAAAARAAAADUAAAAxAAAAOQAA + AEUAAABQAgI/awkJcpkNDXqwBARKggAAAGgAAABhAAAAUAAAADkAAAAhAAAADgAAAAQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAs4TCQnCwQoKt/8KCrH/Cwus/wsL + p/8KCqT/Cgqi/woKnv8LC5r/DQ2V/w8Pkv8REZL/BARQeQAAAD4AAAAjAAAAEAAAAAUAAAAAAAAABQkJ + uv8KCrD/DAyl/wkJeLUAAAB2AAAAbgAAAFIAAAAxAAAAHwQEjEkGBq//Bgat/wUFq/8GBqz/BQWr/wYG + q/8GBqn/Bgan/wYGp/8GBqf/Bgan/wYGp/8HB6X/Bwej/wkJn/8LC5n/Dg6R/xIShP8UFHf/Fxds/xkZ + Z/8PDzbAAAAAigAAAHUAAABeAAAAUQAAAE4AAABSBgZggg8PjswSEpv/EhKZ/xMTlv8TE5D1BARKgQAA + AGgAAABgAAAATAAAADEAAAAZAAAACQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAACBwfNgwgIu/8JCbf/CQmz/wkJsP8JCa3/CQmq/wsLo/8MDJ7/Dg6b/w4O + kNQAAAA+AAAAKAAAABQAAAAIAAAAAgAAAAAAAAADCAi/0QoKsv8MDKb/Dg6Z9QEBGn0AAAB1AAAAYQAA + AEAAAAAqBgaorgYGr/8GBq7/BQWv/wYGrv8FBa3/Bgar/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + pv8HB6X/CAii/woKnf8MDJb/EBCL/xMTf/8VFXL/Fxdr/xUVUOEAAACUAAAAhgAAAHUAAABpCgponhAQ + kusQEJ3/Dw+g/w8PoP8QEKD/ERGd/xISmf8TE47fAAAAYgAAAGYAAABaAAAAQgAAACYAAAARAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBQXXRAcH + weAHB7z/Bwe6/wgItv8JCbH/Cgqs/wwMqP8ODqPzBAR2WAAAACMAAAAVAAAACgAAAAMAAAABAAAAAAAA + AAEHB8qDCgq1/wwMqf8ODp7/CwtytwAAAHgAAABtAAAAUQAAADgREazzBwev/wYGsf8FBbL/Bgay/wUF + r/8GBqv/Bgap/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bgan/wcHpv8HB6T/CQmg/wsLm/8ODpL/ERGG/xMT + ev8VFXH/FhZu/wEBEaAAAACPCQlJpxAQfNwREZT/Dw+c/w4Oo/8NDaXzCgqgpggImWoPD6bxEBCh/xIS + nP8ODoWzAAAAYwAAAGMAAABRAAAANgAAABwAAAAKAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLPEwYG0IMHB7/wBwe9/wgIuf8KCrX/Cwux4wUF + lEgAAAAYAAAAEAAAAAgAAAADAAAAAQAAAAAAAAAAAAAAAAMD2iMJCbn/DAyt/w4Oov8QEJX1AQEafgAA + AHUAAABgAAAARiUlsv8fH7b/FRW5/woKt/8FBbX/BQWx/wYGrf8GBqr/Bgao/wYGp/8GBqf/Bgan/wYG + p/8GBqf/Bgan/wcHpf8ICKL/Cgqe/wwMl/8PD47/EhKD/xMTef8TE3T/EBBP0xMTc/ESEob/ERGR/w8P + mv8ODqP/CgqfpwEBSTQAAAAZAAAAEAYGtjsODqv/EBCk/xISnP8EBFB4AAAAZgAAAF0AAABGAAAAKQAA + ABIAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMFBddEBATLRwQEwTkAAAAMAAAACgAAAAgAAAAFAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAQgIxaILC7L/DQ2n/w8Pnf8LC3K3AAAAeAAAAG0AAABTKyuw6ioquf8oKL3/JibA/yAg + vv8VFbj/DQ2y/wYGrP8GBqn/Bgao/wYGqP8GBqf/Bgan/wYGp/8GBqf/Bwem/wcHpP8JCaD/Cwub/w0N + k/8QEIr/ERGB/xISfP8SEn3/EhKD/xERjv8PD5j/DQ2ZwgMDaUUAAAAcAAAAEQAAAAkAAAAEAAAAAwoK + wJMNDaz/EBCj/xAQktIAAABiAAAAZAAAAFQAAAA4AAAAHQAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAA + AAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPaIwoKuP8MDK3/Dg6i/xAQ + lvUBARp+AAAAdQAAAGAvL6K4MzO7/zAwv/8uLsH/LCzC/ysrwP8pKbz/Jye5/xsbs/8VFa//DQ2r/wgI + qf8GBqf/Bgan/wYGp/8GBqf/Bwel/wgIov8KCp7/CwuY/w4Okf8PD4f/EhKE/xMThf8QEIv/Dw+N3wcH + d2sAAAAjAAAAFAAAAAoAAAAFAAAAAgAAAAAAAAAAAgLOEwwMtfAODqv/ERGg/wYGX4MAAABmAAAAXgAA + AEYAAAApAAAAEgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABCAjEogsLs/8MDKj/Dg6e/woKdLcAAAB3AAAAaxMTT2w8PLz/OTnA/zY2 + w/80NMP/MjLF/zExwv8vL77/Li68/y0tuf8rK7f/Kiq0/yMjsv8dHbD/GRmt/xQUrP8UFKr/FBSn/xQU + o/8WFp//HByZ/yIilP8lJZL/FBSD7wkJaJsAAAA+AAAAIwAAABAAAAAGAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAABCQnIgw0Nsf8PD6X/ERGW3gAAAGQAAABmAAAAVAAAADcAAAAcAAAACgAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBNkjCgq4/wsL + rf8NDaP/Dg6Y9QAAAHYAAABzAAAAXDQ0p6xBQcL/Pz/F/z09yP87O8j/OjrI/zk5xP83N8L/NTW//zQ0 + vP8yMrr/MDC3/y4utv8sLLX/Kiq0/yoqsv8pKbD/KCis/ycnpf8nJ57/JyeY/yYmlf8ICDeBAAAASwAA + ACsAAAAUAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAs4TCwu28A4Oq/8REZ//BgZdhAAA + AGgAAABfAAAARgAAACgAAAARAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEICMOiCgqx/wwMp/8ODp7/BwdkpwAAAHYAAABmAAAASD09 + u75ISMn/RUXL/0REy/9CQsv/QEDL/z8/yf89PcX/PDzB/zo6v/85Ob3/Nze7/zY2uv80NLn/MzO2/zIy + s/8xMa//MTGo/zAwof8vL57/KSmS6AAAAFgAAAA3AAAAHQAAAAsAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEJCciDDAyw/w8PpP8QEJDUAAAAZgAAAGYAAABTAAAANQAAABsAAAAJAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE + 0yQKCrT/Cwup/w0Nn/8NDZHtAAAAeAAAAG0AAABPAAAALkZGyblPT8//TEzQ/0pKz/9JSc7/R0fM/0VF + yv9ERMj/QkLF/0BAwv8/P8H/Pj6//z09vP87O7n/Ojq2/zo6sf85Oav/OTmm/zg4pf8hIXugAAAAQAAA + ACUAAAASAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE1CQLC7X/Dg6p/xER + nv8GBlyHAAAAaQAAAF4AAABEAAAAJgAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwkJu6ULC6z/DQ2h/w4OmP8HB1eiAAAAcAAA + AFMAAAAvAAAAFklJ1ptVVdP/U1PT/1FR0f9QUM//Tk7O/0xMzP9MTMr/SkrH/0hIxP9HR8D/RUW9/0RE + u/9DQ7f/QUGz/0JCr/9BQa3/PT2p7gAAAEAAAAApAAAAFQAAAAgAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJwaMNDa//EBCk/xAQjcoAAABoAAAAZgAAAFEAAAAzAAAAGAAA + AAgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADAwOhLgsLrP8NDaD/Dw+X/wwMeswAAABvAAAAUgAAAC4AAAAUAAAABkVF4FZSUtbpWlrW/1hY + 0/9WVtD/VVXO/1NTzP9SUsj/UVHE/09Pwf9OTr7/TEy7/0xMuP9KSrX/S0u1/0lJs/cjI4BkAAAAJQAA + ABUAAAAKAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBgbVRAsL + tP8ODqn/ERGf/wICOnQAAABoAAAAWgAAAD4AAAAhAAAADAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAASCwus/w4OoP8QEJf/Dw+D3QAA + AGsAAABMAAAAKgAAABEAAAADAAAAAQAAAANMTN57XFzX62Bg1P9eXtH/XFzN/1tbyf9ZWcT/V1fA/1ZW + vv9VVbz/VVW7/1RUu/9LS7fjLCyVWgAAABsAAAARAAAACAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCgq/wgwMsP8PD6b/Dg6PvgAAAGAAAABaAAAAQwAA + ACYAAAAQAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABgQEo0ELC6v/Dg6f/xAQlf8ODnrLAAAAZgAAAEQAAAAkAAAADgAAAAIAAAAAAAAAAAAA + AAEAAAADS0vcalRU0b1hYc72Y2PL/2Jixf9hYcL/YGC//2BgwP9OTrLUQECqjgAAAB0AAAASAAAACgAA + AAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEHB9BjCwu2/w4Orf8QEKX/AgJGZAAAAE8AAAA+AAAAJQAAABEAAAAEAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBwevcAwMqf8ODp3/ERGV/wkJ + Y6cAAABfAAAAPAAAAB0AAAAKAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAFAAAAEQAAACgZGa7qHh6t/yAg + qv8oKJC4AAAASgAAAC8AAAAYAAAACwAAAAUAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMKCr3gDAy0/w4Orv8LC5ucAAAAOwAA + ADEAAAAfAAAADgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAsJCbGrDAyo/w4OnP8REZT/BARFigAAAFcAAAAzAAAAFwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAgAAAAoAAAAaBgacjAgIqv8KCqX/Cgqa7AAAAFMAAAA3AAAAHQAAAAsAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQcH1GILC7r/DQ21/w4OsdUAAAAjAAAAHQAAABMAAAAJAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADwoKr9YMDKb/Dw+a/xER + kPYAAABpAAAATAAAACoAAAASAAAABAAAAAAAAAAAAAAAAAAAAAEAAAAGAAAAEgEBQzUJCarzCgqn/wwM + ov8FBWCFAAAARAAAACgAAAASAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQkJyqILC7zwDAy8wwAA + ABAAAAAOAAAACQAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAQAAAASCwuu/w0No/8QEJr/Dg59yQAAAGIAAABCAAAAIgAAAAwAAAACAAAAAAAA + AAAAAAAAAAAAAwAAAAwAAAAeCQmhqAsLp/8MDKL/DAyR2AAAAFAAAAA0AAAAGgAAAAoAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAEAAAABQAAAAUAAAADAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgUFrFALC6z/DQ2i/xAQ + mf8JCWiiAAAAWQAAADcAAAAbAAAACAAAAAEAAAAAAAAAAAAAAAEAAAAGAAAAFAUFjGALC6j/DQ2h/w4O + nf8EBFF6AAAAQQAAACUAAAAQAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAICAixfgsLqv8ODqD/EBCY/wEBIHAAAABOAAAALgAAABQAAAAFAAAAAAAA + AAAAAAAAAAAAAQAAAAoAAAAdCwulzg0No/8ODpz/DQ2ExQAAAFEAAAAzAAAAGQAAAAgAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAwJCbGrDAyp/w4O + n/8PD4/jAAAAXwAAAEQAAAAkAAAADgAAAAMAAAAAAAAAAAAAAAAAAAADAAAADgcHpXYMDKn/Dg6f/w8P + lPYCAjl4AAAASgAAACwAAAAUAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAADAAAAEAsLr9YNDaf/Dw+d/woKdKkAAABXAAAAOQAAABwAAAAJAAAAAQAA + AAAAAAAAAAAAAAAAAAMAAAAQCwuw8gwMqf8ODp7/Cwt0twAAAGYAAABMAAAAMAAAABkAAAAKAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAUCwuv/w0N + pf8PD53/AgI8dAAAAE0AAAAvAAAAFQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAwcHw2gKCrT/DAyr/w4O + nvUBAR9zAAAAaAAAAFYAAAA+AAAAKgAAABoAAAAQAAAACQAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACAUFp1IMDK3/Dg6j/w8Pl+sAAABaAAAAQgAAACUAAAAOAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAACCQnC0QoKt/8MDK7/DAyTvAAAAF8AAABnAAAAYQAAAFQAAABEAAAAMwAA + ACYAAAAZAAAAEAAAAAkAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAALCQmujwwM + q/8ODqL/DAyGuAAAAFEAAAA3AAAAHAAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEHB8ySCQm7/wsL + s/8MDKbZAgJGYgAAAFsAAABjAAAAYwAAAFwAAABRAAAAQwAAADQAAAAmAAAAGQAAABAAAAAIAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAABAKCq/JDQ2p/w8Pof8CAkBuAAAASAAAAC0AAAAUAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICzxMJCcPRCgq5/wwMsf8ODqj/Dg6UuQICP2sAAABiAAAAZwAA + AGYAAABeAAAAUgAAAEMAAAAzAAAAJQAAABgAAAAOAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAFQwM + rPIODqb/Dw+Y4AAAAFMAAAA9AAAAIwAAAA4AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIC + zxMICMiiCgq4/wwMsv8ODqn/EBCi/w4Ojr0CAjtyAAAAaAAAAGoAAABoAAAAXwAAAFIAAABCAAAAMQAA + ACMAAAAVAAAADAAAAAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAoFBaJVDAys/w4Opf8KCoCgAAAASgAAADMAAAAZAAAACAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHB9JjCgq58AwMs/8NDaz/Dw+l/xER + nv8PD4jAAgI4dgAAAGoAAABsAAAAaAAAAF4AAABPAAAAPgAAAC4AAAAeAAAAEgAAAAgAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAADwkJ + rp8NDar/Dw+k/wICRWcAAABAAAAAKAAAABIAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEEBNojCQnBsgsLtv8MDLD/Dg6p/xAQo/8REZz/Dw+HwQICN3kAAABrAAAAawAA + AGYAAABaAAAASgAAADcAAAAkAAAAFQAAAAoAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAWDAyv1w4Oqf8NDZjIAAAASwAAADYAAAAeAAAACwAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBgbVRAoK + vOALC7T/DQ2t/w8Pp/8QEKH/EhKb/wwMfa0BAR5vAAAAagAAAGgAAABeAAAATAAAADcAAAAhAAAAEAAA + AAYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAACwIC + gTgMDLD/Dg6o/wcHeIUAAABCAAAAKwAAABUAAAAGAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwcH0GQKCrrhDAyz/w0NrP8PD6b/ERGg/xIS + mPQJCXOYAAAAYgAAAGEAAABVAAAAQgAAACoAAAAVAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAPCQmyng0Nr/8NDaboAAAARwAAADYAAAAgAAAADQAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAMICMuDCwu38AwMsv8ODqv/Dw+m/xERoP8REZjdBARZcQAAAE0AAAA+AAAAKgAA + ABcAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAA + ABILC7bkDQ2x/woKmaAAAAA7AAAAKgAAABYAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAs4TCQnIhAsL + tvANDbD/Dw+s/xAQqP8REaTyBARzWgAAAC0AAAAfAAAAEQAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBgbAWgsLuf8MDLLyAQE7QAAAACsAAAAdAAAADQAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgLOEwkJyIQMDLXwDg6y/w4OsP8NDbG4AAAAGQAA + ABIAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAMKCsPCCwu7/wkJtY8AAAAhAAAAGgAAABAAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQICzxMICM9kBgbKRwAAAAsAAAAKAAAABwAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLbEgoKwu8LC73wAQF6IAAAABIAAAANAAAACAAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAQAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABBgbbUgYG2EQAAAAHAAAABwAAAAUAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/////////AH///////////////////wA///////////////////8AP////////////////// + /AB///////////////////wAf//////////////////8AD///////////////////AA///////////// + //////4AP//////////////////+AB///////////////////gAf//////////////////8AD/8D//// + ////////////AA/+Af///////////////4AH/gD///////////////+AB/4A////////////////wAP+ + AH///////////////8AD/AB////////////////AA/wAf///////////////4AH8AH////////////// + /+AB/AB////////////////wAPwAf///////////////8AD8AH//////////+AD///AAfAB///////// + /8AAH//4AHwAf/////////8AAAf/+AB8AH/////////+AAAB//wAPAB//////////AAAAH/8ADwAf/// + //////wAAAA//AAcAH/////////4AAAAH/4AHAB/////////+AAAAA/+ABwAf/////////gAAAAH/gAM + AH/////////4AAAAA/8ADAB/////////+AAAAAH/AAwAf/////////gAAAAA/wAMAH/////////4AAAA + AH+ADAB/////////+AAAAAB/gAwAf/////////gAAAAAP4AMAH/////////4AAAAAB8ADAB///////// + +AAAAAAfAAwAf/////////gAAAAADwAMAH/////////4AAAAAAYADAB//////////AAAAAAGABwAf/// + //////wAAAAAAgAcAD/////////+AAAAAAAAHAA//////////gAAAAAAADwAP/////////8AAAAAAAA8 + AB//////////AAAAAAAAfAAf/////////4AAAAAAAHwAD/////////+AAAAAAAB8AA//////////wAAA + AAAA/gAH/////////+AAAAAAAP4AB//////////wAAAAAAD/AAP/////////+AAAAAAA/wAD//////// + //gAAAAAAP+AAf////+Af//8AAAAAAB/wAH/////AD///wAAAAAAf+AA/////wAP//+AAAAAAH/gAH// + //8AA///wAAAAAAfgAB/////AAD///AAAAAAAAAAf////wAAH//4AAAAAAAAAH////8AAAf//gAAAAAA + AAB/////AAAA//+AAAAAAAAAf////4AAAB//gAAAAAAAAH/////gAAAH/AAAAAAAAAB/////+AAAAOAA + AAAAAAAA//////4AAAAAAAAAAAAAAP//////gAAAAAAAAAAAAAH///////AAAAAAAAAAAAAH///////8 + AAAAAAAAAAAAD////////wAAAAAAAAAAAAP////////AAAAAAAAAAAAA////////8AAAAAAAAAAAAD// + +AD///wAAAH4AAAAAAAf/gAA////AAAH/wAAAAAAB8AAAP///8AAP/+AAAAAAAAAAAD////wAf//gAAA + AAAAAAAA/////////8AAAAAAAAAAAP////////+AAAAAAAAAAAD//8AAAB//gAAAAAAAAAAA/+AAAAAA + P4AAAAAAAAAAAP/AAAAAAB+AAAAAAAAAAAf/wAAAAAAHgAAAAAAAAAA//8AAAAAAA4AAAAAAAAAH///A + AAAAAAGAAAAAAAAA////wAAAAAAAgAAAAAAAP////8AAAAAAAAAAAAAAAP/////gAAAAAAAAAAAAAAB8 + D///8AAAAAAAAAAAAAAAYAP///wAAAAAAAAAAAAAAAAB////8AAHwAAAAAAAAAAAAf////////gAAAAA + AAAAAAD////////+AAAAAAAAAAAA/////////wAAEAAAAAAAAH/////////AABAAAAAAAAA///////// + 4AAQAAAAAAAAP/////////AAOAAAAAAAAB/////////8AHgAAAAAAAAf/////////4P8AAAAAAMAD/// + /////////AAAAAAHAA////////////4AAAAAH4AP///////////+AAAAAD+AB////////////wAAAAA/ + wAf///////////8AAAAAf8AD////////////AAAAAH/AA////////////wAAAAD/4AP///////////8A + GAAB/+AD////////////ABwAB//wA////////////gA8AD//8AP///////////4AOAA///gD//////// + ///+ADgAf//8B////////////gAwAH////////////////4AcAD////////////////8AHAA//////// + /////////ABwAH////////////////wA8AAf///////////////8APAAB///////////////+ADwAAH/ + //////////////gB+AAAf//////////////4AfgAAB//////////////8AH+AAAP//////////////AD + /wAAD//////////////gA//AAAf/////////////4AP/4AAH/////////////+AH//gAB/////////// + ///gB//+AAf/////////////4A///4AH/////////////+AP///gD//////////////gH///+D////// + ////////4B////////8oAAAAQAAAAIAAAAABACAAAAAAAABCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABwAAAA4AAAARAAAADAAA + AAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAA + AA4AAAAcAAAAJgAAAB0AAAAPAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIICLxaCgqokwAAADkAAAAzAAAAHQAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBga1Ow4Opf8ICIqIAAAARAAAAC4AAAATAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNDaHHDg6d5wAA + AEwAAAA+AAAAIQAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAADCwuqaw4Onf8ICH+OAAAASgAAADAAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAA + AAcAAAAFAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAoODpzkDQ2a6AAAAFEAAAA+AAAAHwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAABwAAABAAAAAXAAAAEwAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDAyiiw0Nm/8GBnOHAAAASwAA + AC0AAAAQAAAAAgAAAAAAAAAAAAAAAQAAAA8AAAAiAAAAMgAAACoAAAAXAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQE + pCwNDZv/DQ2U0gAAAFMAAAA8AAAAGwAAAAUAAAAAAAAAAAAAAAMAAAAWDg6o/wUFcnYAAAA+AAAAIgAA + AAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAHDQ2duA0Nm/8DA1Z0AAAASgAAACkAAAAMAAAAAQAAAAAAAAAEBwefUw4O + nv8LC4y1AAAATAAAACoAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAYAAAAIAAAACgAAAAkAAAAHAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkJqFwODpr/DAyMvgAAAFUAAAA5AAAAFwAA + AAQAAAAAAAAABQgIm1MNDZn/DAyR1gAAAFEAAAAsAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACgAAABMAAAAdAAAAJAAA + ACcAAAAlAAAAHwAAABYAAAAMAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDg6Z5A4O + mv8BASNkAAAASAAAACQAAAAKAAAAAAAAAAUICJpTDQ2Y/wwMj9YAAABTAAAALgAAAA4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADgAA + ACAAAAA0AAAARgAAAFEAAABXAAAAVAAAAEoAAAA7AAAAKQAAABcAAAAKAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABQ0NnpsNDZj/CgqBrAAAAFUAAAAzAAAAEwAAAAMAAAAFCAiZUw0NmP8MDI7WAAAAUwAA + AC4AAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAACwAAACEBAS1NCAhymwoKdLoMDIffCgp2yQgIa7gBATKKAAAAawAAAFUAAAA7AAAAIwAA + ABAAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAEHB6Q+DQ2Y/w0NlekAAABcAAAARAAAAB8AAAAHAAAABQgI + mVMNDZj/DAyO1gAAAFMAAAAuAAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABYWFpCGDQ2T9QsLkf8KCpL/CQmS/wkJkf8LC5D/DAyT/woK + edUAABmHAAAAZwAAAEkAAAAsAAAAFAAAAAcAAAABAAAAAAAAAAAAAAAAAAAACQ4OmNYNDZj/BgZpkQAA + AFIAAAAtAAAADgAAAAYICJlTDQ2Y/wwMjtYAAABTAAAALgAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcODnw9HR2c/woKjv8HB5H/CAib/wcH + n/8ICJv/CAiT/wgIj/8KCo//DAyP+QUFVq8AAAByAAAAUgAAADAAAAAVAAAABwAAAAEAAAAAAAAAAAAA + AAQMDJ99DQ2X/wwMjtYAAABbAAAAOgAAABcAAAAICAiZUw0NmP8MDI7WAAAAUQAAACwAAAANAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJHh6gmBYW + lf8ICJH/Bgad/wYGpf8GBqf/Bgal/wYGof8HB5v/BweR/wkJjP8LC5H/Cgp0zwAAAHgAAABVAAAAMAAA + ABQAAAAFAAAAAAAAAAAAAAABBQWbLg0NmP8NDZj/AgI8cgAAAEIAAAAdAAAACggImlMNDZj/DQ2Q1QAA + AE8AAAArAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACCEhn8wXF5f/CAib/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgal/wYGnf8GBpD/CAiL/wsL + j/8KCnnWAAAAdwAAAFEAAAAqAAAAEAAAAAMAAAAAAAAAAAAAAA4NDZS9DQ2X/wkJfKQAAABEAAAAHgAA + AAoICJtTDQ2Z/w0NkdUAAABLAAAAKAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYjI6KVHBya/wgIm/8GBqX/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqX/Bgad/wYGkf8ICIv/CwuQ/wkJbMgAAABxAAAASAAAACEAAAAKAAAAAQAAAAEAAAASDAyMmQ0N + l/8KCoKtAAAAPgAAABoAAAAICAibUw0Nmf8LC4e0AAAASQAAACcAAAAKAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADHh6pciIimv8LC5T/Bgah/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpf8GBp3/BgaR/wgIi/8MDJH/BQVWrgAAAGYAAAA6AAAAFwAA + AAUAAAAFAAAAGw0Nk9sNDZj/BQVjgQAAADQAAAASAAAABwgIm1MODpr/CgqCqwAAAEwAAAAqAAAACwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARIS + lB0jI53/FRWV/wcHm/8GBqX/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgal/wYGnf8GBpH/CQmN/wwM + j/kAABmGAAAAVAAAACkAAAANAAAADAUFfk8NDZj/Dg6W9QAAAE4AAAAoAAAACwAAAAUICJtTDQ2Z/wsL + hLcAAABVAAAAMAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAFISGhrSEhmf8KCpL/Bgad/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + p/8GBqX/Bgad/wcHkf8KCpD/CgpzzgAAAGwAAAA9/////wAAABcMDJOlDQ2X/wsLh8IAAABBAAAAHAAA + AAYAAAAECAiZUw0NmP8MDIzYAAAAXwAAADsAAAAVAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARkZsC0mJp3zGxuV/wYGkv8GBqH/Bgan/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGpf8HB5v/CAiP/wwMk/8CAjCOAAAAUQAAACkAAAAkDg6V5w0N + l/8FBWSAAAAAMwAAABIAAAACAAAAAwgIn1AMDJb/DQ2X/wAAAGgAAABIAAAAHwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAELy+uhDAw + oP8bG5f/Bweb/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYGp/8GBqf/Bgah/wcHkv8KCpD/Cgp1zAAA + AGEAAAA3CAiIcg0NmP8NDZXqAAAASgAAACYAAAAKAAAAAAAAAAEICKlMDQ2V/wwMlP8GBmSXAAAAVgAA + AC0AAAAOAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAc5Oaq0OTmk/yMjnf8HB5v/Bgah/wYGpf8GBqf/Bgan/wYGp/8GBqf/Bgan/wYG + pf8HB5v/CQmQ/wsLh+oAAABrAAAAQgoKjp0NDZj/CgqBrAAAAEAAAAAdAAAABQAAAAAAAAABAwOfGA0N + l/EMDJP/CwuDxAAAAF4AAAA+AAAAGwAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLS2zHEVFrd1ERKj/NDSi/w0Nlf8GBp3/Bgal/wYG + p/8GBqf/Bgan/wYGp/8GBqf/Bgaf/wgIkP8TE5b/AAAAcwAAAEwNDZXQDQ2Z/wICP28AAAA+AAAAGwAA + AAQAAAAAAAAAAAAAAAMMDKZrDAyW/w0Nl/8CAj1wAAAATQAAACwAAAAPAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAACQAA + AAoAAAAHAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIrK60dTk6y309P + rP9FRaf/JSWe/woKnP8GBqH/Bgal/wYGp/8GBqf/Bgan/wYGn/8ODpP/Jyed/w8PSpYAAABZDQ2Q1A0N + mP8BASBtAAAARgAAAB8AAAAGAAAAAAAAAAAAAAABAAAABg0NnqgNDZj/DAyLvgAAAFgAAAA/AAAAHwAA + AAgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAADAAAABcAAAAdAAAAGgAAABAAAAAIAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAhQULatWVmy/1RUrv9LS6z/LCyi/xsbo/8VFaf/FBSq/xcXrf8qKq7/Nzen/zc3 + o/8GBhyKAAAAbQsLh9oNDZX/BgZgngAAAFcAAAAsAAAADgAAAAEAAAAAAAAAAAAAAAMAAAAMDg6Y1g0N + mf8FBV+GAAAAUwAAADEAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBciAAAAAlAAAAMgAAADIAAAAoAAAAHAAAABIAAAAKAAAABAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABUJCu2xfX7bsYGC1/1xcsf9XV7H/U1Oz/1BQ + t/9NTbj/SUm1/0VFrv8eHpn/BwdWswkJZsEJCWjKCwuQ/wsLetIAAABtAAAARAAAACIAAAAQAAAADQAA + ABAAAAAUAAAAGwcHgWINDZf/DQ2Q4gAAAGQAAABDAAAAHAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODrLDDg6o4wYGgmYAAAA9AAAAOwAA + ADMAAAAqAAAAIAAAABcAAAAOAAAACAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACFBQ + vIJoaLrQZ2e5/2Njt/9gYLf/XV22/1hYtP8mJp3/CQmH7QkJh+8KCpL/CQmJ+QoKjv8MDIz4AAAAhAAA + AGQAAABEAAAAMAAAACwAAAAxAAAAOQAAAEAAAABNCwuO6w0Nlf8HB22iAAAASQAAACAAAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAS/Jw0N + rKcODqP/DQ2gywcHh3YAAAA9AAAAPQAAADgAAAAxAAAAKAAAAB8AAAAVAAAADgAAAAcAAAADAAAAAQAA + AAAAAAAAAAAAAQAAAAQAAAAKAAAAFR8fYjc6Opd1NzeNfDc3iX8qKn98CwuBuwoKdsMICJn/CAie/wcH + mf8ICIf5CgqM/woKeN8BAS2TAAAAbwAAAGAAAABeAAAAZQQEWJAFBVSTBgZNlAsLhOUMDJP/DAyOzQAA + AD4AAAAbAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAFBASqKwwMqZoODqLxDg6h5QkJlI4CAlFWAAAARAAAAEIAAAA9AAAANAAA + ACoAAAAgAAAAFgAAAA4AAAAKAAAACQAAAA0AAAAVAAAAIAAAACwAAAA5AAAARAAAAEwAAABPAAAAUDQ0 + jKsYGJr/CAie/xMTqv8bG6n/BgaU/wgIjv8KCo7/CwuL+QYGTLMLC3jSDAyQ9wwMk/8MDJL/DAyR/wsL + kf8LC5H/DQ2W/woKkKAAAAAmAAAADwAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAFAgKOGwwMq4oODqLjDg6g/w0N + msEICIOKAQEoVwAAAE4AAABKAAAAQwAAADgAAAAtAAAAJgAAACUAAAAsAAAAOAAAAEYBASVcCAh2lwoK + f64MDIzMCgp9rgYGWIgPDyx1W1us7V5evv8zM7X/Bgal/wYGof8HB5v/BweS/wgIkP8KCpD/CQmO/wkJ + jf8KCo3/CwuP/wsLkP8MDJP/DQ2V5woKjn8AAAAfAAAAEAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAAEAAAACgsLrGwODqDjDg6d/w4OnP8MDJLGCAh5kwEBJGIAAABXAAAAUQAAAEwAAABMAQEmWwgI + dZcMDIrMDQ2Y/w0Nl/8NDZf/DQ2X/wwMlv8MDJT/DAyN9QkJeNEHB4PfBwel/wYGp/8GBqf/Bgal/wYG + of8HB5//BweZ/wcHjv8KCov/CwuQ/wwMh9cLC4aiBwd7aAAAACoAAAAeAAAAEgAAAAcAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACAgIqk0NDZ3HDQ2b/w0Nmf8NDZn/DAyMyggI + cZkGBmaRCwuGww0NlfUNDZf/DQ2W/w0NmP8NDZXaCgqKfwoKkXkNDZa8DQ2W8gwMk/8KCpD/CAiS/wcH + nf8GBqX/Bgan/wYGp/8GBqf/Bgan/wcHn/8HB5D/BgZEtwAAAH4AAABgAAAASQAAAD0AAAA2AAAALgAA + ACIAAAAVAAAACgAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAABgAA + AAcAAAAHAAAABQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABwUF + ny0NDZ6qDQ2Y8g0NmP8NDZf/DQ2X/w0Nl/8NDZj/DQ2W2goKkIsEBHE/AAAAGQAAABAAAAALAAAACgAA + AA0LC6FeFhaUvRAQkf8ICJP/Bweh/wYGp/8GBqf/Bgan/wYGp/8HB5//BweP/wsLh/kDAzeiAAAAegAA + AGsAAABiAAAAWQAAAFAAAABEAAAANAAAACMAAAASAAAABwAAAAIAAAABAAAAAwAAAAUAAAAIAAAADAAA + ABAAAAAUAAAAGQAAAB4AAAAgAAAAHAAAABQAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAABQICjRsLC6RtDg6b1Q0NmsoLC5aGBARzPgAAABgAAAAQAAAACAAA + AAQAAAABAAAAAAAAAAAAAAAAAAAAAx8fkiA0NKL0GBiY/wkJoP8GBqf/Bgan/wYGp/8GBqf/Bgah/wcH + kv8JCYz/CwuJ+QsLfeUMDJD4DQ2Z/w0NkeMJCYKuAAAkYQAAAFEAAABDAAAAMAAAAB4AAAAVAAAAFAAA + ABcAAAAdAAAAJAAAACoAAAAxAAAANQAAADoAAAA9AAAAPAAAADMAAAAjAAAAEAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAcAAAAKAAAACgAA + AAgAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGLi6ZUj4+pvYuLqj/EhKj/wYG + n/8GBqH/Bgal/wYGpf8HB53/BgaS/wcHj/8JCY//CwuQ/wwMjvcMDJDsDQ2Z/w4OmPQICHaWAAAAWQAA + AE8AAABAAAAANwAAADYAAAA5AAAAQAAAAEcAAABNAAAAUgUFZ30GBnKICgqKpwoKkKQICJmQAAAAJgAA + ABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAACAAAAAsAAAANAAAADgAAAA4AAAAOAAAADgAA + AA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAANAAAADAAAAAgAAAAEAAAAAQAAAAAAAAAAAAAABwEB + Ti0WFpHpNzek/zw8pv8fH5r/BgaT/wYGnf8GBqX/Bgal/wYGof8HB5//BweZ/wkJhPMBAReKAAAAYAsL + h6MNDZn/DQ2Z/wwMkNYCAjxyAAAAWgAAAFYCAkBrBQVjgAoKgqsMDI3LDQ2W6g0Nm/8NDZv/Dg6c/w4O + nv8ODqLlCgqqkwAAABcAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACgAAABcAAAAjAAAAKwAA + AC4AAAAuAAAALgAAAC4AAAAuAAAALgAAAC4AAAAuAAAALgAAAC4AAAAuAAAALQAAACoAAAAiAAAAFQAA + AAoAAAADAAAAAAAAAAoKCpJ3CwuQ/woKjP8uLo3hSEio/yoqm/8JCZP/Bgah/wYGp/8GBqf/Bgan/wgI + n/8JCZL/CAhhvQAAAG0AAABVBARWcA0Ni9UNDZf/DQ2V9Q0NjtUNDZr/DQ2a/w0Nmf8NDZn/DQ2Z/w4O + mv8NDZjZDAyWpAoKmXgDA3o7AAAAFwAAABAAAAAJAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAA + ABIAAAAnAAAAPAAAAEoAAABRAAAAVAAAAFYAAABXAAAAVgAAAFUAAABUAAAAUwAAAFMAAABTAAAAUwAA + AFMAAABRAAAASAAAADYAAAAhAAAADgAAAAUAAAANDQ2VvQsLkP8LC5D/AAAAZj4+j5xSUq7/ODil/xMT + o/8GBqf/Bgan/wYGp/8HB5//CQmR/w4OfeUAAACGBQVQmQUFT5cAAABzCAhlpAwMkusNDZr/Dg6Y8w0N + l80MDJWkCwuZhgcHklkAAAAbAAAAFAAAAA8AAAAKAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAQLC7WWDQ2hyQ0Nl88NDZHTDQ2O1QwMjdcMDIvYDAyM2AwMjNgMDI3XDAyO1wwM + jtYMDI7WDAyO1gwMjtYMDI/XCwuJxAAAIWkAAABUAAAAQAAAACgAAAAVAAAAFw0NkswMDJH/DAyI5AAA + AFkAAAA1R0efk11dtP9PT7X/Nzex/x0dqP8XF6f/ExOh/xgYl/8ZGX3oCgp+7AsLkP8LC5D/CwuH8QMD + O5sAAABsAAAATAAAACwAAAAYAAAADgAAAAoAAAAHAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCQnAZg4OpNMODpz/DQ2Z/w0Nl/8MDJb/DQ2V/w0N + lf8NDZb/DQ2X/w0NmP8NDZj/DQ2Y/w0NmP8NDZf/DAyW/w0Nlv8NDZf0BQVhgwAAAFUAAABGAAAAMwAA + ADENDY/QDAyS/wwMidoAAABQAAAALAcHgl8uLqD/YGC1/1pas/9NTa7/QUGq/zU1qP8pKaD/Dw+S/wcH + kP8HB5D/CAiP/woKjv8LC4z5AwM+mgAAAF4AAAAzAAAAFAAAAAUAAAAEAAAACAAAAAsAAAAKAAAABwAA + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAHAAAADggI + qU4ICJtTDQ2djgwMmZAMDJqRCwuXdggIklgICJVWCAiZVQgImlQICJlUCAiWVQwMmYENDZfJDQ2Y/w4O + mv8JCYGcAAAAVQAAAFIAAABUCwuG2AwMk/8KCni0AAAARgAAACULC5WGDAyU/yAghcdaWqniZma3/1pa + sf9LS67/Hx+Z8gcHn/8HB5//Bgaf/wcHm/8HB5H/CQmO/wsLhusAAAB5AAAATwAAACgAAAAVAAAAFQAA + AB4AAAAkAAAAIwAAABcAAAALAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAUAAAAHAAAACAAAAAgAAAAHAAAABQAAAAUAAAAFAAAABQAA + AAUAAAAGAAAACgkJp00ODpvVDg6a/w0NktEHB2eMBgZRjQsLie0MDJP/CAhzmQAAADcAAAAbCwuckQ0N + l/8GBlyBAAAATSMjZ140NIWIDw+G4wgIn/8HB6f/Bgan/wYGp/8GBqX/Bweb/wgIjv8LC4//CQluxgAA + AGsAAABGAAAAMQAAAC8AAAA5AAAAQQAAAD8AAAAxAAAAGwAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwOYGQ0NoKgNDZn/DAyU/wsLkf8LC5D/DQ2X/wIC + T1sAAAAjAAAAEAwMo4wNDZn/BwdtiAAAAE4AAAA/DAyHtwkJkf8HB5//Bgan/wYGp/8GBqf/Bgan/wYG + of8GBpP/CQmM/wsLjfkAAACBAAAAYgEBKFcJCY2UDg6f5w4On/QDA15sAAAARAAAAC4AAAAUAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAGCwurWw4O + mPENDZX/DQ2X/wwMlqYAAAAjAAAAEAAAAAcGBq08DQ2b/w0Nk9IAAABVAAAATRYWmf8LC5L/Bwef/wYG + p/8GBqf/Bgan/wYGp/8GBqX/Bgab/wgIjv8KCo3/BwdXtgoKeLYODp70Dg6e5woKkYsNDZrZDg6f8wEB + K1MAAAA+AAAAIwAAAAwAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMDA58YCAiuTAYGoEEAAAATAAAADAAAAAUAAAABAAAABw0NncYODpr/BQVhfwAA + AFc2NqP2MTGh/x4eo/8SEqX/Cgqm/wYGp/8GBqf/Bgan/wYGn/8GBo//CQmL/wwMkv8ODpj1CgqSnwEB + SzIAAAAXBASJNA4OnPIKCpGfAAAARwAAADMAAAAXAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAEAAAAAAAAAAAAA + AAIICKtMDg6a/w0Nj9IAAABZNzeXvUNDqP88PKX/OTmn/zU1rv8rK7L/IyOx/x4erf8WFqH/GxuW/x4e + lf8XF4jUAQEvUAAAACIAAAANAAAABQAAAAYMDKWLDg6f/wICS14AAABAAAAAJQAAAAwAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACA0NmsgNDZn/BgZeghAQNV1OTq3kUVGt/0tLqf9HR6v/RESy/z8/ + tP87O6//ODil/zU1oP81NaT/Dw9QZwAAACcAAAANAAAAAgAAAAAAAAABAgKNGw4On/8LC5OsAAAASQAA + ADMAAAAWAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUICJhVDQ2Z/wwMicAAAABMGhoaNVFR + s7NfX7X/Wlqx/1RUsP9RUa//Tk6s/0xMqv9KSqz/ODifuwAAACwAAAASAAAABQAAAAAAAAAAAAAAAAAA + AAUNDaGpDg6c8gEBK1IAAAA7AAAAHgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAQFUKg0N + mf8NDZLVAAAASAAAACYAAAAOU1PCT1tbs85oaLf/ZGS0/2FhtP9cXLP4RUWnrwAAACMAAAARAAAABgAA + AAEAAAAAAAAAAAAAAAAAAAACBgatPA4On/8LC5ScAAAANgAAAB8AAAAKAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACAcHkFkNDZr/DAyNvwAAAEAAAAAfAAAABwAAAAUAAAAYFRV/eCMjnv8kJIejAAAANwAA + ABsAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcODqfEDg6l8QAAACQAAAAVAAAACAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLC5iUDg6a/wgIfJEAAAA2AAAAFgAAAAMAAAAKAAAAIA0N + ls4NDZjoAAAAOgAAAB4AAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBAS/JwsL + uIcAAAAQAAAACgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAQDQ2avQ4OnP8BAS1TAAAALAAA + AA4AAAADAAAAEQkJk3wODp//BQVvdgAAADAAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAADAAAAAwAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAFQ4O + nOUNDZfRAAAAPQAAACEAAAAIAAAAAwEBZiMODp7lDQ2V0gAAAEsAAAAxAAAAFQAAAAYAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABQEBVykODp//CgqKlgAAADMAAAAYAAAABAAAAAMKCrFqDg6d/wcHdX8AAABMAAAAPgAA + ACoAAAAZAAAADgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoICJtmDg6g/wICU1YAAAAoAAAAEAAAAAEAAAABCAi/Rw4O + nvENDZe/AgJLWwAAAEkAAABDAAAANwAAACgAAAAYAAAADAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAQDAyfoQ0NntoAAAA1AAAAHgAA + AAgAAAAAAAAAAAAAAAMHB7Q6Dg6g4g4Onv8MDJa2AgJIYAAAAEsAAABDAAAAMwAAACEAAAAQAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAFw4O + oeUJCZOPAAAAKgAAABQAAAADAAAAAAAAAAAAAAAAAAAAAwICoBgMDKiKDg6e/w4Onv8MDJS5AgJJYAAA + AEQAAAAyAAAAGwAAAAoAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABwUFmkMODqPyAQFAPAAAAB8AAAAMAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQUF + rCoNDaKpDg6e/w4On/IJCZSQAAAAMwAAAB8AAAANAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMDK+YDAyorAAAACAAAAATAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAABQQEpCwNDaapDg6n/woKsIAAAAAUAAAACAAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDg6y0QMDmDEAAAAQAAAACAAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAkAAAAKAAAACAAA + AAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQE + 0iQAAAAHAAAABQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /8B/////////wH/////////AP////////8A/////////4D/////////gHg///////+AeB///////8AwH + ///////wDAf///////gEB/////gD+AQH////4AD8BAf////gAHwAB////8AAHAAH////wAAOAAf////A + AAYAB////8AABgAH////wAADAAf////AAAAAB////8AAAAAH////wAAAAAf////gAAAAA////+AAAAAD + ////8AAABAH////wAAAEAf////gAAAYA//8H/AAABgB//wH+AAADAH//AD8AAAAAf/8AB8AAAAB//wAA + wAAAAH//AAAAAAAAf//AAAAAAAB///AAAAAAAP///AAAAAAAP4D/gAAAAAAAAP/gAOAAAAAA//gH8AAA + AAD4AAAwAAAAAPgAABAAAAAA+AAAAAAAAAP4AAAAAAAAf/gAAAAAAAAf+AAAAAAAAA//gAAAAAAAB/// + /gAAAAAH////AAAAAAP////AAAAAA////+DAAAAB/////+AAAgH/////4AAHAf/////gAAcB/////+AA + D4H/////4AA/gf/////AAH/B/////8AAP///////wAAP///////AAAP//////4DAAf//////gOAB//// + //+A8AH//////4H8Af//////gf8B//////+D////KAAAADAAAABgAAAAAQAgAAAAAACAJQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAh7AQICLzIAAAZNAAACDwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmXCw4Oq+wEBCacAAAAPgAA + AQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsL + sZMMDHPYAAAAcAAAAQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAsLsScODqb6AwMfnQAAADYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7G3Cwtk0wAAAGkAAAELAAAAAAAAAAAAAAAAAAAAAAIC + HggAAAA3AAABEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrNPDw+d+wICEZMAAAAqAAAAAAAA + AAAAAAAAAAAAAAsLiIIFBS2jAAAAOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC7EFDAyv4QoK + T8oAAABcAAABBgAAAAAAAAAAAAAAAA4OpbYNDVvZAAAAUQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAACgqyhRAQjPQAAAeJAAABHgAAAAAAAAAAAAAAAAwMqcIPD2/pAAAAWgAAAQMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQoLAAABKQAAAEIAAABKAAAAPAAAABwAAAAFAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAACgq1JA4Opf4HBzi8AAAASgAAAAIAAAAAAAAAAAsLqcoQEHTuAAAAXAAA + AgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEIRUGBjKHDAxMzRAQVN8QEEbaCgonvgEB + BI0AAABXAAAAGgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAoKtMQPD3XpAAABegAAABEAAAAAAAAAAAsL + qc8QEHTtAAAAWAAAAgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBB1BBISgboODpD+Dw+L/xAQ + iP4SEn/+FhZw/hcXWvQKCiK+AAAAewAAAC0AAAADAAAAAAAAAAAAAAAAAAAAAAoKtmgQEJn+BAQfqQAA + ADQAAAAAAAAAAAoKrdEPD3HpAAAAUQAAAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBitRhMT + sP8HB6b/Bwei/wgIoP8JCZz/DQ2R/xMTf/8YGGj+ERE62AAAAYgAAAAyAAAAAwAAAAAAAAAAAAAAAAoK + sxYMDKn2DAxU2AAAAF8AAA0GAAAAAAkJtNsNDWniAAAASQAABAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAGxvIbBERu/8FBa7+Bgan/wYGpv4GBqb+Bwej/goKmv8REYf+GBhs/hMTP94AAAKIAAAAKwAA + AAEAAAAAAAAAAAAAAAALC6uxEhKC+QAAA2wAAA8IAAAAAAoKs9sMDF/aAAAAQQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAGRnLVhYWwP8FBbH+Bgao/wUFpv4FBab+Bgam/gYGpP8KCpz+EBCJ/hgY + bP8QEDbVAAAAeAAAABcAAAAAAAAAAAAAAAAKCpmjERGC9gAAAU4BARUCAAAAAAoKs9sLC1nUAAAAQAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRnLFhoaxvsICLf+BQWr/wUFp/4FBab+BQWm/gYG + pv8GBqX+Cgqc/hERhf8ZGWb+CQkeugAAAFQCAgIGAAAAAAoKhQ4LC5ruDAxc0QAABSgAAAAAAAAAAAoK + stsMDFnXAAAASwAAAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZzqcTE8D/BQWx/wYG + qP8GBqf/Bgan/wYGp/8GBqb/Bgak/wsLmP8UFH3/GBhZ9AEBBI4GBgcoCAg5AwgIhF0ODpX/BgYukwEB + DQ0AAAAAAAAAAAoKsdcODmXlAAAAZAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsb + 0CYcHMn0DQ28/wUFrv4FBaj+BQWm/gYGp/8FBab+Bgam/gcHov8ODpD+Fxdu/gwMLMYAAABOBAQ4AwkJ + m7oPD4T0AAAGSwEBEQIAAAAAAAAAAAoKr88SEoD4AAAEhwAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAlJdNuJyfJ/hAQuv4FBa3+BQWo/gYGp/8FBab+BQWm/gYGpf8KCpv+ExN+/hUV + VO0AAABwAwM6GAsLo/oKClTDAQEJHwAAAAAAAAAAAAAAAAgIu7cQEJj+BgYntAAAAD8AAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKtEBMzPUljU1zP8cHL7/Bgau/wUFqf8GBqf/Bgan/wYG + pv8ICKH/Dw+L/xoabv0DAwuFBARJSA0Nmv4EBCCTAAAIEgAAAAAAAAAAAAAAAAgIvTYLC6/2Dg5q4QAA + AHcAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANzfTAkBA15NERND+NDTG/hUV + tv8GBqz+BQWo/gYGp/8HB6T+FRWV/iwsgP4FBQ+SBAQ8YxAQjf4DAxadAAABJAAAAAAAAAAAAAAAAAAA + AAAJCbpnDw+h/QUFKKsAAABLAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBERUAAABCAAAAHQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEND + 1gFJSdhgUFDV701Nz/9CQsj+MjK//i0tu/8zM7r+PDyx/jY2kf4HByeyBAQmmRMTfP8LCzDEAAAARwAA + AAIAAAAAAAAAAAAAAAAAAAAACwumrhAQduoAAAOIAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJk6oGBkikAAAEcQAAAEsAAAAeAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAUFDXFlNT1YpYWNXlV1fR/lNTzf9PT8r/QUG//xMTnPoMDHrvDAyA+RIS + ev4TE03mAAAAgAAAAC4AAAIHAAABDQAAAxoAAAwgBAQ9WxISh/8KCjbGAAAASAAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJqD4LC6+2DAyU3wYGR6IAAApyAAAAWQAA + ADIAAAASAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLnoHKChsMyQkVVghIVVUEBBzYAgI + qucICKf+Cgqf/hAQiPoWFmz9Dw841QEBBpIBAQZiBQUeigYGKKgGBjOxBQVBvBAQiP4QEGbaAAACMAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqmLwsL + rKANDaPqCQlmwgQEJ5cAAAF1AAAAVQAAAC4AAAASAAAABAAAAAAAAAAAAQELBAQEDxYBAQQ5AQEQbQMD + GY8BAQqGAwMKczY2rPckJLD+ICCv/goKnf8PD4n+FBR1/hERWuwREXD2ERGC/g8Piv8MDJX+Cgqa/w0N + mPIHB0NcBQUqBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCqgbCgquiAwMru0NDZDtCQlWygQEIqUAAAJ+AAAAWAAAATEAAAIyAgIRZQgI + RLANDXjoDw+R/g4Olf8NDZj+CAiA6xAQbNoXF47wBgam/wYGpf8JCZ//CwuX/wwMkf8MDI3/CgqO/gkJ + lu0ICJm6BweCcgUFVBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKrw8KCrRuCwuz2g4Oov4PD4TxCgpR0QYG + O7wLC2vdDg6R/AwMm/4KCprXCQmPgQkJm1sICLSaBga44gUFsv8EBK7+BQWt/gYGqP8GBqb+Bwek/ggI + nv8LC4T8BQUmtwAABloBARQeAQEVIQAADx8AAAsOAAACAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqyBAkJ + t08JCba5Cgqt/QsLpv4KCqHkCAiSkwgIiTkICIsEAAAAAAAAAAAAAAAABwe6BA0NxU8QEMH8BAS1/gUF + q/8FBaf+Bgam/ggIn/8PD4j+EhJk9AcHHrUICCWqCAgrsAQEGJoAAABzAAAAOgAAAAoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAgEAAAEFAAABCwAAABMAAAAaAAAFEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABwezHwgIqywICJgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAiIseTHh68/g4OsP8GBqn/Bgao/wcHo/8LC5b/EBCE/xISeP8TE3P+EhJ8+hISjP0NDWjdAgIUnAAA + AGIAAAAhAAABCwAAAhEAAAIeAAABMgAAAEoAAAZlAwMYgwQEJpoFBTOiAgIXQAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAMDJg1Fxez+yoqtP8WFrL+BQWw/gYGqv8HB6P+CQmd/gwMkv8ODm/0AgIQkgQE + RGINDZjfERGJ+AgIPcAAAAaHAgIQewUFJ5cICEK3Cwtf1A0NfOsPD5H6Dw+a/w8PnuYNDYuiBgZGHAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAEEwAAACYAAAAqAAAALQAAADAAAAAwAAAAMAAAADAAAAAwAAAALwAA + ACsAAAApAAAAIAAAAAkAAAAAAAAAAAAAAAAGBrOcBgak/gwMaM0zM6vgICC//gYGsf8GBqj+Bgak/gsL + l/8SEnv+BwcouAAAAEoBARBeCQlexRAQkP0ODo/5Dg6Y/Q0Nnv4LC6T7Cwun0wsLp58LC6ZoDAyiLQwM + mAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBXgeBQVLiQcHQ7gICEDACQlGxQkJRcYJCUXGCQlFxgkJ + RcYJCUbGCAg9wggIOr8ICDS5AgIRmQAAAGAAAAAZAAAGAQAAAAAGBrLLCwuZ/wMDIZITE0sqQUHI0jQ0 + wf8YGLL/DAyr/w4Onv8aGoX/FBRH1g0NVdkNDWjrBwcyxAICHZsFBVeMBwd9WgkJkjEKCqUIAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBqEvCQm2ugoKsvQLC6j+Cwul/gwM + o/8MDKL+DAyj/wwMo/4MDKP+DAyj/g0Nov8PD5v+EhKI+QcHMrcAAAByAAACKQICOQYICKHWEBCN/gIC + D3gKCjkJExOokkZGwv9ISMH+ODjB/isrt/8kJKL+EhKF/Q4Oif4QEIb+ExN2/wwMOtEAAAB2AQEXFgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJ + twsICLYoCQmvPAkJrD8JCas/CQmtNQkJry0JCbIlCQm1HAoKsiMLC61ICwuvrQ8PofwJCVPFAAAFhwAA + AF0KCoPoEhJ/+gAAAFkEBEIEBgawwAoKe903N3qsT0/K2zs7ueUWFqn5CAij/wgIof8KCpr/ERGG/xgY + af4ICB64AAAATAAAAwMAAAwCAAAEFAAAAC8AAAAaAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK + s1ALC7DrCwuU8wcHcN8MDIv6Dg5p2wAABy0AAAAABwe4ygYGV8sAAABSERFVEAMDmNQFBav+Bgao/wYG + pv4HB6T+CwuY/xQUe/4WFlPuAAABgQAAAigBARFRCAhIqAcHPa8AAABrAAABFQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAICLcjBgbBvgcHtv4LC6f5BgZEYwQEKQYAAAAACAi0mgwMiO0AAASEBwdIcAgI + tP8FBa/+Bgao/wUFpv4GBqb+CAih/w4Ojv4WFm/+BwclugkJUMENDZTpCgqAlRAQoOkFBTGfAAAATQAA + AQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABga/AgcHvSoHB54fAAAAAAAAAAAAAAAACQm0LwwM + qv0GBju5DQ08kSgovv8fH73/FRWw/w0Nqv8HB6f/Bgal/woKmv8REYX/ExN//AoKaaMGBlEgAAAAAAsL + qF8ODo3oAAAFfAAAARwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAkJt6ULC4rtAQEIgzExodA6Osr+NjbE/zIyu/4uLrb+KSmy/ycnqv4oKJj+CwsyiQQE + JwoAAAAAAAAAAAoKqgUMDLHXBwdAsQAAAE4AAAEDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKsSkMDKT6BAQxsAkJHD5ERMK0TEzR/khIyv5ERMP+QUG7/z8/ + sf4zM5DZBQUTIwAAAAAAAAAAAAAAAAAAAAALC7BpDg6L6AAAAXgAAAEXAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqQYNDaPrCAhHvAUFESAnJ24CSkrFUFNT + zrxWVsb7UlK29T4+k6kiIl0jGxtOAQAAAAAAAAAAAAAAAAAAAAAKCrMODQ2x7AUFNqEAAAA1AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqiYODp3+BQUqlAIC + DA4AAAAAAAAAABYWbysJCaDzAgIeYBwcSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgq0eQkJ + iaUBARgSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK + qlcODpX6AQEKXQEBDAMAAAAACQlnAgkJgLYICF66AgITFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAYGgwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAsLqIsLC3LaAAAEMQAAAAAAAAAABweHSg0NlvcBAQ9dAQERBQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLqMIGBkGjAQEOEwAAAAAAAAAACAi7ogkJds0AAAFzAAAAQQAA + ABMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqdCQ0NovIBARFcAQESBAAAAAAAAAAACAiyIgoK + t9ILC4DXBAQrngAAAHMAAABBAAAAEgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmQSAoKd9EAAAgoAAAAAAAA + AAAAAAAAAAAAAAkJrgoKCrOCDQ2s8wwMedwEBCafAAAAbwAAAC0AAAIDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmRnwQE + N4MBARYKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqzGwoKtpcODqn1CgprxwAACFIAAAMJAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAICK4QCQmiyQEBESEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrAdCgqieQUF + ThkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAICLAFBQWDKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//8P///wAA///wf/// + AAD///h///8AAP//+D7//wAA///8PH//AAD///w8f/8AAP///Bw//wAA//P+HD//AAD/wH4MP/8AAP+A + Hww//wAA/wAPDD//AAD/AAcEP/8AAP8AA4R//wAA/wADhH//AAD/AAEMP/8AAP+AAAw//wAA/4AADD// + AAD/wAAcH/8AAP/AABwf/wAAv+AAHg//AAAP8AAPD/8AAAP8AAAH/wAAAH8AAA//AADADAAAD/8AAPAA + AAA//wAA/AAAAA//AAD/AHAAB8AAAP/j/AAAAAAA///8AAAAAAD4ABwAAAMAAPAABAAAfwAA8AAAAAH/ + AAD8AAAAAAcAAP//wEAABwAA///gQAADAAD///HAAEMAAP///+AAwQAA////4AHhAAD////gAeEAAP// + /+GH8QAA////4Q/7AAD////jD/8AAP///+MD/wAA////wwD/AAD////HgH8AAP///8fgfwAA////j/j/ + AAD///+f//8AACgAAAAgAAAAQAAAAAEAIAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiaBgQEPm8AAAIvAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ2nxAEB + EHoAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAALC7FbCQlVxgAAAC4AAAAAAAAAAAAAAAAAAAcEAAABBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAoKtgYNDZ3hAAAHbgAAAAMAAAAAAAAAAAgIWG8AAABIAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLr4oICEC6AAAAIAAAAAAAAAAADw+e0AICEXcAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQELAQAA + AhYAAAAvAAAAKwAAAA4AAAAAAAAAAAAAAAAAAAAACgq2KA0Nhu4AAAFaAAAAAQAAAAANDaDaBAQdhgAA + AQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAHBzxbDQ1b1BERYOoQEEPZBQUUnQAAAEIAAAAFAAAAAAAAAAAAAAAADAysyAUFJqQAAAAQAAAAAA0N + od8EBB2CAAABAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAFhagIBAQqfoJCZ7/Cgqa/w4OjP8WFnH+Dg40zwAAAF0AAAAHAAAAAAAAAAAKCrNtDAxi3QAA + ADsAAAAADAyn5QMDGHUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAaGslGDg65/wUFqP8GBqb/Bgak/woKmf8UFHr/EBA71wAAAFYAAAADAAAAAAkJ + qBoQEI/8AAADSAAAAAAMDKfnAgIOZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZzBoUFMH9BQWs/wYGp/8GBqf/Bgam/woKm/8VFXf/DAwpwQAA + AC8AAAAACQmOQw0Nd+cAAAchAAAAAA0NpucBAQxqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoay64KCrf/BQWp/wYGp/8GBqf/Bgal/wwM + lf8XF2f6AgIJgAcHKgoKCo+jCAhFqgEBCwYAAAAADQ2k4gQEGY8AAAAGAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHx/RICIiyfAKCrT/BQWo/wYG + p/8GBqf/Bwei/xISg/8NDTLGAgIlIwwMm/ECAhZSAAAAAAAAAAAKCq/UCQlAxQAAACQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMjLTRDU1 + zPYWFrj/BQWq/wYGp/8GBqb/DQ2T/xcXVOIDAy9WDAx25wAABDIAAAAAAAAAAAgIvFMODovxAAAEaQAA + AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRkAAAAcAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAARETWOExM1N87O8f/JSW6/yAgtf8tLaz/KChx7QMDH4kSEnH1AAAAWgAAAAAAAAAAAAAAAAoK + npEJCUTCAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQmSqwUFOpsAAAJRAAAAIAAA + AAUAAAAAAAAAAAAAAAAAAAAATU3OCU1Nw21PT8S+Tk7B2jo6vNsNDZbsCwuK+xMTd/0HBxqqAAAAOgAA + ASAAAAM6AgIjXxMTffoBAQpnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrAFCwuqXwsL + lrgHB0+wAQESdQAAAEMAAAAaAAAABAAAAAAICBkCDQ0lFAgIGkMBAQ9qAwMRWiMjrvsZGaz/DQ2T/hUV + cf0MDELSDg5k4w4Oe/QKCor2DQ2G4QQEJSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAACgqyAQoKrkgMDK25Cwt84QcHQLsCAg9+AAAGUQUFMYgKCmjUDQ2V9wwMm+4JCZX2EBCE6AgI + pv8GBqX/CQmc/wsLk/8JCXTsBgZspgUFalsEBD8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCrUuCgqymwwMpfMMDJn4CgqWxQkJkmwICIkVCAiiAgYG + ujgMDMGwBga2/wUFqf8GBqb/CgqZ/w4OXusEBBWVBQUchwEBC3AAAAA0AAAABQAAAAAAAAAAAAAAAAAA + AQEAAAAGAAAADgAAAg0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgaPDQYGihQAAAAAAAAAAAAA + AAAAAAAAAAAAABYWvxEfH7PdEhKw/wUFqv8ICKL/DQ2P/xERff8ODl7fDw+F5AkJSMUAAANnAAAAJwAA + ATABAQtSBAQlgQcHPacJCU+9BQU2aAAAAAAAAAAAAAAAAAAACgkAAAAaAAAAHQAAACAAAAQgAAAEIAAA + ACAAAAAcAAAAFwAAAAQAAAAACgqrDQYGqPQeHovbHh67/gYGrf8HB6T/DQ2P/wkJOscBARRJCQljxQ4O + eesKCmzdDAyJ8A0Nn+kMDKK2DAyifQwMlj0KCnEDAAAAAAAAAAAAAAAABgZ9mAkJY9EKCmHXCwth2AsL + YdkLC2HZCgpd1wsLV9MJCT2/AAACYwAABA4EBH40Cwue/wICFGYuLqqGNzfA/xsbsv8XF5//GBhn7A4O + auoMDFPfAwMmnwUFVU4ICIoZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLcaCAi4XAkJ + sXoJCax/CQmsegkJr3IJCbJpCgqucQwMqbUMDHXfAQEOgAICMm8QEIr9AQEPRAcHk3klJYrbSEi93zEx + tvINDZ/9Cgqb/xAQh/8SEk7lAAACWAAADQEAAAgJAAAAHQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKs1QKCqfrCAiK7w0NcdcCAiEWBwefgQUF + QbcICDYxBASk6wUFqf8GBqb/CQmd/xUVeP8ICB6sAgIXVwkJXLUICEKyAAAAOQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGwR0HB7dyBwdwKAAA + AAAICKwyCwuI6ggILI0cHLz/ERGw/wkJqP8GBqX/DQ2S/xERbvMLC3CnCAhxIw0NpawDAx2JAAABDgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCrCtBQU1rC8vlsE9Pcn/Nze+/zAwtv8tLaf/FBRLnAUFLAQAAAAACgqyKwoK + cNMAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKrFAKCmDSDg4sHEdHvXNSUszfUFC8+js7la4XF0MTAAAAAAAA + AAAAAAAADAyutwICGX0AAAEGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwupdggIR64DAw4HAAAAAA4Of4UEBDx8GhpDAQAA + AAAAAAAAAAAAAAAAAAAKCrA1BgZpUAAAEQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKSpAwMhagAAAAAGBngiCgp51wAA + DRkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLks8AAAsnAAAAAAgI + tlcICGrGAAAFYgAAACMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCZYjBwdZrwEB + DggAAAAAAAAAAAkJs1oMDJnXBwdDtAAAA2EAAAEWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJ + m3gCAiFKAAAAAAAAAAAAAAAAAAAAAAoKtwwLC7J5DAyS0QEBFzQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAABgaTRAMDPQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCaYBAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA//j////8f////HP///wz///+Mf/8HhH//AcR//gDE//4ARP/+AET//wAEf/8ADH//gAw/x8A + OP8HgAD/AIAA/8AAAf/4AABw/nwAAOAEAADgAAAf4AAAA//wAAP/+IAB///AEf//wDj//8R4///I//// + yD///4wf//+eH///n78oAAAAEAAAACAAAAABACAAAAAAAEAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABARTAQUFPncAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC5aCAAACKAAAAAACAhgwAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAMFAAAAFgAAAAMAAAAACAicLAUFMogAAAAACQlbqgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAKCkwICwt3yg4OcvAKCi6rAAAAGgAAAAAKCnquAgI0EwgIX68AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAADw+AGAsLtP4GBqb/DAyV/wwMN7sCAhcMDAyPkAICNhoHB1qnAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGcevBwer/wYGpv8PD4j9BgYiXQgIYaQDA0kBCQlrwwAA + AAoAAAAAAAAAAAAAAAAAAAAAAAACDQAAAAAAAAAAJyenETc3y8MbG7T/GBim/xERRasHBzuaAAAAAAkJ + lXUCAhJYAAAAAAAAAAAAAAAAAAAAAAgIimsEBDp2AAAELwMDCwcmJmsDLCxyYCMjZ54VFZ74Dw9l6QYG + KoQGBkuhCQlNmgAAAAAAAAAAAAAAAAAAAAAAAAAABweNEgoKp3IICGqyBwdZpgoKhpMJCaOHCgqo5QcH + pP8LC4D1BQVChwICGywAAAABAAAAAAAAAAIAAAAGAAAAAAAADwIBASMOAgJDEwMDPxUBASINAgIzARER + sXwVFaj2CAih/w0NaekJCVGuBgY6lgYGTZcJCWmWCQljWQAAAAAGBposCQmLoAoKhqsKCoiiCwt7rgMD + InQICHaoDg5YajAwru4bG5f2DQ148gYGM4sEBEwJAwM5CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAICLVXCQmJmAUFazIICEuYDg6u+ggIpP8PD2XnBwdVdgYGQYgAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAACQl9nzAwkpRCQr/2JSVzlwMDLwELC6JtAAAGMQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJbo4JCUQKBwdRfAAAAAAAAAAABQV6DQMDShQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFWQkFBUFrBQV2FQcHb5YBARJPAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBpIvAQEbEwAAAAAFBXkDCgqpUwICJA0AAAAAAAAAAPx/ + AAD+XwAA4k8AAMEfAADAHwAA4A8AAGBPAAAADwAAgAQAAIAAAACAAQAA/AAAAP+AAAD/jAAA/wMAAP8j + AAA= + + + + True + + + $this + + + 0, 0, 0, 0 + + + Bottom, Left + + + splitContainer + + + 0, 0, 0, 4 + + + True + + + Use Anti-Aliasing + + + 118, 23 + + + 8, 43 + + + Top, Bottom, Left, Right + + + True + + + False + + + False + + + German + + \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..7b43be9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,28 @@ +AntMe! Community License +Version 1.0, September 2008 + +The AntMe! Community License version 1.0 ("ACL") consists of the Microsoft Public License, +modified to prohibit commercial use of the software licensed with this license. +The original Microsoft Public License can be found at: http://www.microsoft.com/opensource/licenses.mspx#Ms-PL + +This license governs use of the accompanying software. If you use the software, you +accept this license. If you do not accept the license, do not use the software. + +1. Definitions +The terms "reproduce," "reproduction," "derivative works," and "distribution" have the +same meaning here as under U.S. copyright law. +A "contribution" is the original software, or any additions or changes to the software. +A "contributor" is any person that distributes its contribution under this license. +"Licensed patents" are a contributor's patent claims that read directly on its contribution. + +2. Grant of Rights +(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create. +(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software. + +3. Conditions and Limitations +(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks. +(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your patent license from such contributor to the software ends automatically. +(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software. +(D) If you distribute any portion of the software in source code form, you may do so only under this license by including a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object code form, you may only do so under a license that complies with this license. +(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement. +(F) It is not allowed to redistribute and/or use this software for commercial purposes. diff --git a/OnlineClient/AntMe.snk b/OnlineClient/AntMe.snk new file mode 100644 index 0000000..cdd75a4 Binary files /dev/null and b/OnlineClient/AntMe.snk differ diff --git a/OnlineClient/Client.cs b/OnlineClient/Client.cs new file mode 100644 index 0000000..17ba387 --- /dev/null +++ b/OnlineClient/Client.cs @@ -0,0 +1,89 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; + +namespace AntMe.Online.Client +{ + /// + /// Connection Client for the AntMe! Online Legacy Controller. + /// + public sealed class Client + { + /// + /// Indicates a logged in user. + /// + public bool LoggedIn { get; private set; } + + /// + /// Returns the Login Name of the current user. + /// + public string Username { get; private set; } + + public Client() + { + + } + + /// + /// Tries to log in with some saved tokens. + /// + public void Login() + { + + } + + /// + /// Uses the given Token to log in. + /// + /// Token + public void Login(string token) + { + + } + + /// + /// Uses the given Credentials to log in. + /// + /// Email Address + /// Password + public void Login(string email, string password) + { + using (var client = HttpConnection.CreateAuthClient()) + { + HttpContent requestContent = new StringContent( + "grant_type=password&scope=api&username=" + Uri.EscapeUriString(email) + "&password=" + Uri.EscapeUriString(password), + Encoding.UTF8, "application/x-www-form-urlencoded"); + Task requestTask = client.PostAsync("/identity/connect/token", requestContent); + + HttpConnection.HandleTask(requestTask); + + if (requestTask.Result.IsSuccessStatusCode) + { + + } + else + { + } + } + } + + /// + /// Checks for newer Versions. + /// + public void CheckForUpdates() + { + + } + + /// + /// Logs the current user out. + /// + public void Logout() + { + + } + } +} diff --git a/OnlineClient/HttpConnection.cs b/OnlineClient/HttpConnection.cs new file mode 100644 index 0000000..649a0eb --- /dev/null +++ b/OnlineClient/HttpConnection.cs @@ -0,0 +1,94 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net.Http; +using System.Net.Http.Headers; +using System.Text; +using System.Threading.Tasks; + +namespace AntMe.Online.Client +{ + internal static class HttpConnection + { + private static int timeout = 1000; + + //private static Uri authUri = new Uri("http://antmeservice.azurewebsites.net/"); + private static Uri authUri = new Uri("https://localhost:44303/"); + + + + private static Uri baseUri = new Uri("http://antmeapi.azurewebsites.net/"); + + public static string Token = string.Empty; + + public static Guid ClientId = Guid.Empty; + + public static string ClientVersion = string.Empty; + + internal static HttpClient CreateClient() + { + var client = new HttpClient(); + + client.BaseAddress = baseUri; + client.DefaultRequestHeaders.Accept.Clear(); + client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); + + client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("AntMeClient", ClientVersion)); + client.DefaultRequestHeaders.From = ClientId.ToString() + "@antme.net"; + + if (!string.IsNullOrEmpty(Token)) + client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token); + + return client; + } + + internal static HttpClient CreateAuthClient() + { + var client = new HttpClient(); + + client.BaseAddress = authUri; + client.DefaultRequestHeaders.Accept.Clear(); + client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); + + client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("AntMeClient", ClientVersion)); + client.DefaultRequestHeaders.From = ClientId.ToString() + "@antme.net"; + + return client; + } + + internal static T Post(string url, object request) + { + using (var client = CreateClient()) + { + HttpContent content = new StringContent( + JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json"); + + Task requestTask = client.PostAsync(url, content); + HandleTask(requestTask); + + if (requestTask.Result.IsSuccessStatusCode) + { + Task responseTask = requestTask.Result.Content.ReadAsStringAsync(); + HandleTask(responseTask); + + return JsonConvert.DeserializeObject(responseTask.Result); + } + else + { + Task errorTask = requestTask.Result.Content.ReadAsStringAsync(); + HandleTask(errorTask); + throw new Exception(errorTask.Result); + } + } + } + + internal static void HandleTask(Task t) + { + if (!t.Wait(timeout)) + throw new TimeoutException(); + if (t.IsFaulted) + throw t.Exception; + } + } +} diff --git a/OnlineClient/OnlineClient.csproj b/OnlineClient/OnlineClient.csproj new file mode 100644 index 0000000..92a3a44 --- /dev/null +++ b/OnlineClient/OnlineClient.csproj @@ -0,0 +1,75 @@ + + + + + Debug + AnyCPU + {7FDBAFAC-4682-4D47-A95A-6D5A9B82248E} + Library + Properties + AntMe.Online.Client + AntMe.Online.Client + v4.0 + 512 + SAK + SAK + SAK + SAK + + + true + full + false + ..\bin\ + DEBUG;TRACE + prompt + 4 + x86 + + + pdbonly + true + ..\bin\ + TRACE + prompt + 4 + x86 + + + true + + + AntMe.snk + + + + False + ..\packages\Newtonsoft.Json.6.0.6\lib\net40\Newtonsoft.Json.dll + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/OnlineClient/Properties/AssemblyInfo.cs b/OnlineClient/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..46fb962 --- /dev/null +++ b/OnlineClient/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 attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("AntMe! Client for the Online Platform")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("AntMe! GmbH")] +[assembly: AssemblyProduct("AntMe!")] +[assembly: AssemblyCopyright("Copyright © 2014 AntMe! GmbH")] +[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("3cb2f6c9-0ab5-4a62-a50b-10b184360251")] + +// 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("1.7.0.2")] +[assembly: AssemblyFileVersion("1.7.0.2")] diff --git a/OnlineClient/packages.config b/OnlineClient/packages.config new file mode 100644 index 0000000..6f5b1e0 --- /dev/null +++ b/OnlineClient/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/Setup/Config.wxi b/Setup/Config.wxi new file mode 100644 index 0000000..d1b2ce9 --- /dev/null +++ b/Setup/Config.wxi @@ -0,0 +1,56 @@ + + + + + + + + + + + + + + + + + diff --git a/Setup/Product.wxs b/Setup/Product.wxs new file mode 100644 index 0000000..5ce7bc0 --- /dev/null +++ b/Setup/Product.wxs @@ -0,0 +1,218 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Setup/Setup.wixproj b/Setup/Setup.wixproj new file mode 100644 index 0000000..444125b --- /dev/null +++ b/Setup/Setup.wixproj @@ -0,0 +1,129 @@ + + + + Debug + x86 + 3.8 + ec7aa916-0218-436f-b4dc-510bdb769260 + 2.0 + AntMe + Package + $(MSBuildExtensionsPath32)\Microsoft\WiX\v3.x\Wix.targets + $(MSBuildExtensionsPath)\Microsoft\WiX\v3.x\Wix.targets + SAK + SAK + SAK + SAK + + + bin\$(Configuration)\ + obj\$(Configuration)\ + Debug + + + bin\$(Configuration)\ + obj\$(Configuration)\ + + + + + + + AntMe.Online.Client + {43e44b6c-78f6-4515-88f2-c238b51886c5} + True + True + Binaries;Content;Satellites + INSTALLFOLDER + + + AntMe + {931d5011-ae62-420d-8503-f5441136876a} + True + True + Binaries;Content;Satellites + INSTALLFOLDER + + + DemoAmeisen + {b53ecad8-961b-4179-bb46-993da25da6df} + True + True + Binaries;Content;Satellites + INSTALLFOLDER + + + GdiPlusPlugin + {4083b1e6-5eb5-4e51-bb09-eec4b489f355} + True + True + Binaries;Content;Satellites + INSTALLFOLDER + + + SharedComponents + {415f50c3-bd70-4634-b1f7-a15b42f0b0c6} + True + True + Binaries;Content;Satellites + INSTALLFOLDER + + + SimulationCore + {35753e72-07f3-4f18-916c-479850ec375f} + True + True + Binaries;Content;Satellites + INSTALLFOLDER + + + SimulationPlugin + {d622f308-35a9-4a86-8f2c-4e68ceca7c11} + True + True + Binaries;Content;Satellites + INSTALLFOLDER + + + XnaPlugin + {4fdd2b0d-c481-401e-a794-2111bf15f39e} + True + True + Binaries;Content;Satellites + INSTALLFOLDER + + + + + + + + + + + + + + + $(WixExtDir)\WixUtilExtension.dll + WixUtilExtension + + + $(WixExtDir)\WixUIExtension.dll + WixUIExtension + + + $(WixExtDir)\WixNetFxExtension.dll + WixNetFxExtension + + + + + \ No newline at end of file diff --git a/Setup/antme.ico b/Setup/antme.ico new file mode 100644 index 0000000..aebbe09 Binary files /dev/null and b/Setup/antme.ico differ diff --git a/Setup/assets/AntMe.rtf b/Setup/assets/AntMe.rtf new file mode 100644 index 0000000..8d5d3a2 --- /dev/null +++ b/Setup/assets/AntMe.rtf @@ -0,0 +1,224 @@ +{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff0\deff0\stshfdbch0\stshfloch31506\stshfhich31506\stshfbi31506\deflang1031\deflangfe1031\themelang1031\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f2\fbidi \fmodern\fcharset0\fprq1{\*\panose 02070309020205020404}Courier New;} +{\f3\fbidi \froman\fcharset2\fprq2{\*\panose 05050102010706020507}Symbol;}{\f10\fbidi \fnil\fcharset2\fprq2{\*\panose 05000000000000000000}Wingdings;}{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria Math;} +{\f37\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} +{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhimajor\f31502\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria;} +{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} +{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;} +{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f39\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\f40\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} +{\f42\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f43\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f44\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f45\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} +{\f46\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f47\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f59\fbidi \fmodern\fcharset238\fprq1 Courier New CE;}{\f60\fbidi \fmodern\fcharset204\fprq1 Courier New Cyr;} +{\f62\fbidi \fmodern\fcharset161\fprq1 Courier New Greek;}{\f63\fbidi \fmodern\fcharset162\fprq1 Courier New Tur;}{\f64\fbidi \fmodern\fcharset177\fprq1 Courier New (Hebrew);}{\f65\fbidi \fmodern\fcharset178\fprq1 Courier New (Arabic);} +{\f66\fbidi \fmodern\fcharset186\fprq1 Courier New Baltic;}{\f67\fbidi \fmodern\fcharset163\fprq1 Courier New (Vietnamese);}{\f379\fbidi \froman\fcharset238\fprq2 Cambria Math CE;}{\f380\fbidi \froman\fcharset204\fprq2 Cambria Math Cyr;} +{\f382\fbidi \froman\fcharset161\fprq2 Cambria Math Greek;}{\f383\fbidi \froman\fcharset162\fprq2 Cambria Math Tur;}{\f386\fbidi \froman\fcharset186\fprq2 Cambria Math Baltic;}{\f387\fbidi \froman\fcharset163\fprq2 Cambria Math (Vietnamese);} +{\f409\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\f410\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\f412\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\f413\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;} +{\f416\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\f417\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} +{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} +{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} +{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} +{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);} +{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);} +{\fhimajor\f31528\fbidi \froman\fcharset238\fprq2 Cambria CE;}{\fhimajor\f31529\fbidi \froman\fcharset204\fprq2 Cambria Cyr;}{\fhimajor\f31531\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\fhimajor\f31532\fbidi \froman\fcharset162\fprq2 Cambria Tur;} +{\fhimajor\f31535\fbidi \froman\fcharset186\fprq2 Cambria Baltic;}{\fhimajor\f31536\fbidi \froman\fcharset163\fprq2 Cambria (Vietnamese);}{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} +{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} +{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} +{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} +{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);} +{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);} +{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;} +{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} +{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;} +{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;} +{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\fhiminor\f31576\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\fbiminor\f31578\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} +{\fbiminor\f31579\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbiminor\f31581\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbiminor\f31582\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} +{\fbiminor\f31583\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbiminor\f31584\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbiminor\f31585\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} +{\fbiminor\f31586\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}}{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0; +\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;}{\*\defchp +\f31506\fs22\lang1031\langfe1033\langfenp1033 }{\*\defpap \ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 }\noqfpromote {\stylesheet{\ql \li0\ri0\sa200\sl276\slmult1 +\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \f31506\fs22\lang1031\langfe1033\cgrid\langnp1031\langfenp1033 \snext0 \sqformat \spriority0 Normal;}{\*\cs10 \additive +\ssemihidden \sunhideused \spriority1 Default Paragraph Font;}{\* +\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\trcbpat1\trcfpat1\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv \ql \li0\ri0\sa200\sl276\slmult1 +\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31506\afs22\alang1025 \ltrch\fcs0 \f31506\fs22\lang1031\langfe1033\cgrid\langnp1031\langfenp1033 \snext11 \ssemihidden \sunhideused Normal Table;}{ +\s15\ql \li720\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin720\itap0\contextualspace \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \f31506\fs22\lang1031\langfe1033\cgrid\langnp1031\langfenp1033 +\sbasedon0 \snext15 \sqformat \spriority34 \styrsid8653746 List Paragraph;}}{\*\listtable{\list\listtemplateid1311304988\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\leveltext +\leveltemplateid67567617\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li720\lin720 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567619 +\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li1440\lin1440 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;} +\f10\fbias0 \fi-360\li2160\lin2160 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567617\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 +\fi-360\li2880\lin2880 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li3600\lin3600 }{\listlevel +\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li4320\lin4320 }{\listlevel\levelnfc23\levelnfcn23\leveljc0 +\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567617\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li5040\lin5040 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0 +\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li5760\lin5760 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360 +\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li6480\lin6480 }{\listname ;}\listid375471935}{\list\listtemplateid1596598432\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0 +\levelstartat1\levelspace360\levelindent0{\leveltext\leveltemplateid67567617\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li720\lin720 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360 +\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li1440\lin1440 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext +\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li2160\lin2160 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567617 +\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li2880\lin2880 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 +\fi-360\li3600\lin3600 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li4320\lin4320 } +{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567617\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li5040\lin5040 }{\listlevel\levelnfc23\levelnfcn23 +\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li5760\lin5760 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0 +\levelstartat1\lvltentative\levelspace360\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li6480\lin6480 }{\listname ;}\listid1886598068}}{\*\listoverridetable{\listoverride\listid375471935 +\listoverridecount0\ls1}{\listoverride\listid1886598068\listoverridecount0\ls2}}{\*\rsidtbl \rsid8653746\rsid9577401\rsid12549834}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0 +\mnaryLim1}{\info{\author Tom Wendel}{\operator Tom Wendel}{\creatim\yr2014\mo4\dy9\hr16\min17}{\revtim\yr2015\mo1\dy4\hr20\min2}{\version2}{\edmins0}{\nofpages2}{\nofwords406}{\nofchars2558}{\nofcharsws2959}{\vern49167}}{\*\xmlnstbl {\xmlns1 http://schem +as.microsoft.com/office/word/2003/wordml}}\paperw11906\paperh16838\margl1417\margr1417\margt1417\margb1134\gutter0\ltrsect +\deftab708\widowctrl\ftnbj\aenddoc\hyphhotz425\trackmoves0\trackformatting1\donotembedsysfont1\relyonvml0\donotembedlingdata0\grfdocevents0\validatexml1\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0 +\showxmlerrors1\noxlattoyen\expshrtn\noultrlspc\dntblnsbdb\nospaceforul\formshade\horzdoc\dgmargin\dghspace180\dgvspace180\dghorigin1417\dgvorigin1417\dghshow1\dgvshow1 +\jexpand\viewkind1\viewscale100\pgbrdrhead\pgbrdrfoot\splytwnine\ftnlytwnine\htmautsp\nolnhtadjtbl\useltbaln\alntblind\lytcalctblwd\lyttblrtgr\lnbrkrule\nobrkwrptbl\snaptogridincell\allowfieldendsel\wrppunct +\asianbrkrule\rsidroot9577401\newtblstyruls\nogrowautofit\usenormstyforlist\noindnmbrts\felnbrelev\nocxsptable\indrlsweleven\noafcnsttbl\afelev\utinl\hwelev\spltpgpar\notcvasp\notbrkcnstfrctbl\notvatxbx\krnprsnet\cachedcolbal \nouicompat \fet0 +{\*\wgrffmtfilter 2450}\nofeaturethrottle1\ilfomacatclnup0\ltrpar \sectd \ltrsect\linex0\headery708\footery708\colsx708\endnhere\sectlinegrid360\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl2 +\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl6 +\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang +{\pntxtb (}{\pntxta )}}\pard\plain \ltrpar\ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 +\f31506\fs22\lang1031\langfe1033\cgrid\langnp1031\langfenp1033 {\rtlch\fcs1 \af0 \ltrch\fcs0 \b\fs32\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 AntMe! Community License}{\rtlch\fcs1 \af0 \ltrch\fcs0 +\b\fs32\lang1033\langfe1033\langnp1033\insrsid9577401\charrsid8653746 +\par }\pard \ltrpar\ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid8653746 {\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746 Version 1.0, September 2008}{\rtlch\fcs1 +\af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 +\par The AntMe! Community License version 1.0 ("ACL") consists of the Microsoft Public License, modified to prohibit commercial use of the software licensed with this license. +\par The original Microsoft Public License can be found at: http://www.microsoft.com}{\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746 /opensource/licenses.mspx#Ms-PL}{\rtlch\fcs1 \af0 \ltrch\fcs0 +\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 +\par This license governs use of the accompanying software. If you use the software, you accept this license. If you do not accept the license, do not use the software.}{\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid9577401 +\par }{\rtlch\fcs1 \af0\afs28 \ltrch\fcs0 \b\fs28\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 Definitions +\par }{\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 +The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under U.S. copyright law. A "contribution" is the original software, or any additions or changes to the software. A " +contributor" is any person that distributes its contribution under this license. "Licensed patents" are a contributor's patent claims that read directly on its contribution.}{\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746 + +\par }{\rtlch\fcs1 \af0\afs28 \ltrch\fcs0 \b\fs28\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 Grant of Rights +\par {\listtext\pard\plain\ltrpar \s15 \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f3\fs22\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}\pard\plain \ltrpar\s15\ql \fi-360\li720\ri0\sa200\sl276\slmult1 +\widctlpar\wrapdefault\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin720\itap0\pararsid8653746\contextualspace \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \f31506\fs22\lang1031\langfe1033\cgrid\langnp1031\langfenp1033 {\rtlch\fcs1 \af0 \ltrch\fcs0 +\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 Copyright Grant- Subject to the terms of this license, including th +e license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any d +erivative works that you create.}{\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746 +\par {\listtext\pard\plain\ltrpar \s15 \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f3\fs22\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}{\rtlch\fcs1 \af0 \ltrch\fcs0 +\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 +Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to ma +ke, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.}{\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746 +\par }\pard\plain \ltrpar\ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid8653746 \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \f31506\fs22\lang1031\langfe1033\cgrid\langnp1031\langfenp1033 { +\rtlch\fcs1 \af0\afs28 \ltrch\fcs0 \b\fs28\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 Conditions and Limitations +\par {\listtext\pard\plain\ltrpar \s15 \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f3\fs22\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}\pard\plain \ltrpar\s15\ql \fi-360\li720\ri0\sa200\sl276\slmult1 +\widctlpar\wrapdefault\aspalpha\aspnum\faauto\ls2\adjustright\rin0\lin720\itap0\pararsid8653746\contextualspace \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \f31506\fs22\lang1031\langfe1033\cgrid\langnp1031\langfenp1033 {\rtlch\fcs1 \af0 \ltrch\fcs0 +\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.}{\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746 + +\par {\listtext\pard\plain\ltrpar \s15 \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f3\fs22\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}{\rtlch\fcs1 \af0 \ltrch\fcs0 +\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your patent license from such contributor to the software ends automatically.}{ +\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746 +\par {\listtext\pard\plain\ltrpar \s15 \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f3\fs22\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}{\rtlch\fcs1 \af0 \ltrch\fcs0 +\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software.}{\rtlch\fcs1 \af0 \ltrch\fcs0 +\lang1033\langfe1033\langnp1033\insrsid8653746 +\par {\listtext\pard\plain\ltrpar \s15 \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f3\fs22\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}{\rtlch\fcs1 \af0 \ltrch\fcs0 +\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 If you distribute any portion of the software in source + code form, you may do so only under this license by including a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object code form, you may only do so under a license that complies with thi +s license.}{\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746 +\par {\listtext\pard\plain\ltrpar \s15 \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f3\fs22\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}{\rtlch\fcs1 \af0 \ltrch\fcs0 +\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 +The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent +permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement.}{\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746 +\par {\listtext\pard\plain\ltrpar \s15 \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f3\fs22\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}{\rtlch\fcs1 \af0 \ltrch\fcs0 +\lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 It is not allowed to redistribute and/or use this software for commercial purposes.}{\rtlch\fcs1 \af0 \ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid8653746\charrsid8653746 +\par }{\*\themedata 504b030414000600080000002100e9de0fbfff0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb4ec3301045f748fc83e52d4a +9cb2400825e982c78ec7a27cc0c8992416c9d8b2a755fbf74cd25442a820166c2cd933f79e3be372bd1f07b5c3989ca74aaff2422b24eb1b475da5df374fd9ad +5689811a183c61a50f98f4babebc2837878049899a52a57be670674cb23d8e90721f90a4d2fa3802cb35762680fd800ecd7551dc18eb899138e3c943d7e503b6 +b01d583deee5f99824e290b4ba3f364eac4a430883b3c092d4eca8f946c916422ecab927f52ea42b89a1cd59c254f919b0e85e6535d135a8de20f20b8c12c3b0 +0c895fcf6720192de6bf3b9e89ecdbd6596cbcdd8eb28e7c365ecc4ec1ff1460f53fe813d3cc7f5b7f020000ffff0300504b030414000600080000002100a5d6 +a7e7c0000000360100000b0000005f72656c732f2e72656c73848fcf6ac3300c87ef85bd83d17d51d2c31825762fa590432fa37d00e1287f68221bdb1bebdb4f +c7060abb0884a4eff7a93dfeae8bf9e194e720169aaa06c3e2433fcb68e1763dbf7f82c985a4a725085b787086a37bdbb55fbc50d1a33ccd311ba548b6309512 +0f88d94fbc52ae4264d1c910d24a45db3462247fa791715fd71f989e19e0364cd3f51652d73760ae8fa8c9ffb3c330cc9e4fc17faf2ce545046e37944c69e462 +a1a82fe353bd90a865aad41ed0b5b8f9d6fd010000ffff0300504b0304140006000800000021006b799616830000008a0000001c0000007468656d652f746865 +6d652f7468656d654d616e616765722e786d6c0ccc4d0ac3201040e17da17790d93763bb284562b2cbaebbf600439c1a41c7a0d29fdbd7e5e38337cedf14d59b +4b0d592c9c070d8a65cd2e88b7f07c2ca71ba8da481cc52c6ce1c715e6e97818c9b48d13df49c873517d23d59085adb5dd20d6b52bd521ef2cdd5eb9246a3d8b +4757e8d3f729e245eb2b260a0238fd010000ffff0300504b03041400060008000000210030dd4329a8060000a41b0000160000007468656d652f7468656d652f +7468656d65312e786d6cec594f6fdb3614bf0fd87720746f6327761a07758ad8b19b2d4d1bc46e871e698996d850a240d2497d1bdae38001c3ba618715d86d87 +615b8116d8a5fb34d93a6c1dd0afb0475292c5585e9236d88aad3e2412f9e3fbff1e1fa9abd7eec70c1d1221294fda5efd72cd4324f1794093b0eddd1ef62fad +79482a9c0498f184b4bd2991deb58df7dfbb8ad755446282607d22d771db8b944ad79796a40fc3585ee62949606ecc458c15bc8a702910f808e8c66c69b9565b +5d8a314d3c94e018c8de1a8fa94fd05093f43672e23d06af89927ac06762a049136785c10607758d9053d965021d62d6f6804fc08f86e4bef210c352c144dbab +999fb7b4717509af678b985ab0b6b4ae6f7ed9ba6c4170b06c788a705430adf71bad2b5b057d03606a1ed7ebf5babd7a41cf00b0ef83a6569632cd467faddec9 +699640f6719e76b7d6ac355c7c89feca9cccad4ea7d36c65b258a206641f1b73f8b5da6a6373d9c11b90c537e7f08dce66b7bbeae00dc8e257e7f0fd2badd586 +8b37a088d1e4600ead1ddaef67d40bc898b3ed4af81ac0d76a197c86826828a24bb318f3442d8ab518dfe3a20f000d6458d104a9694ac6d88728eee2782428d6 +0cf03ac1a5193be4cbb921cd0b495fd054b5bd0f530c1931a3f7eaf9f7af9e3f45c70f9e1d3ff8e9f8e1c3e3073f5a42ceaa6d9c84e5552fbffdeccfc71fa33f +9e7ef3f2d117d57859c6fffac327bffcfc793510d26726ce8b2f9ffcf6ecc98baf3efdfdbb4715f04d814765f890c644a29be408edf3181433567125272371be +15c308d3f28acd249438c19a4b05fd9e8a1cf4cd296699771c393ac4b5e01d01e5a30a787d72cf1178108989a2159c77a2d801ee72ce3a5c545a6147f32a9979 +3849c26ae66252c6ed637c58c5bb8b13c7bfbd490a75330f4b47f16e441c31f7184e140e494214d273fc80900aedee52ead87597fa824b3e56e82e451d4c2b4d +32a423279a668bb6690c7e9956e90cfe766cb37b077538abd27a8b1cba48c80acc2a841f12e698f13a9e281c57911ce298950d7e03aba84ac8c154f8655c4f2a +f074481847bd804859b5e696007d4b4edfc150b12addbecba6b18b148a1e54d1bc81392f23b7f84137c2715a851dd0242a633f900710a218ed715505dfe56e86 +e877f0034e16bafb0e258ebb4faf06b769e888340b103d331115bebc4eb813bf83291b63624a0d1475a756c734f9bbc2cd28546ecbe1e20a3794ca175f3fae90 +fb6d2dd99bb07b55e5ccf68942bd0877b23c77b908e8db5f9db7f024d9239010f35bd4bbe2fcae387bfff9e2bc289f2fbe24cfaa301468dd8bd846dbb4ddf1c2 +ae7b4c191ba8292337a469bc25ec3d411f06f53a73e224c5292c8de0516732307070a1c0660d125c7d44553488700a4d7bddd3444299910e254ab984c3a219ae +a4adf1d0f82b7bd46cea4388ad1c12ab5d1ed8e1153d9c9f350a3246aad01c6873462b9ac05999ad5cc988826eafc3acae853a33b7ba11cd1445875ba1b236b1 +399483c90bd560b0b0263435085a21b0f22a9cf9356b38ec6046026d77eba3dc2dc60b17e92219e180643ed27acffba86e9c94c7ca9c225a0f1b0cfae0788ad5 +4adc5a9aec1b703b8b93caec1a0bd8e5de7b132fe5113cf312503b998e2c2927274bd051db6b35979b1ef271daf6c6704e86c73805af4bdd476216c26593af84 +0dfb5393d964f9cc9bad5c313709ea70f561ed3ea7b053075221d51696910d0d339585004b34272bff7213cc7a510a5454a3b349b1b206c1f0af490176745d4b +c663e2abb2b34b23da76f6352ba57ca2881844c1111ab189d8c7e07e1daaa04f40255c77988aa05fe06e4e5bdb4cb9c5394bbaf28d98c1d971ccd20867e556a7 +689ec9166e0a522183792b8907ba55ca6e943bbf2a26e52f48957218ffcf54d1fb09dc3eac04da033e5c0d0b8c74a6b43d2e54c4a10aa511f5fb021a07533b20 +5ae07e17a621a8e082dafc17e450ffb739676998b48643a4daa7211214f623150942f6a02c99e83b85583ddbbb2c4996113211551257a656ec1139246ca86be0 +aadedb3d1441a89b6a929501833b197fee7b9641a3503739e57c732a59b1f7da1cf8a73b1f9bcca0945b874d4393dbbf10b1680f66bbaa5d6f96e77b6f59113d +316bb31a795600b3d256d0cad2fe354538e7566b2bd69cc6cbcd5c38f0e2bcc63058344429dc2121fd07f63f2a7c66bf76e80d75c8f7a1b622f878a18941d840 +545fb28d07d205d20e8ea071b283369834296bdaac75d256cb37eb0bee740bbe278cad253b8bbfcf69eca23973d939b97891c6ce2cecd8da8e2d343578f6648a +c2d0383fc818c798cf64e52f597c740f1cbd05df0c264c49134cf09d4a60e8a107260f20f92d47b374e32f000000ffff0300504b030414000600080000002100 +0dd1909fb60000001b010000270000007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73848f4d0ac2301484f7 +8277086f6fd3ba109126dd88d0add40384e4350d363f2451eced0dae2c082e8761be9969bb979dc9136332de3168aa1a083ae995719ac16db8ec8e4052164e89 +d93b64b060828e6f37ed1567914b284d262452282e3198720e274a939cd08a54f980ae38a38f56e422a3a641c8bbd048f7757da0f19b017cc524bd62107bd500 +1996509affb3fd381a89672f1f165dfe514173d9850528a2c6cce0239baa4c04ca5bbabac4df000000ffff0300504b01022d0014000600080000002100e9de0f +bfff0000001c0200001300000000000000000000000000000000005b436f6e74656e745f54797065735d2e786d6c504b01022d0014000600080000002100a5d6 +a7e7c0000000360100000b00000000000000000000000000300100005f72656c732f2e72656c73504b01022d00140006000800000021006b799616830000008a +0000001c00000000000000000000000000190200007468656d652f7468656d652f7468656d654d616e616765722e786d6c504b01022d00140006000800000021 +0030dd4329a8060000a41b00001600000000000000000000000000d60200007468656d652f7468656d652f7468656d65312e786d6c504b01022d001400060008 +00000021000dd1909fb60000001b0100002700000000000000000000000000b20900007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73504b050600000000050005005d010000ad0a00000000} +{\*\colorschememapping 3c3f786d6c2076657273696f6e3d22312e302220656e636f64696e673d225554462d3822207374616e64616c6f6e653d22796573223f3e0d0a3c613a636c724d +617020786d6c6e733a613d22687474703a2f2f736368656d61732e6f70656e786d6c666f726d6174732e6f72672f64726177696e676d6c2f323030362f6d6169 +6e22206267313d226c743122207478313d22646b3122206267323d226c743222207478323d22646b322220616363656e74313d22616363656e74312220616363 +656e74323d22616363656e74322220616363656e74333d22616363656e74332220616363656e74343d22616363656e74342220616363656e74353d22616363656e74352220616363656e74363d22616363656e74362220686c696e6b3d22686c696e6b2220666f6c486c696e6b3d22666f6c486c696e6b222f3e} +{\*\latentstyles\lsdstimax267\lsdlockeddef0\lsdsemihiddendef1\lsdunhideuseddef1\lsdqformatdef0\lsdprioritydef99{\lsdlockedexcept \lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority0 \lsdlocked0 Normal; +\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 1;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 2;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 3;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 4; +\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 5;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 6;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 7;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 8;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 9; +\lsdpriority39 \lsdlocked0 toc 1;\lsdpriority39 \lsdlocked0 toc 2;\lsdpriority39 \lsdlocked0 toc 3;\lsdpriority39 \lsdlocked0 toc 4;\lsdpriority39 \lsdlocked0 toc 5;\lsdpriority39 \lsdlocked0 toc 6;\lsdpriority39 \lsdlocked0 toc 7; +\lsdpriority39 \lsdlocked0 toc 8;\lsdpriority39 \lsdlocked0 toc 9;\lsdqformat1 \lsdpriority35 \lsdlocked0 caption;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority10 \lsdlocked0 Title;\lsdpriority1 \lsdlocked0 Default Paragraph Font; +\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority11 \lsdlocked0 Subtitle;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority22 \lsdlocked0 Strong;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority20 \lsdlocked0 Emphasis; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority59 \lsdlocked0 Table Grid;\lsdunhideused0 \lsdlocked0 Placeholder Text;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority1 \lsdlocked0 No Spacing; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 1; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 1; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 1;\lsdunhideused0 \lsdlocked0 Revision; +\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority34 \lsdlocked0 List Paragraph;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority29 \lsdlocked0 Quote;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority30 \lsdlocked0 Intense Quote; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 1; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 1; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 2; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 2; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 2; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 2; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 2; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 3; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 3; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 3; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 3; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 3; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 4; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 4; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 4; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 4; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 5; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 5; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 5; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 5; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 5; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 6; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 6; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 6; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 6; +\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 6; +\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority19 \lsdlocked0 Subtle Emphasis;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority21 \lsdlocked0 Intense Emphasis; +\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority31 \lsdlocked0 Subtle Reference;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority32 \lsdlocked0 Intense Reference; +\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority33 \lsdlocked0 Book Title;\lsdpriority37 \lsdlocked0 Bibliography;\lsdqformat1 \lsdpriority39 \lsdlocked0 TOC Heading;}}{\*\datastore 010500000200000018000000 +4d73786d6c322e534158584d4c5265616465722e362e3000000000000000000000060000 +d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff090006000000000000000000000001000000010000000000000000100000feffffff00000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffff0c6ad98892f1d411a65f0040963251e500000000000000000000000000da +8d015128d001feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000105000000000000}} \ No newline at end of file diff --git a/Setup/assets/UiBanner.bmp b/Setup/assets/UiBanner.bmp new file mode 100644 index 0000000..b675e30 Binary files /dev/null and b/Setup/assets/UiBanner.bmp differ diff --git a/Setup/assets/UiDialog.bmp b/Setup/assets/UiDialog.bmp new file mode 100644 index 0000000..bfe73b2 Binary files /dev/null and b/Setup/assets/UiDialog.bmp differ diff --git a/SharedComponents/AntMe.snk b/SharedComponents/AntMe.snk new file mode 100644 index 0000000..cdd75a4 Binary files /dev/null and b/SharedComponents/AntMe.snk differ diff --git a/SharedComponents/AntMeException.cs b/SharedComponents/AntMeException.cs new file mode 100644 index 0000000..6637a06 --- /dev/null +++ b/SharedComponents/AntMeException.cs @@ -0,0 +1,15 @@ +using System; +using System.Runtime.Serialization; + +namespace AntMe.SharedComponents { + /// + /// Exception for special AntMe-Exceptions. + /// + [Serializable] + public class AntMeException : Exception { + public AntMeException() {} + public AntMeException(string message) : base(message) {} + public AntMeException(string message, Exception innerException) : base(message, innerException) {} + public AntMeException(SerializationInfo info, StreamingContext context) : base(info, context) { } + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Angle.cs b/SharedComponents/AntVideo/Angle.cs new file mode 100644 index 0000000..d3349ff --- /dev/null +++ b/SharedComponents/AntVideo/Angle.cs @@ -0,0 +1,28 @@ +namespace AntMe.SharedComponents.AntVideo { + internal static class Angle { + public static int Interpolate(int angle, int delta) { + int output = (angle + delta)%360; + if (output < 0) { + output += 360; + } + return output; + } + + public static int Delta(int oldAngle, int newAngle) { + // Cases + // old: 100, new: 90 -> -10 + // old: 100, new: 110 -> 10 + // old: 350, new: 10 -> 20 + // old: 10, new 350 -> -20 + + int output = newAngle - oldAngle; + //if (output < -180) { + // // output += 360; + //} + //else if (output > 180) { + // // output -= 360; + //} + return output; + } + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/AntVideoReader.cs b/SharedComponents/AntVideo/AntVideoReader.cs new file mode 100644 index 0000000..45822d8 --- /dev/null +++ b/SharedComponents/AntVideo/AntVideoReader.cs @@ -0,0 +1,267 @@ +using System; +using System.Collections.Generic; +using System.IO; + +using AntMe.SharedComponents.AntVideo.Block; +using AntMe.SharedComponents.States; +using System.Globalization; + +namespace AntMe.SharedComponents.AntVideo { + /// + /// Class, to read and decode ant-video-Streams. + /// + public sealed class AntVideoReader { + #region local variables + + private readonly Dictionary anthillList; + private readonly Dictionary antList; + private readonly Dictionary bugList; + private readonly Dictionary fruitList; + private readonly Dictionary markerList; + private readonly Dictionary> casteList; + private readonly Serializer serializer; + private readonly Dictionary sugarList; + private readonly Dictionary teamList; + private readonly Dictionary> colonyList; + private Frame frame; + private bool complete; + + #endregion + + /// + /// Creates a new instance of reader. + /// + /// input-stream + public AntVideoReader(Stream inputStream) { + // check for stream + if (inputStream == null) { + throw new ArgumentNullException("inputStream", Resource.AntvideoReaderNoStreamException); + } + + // check for readable stream + if (!inputStream.CanRead) { + throw new InvalidOperationException(Resource.AntvideoReaderNoReadAccessException); + } + + // init block-lists + teamList = new Dictionary(); + colonyList = new Dictionary>(); + casteList = new Dictionary>(); + anthillList = new Dictionary(); + antList = new Dictionary(); + markerList = new Dictionary(); + bugList = new Dictionary(); + sugarList = new Dictionary(); + fruitList = new Dictionary(); + + // create serializer + serializer = new Serializer(inputStream); + + // read hello-message + serializer.ReadHello(); + } + + /// + /// Reads a new simulation-state out of stream. + /// + /// New simulation-state or null, if stream is over + public SimulationState Read() { + + // if stream is at his end, return null + if (complete) { + return null; + } + + // first block have to be a frame-start + ISerializable block; + BlockType blockType = serializer.Read(out block); + + // detect stream-end + if (blockType == BlockType.StreamEnd) { + complete = true; + return null; + } + + // unexpected block-type + if (blockType != BlockType.FrameStart) { + throw new InvalidOperationException( + string.Format( + CultureInfo.CurrentCulture , + Resource.AntvideoReaderInvalidBlockType, blockType)); + } + + // block-loop + while (blockType != BlockType.FrameEnd) { + blockType = serializer.Read(out block); + switch (blockType) { + case BlockType.Ant: + Ant ant = (Ant) block; + antList.Add(ant.Id, ant); + break; + case BlockType.Anthill: + Anthill anthill = (Anthill) block; + anthillList.Add(anthill.Id, anthill); + break; + case BlockType.AntLost: + Lost antLost = (Lost) block; + antList.Remove(antLost.Id); + break; + case BlockType.AntUpdate: + AntUpdate antUpdate = (AntUpdate) block; + antList[antUpdate.Id].Update(antUpdate); + break; + case BlockType.Bug: + Bug bug = (Bug) block; + bugList.Add(bug.Id, bug); + break; + case BlockType.BugLost: + Lost bugLost = (Lost) block; + bugList.Remove(bugLost.Id); + break; + case BlockType.BugUpdate: + BugUpdate bugUpdate = (BugUpdate) block; + bugList[bugUpdate.Id].Update(bugUpdate); + break; + case BlockType.Caste: + Caste caste = (Caste) block; + casteList[caste.ColonyId].Add(caste.Id, caste); + break; + case BlockType.Team: + Team team = (Team) block; + teamList.Add(team.Id, team); + colonyList.Add(team.Id, new Dictionary()); + break; + case BlockType.Colony: + Colony colony = (Colony) block; + colonyList[colony.TeamId].Add(colony.Id, colony); + casteList.Add(colony.Id, new Dictionary()); + break; + case BlockType.ColonyUpdate: + ColonyUpdate colonyUpdate = (ColonyUpdate) block; + colonyList[colonyUpdate.TeamId][colonyUpdate.Id].Update(colonyUpdate); + break; + case BlockType.Frame: + frame = (Frame) block; + break; + case BlockType.FrameUpdate: + FrameUpdate frameUpdate = (FrameUpdate) block; + frame.Update(frameUpdate); + break; + case BlockType.Fruit: + Fruit fruit = (Fruit) block; + fruitList.Add(fruit.Id, fruit); + break; + case BlockType.FruitLost: + Lost fruitLost = (Lost) block; + fruitList.Remove(fruitLost.Id); + break; + case BlockType.FruitUpdate: + FruitUpdate fruitUpdate = (FruitUpdate) block; + fruitList[fruitUpdate.Id].Update(fruitUpdate); + break; + case BlockType.Marker: + Marker marker = (Marker) block; + markerList.Add(marker.Id, marker); + break; + case BlockType.MarkerLost: + Lost markerLost = (Lost) block; + markerList.Remove(markerLost.Id); + break; + case BlockType.MarkerUpdate: + MarkerUpdate markerUpdate = (MarkerUpdate) block; + markerList[markerUpdate.Id].Update(markerUpdate); + break; + case BlockType.Sugar: + Sugar sugar = (Sugar) block; + sugarList.Add(sugar.Id, sugar); + break; + case BlockType.SugarLost: + Lost sugarLost = (Lost) block; + sugarList.Remove(sugarLost.Id); + break; + case BlockType.SugarUpdate: + SugarUpdate sugarUpdate = (SugarUpdate) block; + sugarList[sugarUpdate.Id].Update(sugarUpdate); + break; + } + } + + // Detect streamend + if ((BlockType) serializer.Peek() == BlockType.StreamEnd) { + complete = true; + } + + // Interpolate all elements and buildup state + frame.Interpolate(); + SimulationState state = frame.GenerateState(); + + foreach (Bug bug in bugList.Values) { + bug.Interpolate(); + state.BugStates.Add(bug.GenerateState()); + } + foreach (Fruit fruit in fruitList.Values) { + fruit.Interpolate(); + state.FruitStates.Add(fruit.GenerateState()); + } + foreach (Sugar sugar in sugarList.Values) { + sugar.Interpolate(); + state.SugarStates.Add(sugar.GenerateState()); + } + + foreach (Team team in teamList.Values) { + TeamState teamState = team.GenerateState(); + state.TeamStates.Add(teamState); + + foreach (Colony colony in colonyList[team.Id].Values) { + colony.Interpolate(); + ColonyState colonyState = colony.GenerateState(); + teamState.ColonyStates.Add(colonyState); + + foreach (Caste caste in casteList[colony.Id].Values) { + colonyState.CasteStates.Add(caste.GenerateState()); + } + + foreach (Anthill anthill in anthillList.Values) { + if (anthill.ColonyId == colony.Id) { + colonyState.AnthillStates.Add(anthill.GenerateState()); + } + } + + foreach (Ant ant in antList.Values) { + if (ant.ColonyId == colony.Id) { + ant.Interpolate(); + colonyState.AntStates.Add(ant.GenerateState()); + } + } + foreach (Marker marker in markerList.Values) { + if (marker.ColonyId == colony.Id) { + marker.Interpolate(); + colonyState.MarkerStates.Add(marker.GenerateState()); + } + } + } + } + + // deliver + return state; + } + + /// + /// Gives the current frame-position. + /// + public int CurrentFrame { + get { return frame != null ? frame.CurrentRound : 0; } + } + + /// + /// Gives the number of total frames. + /// + public int TotalFrames { + get { return frame != null ? frame.TotalRounds : 0; } + } + + public bool Complete { + get { return complete; } + } + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/AntVideoWriter.cs b/SharedComponents/AntVideo/AntVideoWriter.cs new file mode 100644 index 0000000..05ff979 --- /dev/null +++ b/SharedComponents/AntVideo/AntVideoWriter.cs @@ -0,0 +1,411 @@ +using System.Collections.Generic; +using System.IO; + +using AntMe.SharedComponents.AntVideo.Block; +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo { + /// + /// Class, to stream some simulation state as ant-video-stream. + /// + public sealed class AntVideoWriter + { + + #region local variables + + private readonly Dictionary anthillList; + private readonly Dictionary antList; + private readonly Dictionary bugList; + private readonly Dictionary fruitList; + private readonly Dictionary markerList; + private readonly Dictionary> casteList; + private readonly Serializer serializer; + private readonly Dictionary sugarList; + private readonly Dictionary teamList; + private readonly Dictionary colonyList; + private Frame frame; + + #endregion + + /// + /// Creates a new instance of ant-video-writer. + /// + /// output-stream + public AntVideoWriter(Stream outputStream) { + + teamList = new Dictionary(); + colonyList = new Dictionary(); + casteList = new Dictionary>(); + anthillList = new Dictionary(); + antList = new Dictionary(); + markerList = new Dictionary(); + bugList = new Dictionary(); + sugarList = new Dictionary(); + fruitList = new Dictionary(); + + serializer = new Serializer(outputStream); + serializer.WriteHello(); + serializer.Write(BlockType.StreamStart); + } + + /// + /// Writes a new state to the stream. + /// + /// New state + public void Write(SimulationState state) { + serializer.Write(BlockType.FrameStart); + int[] keys; + + #region Framestart + + // The first call creates the frame + if (frame == null) { + // Create new frame + frame = new Frame(state); + serializer.Write(BlockType.Frame, frame); + } + else { + // Send frame-update + FrameUpdate update = frame.GenerateUpdate(state); + if (update != null) { + serializer.Write(BlockType.FrameUpdate, update); + } + } + + #endregion + + #region Teams and ColonyStates + + #region ant-reset + + // reset alive-flag + foreach (Ant ant in antList.Values) + { + ant.IsAlive = false; + } + + #endregion + + #region marker-reset + + // reset alive-flag + foreach (Marker marker in markerList.Values) + { + marker.IsAlive = false; + } + + #endregion + + // Teams are static and need no update + + // enumerate all teams + foreach (TeamState teamState in state.TeamStates) + { + + // Check, if team is known + if (teamList.ContainsKey(teamState.Id)) + { + // No Teamupdate needed + } + else + { + Team team = new Team(teamState); + serializer.Write(BlockType.Team, team); + teamList.Add(teamState.Id, team); + } + + // ColonyStates are static and need no update + + // enumerate all colonies + foreach (ColonyState colonyState in teamState.ColonyStates) + { + // Check, if colony is known + if (colonyList.ContainsKey(colonyState.Id)) + { + // colony-update + ColonyUpdate update = colonyList[colonyState.Id].GenerateUpdate(colonyState); + if (update != null) + { + serializer.Write(BlockType.ColonyUpdate, update); + } + colonyList[colonyState.Id].Interpolate(); + } + else + { + // new colony + Colony colony = new Colony(colonyState, teamState.Id); + serializer.Write(BlockType.Colony, colony); + colonyList.Add(colonyState.Id, colony); + casteList.Add(colonyState.Id, new Dictionary()); + + #region Castes + + // Casts are static and need no update + + Dictionary castes = casteList[colonyState.Id]; + + // enumerate casts + for (ushort i = 0; i < colonyState.CasteStates.Count; i++) + { + // Check, if caste is known + if (!castes.ContainsKey(i)) + { + // add caste + Caste caste = new Caste(colonyState.CasteStates[i]); + serializer.Write(BlockType.Caste, caste); + } + } + + #endregion + + #region Anthills + + // Anthills are static and need no update + + // enumerate anthills + foreach (AnthillState anthill in colonyState.AnthillStates) + { + if (!anthillList.ContainsKey(anthill.Id)) + { + Anthill hill = new Anthill(anthill); + serializer.Write(BlockType.Anthill, hill); + anthillList.Add(anthill.Id, hill); + } + } + + #endregion + } + + #region Ants + + // enumerate ants + foreach (AntState antState in colonyState.AntStates) + { + // Check, if ant is known + if (antList.ContainsKey(antState.Id)) + { + // ant-update + AntUpdate update = antList[antState.Id].GenerateUpdate(antState); + if (update != null) + { + serializer.Write(BlockType.AntUpdate, update); + } + antList[antState.Id].Interpolate(); + } + else + { + // create ant + Ant ant = new Ant(antState); + serializer.Write(BlockType.Ant, ant); + antList.Add(ant.Id, ant); + } + + antList[antState.Id].IsAlive = true; + } + + #endregion + + #region Marker + + // enumerate marker + foreach (MarkerState markerState in colonyState.MarkerStates) + { + // Check, if marker is known + if (markerList.ContainsKey(markerState.Id)) + { + // marker-update + MarkerUpdate update = markerList[markerState.Id].GenerateUpdate(markerState); + if (update != null) + { + serializer.Write(BlockType.MarkerUpdate, update); + } + markerList[markerState.Id].Interpolate(); + } + else + { + // create marker + Marker marker = new Marker(markerState); + serializer.Write(BlockType.Marker, marker); + markerList.Add(markerState.Id, marker); + } + + markerList[markerState.Id].IsAlive = true; + } + + #endregion + } + } + + #region Ant-Cleanup + + // remove dead ants + keys = new int[antList.Keys.Count]; + antList.Keys.CopyTo(keys, 0); + for (int i = 0; i < keys.Length; i++) + { + if (!antList[keys[i]].IsAlive) + { + serializer.Write(BlockType.AntLost, new Lost(keys[i])); + antList.Remove(keys[i]); + } + } + + #endregion + + #region Marker-Cleanup + + // remove dead marker + keys = new int[markerList.Keys.Count]; + markerList.Keys.CopyTo(keys, 0); + for (int i = 0; i < keys.Length; i++) + { + if (!markerList[keys[i]].IsAlive) + { + serializer.Write(BlockType.MarkerLost, new Lost(keys[i])); + markerList.Remove(keys[i]); + } + } + + #endregion + + #endregion + + #region Fruit + + // reset alive-flag + foreach (Fruit fruit in fruitList.Values) { + fruit.IsAlive = false; + } + + // enumerate fruit + foreach (FruitState fruitState in state.FruitStates) { + + // Check, if fruit is known + if (fruitList.ContainsKey(fruitState.Id)) { + + // fruit-update + FruitUpdate update = fruitList[fruitState.Id].GenerateUpdate(fruitState); + if (update != null) { + serializer.Write(BlockType.FruitUpdate, update); + } + fruitList[fruitState.Id].Interpolate(); + } + else { + + // create fruit + Fruit fruit = new Fruit(fruitState); + serializer.Write(BlockType.Fruit, fruit); + fruitList.Add(fruitState.Id, fruit); + } + + fruitList[fruitState.Id].IsAlive = true; + } + + // remove dead fruits + keys = new int[fruitList.Keys.Count]; + fruitList.Keys.CopyTo(keys, 0); + for (int i = 0; i < keys.Length; i++) { + if (!fruitList[keys[i]].IsAlive) { + serializer.Write(BlockType.FruitLost, new Lost(keys[i])); + fruitList.Remove(keys[i]); + } + } + + #endregion + + #region Sugar + + // reset alive-flag + foreach (Sugar sugar in sugarList.Values) { + sugar.IsAlive = false; + } + + // enumerate sugar + foreach (SugarState sugarState in state.SugarStates) { + + // Check, if sugar is known + if (sugarList.ContainsKey(sugarState.Id)) { + + // sugar-update + SugarUpdate update = sugarList[sugarState.Id].GenerateUpdate(sugarState); + if (update != null) { + serializer.Write(BlockType.SugarUpdate, update); + } + sugarList[sugarState.Id].Interpolate(); + } + else { + + // create sugar + Sugar sugar = new Sugar(sugarState); + serializer.Write(BlockType.Sugar, sugar); + sugarList.Add(sugarState.Id, sugar); + } + + sugarList[sugarState.Id].IsAlive = true; + } + + // remove dead sugar + keys = new int[sugarList.Keys.Count]; + sugarList.Keys.CopyTo(keys, 0); + for (int i = 0; i < keys.Length; i++) { + if (!sugarList[keys[i]].IsAlive) { + serializer.Write(BlockType.SugarLost, new Lost(keys[i])); + sugarList.Remove(keys[i]); + } + } + + #endregion + + #region Bugs + + // reset alive-flag + foreach (Bug bug in bugList.Values) { + bug.IsAlive = false; + } + + // enumerate bugs + foreach (BugState bugState in state.BugStates) { + + // Check, if bug is known + if (bugList.ContainsKey(bugState.Id)) { + + // bug-update + BugUpdate update = bugList[bugState.Id].GenerateUpdate(bugState); + if (update != null) { + serializer.Write(BlockType.BugUpdate, update); + } + bugList[bugState.Id].Interpolate(); + } + else { + // create bug + Bug bug = new Bug(bugState); + serializer.Write(BlockType.Bug, bug); + bugList.Add(bugState.Id, bug); + } + + bugList[bugState.Id].IsAlive = true; + } + + // remove dead bugs + keys = new int[bugList.Keys.Count]; + bugList.Keys.CopyTo(keys, 0); + for (int i = 0; i < keys.Length; i++) { + if (!bugList[keys[i]].IsAlive) { + serializer.Write(BlockType.BugLost, new Lost(keys[i])); + bugList.Remove(keys[i]); + } + } + + #endregion + + serializer.Write(BlockType.FrameEnd); + } + + /// + /// Close the writer. + /// + public void Close() { + serializer.Write(BlockType.StreamEnd); + } + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Ant.cs b/SharedComponents/AntVideo/Block/Ant.cs new file mode 100644 index 0000000..f2eb240 --- /dev/null +++ b/SharedComponents/AntVideo/Block/Ant.cs @@ -0,0 +1,291 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block +{ + internal sealed class Ant : AntState, IUpdateable, ISerializable + { + #region Updateinformation + + private bool aIsAlive; + private int aLoad; + private LoadType aLoadType = LoadType.None; + private int aTargetPositionX; + private int aTargetPositionY; + private TargetType aTargetType = TargetType.None; + private int aVitality; + private string aDebugMessage; + private int dDirection; + private int dPositionX; + private int dPositionY; + + #endregion + + public Ant(Serializer serializer) + : base(0, 0) + { + Deserialize(serializer); + + Reset(); + } + + public Ant(AntState zustand) + : base(zustand.ColonyId, zustand.Id) + { + CasteId = zustand.CasteId; + ViewRange = zustand.ViewRange; + TargetType = zustand.TargetType; + PositionX = zustand.PositionX; + PositionY = zustand.PositionY; + Direction = zustand.Direction; + Vitality = zustand.Vitality; + TargetPositionX = zustand.TargetPositionX; + TargetPositionY = zustand.TargetPositionY; + Load = zustand.Load; + LoadType = zustand.LoadType; + + Reset(); + } + + private void Reset() + { + aTargetType = TargetType; + aVitality = Vitality; + dPositionX = 0; + dPositionY = 0; + dDirection = 0; + aTargetPositionX = TargetPositionX; + aTargetPositionY = TargetPositionY; + aLoad = Load; + aLoadType = LoadType; + aDebugMessage = string.Empty; + } + + #region IUpdateable Member + + public void Interpolate() + { + TargetType = aTargetType; + Vitality = aVitality; + PositionX = PositionX + dPositionX; + PositionY = PositionY + dPositionY; + Direction = Angle.Interpolate(Direction, dDirection); + TargetPositionX = aTargetPositionX; + TargetPositionY = aTargetPositionY; + Load = aLoad; + LoadType = aLoadType; + DebugMessage = aDebugMessage; + } + + public void Update(AntUpdate update) + { + if (update.HasChanged(AntFields.TargetType)) + { + aTargetType = update.aTargetType; + } + if (update.HasChanged(AntFields.Vitality)) + { + aVitality = update.aVitality; + } + if (update.HasChanged(AntFields.Load)) + { + aLoad = update.aLoad; + } + if (update.HasChanged(AntFields.PositionX)) + { + dPositionX = update.dPositionX; + } + if (update.HasChanged(AntFields.PositionY)) + { + dPositionY = update.dPositionY; + } + if (update.HasChanged(AntFields.Direction)) + { + dDirection = update.dDirection; + } + if (update.HasChanged(AntFields.TargetPositionX)) + { + aTargetPositionX = update.aTargetPositionX; + } + if (update.HasChanged(AntFields.TargetPositionY)) + { + aTargetPositionY = update.aTargetPositionY; + } + if (update.HasChanged(AntFields.LoadType)) + { + aLoadType = update.aLoadType; + } + if (update.HasChanged(AntFields.DebugMessage)) + { + aDebugMessage = update.aDebugMessage; + } + else + { + aDebugMessage = string.Empty; + } + } + + public AntUpdate GenerateUpdate(AntState state) + { + AntUpdate update = new AntUpdate(); + update.Id = Id; + bool changed = false; + + if (state.TargetType != TargetType) + { + update.Change(AntFields.TargetType); + update.aTargetType = state.TargetType; + changed = true; + } + + if (state.PositionX != (PositionX + dPositionX)) + { + update.Change(AntFields.PositionX); + update.dPositionX = state.PositionX - PositionX; + changed = true; + } + + if (state.PositionY != (PositionY + dPositionY)) + { + update.Change(AntFields.PositionY); + update.dPositionY = state.PositionY - PositionY; + changed = true; + } + + if (state.Direction != Angle.Interpolate(Direction, dDirection)) + { + update.Change(AntFields.Direction); + update.dDirection = Angle.Delta(Direction, state.Direction); + changed = true; + } + + if (state.TargetPositionX != TargetPositionX) + { + update.Change(AntFields.TargetPositionX); + update.aTargetPositionX = state.TargetPositionX; + changed = true; + } + + if (state.TargetPositionY != TargetPositionY) + { + update.Change(AntFields.TargetPositionY); + update.aTargetPositionY = state.TargetPositionY; + changed = true; + } + + if (state.Load != Load) + { + update.Change(AntFields.Load); + update.aLoad = state.Load; + changed = true; + } + + if (state.Vitality != Vitality) + { + update.Change(AntFields.Vitality); + update.aVitality = state.Vitality; + changed = true; + } + + if (state.LoadType != LoadType) + { + update.Change(AntFields.LoadType); + update.aLoadType = state.LoadType; + changed = true; + } + + if (!string.IsNullOrEmpty(state.DebugMessage)) + { + update.Change(AntFields.DebugMessage); + update.aDebugMessage = state.DebugMessage; + changed = true; + } + + if (changed) + { + Update(update); + return update; + } + return null; + } + + public AntState GenerateState() + { + AntState state = new AntState(ColonyId, Id); + state.TargetType = TargetType; + state.Vitality = Vitality; + state.Load = Load; + state.ViewRange = ViewRange; + state.PositionX = PositionX; + state.PositionY = PositionY; + state.Direction = Direction; + state.CasteId = CasteId; + state.TargetPositionX = TargetPositionX; + state.TargetPositionY = TargetPositionY; + state.LoadType = LoadType; + state.DebugMessage = DebugMessage; + return state; + } + + public bool IsAlive + { + get { return aIsAlive; } + set { aIsAlive = value; } + } + + #endregion + + #region ISerializable Member + + // Blocklayout: + // - ushort ID + // - ushort ColonyID + // - byte CasteId + // - byte TargetType + // - ushort PosX + // - ushort PosY + // - ushort Direction + // - ushort Vitality + // - ushort TargetPositionX + // - ushort TargetPositionY + // - byte Load + // - byte LoadType + + public void Serialize(Serializer serializer) + { + serializer.SendUshort((ushort)Id); + serializer.SendUshort((ushort)ColonyId); + serializer.SendByte((byte)CasteId); + serializer.SendUshort((ushort)ViewRange); + serializer.SendByte((byte)TargetType); + serializer.SendUshort((ushort)PositionX); + serializer.SendUshort((ushort)PositionY); + serializer.SendUshort((ushort)Direction); + serializer.SendUshort((ushort)Vitality); + serializer.SendUshort((ushort)TargetPositionX); + serializer.SendUshort((ushort)TargetPositionY); + serializer.SendByte((byte)Load); + serializer.SendByte((byte)LoadType); + serializer.SendString(DebugMessage ?? string.Empty); + } + + public void Deserialize(Serializer serializer) + { + Id = serializer.ReadUShort(); + ColonyId = serializer.ReadUShort(); + CasteId = serializer.ReadByte(); + ViewRange = serializer.ReadUShort(); + TargetType = (TargetType)serializer.ReadByte(); + PositionX = serializer.ReadUShort(); + PositionY = serializer.ReadUShort(); + Direction = serializer.ReadUShort(); + Vitality = serializer.ReadUShort(); + TargetPositionX = serializer.ReadUShort(); + TargetPositionY = serializer.ReadUShort(); + Load = serializer.ReadByte(); + LoadType = (LoadType)serializer.ReadByte(); + DebugMessage = serializer.ReadString(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/AntUpdate.cs b/SharedComponents/AntVideo/Block/AntUpdate.cs new file mode 100644 index 0000000..b7db5b6 --- /dev/null +++ b/SharedComponents/AntVideo/Block/AntUpdate.cs @@ -0,0 +1,157 @@ +using System; + +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block +{ + /// + /// Liste der Felder, die sich durch ein Update ändern könnten + /// + [Flags] + internal enum AntFields + { + TargetType = 1, + PositionX = 2, + PositionY = 4, + Direction = 8, + TargetPositionX = 16, + TargetPositionY = 32, + Load = 64, + Vitality = 128, + LoadType = 256, + DebugMessage = 512, + } ; + + internal sealed class AntUpdate : UpdateBase + { + #region Updateinformation + + public int aLoad; + public LoadType aLoadType = LoadType.None; + public int aTargetPositionX; + public int aTargetPositionY; + public TargetType aTargetType = TargetType.None; + public int aVitality; + public string aDebugMessage; + public int dDirection; + public int dPositionX; + public int dPositionY; + + #endregion + + public AntUpdate() { } + + // Blocklayout: + // - ... + // - byte TargetType + // - sbyte PositionX + // - sbyte PositionY + // - short Direction + // - ushort Vitality + // - ushort TargetPositionX + // - ushort TargetPositionY + // - byte Load + // - byte LoadType + + public AntUpdate(Serializer serializer) + : base(serializer) + { + if (HasChanged(AntFields.TargetType)) + { + aTargetType = (TargetType)serializer.ReadByte(); + } + if (HasChanged(AntFields.PositionX)) + { + dPositionX = serializer.ReadSByte(); + } + if (HasChanged(AntFields.PositionY)) + { + dPositionY = serializer.ReadSByte(); + } + if (HasChanged(AntFields.Direction)) + { + dDirection = serializer.ReadShort(); + } + if (HasChanged(AntFields.Vitality)) + { + aVitality = serializer.ReadUShort(); + } + if (HasChanged(AntFields.TargetPositionX)) + { + aTargetPositionX = serializer.ReadUShort(); + } + if (HasChanged(AntFields.TargetPositionY)) + { + aTargetPositionY = serializer.ReadUShort(); + } + if (HasChanged(AntFields.Load)) + { + aLoad = serializer.ReadByte(); + } + if (HasChanged(AntFields.LoadType)) + { + aLoadType = (LoadType)serializer.ReadByte(); + } + if (HasChanged(AntFields.DebugMessage)) + { + aDebugMessage = serializer.ReadString(); + } + } + + public override void Serialize(Serializer serializer) + { + base.Serialize(serializer); + + if (HasChanged(AntFields.TargetType)) + { + serializer.SendByte((byte)aTargetType); + } + if (HasChanged(AntFields.PositionX)) + { + serializer.SendSByte((sbyte)dPositionX); + } + if (HasChanged(AntFields.PositionY)) + { + serializer.SendSByte((sbyte)dPositionY); + } + if (HasChanged(AntFields.Direction)) + { + serializer.SendShort((short)dDirection); + } + if (HasChanged(AntFields.Vitality)) + { + serializer.SendUshort((ushort)aVitality); + } + if (HasChanged(AntFields.TargetPositionX)) + { + serializer.SendUshort((ushort)aTargetPositionX); + } + if (HasChanged(AntFields.TargetPositionY)) + { + serializer.SendUshort((ushort)aTargetPositionY); + } + if (HasChanged(AntFields.Load)) + { + serializer.SendByte((byte)aLoad); + } + if (HasChanged(AntFields.LoadType)) + { + serializer.SendByte((byte)aLoadType); + } + if (HasChanged(AntFields.DebugMessage)) + { + serializer.SendString(aDebugMessage); + } + } + + public void Change(AntFields field) + { + Change((int)field); + } + + public bool HasChanged(AntFields field) + { + return HasChanged((int)field); + } + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Anthill.cs b/SharedComponents/AntVideo/Block/Anthill.cs new file mode 100644 index 0000000..0f79c55 --- /dev/null +++ b/SharedComponents/AntVideo/Block/Anthill.cs @@ -0,0 +1,57 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block { + internal sealed class Anthill : AnthillState, ISerializable { + private bool isAlive; + + public Anthill(Serializer serializer) : base(0, 0) { + Deserialize(serializer); + } + + public Anthill(AnthillState state) : base(state.ColonyId, state.Id) { + PositionX = state.PositionX; + PositionY = state.PositionY; + Radius = state.Radius; + } + + public AnthillState GenerateState() { + AnthillState state = new AnthillState(ColonyId, Id); + state.PositionX = PositionX; + state.PositionY = PositionY; + state.Radius = Radius; + return state; + } + + public bool IsAlive { + get { return isAlive; } + set { isAlive = value; } + } + + #region ISerializable Member + + // Blocklayout: + // - ushort Id + // - ushort ColonyId + // - ushort PositionX + // - ushort PositionY + // - ushort Radius + + public void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) Id); + serializer.SendUshort((ushort) ColonyId); + serializer.SendUshort((ushort) PositionX); + serializer.SendUshort((ushort) PositionY); + serializer.SendUshort((ushort) Radius); + } + + public void Deserialize(Serializer serializer) { + Id = serializer.ReadUShort(); + ColonyId = serializer.ReadUShort(); + PositionX = serializer.ReadUShort(); + PositionY = serializer.ReadUShort(); + Radius = serializer.ReadUShort(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Bug.cs b/SharedComponents/AntVideo/Block/Bug.cs new file mode 100644 index 0000000..27cf0b9 --- /dev/null +++ b/SharedComponents/AntVideo/Block/Bug.cs @@ -0,0 +1,141 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block { + internal sealed class Bug : BugState, IUpdateable, ISerializable { + #region Updateinformation + + public int aVitality; + public int dDirection; + public int dPositionX; + public int dPositionY; + + private bool isAlive; + + #endregion + + public Bug(Serializer serializer) : base(0) { + Deserialize(serializer); + + Reset(); + } + + public Bug(BugState zustand) : base(zustand.Id) { + PositionX = zustand.PositionX; + PositionY = zustand.PositionY; + Direction = zustand.Direction; + Vitality = zustand.Vitality; + + Reset(); + } + + public void Reset() { + dPositionX = 0; + dPositionY = 0; + dDirection = 0; + aVitality = Vitality; + } + + #region IUpdateable Member + + public void Interpolate() { + PositionX += dPositionX; + PositionY += dPositionY; + Direction = Angle.Interpolate(Direction, dDirection); + Vitality = aVitality; + } + + public void Update(BugUpdate update) { + if (update.HasChanged(BugFields.PositionX)) { + dPositionX = update.dPositionX; + } + if (update.HasChanged(BugFields.PositionY)) { + dPositionY = update.dPositionY; + } + if (update.HasChanged(BugFields.Direction)) { + dDirection = update.dRichtung; + } + if (update.HasChanged(BugFields.Vitality)) { + aVitality = update.aEnergie; + } + } + + public BugUpdate GenerateUpdate(BugState state) { + BugUpdate update = new BugUpdate(); + update.Id = Id; + bool changed = false; + + if (state.PositionX != (PositionX + dPositionX)) { + update.Change(BugFields.PositionX); + update.dPositionX = state.PositionX - PositionX; + changed = true; + } + + if (state.PositionY != (PositionY + dPositionY)) { + update.Change(BugFields.PositionY); + update.dPositionY = state.PositionY - PositionY; + changed = true; + } + + if (state.Direction != Angle.Interpolate(Direction, dDirection)) { + update.Change(BugFields.Direction); + update.dRichtung = Angle.Delta(Direction, state.Direction); + changed = true; + } + + if (state.Vitality != aVitality) { + update.Change(BugFields.Vitality); + update.aEnergie = state.Vitality; + changed = true; + } + + if (changed) { + Update(update); + return update; + } + return null; + } + + public BugState GenerateState() { + BugState state = new BugState(Id); + state.PositionX = PositionX; + state.PositionY = PositionY; + state.Vitality = Vitality; + state.Direction = Direction; + return state; + } + + public bool IsAlive { + get { return isAlive; } + set { isAlive = value; } + } + + #endregion + + #region ISerializable Member + + // Blocklayout: + // - ushort Id + // - ushort PositionX + // - ushort PositionY + // - ushort Direction + // - ushort Vitality + + public void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) Id); + serializer.SendUshort((ushort) PositionX); + serializer.SendUshort((ushort) PositionY); + serializer.SendUshort((ushort) Direction); + serializer.SendUshort((ushort) Vitality); + } + + public void Deserialize(Serializer serializer) { + Id = serializer.ReadUShort(); + PositionX = serializer.ReadUShort(); + PositionY = serializer.ReadUShort(); + Direction = serializer.ReadUShort(); + Vitality = serializer.ReadUShort(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/BugUpdate.cs b/SharedComponents/AntVideo/Block/BugUpdate.cs new file mode 100644 index 0000000..9c22fa8 --- /dev/null +++ b/SharedComponents/AntVideo/Block/BugUpdate.cs @@ -0,0 +1,73 @@ +using System; + +namespace AntMe.SharedComponents.AntVideo.Block { + [Flags] + internal enum BugFields { + PositionX = 1, + PositionY = 2, + Direction = 4, + Vitality = 8 + } + + internal sealed class BugUpdate : UpdateBase { + public int aEnergie; + public int dPositionX; + public int dPositionY; + public int dRichtung; + + public BugUpdate() {} + + // Blocklayout: + // - ... + // - sbyte PositionX + // - sbyte PositionY + // - short Direction + // - ushort Vitality + + public BugUpdate(Serializer serializer) + : base(serializer) { + if (HasChanged(BugFields.PositionX)) { + dPositionX = serializer.ReadSByte(); + } + + if (HasChanged(BugFields.PositionY)) { + dPositionY = serializer.ReadSByte(); + } + + if (HasChanged(BugFields.Direction)) { + dRichtung = serializer.ReadShort(); + } + + if (HasChanged(BugFields.Vitality)) { + aEnergie = serializer.ReadUShort(); + } + } + + public override void Serialize(Serializer serializer) { + base.Serialize(serializer); + if (HasChanged(BugFields.PositionX)) { + serializer.SendSByte((sbyte) dPositionX); + } + + if (HasChanged(BugFields.PositionY)) { + serializer.SendSByte((sbyte) dPositionY); + } + + if (HasChanged(BugFields.Direction)) { + serializer.SendShort((short) dRichtung); + } + + if (HasChanged(BugFields.Vitality)) { + serializer.SendUshort((ushort) aEnergie); + } + } + + public void Change(BugFields field) { + Change((int) field); + } + + public bool HasChanged(BugFields field) { + return HasChanged((int) field); + } + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Caste.cs b/SharedComponents/AntVideo/Block/Caste.cs new file mode 100644 index 0000000..b8ef669 --- /dev/null +++ b/SharedComponents/AntVideo/Block/Caste.cs @@ -0,0 +1,76 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block { + internal sealed class Caste : CasteState, ISerializable { + public Caste(CasteState zustand) : base(zustand.ColonyId, zustand.Id) { + Name = zustand.Name; + SpeedModificator = zustand.SpeedModificator; + RotationSpeedModificator = zustand.RotationSpeedModificator; + LoadModificator = zustand.LoadModificator; + ViewRangeModificator = zustand.ViewRangeModificator; + RangeModificator = zustand.RangeModificator; + VitalityModificator = zustand.VitalityModificator; + AttackModificator = zustand.AttackModificator; + } + + public Caste(Serializer serializer) + : base(0, 0) { + Deserialize(serializer); + } + + public CasteState GenerateState() { + CasteState state = new CasteState(ColonyId, Id); + state.Name = Name; + state.SpeedModificator = SpeedModificator; + state.RotationSpeedModificator = RotationSpeedModificator; + state.LoadModificator = LoadModificator; + state.ViewRangeModificator = ViewRangeModificator; + state.RangeModificator = RangeModificator; + state.VitalityModificator = VitalityModificator; + state.AttackModificator = AttackModificator; + return state; + } + + #region ISerializable Member + + // Blocklayout: + // - ushort Id + // - ushort ColonyId + // - string Name + // - byte Speed + // - byte Rotate + // - byte Load + // - byte Viewrange + // - byte Range + // - byte Vitality + // - byte Attack + + public void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) Id); + serializer.SendUshort((ushort) ColonyId); + serializer.SendString(Name); + serializer.SendByte(SpeedModificator); + serializer.SendByte(RotationSpeedModificator); + serializer.SendByte(LoadModificator); + serializer.SendByte(ViewRangeModificator); + serializer.SendByte(RangeModificator); + serializer.SendByte(VitalityModificator); + serializer.SendByte(AttackModificator); + } + + public void Deserialize(Serializer serializer) { + Id = serializer.ReadUShort(); + ColonyId = serializer.ReadUShort(); + Name = serializer.ReadString(); + SpeedModificator = serializer.ReadByte(); + RotationSpeedModificator = serializer.ReadByte(); + LoadModificator = serializer.ReadByte(); + ViewRangeModificator = serializer.ReadByte(); + RangeModificator = serializer.ReadByte(); + VitalityModificator = serializer.ReadByte(); + AttackModificator = serializer.ReadByte(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Colony.cs b/SharedComponents/AntVideo/Block/Colony.cs new file mode 100644 index 0000000..aa16101 --- /dev/null +++ b/SharedComponents/AntVideo/Block/Colony.cs @@ -0,0 +1,220 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block { + internal sealed class Colony : ColonyState, IUpdateable, ISerializable { + #region Basisinformation + + public int TeamId; + + #endregion + + #region Updateinformation + + private int aBeatenAnts; + private int aCollectedFood; + private int aEatenAnts; + private int aKilledBugs; + private int aKilledEnemies; + private int aPoints; + private int aStarvedAnts; + + private bool isAlive; + + #endregion + + public Colony(ColonyState state, int teamId) : base(state.Id) { + Guid = state.Guid; + TeamId = teamId; + PlayerName = state.PlayerName; + ColonyName = state.ColonyName; + CollectedFood = state.CollectedFood; + StarvedAnts = state.StarvedAnts; + BeatenAnts = state.BeatenAnts; + EatenAnts = state.EatenAnts; + KilledBugs = state.KilledBugs; + KilledEnemies = state.KilledEnemies; + Points = state.Points; + + Reset(); + } + + public Colony(Serializer serializer) + : base(0) { + Deserialize(serializer); + + Reset(); + } + + /// + /// Setzt die Updatedaten auf erwartete Werte + /// + private void Reset() { + aStarvedAnts = StarvedAnts; + aBeatenAnts = BeatenAnts; + aEatenAnts = EatenAnts; + aKilledBugs = KilledBugs; + aKilledEnemies = KilledEnemies; + aCollectedFood = CollectedFood; + aPoints = Points; + } + + #region IUpdateable Member + + public void Interpolate() { + StarvedAnts = aStarvedAnts; + BeatenAnts = aBeatenAnts; + EatenAnts = aEatenAnts; + KilledBugs = aKilledBugs; + KilledEnemies = aKilledEnemies; + CollectedFood = aCollectedFood; + Points = aPoints; + } + + public void Update(ColonyUpdate update) { + if (update.HasChanged(ColonyFields.StarvedAnts)) { + aStarvedAnts = update.aStarvedAnts; + } + if (update.HasChanged(ColonyFields.EatenAnts)) { + aEatenAnts = update.aEatenAnts; + } + if (update.HasChanged(ColonyFields.BeatenAnts)) { + aBeatenAnts = update.aBeatenAnts; + } + if (update.HasChanged(ColonyFields.KilledBugs)) { + aKilledBugs = update.aKilledBugs; + } + if (update.HasChanged(ColonyFields.KilledEnemies)) { + aKilledEnemies = update.aKilledEnemies; + } + if (update.HasChanged(ColonyFields.CollectedFood)) { + aCollectedFood = update.aCollectedFood; + } + if (update.HasChanged(ColonyFields.Points)) { + aPoints = update.aPoints; + } + } + + public ColonyUpdate GenerateUpdate(ColonyState state) { + ColonyUpdate update = new ColonyUpdate(); + update.Id = Id; + update.TeamId = TeamId; + bool changed = false; + + if (state.StarvedAnts != aStarvedAnts) { + update.Change(ColonyFields.StarvedAnts); + update.aStarvedAnts = state.StarvedAnts; + changed = true; + } + if (state.EatenAnts != aEatenAnts) { + update.Change(ColonyFields.EatenAnts); + update.aEatenAnts = state.EatenAnts; + changed = true; + } + + if (state.BeatenAnts != aBeatenAnts) { + update.Change(ColonyFields.BeatenAnts); + update.aBeatenAnts = state.BeatenAnts; + changed = true; + } + + if (state.KilledBugs != aKilledBugs) { + update.Change(ColonyFields.KilledBugs); + update.aKilledBugs = state.KilledBugs; + changed = true; + } + if (state.KilledEnemies != aKilledEnemies) { + update.Change(ColonyFields.KilledEnemies); + update.aKilledEnemies = state.KilledEnemies; + changed = true; + } + + if (state.CollectedFood != aCollectedFood) { + update.Change(ColonyFields.CollectedFood); + update.aCollectedFood = state.CollectedFood; + changed = true; + } + + if (state.Points != aPoints) { + update.Change(ColonyFields.Points); + update.aPoints = state.Points; + changed = true; + } + + if (changed) { + Update(update); + return update; + } + return null; + } + + public ColonyState GenerateState() { + ColonyState state = new ColonyState(Id); + state.Guid = Guid; + state.PlayerName = PlayerName; + state.ColonyName = ColonyName; + state.StarvedAnts = StarvedAnts; + state.EatenAnts = EatenAnts; + state.BeatenAnts = BeatenAnts; + state.KilledBugs = KilledBugs; + state.KilledEnemies = KilledEnemies; + state.CollectedFood = CollectedFood; + state.Points = Points; + return state; + } + + public bool IsAlive { + get { return isAlive; } + set { isAlive = value; } + } + + #endregion + + #region ISerializable Member + + // Blocklayout: + // - ushort ID + // - guid Guid + // - ushort Team + // - string PlayerName + // - string ColonyName + // - ushort StarvedAnts + // - ushort EatenAnts + // - ushort BeatenAnts + // - ushort KilledBugs + // - ushort KilledEnemies + // - ushort CollectedFood + // - int Points + + public void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) Id); + serializer.SendGuid(Guid); + serializer.SendUshort((ushort) TeamId); + serializer.SendString(PlayerName); + serializer.SendString(ColonyName); + serializer.SendUshort((ushort) StarvedAnts); + serializer.SendUshort((ushort) EatenAnts); + serializer.SendUshort((ushort) BeatenAnts); + serializer.SendUshort((ushort) KilledBugs); + serializer.SendUshort((ushort) KilledEnemies); + serializer.SendUshort((ushort) CollectedFood); + serializer.SendInt(Points); + } + + public void Deserialize(Serializer serializer) { + Id = serializer.ReadUShort(); + Guid = serializer.ReadGuid(); + TeamId = serializer.ReadUShort(); + PlayerName = serializer.ReadString(); + ColonyName = serializer.ReadString(); + StarvedAnts = serializer.ReadUShort(); + EatenAnts = serializer.ReadUShort(); + BeatenAnts = serializer.ReadUShort(); + KilledBugs = serializer.ReadUShort(); + KilledEnemies = serializer.ReadUShort(); + CollectedFood = serializer.ReadUShort(); + Points = serializer.ReadInt(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/ColonyUpdate.cs b/SharedComponents/AntVideo/Block/ColonyUpdate.cs new file mode 100644 index 0000000..bda298d --- /dev/null +++ b/SharedComponents/AntVideo/Block/ColonyUpdate.cs @@ -0,0 +1,106 @@ +using System; + +namespace AntMe.SharedComponents.AntVideo.Block { + [Flags] + internal enum ColonyFields { + CollectedFood = 1, + StarvedAnts = 2, + EatenAnts = 4, + BeatenAnts = 8, + KilledBugs = 16, + KilledEnemies = 32, + Points = 64 + } + + internal sealed class ColonyUpdate : UpdateBase { + public int TeamId; + public int aBeatenAnts; + public int aEatenAnts; + public int aCollectedFood; + public int aKilledBugs; + public int aKilledEnemies; + public int aPoints; + public int aStarvedAnts; + + public ColonyUpdate() {} + + // Blocklayout: + // - ... + // - ushort TeamId + // - ushort CollectedFood + // - ushort StarvedAnts + // - ushort EatenAnts + // - ushort BeatenAnts + // - ushort KilledBugs + // - ushort KilledEnemies + // - int Points + + public ColonyUpdate(Serializer serializer) + : base(serializer) { + TeamId = serializer.ReadUShort(); + + if (HasChanged(ColonyFields.CollectedFood)) { + aCollectedFood = serializer.ReadUShort(); + } + + if (HasChanged(ColonyFields.StarvedAnts)) { + aStarvedAnts = serializer.ReadUShort(); + } + if (HasChanged(ColonyFields.EatenAnts)) { + aEatenAnts = serializer.ReadUShort(); + } + if (HasChanged(ColonyFields.BeatenAnts)) { + aBeatenAnts = serializer.ReadUShort(); + } + + if (HasChanged(ColonyFields.KilledBugs)) { + aKilledBugs = serializer.ReadUShort(); + } + if (HasChanged(ColonyFields.KilledEnemies)) { + aKilledEnemies = serializer.ReadUShort(); + } + + if (HasChanged(ColonyFields.Points)) { + aPoints = serializer.ReadInt(); + } + } + + public override void Serialize(Serializer serializer) { + base.Serialize(serializer); + serializer.SendUshort((ushort) TeamId); + + if (HasChanged(ColonyFields.CollectedFood)) { + serializer.SendUshort((ushort) aCollectedFood); + } + + if (HasChanged(ColonyFields.StarvedAnts)) { + serializer.SendUshort((ushort) aStarvedAnts); + } + if (HasChanged(ColonyFields.EatenAnts)) { + serializer.SendUshort((ushort) aEatenAnts); + } + if (HasChanged(ColonyFields.BeatenAnts)) { + serializer.SendUshort((ushort) aBeatenAnts); + } + + if (HasChanged(ColonyFields.KilledBugs)) { + serializer.SendUshort((ushort) aKilledBugs); + } + if (HasChanged(ColonyFields.KilledEnemies)) { + serializer.SendUshort((ushort) aKilledEnemies); + } + + if (HasChanged(ColonyFields.Points)) { + serializer.SendInt(aPoints); + } + } + + public void Change(ColonyFields field) { + Change((int) field); + } + + public bool HasChanged(ColonyFields field) { + return HasChanged((int) field); + } + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/FolkLost.cs b/SharedComponents/AntVideo/Block/FolkLost.cs new file mode 100644 index 0000000..bdcdc87 --- /dev/null +++ b/SharedComponents/AntVideo/Block/FolkLost.cs @@ -0,0 +1,32 @@ +using System.IO; + +namespace AntMe.SharedComponents.AntVideo.Block { + internal class FolkLost : Lost, ISerializable { + private int folkId; + + public FolkLost(int folkId, int id) : base(id) { + this.folkId = (ushort) folkId; + } + + public FolkLost(Stream stream) : base(stream) { + Deserialize(stream); + } + + public int FolkId { + get { return folkId; } + } + + #region ISerializable Member + + public override void Serialize(Stream outputstream) { + base.Serialize(outputstream); + Serializer.SendUshort(outputstream, folkId); + } + + public new void Deserialize(Stream stream) { + folkId = Serializer.ReadUShort(stream); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Frame.cs b/SharedComponents/AntVideo/Block/Frame.cs new file mode 100644 index 0000000..28efc00 --- /dev/null +++ b/SharedComponents/AntVideo/Block/Frame.cs @@ -0,0 +1,103 @@ +using System; + +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block { + /// + /// Repräsentiert den Zustandsblock + /// + internal sealed class Frame : SimulationState, IUpdateable, ISerializable { + #region Updateinformation + + private int aCurrentRound; + private DateTime aTimestamp; + private bool isAlive; + + #endregion + + public Frame(SimulationState state) { + TotalRounds = state.TotalRounds; + PlaygroundHeight = state.PlaygroundHeight; + PlaygroundWidth = state.PlaygroundWidth; + TimeStamp = state.TimeStamp; + CurrentRound = state.CurrentRound; + + Reset(); + } + + public Frame(Serializer serializer) { + Deserialize(serializer); + + Reset(); + } + + private void Reset() { + aTimestamp = TimeStamp; + aCurrentRound = CurrentRound; + } + + #region IUpdateable Member + + public void Interpolate() { + TimeStamp = aTimestamp; + CurrentRound = aCurrentRound; + } + + public void Update(FrameUpdate update) { + aTimestamp = update.aTimestamp; + aCurrentRound = update.aCurrentRound; + } + + public FrameUpdate GenerateUpdate(SimulationState state) { + FrameUpdate update = new FrameUpdate(); + update.aTimestamp = state.TimeStamp; + update.aCurrentRound = state.CurrentRound; + Update(update); + return update; + } + + public SimulationState GenerateState() { + SimulationState state = new SimulationState(); + state.CurrentRound = CurrentRound; + state.PlaygroundHeight = PlaygroundHeight; + state.PlaygroundWidth = PlaygroundWidth; + state.TimeStamp = TimeStamp; + state.TotalRounds = TotalRounds; + return state; + } + + public bool IsAlive { + get { return isAlive; } + set { isAlive = value; } + } + + #endregion + + #region ISerializable Member + + // Blocklayout: + // ushort TotalRounds + // ushort Height + // ushort Width + // timestamp Timestamp + // ushort CurrentRound + + public void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) TotalRounds); + serializer.SendUshort((ushort) PlaygroundHeight); + serializer.SendUshort((ushort) PlaygroundWidth); + serializer.SendDateTime(TimeStamp); + serializer.SendUshort((ushort) CurrentRound); + } + + public void Deserialize(Serializer serializer) { + TotalRounds = serializer.ReadUShort(); + PlaygroundHeight = serializer.ReadUShort(); + PlaygroundWidth = serializer.ReadUShort(); + TimeStamp = serializer.ReadDateTime(); + CurrentRound = serializer.ReadUShort(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/FrameUpdate.cs b/SharedComponents/AntVideo/Block/FrameUpdate.cs new file mode 100644 index 0000000..93347c6 --- /dev/null +++ b/SharedComponents/AntVideo/Block/FrameUpdate.cs @@ -0,0 +1,32 @@ +using System; + +namespace AntMe.SharedComponents.AntVideo.Block { + internal sealed class FrameUpdate : ISerializable { + public DateTime aTimestamp = DateTime.MinValue; + public int aCurrentRound; + + public FrameUpdate() {} + + // Blocklayout: + // - Datetime TimeStamp + // - ushort aCurrentRound + + public FrameUpdate(Serializer serializer) { + Deserialize(serializer); + } + + #region ISerializable Member + + public void Serialize(Serializer serializer) { + serializer.SendDateTime(aTimestamp); + serializer.SendUshort((ushort) aCurrentRound); + } + + public void Deserialize(Serializer serializer) { + aTimestamp = serializer.ReadDateTime(); + aCurrentRound = serializer.ReadUShort(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Fruit.cs b/SharedComponents/AntVideo/Block/Fruit.cs new file mode 100644 index 0000000..88fb87d --- /dev/null +++ b/SharedComponents/AntVideo/Block/Fruit.cs @@ -0,0 +1,134 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block { + internal sealed class Fruit : FruitState, IUpdateable, ISerializable { + #region Updateinformation + + public byte aCarringAnts; + public int dPositionX; + public int dPositionY; + + private bool isAlive; + + #endregion + + public Fruit(Serializer serializer) + : base(0) { + Deserialize(serializer); + + Reset(); + } + + public Fruit(FruitState zustand) : base(zustand.Id) { + Amount = zustand.Amount; + Radius = zustand.Radius; + PositionX = zustand.PositionX; + PositionY = zustand.PositionY; + CarryingAnts = zustand.CarryingAnts; + + Reset(); + } + + private void Reset() { + dPositionX = 0; + dPositionY = 0; + aCarringAnts = CarryingAnts; + } + + #region IUpdateable Member + + public void Interpolate() { + PositionX += dPositionX; + PositionY += dPositionY; + CarryingAnts = aCarringAnts; + } + + public void Update(FruitUpdate update) { + if (update.HasChanged(FruitFields.PositionX)) { + dPositionX = update.dPositionX; + } + + if (update.HasChanged(FruitFields.PositionY)) { + dPositionY = update.dPositionY; + } + if (update.HasChanged(FruitFields.CarringAnts)) { + aCarringAnts = update.aCarringAnts; + } + } + + public FruitUpdate GenerateUpdate(FruitState state) { + FruitUpdate update = new FruitUpdate(); + update.Id = Id; + bool changed = false; + + if (state.PositionX != (PositionX + dPositionX)) { + update.Change(FruitFields.PositionX); + update.dPositionX = state.PositionX - PositionX; + changed = true; + } + if (state.PositionY != (PositionY + dPositionY)) { + update.Change(FruitFields.PositionY); + update.dPositionY = state.PositionY - PositionY; + changed = true; + } + if (state.CarryingAnts != CarryingAnts) { + update.Change(FruitFields.CarringAnts); + update.aCarringAnts = state.CarryingAnts; + changed = true; + } + + if (changed) { + Update(update); + return update; + } + return null; + } + + public FruitState GenerateState() { + FruitState state = new FruitState(Id); + state.PositionX = PositionX; + state.PositionY = PositionY; + state.Radius = Radius; + state.Amount = Amount; + state.CarryingAnts = CarryingAnts; + return state; + } + + public bool IsAlive { + get { return isAlive; } + set { isAlive = value; } + } + + #endregion + + #region ISerializable Member + + // Blocklayout: + // - ushort Id + // - ushort Amount + // - ushort Radius + // - ushort PositionX + // - ushort PositionY + // - byte CarringAnts + + public void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) Id); + serializer.SendUshort((ushort) Amount); + serializer.SendUshort((ushort) Radius); + serializer.SendUshort((ushort) PositionX); + serializer.SendUshort((ushort) PositionY); + serializer.SendByte(CarryingAnts); + } + + public void Deserialize(Serializer serializer) { + Id = serializer.ReadUShort(); + Amount = serializer.ReadUShort(); + Radius = serializer.ReadUShort(); + PositionX = serializer.ReadUShort(); + PositionY = serializer.ReadUShort(); + CarryingAnts = serializer.ReadByte(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/FruitUpdate.cs b/SharedComponents/AntVideo/Block/FruitUpdate.cs new file mode 100644 index 0000000..9194660 --- /dev/null +++ b/SharedComponents/AntVideo/Block/FruitUpdate.cs @@ -0,0 +1,64 @@ +using System; + +namespace AntMe.SharedComponents.AntVideo.Block { + [Flags] + internal enum FruitFields { + PositionX = 1, + PositionY = 2, + CarringAnts = 4 + } ; + + internal sealed class FruitUpdate : UpdateBase { + public byte aCarringAnts; + public int dPositionX; + public int dPositionY; + + public FruitUpdate() {} + + // Blocklayout: + // ... + // - sbyte PositionX + // - sbyte PositionY + // - byte CarringAnts + + public FruitUpdate(Serializer serializer) + : base(serializer) { + + if (HasChanged(FruitFields.PositionX)) { + dPositionX = serializer.ReadSByte(); + } + + if (HasChanged(FruitFields.PositionY)) { + dPositionY = serializer.ReadSByte(); + } + + if (HasChanged(FruitFields.CarringAnts)) { + aCarringAnts = serializer.ReadByte(); + } + } + + public override void Serialize(Serializer serializer) { + base.Serialize(serializer); + + if (HasChanged(FruitFields.PositionX)) { + serializer.SendSByte((sbyte) dPositionX); + } + + if (HasChanged(FruitFields.PositionY)) { + serializer.SendSByte((sbyte) dPositionY); + } + + if (HasChanged(FruitFields.CarringAnts)) { + serializer.SendByte(aCarringAnts); + } + } + + public void Change(FruitFields field) { + Change((int) field); + } + + public bool HasChanged(FruitFields field) { + return HasChanged((int) field); + } + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Lost.cs b/SharedComponents/AntVideo/Block/Lost.cs new file mode 100644 index 0000000..4a856c1 --- /dev/null +++ b/SharedComponents/AntVideo/Block/Lost.cs @@ -0,0 +1,29 @@ +namespace AntMe.SharedComponents.AntVideo.Block { + internal class Lost : ISerializable { + private int id; + + public Lost(int id) { + this.id = id; + } + + public Lost(Serializer serializer) { + Deserialize(serializer); + } + + public int Id { + get { return id; } + } + + #region ISerializable Member + + public virtual void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) id); + } + + public void Deserialize(Serializer serializer) { + id = serializer.ReadUShort(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Marker.cs b/SharedComponents/AntVideo/Block/Marker.cs new file mode 100644 index 0000000..99465a3 --- /dev/null +++ b/SharedComponents/AntVideo/Block/Marker.cs @@ -0,0 +1,118 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block { + internal class Marker : MarkerState, IUpdateable, ISerializable { + #region Updateinformation + + public int aRichtung; + public int dRadius; + private bool isAlive; + + #endregion + + public Marker(Serializer serializer) + : base(0, 0) { + Deserialize(serializer); + + Reset(); + } + + public Marker(MarkerState zustand) : base(zustand.ColonyId, zustand.Id) { + PositionX = zustand.PositionX; + PositionY = zustand.PositionY; + Radius = zustand.Radius; + Direction = zustand.Direction; + + Reset(); + } + + private void Reset() { + aRichtung = Direction; + dRadius = 0; + } + + #region IUpdateable Member + + public void Interpolate() { + Radius += dRadius; + Direction = aRichtung; + } + + public void Update(MarkerUpdate update) { + if (update.HasChanged(MarkerFields.Radius)) { + dRadius = update.dRadius; + } + if (update.HasChanged(MarkerFields.Direction)) { + aRichtung = update.aDirection; + } + } + + public MarkerUpdate GenerateUpdate(MarkerState state) { + MarkerUpdate update = new MarkerUpdate(); + update.Id = Id; + bool changed = false; + + if (state.Radius != (Radius + dRadius)) { + update.Change(MarkerFields.Radius); + update.dRadius = state.Radius - Radius; + changed = true; + } + if (state.Direction != Direction) { + update.Change(MarkerFields.Direction); + update.aDirection = state.Direction; + changed = true; + } + + if (changed) { + Update(update); + return update; + } + return null; + } + + public MarkerState GenerateState() { + MarkerState state = new MarkerState(ColonyId, Id); + state.PositionX = PositionX; + state.PositionY = PositionY; + state.Radius = Radius; + state.Direction = Direction; + return state; + } + + public bool IsAlive { + get { return isAlive; } + set { isAlive = value; } + } + + #endregion + + #region ISerializable Member + + // Blocklayout: + // - ushort Id + // - ushort ColonyId + // - ushort PositionX + // - ushort PositionY + // - ushort Radius + // - ushort Direction + public void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) Id); + serializer.SendUshort((ushort) ColonyId); + serializer.SendUshort((ushort) PositionX); + serializer.SendUshort((ushort) PositionY); + serializer.SendUshort((ushort) Radius); + serializer.SendUshort((ushort) Direction); + } + + public void Deserialize(Serializer serializer) { + Id = serializer.ReadUShort(); + ColonyId = serializer.ReadUShort(); + PositionX = serializer.ReadUShort(); + PositionY = serializer.ReadUShort(); + Radius = serializer.ReadUShort(); + Direction = serializer.ReadUShort(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/MarkerUpdate.cs b/SharedComponents/AntVideo/Block/MarkerUpdate.cs new file mode 100644 index 0000000..8b0e0af --- /dev/null +++ b/SharedComponents/AntVideo/Block/MarkerUpdate.cs @@ -0,0 +1,49 @@ +using System; + +namespace AntMe.SharedComponents.AntVideo.Block { + [Flags] + internal enum MarkerFields { + Radius = 1, + Direction = 2 + } ; + + internal sealed class MarkerUpdate : UpdateBase { + public int aDirection; + public int dRadius; + + public MarkerUpdate() {} + + // Blocklayout: + // ... + // - ushort aRadius + // - ushort aDirection + + public MarkerUpdate(Serializer serializer) + : base(serializer) { + if (HasChanged(MarkerFields.Radius)) { + dRadius = serializer.ReadUShort(); + } + if (HasChanged(MarkerFields.Direction)) { + aDirection = serializer.ReadUShort(); + } + } + + public override void Serialize(Serializer serializer) { + base.Serialize(serializer); + if (HasChanged(MarkerFields.Radius)) { + serializer.SendUshort((ushort) dRadius); + } + if (HasChanged(MarkerFields.Direction)) { + serializer.SendUshort((ushort) aDirection); + } + } + + public void Change(MarkerFields field) { + Change((int) field); + } + + public bool HasChanged(MarkerFields field) { + return HasChanged((int) field); + } + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Sugar.cs b/SharedComponents/AntVideo/Block/Sugar.cs new file mode 100644 index 0000000..5ae312c --- /dev/null +++ b/SharedComponents/AntVideo/Block/Sugar.cs @@ -0,0 +1,116 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block { + internal sealed class Sugar : SugarState, IUpdateable, ISerializable { + #region Updateinformation + + private bool m_isAlive; + private int m_aAmount; + private int m_aRadius; + + #endregion + + public Sugar(Serializer serializer) + : base(0) { + Deserialize(serializer); + + Reset(); + } + + public Sugar(SugarState zustand) : base(zustand.Id) { + PositionX = zustand.PositionX; + PositionY = zustand.PositionY; + Radius = zustand.Radius; + Amount = zustand.Amount; + + Reset(); + } + + private void Reset() { + m_aAmount = Amount; + m_aRadius = Radius; + } + + #region IUpdateable Member + + public void Interpolate() { + Amount = m_aAmount; + Radius = m_aRadius; + } + + public void Update(SugarUpdate update) { + if (update.HasChanged(SugarFields.Amount)) { + m_aAmount = update.AbsoluteAmount; + } + if (update.HasChanged(SugarFields.Range)) { + m_aRadius = update.AbsoluteRadius; + } + } + + public SugarUpdate GenerateUpdate(SugarState state) { + SugarUpdate update = new SugarUpdate(); + update.Id = Id; + bool changed = false; + + if (Radius != state.Radius) { + update.Change(SugarFields.Range); + update.AbsoluteRadius = (ushort) state.Radius; + changed = true; + } + if (Amount != state.Amount) { + update.Change(SugarFields.Amount); + update.AbsoluteAmount = (ushort) state.Amount; + changed = true; + } + + if (changed) { + Update(update); + return update; + } + return null; + } + + public SugarState GenerateState() { + SugarState zustand = new SugarState(Id); + zustand.PositionX = PositionX; + zustand.PositionY = PositionY; + zustand.Radius = Radius; + zustand.Amount = Amount; + return zustand; + } + + public bool IsAlive { + get { return m_isAlive; } + set { m_isAlive = value; } + } + + #endregion + + #region ISerializable Member + + // Blocklayout: + // - ushort ID + // - ushort PosX + // - ushort PosY + // - ushort Amount + // - ushort Radius + + public void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) Id); + serializer.SendUshort((ushort) PositionX); + serializer.SendUshort((ushort) PositionY); + serializer.SendUshort((ushort) Amount); + serializer.SendUshort((ushort) Radius); + } + + public void Deserialize(Serializer serializer) { + Id = serializer.ReadUShort(); + PositionX = serializer.ReadUShort(); + PositionY = serializer.ReadUShort(); + Amount = serializer.ReadUShort(); + Radius = serializer.ReadUShort(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/SugarUpdate.cs b/SharedComponents/AntVideo/Block/SugarUpdate.cs new file mode 100644 index 0000000..107f1fe --- /dev/null +++ b/SharedComponents/AntVideo/Block/SugarUpdate.cs @@ -0,0 +1,77 @@ +using System; + +namespace AntMe.SharedComponents.AntVideo.Block { + /// + /// Possible Fields of sugarupdate + /// + [Flags] + internal enum SugarFields { + Amount = 1, + Range = 2 + } + + internal sealed class SugarUpdate : UpdateBase { + #region Updateinformation + + private int m_aMenge; + private int m_aRadius; + + #endregion + + public SugarUpdate() {} + + // Blocklayout: + // ... + // ushort aAmount + // ushort aRadius + + public SugarUpdate(Serializer serializer) + : base(serializer) { + if (HasChanged(SugarFields.Amount)) { + m_aMenge = serializer.ReadUShort(); + } + if (HasChanged(SugarFields.Range)) { + m_aRadius = serializer.ReadUShort(); + } + } + + public override void Serialize(Serializer serializer) { + base.Serialize(serializer); + + if (HasChanged(SugarFields.Amount)) { + serializer.SendUshort((ushort) m_aMenge); + } + if (HasChanged(SugarFields.Range)) { + serializer.SendUshort((ushort) m_aRadius); + } + } + + public void Change(SugarFields field) { + Change((int) field); + } + + public bool HasChanged(SugarFields field) { + return HasChanged((int) field); + } + + #region Properties + + /// + /// Gets or sets the absolute value of amount. + /// + public int AbsoluteAmount { + get { return m_aMenge; } + set { m_aMenge = value; } + } + + /// + /// Gets or sets the absolute value for radius. + /// + public int AbsoluteRadius { + get { return m_aRadius; } + set { m_aRadius = value; } + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/Team.cs b/SharedComponents/AntVideo/Block/Team.cs new file mode 100644 index 0000000..db18b1a --- /dev/null +++ b/SharedComponents/AntVideo/Block/Team.cs @@ -0,0 +1,41 @@ +using System; + +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.AntVideo.Block { + internal sealed class Team : TeamState, ISerializable { + public Team(TeamState state) : base(state.Id, state.Guid, state.Name) {} + + public Team(Serializer serializer) + : base(0, new Guid(), string.Empty) { + Deserialize(serializer); + } + + public TeamState GenerateState() { + TeamState state = new TeamState(Id); + state.Guid = Guid; + state.Name = Name; + return state; + } + + #region ISerializable Members + + // - ushort ID + // - guid Guid + // - string Name + + public void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) Id); + serializer.SendGuid(Guid); + serializer.SendString(Name); + } + + public void Deserialize(Serializer serializer) { + Id = serializer.ReadUShort(); + Guid = serializer.ReadGuid(); + Name = serializer.ReadString(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Block/UpdateBase.cs b/SharedComponents/AntVideo/Block/UpdateBase.cs new file mode 100644 index 0000000..c754f97 --- /dev/null +++ b/SharedComponents/AntVideo/Block/UpdateBase.cs @@ -0,0 +1,73 @@ +using System; + +namespace AntMe.SharedComponents.AntVideo.Block { + /// + /// Basisklasse für alle Updateblocks für ein einheitliches Speichern der veränderten Felder + /// + internal abstract class UpdateBase : ISerializable { + #region internal Variables + + private int m_id; + private int m_changedFields; + + #endregion + + protected UpdateBase() {} + + protected UpdateBase(Serializer serializer) { + m_changedFields = serializer.ReadUShort(); + m_id = serializer.ReadUShort(); + } + + /// + /// Sets the given field to changed-state + /// + /// Changed field + protected void Change(int field) { + m_changedFields |= field; + } + + /// + /// Indicates changes in given field. + /// + /// field to check + /// Changes in field + protected bool HasChanged(int field) { + return ((m_changedFields & field) > 0); + } + + /// + /// Gets or sets the id. + /// + public int Id { + get { return m_id; } + set { m_id = value; } + } + + #region ISerializable Member + + // Blocklayout: + // - ushort changedFields + // - ushort id + // - ... + + /// + /// Serializes the updateinformation into the given stream. + /// + /// outputstream + public virtual void Serialize(Serializer serializer) { + serializer.SendUshort((ushort) m_changedFields); + serializer.SendUshort((ushort) m_id); + } + + /// + /// Deserializes the updateinformation out of given stream. + /// + /// inputstream + public void Deserialize(Serializer serializer) { + throw new NotImplementedException("Deserializer is not needed."); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/BlockType.cs b/SharedComponents/AntVideo/BlockType.cs new file mode 100644 index 0000000..04717a6 --- /dev/null +++ b/SharedComponents/AntVideo/BlockType.cs @@ -0,0 +1,50 @@ +namespace AntMe.SharedComponents.AntVideo +{ + /// + /// List of possible block-types in stream. + /// + internal enum BlockType + { + // Frame-blocks + StreamStart = 0x01, + StreamEnd = 0x02, + FrameStart = 0x03, + FrameEnd = 0x04, + + // Start-blocks + Frame = 0x10, + Colony = 0x11, + Anthill = 0x12, + Ant = 0x13, + Marker = 0x14, + Fruit = 0x15, + Caste = 0x16, + Sugar = 0x17, + Bug = 0x18, + Team = 0x19, + + // Update-blocks + FrameUpdate = 0x20, + ColonyUpdate = 0x21, + AnthillUpdate = 0x22, + AntUpdate = 0x23, + MarkerUpdate = 0x24, + FruitUpdate = 0x25, + CasteUpdate = 0x26, + SugarUpdate = 0x27, + BugUpdate = 0x28, + TeamUpdate = 0x29, + + // Lost-blocks + FrameLost = 0x30, + ColonyLost = 0x31, + AnthillLost = 0x32, + AntLost = 0x33, + MarkerLost = 0x34, + FruitLost = 0x35, + CasteLost = 0x36, + SugarLost = 0x37, + BugLost = 0x38, + TeamLost = 0x39 + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/ISerializable.cs b/SharedComponents/AntVideo/ISerializable.cs new file mode 100644 index 0000000..438828a --- /dev/null +++ b/SharedComponents/AntVideo/ISerializable.cs @@ -0,0 +1,18 @@ +namespace AntMe.SharedComponents.AntVideo { + /// + /// Interface for all serializable blocks. + /// + internal interface ISerializable { + /// + /// Serializes the object into the given stream. + /// + /// output-stream + void Serialize(Serializer serializer); + + /// + /// De-serializes the object out of given stream. + /// + /// input-stream + void Deserialize(Serializer serializer); + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/IUpdateable.cs b/SharedComponents/AntVideo/IUpdateable.cs new file mode 100644 index 0000000..8a9c9be --- /dev/null +++ b/SharedComponents/AntVideo/IUpdateable.cs @@ -0,0 +1,34 @@ +namespace AntMe.SharedComponents.AntVideo { + /// + /// Interface for all updateable item-states + /// + internal interface IUpdateable { + /// + /// Calculates the next state based on the last update-information + /// + void Interpolate(); + + /// + /// Delivers a new update-information + /// + /// new Update + void Update(T update); + + /// + /// Generates a new update-information based on given state + /// + /// update-information + T GenerateUpdate(V state); + + /// + /// Generates a state of current states + /// + /// state + V GenerateState(); + + /// + /// Flag to mark activity + /// + bool IsAlive { get; set; } + } +} \ No newline at end of file diff --git a/SharedComponents/AntVideo/Serializer.cs b/SharedComponents/AntVideo/Serializer.cs new file mode 100644 index 0000000..ce37bed --- /dev/null +++ b/SharedComponents/AntVideo/Serializer.cs @@ -0,0 +1,344 @@ +using System; +using System.IO; +using System.Text; +using AntMe.SharedComponents.AntVideo.Block; +using System.Globalization; + +namespace AntMe.SharedComponents.AntVideo { + /// + /// Class, to manage all serialize-tasks. + /// + internal sealed class Serializer : IDisposable { + private const string HELLOMESSAGE = "AntVI-VideoStream"; + + private readonly Stream stream; + private readonly BinaryWriter writer; + private readonly BinaryReader reader; + private readonly byte[] version = new byte[] {1, 0, 0, 0}; + + public Serializer(Stream stream) { + this.stream = stream; + reader = new BinaryReader(stream, Encoding.ASCII); + writer = new BinaryWriter(stream, Encoding.ASCII); + } + + /// + /// Reads the next block out of stream. + /// + /// the found block + /// type of found block + public BlockType Read(out ISerializable block) { + BlockType blockType = (BlockType) stream.ReadByte(); + block = null; + + switch (blockType) { + case BlockType.Ant: + block = new Ant(this); + break; + case BlockType.Anthill: + block = new Anthill(this); + break; + case BlockType.AnthillLost: + throw new InvalidOperationException(string.Format(Resource.AntvideoSerializerInvalidBlockType, blockType)); + case BlockType.AnthillUpdate: + throw new InvalidOperationException(string.Format(Resource.AntvideoSerializerInvalidBlockType, blockType)); + case BlockType.AntLost: + block = new Lost(this); + break; + case BlockType.AntUpdate: + block = new AntUpdate(this); + break; + case BlockType.Bug: + block = new Bug(this); + break; + case BlockType.BugLost: + block = new Lost(this); + break; + case BlockType.BugUpdate: + block = new BugUpdate(this); + break; + case BlockType.Team: + block = new Team(this); + break; + case BlockType.TeamLost: + throw new InvalidOperationException(string.Format(Resource.AntvideoSerializerInvalidBlockType, blockType)); + case BlockType.TeamUpdate: + throw new InvalidOperationException(string.Format(Resource.AntvideoSerializerInvalidBlockType, blockType)); + case BlockType.Colony: + block = new Colony(this); + break; + case BlockType.ColonyLost: + throw new InvalidOperationException(string.Format(Resource.AntvideoSerializerInvalidBlockType, blockType)); + case BlockType.ColonyUpdate: + block = new ColonyUpdate(this); + break; + case BlockType.Frame: + block = new Frame(this); + break; + case BlockType.StreamEnd: + break; + case BlockType.FrameLost: + throw new InvalidOperationException(string.Format(Resource.AntvideoSerializerInvalidBlockType, blockType)); + case BlockType.FrameUpdate: + block = new FrameUpdate(this); + break; + case BlockType.Fruit: + block = new Fruit(this); + break; + case BlockType.FruitLost: + block = new Lost(this); + break; + case BlockType.FruitUpdate: + block = new FruitUpdate(this); + break; + case BlockType.Marker: + block = new Marker(this); + break; + case BlockType.MarkerLost: + block = new Lost(this); + break; + case BlockType.MarkerUpdate: + block = new MarkerUpdate(this); + break; + case BlockType.Caste: + block = new Caste(this); + break; + case BlockType.CasteLost: + throw new InvalidOperationException(string.Format(Resource.AntvideoSerializerInvalidBlockType, blockType)); + case BlockType.CasteUpdate: + throw new InvalidOperationException(string.Format(Resource.AntvideoSerializerInvalidBlockType, blockType)); + case BlockType.Sugar: + block = new Sugar(this); + break; + case BlockType.SugarLost: + block = new Lost(this); + break; + case BlockType.SugarUpdate: + block = new SugarUpdate(this); + break; + case BlockType.FrameStart: + break; + case BlockType.FrameEnd: + break; + default: + throw new InvalidOperationException(string.Format(Resource.AntvideoSerializerInvalidBlockType, blockType)); + } + + return blockType; + } + + /// + /// Writes the hello-header to stream. + /// + public void WriteHello() { + byte[] output = ASCIIEncoding.ASCII.GetBytes(HELLOMESSAGE); + stream.Write(output, 0, output.Length); + stream.WriteByte(version[0]); + stream.WriteByte(version[1]); + stream.WriteByte(version[2]); + stream.WriteByte(version[3]); + } + + /// + /// Reads hello-header out of stream. + /// + public void ReadHello() { + + // Compare hello-message + byte[] compare = ASCIIEncoding.ASCII.GetBytes(HELLOMESSAGE); + stream.Read(compare, 0, compare.Length); + if (ASCIIEncoding.ASCII.GetString(compare) != HELLOMESSAGE) { + throw new NotSupportedException(Resource.AntvideoSerializerWrongHeader); + } + + // Compare version-number + byte[] vers = new byte[4]; + stream.Read(vers, 0, 4); + if (vers[0] != version[0] || + vers[1] != version[1] || + vers[2] != version[2] || + vers[3] != version[3]) { + throw new NotSupportedException( + string.Format( + CultureInfo.CurrentCulture, + Resource.AntvideoSerializerWrongProtocolVersion, vers[0], vers[1], vers[2], vers[3])); + } + + if ((BlockType) stream.ReadByte() != BlockType.StreamStart) { + throw new NotSupportedException(Resource.AntvideoSerializerWrongHeader); + } + } + + /// + /// Writes a given block to stream. + /// + /// type of given block + /// block, to write + public void Write(BlockType blocktype, ISerializable block) { + stream.WriteByte((byte) blocktype); + if (block != null) { + block.Serialize(this); + } + } + + /// + /// Writes a given block to stream. + /// + /// type of block + public void Write(BlockType blocktype) { + Write(blocktype, null); + } + + /// + /// Reads the following byte without affect the streamposition. + /// + /// next byte + public int Peek() { + int output = stream.ReadByte(); + stream.Position--; + return output; + } + + /// + /// Close stream. + /// + public void Close() { + stream.Close(); + reader.Close(); + writer.Close(); + } + + #region Sendemethoden + + /// + /// Sendet einen ushort über den Stream + /// + /// ushort + public void SendUshort(ushort item) { + writer.Write(item); + } + + /// + /// Sends a short + /// + /// short + public void SendShort(short item) { + writer.Write(item); + } + + /// + /// Sendet einen sbyte über den angegebenen stream + /// + /// sbyte + public void SendSByte(sbyte item) { + writer.Write(item); + } + + /// + /// Sendet einen integer über den Stream + /// + /// integer + public void SendInt(int item) { + writer.Write(item); + } + + public void SendLong(long item) { + writer.Write(item); + } + + /// + /// Sendet einen string über den Stream + /// + /// string + public void SendString(string item) { + writer.Write(item); + } + + public void SendDateTime(DateTime item) { + SendLong(item.Ticks); + } + + public void SendGuid(Guid guid) { + byte[] output = guid.ToByteArray(); + stream.Write(output, 0, output.Length); + } + + public void SendByte(byte item) { + writer.Write(item); + } + + #endregion + + #region Empfangsmethoden + + /// + /// Liest den nächsten ushort aus dem angegebenen Stream + /// + /// ausgelesener ushort + public ushort ReadUShort() { + return reader.ReadUInt16(); + } + + public short ReadShort() { + return reader.ReadInt16(); + } + + /// + /// Liest das nächste sbyte aus dem angegebenen Stream + /// + /// ausgelesener sbyte + public sbyte ReadSByte() { + return reader.ReadSByte(); + } + + /// + /// Liest einen Integer aus dem Stream + /// + /// gelesener int + public int ReadInt() { + return reader.ReadInt32(); + } + + public long ReadLong() { + return reader.ReadInt64(); + } + + /// + /// Liest einen String aus dem stream + /// + /// string + public string ReadString() { + return reader.ReadString(); + } + + /// + /// Liest einen DateTime aus dem Stream aus + /// + /// DateTime + public DateTime ReadDateTime() { + return new DateTime(ReadLong()); + } + + public Guid ReadGuid() { + byte[] input = new byte[16]; + stream.Read(input, 0, 16); + return new Guid(input); + } + + public byte ReadByte() { + return reader.ReadByte(); + } + + #endregion + + #region IDisposable Member + + public void Dispose() + { + ((IDisposable)writer).Dispose(); + ((IDisposable)reader).Dispose(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/Plugin/IConsumerPlugin.cs b/SharedComponents/Plugin/IConsumerPlugin.cs new file mode 100644 index 0000000..fc05f77 --- /dev/null +++ b/SharedComponents/Plugin/IConsumerPlugin.cs @@ -0,0 +1,34 @@ +using AntMe.SharedComponents.Plugin; +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.Plugin { + /// + /// Interface for all consuming plugins. + /// + /// Tom Wendel (tom@antme.net) + public interface IConsumerPlugin : IPlugin + { + /// + /// Allows a plugin to signal an interrupt. Only called by GameLoop-Thread. + /// + bool Interrupt { get; } + + /// + /// Sends the empty state to push some custom fields to control the simulation. Only called by GameLoop-Thread. + /// + /// empty state + void CreateState(ref SimulationState state); + + /// + /// Sends the filled state to push some custom fields to control the other consumers. Only called by GameLoop-Thread. + /// + /// filled state + void CreatingState(ref SimulationState state); + + /// + /// Sends the complete filled state to consume. Only called by GameLoop-Thread. + /// + /// complete state + void CreatedState(ref SimulationState state); + } +} \ No newline at end of file diff --git a/SharedComponents/Plugin/IPlugin.cs b/SharedComponents/Plugin/IPlugin.cs new file mode 100644 index 0000000..8421c7c --- /dev/null +++ b/SharedComponents/Plugin/IPlugin.cs @@ -0,0 +1,79 @@ +using System; +using System.Windows.Forms; + +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.Plugin { + /// + /// Base-Interface for all AntMe-Plugins. + /// + /// Tom Wendel (tom@antme.net) + public interface IPlugin { + /// + /// Plugin-Description. Only called by UI-Thread. + /// + string Description { get; } + + /// + /// Plugin-Guid. Only called by UI-Thread. + /// + Guid Guid { get; } + + /// + /// Plugin-Name. Only called by UI-Thread. + /// + string Name { get; } + + /// + /// Plugin-Version. Only called by UI-Thread. + /// + Version Version { get; } + + /// + /// Gets the current plugin-state. Called by UI- and GameLoop-Thread. + /// + PluginState State { get; } + + /// + /// Gets the plugin-user-control so show in main application or null, if there is no user-control. Only called by UI-Thread. + /// + Control Control { get; } + + /// + /// Gets or sets the settings for this plugin. usually a serialized configuration-class. Only called by UI-Thread. + /// + byte[] Settings { get; set; } + + /// + /// Starts the plugin-activity or resumes activity, if paused. Only called by UI-Thread. + /// + void Start(); + + /// + /// Stops the plugin-activity. Only called by UI-Thread. + /// + void Stop(); + + /// + /// Pauses the activity or starts and pauses, if stopped. Only called by UI-Thread. + /// + void Pause(); + + /// + /// Delivers the start-parameter from main application to this plugin. Only called by UI-Thread. + /// + /// start-parameter + void StartupParameter(string[] parameter); + + /// + /// Sets the state of visibility of plugins user-control. Only called by UI-Thread. + /// + /// is user-control visible in main window + void SetVisibility(bool visible); + + /// + /// Updates UI. Only called by UI-Thread. + /// + void UpdateUI(SimulationState state); + } +} \ No newline at end of file diff --git a/SharedComponents/Plugin/IProducerPlugin.cs b/SharedComponents/Plugin/IProducerPlugin.cs new file mode 100644 index 0000000..9bf3a2d --- /dev/null +++ b/SharedComponents/Plugin/IProducerPlugin.cs @@ -0,0 +1,17 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.SharedComponents.Plugin { + + /// + /// Interface for all producing plugins in antme. + /// + /// Tom Wendel (tom@antme.net) + public interface IProducerPlugin : IPlugin { + + /// + /// Sends the filled state from consumers to the producer to put in the . Only called by GameLoop-Thread. + /// + /// filled state + void CreateState(ref SimulationState state); + } +} \ No newline at end of file diff --git a/SharedComponents/Plugin/PluginState.cs b/SharedComponents/Plugin/PluginState.cs new file mode 100644 index 0000000..d9dbcd2 --- /dev/null +++ b/SharedComponents/Plugin/PluginState.cs @@ -0,0 +1,27 @@ +namespace AntMe.SharedComponents.Plugin { + /// + /// List of possible plugin-states. + /// + /// Tom Wendel (tom@antme.net) + public enum PluginState { + /// + /// Indicates a not startable state. + /// + NotReady, + + /// + /// Shows the ability to start. Also pause is a possible command. + /// + Ready, + + /// + /// Indicates a running plugin. Plugin can pause and stop. + /// + Running, + + /// + /// Plugin is suspended. It can resume again via start or stop complete. + /// + Paused + } +} \ No newline at end of file diff --git a/SharedComponents/Plugin/PreselectedAttribute.cs b/SharedComponents/Plugin/PreselectedAttribute.cs new file mode 100644 index 0000000..b978863 --- /dev/null +++ b/SharedComponents/Plugin/PreselectedAttribute.cs @@ -0,0 +1,12 @@ +using System; + +namespace AntMe.SharedComponents.Plugin { + /// + /// Attribute to mark a plugin as important that should be selected at the + /// first start of AntMe. This attribute only takes effect, if there is no + /// configuration-file from earlier starts. + /// + /// Tom Wendel (tom@antme.net) + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class PreselectedAttribute : Attribute {} +} \ No newline at end of file diff --git a/SharedComponents/Plugin/ReadCustomStateAttribute.cs b/SharedComponents/Plugin/ReadCustomStateAttribute.cs new file mode 100644 index 0000000..a7dc7c4 --- /dev/null +++ b/SharedComponents/Plugin/ReadCustomStateAttribute.cs @@ -0,0 +1,24 @@ +using System; + +namespace AntMe.SharedComponents.Plugin { + /// + /// Attribute, to signal, that the marked plugin reads the custom field. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + public sealed class ReadCustomStateAttribute : Attribute { + /// + /// The name of the custom field. + /// + public string Name = string.Empty; + + /// + /// The full name of the used type. + /// + public string Type = string.Empty; + + /// + /// Optional description of usage. + /// + public string Description = string.Empty; + } +} \ No newline at end of file diff --git a/SharedComponents/Plugin/WriteCustomStateAttribute.cs b/SharedComponents/Plugin/WriteCustomStateAttribute.cs new file mode 100644 index 0000000..49bb266 --- /dev/null +++ b/SharedComponents/Plugin/WriteCustomStateAttribute.cs @@ -0,0 +1,24 @@ +using System; + +namespace AntMe.SharedComponents.Plugin { + /// + /// Attribute, to signal, that the marked plugin writes the custom field. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + public sealed class WriteCustomStateAttribute : Attribute { + /// + /// The name of the custom field. + /// + public string Name = string.Empty; + + /// + /// The full name of the used type. + /// + public string Type = string.Empty; + + /// + /// Optional description of usage. + /// + public string Description = string.Empty; + } +} \ No newline at end of file diff --git a/SharedComponents/Properties/AssemblyInfo.cs b/SharedComponents/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..d3f85cd --- /dev/null +++ b/SharedComponents/Properties/AssemblyInfo.cs @@ -0,0 +1,43 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; +using System; + +// Allgemeine Informationen über eine Assembly werden über die folgenden +// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern, +// die mit einer Assembly verknüpft sind. +[assembly: AssemblyTitle("AntMe! Shared Components")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("AntMe! GmbH")] +[assembly: AssemblyProduct("AntMe!")] +[assembly: AssemblyCopyright("Copyright © 2014 AntMe! GmbH")] +[assembly: AssemblyTrademark("AntMe!")] +[assembly: AssemblyCulture("")] +[assembly: AllowPartiallyTrustedCallers] +[assembly: CLSCompliant(true)] +//[assembly: +// InternalsVisibleTo( +// "AntMe.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001000f5bb66b6a593b52d3188920c2ae2f9f539c2f2108e84ef10551fb28fba1db6c7faf83a93a29dde43588bed0832bcb1e1371f3830525b4a862dd4d6d59afc521509736af1e63c276743c4b6e74193a1fe47f03389ae0d3f6b16654b887ccd227b959f84d378ec4b94d399ec4cdfdfa56a8cb46835770e1ab69a77f1aadb2e9b3" +// )] + +// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar +// für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von +// COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest. +[assembly: ComVisible(false)] + +// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird +[assembly: Guid("7f33bf8c-1582-402f-a9a5-4f8bb00186ef")] + +// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +// +// Hauptversion +// Nebenversion +// Buildnummer +// Revision +// +// Sie können alle Werte angeben oder die standardmäßigen Revisions- und Buildnummern +// übernehmen, indem Sie "*" eingeben: +[assembly: AssemblyVersion("1.7.1.64")] +[assembly: AssemblyFileVersion("1.7.1.64")] \ No newline at end of file diff --git a/SharedComponents/Properties/Resources.Designer.cs b/SharedComponents/Properties/Resources.Designer.cs new file mode 100644 index 0000000..23688c1 --- /dev/null +++ b/SharedComponents/Properties/Resources.Designer.cs @@ -0,0 +1,153 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.SharedComponents.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("AntMe.SharedComponents.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; + } + } + + /// + /// Looks up a localized string similar to Abby + ///Abelina + ///Abigail + ///Adelaide + ///Adeline + ///Adina + ///Adriana + ///Adrienne + ///Afra + ///Agatha + ///Agnes + ///Aida + ///Aimee + ///Aischa + ///Ajlin + ///Albertine + ///Alea + ///Aleksandra + ///Alena + ///Alessa + ///Alessandra + ///Alessia + ///Alexa + ///Alexandra + ///Alexia + ///Alexis + ///Alice + ///Alicia + ///Alida + ///Alina + ///Aline + ///Alisa + ///Alissa + ///Alisson + ///Amabella + ///Amadea + ///Amanda + ///Amelia + ///Amelie + ///Amina + ///Amy + ///Ana + ///Anastasia + ///Andrea + ///Andrina + ///Anette + ///Angela + ///Angelika + ///Angelina + ///Angelique + ///Anina + ///Anine + ///Anita + ///Anja + ///Anjalie + ///Anke + ///Ann + ///Anna + ///Annabel + ///Annabell + ///Annabella + ///Annabelle + ///Anne + ///A [rest of string was truncated]";. + /// + internal static string FemaleNames { + get { + return ResourceManager.GetString("FemaleNames", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Christoph + ///Dominik + ///Hardy + ///Immo + ///Patric + ///Sebastian + ///Stefan + ///Tom + ///Uwe + ///Wolfgang. + /// + internal static string MaleNames { + get { + return ResourceManager.GetString("MaleNames", resourceCulture); + } + } + } +} diff --git a/SharedComponents/Properties/Resources.resx b/SharedComponents/Properties/Resources.resx new file mode 100644 index 0000000..1d97e66 --- /dev/null +++ b/SharedComponents/Properties/Resources.resx @@ -0,0 +1,127 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\Resources\FemaleNames.txt;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\MaleNames.txt;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + \ No newline at end of file diff --git a/SharedComponents/Properties/Settings.Designer.cs b/SharedComponents/Properties/Settings.Designer.cs new file mode 100644 index 0000000..a1f3fb8 --- /dev/null +++ b/SharedComponents/Properties/Settings.Designer.cs @@ -0,0 +1,98 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.SharedComponents.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "12.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.ApplicationScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Black")] + public global::System.Drawing.Color ColonyColor1 { + get { + return ((global::System.Drawing.Color)(this["ColonyColor1"])); + } + } + + [global::System.Configuration.ApplicationScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Red")] + public global::System.Drawing.Color ColonyColor2 { + get { + return ((global::System.Drawing.Color)(this["ColonyColor2"])); + } + } + + [global::System.Configuration.ApplicationScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Orange")] + public global::System.Drawing.Color ColonyColor3 { + get { + return ((global::System.Drawing.Color)(this["ColonyColor3"])); + } + } + + [global::System.Configuration.ApplicationScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Blue")] + public global::System.Drawing.Color ColonyColor4 { + get { + return ((global::System.Drawing.Color)(this["ColonyColor4"])); + } + } + + [global::System.Configuration.ApplicationScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Yellow")] + public global::System.Drawing.Color ColonyColor5 { + get { + return ((global::System.Drawing.Color)(this["ColonyColor5"])); + } + } + + [global::System.Configuration.ApplicationScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("White")] + public global::System.Drawing.Color ColonyColor6 { + get { + return ((global::System.Drawing.Color)(this["ColonyColor6"])); + } + } + + [global::System.Configuration.ApplicationScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Fuchsia")] + public global::System.Drawing.Color ColonyColor7 { + get { + return ((global::System.Drawing.Color)(this["ColonyColor7"])); + } + } + + [global::System.Configuration.ApplicationScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Lime")] + public global::System.Drawing.Color ColonyColor8 { + get { + return ((global::System.Drawing.Color)(this["ColonyColor8"])); + } + } + } +} diff --git a/SharedComponents/Properties/Settings.settings b/SharedComponents/Properties/Settings.settings new file mode 100644 index 0000000..71b1588 --- /dev/null +++ b/SharedComponents/Properties/Settings.settings @@ -0,0 +1,30 @@ + + + + + + Black + + + Red + + + Orange + + + Blue + + + Yellow + + + White + + + Fuchsia + + + Lime + + + \ No newline at end of file diff --git a/SharedComponents/Resource.Designer.cs b/SharedComponents/Resource.Designer.cs new file mode 100644 index 0000000..08b1c7f --- /dev/null +++ b/SharedComponents/Resource.Designer.cs @@ -0,0 +1,117 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.SharedComponents { + 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 Resource { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resource() { + } + + /// + /// 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("AntMe.SharedComponents.Resource", typeof(Resource).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; + } + } + + /// + /// Looks up a localized string similar to AntVI-Stream delivered an invalid start block. Expected: FrameStart. Received: {0}.. + /// + internal static string AntvideoReaderInvalidBlockType { + get { + return ResourceManager.GetString("AntvideoReaderInvalidBlockType", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The input stream could not be read.. + /// + internal static string AntvideoReaderNoReadAccessException { + get { + return ResourceManager.GetString("AntvideoReaderNoReadAccessException", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The input stream has not been set.. + /// + internal static string AntvideoReaderNoStreamException { + get { + return ResourceManager.GetString("AntvideoReaderNoStreamException", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to AntVI-Stream delivered an invalid element: {0}.. + /// + internal static string AntvideoSerializerInvalidBlockType { + get { + return ResourceManager.GetString("AntvideoSerializerInvalidBlockType", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The stream does not contain the AntVi-format.. + /// + internal static string AntvideoSerializerWrongHeader { + get { + return ResourceManager.GetString("AntvideoSerializerWrongHeader", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The stream contains an AntVI-version that could not be processed ({0}.{1}.{2}.{3}).. + /// + internal static string AntvideoSerializerWrongProtocolVersion { + get { + return ResourceManager.GetString("AntvideoSerializerWrongProtocolVersion", resourceCulture); + } + } + } +} diff --git a/SharedComponents/Resource.de.Designer.cs b/SharedComponents/Resource.de.Designer.cs new file mode 100644 index 0000000..e69de29 diff --git a/SharedComponents/Resource.de.resx b/SharedComponents/Resource.de.resx new file mode 100644 index 0000000..56cb79e --- /dev/null +++ b/SharedComponents/Resource.de.resx @@ -0,0 +1,144 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + AntVI-Stream liefert einen ungültigen Startblock. FrameStart erwartet, {0} empfangen. + If the reader receives a unexpected blocktype in stream + + + Der Eingangsstream kann nicht gelesen werden + If the given input-stream at constructor is not readable + + + Der Eingangsstream wurde nicht gesetzt + If the given input-stream at the constructor is null + + + AntVI-Stream liefert ein ungültiges Element: {0} + If the serializer reads a unexpected blocktype in stream + + + Der geöffnete Stream enthält kein AntVI-Format + If the serializer reads wrong stream-header-content + + + Der geöffnete Stream enthält eine nicht verarbeitbare AntVI-Version ({0}.{1}.{2}.{3}) + If the serializer reads wrong version number + + \ No newline at end of file diff --git a/SharedComponents/Resource.resx b/SharedComponents/Resource.resx new file mode 100644 index 0000000..e1aa9e5 --- /dev/null +++ b/SharedComponents/Resource.resx @@ -0,0 +1,144 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + AntVI-Stream delivered an invalid start block. Expected: FrameStart. Received: {0}. + If the reader receives a unexpected blocktype in stream + + + The input stream could not be read. + If the given input-stream at constructor is not readable + + + The input stream has not been set. + If the given input-stream at the constructor is null + + + AntVI-Stream delivered an invalid element: {0}. + If the serializer reads a unexpected blocktype in stream + + + The stream does not contain the AntVi-format. + If the serializer reads wrong stream-header-content + + + The stream contains an AntVI-version that could not be processed ({0}.{1}.{2}.{3}). + If the serializer reads wrong version number + + \ No newline at end of file diff --git a/SharedComponents/Resources/FemaleNames.txt b/SharedComponents/Resources/FemaleNames.txt new file mode 100644 index 0000000..61325a8 --- /dev/null +++ b/SharedComponents/Resources/FemaleNames.txt @@ -0,0 +1,1240 @@ +Abby +Abelina +Abigail +Adelaide +Adeline +Adina +Adriana +Adrienne +Afra +Agatha +Agnes +Aida +Aimee +Aischa +Ajlin +Albertine +Alea +Aleksandra +Alena +Alessa +Alessandra +Alessia +Alexa +Alexandra +Alexia +Alexis +Alice +Alicia +Alida +Alina +Aline +Alisa +Alissa +Alisson +Amabella +Amadea +Amanda +Amelia +Amelie +Amina +Amy +Ana +Anastasia +Andrea +Andrina +Anette +Angela +Angelika +Angelina +Angelique +Anina +Anine +Anita +Anja +Anjalie +Anke +Ann +Anna +Annabel +Annabell +Annabella +Annabelle +Anne +Annett +Annette +Annika +Annina +Antje +Antoinette +Antonella +Antonia +Arabella +Ariadne +Ariana +Ariane +Arianna +Ariella +Arielle +Arlene +Arlette +Arwenna +Ashley +Asta +Astrid +Audrey +Aurelia +Babette +Barbara +Bärbel +Bastiane +Bea +Beata +Beatrice +Beatrix +Becky +Belinda +Bella +Bellana +Belle +Benedikta +Benita +Bente +Beppina +Berenike +Berit +Bernadett +Bernadette +Bernadine +Betina +Betsy +Bettina +Betty +Bianca +Bianka +Bibiana +Bibiane +Birgit +Birgitt +Bodil +Bridget +Brigitta +Brigitte +Britta +Caillean +Caitlin +Cameron +Camilla +Camille +Cammy +Cara +Carin +Carina +Carinna +Carla +Carmela +Carmelia +Carmen +Carol +Carola +Carole +Carolin +Carolina +Caroline +Carolyn +Carolyne +Cassandra +Cassie +Catalin +Caterina +Catharina +Catherine +Cathrin +Cathrine +Cathy +Catina +Catrin +Catriona +Cecile +Cecilia +Cecilie +Celeste +Celestine +Celina +Celine +Chantal +Charleen +Charlotte +Chatrina +Chelsea +Chiara +Chloe +Chrissy +Christa +Christiana +Christiane +Christin +Christina +Christine +Chyna +Ciara +Cinderella +Cindy +Cinja +Cira +Claire +Clara +Clarissa +Claudette +Claudia +Claudine +Clea +Cleannis +Clementia +Clementine +Cleo +Clio +Cliona +Clodia +Cloris +Coletta +Colette +Connie +Conny +Constance +Constanze +Cora +Coral +Coralie +Cordelia +Cordula +Corin +Corina +Corinna +Corinne +Cornelia +Cosette +Cosima +Cynthia +Dagmar +Daisy +Dajana +Daliah +Damaris +Damia +Damiana +Dana +Dania +Danica +Daniela +Daniele +Daniella +Danielle +Danja +Daphne +Darcie +Daria +Darina +Dawn +Dayna +Debbie +Debby +Debora +Deborah +Deetya +Delia +Delphine +Dena +Denise +Desdemona +Desideria +Desiree +Diana +Diane +Didina +Dina +Dinah +Dolly +Dolores +Domenica +Dominika +Dominique +Donna +Dora +Doreen +Dorina +Doris +Dorit +Doro +Dorothea +Dorothee +Dorothy +Dunja +Ebony +Edda +Edina +Edita +Edvige +Edwina +Eike +Eila +Eileen +Ela +Elaine +Eleanor +Elektra +Elena +Eleonora +Eleonore +Eliane +Elisa +Elisabeth +Elise +Elizabeth +Elke +Ella +Ellen +Elly +Eloise +Elsa +Elsbeth +Elvira +Elvire +Emanuela +Emanuelle +Emilia +Emilie +Emily +Emma +Enisa +Enrica +Enya +Erika +Erin +Ernesta +Ernestina +Ernestine +Esmerelda +Esra +Estella +Estelle +Ester +Esther +Etiennette +Eudoxia +Eugenia +Eunike +Euphemia +Euphrasia +Eusebia +Eva +Evangelina +Evania +Eve +Evelien +Evelin +Eveline +Evelyn +Evelyne +Evette +Evi +Evita +Fabia +Fabiane +Fabienne +Fabiola +Faith +Fanny +Farrah +Fatima +Faustina +Faustine +Fay +Faye +Faylinn +Federica +Fedora +Fee +Feli +Felice +Felicia +Felicitas +Felicity +Felizitas +Feodora +Fergie +Fidelia +Filia +Filiz +Finetta +Finja +Fiona +Fjodora +Flavia +Fleur +Fleur +Flo +Flora +Florence +Florentina +Florentine +Floria +Floriane +Florida +Florinda +Floris +Fortuna +Frances +Francesca +Francisca +Françoise +Franka +Franzi +Franziska +Frauke +Freya +Friederike +Gabi +Gabriela +Gabriele +Gabriella +Gabrielle +Gaby +Gail +Galatea +Galina +Gazelle +Gela +Geneva +Genoveva +Georgette +Georgia +Georgina +Geraldene +Geraldine +Germain +Germaine +Germana +Ghita +Gianna +Gigi +Gill +Gillian +Gina +Ginevra +Ginger +Ginny +Giovanna +Gisela +Gisele +Gisella +Giselle +Gitta +Giulia +Giuliana +Giulietta +Giuseppa +Giuseppina +Giustina +Gladys +Gloria +Glory +Goldie +Goldy +Grace +Gratia +Gratiana +Grazia +Greta +Gretel +Gunda +Gwen +Gwenda +Gwendolin +Gwendolyn +Gypsy +Hanna +Hannah +Hanne +Harmony +Harriet +Hazel +Hedi +Hedy +Heide +Heidi +Heike +Helen +Helena +Helene +Helin +Hella +Hemma +Henrietta +Henriette +Henrike +Hera +Hetty +Hilary +Hilda +Hilde +Holiday +Holli +Holly +Hope +Ida +Ilana +Ilaria +Iliana +Iljana +Ilka +Ilona +Ilse +Ilyssa +Imke +Ina +India +Indira +Indra +Ines +Inga +Inge +Ingrid +Inka +Inken +Innozentia +Iona +Ira +Irena +Irene +Irina +Iris +Irisa +Irma +Isabel +Isabell +Isabella +Isabelle +Isis +Iva +Ivana +Ivona +Ivonne +Jackie +Jaclyn +Jacqueline +Jacqui +Jael +Jamari +Jan +Jana +Jane +Janet +Janette +Janin +Janina +Janine +Janique +Janna +Jannine +Jarla +Jasmin +Jasmina +Jasmine +Jeanette +Jeanine +Jeanne +Jeannette +Jeannine +Jekaterina +Jelena +Jenifer +Jenna +Jennelle +Jennessa +Jennie +Jennifer +Jenny +Jennyfer +Jess +Jessica +Jessie +Jessika +Jill +Joan +Joana +Joann +Joanna +Joelle +Johanna +Jolanda +Jona +Jordana +Jördis +Josee +Josefa +Josefina +Josefine +Josepha +Josephine +Josiane +Josie +Jovita +Joy +Joyce +Juana +Juanita +Judith +Judy +Julia +Juliana +Juliane +Julianne +Julie +Juliet +Juliette +July +June +Justina +Justine +Justise +Jutta +Kaja +Kamilia +Kamilla +Karen +Karima +Karin +Karina +Karla +Karola +Karolin +Karolina +Karoline +Kassandra +Katalin +Katarina +Kate +Katharina +Katharine +Käthe +Katherina +Katherine +Kathleen +Kathrin +Kathrina +Kathryn +Kathy +Katinka +Katja +Katjana +Katrin +Katrina +Katrine +Kayla +Keala +Keelin +Kendra +Kerstin +Kiana +Kiara +Kim +Kira +Kirsten +Kirstin +Kita +Klara +Klarissa +Klaudia +Kleopatra +Kolina +Konstanze +Kora +Kordula +Kori +Kornelia +Krista +Kristiane +Kristin +Kristina +Kristine +Kyra +Laetitia +Laila +Lana +Lara +Laria +Larissa +Lätizia +Laurel +Lauren +Laurence +Laurentia +Lauretta +Lavina +Laya +Lea +Leah +Leandra +Lee +Leigh +Leila +Lena +Leona +Leonie +Leontine +Leopoldine +Lesley +Leslie +Levana +Levia +Lia +Liane +Libusa +Licia +Lidia +Liesa +Liesbeth +Liese +Liesel +Lilian +Liliane +Lilith +Lilli +Lillian +Lilo +Lily +Lina +Linda +Lioba +Lisa +Lisbeth +Lise +Lisette +Liv +Livana +Livia +Liz +Liza +Lizzie +Lola +Lora +Lorena +Loretta +Lori +Lorraine +Lotte +Lotus +Louise +Luana +Luca +Lucia +Luciana +Lucie +Lucy +Luigia +Luisa +Luise +Luna +Luzia +Lydia +Lydie +Lynette +Lynn +Mabel +Maddalena +Madelaine +Madeleine +Madeline +Madison +Madita +Madleine +Madlen +Madlene +Mae +Magda +Magdalena +Maggy +Magret +Maia +Maike +Maiken +Mailin +Maja +Malea +Malee +Malin +Malina +Mandy +Manja +Manon +Manuela +Mara +Maraike +Marcella +Marcelle +Marcia +Mareike +Maren +Margaret +Margareta +Margarete +Margaretha +Margarita +Margaritha +Margherita +Margit +Margitta +Margot +Margret +Margreth +Marguerite +Maria +Mariam +Marian +Mariana +Marianna +Marianne +Marie +Marieke +Mariella +Marielle +Marietta +Marija +Marika +Marilies +Marilyn +Marina +Marion +Marisa +Marissa +Marita +Maritta +Marjorie +Marla +Marleen +Marlen +Marlena +Marlene +Marlies +Marlis +Marsha +Martha +Marthe +Martina +Mary +Maryse +Mascha +Mathilda +Mathilde +Matilde +Mattea +Maude +Maura +Maureen +Maximiliane +May +Maya +Meg +Megan +Meike +Melanie +Melia +Melina +Melinda +Melissa +Melitta +Melodie +Meloney +Mercedes +Meret +Meri +Merle +Merline +Meryem +Mia +Micaela +Michaela +Michele +Michelle +Milena +Milla +Milva +Mimi +Minerva +Minna +Mira +Mirabella +Mireille +Mirella +Mireya +Miriam +Mirijam +Mirjam +Moesha +Moira +Mona +Moni +Monica +Monika +Monique +Monja +Morgane +Muriel +Myriam +Nadia +Nadin +Nadine +Nadja +Nadjana +Naemi +Nancy +Nanette +Nani +Naomi +Nastasja +Natalia +Natalie +Natanja +Natascha +Nathalie +Neeja +Nena +Neria +Nerine +Nicol +Nicola +Nicole +Nicoletta +Nicolette +Nike +Nikola +Nina +Ninja +Ninon +Noa +Noelle +Noemi +Noemie +Nora +Norma +Nuala +Oceana +Olga +Olivia +Ophelia +Orania +Orla +Ornella +Orsola +Ottilie +Palmira +Paloma +Pam +Pamela +Pandora +Paola +Paolina +Pascale +Pat +Patrice +Patricia +Patrizia +Patsy +Patty +Paula +Paulette +Paulina +Pauline +Penelope +Pepita +Petra +Philine +Philippa +Philomele +Philomena +Phoebe +Phyllis +Pia +Pier +Prica +Prisca +Priscilla +Priscille +Priska +Quendoline +Rabea +Rachel +Rachel +Rachelle +Radomila +Rafaela +Raffaela +Raffaella +Ragna +Rahel +Raja +Ramona +Raphaela +Raquel +Rebecca +Rebekka +Regina +Regine +Reisha +Renata +Renate +Renee +Resi +Rhea +Rhoda +Rhonda +Ricarda +Riccarda +Rike +Rita +Roberta +Romana +Romina +Romy +Ronja +Rosa +Rosalia +Rosalie +Rosalinda +Rosalinde +Rosaline +Rose +Roseline +Rosetta +Rosette +Rosi +Rosina +Rosine +Rossana +Roswitha +Roxana +Roxane +Roxanne +Roxy +Rubina +Ruth +Sabina +Sabine +Sabrina +Sahra +Sally +Salome +Salvina +Samanta +Samantha +Samira +Sandra +Sandrina +Sandrine +Sandy +Sanne +Sanya +Saphira +Sara +Sarah +Sarina +Sascha +Saskia +Scarlet +Scarlett +Schirin +Selina +Selma +Serafina +Seraina +Seraphin +Seraphina +Seraphine +Serena +Severina +Severine +Shana +Shanaya +Shantala +Shari +Sharlene +Sharon +Sheena +Sheila +Sheryl +Shirin +Shirley +Shirlyn +Sibilla +Sibyl +Sibylle +Siegrid +Sigrid +Sigrun +Silja +Silke +Silvana +Silvia +Silviane +Simona +Simone +Simonette +Simonne +Sina +Sindy +Sinja +Sissy +Skyla +Smarula +Smilla +Sofia +Sofie +Sonia +Sonja +Sonnele +Sonya +Sophia +Sophie +Soraya +Stefanie +Steffi +Stella +Stephanie +Stina +Sumehra +Summer +Susan +Susanna +Susanne +Susi +Suzan +Suzanne +Suzette +Svea +Svenja +Swane +Sybilla +Sybille +Sydney +Sylvana +Sylvia +Sylvie +Tabea +Tabitha +Taissa +Tamara +Tamina +Tania +Tanita +Tanja +Tara +Tatiana +Tatjana +Taya +Tecla +Telka +Teodora +Teona +Teresa +Terry +Tess +Tessa +Tessie +Thea +Thekla +Theodora +Theres +Theresa +Therese +Theresia +Tiana +Tiffany +Tilly +Timna +Tina +Tiziana +Tonja +Toril +Tosca +Tracey +Traudl +Trixi +Tycho +Tyra +Ulita +Ulla +Ulli +Ulrica +Ulrike +Undine +Urania +Ursel +Ursina +Ursula +Ursule +Uschi +Uta +Ute +Val +Valentina +Valentine +Valeria +Valerie +Valeska +Vanadis +Vanessa +Vanja +Varinka +Venetia +Vera +Verena +Verona +Veronica +Veronika +Veronique +Vesla +Vicky +Victoire +Victoria +Viki +Viktoria +Vilja +Viola +Violet +Violetta +Violette +Virginia +Virginie +Vittoria +Viviana +Viviane +Vivien +Vivienne +Vreneli +Vreni +Vroni +Walli +Wencke +Weneke +Wibke +Wilja +Willow +Wilma +Xaveria +Xenia +Yahsarah +Yasemin +Yasmin +Yasmine +Yola +Yolanda +Yvette +Yvonne +Zaida +Zarah +Zenia +Zenobia +Zita +Zoe +Zora \ No newline at end of file diff --git a/SharedComponents/Resources/MaleNames.txt b/SharedComponents/Resources/MaleNames.txt new file mode 100644 index 0000000..3948762 --- /dev/null +++ b/SharedComponents/Resources/MaleNames.txt @@ -0,0 +1,10 @@ +Christoph +Dominik +Hardy +Immo +Patric +Sebastian +Stefan +Tom +Uwe +Wolfgang \ No newline at end of file diff --git a/SharedComponents/SharedComponents.csproj b/SharedComponents/SharedComponents.csproj new file mode 100644 index 0000000..27e5ae8 --- /dev/null +++ b/SharedComponents/SharedComponents.csproj @@ -0,0 +1,218 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {415F50C3-BD70-4634-B1F7-A15B42F0B0C6} + Library + Properties + AntMe.SharedComponents + AntMe.SharedComponents + true + x86 + AntMe.snk + SAK + SAK + SAK + SAK + + + + + 3.5 + false + v4.0 + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + true + + + + true + ..\bin\ + DEBUG;TRACE + ..\bin\AntMe.SharedComponents.XML + full + x86 + + + true + GlobalSuppressions.cs + prompt + Migrated rules for SharedComponents.ruleset + true + + + ..\bin\ + TRACE + true + pdbonly + x86 + + + true + GlobalSuppressions.cs + prompt + ..\bin\AntMe.SharedComponents.XML + Migrated rules for SharedComponents.ruleset + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + True + True + Resources.resx + + + True + True + Resource.de.resx + + + True + True + Resource.resx + + + True + True + Settings.settings + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + Designer + ResXFileCodeGenerator + Resource.de.Designer.cs + + + ResXFileCodeGenerator + Resource.Designer.cs + Designer + + + + + + + + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + + + \ No newline at end of file diff --git a/SharedComponents/States/AntState.cs b/SharedComponents/States/AntState.cs new file mode 100644 index 0000000..f4ede39 --- /dev/null +++ b/SharedComponents/States/AntState.cs @@ -0,0 +1,92 @@ +using System; + +namespace AntMe.SharedComponents.States +{ + /// + /// Holds information about an ant. + /// + [Serializable] + public class AntState : ColonyBasedState + { + + #region Constructor + + /// + /// Constructor of ant-state + /// + /// Colony-id + /// id + public AntState(int colonyId, int id) + : base(colonyId, id) + { + LoadType = LoadType.None; + TargetType = TargetType.None; + } + + #endregion + + #region Properties + + /// + /// Gets or sets the id of the caste. + /// + public int CasteId { get; set; } + + /// + /// Gets or sets the direction. + /// + public int Direction { get; set; } + + /// + /// Gets or sets the load. + /// + public int Load { get; set; } + + /// + /// Gets or sets the type of load. + /// + public LoadType LoadType { get; set; } + + /// + /// Gets or sets the x-part of position. + /// + public int PositionX { get; set; } + + /// + /// Gets or sets the kind of target. + /// + public TargetType TargetType { get; set; } + + /// + /// Gets or sets the x-part of the target position. + /// + public int TargetPositionX { get; set; } + + /// + /// Gets or sets the y-part of the target position. + /// + public int TargetPositionY { get; set; } + + /// + /// Gets or sets the y-part of position. + /// + public int PositionY { get; set; } + + /// + /// Gets or sets the vitality. + /// + public int Vitality { get; set; } + + /// + /// View Range + /// + public int ViewRange { get; set; } + + /// + /// Debug Message + /// + public string DebugMessage { get; set; } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/States/AnthillState.cs b/SharedComponents/States/AnthillState.cs new file mode 100644 index 0000000..90b6ffb --- /dev/null +++ b/SharedComponents/States/AnthillState.cs @@ -0,0 +1,42 @@ +using System; + +namespace AntMe.SharedComponents.States +{ + /// + /// Holds information about an anthill. + /// + [Serializable] + public class AnthillState : ColonyBasedState + { + + #region Constructor + + /// + /// Constructor of anthill-state + /// + /// Colony-id + /// id + public AnthillState(int colonyId, int id) : base(colonyId, id) { } + + #endregion + + #region Properties + + /// + /// Gets or sets the x-part of position. + /// + public int PositionX { get; set; } + + /// + /// Gets or sets the y-part of position. + /// + public int PositionY { get; set; } + + /// + /// Gets or sets the radius. + /// + public int Radius { get; set; } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/States/BugState.cs b/SharedComponents/States/BugState.cs new file mode 100644 index 0000000..415183b --- /dev/null +++ b/SharedComponents/States/BugState.cs @@ -0,0 +1,36 @@ +using System; + +namespace AntMe.SharedComponents.States { + /// + /// Holds information about bugs. + /// + [Serializable] + public class BugState : IndexBasedState { + + /// + /// Constructor of bugstate. + /// + /// id + public BugState(int id) : base(id) {} + + /// + /// Gets or sets the x-part of the position. + /// + public int PositionX {get;set;} + + /// + /// Gets or sets the y-part of the position. + /// + public int PositionY { get; set; } + + /// + /// Gets or sets the direction. + /// + public int Direction { get; set; } + + /// + /// Gets or sets the vitality. + /// + public int Vitality { get; set; } + } +} \ No newline at end of file diff --git a/SharedComponents/States/CasteState.cs b/SharedComponents/States/CasteState.cs new file mode 100644 index 0000000..8ab7193 --- /dev/null +++ b/SharedComponents/States/CasteState.cs @@ -0,0 +1,63 @@ +using System; + +namespace AntMe.SharedComponents.States +{ + /// + /// Holds information about ant-castes + /// + [Serializable] + public class CasteState : ColonyBasedState + { + + /// + /// Constructor of caste-state + /// + /// Id of colony + /// Id of caste + public CasteState(int colonyId, int id) : base(colonyId, id) { } + + #region Properties + + /// + /// Gets or sets the attack-modificator. + /// + public byte AttackModificator { get; set; } + + /// + /// Gets or sets the load-modificator. + /// + public byte LoadModificator { get; set; } + + /// + /// Gets or sets the name of this caste. + /// + public string Name { get; set; } + + /// + /// Gets or sets the range-modificator. + /// + public byte RangeModificator { get; set; } + + /// + /// Gets or sets the rotation-speed-modificator. + /// + public byte RotationSpeedModificator { get; set; } + + /// + /// Gets or sets the speed-modificator. + /// + public byte SpeedModificator { get; set; } + + /// + /// Gets or sets the view-range-modificator. + /// + public byte ViewRangeModificator { get; set; } + + /// + /// Gets or sets the vitality-modificator. + /// + public byte VitalityModificator { get; set; } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/States/ColonyBasedState.cs b/SharedComponents/States/ColonyBasedState.cs new file mode 100644 index 0000000..cf75ac7 --- /dev/null +++ b/SharedComponents/States/ColonyBasedState.cs @@ -0,0 +1,27 @@ +using System; +namespace AntMe.SharedComponents.States +{ + /// + /// Base-class for all colony-based and index-based states. + /// + [Serializable] + public abstract class ColonyBasedState : IndexBasedState + { + + /// + /// Constructor of this state. + /// + /// colony-id + /// id + public ColonyBasedState(int colonyId, int id) + : base(id) + { + ColonyId = colonyId; + } + + /// + /// Gets the colony-id of this state. + /// + public int ColonyId { get; set; } + } +} \ No newline at end of file diff --git a/SharedComponents/States/ColonyState.cs b/SharedComponents/States/ColonyState.cs new file mode 100644 index 0000000..182d26f --- /dev/null +++ b/SharedComponents/States/ColonyState.cs @@ -0,0 +1,119 @@ +using System; +using System.Collections.ObjectModel; + +namespace AntMe.SharedComponents.States +{ + /// + /// Holds the information of one colony in a simulation-state. + /// + [Serializable] + public class ColonyState : IndexBasedState + { + /// + /// Constructor of colony-state + /// + /// id + public ColonyState(int id) + : base(id) + { + AntStates = new Collection(); + AnthillStates = new Collection(); + MarkerStates = new Collection(); + CasteStates = new Collection(); + } + + /// + /// Constructor of colony-state + /// + /// id of this colony + /// guid + /// Name of this colony + /// Name of player + public ColonyState(int id, Guid guid, string colonyName, string playerName) + : this(id) + { + Guid = guid; + ColonyName = colonyName; + PlayerName = playerName; + } + + #region Properties + + /// + /// Gets a list of ants. + /// + public Collection AntStates { get; set; } + + /// + /// Gets a list of anthills. + /// + public Collection AnthillStates { get; set; } + + /// + /// Gets a list of markers. + /// + public Collection MarkerStates { get; set; } + + /// + /// gets a list of castes. + /// + public Collection CasteStates { get; set; } + + /// + /// Gets or sets the guid of the colony. + /// + public Guid Guid { get; set; } + + /// + /// Gets or sets the name of this colony. + /// + public string ColonyName { get; set; } + + /// + /// Gets or sets the name of the player. + /// + public string PlayerName { get; set; } + + /// + /// Gets or sets the count of starved ants. + /// + public int StarvedAnts { get; set; } + + /// + /// Gets or sets the count of eaten ants. + /// + public int EatenAnts { get; set; } + + /// + /// Gets or sets the count of beaten ants. + /// + public int BeatenAnts { get; set; } + + /// + /// Gets or sets the count of killed bugs. + /// + public int KilledBugs { get; set; } + + /// + /// Gets or sets the count of killed enemies. + /// + public int KilledEnemies { get; set; } + + /// + /// Gets or sets the amount of collected food. + /// + public int CollectedFood { get; set; } + + /// + /// Gets or sets the amount of collected fruits. + /// + public int CollectedFruits { get; set; } + + /// + /// Gets or sets the total points. + /// + public int Points { get; set; } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/States/CustomState.cs b/SharedComponents/States/CustomState.cs new file mode 100644 index 0000000..f9495ad --- /dev/null +++ b/SharedComponents/States/CustomState.cs @@ -0,0 +1,109 @@ +using System; +using System.Collections.Generic; + +namespace AntMe.SharedComponents.States { + /// + /// Holds custom Plugin-Information + /// + [Serializable] + public sealed class CustomState { + private readonly List keys = new List(); + private readonly List values = new List(); + + /// + /// Gets a value indicating whether this instance has value. + /// + /// true if this instance has value; otherwise, false. + public bool HasValue { + get { return keys != null && keys.Count > 0; } + } + + /// + /// Adds the specified key. + /// + /// The key. + /// The value. + public void Add(string key, object value) { + if (key == null) { + throw new ArgumentNullException("key"); + } + if (value == null) { + throw new ArgumentNullException("value"); + } + + if (keys.Contains(key)) { + int index = keys.IndexOf(key); + values[index] = value; + } + else { + keys.Add(key); + values.Add(value); + } + keys.TrimExcess(); + values.TrimExcess(); + } + + /// + /// Removes the specified key. + /// + /// The key. + /// + public bool Remove(string key) { + if (key == null) { + return false; + } + + int index = keys.IndexOf(key); + if (index == -1) { + return false; + } + keys.Remove(key); + values.RemoveAt(index); + keys.TrimExcess(); + values.TrimExcess(); + return true; + } + + /// + /// Removes the specified value. + /// + /// The value. + /// + public bool Remove(object value) { + if (value == null) { + return false; + } + int index = values.IndexOf(value); + if (index == -1) { + return false; + } + values.Remove(value); + keys.RemoveAt(index); + values.TrimExcess(); + keys.TrimExcess(); + return true; + } + + /// + /// Gets or sets the with the specified key. + /// + /// + public object this[string key] { + get { + if (!keys.Contains(key)) { + return null; + } + int index = keys.IndexOf(key); + return values[index]; + } + set { Add(key, value); } + } + + /// + /// Gets a list of available keys. + /// + public string[] Keys { + get { return keys.ToArray(); } + } + } +} \ No newline at end of file diff --git a/SharedComponents/States/FruitState.cs b/SharedComponents/States/FruitState.cs new file mode 100644 index 0000000..7077208 --- /dev/null +++ b/SharedComponents/States/FruitState.cs @@ -0,0 +1,43 @@ +using System; + +namespace AntMe.SharedComponents.States +{ + /// + /// Holds information about fruit. + /// + [Serializable] + public class FruitState : IndexBasedState + { + + /// + /// Constructor of fruit-state. + /// + /// id + public FruitState(int id) : base(id) { } + + /// + /// Gets or sets the amount of fruit. + /// + public int Amount { get; set; } + + /// + /// Gets or sets the x-part of the position. + /// + public int PositionX { get; set; } + + /// + /// Gets or sets the y-part of the position. + /// + public int PositionY { get; set; } + + /// + /// Gets or sets the radius. + /// + public int Radius { get; set; } + + /// + /// Gets or sets the number of carrying ants. + /// + public byte CarryingAnts { get; set; } + } +} \ No newline at end of file diff --git a/SharedComponents/States/IndexBasedState.cs b/SharedComponents/States/IndexBasedState.cs new file mode 100644 index 0000000..b68773d --- /dev/null +++ b/SharedComponents/States/IndexBasedState.cs @@ -0,0 +1,36 @@ +using System; +namespace AntMe.SharedComponents.States { + /// + /// Base-class for all index-based states + /// + [Serializable] + public abstract class IndexBasedState : IComparable { + + /// + /// Constructor of this state. + /// + /// + public IndexBasedState(int id) { + Id = id; + } + + /// + /// Gets the id of this state. + /// + public int Id { get; set; } + + #region IComparable Member + + /// + /// Compares two IndexBasedStates + /// + /// other state + /// compare-result + public int CompareTo(IndexBasedState other) + { + return Id.CompareTo(other.Id); + } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/States/LoadType.cs b/SharedComponents/States/LoadType.cs new file mode 100644 index 0000000..9e03869 --- /dev/null +++ b/SharedComponents/States/LoadType.cs @@ -0,0 +1,23 @@ +using System; +namespace AntMe.SharedComponents.States { + /// + /// List of possible loads. + /// + [Serializable] + public enum LoadType { + /// + /// No load + /// + None = 0, + + /// + /// Sugar + /// + Sugar = 1, + + /// + /// Fruit + /// + Fruit = 2 + } +} \ No newline at end of file diff --git a/SharedComponents/States/MarkerState.cs b/SharedComponents/States/MarkerState.cs new file mode 100644 index 0000000..80446ca --- /dev/null +++ b/SharedComponents/States/MarkerState.cs @@ -0,0 +1,43 @@ +using System; + +namespace AntMe.SharedComponents.States +{ + /// + /// Holds information about a marker. + /// + [Serializable] + public class MarkerState : ColonyBasedState + { + + /// + /// Constructor of marker-state. + /// + /// Colony-id + /// id + public MarkerState(int colonyId, int id) : base(colonyId, id) { } + + #region Properties + + /// + /// Gets or sets the x-part of the position. + /// + public int PositionX { get; set; } + + /// + /// Gets or sets the y-part of the position. + /// + public int PositionY { get; set; } + + /// + /// Gets or sets the radius. + /// + public int Radius { get; set; } + + /// + /// Gets or sets the direction. + /// + public int Direction { get; set; } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/States/SimulationState.cs b/SharedComponents/States/SimulationState.cs new file mode 100644 index 0000000..6d97763 --- /dev/null +++ b/SharedComponents/States/SimulationState.cs @@ -0,0 +1,126 @@ +using System; +using System.Collections.ObjectModel; + +namespace AntMe.SharedComponents.States +{ + /// + /// Holds the information of one single simulation-step + /// + [Serializable] + public class SimulationState + { + + #region Konstruction + + /// + /// Constructor to initialize the lists. + /// + public SimulationState() + { + TimeStamp = DateTime.Now; + BugStates = new Collection(); + FruitStates = new Collection(); + TeamStates = new Collection(); + SugarStates = new Collection(); + CustomFields = new CustomState(); + } + + /// + /// Constructor to initialize the lists and set the basic parameters. + /// + /// width of the playground + /// height of the playground + /// the current round + /// the number of total rounds + public SimulationState(int width, int height, int round, int rounds) : + this() + { + PlaygroundWidth = width; + PlaygroundHeight = height; + CurrentRound = round; + TotalRounds = rounds; + } + + /// + /// Constructor to initialize the lists and set the basic parameters. + /// + /// width of the playground + /// height of the playground + /// the current round + /// the number of total rounds + /// the time-stamp of this simulation-state + public SimulationState(int width, int height, int round, int rounds, DateTime time) : + this(width, height, round, rounds) + { + TimeStamp = time; + } + + #endregion + + #region Properties + + /// + /// Gets a list of bugs. + /// + public Collection BugStates { get; set; } + + /// + /// Gets a list of fruits. + /// + public Collection FruitStates { get; set; } + + public Collection ColonyStates + { + get + { + Collection colonies = new Collection(); + foreach (TeamState team in TeamStates) + foreach (ColonyState colony in team.ColonyStates) + colonies.Add(colony); + return colonies; + } + } + + /// + /// Gets a list of teams. + /// + public Collection TeamStates { get; set; } + + /// + /// Gets a list of sugar. + /// + public Collection SugarStates { get; set; } + + /// + /// Gets the list of custom fields. + /// + public CustomState CustomFields { get; set; } + + /// + /// Gets or sets the time-stamp of this simulation-state. + /// + public DateTime TimeStamp { get; set; } + + /// + /// Gets or sets the number of total rounds. + /// + public int TotalRounds { get; set; } + + /// + /// Gets or sets the number of current round. + /// + public int CurrentRound { get; set; } + + /// + /// Gets or sets the width of the playground. + /// + public int PlaygroundWidth { get; set; } + + /// + /// Gets or sets the height of the playground. + /// + public int PlaygroundHeight { get; set; } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/States/SugarState.cs b/SharedComponents/States/SugarState.cs new file mode 100644 index 0000000..81c6a23 --- /dev/null +++ b/SharedComponents/States/SugarState.cs @@ -0,0 +1,41 @@ +using System; + +namespace AntMe.SharedComponents.States +{ + /// + /// Holds information about sugar. + /// + [Serializable] + public class SugarState : IndexBasedState + { + /// + /// Constructor of sugar-state + /// + /// id + public SugarState(int id) : base(id) { } + + #region Properties + + /// + /// Gets or sets the load of sugar. + /// + public int Amount { get; set; } + + /// + /// Gets or sets the x-part of the position. + /// + public int PositionX { get; set; } + + /// + /// Gets or sets the y-part of the position. + /// + public int PositionY { get; set; } + + /// + /// Gets or sets the radius. + /// + public int Radius { get; set; } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/States/TargetType.cs b/SharedComponents/States/TargetType.cs new file mode 100644 index 0000000..28bd882 --- /dev/null +++ b/SharedComponents/States/TargetType.cs @@ -0,0 +1,43 @@ +using System; +namespace AntMe.SharedComponents.States { + /// + /// List of possible targets for an ant. + /// + [Serializable] + public enum TargetType { + /// + /// There is no target. + /// + None, + + /// + /// Target is an ant. + /// + Ant, + + /// + /// Target is an anthill. + /// + Anthill, + + /// + /// Target are bugs. + /// + Bug, + + /// + /// Target is fruit. + /// + Fruit, + + /// + /// Target is a marker. + /// + Marker, + + /// + /// Target is sugar. + /// + Sugar + } +} \ No newline at end of file diff --git a/SharedComponents/States/TeamState.cs b/SharedComponents/States/TeamState.cs new file mode 100644 index 0000000..cfb0d6e --- /dev/null +++ b/SharedComponents/States/TeamState.cs @@ -0,0 +1,54 @@ +using System; +using System.Collections.ObjectModel; + +namespace AntMe.SharedComponents.States +{ + /// + /// Holds the information of a team of multiple colonies. + /// + [Serializable] + public class TeamState : IndexBasedState + { + /// + /// Constructor of team-state + /// + /// id + public TeamState(int id) + : base(id) + { + ColonyStates = new Collection(); + } + + /// + /// Constructor of team-state + /// + /// id of this team + /// guid + /// Name of this team + public TeamState(int id, Guid guid, string name) + : this(id) + { + Guid = guid; + Name = name; + } + + #region Properties + + /// + /// gets a list of castes. + /// + public Collection ColonyStates { get; set; } + + /// + /// Gets or sets the guid of the team. + /// + public Guid Guid { get; set; } + + /// + /// Gets or sets the name of the team. + /// + public string Name { get; set; } + + #endregion + } +} \ No newline at end of file diff --git a/SharedComponents/Tools/ColorFinder.cs b/SharedComponents/Tools/ColorFinder.cs new file mode 100644 index 0000000..f8040d5 --- /dev/null +++ b/SharedComponents/Tools/ColorFinder.cs @@ -0,0 +1,265 @@ +using System; +using System.Collections.Generic; +using System.Drawing; + +using AntMe.SharedComponents.Properties; + +namespace AntMe.SharedComponents.Tools { + /// + /// Stellt eine Farbe im RGB-Farbraum dar. + /// + /// + /// Diese Struktur wurde definiert um von den in Windows Forms und Managed + /// DirectX definierten Farben unabhängig zu sein. Zusätzlich können Farben + /// durch die Verwendung dieser Struktur gemischt werden. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + public struct Farbe { + private int blau; + private int grün; + private int rot; + + /// + /// Der Farbe Konstruktor. + /// + /// Rot-Wert + /// Grün-Wert + /// Blau-Wert + public Farbe(int rot, int grün, int blau) { + this.rot = rot; + this.grün = grün; + this.blau = blau; + } + + /// + /// Der Rot-Wert der Farbe. + /// + public byte Rot { + get { return rot < 0 ? (byte) 0 : rot > 255 ? (byte) 255 : (byte) rot; } + set { rot = value; } + } + + /// + /// Der Grün-Wert der Farbe. + /// + public byte Grün { + get { return grün < 0 ? (byte) 0 : grün > 255 ? (byte) 255 : (byte) grün; } + set { grün = value; } + } + + /// + /// Der Blau-Wert der Farbe. + /// + public byte Blau { + get { return blau < 0 ? (byte) 0 : blau > 255 ? (byte) 255 : (byte) blau; } + set { blau = value; } + } + + /// + /// Gibt die Farbe als Zeichenkette zurück. + /// + /// (Rot,Grün,Blau) + public override string ToString() { + return "(" + Rot + "," + Grün + "," + Blau + ")"; + } + + /// + /// Addiert die RGB-Werte zweier Farben. + /// + /// Um zwei Farben zu mischen muß zusätzlich eine Division durchgeführt + /// werden: (farbe1 + farbe2) / 2. + /// + /// Farbe 1 + /// Farbe 2 + /// Farbe + public static Farbe operator +(Farbe f1, Farbe f2) { + return new Farbe(f1.rot + f2.rot, f1.grün + f2.grün, f1.blau + f2.blau); + } + + /// + /// Multipliziert die RGB-Werte einer Farbe mit einer Zahl. + /// + /// Farbe + /// Zahl + /// Farbe + public static Farbe operator *(Farbe f, int i) { + return new Farbe(f.rot*i, f.grün*i, f.blau*i); + } + + /// + /// Dividiert die RGB-Werte einer Farbe durch eine Zahl. + /// + /// Farbe + /// Zahl + /// Farbe + public static Farbe operator /(Farbe f, int i) { + return new Farbe(f.rot/i, f.grün/i, f.blau/i); + } + + /// + /// Bestimmt ein Abstand-Maß zwischen zwei Farben im RGB-Farbraum. + /// + /// Wird von der Farbberater-Klasse verwendet. + /// + /// Farbe 1 + /// Farbe 2 + /// Abstand² + public static int operator -(Farbe f1, Farbe f2) { + int deltaRot = f1.rot - f2.rot; + int deltaGrün = f1.grün - f2.grün; + int deltaBlau = f1.blau - f2.blau; + return deltaRot*deltaRot + deltaGrün*deltaGrün + deltaBlau*deltaBlau; + //return Math.Abs(deltaRot) + Math.Abs(deltaGrün) + Math.Abs(deltaBlau); + } + } + + /// + /// Liefert Farben die sie möglichst stark voneinander Unterscheiden. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + public class ColorFinder { + public static Color ColonyColor1 { + get { return Settings.Default.ColonyColor1; } + } + + public static Color ColonyColor2 { + get { return Settings.Default.ColonyColor2; } + } + + public static Color ColonyColor3 { + get { return Settings.Default.ColonyColor3; } + } + + public static Color ColonyColor4 { + get { return Settings.Default.ColonyColor4; } + } + + public static Color ColonyColor5 { + get { return Settings.Default.ColonyColor5; } + } + + public static Color ColonyColor6 { + get { return Settings.Default.ColonyColor6; } + } + + public static Color ColonyColor7 { + get { return Settings.Default.ColonyColor7; } + } + + public static Color ColonyColor8 { + get { return Settings.Default.ColonyColor8; } + } + + private readonly List farben = new List(); + + /// + /// Markiert eine neue Farbe als bereits vorhanden. + /// + /// Neue Farbe. + public void BelegeFarbe(Farbe farbe) { + farben.Add(farbe); + } + + /// + /// Entfernt eine vorhandene Farbe. + /// + /// Vorhandene Farbe. + public void EntferneFarbe(Farbe farbe) { + farben.Remove(farbe); + } + + private int bestimmeMinimalenAbstand(Farbe farbe) { + int besterAbstand = int.MaxValue; + for (int f = 0; f < farben.Count; f++) { + int abstand = farben[f] - farbe; + if (abstand < besterAbstand) { + besterAbstand = abstand; + } + } + return besterAbstand; + } + + /// + /// Erzeugt eine neue Farbe mit möglichst großem Abstand zu den bereits + /// vorhandenen Farben. + /// + /// Neue Farbe. + public Farbe ErzeugeFarbe() { + int besterAbstand = 0; + Farbe besteFarbe = new Farbe(0, 0, 0); + + int r, g, b; + int r0 = 0, g0 = 0, b0 = 0; + int abstand; + Farbe farbe; + + for (r = 8; r < 256; r += 16) { + for (g = 8; g < 256; g += 16) { + for (b = 8; b < 256; b += 16) { + farbe = new Farbe(r, g, b); + abstand = bestimmeMinimalenAbstand(farbe); + if (abstand > besterAbstand) { + besterAbstand = abstand; + r0 = r; + g0 = g; + b0 = b; + } + } + } + } + + for (r = -8; r < 8; r++) { + for (g = -8; g < 8; g++) { + for (b = -8; b < 8; b++) { + farbe = new Farbe(r0 + r, g0 + g, b0 + b); + abstand = bestimmeMinimalenAbstand(farbe); + if (abstand > besterAbstand) { + besterAbstand = abstand; + besteFarbe = farbe; + } + } + } + } + + return besteFarbe; + } + + /// + /// Erzeugt eine neue Farbe mit möglichst großem Abstand zu den bereits + /// vorhandenen Farben und verändert sie leicht. + /// + /// Neue Farbe. + public Farbe ErzeugeFarbe(int streuung) { + Farbe farbe = ErzeugeFarbe(); + Random zufall = new Random(); + return + new Farbe + ( + (farbe.Rot*100)/(100 + zufall.Next(-streuung, streuung)), + (farbe.Grün*100)/(100 + zufall.Next(-streuung, streuung)), + (farbe.Blau*100)/(100 + zufall.Next(-streuung, streuung))); + } + + /// + /// Erzeugt eine neue Farbe mit möglichst großem Abstand zu den bereits + /// vorhandenen Farben und markiert sie als belegt. + /// + /// Neue Farbe. + public Farbe ErzeugeUndBelegeFarbe() { + Farbe farbe = ErzeugeFarbe(); + BelegeFarbe(farbe); + return farbe; + } + + /// + /// Erzeugt eine neue Farbe mit möglichst großem Abstand zu den bereits + /// vorhandenen Farben, verändert sie leicht und markiert sie als belegt. + /// + /// Neue Farbe. + public Farbe ErzeugeUndBelegeFarbe(int streuung) { + Farbe farbe = ErzeugeFarbe(streuung); + BelegeFarbe(farbe); + return farbe; + } + } +} \ No newline at end of file diff --git a/SharedComponents/Tools/NameHelper.cs b/SharedComponents/Tools/NameHelper.cs new file mode 100644 index 0000000..3382f50 --- /dev/null +++ b/SharedComponents/Tools/NameHelper.cs @@ -0,0 +1,55 @@ +using System; + +using AntMe.SharedComponents.Properties; + +namespace AntMe.SharedComponents.Tools { + /// + /// A static helper class that returns female and male first names. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + public static class NameHelper { + private static readonly int randomNumber; + + /// + /// An array of female first names. + /// + private static readonly string[] FemaleNames; + + /// + /// An array of male first names. + /// + private static readonly string[] MaleNames; + + // Static constructor. + static NameHelper() { + string[] separators = new string[] {"\n", "\r"}; + FemaleNames = Resources.FemaleNames.Split(separators, StringSplitOptions.RemoveEmptyEntries); + MaleNames = Resources.MaleNames.Split(separators, StringSplitOptions.RemoveEmptyEntries); + randomNumber = new Random().Next(1024); + } + + /// + /// Returns a female first name for a given hash value. + /// + /// + /// The same hash value will always return the same name within an application session. + /// + /// A value to use for hashing, for example an id. + /// A female first name. + public static string GetFemaleName(int hashValue) { + return FemaleNames[(hashValue*randomNumber)%FemaleNames.Length]; + } + + /// + /// Returns a male first name for a given hash value. + /// + /// + /// The same hash value will always return the same name within an application session. + /// + /// A value to use for hashing, for example an id. + /// A male first name. + public static string GetMaleName(int hashValue) { + return MaleNames[(hashValue*randomNumber)%MaleNames.Length]; + } + } +} \ No newline at end of file diff --git a/SharedComponents/app.config b/SharedComponents/app.config new file mode 100644 index 0000000..e80be5b --- /dev/null +++ b/SharedComponents/app.config @@ -0,0 +1,36 @@ + + + + +
+ + + + + + Black + + + Red + + + Orange + + + Blue + + + Yellow + + + White + + + Fuchsia + + + Lime + + + + diff --git a/SimulationCore/AntMe.snk b/SimulationCore/AntMe.snk new file mode 100644 index 0000000..cdd75a4 Binary files /dev/null and b/SimulationCore/AntMe.snk differ diff --git a/SimulationCore/Deutsch/Ameise.cs b/SimulationCore/Deutsch/Ameise.cs new file mode 100644 index 0000000..d4a010f --- /dev/null +++ b/SimulationCore/Deutsch/Ameise.cs @@ -0,0 +1,51 @@ +namespace AntMe.Deutsch { + /// + /// Repräsentiert eine Ameise + /// + public sealed class Ameise : Insekt { + internal Ameise(Simulation.CoreAnt ant) : base(ant) {} + + /// + /// Liefert die aktuelle Last + /// + public int AktuelleLast { + get { return ((Simulation.CoreAnt) element).AktuelleLastBase; } + } + + /// + /// Liefert einen Verweis auf das aktuell getragene Obst + /// + public Obst GetragenesObst { + get { + Simulation.CoreAnt temp = (Simulation.CoreAnt) element; + if (temp.GetragenesObstBase == null) { + return null; + } + else { + return new Obst(temp.GetragenesObstBase); + } + } + } + + /// + /// Liefert die maximale Belastbarkeit der Ameise + /// + public int MaximaleLast { + get { return ((Simulation.CoreAnt) element).MaximaleLastBase; } + } + + /// + /// Liefert die Reichweite der Ameise + /// + public int Reichweite { + get { return ((Simulation.CoreAnt) element).ReichweiteBase; } + } + + /// + /// Liefet den Volknamen dieser Ameise + /// + public string Volk { + get { return ((Simulation.CoreAnt) element).colony.Player.ColonyName; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Basisameise.cs b/SimulationCore/Deutsch/Basisameise.cs new file mode 100644 index 0000000..a723452 --- /dev/null +++ b/SimulationCore/Deutsch/Basisameise.cs @@ -0,0 +1,643 @@ +using System.Collections.Generic; +using AntMe.Simulation; + +namespace AntMe.Deutsch +{ + /// + /// Basisklasse für die Implementierung einer neuen Ameise + /// + public abstract class Basisameise : CoreAnt + { + #region Event-Wrapper + + internal override string BestimmeKasteBase(Dictionary anzahl) + { + return BestimmeKaste(anzahl); + } + + /// + /// Legt die Kaste der Ameise fest die als nächstes geboren wird + /// + /// Liste von Ameisenkasten und deren aktuell lebende Anzahl + /// Zeichenkette des neuen Ameisenkaste + public virtual string BestimmeKaste(Dictionary anzahl) + { + return ""; + } + + internal override void IstGestorbenBase(CoreKindOfDeath todesArt) + { + IstGestorben((Todesart) (int) todesArt); + } + + /// + /// Wird aufgerufen, wenn eine Ameise stirbt + /// + /// Art des Todes + public virtual void IstGestorben(Todesart todesart) + { + } + + internal override void RiechtFreundBase(CoreMarker markierung) + { + RiechtFreund(new Markierung(markierung)); + } + + /// + /// Wird aufgerufen, wenn die Ameise eine Markierung riecht + /// + /// gerochene Markierung + public virtual void RiechtFreund(Markierung markierung) + { + } + + internal override void SiehtBase(CoreFruit obst) + { + Sieht(new Obst(obst)); + } + + /// + /// Wird aufgerufen, wenn die Ameise Obst sieht + /// + /// obst + public virtual void Sieht(Obst obst) + { + } + + internal override void SiehtBase(CoreSugar zucker) + { + Sieht(new Zucker(zucker)); + } + + /// + /// Wird aufgerufen, wenn die Ameise Zucker sieht + /// + /// Verweis auf den Zucker + public virtual void Sieht(Zucker zucker) + { + } + + internal override void SiehtFeindBase(CoreAnt ameise) + { + SiehtFeind(new Ameise(ameise)); + } + + /// + /// Wird aufgerufen, wenn die Ameise eine feindliche Ameise sieht + /// + /// feindliche Ameise + public virtual void SiehtFeind(Ameise ameise) + { + } + + internal override void SiehtFeindBase(CoreBug wanze) + { + SiehtFeind(new Wanze(wanze)); + } + + /// + /// Wird aufgerufen, wenn die Ameise eine Wanze trifft + /// + /// Wanze + public virtual void SiehtFeind(Wanze wanze) + { + } + + internal override void SiehtFreundBase(CoreAnt ameise) + { + SiehtFreund(new Ameise(ameise)); + } + + /// + /// Wird aufgerufen, wenn die Ameise eine befreundete Ameise trifft + /// + /// befreundete Ameise + public virtual void SiehtFreund(Ameise ameise) + { + } + + internal override void SiehtVerbündetenBase(CoreAnt ameise) + { + SiehtVerbündeten(new Ameise(ameise)); + } + + /// + /// Wird aufgerufen, wenn die Ameise eine befreundete Ameise eines anderen Teams trifft. + /// + /// + public virtual void SiehtVerbündeten(Ameise ameise) {} + + internal override void TickBase() + { + Tick(); + } + + /// + /// Wird in jeder Runde aufgerufen + /// + public virtual void Tick() + { + } + + internal override void WartetBase() + { + Wartet(); + } + + /// + /// Wird aufgerufen, wenn die Ameise keinen Arbeitsauftrag mehr hat + /// + public virtual void Wartet() + { + } + + internal override void WirdAngegriffenBase(CoreAnt ameise) + { + WirdAngegriffen(new Ameise(ameise)); + } + + /// + /// Wird aufgerufen, wenn die Ameise von einer feindlichen Ameise attackiert wird + /// + /// feindliche Ameise + public virtual void WirdAngegriffen(Ameise ameise) + { + } + + internal override void WirdAngegriffenBase(CoreBug wanze) + { + WirdAngegriffen(new Wanze(wanze)); + } + + /// + /// Wird aufgerufen, wenn die Ameise von einer Wanze attackiert wird + /// + /// Wanze + public virtual void WirdAngegriffen(Wanze wanze) + { + } + + internal override void WirdMüdeBase() + { + WirdMüde(); + } + + /// + /// Wird aufgerufen, sobald die Ameise ein Drittel ihrer Reichweite zurückgelegt hat + /// + public virtual void WirdMüde() + { + } + + internal override void ZielErreichtBase(CoreFruit obst) + { + ZielErreicht(new Obst(obst)); + } + + /// + /// Wird aufgerufen, wenn die Ameise am anvisierten Obst angekommen ist + /// + /// anvisiertes Obst + public virtual void ZielErreicht(Obst obst) + { + } + + internal override void ZielErreichtBase(CoreSugar zucker) + { + ZielErreicht(new Zucker(zucker)); + } + + /// + /// Wird aufgerufen, wenn die Ameise am anvisierten Zuckerberg angekommen ist + /// + /// anvisierter Zuckerberg + public virtual void ZielErreicht(Zucker zucker) + { + } + + #endregion + + #region Befehlswrapper + + /// + /// Dreht die Ameise in die angegebene Richtung + /// + /// Zielrichtung + public void DreheInRichtung(int richtung) + { + DreheInRichtungBase(richtung); + } + + /// + /// Dreht die Ameise um den angegebenen Winkel + /// + /// winkel + public void DreheUmWinkel(int winkel) + { + DreheUmWinkelBase(winkel); + } + + /// + /// Dreht die Ameise in die entgegengesetzt Richtung + /// + public void DreheUm() + { + DreheUmBase(); + } + + /// + /// Dreht die Ameise in Richtung des Ziels + /// + /// anvisiertes Ziel + public void DreheZuZiel(Spielobjekt ziel) + { + DreheZuZielBase(ziel.Element); + } + + /// + /// Lässt die Ameise sofort anhalten + /// + public void BleibStehen() + { + BleibStehenBase(); + } + + /// + /// Lässt die Ameise geradeaus gehen + /// + public void GeheGeradeaus() + { + GeheGeradeausBase(); + } + + /// + /// Lässt die Ameise die angegebenen Schritte geradeaus laufen + /// + /// zu laufende Strecke + public void GeheGeradeaus(int entfernung) + { + GeheGeradeausBase(entfernung); + } + + /// + /// Lässt die Ameise in entgegengesetzte Richtung davon laufen + /// + /// Objekt, vor dem weggerannt werden soll + public void GeheWegVon(Spielobjekt ziel) + { + GeheWegVonBase(ziel.Element); + } + + /// + /// Lässt die Ameise in entgegengesetzte Richtung davon laufen + /// + /// Objekt, vor dem weggerannt werden soll + /// Entfernung, die zurückgelegt werden soll + public void GeheWegVon(Spielobjekt ziel, int entfernung) { + GeheWegVonBase(ziel.Element, entfernung); + } + + /// + /// Lässt die Ameise zum angegebenen Ziel laufen + /// + /// Ziel + public void GeheZuZiel(Spielobjekt ziel) + { + GeheZuZielBase(ziel.Element); + } + + /// + /// Lässt die Ameise zurück zum Bau laufen + /// + public void GeheZuBau() + { + GeheZuBauBase(); + } + + /// + /// Lässt die Ameise das angegebene Insekt angreifen + /// + /// Angriffsziel + public void GreifeAn(Insekt ziel) + { + GreifeAnBase((CoreInsect) ziel.Element); + } + + /// + /// Nimmt die angegebene Nahrung auf + /// + /// Nahrung + public void Nimm(Nahrung nahrung) + { + if (nahrung is Zucker) + { + NimmBase((CoreSugar) nahrung.Element); + } + else if (nahrung is Obst) + { + NimmBase((CoreFruit) nahrung.Element); + } + } + + /// + /// Lässt die gerade getragene Nahrung fallen + /// + public void LasseNahrungFallen() + { + LasseNahrungFallenBase(); + } + + /// + /// Sprüht eine Markierung mit minimaler Größe + /// + /// Information + public void SprüheMarkierung(int information) + { + SprüheMarkierungBase(information); + } + + /// + /// Sprüht eine Markierung mit angegebener Größe + /// + /// Information + /// Größe der Markierung + public void SprüheMarkierung(int information, int größe) + { + SprüheMarkierungBase(information, größe); + } + + /// + /// Lässt die Ameise über diese Nachricht nachdenken. + /// Im Debug-Modus wird das als Denkblase über der Ameise angezeigt. + /// + /// Nachricht + public void Denke(string nachricht) + { + DenkeCore(nachricht); + } + + #endregion + + #region Eigenschaften + + /// + /// Liefert die maximale Energie + /// + public int MaximaleEnergie + { + get { return MaximaleEnergieBase; } + } + + /// + /// Liefert die maximale Geschwindigkeit + /// + public int MaximaleGeschwindigkeit + { + get { return MaximaleGeschwindigkeitBase; } + } + + /// + /// Liefert die maximale Last + /// + public int MaximaleLast + { + get { return MaximaleLastBase; } + } + + /// + /// Gibt die Reichweite an + /// + public int Reichweite + { + get { return ReichweiteBase; } + } + + /// + /// Angriffswert + /// + public int Angriff + { + get { return AngriffBase; } + } + + /// + /// Sichtweite der Ameise + /// + public int Sichtweite + { + get { return SichtweiteBase; } + } + + /// + /// Drehgeschwindigkeit + /// + public int Drehgeschwindigkeit + { + get { return DrehgeschwindigkeitBase; } + } + + /// + /// Aktuelle Energie + /// + public int AktuelleEnergie + { + get { return AktuelleEnergieBase; } + } + + /// + /// Aktuelle Geschwindigkeit + /// + public int AktuelleGeschwindigkeit + { + get { return AktuelleGeschwindigkeitBase; } + } + + /// + /// Aktuelle Last + /// + public int AktuelleLast + { + get { return AktuelleLastBase; } + } + + /// + /// Anzahl befreundeter Ameisen in Sichtweite + /// + public int AnzahlAmeisenInSichtweite + { + get { return FriendlyAntsInViewrange; } + } + + /// + /// Anzahl befreundeter Ameisen aus der selben Kaste in Sichtweite + /// + public int AnzahlAmeisenDerSelbenKasteInSichtweite { + get { return FriendlyAntsFromSameCasteInViewrange; } + } + + /// + /// Anzahl Ameisen aus Völkern des eigenen Teams in Sichtweite. + /// + public int AnzahlAmeisenDesTeamsInSichtweite { + get { return TeamAntsInViewrange; } + } + + /// + /// Anzahl fremder Ameisen aus anderen Teams in Sichtweite. + /// + public int AnzahlFremderAmeisenInSichtweite { + get { return ForeignAntsInViewrange; } + } + + /// + /// Anzahl Wanzen in Sichtweite. + /// + public int WanzenInSichtweite { + get { return BugsInViewrange; } + } + + /// + /// Gibt die Entfernung zum nächsten Bau an + /// + public int EntfernungZuBau + { + get { return EntfernungZuBauBase; } + } + + /// + /// Liefert das aktuell getragene Obst + /// + public Obst GetragenesObst + { + get + { + if (GetragenesObstBase != null) + { + return new Obst(GetragenesObstBase); + } + else + { + return null; + } + } + } + + /// + /// Liefert die Ameisenkaste + /// + public string Kaste + { + get { return KasteBase; } + } + + /// + /// Index der Ameisenkaste + /// + public int CasteIndex + { + get { return CasteIndexBase; } + } + + /// + /// Liefert das Ziel der Ameise + /// + public Spielobjekt Ziel + { + get + { + if (ZielBase is CoreSugar) + { + return new Zucker((CoreSugar) ZielBase); + } + else if (ZielBase is CoreFruit) + { + return new Obst((CoreFruit) ZielBase); + } + else if (ZielBase is CoreAnt) + { + return new Ameise((CoreAnt) ZielBase); + } + else if (ZielBase is CoreBug) + { + return new Wanze((CoreBug) ZielBase); + } + else if (ZielBase is CoreMarker) + { + return new Markierung((CoreMarker) ZielBase); + } + else if (ZielBase is CoreAnthill) + { + return new Bau((CoreAnthill) ZielBase); + } + else + { + return null; + } + } + } + + /// + /// Ist die Ameise müde + /// + public bool IstMüde + { + get { return IstMüdeBase; } + } + + /// + /// Verbleibende Reststrecke bis zum erreichen des Ziels + /// + public int RestStrecke + { + get { return RestStreckeBase; } + } + + /// + /// Verbleibende Drehung bis zur Ausrichtung zum Ziel + /// + public int RestWinkel + { + get { return RestWinkelBase; } + } + + /// + /// Ausrichtung der Ameise + /// + public int Richtung + { + get { return RichtungBase; } + } + + /// + /// Informiert darüber, ob die Ameise ihr Ziel erreicht hat + /// + public bool Angekommen + { + get { return AngekommenBase; } + } + + /// + /// Die, von der Ameise zurückgelgte Strecke + /// + public int ZurückgelegteStrecke + { + get { return ZurückgelegteStreckeBase; } + } + + #endregion + + #region Hilfemethoden + + /// + /// Ermittelt, ob das übergebene Stück Obst noch weitere Träger braucht + /// + /// zu prüfendes Obst + /// Braucht noch Träger + public bool BrauchtNochTräger(Obst obst) + { + return ((CoreFruit) obst.Element).BrauchtNochTräger(colony); + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Bau.cs b/SimulationCore/Deutsch/Bau.cs new file mode 100644 index 0000000..354d0ce --- /dev/null +++ b/SimulationCore/Deutsch/Bau.cs @@ -0,0 +1,15 @@ +namespace AntMe.Deutsch { + /// + /// Repräsentiert einen Ameisenbau + /// + public sealed class Bau : Spielobjekt { + internal Bau(Simulation.CoreAnthill bau) : base(bau) {} + + /// + /// Liefert die ID dieses Baus + /// + public override int Id { + get { return ((Simulation.CoreAnthill) element).Id; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/DateizugriffAttribute.cs b/SimulationCore/Deutsch/DateizugriffAttribute.cs new file mode 100644 index 0000000..f97990c --- /dev/null +++ b/SimulationCore/Deutsch/DateizugriffAttribute.cs @@ -0,0 +1,9 @@ +using System; + +namespace AntMe.Deutsch { + /// + /// Attribut zur Anfrage von Dateizugriffen. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class DateizugriffAttribute : ZugriffAttribute {} +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/DatenbankzugriffAttribute.cs b/SimulationCore/Deutsch/DatenbankzugriffAttribute.cs new file mode 100644 index 0000000..e985668 --- /dev/null +++ b/SimulationCore/Deutsch/DatenbankzugriffAttribute.cs @@ -0,0 +1,9 @@ +using System; + +namespace AntMe.Deutsch { + /// + /// Attribut zur Anfrage von Zugriffen auf Datenbanken. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class DatenbankzugriffAttribute : ZugriffAttribute {} +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/FensterzugriffAttribute.cs b/SimulationCore/Deutsch/FensterzugriffAttribute.cs new file mode 100644 index 0000000..ae440f1 --- /dev/null +++ b/SimulationCore/Deutsch/FensterzugriffAttribute.cs @@ -0,0 +1,9 @@ +using System; + +namespace AntMe.Deutsch { + /// + /// Attribut zur Anfrage von Zugriff auf Fensterelemente. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class FensterzugriffAttribute : ZugriffAttribute {} +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Insekt.cs b/SimulationCore/Deutsch/Insekt.cs new file mode 100644 index 0000000..3929051 --- /dev/null +++ b/SimulationCore/Deutsch/Insekt.cs @@ -0,0 +1,85 @@ +namespace AntMe.Deutsch { + /// + /// Repräsentiert ein beliebiges Lebewesen auf dem Spielfeld + /// + public abstract class Insekt : Spielobjekt { + internal Insekt(Simulation.CoreInsect insekt) : base(insekt) {} + + /// + /// Liefer die eindeutige ID dieses Insektes + /// + public override int Id { + get { return ((Simulation.CoreInsect) element).id; } + } + + /// + /// Gibt die aktuelle Lebensenergie an + /// + public int AktuelleEnergie { + get { return ((Simulation.CoreInsect) element).AktuelleEnergieBase; } + } + + /// + /// Gibt die aktuelle geschwindigkeit an + /// + public int AktuelleGeschwindigkeit { + get { return ((Simulation.CoreInsect) element).AktuelleGeschwindigkeitBase; } + } + + /// + /// Gibt die Angriffsstärke an + /// + public int Angriff { + get { return ((Simulation.CoreInsect) element).AngriffBase; } + } + + /// + /// Gibt die aktuelle Geschwindigkeit an + /// + public int Drehgeschwindigkeit { + get { return ((Simulation.CoreInsect) element).DrehgeschwindigkeitBase; } + } + + /// + /// Gibt die maximale Lebensenergie an + /// + public int MaximaleEnergie { + get { return ((Simulation.CoreInsect) element).MaximaleEnergieBase; } + } + + /// + /// Gibt die maximale Geschwindigkeit an + /// + public int MaximaleGeschwindigkeit { + get { return ((Simulation.CoreInsect) element).MaximaleGeschwindigkeitBase; } + } + + /// + /// Gibt die Sichtweite an + /// + public int Sichtweite { + get { return ((Simulation.CoreInsect) element).SichtweiteBase; } + } + + /// + /// Gibt den noch zu rotierenden Winkel an + /// + public int RestWinkel { + get { return ((Simulation.CoreInsect) element).RestWinkelBase; } + } + + /// + /// Gibt die Ausrichtung der Ameise an + /// + public int Richtung { + get { return ((Simulation.CoreInsect) element).RichtungBase; } + } + + /// + /// Gibt die noch zu laufende Strecke an + /// + public int RestStrecke { + get { return ((Simulation.CoreInsect) element).RestStreckeBase; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/KasteAttribute.cs b/SimulationCore/Deutsch/KasteAttribute.cs new file mode 100644 index 0000000..21a7836 --- /dev/null +++ b/SimulationCore/Deutsch/KasteAttribute.cs @@ -0,0 +1,49 @@ +using System; + +namespace AntMe.Deutsch { + /// + /// Attribut für die Beschreibung von verschiedenen Ameisenkasten + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + public sealed class KasteAttribute : Attribute { + /// + /// Legt die Angriffsstärke der Ameise fest + /// + public int AngriffModifikator = 0; + + /// + /// Legt die Drehgeschwindigkeit der Ameise fest + /// + public int DrehgeschwindigkeitModifikator = 0; + + /// + /// Legt die Energie einer Ameise fest + /// + public int EnergieModifikator = 0; + + /// + /// Legt die Bewegungsgeschwindigkeit einer Ameise fest + /// + public int GeschwindigkeitModifikator = 0; + + /// + /// Legt die Belastbarkeit einer Ameise fest + /// + public int LastModifikator = 0; + + /// + /// Legt den Namen der Ameisenkaste fest + /// + public string Name = string.Empty; + + /// + /// Legt die Reichweite einer Ameise fest + /// + public int ReichweiteModifikator = 0; + + /// + /// Legt die Sichtweite einer Ameise fest + /// + public int SichtweiteModifikator = 0; + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Koordinate.cs b/SimulationCore/Deutsch/Koordinate.cs new file mode 100644 index 0000000..05e938a --- /dev/null +++ b/SimulationCore/Deutsch/Koordinate.cs @@ -0,0 +1,88 @@ +using AntMe.Simulation; + +namespace AntMe.Deutsch { + /// + /// Hilfsklasse für Entfernungs- und Richtungsberechnungen + /// + public static class Koordinate { + /// + /// Bestimmt die Entfernung zwischen zwei Spielelementen + /// + /// Element 1 + /// Element 2 + /// Entfernung in Schritten + public static int BestimmeEntfernung(Spielobjekt objekt1, Spielobjekt objekt2) { + return CoreCoordinate.BestimmeEntfernung(objekt1.Element, objekt2.Element); + } + + /// + /// Bestimmt die Entfernung zwischen zwei Spielelementen + /// + /// Element 1 + /// Element 2 + /// Entfernung in Schritten + public static int BestimmeEntfernung(CoreAnt objekt1, Spielobjekt objekt2) { + return CoreCoordinate.BestimmeEntfernung(objekt1, objekt2.Element); + } + + /// + /// Bestimmt die Entfernung zwischen zwei Spielelementen + /// + /// Element 1 + /// Element 2 + /// Entfernung in Schritten + public static int BestimmeEntfernung(Spielobjekt objekt1, CoreAnt objekt2) { + return CoreCoordinate.BestimmeEntfernung(objekt1.Element, objekt2); + } + + /// + /// Bestimmt die Entfernung zwischen zwei Spielelementen + /// + /// Element 1 + /// Element 2 + /// Entfernung in Schritten + public static int BestimmeEntfernung(CoreAnt objekt1, CoreAnt objekt2) { + return CoreCoordinate.BestimmeEntfernung(objekt1, objekt2); + } + + /// + /// Ermittelt den Richtungsunterscheid zwischen zwei Spielelementen + /// + /// Element 1 + /// Element 2 + /// Entfernung in Gradschritten + public static int BestimmeRichtung(Spielobjekt objekt1, Spielobjekt objekt2) { + return CoreCoordinate.BestimmeRichtung(objekt1.Element, objekt2.Element); + } + + /// + /// Ermittelt den Richtungsunterscheid zwischen zwei Spielelementen + /// + /// Element 1 + /// Element 2 + /// Entfernung in Gradschritten + public static int BestimmeRichtung(CoreAnt objekt1, Spielobjekt objekt2) { + return CoreCoordinate.BestimmeRichtung(objekt1, objekt2.Element); + } + + /// + /// Ermittelt den Richtungsunterscheid zwischen zwei Spielelementen + /// + /// Element 1 + /// Element 2 + /// Entfernung in Gradschritten + public static int BestimmeRichtung(Spielobjekt objekt1, CoreAnt objekt2) { + return CoreCoordinate.BestimmeRichtung(objekt1.Element, objekt2); + } + + /// + /// Ermittelt den Richtungsunterscheid zwischen zwei Spielelementen + /// + /// Element 1 + /// Element 2 + /// Entfernung in Gradschritten + public static int BestimmeRichtung(CoreAnt objekt1, CoreAnt objekt2) { + return CoreCoordinate.BestimmeRichtung(objekt1, objekt2); + } + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Markierung.cs b/SimulationCore/Deutsch/Markierung.cs new file mode 100644 index 0000000..4e1f5e9 --- /dev/null +++ b/SimulationCore/Deutsch/Markierung.cs @@ -0,0 +1,22 @@ +namespace AntMe.Deutsch { + /// + /// Repräsentiert eine Markierung + /// + public sealed class Markierung : Spielobjekt { + internal Markierung(Simulation.CoreMarker markierung) : base(markierung) {} + + /// + /// Liefert die eindeutige ID dieser Markeriung + /// + public override int Id { + get { return ((Simulation.CoreMarker) element).Id; } + } + + /// + /// Liefert die Information aus der Markierung + /// + public int Information { + get { return ((Simulation.CoreMarker) element).Information; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Nahrung.cs b/SimulationCore/Deutsch/Nahrung.cs new file mode 100644 index 0000000..e920338 --- /dev/null +++ b/SimulationCore/Deutsch/Nahrung.cs @@ -0,0 +1,22 @@ +namespace AntMe.Deutsch { + /// + /// Basisklasse für alle Nahrungsmittel auf dem Spielfeld + /// + public abstract class Nahrung : Spielobjekt { + internal Nahrung(Simulation.CoreFood nahrung) : base(nahrung) {} + + /// + /// Liefert die Menge an Nahrung + /// + public int Menge { + get { return ((Simulation.CoreFood) element).Menge; } + } + + /// + /// Liefer die ID dieser Nahrung + /// + public override int Id { + get { return ((Simulation.CoreFood)element).Id; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/NetzwerkzugriffAttribute.cs b/SimulationCore/Deutsch/NetzwerkzugriffAttribute.cs new file mode 100644 index 0000000..f68a148 --- /dev/null +++ b/SimulationCore/Deutsch/NetzwerkzugriffAttribute.cs @@ -0,0 +1,9 @@ +using System; + +namespace AntMe.Deutsch { + /// + /// Attribut zur Anfrage von Netzwerkzugriff. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class NetzwerkzugriffAttribute : ZugriffAttribute {} +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Obst.cs b/SimulationCore/Deutsch/Obst.cs new file mode 100644 index 0000000..31b52a9 --- /dev/null +++ b/SimulationCore/Deutsch/Obst.cs @@ -0,0 +1,8 @@ +namespace AntMe.Deutsch { + /// + /// Repräsentiert einen Apfel + /// + public sealed class Obst : Nahrung { + internal Obst(Simulation.CoreFruit obst) : base(obst) {} + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/SpielerAttribute.cs b/SimulationCore/Deutsch/SpielerAttribute.cs new file mode 100644 index 0000000..a1502c9 --- /dev/null +++ b/SimulationCore/Deutsch/SpielerAttribute.cs @@ -0,0 +1,38 @@ +using System; + +namespace AntMe.Deutsch { + /// + /// Attribut für die spielerrelevanten Angaben zum Volk + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class SpielerAttribute : Attribute { + + private string nachname = string.Empty; + private string volkname = string.Empty; + private string vorname = string.Empty; + + /// + /// Name des Volkes (Angabe erforderlich) + /// + public string Volkname { + get { return volkname; } + set { volkname = value;} + } + + /// + /// Nachname des Spielers + /// + public string Nachname { + get { return nachname; } + set { nachname = value; } + } + + /// + /// Vorname des Spielers + /// + public string Vorname { + get { return vorname; } + set { vorname = value; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Spielobjekt.cs b/SimulationCore/Deutsch/Spielobjekt.cs new file mode 100644 index 0000000..b39c899 --- /dev/null +++ b/SimulationCore/Deutsch/Spielobjekt.cs @@ -0,0 +1,94 @@ +using AntMe.Simulation; + +namespace AntMe.Deutsch { + /// + /// Allgemeines Spielelement + /// + public abstract class Spielobjekt { + /// + /// Speichert die Referenz auf das original Spielobjekt + /// + protected ICoordinate element; + + internal Spielobjekt(ICoordinate element) { + this.element = element; + } + + /// + /// Gibt das Basiselement zurück + /// + internal ICoordinate Element { + get { return element; } + } + + /// + /// Liefert die eindeutige ID dieses Elements + /// + public abstract int Id { get; } + + #region Vergleichsoperatoren + + /// + /// operator == + /// + /// Vergleichsobjekt 1 + /// Vergleichsobjekt 2 + /// + public static bool operator ==(Spielobjekt a, Spielobjekt b) + { + // prüfen, ob beide Elemente null sind + if ((object)a == null) + { + if ((object)b == null) + { + return true; + } + return false; + } + + // prüfen, ob b null ist + if ((object)b == null) + { + return false; + } + + // Beides Instanzen - echte Prüfung + return a.Equals(b); + } + + /// + /// operator != + /// + /// Vergleichsobjekt 1 + /// Vergleichsobjekt 2 + /// + public static bool operator !=(Spielobjekt a, Spielobjekt b) + { + return !(a == b); + } + + /// + /// Vergleicht dieses Element mit einem anderen + /// + /// Vergleichsobjekt + /// Haben den gleichen Inhalt + public override bool Equals(object obj) { + if (obj == null) + return false; + if (obj.GetType() == GetType()) { + return obj.GetHashCode() == GetHashCode(); + } + return false; + } + + /// + /// Erstellt einen eindeutigen Code für dieses Objekt + /// + /// eindeutiger Code + public override int GetHashCode() { + return Id; + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Todesart.cs b/SimulationCore/Deutsch/Todesart.cs new file mode 100644 index 0000000..5f16e7a --- /dev/null +++ b/SimulationCore/Deutsch/Todesart.cs @@ -0,0 +1,21 @@ +namespace AntMe.Deutsch { + /// + /// Liste möglicher Todesursachen + /// + public enum Todesart { + /// + /// Ameise verhungert + /// + Verhungert = 1, + + /// + /// Ameise wurde von Wanze gefressen + /// + Gefressen = 2, + + /// + /// Ameise wurde von feindlichen Ameisen besiegt + /// + Besiegt = 4 + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Volk.cs b/SimulationCore/Deutsch/Volk.cs new file mode 100644 index 0000000..3bc2417 --- /dev/null +++ b/SimulationCore/Deutsch/Volk.cs @@ -0,0 +1,19 @@ +namespace AntMe.Deutsch { + /// + /// Repräsentant eines Volkes + /// + public sealed class Volk { + private readonly Simulation.CoreColony volk; + + internal Volk(Simulation.CoreColony volk) { + this.volk = volk; + } + + /// + /// Liefert den Namen des Volkes + /// + public string Name { + get { return volk.Player.ColonyName; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Wanze.cs b/SimulationCore/Deutsch/Wanze.cs new file mode 100644 index 0000000..75f57e4 --- /dev/null +++ b/SimulationCore/Deutsch/Wanze.cs @@ -0,0 +1,8 @@ +namespace AntMe.Deutsch { + /// + /// Repräsentiert eine Wanze + /// + public sealed class Wanze : Insekt { + internal Wanze(Simulation.CoreBug wanze) : base(wanze) {} + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Zucker.cs b/SimulationCore/Deutsch/Zucker.cs new file mode 100644 index 0000000..b309c89 --- /dev/null +++ b/SimulationCore/Deutsch/Zucker.cs @@ -0,0 +1,8 @@ +namespace AntMe.Deutsch { + /// + /// Repräsentiert einen Zuckerberg + /// + public sealed class Zucker : Nahrung { + internal Zucker(Simulation.CoreSugar zucker) : base(zucker) {} + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/Zufall.cs b/SimulationCore/Deutsch/Zufall.cs new file mode 100644 index 0000000..776745d --- /dev/null +++ b/SimulationCore/Deutsch/Zufall.cs @@ -0,0 +1,32 @@ +using System; + +namespace AntMe.Deutsch { + /// + /// Hilfsklasse zur Generierung von Zufallszahlen + /// + public static class Zufall { + private static readonly Random random = new Random(); + + /// + /// Generiert eine Zufallszahl zwischen 0 und dem angegebenen Maximum + /// + /// Maximum + /// Zufallszahl + public static int Zahl(int maximum) { + return random.Next(maximum); + } + + /// + /// Generiert eine Zufallszahl zwischen dem angegebenen Minimum und dem angegebenen Maximum + /// + /// Minumum + /// Maximum + /// Zufallszahl + public static int Zahl(int minimum, int maximum) { + if (maximum < minimum) { + return random.Next(maximum, minimum); + } + return random.Next(minimum, maximum); + } + } +} \ No newline at end of file diff --git a/SimulationCore/Deutsch/ZugriffAttribute.cs b/SimulationCore/Deutsch/ZugriffAttribute.cs new file mode 100644 index 0000000..352c2e4 --- /dev/null +++ b/SimulationCore/Deutsch/ZugriffAttribute.cs @@ -0,0 +1,14 @@ +using System; + +namespace AntMe.Deutsch { + /// + /// Attribut, um Zugriffsrechte anzufordern. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public abstract class ZugriffAttribute : Attribute { + /// + /// Beschreibung zur Verwendung der erteilten Zugriffsrechte. + /// + public string Beschreibung; + } +} \ No newline at end of file diff --git a/SimulationCore/English/AccessAttribute.cs b/SimulationCore/English/AccessAttribute.cs new file mode 100644 index 0000000..f32eca7 --- /dev/null +++ b/SimulationCore/English/AccessAttribute.cs @@ -0,0 +1,14 @@ +using System; + +namespace AntMe.English { + /// + /// Baseattribute for all access-requesting attributes. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public abstract class AccessAttribute : Attribute { + /// + /// Short description of what the ant will do with the requested rights. + /// + public string Description; + } +} \ No newline at end of file diff --git a/SimulationCore/English/Ant.cs b/SimulationCore/English/Ant.cs new file mode 100644 index 0000000..0f142a9 --- /dev/null +++ b/SimulationCore/English/Ant.cs @@ -0,0 +1,53 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Represents a foreign ant + /// + public sealed class Ant : Insect { + internal Ant(CoreAnt ant) : base(ant) {} + + /// + /// Delivers the current load of this ant. + /// + public int CurrentLoad { + get { return ((CoreAnt) Baseitem).AktuelleLastBase; } + } + + /// + /// delivers the current carried fruit. + /// + public Fruit CarriedFruit { + get { + CoreAnt temp = (CoreAnt) Baseitem; + if (temp.GetragenesObstBase == null) { + return null; + } + else { + return new Fruit(temp.GetragenesObstBase); + } + } + } + + /// + /// Delivers the maximum load. + /// + public int MaximumLoad { + get { return ((CoreAnt) Baseitem).MaximaleLastBase; } + } + + /// + /// Delivers the range. + /// + public int Range { + get { return ((CoreAnt) Baseitem).ReichweiteBase; } + } + + /// + /// Delivers the Colony-Name. + /// + public string Colony { + get { return ((CoreAnt) Baseitem).colony.Player.ColonyName; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/English/Anthill.cs b/SimulationCore/English/Anthill.cs new file mode 100644 index 0000000..54f3abd --- /dev/null +++ b/SimulationCore/English/Anthill.cs @@ -0,0 +1,17 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Represents an anthill + /// + public sealed class Anthill : Item { + internal Anthill(CoreAnthill anthill) : base(anthill) {} + + /// + /// Delivers the unique ID of this anthill + /// + public override int Id { + get { return ((CoreAnthill) Baseitem).Id; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/English/BaseAnt.cs b/SimulationCore/English/BaseAnt.cs new file mode 100644 index 0000000..5bc542d --- /dev/null +++ b/SimulationCore/English/BaseAnt.cs @@ -0,0 +1,546 @@ +using System.Collections.Generic; + +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Baseclass for new Ant-Implementations + /// + public abstract class BaseAnt : CoreAnt { + #region Eventwrapper + + internal override string BestimmeKasteBase(Dictionary anzahl) { + return ChooseType(anzahl); + } + + /// + /// Returns the name of the ant-type which will be born next + /// + /// List of ant-types and there population + /// Name of ant-type which will born next + public virtual string ChooseType(Dictionary typeCount) { + return string.Empty; + } + + internal override void IstGestorbenBase(CoreKindOfDeath todesArt) { + HasDied((KindOfDeath) (int) todesArt); + } + + /// + /// Will be fired when the ant is going to death + /// + /// Kind of Death + public virtual void HasDied(KindOfDeath kindOfDeath) {} + + internal override void RiechtFreundBase(CoreMarker markierung) { + SmellsFriend(new Marker(markierung)); + } + + /// + /// Will be fired when the ant smells a Marker + /// + /// the smelled marker + public virtual void SmellsFriend(Marker marker) {} + + internal override void SiehtBase(CoreFruit obst) { + Spots(new Fruit(obst)); + } + + /// + /// Will be fired when the ant sees fruit + /// + /// the discovered fruit + public virtual void Spots(Fruit fruit) {} + + internal override void SiehtBase(CoreSugar zucker) { + Spots(new Sugar(zucker)); + } + + /// + /// Will be fired when the ant discovers a sugarhill + /// + /// discovered sugarhill + public virtual void Spots(Sugar sugar) {} + + internal override void SiehtFeindBase(CoreAnt ameise) { + SpotsEnemy(new Ant(ameise)); + } + + /// + /// Will be fired when the ant discovers a foreign ant + /// + /// the foreign ant + public virtual void SpotsEnemy(Ant ant) {} + + internal override void SiehtFeindBase(CoreBug wanze) { + SpotsEnemy(new Bug(wanze)); + } + + /// + /// Will be fired when the ant spots a bug + /// + /// the discovered bug + public virtual void SpotsEnemy(Bug bug) {} + + internal override void SiehtFreundBase(CoreAnt ameise) { + SpotsFriend(new Ant(ameise)); + } + + /// + /// Will be fired when the ant spots another ant of there own colony. + /// + /// the other ant + public virtual void SpotsFriend(Ant ant) {} + + internal override void SiehtVerbündetenBase(CoreAnt ameise) { + SpotsPartner(new Ant(ameise)); + } + + /// + /// Will be fired when the ant spots another ant from friendly team. + /// + /// the other ant + public virtual void SpotsPartner(Ant ant) {} + + internal override void TickBase() { + Tick(); + } + + /// + /// Will be fired every round for every single ant + /// + public virtual void Tick() {} + + internal override void WartetBase() { + Waits(); + } + + /// + /// Will be fired everytime the ant don't know whats next + /// + public virtual void Waits() {} + + internal override void WirdAngegriffenBase(CoreAnt ameise) { + UnderAttack(new Ant(ameise)); + } + + /// + /// Will be fired when the ant is under attack by a foreign ant + /// + /// attacking ant + public virtual void UnderAttack(Ant ant) {} + + internal override void WirdAngegriffenBase(CoreBug wanze) { + UnderAttack(new Bug(wanze)); + } + + /// + /// Will be fired when the ant is under attack by a bug + /// + /// attacking bug + public virtual void UnderAttack(Bug bug) {} + + internal override void WirdMüdeBase() { + BecomesTired(); + } + + /// + /// Will be fired when the ant is going to run out of food + /// + public virtual void BecomesTired() {} + + internal override void ZielErreichtBase(CoreFruit obst) { + TargetReached(new Fruit(obst)); + } + + /// + /// Will be fired when the ant reaches the targeted vegetable + /// + /// targeted fruit + public virtual void TargetReached(Fruit fruit) {} + + internal override void ZielErreichtBase(CoreSugar zucker) { + TargetReached(new Sugar(zucker)); + } + + /// + /// Will be fired when the ant reaches the targeted sugarhill + /// + /// targeted sugarhill + public virtual void TargetReached(Sugar sugar) {} + + #endregion + + #region Command-Wrapper + + /// + /// Rotates the ant in the given direction + /// + /// target direction + public void TurnToDirection(int direction) { + DreheInRichtungBase(direction); + } + + /// + /// Rotates the ant by the given degrees + /// + /// degrees to rotate + public void TurnByDegrees(int degrees) { + DreheUmWinkelBase(degrees); + } + + /// + /// Rotates the ant to the oposit direction + /// + public void TurnAround() { + DreheUmBase(); + } + + /// + /// Rotates the ant to the given Target + /// + /// target + public void TurnToTarget(Item target) { + DreheZuZielBase(target.Baseitem); + } + + /// + /// Stops the ant-movement + /// + public void Stop() { + BleibStehenBase(); + } + + /// + /// Let the ant go forward + /// + public void GoAhead() { + GeheGeradeausBase(); + } + + /// + /// Let the ant walk forward the given steps + /// + /// steps to go + public void GoAhead(int steps) { + GeheGeradeausBase(steps); + } + + /// + /// Let the ant go away from given target + /// + /// target + public void GoAwayFromTarget(Item target) { + GeheWegVonBase(target.Baseitem); + } + + /// + /// Let the ant go away from given target + /// + /// target + /// Steps to go + public void GoAwayFromTarget(Item target, int steps) { + GeheWegVonBase(target.Baseitem, steps); + } + + /// + /// Let the ant walk to the given target + /// + /// target + public void GoToTarget(Item target) { + GeheZuZielBase(target.Baseitem); + } + + /// + /// Let the ant walk back to the nearest anthill + /// + public void GoBackToAnthill() { + GeheZuBauBase(); + } + + /// + /// Let the ant attack the given target + /// + /// target to attack + public void Attack(Insect target) { + GreifeAnBase((CoreInsect) target.Baseitem); + } + + /// + /// Picks up the given food + /// + /// food to pick up + public void Take(Food food) { + if (food is Sugar) { + NimmBase((CoreSugar) food.Baseitem); + } + else if (food is Fruit) { + NimmBase((CoreFruit) food.Baseitem); + } + } + + /// + /// Let the ant drop all the carring food + /// + public void Drop() { + LasseNahrungFallenBase(); + } + + /// + /// Let the ant create a mark with given information + /// + /// information to put in mark + public void MakeMark(int information) { + SprüheMarkierungBase(information); + } + + /// + /// Let the ant create a mark with given information and given range + /// + /// information to put in mark + /// range of mark + public void MakeMark(int information, int range) { + SprüheMarkierungBase(information, range); + } + + /// + /// Let the ant think about the given message. This will be + /// shown in the 3D View during the Debug Mode. + /// + /// Message + public void Think(string message) + { + DenkeCore(message); + } + + #endregion + + #region Property-Wrapper + + /// + /// Gives the highest possible Hitpoints of this ant + /// + public int MaximumEnergy { + get { return MaximaleEnergieBase; } + } + + /// + /// Gives the highest possible Speed of this ant (in steps per round) + /// + public int MaximumSpeed { + get { return MaximaleGeschwindigkeitBase; } + } + + /// + /// Gives the highest possible Carrage of this ant + /// + public int MaximumLoad { + get { return MaximaleLastBase; } + } + + /// + /// Gives the Range of this ant (in steps) + /// + public int Range { + get { return ReichweiteBase; } + } + + /// + /// Gives the attack-strength of this ant + /// + public int Strength { + get { return AngriffBase; } + } + + /// + /// Gives the range of view of this ant + /// + public int Viewrange { + get { return SichtweiteBase; } + } + + /// + /// Gives the rotationspeed of this ant (degrees per round) + /// + public int RotationSpeed { + get { return DrehgeschwindigkeitBase; } + } + + /// + /// Gives the current amount of hitpoints + /// + public int CurrentEnergy { + get { return AktuelleEnergieBase; } + } + + /// + /// Gives the current speed of this ant + /// + public int CurrentSpeed { + get { return AktuelleGeschwindigkeitBase; } + } + + /// + /// Gives the current carrage of this ant + /// + public int CurrentLoad { + get { return AktuelleLastBase; } + } + + /// + /// Gives the count of friendly ants in viewrange of this ant + /// + public new int FriendlyAntsInViewrange { + get { return base.FriendlyAntsInViewrange; } + } + + /// + /// Gives the count of friendly ants from same caste in viewrange. + /// + public new int FriendlyAntsFromSameCasteInViewrange { + get { return base.FriendlyAntsFromSameCasteInViewrange; } + } + + /// + /// Gives the count of Ants from same team in Viewrange. + /// + public new int TeamAntsInViewrange { + get { return base.TeamAntsInViewrange; } + } + + /// + /// Gives the count of foreign ants in viewrange. + /// + public new int ForeignAntsInViewrange { + get { return base.ForeignAntsInViewrange; } + } + + /// + /// Gives the count of bugs in viewrange. + /// + public int BugsInViewrange { + get { return base.BugsInViewrange; } + } + + /// + /// Gives the distance to the nearest anthill (in steps) + /// + public int DistanceToAnthill { + get { return EntfernungZuBauBase; } + } + + /// + /// Gives the loaded Vegetable + /// + public Fruit CarringFruit { + get { + if (GetragenesObstBase != null) { + return new Fruit(GetragenesObstBase); + } + else { + return null; + } + } + } + + /// + /// Gives the profession of this ant + /// + public string Caste { + get { return KasteBase; } + } + + /// + /// Gives the Index of the ants profession + /// + public int CasteIndex { + get { return CasteIndexBase; } + } + + /// + /// Gives the ants target + /// + public Item Target { + get { + if (ZielBase is CoreSugar) { + return new Sugar((CoreSugar) ZielBase); + } + else if (ZielBase is CoreFruit) { + return new Fruit((CoreFruit) ZielBase); + } + else if (ZielBase is CoreAnt) { + return new Ant((CoreAnt) ZielBase); + } + else if (ZielBase is CoreBug) { + return new Bug((CoreBug) ZielBase); + } + else if (ZielBase is CoreMarker) { + return new Marker((CoreMarker) ZielBase); + } + else if (ZielBase is CoreAnthill) { + return new Anthill((CoreAnthill) ZielBase); + } + else { + return null; + } + } + } + + /// + /// Gives back, if the ant is tired + /// + public bool IsTired { + get { return IstMüdeBase; } + } + + /// + /// Gives the remain distance to target + /// + public int DistanceToTarget { + get { return RestStreckeBase; } + } + + /// + /// Gives the remain degrees to rotate + /// + public int DegreesToTarget { + get { return RestWinkelBase; } + } + + /// + /// Gives the current direction of the ant + /// + public int Direction { + get { return RichtungBase; } + } + + /// + /// Gives back, if the ant reched the target + /// + public bool ReachedTarget { + get { return AngekommenBase; } + } + + /// + /// Gives the distance that was walked by the ant + /// + public int WalkedRange { + get { return ZurückgelegteStreckeBase; } + } + + #endregion + + #region Supporting Methodes + + /// + /// Finds out, if the given Vegetable needs more ants to carry + /// + /// Fruit to test + /// needs more ants + public bool NeedsCarrier(Fruit fruit) { + return ((CoreFruit) fruit.Baseitem).BrauchtNochTräger(colony); + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/English/Bug.cs b/SimulationCore/English/Bug.cs new file mode 100644 index 0000000..14f219a --- /dev/null +++ b/SimulationCore/English/Bug.cs @@ -0,0 +1,10 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Represents a bug + /// + public sealed class Bug : Insect { + internal Bug(CoreBug bug) : base(bug) {} + } +} \ No newline at end of file diff --git a/SimulationCore/English/CasteAttribute.cs b/SimulationCore/English/CasteAttribute.cs new file mode 100644 index 0000000..39bce84 --- /dev/null +++ b/SimulationCore/English/CasteAttribute.cs @@ -0,0 +1,49 @@ +using System; + +namespace AntMe.English { + /// + /// Attribute to descripe the different professions of ants + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + public sealed class CasteAttribute : Attribute { + /// + /// The Attackstrength + /// + public int AttackModificator = 0; + + /// + /// Hitpoints + /// + public int EnergyModificator = 0; + + /// + /// Load + /// + public int LoadModificator = 0; + + /// + /// name + /// + public string Name = string.Empty; + + /// + /// range + /// + public int RangeModificator = 0; + + /// + /// Rotationspeed + /// + public int RotationSpeedModificator = 0; + + /// + /// Spped + /// + public int SpeedModificator = 0; + + /// + /// viewrange + /// + public int ViewRangeModificator = 0; + } +} \ No newline at end of file diff --git a/SimulationCore/English/Colony.cs b/SimulationCore/English/Colony.cs new file mode 100644 index 0000000..903f4fd --- /dev/null +++ b/SimulationCore/English/Colony.cs @@ -0,0 +1,21 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Represents the Colony + /// + public sealed class Colony { + private readonly CoreColony colony; + + internal Colony(CoreColony colony) { + this.colony = colony; + } + + /// + /// Delivers the Name of that colony + /// + public string Name { + get { return colony.Player.ColonyName; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/English/Coordinate.cs b/SimulationCore/English/Coordinate.cs new file mode 100644 index 0000000..fd46006 --- /dev/null +++ b/SimulationCore/English/Coordinate.cs @@ -0,0 +1,88 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Helper-class to calculate with distances and angles + /// + public static class Coordinate { + /// + /// Gives the distance between the to given objects + /// + /// object 1 + /// object 2 + /// Distance between + public static int GetDistanceBetween(Item a, Item b) { + return CoreCoordinate.BestimmeEntfernung(a.Baseitem, b.Baseitem); + } + + /// + /// Gives the distance between the to given objects + /// + /// object 1 + /// object 2 + /// Distance between + public static int GetDistanceBetween(CoreAnt a, Item b) { + return CoreCoordinate.BestimmeEntfernung(a, b.Baseitem); + } + + /// + /// Gives the distance between the to given objects + /// + /// object 1 + /// object 2 + /// Distance between + public static int GetDistanceBetween(Item a, CoreAnt b) { + return CoreCoordinate.BestimmeEntfernung(a.Baseitem, b); + } + + /// + /// Gives the distance between the to given objects + /// + /// object 1 + /// object 2 + /// Distance between + public static int GetDistanceBetween(CoreAnt a, CoreAnt b) { + return CoreCoordinate.BestimmeEntfernung(a, b); + } + + /// + /// Gives the direction from object 1 to object 2 + /// + /// object 1 + /// object 2 + /// direction + public static int GetDegreesBetween(Item a, Item b) { + return CoreCoordinate.BestimmeRichtung(a.Baseitem, b.Baseitem); + } + + /// + /// Gives the direction from object 1 to object 2 + /// + /// object 1 + /// object 2 + /// direction + public static int GetDegreesBetween(CoreAnt a, Item b) { + return CoreCoordinate.BestimmeRichtung(a, b.Baseitem); + } + + /// + /// Gives the direction from object 1 to object 2 + /// + /// object 1 + /// object 2 + /// direction + public static int GetDegreesBetween(Item a, CoreAnt b) { + return CoreCoordinate.BestimmeRichtung(a.Baseitem, b); + } + + /// + /// Gives the direction from object 1 to object 2 + /// + /// object 1 + /// object 2 + /// direction + public static int GetDegreesBetween(CoreAnt a, CoreAnt b) { + return CoreCoordinate.BestimmeRichtung(a, b); + } + } +} \ No newline at end of file diff --git a/SimulationCore/English/DatabaseAccessAttribute.cs b/SimulationCore/English/DatabaseAccessAttribute.cs new file mode 100644 index 0000000..67c7b8b --- /dev/null +++ b/SimulationCore/English/DatabaseAccessAttribute.cs @@ -0,0 +1,9 @@ +using System; + +namespace AntMe.English { + /// + /// Attribute to request access to database. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class DatabaseAccessAttribute : AccessAttribute {} +} \ No newline at end of file diff --git a/SimulationCore/English/FileAccessAttribute.cs b/SimulationCore/English/FileAccessAttribute.cs new file mode 100644 index 0000000..5986300 --- /dev/null +++ b/SimulationCore/English/FileAccessAttribute.cs @@ -0,0 +1,9 @@ +using System; + +namespace AntMe.English { + /// + /// Attribute to request fileaccess. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class FileAccessAttribute : AccessAttribute {} +} \ No newline at end of file diff --git a/SimulationCore/English/Food.cs b/SimulationCore/English/Food.cs new file mode 100644 index 0000000..452e7ba --- /dev/null +++ b/SimulationCore/English/Food.cs @@ -0,0 +1,24 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Its the interface for all kind of food + /// + public abstract class Food : Item { + internal Food(CoreFood food) : base(food) {} + + /// + /// Returns the amount of food + /// + public int Amount { + get { return ((CoreFood) Baseitem).Menge; } + } + + /// + /// Delivers the unique Id of this food + /// + public override int Id { + get { return ((CoreFood) Baseitem).Id; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/English/Fruit.cs b/SimulationCore/English/Fruit.cs new file mode 100644 index 0000000..4150560 --- /dev/null +++ b/SimulationCore/English/Fruit.cs @@ -0,0 +1,10 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Represents Fruit + /// + public sealed class Fruit : Food { + internal Fruit(CoreFruit fruit) : base(fruit) {} + } +} \ No newline at end of file diff --git a/SimulationCore/English/Insect.cs b/SimulationCore/English/Insect.cs new file mode 100644 index 0000000..14503d7 --- /dev/null +++ b/SimulationCore/English/Insect.cs @@ -0,0 +1,87 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Its the interface for all lifeforms on playground + /// + public abstract class Insect : Item { + internal Insect(CoreInsect insekt) : base(insekt) {} + + /// + /// Returns the unique ID of this insect + /// + public override int Id { + get { return ((CoreInsect) Baseitem).id; } + } + + /// + /// Delivers the current energy of this ant + /// + public int CurrentEnergy { + get { return ((CoreInsect) Baseitem).AktuelleEnergieBase; } + } + + /// + /// Delivers the current speed + /// + public int CurrentSpeed { + get { return ((CoreInsect)Baseitem).AktuelleGeschwindigkeitBase; } + } + + /// + /// Delivers the strength + /// + public int AttackStrength { + get { return ((CoreInsect)Baseitem).AngriffBase; } + } + + /// + /// Delivers the rotationspeed + /// + public int RotationSpeed { + get { return ((CoreInsect)Baseitem).DrehgeschwindigkeitBase; } + } + + /// + /// delivers the maximum energy + /// + public int MaximumEnergy { + get { return ((CoreInsect)Baseitem).MaximaleEnergieBase; } + } + + /// + /// delivers the maximum speed + /// + public int MaximumSpeed { + get { return ((CoreInsect)Baseitem).MaximaleGeschwindigkeitBase; } + } + + /// + /// delivers the viewrange + /// + public int Viewrange { + get { return ((CoreInsect)Baseitem).SichtweiteBase; } + } + + /// + /// delivers the degrees to rotate + /// + public int DegreesToTarget { + get { return ((CoreInsect)Baseitem).RestWinkelBase; } + } + + /// + /// delivers the direction + /// + public int Direction { + get { return ((CoreInsect)Baseitem).RichtungBase; } + } + + /// + /// delivers the distance to go + /// + public int DistanceToTarget { + get { return ((CoreInsect)Baseitem).RestStreckeBase; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/English/Item.cs b/SimulationCore/English/Item.cs new file mode 100644 index 0000000..bef6d19 --- /dev/null +++ b/SimulationCore/English/Item.cs @@ -0,0 +1,90 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Baseclass for all items on playground + /// + public abstract class Item { + /// + /// Saves the reference to the original simulation-object + /// + private readonly ICoordinate item; + + internal Item(ICoordinate item) { + this.item = item; + } + + /// + /// Delivers the base-item + /// + internal ICoordinate Baseitem { + get { return item; } + } + + /// + /// Gives the unique ID of this item + /// + public abstract int Id { get; } + + #region Comparation + + /// + /// Delivers a unique code for that item + /// + /// unique Code + public override int GetHashCode() { + return Id; + } + + /// + /// Vergleich zwischen zwei Objekten + /// + /// Vergleichsobjekt + /// beide meinen das gleiche Element + public override bool Equals(object obj) { + if (obj == null) + return false; + + if (obj.GetType() == GetType()) { + return obj.GetHashCode() == GetHashCode(); + } + return false; + } + + /// + /// operator == + /// + /// + /// + /// + public static bool operator ==(Item a, Item b) { + // check, if both items are null + if ((object) a == null) { + if ((object) b == null) { + return true; + } + return false; + } + + // check, if b is null + if ((object) b == null) { + return false; + } + + // both are instances - check if equal + return a.Equals(b); + } + + /// + /// operator != + /// + /// + /// + /// + public static bool operator !=(Item a, Item b) { + return !(a==b); + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/English/KindOfDeath.cs b/SimulationCore/English/KindOfDeath.cs new file mode 100644 index 0000000..6392377 --- /dev/null +++ b/SimulationCore/English/KindOfDeath.cs @@ -0,0 +1,21 @@ +namespace AntMe.English { + /// + /// List of possible kinds of death + /// + public enum KindOfDeath { + /// + /// The ant was running out of food + /// + Starved = 1, + + /// + /// The ant was eaten up by a bug + /// + Eaten = 2, + + /// + /// The ant was killed by a foreign ant + /// + Beaten = 4 + } +} \ No newline at end of file diff --git a/SimulationCore/English/Marker.cs b/SimulationCore/English/Marker.cs new file mode 100644 index 0000000..38fdc76 --- /dev/null +++ b/SimulationCore/English/Marker.cs @@ -0,0 +1,24 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Represents a marker + /// + public sealed class Marker : Item { + internal Marker(CoreMarker markierung) : base(markierung) {} + + /// + /// Gives the information saved in that mark + /// + public int Information { + get { return ((CoreMarker)Baseitem).Information; } + } + + /// + /// Delivers the unique ID of this marker + /// + public override int Id { + get { return ((CoreMarker)Baseitem).Id; } + } + } +} \ No newline at end of file diff --git a/SimulationCore/English/NetworkAccessAttribute.cs b/SimulationCore/English/NetworkAccessAttribute.cs new file mode 100644 index 0000000..217267e --- /dev/null +++ b/SimulationCore/English/NetworkAccessAttribute.cs @@ -0,0 +1,9 @@ +using System; + +namespace AntMe.English { + /// + /// Attribute to request access to network. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class NetworkAccessAttribute : AccessAttribute {} +} \ No newline at end of file diff --git a/SimulationCore/English/PlayerAttribute.cs b/SimulationCore/English/PlayerAttribute.cs new file mode 100644 index 0000000..bd93600 --- /dev/null +++ b/SimulationCore/English/PlayerAttribute.cs @@ -0,0 +1,24 @@ +using System; + +namespace AntMe.English { + /// + /// Attribute to descripe an ant + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class PlayerAttribute : Attribute { + /// + /// First name of the player + /// + public string FirstName = string.Empty; + + /// + /// Name of the colony + /// + public string ColonyName = string.Empty; + + /// + /// Last name of the player + /// + public string LastName = string.Empty; + } +} \ No newline at end of file diff --git a/SimulationCore/English/RandomNumber.cs b/SimulationCore/English/RandomNumber.cs new file mode 100644 index 0000000..08cea8a --- /dev/null +++ b/SimulationCore/English/RandomNumber.cs @@ -0,0 +1,30 @@ +namespace AntMe.English { + /// + /// Helper-class to generate some random numbers + /// + public static class RandomNumber { + private static readonly System.Random random = new System.Random(); + + /// + /// Gives a random number between 0 and the given maximum + /// + /// maximum + /// random number + public static int Number(int maximum) { + return random.Next(maximum); + } + + /// + /// Gives a random number between the given minimum and the given maximum + /// + /// minimum + /// maximum + /// random number + public static int Number(int minimum, int maximum) { + if (minimum > maximum) { + random.Next(maximum, minimum); + } + return random.Next(minimum, maximum); + } + } +} \ No newline at end of file diff --git a/SimulationCore/English/Sugar.cs b/SimulationCore/English/Sugar.cs new file mode 100644 index 0000000..ffea872 --- /dev/null +++ b/SimulationCore/English/Sugar.cs @@ -0,0 +1,10 @@ +using AntMe.Simulation; + +namespace AntMe.English { + /// + /// Represents a sugarhill + /// + public sealed class Sugar : Food { + internal Sugar(CoreSugar zucker) : base(zucker) {} + } +} \ No newline at end of file diff --git a/SimulationCore/English/UserinterfaceAccessAttribute.cs b/SimulationCore/English/UserinterfaceAccessAttribute.cs new file mode 100644 index 0000000..fc8cb9d --- /dev/null +++ b/SimulationCore/English/UserinterfaceAccessAttribute.cs @@ -0,0 +1,9 @@ +using System; + +namespace AntMe.English { + /// + /// Attribute to request access to the userinterface. + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] + public sealed class UserinterfaceAccessAttribute : AccessAttribute {} +} \ No newline at end of file diff --git a/SimulationCore/Properties/AssemblyInfo.cs b/SimulationCore/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..7765322 --- /dev/null +++ b/SimulationCore/Properties/AssemblyInfo.cs @@ -0,0 +1,45 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. + +[assembly: AssemblyTitle("AntMe! Simulation Core")] +[assembly: AssemblyDescription("")] +[assembly : AssemblyConfiguration("")] +[assembly: AssemblyCompany("AntMe! GmbH")] +[assembly : AssemblyProduct("AntMe!")] +[assembly: AssemblyCopyright("Copyright © 2014 AntMe! GmbH")] +[assembly: AssemblyTrademark("AntMe!")] +[assembly : AssemblyCulture("")] +[assembly : AllowPartiallyTrustedCallers] +//[assembly: +// InternalsVisibleTo( +// "AntMe.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001000f5bb66b6a593b52d3188920c2ae2f9f539c2f2108e84ef10551fb28fba1db6c7faf83a93a29dde43588bed0832bcb1e1371f3830525b4a862dd4d6d59afc521509736af1e63c276743c4b6e74193a1fe47f03389ae0d3f6b16654b887ccd227b959f84d378ec4b94d399ec4cdfdfa56a8cb46835770e1ab69a77f1aadb2e9b3" +// )] + +// 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("6afb3124-e1de-4b6d-b9c6-966c47cd2abc")] + +// 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 Revision and Build Numbers +// by using the '*' as shown below: + +[assembly: AssemblyVersion("1.7.1.129")] +[assembly: AssemblyFileVersion("1.7.1.129")] \ No newline at end of file diff --git a/SimulationCore/Properties/Settings.Designer.cs b/SimulationCore/Properties/Settings.Designer.cs new file mode 100644 index 0000000..7a85ddc --- /dev/null +++ b/SimulationCore/Properties/Settings.Designer.cs @@ -0,0 +1,26 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "12.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; + } + } + } +} diff --git a/SimulationCore/Properties/Settings.settings b/SimulationCore/Properties/Settings.settings new file mode 100644 index 0000000..8e615f2 --- /dev/null +++ b/SimulationCore/Properties/Settings.settings @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/SimulationCore/Resource.Designer.cs b/SimulationCore/Resource.Designer.cs new file mode 100644 index 0000000..2c0bcbc --- /dev/null +++ b/SimulationCore/Resource.Designer.cs @@ -0,0 +1,459 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe { + 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 Resource { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resource() { + } + + /// + /// 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("AntMe.Resource", typeof(Resource).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; + } + } + + /// + /// Looks up a localized string similar to Standard. + /// + internal static string SettingsDefaultName { + get { + return ResourceManager.GetString("SettingsDefaultName", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Attempt to cheat with a fake Framework assembly.. + /// + internal static string SimulationCoreAnalysisCheatWithFxFake { + get { + return ResourceManager.GetString("SimulationCoreAnalysisCheatWithFxFake", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to External reference:. + /// + internal static string SimulationCoreAnalysisForeignRefInfotext { + get { + return ResourceManager.GetString("SimulationCoreAnalysisForeignRefInfotext", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to This ant was likely created with a newer version of AntMe!.. + /// + internal static string SimulationCoreAnalysisNewerVersion { + get { + return ResourceManager.GetString("SimulationCoreAnalysisNewerVersion", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The file does not contain a class with this name.. + /// + internal static string SimulationCoreAnalysisNoClassFound { + get { + return ResourceManager.GetString("SimulationCoreAnalysisNoClassFound", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The ant class that was found ({0}) is not decorated with a PlayerAttribute.. + /// + internal static string SimulationCoreAnalysisNoPlayerAttribute { + get { + return ResourceManager.GetString("SimulationCoreAnalysisNoPlayerAttribute", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Ants of version 1.1 or lower are not supported in this version anymore.. + /// + internal static string SimulationCoreAnalysisNotSupportedAntVersion { + get { + return ResourceManager.GetString("SimulationCoreAnalysisNotSupportedAntVersion", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Attempting to load an earlier ant simulation core (version: {0}) failed.. + /// + internal static string SimulationCoreAnalysisOldAssemblyLoadFailed { + get { + return ResourceManager.GetString("SimulationCoreAnalysisOldAssemblyLoadFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The ant class {0} containas more than one PlayerAttribute.. + /// + internal static string SimulationCoreAnalysisTooManyPlayerAttributes { + get { + return ResourceManager.GetString("SimulationCoreAnalysisTooManyPlayerAttributes", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The external reference '{0}' could not be loaded.. + /// + internal static string SimulationCoreAnalysisUnknownReferenceLoadFailed { + get { + return ResourceManager.GetString("SimulationCoreAnalysisUnknownReferenceLoadFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The ant could not be assigned a version. {0}. + /// + internal static string SimulationCoreAnalysisUnknownVersion { + get { + return ResourceManager.GetString("SimulationCoreAnalysisUnknownVersion", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The attack-modificator of caste {0} of ant {1} is invalid.. + /// + internal static string SimulationCoreCasteRuleAttackFailed { + get { + return ResourceManager.GetString("SimulationCoreCasteRuleAttackFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The energy-modificator of caste {0} of ant {1} is invalid.. + /// + internal static string SimulationCoreCasteRuleEnergyFailed { + get { + return ResourceManager.GetString("SimulationCoreCasteRuleEnergyFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The load-modificator of caste {0} of ant {1} is invalid.. + /// + internal static string SimulationCoreCasteRuleLoadFailed { + get { + return ResourceManager.GetString("SimulationCoreCasteRuleLoadFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The caste-attribute of ant {0} does not contain a name.. + /// + internal static string SimulationCoreCasteRuleNoName { + get { + return ResourceManager.GetString("SimulationCoreCasteRuleNoName", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The reach-modificator of caste {0} of ant {1} is invalid.. + /// + internal static string SimulationCoreCasteRuleRangeFailed { + get { + return ResourceManager.GetString("SimulationCoreCasteRuleRangeFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The rotationspeed-modificator of caste {0} of ant {1}is invalid.. + /// + internal static string SimulationCoreCasteRuleRotationSpeedFailed { + get { + return ResourceManager.GetString("SimulationCoreCasteRuleRotationSpeedFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The speed-modificator of caste {0} of ant {1} is invalid.. + /// + internal static string SimulationCoreCasteRuleSpeedFailed { + get { + return ResourceManager.GetString("SimulationCoreCasteRuleSpeedFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The sum of modificators of caste {0} of player {1} are invalid.. + /// + internal static string SimulationCoreCasteRuleSumFailed { + get { + return ResourceManager.GetString("SimulationCoreCasteRuleSumFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The viewrange-modificator of caste {0} of ant {1} is invalid.. + /// + internal static string SimulationCoreCasteRuleViewRangeFailed { + get { + return ResourceManager.GetString("SimulationCoreCasteRuleViewRangeFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The desired caste for the new ant '{0}' doesn't exist.. + /// + internal static string SimulationCoreChooseWrongCaste { + get { + return ResourceManager.GetString("SimulationCoreChooseWrongCaste", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The loop count cannot be greater than {0}.. + /// + internal static string SimulationCoreConfigurationLoopCountTooBig { + get { + return ResourceManager.GetString("SimulationCoreConfigurationLoopCountTooBig", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The minimum loop count is 1.. + /// + internal static string SimulationCoreConfigurationLoopCountTooSmall { + get { + return ResourceManager.GetString("SimulationCoreConfigurationLoopCountTooSmall", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The timeout value for a loop cannot be less than 1.. + /// + internal static string SimulationCoreConfigurationLoopTimeoutTooSmall { + get { + return ResourceManager.GetString("SimulationCoreConfigurationLoopTimeoutTooSmall", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to At least one team must be selected for the simulation.. + /// + internal static string SimulationCoreConfigurationNoTeams { + get { + return ResourceManager.GetString("SimulationCoreConfigurationNoTeams", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The round count must not exceed {0}.. + /// + internal static string SimulationCoreConfigurationRoundCountTooBig { + get { + return ResourceManager.GetString("SimulationCoreConfigurationRoundCountTooBig", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The minimum round count is 1.. + /// + internal static string SimulationCoreConfigurationRoundCountTooSmall { + get { + return ResourceManager.GetString("SimulationCoreConfigurationRoundCountTooSmall", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The timeout value for a round cannot be less than 1.. + /// + internal static string SimulationCoreConfigurationRoundTimeoutTooSmall { + get { + return ResourceManager.GetString("SimulationCoreConfigurationRoundTimeoutTooSmall", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The parameter configuration must not be null.. + /// + internal static string SimulationCoreFactoryConfigIsNull { + get { + return ResourceManager.GetString("SimulationCoreFactoryConfigIsNull", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The environment has not yet been initialized.. + /// + internal static string SimulationCoreHostEnvironmentNotInit { + get { + return ResourceManager.GetString("SimulationCoreHostEnvironmentNotInit", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The timeout for a round has been exceeded.. + /// + internal static string SimulationCoreHostRoundTimeout { + get { + return ResourceManager.GetString("SimulationCoreHostRoundTimeout", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The configuration may only contain PlayerInfoFileName or PlayerInfoFileDump.. + /// + internal static string SimulationCoreHostWrongPlayerInfo { + get { + return ResourceManager.GetString("SimulationCoreHostWrongPlayerInfo", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to It's not possible to create marker with size smaller than 0. + /// + internal static string SimulationCoreNegativeMarkerSize { + get { + return ResourceManager.GetString("SimulationCoreNegativeMarkerSize", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The PlayerAttribute of class {0} does not contain a name.. + /// + internal static string SimulationCorePlayerRuleNoName { + get { + return ResourceManager.GetString("SimulationCorePlayerRuleNoName", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The simulation has already been unloaded.. + /// + internal static string SimulationCoreProxyUnloaded { + get { + return ResourceManager.GetString("SimulationCoreProxyUnloaded", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The configuration may only contain PlayerInfoFileName or PlayerInfoFileDump.. + /// + internal static string SimulationCoreProxyWrongPlayerInfo { + get { + return ResourceManager.GetString("SimulationCoreProxyWrongPlayerInfo", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There are no rights to grand database-access to various colonies.. + /// + internal static string SimulationCoreRightsConflictDb { + get { + return ResourceManager.GetString("SimulationCoreRightsConflictDb", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There are no rights to grand file-access to various colonies.. + /// + internal static string SimulationCoreRightsConflictIo { + get { + return ResourceManager.GetString("SimulationCoreRightsConflictIo", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There are no rights to grand network-access to various colonies.. + /// + internal static string SimulationCoreRightsConflictNet { + get { + return ResourceManager.GetString("SimulationCoreRightsConflictNet", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There are no rights to grand userinterface-access to various colonies.. + /// + internal static string SimulationCoreRightsConflictUi { + get { + return ResourceManager.GetString("SimulationCoreRightsConflictUi", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The index of the caste column is too large.. + /// + internal static string SimulationCoreSettingsCasteColumnToBig { + get { + return ResourceManager.GetString("SimulationCoreSettingsCasteColumnToBig", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The index of the caste column is too small.. + /// + internal static string SimulationCoreSettingsCasteColumnToSmall { + get { + return ResourceManager.GetString("SimulationCoreSettingsCasteColumnToSmall", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Cannot call Step() on a simulation that has already completed.. + /// + internal static string SimulationCoreSimulatorRestartFailed { + get { + return ResourceManager.GetString("SimulationCoreSimulatorRestartFailed", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The list of players of a team may not be empty.. + /// + internal static string SimulationCoreTeamInfoNoName { + get { + return ResourceManager.GetString("SimulationCoreTeamInfoNoName", resourceCulture); + } + } + } +} diff --git a/SimulationCore/Resource.de.resx b/SimulationCore/Resource.de.resx new file mode 100644 index 0000000..74c6b05 --- /dev/null +++ b/SimulationCore/Resource.de.resx @@ -0,0 +1,297 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Standard + default name of default-SimulationSettings (SimulationSettings.cs) + + + Cheatversuch mit gefälschter Framework-Assembly + If the analyzer detects a fake of framework-assemblies with wrong public key (AnalysisHost.cs, 100) + + + Fremdreferenz: + would be used to list foreign libs in a clear readable text (AnalysisHost.cs, 150) + + + Diese Ameise wurde vermutlich mit einer neueren Version von AntMe! erstellt + If the analyser detects an ant with references to newer core-versions (AnalysisHost.cs, 129) + + + Die Datei enthält keine Klasse mit diesem Namen + If the method to find specific player-class in assembly can not found the right class (AiAnalysis.cs, 102 & 123) + + + Die gefundene Ameisenklasse {0} verfügt nicht über ein SpielerAttribut + if there is a playerclass without a needed playerattribute (AnalysisHost.cs, 324 & 422) + + + Ameisen der Version 1.1 oder kleiner werden in dieser Version nicht mehr unterstützt. + if the analizer detects an ant with version 1.1 or lesser (AnalysisHost.cs, 108) + + + Der Versuch, eine ältere Ameisensimulation (Version: {0}) zu laden ist fehlgeschlagen. + If the analyser couldn't find the needed simulationcore for older ant-versions. (AnalysisHost.cs, 119) + + + Die gefundene Ameisenklasse {0} verfügt über mehr als nur ein Spielerattribut + if there is a playerclass with too many playerattributes (AnalysisHost.cs, 333 & 431) + + + Die Fremdreferenz '{0}' konnte nicht geladen werden + if the foreign reference is not loadable (AnalysisHost.cs, 147) + + + Die Ameise konnte keiner Version zugewiesen werden. {0} + if the analyser couldn't find out the ant-version. (AnalysisHost.cs, 132 & 137) + + + Der AngriffModifikator der Kaste {0} der Ameise {1} ist ungültig. + if a checked caste has wrong attackmodificator (CasteInfo.cs, 122) + + + Der EnergieModifikator der Kaste {0} der Ameise {1} ist ungültig. + if a checked caste has wrong energymodificator (CasteInfo.cs, 115) + + + Der LastModifikator der Kaste {0} der Ameise {1} ist ungültig. + if a checked caste has wrong loadmodificator (CasteInfo.cs, 92) + + + Ein Kaste-Attribut der Ameise {0} gibt keinen Namen an. + if a checked caste has no name (CasteInfo.cs, 67) + + + Der ReichweiteModifikator der Kaste {0} der Ameise {1} ist ungültig. + if a checked caste has wrong rangemodificator (CasteInfo.cs, 108) + + + Der DrehgeschwindigkeitModifikator der Kaste {0} der Ameise {1} ist ungültig. + if a checked caste has wrong rotationspeedmodificator (CasteInfo.cs, 83) + + + Der GeschwindigkeitModifikator der Kaste {0} der Ameise {1} ist ungültig. + if a checked caste has wrong speedmodificator (CasteInfo.cs, 75) + + + Die Summe der Modifikatoren der Kaste {0} des Spielers {1} ist ungültig. + if a checked caste has wrong sum (CasteInfo.cs, 134) + + + Der SichtweiteModifikator der Kaste {0} der Ameise {1} ist ungültig. + if a checked caste has wrong viewrangemodificator (CasteInfo.cs, 100) + + + Gewünschte Kaste für die neue Ameise '{0}' existiert nicht + m not existing caste (CoreAnt.cs) +0: Wrong Castename + + + Durchlaufmenge darf maximal {0} betragen + if the simulatorConfig has a too big loopcount(SimulatorConfiguration.cs, 100) + + + Durchlaufmenge muss mindestens 1 betragen + if the simulatorConfig has a too small loopcount(SimulatorConfiguration.cs, 97) + + + Der Timeout-Wert für einen Durchlauf darf nicht kleiner als 1 sein + if the simulatorConfig has a too small looptimeout(SimulatorConfiguration.cs, 109) + + + Es muss mindestens ein Team für die Simulation angegeben werden + if the simulatorConfig has no teams (SimulatorConfiguration.cs, 120) + + + Rundenanzahl darf maximal {0} betragen + if the simulatorConfig has a too big roundcount(SimulatorConfiguration.cs, 92) + + + Rundenanzahl muss mindestens 1 betragen + if the simulatorConfig has a too small roundcount (SimulatorConfiguration.cs, 89) + + + Der Timeout-Wert für eine Runde darf nicht kleiner als 1 sein + if the simulatorConfig has a too small roundtimeout(SimulatorConfiguration.cs, 113) + + + Der Parameter Konfiguration darf nicht null sein + if the config-parameter of factory is null (SimulatorFactory.cs, 13) + + + Die Spielumgebung wurde noch nicht initialisiert + if the environment was not initialized before called step (SimulatorHost.cs, 122) + + + Die maximale Arbeitszeit für eine Runde wurde überschritten + if there was a round-timeout in simulation (SimulatorHost.cs, 149) + + + Konfiguration darf nur SpielerInfoDateiname oder SpielerInfoDateikopie enthalten + if there is a wrong type of playerinfo in playerlist (SimulatorHost.cs, 84) + + + Die Ausbreitungsgröße der Markierung darf nicht kleiner 0 sein + Exceptionmessage for negative markersize (CoreInsect.cs) + + + Das Spieler-Attribut der Klasse {0} gibt keinen Namen an. + if playerInfo has no name (PlayerInfo.cs, 214) + + + Die Simulation wurde bereits entladen. + if step was called after unload. (SimulatorProxy.cs, 123) + + + Konfiguration darf nur SpielerInfoDateiname oder SpielerInfoDateikopie enthalten + if the config holds wrong PlayerInfos (SimulatorProxy.cs, 63) + + + Es fehlen die nötigen Rechte um einem Ameisenvolk Datenbankzugriffsrechte zu gewähren. + if colony request rights without the needed rights in config (SimulatorProxy.cs) + + + Es fehlen die nötigen Rechte um einem Ameisenvolk Dateizugriffsrechte zu gewähren. + if colony request rights without the needed rights in config (SimulatorProxy.cs) + + + Es fehlen die nötigen Rechte um einem Ameisenvolk Netzwerkzugriffsrechte zu gewähren. + if colony request rights without the needed rights in config (SimulatorProxy.cs) + + + Es fehlen die nötigen Rechte um einem Ameisenvolk Fensterzugriffsrechte zu gewähren. + if colony request rights without the needed rights in config (SimulatorProxy.cs) + + + Der Index der Kasten-Spalte ist zu groß + if there was access to CasteColumns with a too big index (SimulatorCasteSettings.cs, 49) + + + Der Index der Kasten-Spalte ist zu klein + if there was access to CasteColumns with a too small index (SimulatorCasteSettings.cs, 46) + + + Eine Simulation die bereits beendet wurde, darf nicht gesteppt werden. + if a step was called on a finished simulation (Simulator.cs, 133) + + + Menge der Spieler eines Teams darf nicht leer sein + if there is no teamname (TeamInfo.cs, 95) + + \ No newline at end of file diff --git a/SimulationCore/Resource.resx b/SimulationCore/Resource.resx new file mode 100644 index 0000000..e4dad2b --- /dev/null +++ b/SimulationCore/Resource.resx @@ -0,0 +1,297 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Standard + default name of default-SimulationSettings (SimulationSettings.cs) + + + Attempt to cheat with a fake Framework assembly. + If the analyzer detects a fake of framework-assemblies with wrong public key (AnalysisHost.cs, 100) + + + External reference: + would be used to list foreign libs in a clear readable text (AnalysisHost.cs, 150) + + + This ant was likely created with a newer version of AntMe!. + If the analyser detects an ant with references to newer core-versions (AnalysisHost.cs, 129) + + + The file does not contain a class with this name. + If the method to find specific player-class in assembly could not find the right class (AiAnalysis.cs, 102 & 123) + + + The ant class that was found ({0}) is not decorated with a PlayerAttribute. + if there is a playerclass without a needed playerattribute (AnalysisHost.cs, 324 & 422) + + + Ants of version 1.1 or lower are not supported in this version anymore. + if the analizer detects an ant with version 1.1 or lower (AnalysisHost.cs, 108) + + + Attempting to load an earlier ant simulation core (version: {0}) failed. + If the analyser couldn't find the needed simulationcore for older ant-versions. (AnalysisHost.cs, 119) + + + The ant class {0} containas more than one PlayerAttribute. + if there is a playerclass with too many playerattributes (AnalysisHost.cs, 333 & 431) + + + The external reference '{0}' could not be loaded. + if the foreign reference is not loadable (AnalysisHost.cs, 147) + + + The ant could not be assigned a version. {0} + if the analyser couldn't find out the ant-version. (AnalysisHost.cs, 132 & 137) + + + The attack-modificator of caste {0} of ant {1} is invalid. + if a checked caste has wrong attackmodificator (CasteInfo.cs, 122) + + + The energy-modificator of caste {0} of ant {1} is invalid. + if a checked caste has wrong energymodificator (CasteInfo.cs, 115) + + + The load-modificator of caste {0} of ant {1} is invalid. + if a checked caste has wrong loadmodificator (CasteInfo.cs, 92) + + + The caste-attribute of ant {0} does not contain a name. + if a checked caste has no name (CasteInfo.cs, 67) + + + The reach-modificator of caste {0} of ant {1} is invalid. + if a checked caste has wrong rangemodificator (CasteInfo.cs, 108) + + + The rotationspeed-modificator of caste {0} of ant {1}is invalid. + if a checked caste has wrong rotationspeedmodificator (CasteInfo.cs, 83) + + + The speed-modificator of caste {0} of ant {1} is invalid. + if a checked caste has wrong speedmodificator (CasteInfo.cs, 75) + + + The sum of modificators of caste {0} of player {1} are invalid. + if a checked caste has wrong sum (CasteInfo.cs, 134) + + + The viewrange-modificator of caste {0} of ant {1} is invalid. + if a checked caste has wrong viewrangemodificator (CasteInfo.cs, 100) + + + The desired caste for the new ant '{0}' doesn't exist. + m not existing caste (CoreAnt.cs) +0: Wrong Castename + + + The loop count cannot be greater than {0}. + if the simulatorConfig has a too big loopcount(SimulatorConfiguration.cs, 100) + + + The minimum loop count is 1. + if the simulatorConfig has a too small loopcount(SimulatorConfiguration.cs, 97) + + + The timeout value for a loop cannot be less than 1. + if the simulatorConfig has a too small looptimeout(SimulatorConfiguration.cs, 109) + + + At least one team must be selected for the simulation. + if the simulatorConfig has no teams (SimulatorConfiguration.cs, 120) + + + The round count must not exceed {0}. + if the simulatorConfig has a too big roundcount(SimulatorConfiguration.cs, 92) + + + The minimum round count is 1. + if the simulatorConfig has a too small roundcount (SimulatorConfiguration.cs, 89) + + + The timeout value for a round cannot be less than 1. + if the simulatorConfig has a too small roundtimeout(SimulatorConfiguration.cs, 113) + + + The parameter configuration must not be null. + if the config-parameter of factory is null (SimulatorFactory.cs, 13) + + + The environment has not yet been initialized. + if the environment was not initialized before called step (SimulatorHost.cs, 122) + + + The timeout for a round has been exceeded. + if there was a round-timeout in simulation (SimulatorHost.cs, 149) + + + The configuration may only contain PlayerInfoFileName or PlayerInfoFileDump. + if there is a wrong type of playerinfo in playerlist (SimulatorHost.cs, 84) + + + It's not possible to create marker with size smaller than 0 + Exceptionmessage for negative markersize (CoreInsect.cs) + + + The PlayerAttribute of class {0} does not contain a name. + if playerInfo has no name (PlayerInfo.cs, 214) + + + The simulation has already been unloaded. + if step was called after unload. (SimulatorProxy.cs, 123) + + + The configuration may only contain PlayerInfoFileName or PlayerInfoFileDump. + if the config holds wrong PlayerInfos (SimulatorProxy.cs, 63) + + + There are no rights to grand database-access to various colonies. + if colony request rights without the needed rights in config (SimulatorProxy.cs) + + + There are no rights to grand file-access to various colonies. + if colony request rights without the needed rights in config (SimulatorProxy.cs) + + + There are no rights to grand network-access to various colonies. + if colony request rights without the needed rights in config (SimulatorProxy.cs) + + + There are no rights to grand userinterface-access to various colonies. + if colony request rights without the needed rights in config (SimulatorProxy.cs) + + + The index of the caste column is too large. + if there was access to CasteColumns with a too big index (SimulatorCasteSettings.cs, 49) + + + The index of the caste column is too small. + if there was access to CasteColumns with a too small index (SimulatorCasteSettings.cs, 46) + + + Cannot call Step() on a simulation that has already completed. + if a step was called on a finished simulation (Simulator.cs, 133) + + + The list of players of a team may not be empty. + if there is no teamname (TeamInfo.cs, 95) + + \ No newline at end of file diff --git a/SimulationCore/Simulation/AiAnalysis.cs b/SimulationCore/Simulation/AiAnalysis.cs new file mode 100644 index 0000000..eeea245 --- /dev/null +++ b/SimulationCore/Simulation/AiAnalysis.cs @@ -0,0 +1,198 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using System.Security; +using System.Security.Permissions; +using System.Security.Policy; + +namespace AntMe.Simulation +{ + /// + /// Class, to extract PlayerInfos from given Ai-Assembly. + /// + /// Tom Wendel (tom@antme.net) + public static class AiAnalysis + { + #region public, static Methods + + /// + /// Analyzes a Ai-File based on filename. + /// + /// Ai-File to analyze. + /// List of found PlayerInfos + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + public static List Analyse(string filename) + { + return Analyse(filename, true); + } + + /// + /// Analyzes a Ai-File based on filename. + /// + /// Ai-File to analyze. + /// True, if Analyser should also check player-rules. + /// List of found PlayerInfos + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + public static List Analyse(string filename, bool checkRules) + { + return Analyse(File.ReadAllBytes(filename), checkRules); + } + + /// + /// Analyzes a Ai-File based on binary file-dump. + /// + /// Ai-File to analyze. + /// List of found PlayerInfos + /// + /// + /// + /// + /// + public static List Analyse(byte[] file) + { + return Analyse(file, true); + } + + /// + /// Analyzes a Ai-File based on binary file-dump. + /// + /// Ai-File to analyze. + /// True, if Analyser should also check player-rules. + /// List of found PlayerInfos + /// + /// + /// + /// + /// + public static List Analyse(byte[] file, bool checkRules) + { + // setup appdomain + AppDomainSetup setup = new AppDomainSetup(); + setup.ApplicationBase = ".\\"; + + // setup accessrights for the appdomain + PermissionSet rechte = new PermissionSet(PermissionState.None); + rechte.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution)); + rechte.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess)); + + // create appdomain and analyse-host + AppDomain app = AppDomain.CreateDomain("AnalysisHost", AppDomain.CurrentDomain.Evidence, setup, rechte); + //app.ReflectionOnlyAssemblyResolve += + // delegate(object sender, ResolveEventArgs args) { return Assembly.ReflectionOnlyLoad(args.Name); }; + + AnalysisHost host = + (AnalysisHost) + app.CreateInstanceAndUnwrap( + Assembly.GetExecutingAssembly().FullName, "AntMe.Simulation.AnalysisHost"); + List spieler = host.Analyse(file, checkRules); + + // in case of exceptions unload the appdomain and throw the exception + if (spieler == null) + { + Exception ex = host.Exception; + AppDomain.Unload(app); + throw ex; + } + + // unload appdomain + AppDomain.Unload(app); + + // return list of PlayerInfo + return spieler; + } + + /// + /// Find a specific Player-information in given Ai-File. + /// + /// File as binary file-dump + /// Class-name of Ai + /// the right + /// + public static PlayerInfoFiledump FindPlayerInformation(byte[] file, string className) + { + // load all included players + List foundPlayers = Analyse(file); + + // If there is no classname, just take the only one + if (className == string.Empty) + { + if (foundPlayers.Count == 1) + { + return new PlayerInfoFiledump(foundPlayers[0], file); + } + throw new InvalidOperationException(Resource.SimulationCoreAnalysisNoClassFound); + } + + // search for needed classname + foreach (PlayerInfo player in foundPlayers) + { + if (player.ClassName == className) + { + return new PlayerInfoFiledump(player, file); + } + } + + // Exception, if there was no hit + throw new InvalidOperationException(Resource.SimulationCoreAnalysisNoClassFound); + } + + /// + /// Find a specific in given Ai-File. + /// + /// File as filename + /// Class-name of Ai + /// the right or null for no hits + public static PlayerInfoFilename FindPlayerInformation(string file, string className) + { + // load all included players + List foundPlayer = Analyse(file); + + // If there is no classname, just take the only one + if (className == string.Empty) + { + if (foundPlayer.Count == 1) + { + return new PlayerInfoFilename(foundPlayer[0], file); + } + throw new InvalidOperationException(Resource.SimulationCoreAnalysisNoClassFound); + } + + // search for needed classname + foreach (PlayerInfo player in foundPlayer) + { + if (player.ClassName == className) + { + return new PlayerInfoFilename(player, file); + } + } + + // Exception, if there was no hit + throw new InvalidOperationException(Resource.SimulationCoreAnalysisNoClassFound); + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/AiException.cs b/SimulationCore/Simulation/AiException.cs new file mode 100644 index 0000000..cc095cb --- /dev/null +++ b/SimulationCore/Simulation/AiException.cs @@ -0,0 +1,37 @@ +using System; +using System.Runtime.Serialization; + +using AntMe.SharedComponents; + +namespace AntMe.Simulation { + /// + /// Exception for implementation-Problems in player-ai-files. + /// + [Serializable] + internal class AiException : AntMeException { + /// + /// KOnstruktor der Regelverletzung ohne weitere Angaben + /// + public AiException() {} + + /// + /// Konsruktor der Regelverletzung mit der Ãœbergabe einer Beschreibung zur Verletzung + /// + /// Beschreibung der Regelverletzung + public AiException(string message) : base(message) {} + + /// + /// Konstruktor zur Regelverletung mit übergabe einer Nachricht sowie einer verursachenden Exception + /// + /// Beschreibung zum Problem + /// Verursachende Exception + public AiException(string message, Exception innerException) : base(message, innerException) {} + + /// + /// Konstruktor für die Serialisierung dieser Exception + /// + /// + /// + public AiException(SerializationInfo info, StreamingContext context) : base(info, context) {} + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/AnalysisHost.cs b/SimulationCore/Simulation/AnalysisHost.cs new file mode 100644 index 0000000..06bfc4d --- /dev/null +++ b/SimulationCore/Simulation/AnalysisHost.cs @@ -0,0 +1,592 @@ +using System; +using System.Collections.Generic; +using System.Reflection; + +namespace AntMe.Simulation +{ + /// + /// Host-Class for Ai-Analysis to host the analyze-core inside application-domains. + /// + internal sealed class AnalysisHost : MarshalByRefObject + { + #region local Variables + + /// + /// Type of baseAnt from core. + /// + private Type coreAnt; + + /// + /// Holds all thrown exceptions. + /// + private Exception exception; + + /// + /// List of all Ant-BaseClasses in every known language. + /// + private Dictionary languageBases; + + #endregion + + #region public Methods + + /// + /// Sets special simulation-settings. + /// + /// special settings + public void InitSettings(SimulationSettings settings) + { + SimulationSettings.SetCustomSettings(settings); + } + + /// + /// Searches in the given file for possible PlayerInfos and delivers a list of found Players. + /// + /// Ai-File as binary file-dump. + /// True, if Analyzer should also check player-rules + /// List of found players. + public List Analyse(byte[] file, bool checkRules) + { + try + { + // load base-class from Simulation-Core. + Assembly simulation = Assembly.Load(Assembly.GetExecutingAssembly().FullName); + coreAnt = simulation.GetType("AntMe.Simulation.CoreAnt"); + + // load all base-classes of different languages + languageBases = new Dictionary(); + languageBases.Add( + PlayerLanguages.Deutsch, + simulation.GetType("AntMe.Deutsch.Basisameise")); + languageBases.Add( + PlayerLanguages.English, + simulation.GetType("AntMe.English.BaseAnt")); + + // open Ai-File + exception = null; + Assembly assembly = Assembly.Load(file); + + return analyseAssembly(assembly, checkRules); + } + catch (Exception ex) + { + // problems during analyse - save Exception without throwing and return null + exception = ex; + return null; + } + } + + #endregion + + #region Helpermethods + + /// + /// Analyzes the given for any kind of valid player-information. + /// + /// given assembly. + /// true, if the Analyser should also check player-rules + /// List of valid players. + private List analyseAssembly(Assembly assembly, bool checkRules) + { + // All included players would be marked as static, if one static play is found. + bool staticVariables = false; + + bool foreignReferences = false; + string referenceInformation = string.Empty; + + List players = new List(); + + // filter valid references + AssemblyName[] references = assembly.GetReferencedAssemblies(); + foreach (AssemblyName reference in references) + { + switch (reference.Name) + { + case "mscorlib": + // Framework-Core + byte[] coreschlüssel = new AssemblyName(typeof(object).Assembly.FullName).GetPublicKeyToken(); + byte[] referenzschlüssel = reference.GetPublicKeyToken(); + if (coreschlüssel[0] != referenzschlüssel[0] || + coreschlüssel[1] != referenzschlüssel[1] || + coreschlüssel[2] != referenzschlüssel[2] || + coreschlüssel[3] != referenzschlüssel[3] || + coreschlüssel[4] != referenzschlüssel[4] || + coreschlüssel[5] != referenzschlüssel[5] || + coreschlüssel[6] != referenzschlüssel[6] || + coreschlüssel[7] != referenzschlüssel[7]) + { + throw new RuleViolationException(Resource.SimulationCoreAnalysisCheatWithFxFake); + } + break; + case "Microsoft.VisualBasic": + // TODO: Prüfen, wie wir damit umgehen + break; + case "System": + // TODO: Prüfen, wie wir damit umgehen + break; + case "AntMe.Simulation": + if (Assembly.GetCallingAssembly().FullName != reference.FullName) + throw new RuleViolationException(Resource.SimulationCoreAnalysisNotSupportedAntVersion); + + //if (reference.Version.Major == 1) { + // switch (reference.Version.Minor) { + // case 1: + // // Version 1.1 + // throw new NotSupportedException( + // Resource.SimulationCoreAnalysisNotSupportedAntVersion); + // case 5: + // // Version 1.5 + // try { + // Assembly.ReflectionOnlyLoad("AntMe.Simulation.Ameise"); + // } + // catch (Exception ex) { + // throw new DllNotFoundException( + // string.Format( + // Resource.SimulationCoreAnalysisOldAssemblyLoadFailed, + // reference.Version.ToString(2)), + // ex); + // } + // break; + // case 6: + // if (Assembly.GetCallingAssembly().FullName != reference.FullName) { + // throw new RuleViolationException(Resource.SimulationCoreAnalysisNewerVersion); + // } + // break; + // default: + // // unknown Version + // throw new NotSupportedException( + // string.Format( + // Resource.SimulationCoreAnalysisUnknownVersion, reference.Version.ToString(2))); + // } + //} + //else { + // // unknown Version + // throw new NotSupportedException( + // string.Format( + // Resource.SimulationCoreAnalysisUnknownVersion, reference.Version.ToString(2))); + //} + break; + default: + // load unknown refereneces and add to list + try + { + Assembly.ReflectionOnlyLoad(reference.FullName); + } + catch (Exception ex) + { + throw new DllNotFoundException( + string.Format( + Resource.SimulationCoreAnalysisUnknownReferenceLoadFailed, reference.FullName), + ex); + } + foreignReferences = true; + referenceInformation += reference.FullName + Environment.NewLine; + break; + } + } + + // TODO: Statische Variablen finden + // TODO: Statische Konstruktoren finden - immernoch ein Problem? + // TODO: Nested Types! + + Type[] types = assembly.GetTypes(); + foreach (Type type in types) + { + // Suche nach statischen Variablen und bestimme so, ob der Spieler + // ein globales Gedächtnis für seine Ameisen benutzt. + BindingFlags flags = + BindingFlags.Public | BindingFlags.NonPublic | + BindingFlags.Static | BindingFlags.SetField; + staticVariables |= type.GetFields(flags).Length > 0; + } + + // Gefundene KIs auf Regeln prüfen + // Betrachte alle öffentlichen Typen in der Bibliothek. + foreach (Type type in assembly.GetExportedTypes()) + { + // Prüfe ob der Typ von der Klasse Ameise erbt. + + // Ameisenversion 1.6 + if (type.IsSubclassOf(coreAnt)) + { + // Leerer Spieler-Rumpf + int playerDefinitions = 0; + + PlayerInfo player = new PlayerInfo(); + player.SimulationVersion = PlayerSimulationVersions.Version_1_7; + player.ClassName = type.FullName; + + // Sprache ermitteln + foreach (PlayerLanguages sprache in languageBases.Keys) + { + if (type.IsSubclassOf(languageBases[sprache])) + { + player.Language = sprache; + break; + } + } + // TODO: Vorgehensweise bei unbekannten Sprachen + + // Attribute auslesen + foreach (CustomAttributeData attribute in CustomAttributeData.GetCustomAttributes(type)) + { + // Player-Attribut auslesen + switch (attribute.Constructor.ReflectedType.FullName) + { + case "AntMe.Deutsch.SpielerAttribute": + playerDefinitions++; + foreach (CustomAttributeNamedArgument argument in attribute.NamedArguments) + { + switch (argument.MemberInfo.Name) + { + case "Volkname": + player.ColonyName = (string)argument.TypedValue.Value; + break; + case "Vorname": + player.FirstName = (string)argument.TypedValue.Value; + break; + case "Nachname": + player.LastName = (string)argument.TypedValue.Value; + break; + } + } + break; + case "AntMe.English.PlayerAttribute": + playerDefinitions++; + foreach (CustomAttributeNamedArgument argument in attribute.NamedArguments) + { + switch (argument.MemberInfo.Name) + { + case "ColonyName": + player.ColonyName = (string)argument.TypedValue.Value; + break; + case "FirstName": + player.FirstName = (string)argument.TypedValue.Value; + break; + case "LastName": + player.LastName = (string)argument.TypedValue.Value; + break; + } + } + break; + } + + // Caste-Attribut auslesen + CasteInfo caste = new CasteInfo(); + switch (attribute.Constructor.ReflectedType.FullName) + { + case "AntMe.English.CasteAttribute": + + // englische Kasten + foreach (CustomAttributeNamedArgument argument in attribute.NamedArguments) + { + switch (argument.MemberInfo.Name) + { + case "Name": + caste.Name = (string)argument.TypedValue.Value; + break; + case "SpeedModificator": + caste.Speed = (int)argument.TypedValue.Value; + break; + case "RotationSpeedModificator": + caste.RotationSpeed = (int)argument.TypedValue.Value; + break; + case "LoadModificator": + caste.Load = (int)argument.TypedValue.Value; + break; + case "RangeModificator": + caste.Range = (int)argument.TypedValue.Value; + break; + case "ViewRangeModificator": + caste.ViewRange = (int)argument.TypedValue.Value; + break; + case "EnergyModificator": + caste.Energy = (int)argument.TypedValue.Value; + break; + case "AttackModificator": + caste.Attack = (int)argument.TypedValue.Value; + break; + } + } + + // Bei Individualkasten zur Liste + if (!caste.IsEmpty()) + { + player.Castes.Add(caste); + } + break; + case "AntMe.Deutsch.KasteAttribute": + + // deutsche Kasten + foreach (CustomAttributeNamedArgument argument in attribute.NamedArguments) + { + switch (argument.MemberInfo.Name) + { + case "Name": + caste.Name = (string)argument.TypedValue.Value; + break; + case "GeschwindigkeitModifikator": + caste.Speed = (int)argument.TypedValue.Value; + break; + case "DrehgeschwindigkeitModifikator": + caste.RotationSpeed = (int)argument.TypedValue.Value; + break; + case "LastModifikator": + caste.Load = (int)argument.TypedValue.Value; + break; + case "ReichweiteModifikator": + caste.Range = (int)argument.TypedValue.Value; + break; + case "SichtweiteModifikator": + caste.ViewRange = (int)argument.TypedValue.Value; + break; + case "EnergieModifikator": + caste.Energy = (int)argument.TypedValue.Value; + break; + case "AngriffModifikator": + caste.Attack = (int)argument.TypedValue.Value; + break; + } + } + + // Bei Individualkasten zur Liste + if (!caste.IsEmpty()) + { + player.Castes.Add(caste); + } + break; + } + + // Access-Attributes + bool isAccessAttribute = false; + // TODO: Request-Infos lokalisieren + switch (attribute.Constructor.ReflectedType.FullName) + { + case "AntMe.Deutsch.DateizugriffAttribute": + player.RequestFileAccess = true; + isAccessAttribute = true; + player.RequestInformation += "Dateizugriff:" + Environment.NewLine; + break; + case "AntMe.Deutsch.DatenbankzugriffAttribute": + player.RequestDatabaseAccess = true; + isAccessAttribute = true; + player.RequestInformation += "Datenbankzugriff:" + Environment.NewLine; + break; + case "AntMe.Deutsch.FensterzugriffAttribute": + player.RequestUserInterfaceAccess = true; + isAccessAttribute = true; + player.RequestInformation += "Fensterzugriff:" + Environment.NewLine; + break; + case "AntMe.Deutsch.NetzwerkzugriffAttribute": + player.RequestNetworkAccess = true; + isAccessAttribute = true; + player.RequestInformation += "Netzwerkzugriff:" + Environment.NewLine; + break; + case "AntMe.English.FileAccessAttribute": + player.RequestFileAccess = true; + isAccessAttribute = true; + player.RequestInformation += "Dateizugriff:" + Environment.NewLine; + break; + case "AntMe.English.DatabaseAccessAttribute": + player.RequestDatabaseAccess = true; + isAccessAttribute = true; + player.RequestInformation += "Datenbankzugriff:" + Environment.NewLine; + break; + case "AntMe.English.UserinterfaceAccessAttribute": + player.RequestUserInterfaceAccess = true; + isAccessAttribute = true; + player.RequestInformation += "Fensterzugriff:" + Environment.NewLine; + break; + case "AntMe.English.NetworkAccessAttribute": + player.RequestNetworkAccess = true; + isAccessAttribute = true; + player.RequestInformation += "Netzwerkzugriff:" + Environment.NewLine; + break; + } + + if (isAccessAttribute) + { + foreach (CustomAttributeNamedArgument argument in attribute.NamedArguments) + { + switch (argument.MemberInfo.Name) + { + case "Beschreibung": + player.RequestInformation += argument.TypedValue.Value + + Environment.NewLine + Environment.NewLine; + break; + case "Description": + player.RequestInformation += argument.TypedValue.Value + + Environment.NewLine + Environment.NewLine; + break; + } + } + } + } + + // Prüfe ob die Klasse regelkonform ist + player.Static = staticVariables; + player.RequestReferences = foreignReferences; + if (foreignReferences) + { + player.RequestInformation += Resource.SimulationCoreAnalysisForeignRefInfotext + + Environment.NewLine + referenceInformation + Environment.NewLine + + Environment.NewLine; + } + + switch (playerDefinitions) + { + case 0: + // Kein Spielerattribut gefunden + throw new RuleViolationException( + string.Format( + Resource.SimulationCoreAnalysisNoPlayerAttribute, + player.ClassName)); + case 1: + if (checkRules) + { + player.RuleCheck(); + } + players.Add(player); + break; + default: + throw new RuleViolationException( + string.Format( + Resource.SimulationCoreAnalysisTooManyPlayerAttributes, + player.ClassName)); + } + } + + #region Erkennung älterer KI-Versionen + + // Ältere Versionen + else if (type.BaseType.Name == "AntMe.Ameise") + { + // Leerer Spieler-Rumpf + int playerDefinitions = 0; + + PlayerInfo player = new PlayerInfo(); + player.SimulationVersion = PlayerSimulationVersions.Version_1_1; + player.ClassName = type.FullName; + + // Veraltete Version (1.1 oder 1.5) + // TODO: Prüfen + if (type.GetMember("RiechtFreund") != null) + { + player.SimulationVersion = PlayerSimulationVersions.Version_1_5; + } + + // Attribute auslesen + foreach (CustomAttributeData attribute in CustomAttributeData.GetCustomAttributes(type)) + { + // Spieler-Attribut auslesen + if (attribute.Constructor.ReflectedType.FullName == "AntMe.SpielerAttribute") + { + playerDefinitions++; + foreach (CustomAttributeNamedArgument argument in attribute.NamedArguments) + { + switch (argument.MemberInfo.Name) + { + case "Name": + player.ColonyName = (string)argument.TypedValue.Value; + break; + case "Vorname": + player.FirstName = (string)argument.TypedValue.Value; + break; + case "Nachname": + player.LastName = (string)argument.TypedValue.Value; + break; + } + } + break; + } + + // Typ-Attribut auslesen + if (attribute.Constructor.ReflectedType.FullName == "AntMe.TypAttribute") + { + CasteInfo caste = new CasteInfo(); + foreach (CustomAttributeNamedArgument argument in attribute.NamedArguments) + { + switch (argument.MemberInfo.Name) + { + case "Name": + caste.Name = (string)argument.TypedValue.Value; + break; + case "GeschwindigkeitModifikator": + caste.Speed = (int)argument.TypedValue.Value; + break; + case "DrehgeschwindigkeitModifikator": + caste.RotationSpeed = (int)argument.TypedValue.Value; + break; + case "LastModifikator": + caste.Load = (int)argument.TypedValue.Value; + break; + case "ReichweiteModifikator": + caste.Range = (int)argument.TypedValue.Value; + break; + case "SichtweiteModifikator": + caste.ViewRange = (int)argument.TypedValue.Value; + break; + case "EnergieModifikator": + caste.Energy = (int)argument.TypedValue.Value; + break; + case "AngriffModifikator": + caste.Attack = (int)argument.TypedValue.Value; + break; + } + } + + // Bei Individualtypen zur Liste + if (!caste.IsEmpty()) + { + player.Castes.Add(caste); + } + break; + } + } + + // Prüfe ob die Klasse regelkonform ist + player.Static = staticVariables; + switch (playerDefinitions) + { + case 0: + // Kein Spielerattribut gefunden + throw new RuleViolationException( + string.Format( + Resource.SimulationCoreAnalysisNoPlayerAttribute, + player.ClassName)); + case 1: + if (checkRules) + { + player.RuleCheck(); + } + players.Add(player); + break; + default: + throw new RuleViolationException( + string.Format( + Resource.SimulationCoreAnalysisTooManyPlayerAttributes, + player.ClassName)); + } + } + + #endregion + } + + return players; + } + + #endregion + + #region Eigenschaften + + /// + /// List of thrown Exceptions.s + /// + public Exception Exception + { + get { return exception; } + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/AreaChange.cs b/SimulationCore/Simulation/AreaChange.cs new file mode 100644 index 0000000..82f3925 --- /dev/null +++ b/SimulationCore/Simulation/AreaChange.cs @@ -0,0 +1,74 @@ +using System; + +namespace AntMe.Simulation { + /// + /// List of possible areas + /// + internal enum Area { + Unknown, + Constructor, + ChooseType, + Waits, + SpotsSugar, + SpotsFruit, + ReachedSugar, + ReachedFruit, + BecomesTired, + SmellsFriend, + SpotsFriend, + SpotsEnemy, + SpotsTeamMember, + SpotsBug, + UnderAttackByAnt, + UnderAttackByBug, + HasDied, + Tick + } + + /// + /// Event-Arguments for a AreaChange-Event + /// + internal class AreaChangeEventArgs : EventArgs { + private readonly Area area; + private readonly PlayerInfo player; + + /// + /// Creates a new AreaChangeEventArgs to unknown area. + /// + public AreaChangeEventArgs() { + area = Area.Unknown; + player = null; + } + + /// + /// Creates a new AreaChangeEventArgs to given area and player. + /// + /// player + /// area + public AreaChangeEventArgs(PlayerInfo player, Area area) { + this.player = player; + this.area = area; + } + + /// + /// Gets the player. + /// + public PlayerInfo Player { + get { return player; } + } + + /// + /// Gets the area. + /// + public Area Area { + get { return area; } + } + } + + /// + /// Delegate for area-changes. + /// + /// sending simulation-environment + /// arguments for event + internal delegate void AreaChangeEventHandler(object sender, AreaChangeEventArgs e); +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CasteInfo.cs b/SimulationCore/Simulation/CasteInfo.cs new file mode 100644 index 0000000..c040e2a --- /dev/null +++ b/SimulationCore/Simulation/CasteInfo.cs @@ -0,0 +1,162 @@ +using System; + +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation { + /// + /// Holds the caste-information. + /// + [Serializable] + public sealed class CasteInfo { + /// + /// Der Angriffmodifikator der Kaste. + /// + public int Attack = 0; + + /// + /// Der Drehgeschwindigkeitmodifikator der Kaste. + /// + public int RotationSpeed = 0; + + /// + /// Der Energiemodifikator der Kaste. + /// + public int Energy = 0; + + /// + /// Der Geschwindigkeitmodifikator der Kaste. + /// + public int Speed = 0; + + /// + /// Der Lastmodifikator der Kaste. + /// + public int Load = 0; + + /// + /// Der Name der Kaste. + /// + public string Name = string.Empty; + + /// + /// Der Reichweitenmodifikator der Kaste. + /// + public int Range = 0; + + /// + /// Der Sichtweitenmodifikator der Kaste. + /// + public int ViewRange = 0; + + /// + /// Prüft, ob diese Ameisenkaste den Regeln entspricht + /// + /// RuleViolationException + public void Rulecheck(string aiName) { + // Ignoriere die Kaste, wenn er keinen Namen hat. + if (string.IsNullOrEmpty(Name)) { + throw new RuleViolationException( + string.Format(Resource.SimulationCoreCasteRuleNoName, aiName)); + } + + // Prüfen, ob der Geschindwigkeitsmodifikator im Rahmen ist + if (Speed < SimulationSettings.Custom.CasteSettings.MinIndex || + Speed > SimulationSettings.Custom.CasteSettings.MaxIndex) { + throw new RuleViolationException( + string.Format( + Resource.SimulationCoreCasteRuleSpeedFailed, Name, aiName)); + } + + // Prüfen, ob der Drehgeschwindigkeitsmodifikator im Rahmen ist + if (RotationSpeed < SimulationSettings.Custom.CasteSettings.MinIndex || + RotationSpeed > SimulationSettings.Custom.CasteSettings.MaxIndex) { + throw new RuleViolationException( + string.Format( + Resource.SimulationCoreCasteRuleRotationSpeedFailed, + Name, + aiName)); + } + + // Prüfen, ob der Lastmodifikator im Rahmen ist + if (Load < SimulationSettings.Custom.CasteSettings.MinIndex || + Load > SimulationSettings.Custom.CasteSettings.MaxIndex) { + throw new RuleViolationException( + string.Format(Resource.SimulationCoreCasteRuleLoadFailed, Name, aiName)); + } + + // Prüfen, ob der Sichtweitemodifikator im Rahmen ist + if (ViewRange < SimulationSettings.Custom.CasteSettings.MinIndex || + ViewRange > SimulationSettings.Custom.CasteSettings.MaxIndex) { + throw new RuleViolationException( + string.Format( + Resource.SimulationCoreCasteRuleViewRangeFailed, Name, aiName)); + } + + // Prüfen, ob der Riechweitemodifikator im Rahmen ist + if (Range < SimulationSettings.Custom.CasteSettings.MinIndex || + Range > SimulationSettings.Custom.CasteSettings.MaxIndex) { + throw new RuleViolationException( + string.Format( + Resource.SimulationCoreCasteRuleRangeFailed, Name, aiName)); + } + + // Prüfen, ob der Energiemodifikator im Rahmen ist + if (Energy < SimulationSettings.Custom.CasteSettings.MinIndex || + Energy > SimulationSettings.Custom.CasteSettings.MaxIndex) { + throw new RuleViolationException( + string.Format(Resource.SimulationCoreCasteRuleEnergyFailed, Name, aiName)); + } + + // Prüfen, ob der Angriffsmodifikator im Rahmen ist + if (Attack < SimulationSettings.Custom.CasteSettings.MinIndex || + Attack > SimulationSettings.Custom.CasteSettings.MaxIndex) { + throw new RuleViolationException( + string.Format(Resource.SimulationCoreCasteRuleAttackFailed, Name, aiName)); + } + + // Prüfen, ob die Eigenschaftssumme stimmt + if (Speed + + RotationSpeed + + Load + + ViewRange + + Range + + Energy + + Attack > SimulationSettings.Custom.CasteSettings.Sum) { + throw new RuleViolationException( + string.Format(Resource.SimulationCoreCasteRuleSumFailed, Name, aiName)); + } + } + + /// + /// Gibt an, ob es sich bei dieser Ameisenkaste um die Standard-Kaste handelt + /// + /// Standardwert + public bool IsEmpty() { + return Name == String.Empty && + Attack == 0 && + RotationSpeed == 0 && + Energy == 0 && + Speed == 0 && + Load == 0 && + Range == 0 && + ViewRange == 0; + } + + /// + /// Erzeugt ein CasteState-Objekt. + /// + /// + public CasteState CreateState(int colonyId, int id) { + CasteState state = new CasteState(colonyId, id); + state.Name = Name; + state.SpeedModificator = (byte) Speed; + state.RotationSpeedModificator = (byte) RotationSpeed; + state.LoadModificator = (byte) Load; + state.ViewRangeModificator = (byte) ViewRange; + state.RangeModificator = (byte) Range; + state.VitalityModificator = (byte) Energy; + state.AttackModificator = (byte) Attack; + return state; + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreAnt.cs b/SimulationCore/Simulation/CoreAnt.cs new file mode 100644 index 0000000..db474e7 --- /dev/null +++ b/SimulationCore/Simulation/CoreAnt.cs @@ -0,0 +1,231 @@ +using System; +using System.Collections.Generic; + +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation { + + + /// + /// Abstrakte Basisklasse für alle Ameisen. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + public abstract class CoreAnt : CoreInsect { + internal override void Init(CoreColony colony, Dictionary availableInsects) { + base.Init(colony, availableInsects); + + koordinate.Radius = 2; + + // Bestimme die Kaste der neuen Ameise. + int casteIndex = -1; + string casteName = string.Empty; + if (availableInsects != null) { + casteName = BestimmeKasteBase(availableInsects); + for (int i = 0; i < colony.Player.Castes.Count; i++) { + if (colony.Player.Castes[i].Name == casteName) { + casteIndex = i; + break; + } + } + } + + // Check, if caste is available + if (casteIndex == -1) { + throw new InvalidOperationException(string.Format(Resource.SimulationCoreChooseWrongCaste, casteName)); + } + + // Setze die von der Kaste abhängigen Werte. + CasteIndexBase = casteIndex; + AktuelleEnergieBase = colony.Energie[casteIndex]; + aktuelleGeschwindigkeitI = colony.GeschwindigkeitI[casteIndex]; + AngriffBase = colony.Angriff[casteIndex]; + } + + /// + /// Bestimmt die Kaste einer neuen Ameise. + /// + /// Die Anzahl der von jeder Klaste bereits vorhandenen Ameisen. + /// Der Name der Kaste der Ameise. + internal virtual string BestimmeKasteBase(Dictionary anzahl) { + return ""; + } + + /// + /// Erzeugt ein AmeiseZustand-Objekt mit den aktuellen Daten der Ameise. + /// + internal AntState ErzeugeInfo() { + AntState zustand = new AntState(colony.Id, id); + + zustand.CasteId = CasteIndexBase; + zustand.PositionX = CoordinateBase.X/SimulationEnvironment.PLAYGROUND_UNIT; + zustand.PositionY = CoordinateBase.Y/SimulationEnvironment.PLAYGROUND_UNIT; + zustand.ViewRange = SichtweiteBase; + zustand.DebugMessage = debugMessage; + debugMessage = string.Empty; + zustand.Direction = CoordinateBase.Richtung; + if (ZielBase != null) { + zustand.TargetPositionX = ZielBase.CoordinateBase.X/SimulationEnvironment.PLAYGROUND_UNIT; + zustand.TargetPositionY = ZielBase.CoordinateBase.Y/SimulationEnvironment.PLAYGROUND_UNIT; + } + else { + zustand.TargetPositionX = 0; + zustand.TargetPositionY = 0; + } + zustand.Load = AktuelleLastBase; + if (AktuelleLastBase > 0) + if (GetragenesObstBase != null) + zustand.LoadType = LoadType.Fruit; + else + zustand.LoadType = LoadType.Sugar; + zustand.Vitality = AktuelleEnergieBase; + + if (ZielBase is CoreAnthill) + zustand.TargetType = TargetType.Anthill; + else if (ZielBase is CoreSugar) + zustand.TargetType = TargetType.Sugar; + else if (ZielBase is CoreFruit) + zustand.TargetType = TargetType.Fruit; + else if (ZielBase is CoreBug) + zustand.TargetType = TargetType.Bug; + else if (ZielBase is CoreMarker) + zustand.TargetType = TargetType.Marker; + else if (ZielBase is CoreAnt) + zustand.TargetType = TargetType.Ant; + else + zustand.TargetType = TargetType.None; + + return zustand; + } + + #region Fortbewegung + + private bool istMüde; + + /// + /// Gibt an, ob die Ameise müde ist. + /// + internal bool IstMüdeBase { + get { return istMüde; } + set { istMüde = value; } + } + + /// + /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie + /// hingehen soll. + /// + internal virtual void WartetBase() {} + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Drittel ihrer maximalen + /// Reichweite überschritten hat. + /// + internal virtual void WirdMüdeBase() {} + + #endregion + + #region Nahrung + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen + /// Zuckerhaufen sieht. + /// + /// Der nächstgelegene Zuckerhaufen. + internal virtual void SiehtBase(CoreSugar zucker) {} + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein + /// Obststück sieht. + /// + /// Das nächstgelegene Obststück. + internal virtual void SiehtBase(CoreFruit obst) {} + + /// + /// Wird einmal aufgerufen, wenn die Ameise einen Zuckerhaufen als Ziel + /// hat und bei diesem ankommt. + /// + /// Der Zuckerhaufen. + internal virtual void ZielErreichtBase(CoreSugar zucker) {} + + /// + /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und + /// bei diesem ankommt. + /// + /// Das Obstück. + internal virtual void ZielErreichtBase(CoreFruit obst) {} + + #endregion + + #region Kommunikation + + /// + /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben + /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut + /// gerochen. + /// + /// Die nächste neue Markierung. + internal virtual void RiechtFreundBase(CoreMarker markierung) {} + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindstens eine Ameise des + /// selben Volkes sieht. + /// + /// Die nächstgelegene befreundete Ameise. + internal virtual void SiehtFreundBase(CoreAnt ameise) {} + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise verbündeter + /// Völker sieht. + /// + /// + internal virtual void SiehtVerbündetenBase(CoreAnt ameise) {} + + #endregion + + #region Kampf + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Wanze + /// sieht. + /// + /// Die nächstgelegene Wanze. + internal virtual void SiehtFeindBase(CoreBug wanze) {} + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines + /// anderen Volkes sieht. + /// + /// Die nächstgelegen feindliche Ameise. + internal virtual void SiehtFeindBase(CoreAnt ameise) {} + + /// + /// Wird wiederholt aufgerufen, wenn die Ameise von einer Wanze angegriffen + /// wird. + /// + /// Die angreifende Wanze. + internal virtual void WirdAngegriffenBase(CoreBug wanze) {} + + /// + /// Wird wiederholt aufgerufen in der die Ameise von einer Ameise eines + /// anderen Volkes Ameise angegriffen wird. + /// + /// Die angreifende feindliche Ameise. + internal virtual void WirdAngegriffenBase(CoreAnt ameise) {} + + #endregion + + #region Sonstiges + + /// + /// Wird einmal aufgerufen, wenn die Ameise gestorben ist. + /// + /// Die Todesart der Ameise + internal virtual void IstGestorbenBase(CoreKindOfDeath todesArt) {} + + /// + /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen. + /// + internal virtual void TickBase() {} + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreAnthill.cs b/SimulationCore/Simulation/CoreAnthill.cs new file mode 100644 index 0000000..fc0c17c --- /dev/null +++ b/SimulationCore/Simulation/CoreAnthill.cs @@ -0,0 +1,57 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation { + /// + /// Ein Bau eines Ameisenvolkes. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + internal sealed class CoreAnthill : ICoordinate { + // Die Id des nächsten erzeugten Bau. + private static int neueId = 0; + + /// + /// Die Id die den Bau während eines Spiels eindeutig identifiziert. + /// + public readonly int Id; + + private readonly int colonyId; + + private CoreCoordinate koordinate; + + /// + /// Erzeugt eine neue Instanz der Bau-Klasse. + /// X-Koordinate + /// Y.Koordinate + /// Radius + /// Volk ID + /// + internal CoreAnthill(int x, int y, int radius, int colonyId) { + this.colonyId = colonyId; + Id = neueId++; + koordinate = new CoreCoordinate(x, y, radius); + } + + #region IKoordinate Members + + /// + /// Die Position des Bau auf dem Spielfeld. + /// + public CoreCoordinate CoordinateBase { + get { return koordinate; } + internal set { koordinate = value; } + } + + #endregion + + /// + /// Erzeugt ein BauZustand-Objekt mit den aktuellen Daten des Bau. + /// + internal AnthillState ErzeugeInfo() { + AnthillState zustand = new AnthillState(colonyId, Id); + zustand.PositionX = koordinate.X/SimulationEnvironment.PLAYGROUND_UNIT; + zustand.PositionY = koordinate.Y/SimulationEnvironment.PLAYGROUND_UNIT; + zustand.Radius = koordinate.Radius/SimulationEnvironment.PLAYGROUND_UNIT; + return zustand; + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreBug.cs b/SimulationCore/Simulation/CoreBug.cs new file mode 100644 index 0000000..c87bc6a --- /dev/null +++ b/SimulationCore/Simulation/CoreBug.cs @@ -0,0 +1,37 @@ +using System.Collections.Generic; + +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation { + /// + /// Eine Wanze + /// + /// Wolfgang Gallo (wolfgang@antme.net) + internal sealed class CoreBug : CoreInsect { + /// + /// Gibt an, ob die Wanze sich in der aktuellen Runde noch bewegen kann. + /// + internal bool KannSichNochBewegen = true; + + internal override void Init(CoreColony colony, Dictionary vorhandeneInsekten) { + base.Init(colony, vorhandeneInsekten); + koordinate.Radius = 4; + AktuelleEnergieBase = colony.Energie[0]; + aktuelleGeschwindigkeitI = colony.GeschwindigkeitI[0]; + AngriffBase = colony.Angriff[0]; + } + + /// + /// Erzeugt ein BugState-Objekt mit dem aktuellen Daten der Wanzen. + /// + /// + internal BugState ErzeugeInfo() { + BugState info = new BugState((ushort)id); + info.PositionX = (ushort) (CoordinateBase.X/SimulationEnvironment.PLAYGROUND_UNIT); + info.PositionY = (ushort) (CoordinateBase.Y/SimulationEnvironment.PLAYGROUND_UNIT); + info.Direction = (ushort) CoordinateBase.Richtung; + info.Vitality = (ushort) AktuelleEnergieBase; + return info; + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreColony.cs b/SimulationCore/Simulation/CoreColony.cs new file mode 100644 index 0000000..2cea17b --- /dev/null +++ b/SimulationCore/Simulation/CoreColony.cs @@ -0,0 +1,303 @@ +using System; +using System.Collections.Generic; + +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation { + /// + /// Ein Ameisenvolk. Kapselt alle Informationen die zur Laufzeit eines Spiels + /// zu einem Spieler anfallen. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + internal sealed class CoreColony { + // Die Id des nächsten erzeugten Volkes. + private static int nextId = 0; + private readonly int[] antsInCaste; + internal readonly List AntHills = new List(); + internal readonly CoreTeam Team; + internal readonly List BeatenInsects = new List(); + internal readonly List EatenInsects = new List(); + + /// + /// Die Id die das Volk während eines laufenden Spiels idenzifiziert. + /// + public readonly int Id; + + /// + /// Die Guid, die das Volk eindeutig identifiziert. + /// + public readonly Guid Guid; + + internal readonly List Insects = new List(); + private readonly Type Klasse; + internal readonly Grid Marker; + internal readonly List NewMarker = new List(); + + /// + /// Der Spieler der das Verhalten des Volkes steuert. + /// + internal readonly PlayerInfo Player; + + internal readonly List VerhungerteInsekten = new List(); + + internal int BreiteI; + internal int BreiteI2; + internal int HöheI; + internal int HöheI2; + internal CorePlayground Playground; + + internal PlayerStatistics Statistik = new PlayerStatistics(); + internal PlayerStatistics StatistikDurchschnitt = new PlayerStatistics(); + + /// + /// Zählt die Anzahl an Runden herunter, bis wieder eine neus Insekt erzeugt + /// werden kann. + /// + internal int insectDelay = 0; + + internal int insectCountDown; + + #region Fähigkeiten + + /// + /// Die Angriffswerte aller Kasten des Volkes. + /// + internal readonly int[] Angriff; + + /// + /// Gitter für die verschiedenen Sichtweiten. + /// + internal readonly Grid[] Grids; + + /// + /// Die Drehgeschwindigkeiten aller Kasten des Volkes in Grad pro Runde. + /// + internal readonly int[] Drehgeschwindigkeit; + + /// + /// Die Lebenspunkte aller Kasten des Volkes. + /// + internal readonly int[] Energie; + + /// + /// Die Geschwindigkeiten aller Kasten des Volkes in der internen Einheit. + /// + internal readonly int[] GeschwindigkeitI; + + /// + /// Die maximalen Lastwerte aller Kasten des Volkes. + /// + internal readonly int[] Last; + + /// + /// Die Reichweiten aller Kasten des Volkes in der internen Einheit. + /// + internal readonly int[] ReichweiteI; + + /// + /// Die Sichtweiten aller Kasten des Volkes in der internen Einheit. + /// + internal readonly int[] SichtweiteI; + + #endregion + + /// + /// Erzeugt eine neue Instanz der Volk-Klasse. Erzeugt ein Wanzen-Volk. + /// + /// Das Spielfeld. + internal CoreColony(CorePlayground spielfeld) { + Playground = spielfeld; + BreiteI = spielfeld.Width*SimulationEnvironment.PLAYGROUND_UNIT; + HöheI = spielfeld.Height*SimulationEnvironment.PLAYGROUND_UNIT; + BreiteI2 = BreiteI*2; + HöheI2 = HöheI*2; + + Marker = + new Grid + ( + spielfeld.Width*SimulationEnvironment.PLAYGROUND_UNIT, + spielfeld.Height*SimulationEnvironment.PLAYGROUND_UNIT, + SimulationSettings.Custom.MarkerSizeMaximum *SimulationEnvironment.PLAYGROUND_UNIT); + + Id = nextId++; + Guid = Guid.NewGuid(); + + // Die Wanzen werden vom Spiel gesteuert. + Player = null; + + // Die Klasse ist in diesem Fall bereits bekannt. + Klasse = typeof (CoreBug); + + //TODO: Werte überprüfen. + GeschwindigkeitI = new int[1] {SimulationSettings.Custom.BugSpeed*SimulationEnvironment.PLAYGROUND_UNIT}; + Drehgeschwindigkeit = new int[1] { SimulationSettings.Custom.BugRotationSpeed }; + ReichweiteI = new int[1] {int.MaxValue}; + SichtweiteI = new int[1] {0}; + Last = new int[1] {0}; + Energie = new int[1] { SimulationSettings.Custom.BugEnergy }; + Angriff = new int[1] { SimulationSettings.Custom.BugAttack }; + + Grids = new Grid[1]; + Grids[0] = + Grid.Create + ( + spielfeld.Width*SimulationEnvironment.PLAYGROUND_UNIT, + spielfeld.Height*SimulationEnvironment.PLAYGROUND_UNIT, + SimulationSettings.Custom.BattleRange*SimulationEnvironment.PLAYGROUND_UNIT); + + antsInCaste = new int[1]; + } + + /// + /// Erzeugt eine neue Instanz der Volk-Klasse. Erzeugt ein Ameisen-Volk. + /// + /// Das Spielfeld. + /// Das Spieler zu dem das Volk gehört. + /// Das dazugehörige Team. + internal CoreColony(CorePlayground spielfeld, PlayerInfo spieler, CoreTeam team) { + Playground = spielfeld; + BreiteI = spielfeld.Width*SimulationEnvironment.PLAYGROUND_UNIT; + HöheI = spielfeld.Height*SimulationEnvironment.PLAYGROUND_UNIT; + BreiteI2 = BreiteI*2; + HöheI2 = HöheI*2; + + Marker = + new Grid + ( + spielfeld.Width*SimulationEnvironment.PLAYGROUND_UNIT, + spielfeld.Height*SimulationEnvironment.PLAYGROUND_UNIT, + SimulationSettings.Custom.MarkerSizeMaximum *SimulationEnvironment.PLAYGROUND_UNIT); + + Id = nextId++; + Guid = spieler.Guid; + Team = team; + + Player = spieler; + Klasse = spieler.assembly.GetType(spieler.ClassName, true, false); + + // Basisameisenkaste erstellen, falls keine Kasten definiert wurden + if (spieler.Castes.Count == 0) { + spieler.Castes.Add(new CasteInfo()); + } + + GeschwindigkeitI = new int[spieler.Castes.Count]; + Drehgeschwindigkeit = new int[spieler.Castes.Count]; + Last = new int[spieler.Castes.Count]; + SichtweiteI = new int[spieler.Castes.Count]; + Grids = new Grid[spieler.Castes.Count]; + ReichweiteI = new int[spieler.Castes.Count]; + Energie = new int[spieler.Castes.Count]; + Angriff = new int[spieler.Castes.Count]; + antsInCaste = new int[spieler.Castes.Count]; + + int index = 0; + foreach (CasteInfo caste in spieler.Castes) { + GeschwindigkeitI[index] = SimulationEnvironment.PLAYGROUND_UNIT; + GeschwindigkeitI[index] *= SimulationSettings.Custom.CasteSettings[caste.Speed].Speed; + Drehgeschwindigkeit[index] = SimulationSettings.Custom.CasteSettings[caste.RotationSpeed].RotationSpeed; + Last[index] = SimulationSettings.Custom.CasteSettings[caste.Load].Load; + SichtweiteI[index] = SimulationEnvironment.PLAYGROUND_UNIT; + SichtweiteI[index] *= SimulationSettings.Custom.CasteSettings[caste.ViewRange].ViewRange; + ReichweiteI[index] = SimulationEnvironment.PLAYGROUND_UNIT; + ReichweiteI[index] *= SimulationSettings.Custom.CasteSettings[caste.Range].Range; + Energie[index] = SimulationSettings.Custom.CasteSettings[caste.Energy].Energy; + Angriff[index] = SimulationSettings.Custom.CasteSettings[caste.Attack].Attack; + + Grids[index] = + Grid.Create + ( + spielfeld.Width * SimulationEnvironment.PLAYGROUND_UNIT, + spielfeld.Height * SimulationEnvironment.PLAYGROUND_UNIT, + SichtweiteI[index]); + + index++; + } + } + + /// + /// Die Anzahl von Insektenkasten in diesem Volk. + /// + public int AnzahlKasten { + get { return Player.Castes.Count; } + } + + /// + /// Erstellt eine neues Insekt. + /// + internal void NeuesInsekt() { + Dictionary dictionary = null; + + if (Player != null) { + dictionary = new Dictionary(); + foreach (CasteInfo caste in Player.Castes) { + if (!dictionary.ContainsKey(caste.Name)) { + dictionary.Add(caste.Name, antsInCaste[dictionary.Count]); + } + } + } + + //Insekt insekt = + // (Insekt) + // Klasse.Assembly.CreateInstance + // (Klasse.FullName, false, BindingFlags.Default, null, new object[] {this, dictionary}, null, + // new object[] {}); + CoreInsect insekt = (CoreInsect) Klasse.Assembly.CreateInstance(Klasse.FullName); + insekt.Init(this, dictionary); + + // Merke das Insekt. + Insects.Add(insekt); + antsInCaste[insekt.CasteIndexBase]++; + } + + /// + /// Entfernt ein Insekt. + /// + /// Insekt + internal void EntferneInsekt(CoreInsect insekt) { + if (Insects.Remove(insekt)) { + antsInCaste[insekt.CasteIndexBase]--; + } + } + + /// + /// Erzeugt ein VolkZustand Objekt mit dem aktuellen Zustand des Volkes. + /// + /// + public ColonyState ErzeugeInfo() { + ColonyState info = new ColonyState(Id, Player.Guid, Player.ColonyName, Player.FirstName + " " + Player.LastName); + + info.CollectedFood = Statistik.CollectedFood; + info.CollectedFruits = Statistik.CollectedFruits; + info.StarvedAnts = Statistik.StarvedAnts; + info.EatenAnts = Statistik.EatenAnts; + info.BeatenAnts = Statistik.BeatenAnts; + info.KilledBugs = Statistik.KilledBugs; + info.KilledEnemies = Statistik.KilledAnts; + info.Points = Statistik.Points; + + int index; + + for (index = 0; index < AntHills.Count; index++) { + info.AnthillStates.Add(AntHills[index].ErzeugeInfo()); + } + + for (index = 1; index < Player.Castes.Count; index++) { + info.CasteStates.Add(Player.Castes[index].CreateState(Id, index)); + } + + for (index = 0; index < Insects.Count; index++) { + info.AntStates.Add(((CoreAnt) Insects[index]).ErzeugeInfo()); + } + + // Markierungen ist ein Bucket und die Bucket Klasse enthält keinen + // Indexer. Daher können wir hier keine for Schleife verwenden, wie eben + // bei den Bauten und den Ameisen. Daher benutzen wir eine foreach + // Schleife für die wir eine extra Laufvariable benötigen. + foreach (CoreMarker markierung in Marker) { + info.MarkerStates.Add(markierung.ErzeugeInfo()); + } + + return info; + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreCoordinate.cs b/SimulationCore/Simulation/CoreCoordinate.cs new file mode 100644 index 0000000..841ad3e --- /dev/null +++ b/SimulationCore/Simulation/CoreCoordinate.cs @@ -0,0 +1,189 @@ +using System; + +namespace AntMe.Simulation { + + + /// + /// Die Position eines Objekts auf dem Spielfeld. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + public struct CoreCoordinate { + private int radius; + private int richtung; + private int x; + private int y; + + /// + /// Erzeugt eine neue Instanz der Koordinate-Struktur. + /// + /// Der X-Wert des Elementes. + /// Der Y-Wert des Elementes. + /// Der Radius des Elementes. + /// Die Richtung in die das Element blickt. + internal CoreCoordinate(int x, int y, int radius, int richtung) { + this.x = x*SimulationEnvironment.PLAYGROUND_UNIT; + this.y = y*SimulationEnvironment.PLAYGROUND_UNIT; + + // In diesem Konstruktor müssen alle Werte der Struktur initialisiert + // werden, deswegen werden Radius und Richtung hier gesetzt, obwohl sie + // im Anschluß gleich wieder überschrieben werden. + this.radius = 0; + this.richtung = 0; + + Radius = radius*SimulationEnvironment.PLAYGROUND_UNIT; + Richtung = richtung; + } + + /// + /// Erzeugt eine neue Instanz der Koordinate-Struktur. + /// + /// Der X-Wert des Elementes. + /// Der Y-Wert des Elementes. + /// Der Radius des Elementes. + internal CoreCoordinate(int x, int y, int radius) { + this.x = x*SimulationEnvironment.PLAYGROUND_UNIT; + this.y = y*SimulationEnvironment.PLAYGROUND_UNIT; + this.radius = 0; + richtung = 0; + Radius = radius*SimulationEnvironment.PLAYGROUND_UNIT; + } + + /// + /// Erzeugt eine neue Instanz der Koordinate-Struktur. + /// + /// Der X-Wert des Elementes. + /// Der Y-Wert des Elementes. + internal CoreCoordinate(int x, int y) { + this.x = x*SimulationEnvironment.PLAYGROUND_UNIT; + this.y = y*SimulationEnvironment.PLAYGROUND_UNIT; + radius = 0; + richtung = 0; + } + + /// + /// Erzeugt eine neue Instanz der Koordinate-Struktur ausgehend von einer + /// bestehenden Koordinate. + /// + /// Die bestehende Koordinate. + /// Der X-Wert relativ zu der Koordinate. + /// Der Y-Wert relativ zu der Koordinate. + internal CoreCoordinate(CoreCoordinate k, int deltaX, int deltaY) { + x = k.x + deltaX; + y = k.y + deltaY; + radius = k.radius; + richtung = k.richtung; + } + + /// + /// Der X-Wert des Elements. + /// + internal int X { + get { return x; } + set { x = value; } + } + + /// + /// Der Y-Wert des Elements. + /// + internal int Y { + get { return y; } + set { y = value; } + } + + /// + /// Der Radius des Elementes. Da alle Berechnungen in der Spiel (z.B. + /// die Bestimmung von Entfernungen) auf Punkten und Kreisen basiert, wird + /// auch der Radius eines Objektes in der IKoordinate Struktur gespeichert. + /// + internal int Radius { + get { return radius; } + set { radius = Math.Abs(value); } + } + + /// + /// Die Richtung in die das Element blickt. Eine Richtung ist zwar kein + /// echter Teil einer Koordinate und nicht alle Elemente die eine Koordinate + /// haben benötigen die Richtung, aber die IKoordinate-Struktur ist der + /// beste Platz um auch die Richtung eines Objektes zu speichern. + /// + internal int Richtung { + get { return richtung; } + set { + richtung = value; + while (richtung < 0) { + richtung += 360; + } + while (richtung > 359) { + richtung -= 360; + } + } + } + + /// + /// Bestimmt die Entfernung zweier Objekte auf dem Spielfeld in Schritten. + /// + /// Objekt 1. + /// Objekt 2. + /// Die Entfernung. + internal static int BestimmeEntfernung(ICoordinate o1, ICoordinate o2) { + return BestimmeEntfernungI(o1.CoordinateBase, o2.CoordinateBase)/SimulationEnvironment.PLAYGROUND_UNIT; + } + + /// + /// Bestimmt die Richtung von einem Objekt auf dem Spielfeld zu einem + /// anderen. + /// + /// Das Start Objekt. + /// Das Ziel Objekt. + /// Die Richtung. + internal static int BestimmeRichtung(ICoordinate o1, ICoordinate o2) { + return BestimmeRichtung(o1.CoordinateBase, o2.CoordinateBase); + } + + /// + /// Bestimmt die Entfernung zweier Koordinaten auf dem Spielfeld in der + /// internen Einheit. + /// + /// Koordinate 1. + /// Koordinate 2. + /// Die Entfernung. + internal static int BestimmeEntfernungI(CoreCoordinate k1, CoreCoordinate k2) { + double deltaX = k1.x - k2.x; + double deltaY = k1.y - k2.y; + int entfernung = (int) Math.Round(Math.Sqrt(deltaX*deltaX + deltaY*deltaY)); + entfernung = entfernung - k1.radius - k2.radius; + if (entfernung < 0) { + return 0; + } + return entfernung; + } + + /// + /// Bestimmt die Entfernung zweier Koordinaten auf dem Spielfeld in der + /// internen Einheit ohne Beachtung der Radien. + /// + /// Koordinate 1. + /// Koordinate 2. + /// Die Entfernung. + internal static int BestimmeEntfernungDerMittelpunkteI(CoreCoordinate k1, CoreCoordinate k2) { + double deltaX = k1.x - k2.x; + double deltaY = k1.y - k2.y; + return (int) Math.Round(Math.Sqrt(deltaX*deltaX + deltaY*deltaY)); + } + + /// + /// Bestimmt die Richtung von einer Koordinate auf dem Spielfeld zu einer + /// anderen. + /// + /// Die Start Koordinate. + /// Die Ziel Koordinate. + /// Die Richtung. + internal static int BestimmeRichtung(CoreCoordinate k1, CoreCoordinate k2) { + int richtung = (int) Math.Round(Math.Atan2(k2.Y - k1.Y, k2.X - k1.X)*180d/Math.PI); + if (richtung < 0) { + richtung += 360; + } + return richtung; + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreFood.cs b/SimulationCore/Simulation/CoreFood.cs new file mode 100644 index 0000000..3fc0266 --- /dev/null +++ b/SimulationCore/Simulation/CoreFood.cs @@ -0,0 +1,65 @@ +using System; +using System.Collections.Generic; + +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation { + /// + /// Die abstrakte Basisklasse für Nahrung. + /// + internal abstract class CoreFood : ICoordinate { + // Die Id der nächsten erzeugten Nahrung. + private static int neueId = 0; + + /// + /// Die Id die die Nahrung während eines Spiels eindeutig identifiziert. + /// + public readonly int Id; + + /// + /// Die Position der Nahrung auf dem Spielfeld. + /// + protected CoreCoordinate koordinate; + + /// + /// Die verbleibende Menge an Nahrungspunkten. + /// + protected int menge; + + /// + /// Der abstrakte Nahrung-Basiskonstruktor. + /// + /// Die X-Position der Koordinate auf dem Spielfeld. + /// Die Y-Position der Koordinate auf dem Spielfeld. + /// Die Anzahl der Nahrungspunkte. + internal CoreFood(int x, int y, int menge) { + Id = neueId++; + koordinate = new CoreCoordinate(x, y); + Menge = menge; + } + + /// + /// Die verbleibende Menge an Nahrungspunkten. + /// + public virtual int Menge { + get { return menge; } + internal set { + menge = value; + koordinate.Radius = (int) + (Math.Round(Math.Sqrt(menge/Math.PI)*SimulationEnvironment.PLAYGROUND_UNIT)); + } + } + + #region IKoordinate Members + + /// + /// Die Position der Nahrung auf dem Spielfeld. + /// + public CoreCoordinate CoordinateBase { + get { return koordinate; } + internal set { koordinate = value; } + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreFruit.cs b/SimulationCore/Simulation/CoreFruit.cs new file mode 100644 index 0000000..8e8ea08 --- /dev/null +++ b/SimulationCore/Simulation/CoreFruit.cs @@ -0,0 +1,74 @@ +using System; +using System.Collections.Generic; +using System.Text; + +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation +{ + /// + /// Represents fruit. + /// + internal sealed class CoreFruit : CoreFood + { + /// + /// Liste der tragenden Ameisen. + /// + internal readonly List TragendeInsekten = new List(); + + /// + /// Erzeugt eine neue Instanz der Obst-Klasse. + /// + /// Die X-Position des Obststücks auf dem Spielfeld. + /// Die Y-Position des Obststücks auf dem Spielfeld. + /// Die Anzahl an Nahrungspunkten. + internal CoreFruit(int x, int y, int menge) + : base(x, y, menge) { } + + /// + /// Die verbleibende Menge an Nahrungspunkten. + /// + public override int Menge + { + internal set + { + menge = value; + koordinate.Radius = (int)(SimulationSettings.Custom.FruitRadiusMultiplier * + Math.Sqrt(menge / Math.PI) * SimulationEnvironment.PLAYGROUND_UNIT); + } + } + + /// + /// Bestimmt, ob das Stück Obst für das angegebene Volk noch tragende + /// Insekten benötigt, um die maximale Geschwindigkeit beim Tragen zu + /// erreichen. + /// + /// Das Volk. + internal bool BrauchtNochTräger(CoreColony colony) + { + int last = 0; + foreach (CoreInsect insekt in TragendeInsekten) + { + if (insekt.colony == colony) + { + last += insekt.AktuelleLastBase; + } + } + return last * SimulationSettings.Custom.FruitLoadMultiplier < Menge; + } + + /// + /// Erzeugt ein ObstZustand-Objekt mit dem Daten Zustand des Obststücks. + /// + internal FruitState ErzeugeInfo() + { + FruitState info = new FruitState((ushort)Id); + info.PositionX = (ushort)(koordinate.X / SimulationEnvironment.PLAYGROUND_UNIT); + info.PositionY = (ushort)(koordinate.Y / SimulationEnvironment.PLAYGROUND_UNIT); + info.Radius = (ushort)(koordinate.Radius / SimulationEnvironment.PLAYGROUND_UNIT); + info.Amount = (ushort)menge; + info.CarryingAnts = (byte)TragendeInsekten.Count; + return info; + } + } +} diff --git a/SimulationCore/Simulation/CoreInsect.cs b/SimulationCore/Simulation/CoreInsect.cs new file mode 100644 index 0000000..1c99d2f --- /dev/null +++ b/SimulationCore/Simulation/CoreInsect.cs @@ -0,0 +1,791 @@ +using System; +using System.Collections.Generic; +using System.Threading; + +using AntMe.English; + +namespace AntMe.Simulation { + /// + /// Abstrakte Basisklasse für alle Insekten. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + public abstract class CoreInsect : ICoordinate { + /// + /// Die Id des nächste erzeugten Insekts. + /// + private static int neueId = 0; + + /// + /// Speichert die Markierungen, die das Insekt schon gesehen hat. Das + /// verhindert, daß das Insekt zwischen Markierungen im Kreis läuft. + /// + internal readonly List SmelledMarker = new List(); + + private bool reached = false; + private int antCount = 0; + private int casteCount = 0; + private int colonyCount = 0; + private int bugCount = 0; + private int teamCount = 0; + private CoreFruit getragenesObst; + + /// + /// Die Id die das Insekt während eines Spiels eindeutig indentifiziert. + /// + internal int id; + + /// + /// Die Position des Insekts auf dem Spielfeld. + /// + internal CoreCoordinate koordinate; + + /// + /// Legt fest, ob das Insekt Befehle entgegen nimmt. + /// + internal bool NimmBefehleEntgegen = false; + + private int restStreckeI; + private int restWinkel = 0; + + /// + /// Der Index der Kaste des Insekts in der Kasten-Struktur des Spielers. + /// + internal int CasteIndexBase; + + /// + /// Das Volk zu dem das Insekts gehört. + /// + internal CoreColony colony; + + private ICoordinate ziel = null; + private int zurückgelegteStreckeI; + + internal CoreInsect() {} + + /// + /// Die Kaste des Insekts. + /// + internal string KasteBase { + get { return colony.Player.Castes[CasteIndexBase].Name; } + } + + /// + /// Die Anzahl von Wanzen in Sichtweite des Insekts. + /// + internal int BugsInViewrange { + get { return bugCount; } + set { bugCount = value; } + } + + /// + /// Die Anzahl feindlicher Ameisen in Sichtweite des Insekts. + /// + internal int ForeignAntsInViewrange { + get { return antCount; } + set { antCount = value; } + } + + /// + /// Die Anzahl befreundeter Ameisen in Sichtweite des Insekts. + /// + internal int FriendlyAntsInViewrange { + get { return colonyCount; } + set { colonyCount = value; } + } + + /// + /// Die Anzahl befreundeter Ameisen der selben Kaste in Sichtweite des + /// Insekts. + /// + internal int FriendlyAntsFromSameCasteInViewrange { + get { return casteCount; } + set { casteCount = value; } + } + + /// + /// Anzahl Ameisen aus befreundeten Völkern in sichtweite des Insekts. + /// + internal int TeamAntsInViewrange { + get { return teamCount; } + set { teamCount = value; } + } + + /// + /// Die Richtung in die das Insekt gedreht ist. + /// + internal int RichtungBase { + get { return koordinate.Richtung; } + } + + /// + /// Die Strecke die die Ameise zurückgelegt hat, seit sie das letzte Mal in + /// einem Ameisenbau war. + /// + internal int ZurückgelegteStreckeBase { + get { return zurückgelegteStreckeI/SimulationEnvironment.PLAYGROUND_UNIT; } + } + + /// + /// Die Strecke die die Ameise zurückgelegt hat, seit sie das letzte Mal in + /// einem Ameisenbau war in der internen Einheit. + /// + internal int ZurückgelegteStreckeI { + get { return zurückgelegteStreckeI; } + set { zurückgelegteStreckeI = value; } + } + + /// + /// Die Strecke die das Insekt geradeaus gehen wird, bevor das nächste Mal + /// Wartet() aufgerufen wird bzw. das Insekt sich zu seinem Ziel ausrichtet. + /// + internal int RestStreckeBase { + get { return restStreckeI/SimulationEnvironment.PLAYGROUND_UNIT; } + } + + /// + /// Die Strecke die das Insekt geradeaus gehen wird, bevor das nächste + /// Mal Wartet() aufgerufen wird bzw. das Insekt sich zu seinem Ziel + /// ausrichtet in der internen Einheit. + /// + internal int RestStreckeI { + get { return restStreckeI; } + set { restStreckeI = value; } + } + + /// + /// Der Winkel um den das Insekt sich noch drehen muß, bevor es wieder + /// geradeaus gehen kann. + /// + internal int RestWinkelBase { + get { return restWinkel; } + set { + // TODO: Modulo? + restWinkel = value; + while (restWinkel > 180) { + restWinkel -= 360; + } + while (restWinkel < -180) { + restWinkel += 360; + } + } + } + + /// + /// Das Ziel auf das das Insekt zugeht. + /// + internal ICoordinate ZielBase { + get { return ziel; } + set { + if (ziel != value || value == null) { + ziel = value; + restWinkel = 0; + restStreckeI = 0; + } + } + } + + /// + /// Liefert die Entfernung in Schritten zum nächsten Ameisenbau. + /// + internal int EntfernungZuBauBase { + get { + int aktuelleEntfernung; + int gemerkteEntfernung = int.MaxValue; + foreach (CoreAnthill bau in colony.AntHills) { + aktuelleEntfernung = CoreCoordinate.BestimmeEntfernungI(CoordinateBase, bau.CoordinateBase); + if (aktuelleEntfernung < gemerkteEntfernung) { + gemerkteEntfernung = aktuelleEntfernung; + } + } + return gemerkteEntfernung/SimulationEnvironment.PLAYGROUND_UNIT; + } + } + + /// + /// Gibt das Obst zurück, das das Insekt gerade trägt. + /// + internal CoreFruit GetragenesObstBase { + get { return getragenesObst; } + set { getragenesObst = value; } + } + + /// + /// Gibt zurück on das Insekt bei seinem Ziel angekommen ist. + /// + internal bool AngekommenBase { + get { return reached; } + } + + #region IKoordinate Members + + /// + /// Die Position des Insekts auf dem Spielfeld. + /// + public CoreCoordinate CoordinateBase { + get { return koordinate; } + internal set { koordinate = value; } + } + + #endregion + + /// + /// Der abstrakte Insekt-Basiskonstruktor. + /// + /// Das Volk zu dem das neue Insekt gehört. + /// Hier unbenutzt! + internal virtual void Init(CoreColony colony, Dictionary vorhandeneInsekten) { + id = neueId; + neueId++; + + this.colony = colony; + + koordinate.Richtung = RandomNumber.Number(0, 359); + + // Zufällig auf dem Spielfeldrand platzieren. + if (colony.AntHills.Count == 0) // Am oberen oder unteren Rand platzieren. + { + if (RandomNumber.Number(2) == 0) { + koordinate.X = RandomNumber.Number(0, colony.Playground.Width); + koordinate.X *= SimulationEnvironment.PLAYGROUND_UNIT; + if (RandomNumber.Number(2) == 0) { + koordinate.Y = 0; + } + else { + koordinate.Y = colony.Playground.Height*SimulationEnvironment.PLAYGROUND_UNIT; + } + } + + // Am linken oder rechten Rand platzieren. + else { + if (RandomNumber.Number(2) == 0) { + koordinate.X = 0; + } + else { + koordinate.X = colony.Playground.Width*SimulationEnvironment.PLAYGROUND_UNIT; + } + koordinate.Y = RandomNumber.Number(0, colony.Playground.Height); + koordinate.Y *= SimulationEnvironment.PLAYGROUND_UNIT; + } + } + + // In einem zufälligen Bau platzieren. + else { + int i = RandomNumber.Number(colony.AntHills.Count); + koordinate.X = colony.AntHills[i].CoordinateBase.X + + SimulationEnvironment.Cosinus( + colony.AntHills[i].CoordinateBase.Radius, koordinate.Richtung); + koordinate.Y = colony.AntHills[i].CoordinateBase.Y + + SimulationEnvironment.Sinus( + colony.AntHills[i].CoordinateBase.Radius, koordinate.Richtung); + } + } + + /// + /// Gibt an, ob weitere Insekten benötigt werden, um ein Stück Obst zu + /// tragen. + /// + /// Obst + /// + internal bool BrauchtNochTräger(CoreFruit obst) { + return obst.BrauchtNochTräger(colony); + } + + /// + /// Dreht das Insekt um den angegebenen Winkel. Die maximale Drehung beträgt + /// -180 Grad (nach links) bzw. 180 Grad (nach rechts). Größere Werte werden + /// abgeschnitten. + /// + /// Winkel + internal void DreheUmWinkelBase(int winkel) { + if (!NimmBefehleEntgegen) { + return; + } + RestWinkelBase = winkel; + } + + /// + /// Dreht das Insekt in die angegebene Richtung (Grad). + /// + /// Richtung + internal void DreheInRichtungBase(int richtung) { + if (!NimmBefehleEntgegen) { + return; + } + dreheInRichtung(richtung); + } + + private void dreheInRichtung(int richtung) { + RestWinkelBase = richtung - koordinate.Richtung; + } + + /// + /// Dreht das Insekt in die Richtung des angegebenen Ziels. + /// + /// Ziel + internal void DreheZuZielBase(ICoordinate ziel) { + DreheInRichtungBase(CoreCoordinate.BestimmeRichtung(this, ziel)); + } + + /// + /// Dreht das Insekt um 180 Grad. + /// + internal void DreheUmBase() { + if (!NimmBefehleEntgegen) { + return; + } + if (restWinkel > 0) { + restWinkel = 180; + } + else { + restWinkel = -180; + } + } + + /// + /// Lässt das Insekt unbegrenzt geradeaus gehen. + /// + internal void GeheGeradeausBase() { + if (!NimmBefehleEntgegen) { + return; + } + restStreckeI = int.MaxValue; + } + + /// + /// Lässt das Insekt die angegebene Entfernung in Schritten geradeaus gehen. + /// + /// Die Entfernung. + internal void GeheGeradeausBase(int entfernung) { + if (!NimmBefehleEntgegen) { + return; + } + restStreckeI = entfernung*SimulationEnvironment.PLAYGROUND_UNIT; + } + + /// + /// Lässt das Insekt auf ein Ziel zugehen. Das Ziel darf sich bewegen. + /// Wenn das Ziel eine Wanze ist, wird dieser angegriffen. + /// + /// Das Ziel. + internal void GeheZuZielBase(ICoordinate ziel) { + if (!NimmBefehleEntgegen) { + return; + } + ZielBase = ziel; + } + + /// + /// Lässt das Insekt ein Ziel angreifen. Das Ziel darf sich bewegen. + /// In der aktuellen Version kann das Ziel nur eine Wanze sein. + /// + /// Ziel + internal void GreifeAnBase(CoreInsect ziel) { + if (!NimmBefehleEntgegen) { + return; + } + ZielBase = ziel; + } + + /// + /// Lässt das Insekt von der aktuellen Position aus entgegen der Richtung zu + /// einer Quelle gehen. Wenn die Quelle ein Insekt eines anderen Volkes ist, + /// befindet sich das Insekt auf der Flucht. + /// + /// Die Quelle. + internal void GeheWegVonBase(ICoordinate quelle) { + DreheInRichtungBase(CoreCoordinate.BestimmeRichtung(this, quelle) + 180); + GeheGeradeausBase(); + } + + /// + /// Lässt das Insekt von der aktuellen Position aus die angegebene + /// Entfernung in Schritten entgegen der Richtung zu einer Quelle gehen. + /// Wenn die Quelle ein Insekt eines anderen Volkes ist, befindet sich das + /// Insekt auf der Flucht. + /// + /// Die Quelle. + /// Die Entfernung in Schritten. + internal void GeheWegVonBase(ICoordinate quelle, int entfernung) { + DreheInRichtungBase(CoreCoordinate.BestimmeRichtung(this, quelle) + 180); + GeheGeradeausBase(entfernung); + } + + /// + /// Lässt das Insekt zum nächsten Bau gehen. + /// + internal void GeheZuBauBase() { + if (!NimmBefehleEntgegen) { + return; + } + int aktuelleEntfernung; + int gemerkteEntfernung = int.MaxValue; + CoreAnthill gemerkterBau = null; + foreach (CoreAnthill bau in colony.AntHills) { + aktuelleEntfernung = CoreCoordinate.BestimmeEntfernungI(CoordinateBase, bau.CoordinateBase); + if (aktuelleEntfernung < gemerkteEntfernung) { + gemerkterBau = bau; + gemerkteEntfernung = aktuelleEntfernung; + } + } + GeheZuZielBase(gemerkterBau); + } + + /// + /// Lässt das Insekt anhalten. Dabei geht sein Ziel verloren. + /// + internal void BleibStehenBase() { + if (!NimmBefehleEntgegen) { + return; + } + ZielBase = null; + restStreckeI = 0; + restWinkel = 0; + } + + /// + /// Lässt das Insekt Zucker von einem Zuckerhaufen nehmen. + /// + /// Zuckerhaufen + internal void NimmBase(CoreSugar zucker) { + if (!NimmBefehleEntgegen) { + return; + } + int entfernung = CoreCoordinate.BestimmeEntfernungI(CoordinateBase, zucker.CoordinateBase); + if (entfernung <= SimulationEnvironment.PLAYGROUND_UNIT) { + int menge = Math.Min(MaximaleLastBase - aktuelleLast, zucker.Menge); + AktuelleLastBase += menge; + zucker.Menge -= menge; + } + else { + Thread.Sleep(0); + } + } + + /// + /// Lässt das Insekt ein Obststück nehmen. + /// + /// Das Obststück. + internal void NimmBase(CoreFruit obst) { + if (!NimmBefehleEntgegen) { + return; + } + if (GetragenesObstBase == obst) { + return; + } + if (GetragenesObstBase != null) { + LasseNahrungFallenBase(); + } + int entfernung = CoreCoordinate.BestimmeEntfernungI(CoordinateBase, obst.CoordinateBase); + if (entfernung <= SimulationEnvironment.PLAYGROUND_UNIT) { + BleibStehenBase(); + GetragenesObstBase = obst; + obst.TragendeInsekten.Add(this); + AktuelleLastBase = colony.Last[CasteIndexBase]; + } + } + + /// + /// Lässt das Insekt die aktuell getragene Nahrung fallen. Das Ziel des + /// Insekts geht dabei verloren. + /// + internal void LasseNahrungFallenBase() { + if (!NimmBefehleEntgegen) { + return; + } + AktuelleLastBase = 0; + ZielBase = null; + if (GetragenesObstBase != null) { + GetragenesObstBase.TragendeInsekten.Remove(this); + GetragenesObstBase = null; + } + } + + /// + /// Lässt die Ameise eine Markierung sprühen. Die Markierung enthält die + /// angegebene Information und breitet sich um die angegebene Anzahl an + /// Schritten weiter aus. Je weiter sich eine Markierung ausbreitet, desto + /// kürzer bleibt sie aktiv. + /// + /// Die Information. + /// Die Ausbreitung in Schritten. + internal void SprüheMarkierungBase(int information, int ausbreitung) { + if (!NimmBefehleEntgegen) { + return; + } + + // Check for unsupported markersize + if (ausbreitung < 0) { + throw new AiException(Resource.SimulationCoreNegativeMarkerSize); + } + + CoreMarker markierung = new CoreMarker(koordinate, ausbreitung, colony.Id); + markierung.Information = information; + colony.NewMarker.Add(markierung); + SmelledMarker.Add(markierung); + } + + /// + /// Lässt die Ameise eine Markierung sprühen. Die Markierung enthält die + /// angegebene Information und breitet sich nicht aus. So hat die Markierung + /// die maximale Lebensdauer. + /// + /// Die Information. + internal void SprüheMarkierungBase(int information) { + if (!NimmBefehleEntgegen) { + return; + } + SprüheMarkierungBase(information, 0); + } + + /// + /// Berechnet die Bewegung des Insekts. + /// + internal void Bewegen() { + reached = false; + + // Insekt dreht sich. + if (restWinkel != 0) { + // Zielwinkel wird erreicht. + if (Math.Abs(restWinkel) < colony.Drehgeschwindigkeit[CasteIndexBase]) { + koordinate.Richtung += restWinkel; + restWinkel = 0; + } + + // Insekt dreht sich nach rechts. + else if (restWinkel >= colony.Drehgeschwindigkeit[CasteIndexBase]) { + koordinate.Richtung += colony.Drehgeschwindigkeit[CasteIndexBase]; + RestWinkelBase -= colony.Drehgeschwindigkeit[CasteIndexBase]; + } + + // Insekt dreht sich nach links. + else if (restWinkel <= -colony.Drehgeschwindigkeit[CasteIndexBase]) { + koordinate.Richtung -= colony.Drehgeschwindigkeit[CasteIndexBase]; + RestWinkelBase += colony.Drehgeschwindigkeit[CasteIndexBase]; + } + } + + // Insekt geht. + else if (restStreckeI > 0) { + if (GetragenesObstBase == null) { + int strecke = Math.Min(restStreckeI, aktuelleGeschwindigkeitI); + + restStreckeI -= strecke; + zurückgelegteStreckeI += strecke; + koordinate.X += SimulationEnvironment.Cos[strecke, koordinate.Richtung]; + koordinate.Y += SimulationEnvironment.Sin[strecke, koordinate.Richtung]; + } + } + + // Insekt geht auf Ziel zu. + else if (ziel != null) { + int entfernungI; + + if (ZielBase is CoreMarker) { + entfernungI = CoreCoordinate.BestimmeEntfernungDerMittelpunkteI(koordinate, ziel.CoordinateBase); + } + else { + entfernungI = CoreCoordinate.BestimmeEntfernungI(koordinate, ziel.CoordinateBase); + } + + reached = entfernungI <= SimulationEnvironment.PLAYGROUND_UNIT; + if (!reached) { + int richtung = CoreCoordinate.BestimmeRichtung(koordinate, ziel.CoordinateBase); + + // Ziel ist in Sichtweite oder Insekt trägt Obst. + if (entfernungI < colony.SichtweiteI[CasteIndexBase] || getragenesObst != null) { + restStreckeI = entfernungI; + } + + // Ansonsten Richtung verfälschen. + else { + richtung += RandomNumber.Number(-18, 18); + restStreckeI = colony.SichtweiteI[CasteIndexBase]; + } + + dreheInRichtung(richtung); + } + } + + // Koordinaten links begrenzen. + if (koordinate.X < 0) { + koordinate.X = -koordinate.X; + if (koordinate.Richtung > 90 && koordinate.Richtung <= 180) { + koordinate.Richtung = 180 - koordinate.Richtung; + } + else if (koordinate.Richtung > 180 && koordinate.Richtung < 270) { + koordinate.Richtung = 540 - koordinate.Richtung; + } + } + + // Koordinaten rechts begrenzen. + else if (koordinate.X > colony.BreiteI) { + koordinate.X = colony.BreiteI2 - koordinate.X; + if (koordinate.Richtung >= 0 && koordinate.Richtung < 90) { + koordinate.Richtung = 180 - koordinate.Richtung; + } + else if (koordinate.Richtung > 270 && koordinate.Richtung < 360) { + koordinate.Richtung = 540 - koordinate.Richtung; + } + } + + // Koordinaten oben begrenzen. + if (koordinate.Y < 0) { + koordinate.Y = -koordinate.Y; + if (koordinate.Richtung > 180 && koordinate.Richtung < 360) { + koordinate.Richtung = 360 - koordinate.Richtung; + } + } + + // Koordinaten unten begrenzen. + else if (koordinate.Y > colony.HöheI) { + koordinate.Y = colony.HöheI2 - koordinate.Y; + if (koordinate.Richtung > 0 && koordinate.Richtung < 180) { + koordinate.Richtung = 360 - koordinate.Richtung; + } + } + } + + #region Geschwindigkeit + + /// + /// Die aktuelle Geschwindigkeit des Insekts in der internen Einheit. + /// + internal int aktuelleGeschwindigkeitI; + + /// + /// Die aktuelle Geschwindigkeit des Insekts in Schritten. Wenn das Insekt + /// seine maximale Last trägt, halbiert sich seine Geschwindigkeit. + /// + internal int AktuelleGeschwindigkeitBase { + get { return aktuelleGeschwindigkeitI/SimulationEnvironment.PLAYGROUND_UNIT; } + } + + /// + /// Die maximale Geschwindigkeit des Insekts. + /// + internal int MaximaleGeschwindigkeitBase { + get { return colony.GeschwindigkeitI[CasteIndexBase]/SimulationEnvironment.PLAYGROUND_UNIT; } + } + + #endregion + + #region Drehgeschwindigkeit + + /// + /// Die Drehgeschwindigkeit des Insekts in Grad pro Runde. + /// + internal int DrehgeschwindigkeitBase { + get { return colony.Drehgeschwindigkeit[CasteIndexBase]; } + } + + #endregion + + #region Last + + private int aktuelleLast = 0; + + /// + /// Die Last die die Ameise gerade trägt. + /// + internal int AktuelleLastBase { + get { return aktuelleLast; } + set { + aktuelleLast = value >= 0 ? value : 0; + aktuelleGeschwindigkeitI = colony.GeschwindigkeitI[CasteIndexBase]; + aktuelleGeschwindigkeitI -= aktuelleGeschwindigkeitI*aktuelleLast/colony.Last[CasteIndexBase]/2; + } + } + + /// + /// Die maximale Last die das Insekt tragen kann. + /// + internal int MaximaleLastBase { + get { return colony.Last[CasteIndexBase]; } + } + + #endregion + + #region Sichtweite + + /// + /// Die Sichtweite des Insekts in Schritten. + /// + internal int SichtweiteBase { + get { return colony.SichtweiteI[CasteIndexBase]/SimulationEnvironment.PLAYGROUND_UNIT; } + } + + /// + /// Die Sichtweite des Insekts in der internen Einheit. + /// + internal int SichtweiteI { + get { return colony.SichtweiteI[CasteIndexBase]; } + } + + #endregion + + #region Reichweite + + /// + /// Die Reichweite des Insekts in Schritten. + /// + internal int ReichweiteBase { + get { return colony.ReichweiteI[CasteIndexBase]/SimulationEnvironment.PLAYGROUND_UNIT; } + } + + /// + /// Die Reichweite des Insekts in der internen Einheit. + /// + internal int ReichweiteI { + get { return colony.ReichweiteI[CasteIndexBase]; } + } + + #endregion + + #region Energie + + private int aktuelleEnergie; + + /// + /// Die verbleibende Energie des Insekts. + /// + internal int AktuelleEnergieBase { + get { return aktuelleEnergie; } + set { aktuelleEnergie = value >= 0 ? value : 0; } + } + + /// + /// Die maximale Energie des Insetks. + /// + internal int MaximaleEnergieBase { + get { return colony.Energie[CasteIndexBase]; } + } + + #endregion + + #region Angriff + + private int angriff; + + /// + /// Die Angriffstärke des Insekts. Wenn das Insekt Last trägt ist die + /// Angriffstärke gleich Null. + /// + internal int AngriffBase { + get { return aktuelleLast == 0 ? angriff : 0; } + set { angriff = value >= 0 ? value : 0; } + } + + #endregion + + #region Debug + + internal string debugMessage; + + internal void DenkeCore(string message) + { + debugMessage = message.Length > 100 ? message.Substring(0, 100) : message; + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreKindOfDeath.cs b/SimulationCore/Simulation/CoreKindOfDeath.cs new file mode 100644 index 0000000..2303100 --- /dev/null +++ b/SimulationCore/Simulation/CoreKindOfDeath.cs @@ -0,0 +1,22 @@ +namespace AntMe.Simulation { + /// + /// Beschreibt wie eine Ameise gestorben ist. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + internal enum CoreKindOfDeath { + /// + /// Gibt an, dass die Ameise verhungert ist. + /// + Starved = 1, + + /// + /// Gibt an, dass die Ameise von einer Wanze gefressen wurde. + /// + Eaten = 2, + + /// + /// Gibt an, dass die Ameise von einer feindlichen Ameise besiegt wurde. + /// + Beaten = 4 + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreMarker.cs b/SimulationCore/Simulation/CoreMarker.cs new file mode 100644 index 0000000..e3e08eb --- /dev/null +++ b/SimulationCore/Simulation/CoreMarker.cs @@ -0,0 +1,102 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation { + /// + /// Eine Duft-Markierung die eine Information enthält. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + internal sealed class CoreMarker : ICoordinate { + // Die Id der nächsten erzeugten Markierung. + private static int neueId = 0; + + /// + /// Die Id die die Markierung während eines Spiels eindeutig identifiziert. + /// + public readonly int Id; + + private readonly int colonyId; + + private int age = 0; + private int ausbreitung; + private int information; + private CoreCoordinate koordinate; + private int maximalAlter; + + /// + /// Erzeugt eine neue Instanz der Markierung-Klasse. + /// + /// Die Koordinate der Markierung. + /// Die Ausbreitung der Markierung in Schritten. + /// + /// ID des Volkes + internal CoreMarker(CoreCoordinate koordinate, int ausbreitung, int colonyId) { + this.colonyId = colonyId; + Id = neueId++; + this.koordinate = koordinate; + maximalAlter = SimulationSettings.Custom.MarkerMaximumAge; + if (ausbreitung < 0) { + ausbreitung = 0; + } + else { + if (ausbreitung > SimulationSettings.Custom.MarkerRangeMaximum) + { + ausbreitung = SimulationSettings.Custom.MarkerRangeMaximum; + } + maximalAlter = + maximalAlter * SimulationSettings.Custom.MarkerSizeMinimum / + (SimulationSettings.Custom.MarkerSizeMinimum + ausbreitung); + } + this.ausbreitung = ausbreitung*SimulationEnvironment.PLAYGROUND_UNIT; + Aktualisieren(); + } + + /// + /// Die gespeicherte Information. + /// + public int Information { + get { return information; } + internal set { information = value; } + } + + /// + /// Bestimmt ob die Markierung ihre maximales Alter noch nicht überschritten + /// hat. + /// + public bool IstAktiv { + get { return age < maximalAlter; } + } + + #region IKoordinate Members + + /// + /// Die Position der Markierung auf dem Spielfeld. + /// + public CoreCoordinate CoordinateBase { + get { return koordinate; } + } + + #endregion + + /// + /// Erhöht das Alter der Markierung und passt ihren Radius an. + /// + internal void Aktualisieren() { + age++; + koordinate.Radius = SimulationSettings.Custom.MarkerSizeMinimum * SimulationEnvironment.PLAYGROUND_UNIT; + koordinate.Radius += ausbreitung * age / maximalAlter; + } + + /// + /// Erzeugt ein MarkierungZustand-Objekt mit den aktuellen Daten der + /// Markierung. + /// + internal MarkerState ErzeugeInfo() { + MarkerState info = new MarkerState(colonyId, Id); + info.PositionX = koordinate.X/SimulationEnvironment.PLAYGROUND_UNIT; + info.PositionY = koordinate.Y/SimulationEnvironment.PLAYGROUND_UNIT; + info.Radius = koordinate.Radius/SimulationEnvironment.PLAYGROUND_UNIT; + info.Direction = koordinate.Richtung; + return info; + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CorePlayground.cs b/SimulationCore/Simulation/CorePlayground.cs new file mode 100644 index 0000000..c67d85f --- /dev/null +++ b/SimulationCore/Simulation/CorePlayground.cs @@ -0,0 +1,193 @@ +using System; +using System.Collections.Generic; +using AntMe.Deutsch; + +namespace AntMe.Simulation { + /// + /// Das Spielfeld. + /// + /// Wolfgang Gallo (gallo@antme.net) + internal class CorePlayground { + public readonly List AntHills; + public readonly int Width; + public readonly int Height; + private readonly Random mapRandom; + + public readonly List Fruits; + public readonly List SugarHills; + + //TODO: Koordinate-Struktur benutzen. + private Punkt[] punkte; + + /// + /// Erzeugt eine neue Instanz der Spielfeld-Klasse. + /// + /// Die Breite in Schritten. + /// Die Höhe in Schritten. + /// Initialwert für Zufallsgenerator + public CorePlayground(int breite, int höhe, int randomSeed) { + Width = breite; + Height = höhe; + + // Random initialize with mapInitValue + if (randomSeed != 0) + { + mapRandom = new Random(randomSeed); + } + else { + mapRandom = new Random(); + } + + SugarHills = new List(); + Fruits = new List(); + AntHills = new List(); + } + + // Bestimmt den minimalen Abstand des übergebenen Punktes zu allen + // Elementen auf dem Spielfeld und dem Spielfeldrand. + private int minimum(int x, int y) { + int dx, dy; + + // Speichert die Quadrate des gemerkten und berechneten Abstandes. + // So sparen wir uns beim Pythargoras das Wurzelziehen. + int minimum, abstand; + + // Abstand zum Spielfeldrand bestimmen, diesen aber nur 1/2 Gewichten. + minimum = Math.Min(Math.Min(x, Width - x), Math.Min(y, Height - y)); + minimum *= 2; + minimum *= minimum; + + for (int index = 0; index < punkte.Length; index++) { + dx = punkte[index].X - x; + dy = punkte[index].Y - y; + abstand = dx*dx + dy*dy; + abstand -= punkte[index].Radius*punkte[index].Radius; + + minimum = Math.Min(abstand, minimum); + } + + return minimum; + } + + // Findet den Punkt mit dem angenähert minimalen Abstand zu allen Elementen + // auf dem Spielfeld und dem Spielfeldrand. + private Punkt findePunkt() { + int index = 0; + int anzahl = 4; + anzahl += SugarHills.Count; + anzahl += Fruits.Count; + anzahl += AntHills.Count; + + punkte = new Punkt[anzahl]; + foreach (CoreSugar zucker in SugarHills) { + punkte[index++] = new Punkt(zucker.CoordinateBase); + } + foreach (CoreFruit obst in Fruits) { + punkte[index++] = new Punkt(obst.CoordinateBase); + } + foreach (CoreAnthill bau in AntHills) { + punkte[index++] = new Punkt(bau.CoordinateBase); + } + + int x, y, a; + int maximum = 0; + int dx = Width/100; + int dy = Height/100; + int nx = 0; + int ny = 0; + + // Die optimale Koordinate schätzen. + for (x = 0; x < Width; x += dx) { + for (y = 0; y < Height; y += dy) { + a = minimum(x, y); + if (a > maximum) { + maximum = a; + nx = x; + ny = y; + } + } + } + + // Noch ein wenig von der optimalen Koordiante abweichen. + double radius = mapRandom.Next(0, (int) (Math.Sqrt(maximum)/3d)); + double winkel = mapRandom.Next(0, 359); + nx += (int) (radius*Math.Cos(winkel*Math.PI/180d)); + ny += (int) (radius*Math.Sin(winkel*Math.PI/180d)); + + return new Punkt(nx, ny, 0); + } + + /// + /// Erzeugt einen neuen Zuckerhaufen. + /// + public void NeuerZucker() { + Punkt punkt = findePunkt(); + int wert = mapRandom.Next(SimulationSettings.Custom.SugarAmountMinimum, SimulationSettings.Custom.SugarAmountMaximum); + SugarHills.Add(new CoreSugar(punkt.X, punkt.Y, wert)); + } + + /// + /// Erzeugt ein neues Obsttück. + /// + public void NeuesObst() { + Punkt punkt = findePunkt(); + int wert = mapRandom.Next(SimulationSettings.Custom.FruitAmountMinimum, SimulationSettings.Custom.FruitAmountMaximum); + Fruits.Add(new CoreFruit(punkt.X, punkt.Y, wert)); + } + + /// + /// Erzeugt einen neuen Bau. + /// + /// Id of colony + /// Der neue Bau. + public CoreAnthill NeuerBau(int colony) { + Punkt punkt = findePunkt(); + CoreAnthill bau = new CoreAnthill(punkt.X, punkt.Y, SimulationSettings.Custom.AntHillRadius, colony); + AntHills.Add(bau); + return bau; + } + + #region Nested type: Punkt + + private struct Punkt { + /// + /// Der Radius. + /// + public int Radius; + + /// + /// Die X-Koordinate. + /// + public int X; + + /// + /// Die Y-Koordinate. + /// + public int Y; + + /// + /// Erzeugt eine neue Instant der Punkt-Struktur. + /// + /// Die X-Koordinate. + /// Die Y-Koordinate. + /// Der Radius. + public Punkt(int x, int y, int radius) { + X = x; + Y = y; + Radius = radius; + } + + /// + /// Erzeugt eine neue Instant der Punkt-Struktur aus einer Koordinate. + /// + /// Die Koordinate. + public Punkt(CoreCoordinate koordinate) { + X = koordinate.X/SimulationEnvironment.PLAYGROUND_UNIT; + Y = koordinate.Y/SimulationEnvironment.PLAYGROUND_UNIT; + Radius = koordinate.Radius/SimulationEnvironment.PLAYGROUND_UNIT; + } + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreSugar.cs b/SimulationCore/Simulation/CoreSugar.cs new file mode 100644 index 0000000..6930c78 --- /dev/null +++ b/SimulationCore/Simulation/CoreSugar.cs @@ -0,0 +1,30 @@ +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation { + /// + /// Represents a sugar-Hill. + /// + internal sealed class CoreSugar : CoreFood { + /// + /// Creates an instance of CoreSugar. + /// + /// The x-position of sugar on playground. + /// The y-position of sugar on playground. + /// The amount of food. + internal CoreSugar(int x, int y, int amount) + : base(x, y, amount) {} + + /// + /// Creates a sugar-state of this sugar-hill. + /// + /// current state of that sugar-hill. + internal SugarState CreateState() { + SugarState state = new SugarState((ushort) Id); + state.PositionX = (ushort) (koordinate.X/SimulationEnvironment.PLAYGROUND_UNIT); + state.PositionY = (ushort) (koordinate.Y/SimulationEnvironment.PLAYGROUND_UNIT); + state.Radius = (ushort) (koordinate.Radius/SimulationEnvironment.PLAYGROUND_UNIT); + state.Amount = (ushort) menge; + return state; + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/CoreTeam.cs b/SimulationCore/Simulation/CoreTeam.cs new file mode 100644 index 0000000..465d5d1 --- /dev/null +++ b/SimulationCore/Simulation/CoreTeam.cs @@ -0,0 +1,33 @@ +using System; +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation +{ + internal sealed class CoreTeam + { + internal readonly int Id; + internal readonly Guid Guid; + internal readonly string Name; + internal CoreColony[] Colonies; + + public CoreTeam(int id, Guid guid, string name) + { + Id = id; + Guid = guid; + Name = name; + } + + public TeamState CreateState() + { + TeamState state = new TeamState(Id, Guid, Name); + + for (int i = 0; i < Colonies.Length; i++) + { + Colonies[i].Statistik.CurrentAntCount = Colonies[i].Insects.Count; + state.ColonyStates.Add(Colonies[i].ErzeugeInfo()); + } + + return state; + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/DebugMessage.cs b/SimulationCore/Simulation/DebugMessage.cs new file mode 100644 index 0000000..bd8e290 --- /dev/null +++ b/SimulationCore/Simulation/DebugMessage.cs @@ -0,0 +1,67 @@ +using System; + +namespace AntMe.Simulation { + /// + /// Klasse zur Weiterleitung von Debug-Information mit Kontextinformationen + /// + [Serializable] + public sealed class DebugMessage { + #region interne Variablen + + private readonly int ameise; + private readonly string nachricht; + private readonly int spieler; + private readonly DateTime zeit; + + #endregion + + #region Konstruktor und Initialisierung + + /// + /// Konstruktor einer Debugnachricht + /// + /// ID des spielers + /// ID der Ameise + /// Nachricht + public DebugMessage(int spieler, int ameise, string nachricht) { + zeit = DateTime.Now; + this.spieler = spieler; + this.ameise = ameise; + this.nachricht = nachricht; + } + + #endregion + + #region Eigenschaften + + /// + /// Zeitpunkt der Nachricht + /// + public DateTime Zeit { + get { return zeit; } + } + + /// + /// Assoziierter Spieler + /// + public int Spieler { + get { return spieler; } + } + + /// + /// ID der betroffenen Ameise + /// + public int Ameise { + get { return ameise; } + } + + /// + /// Die Debugnachricht + /// + public string Nachricht { + get { return nachricht; } + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/Grid.cs b/SimulationCore/Simulation/Grid.cs new file mode 100644 index 0000000..a710c50 --- /dev/null +++ b/SimulationCore/Simulation/Grid.cs @@ -0,0 +1,525 @@ +using System.Collections; +using System.Collections.Generic; +using System.Diagnostics; + +namespace AntMe.Simulation +{ + + /// + /// Implementiert ein Zellrasterverfahren zum schnellen Auffinden von + /// Spielelementen auf dem Spielfeld. + /// + /// + /// Ein Spielelement wird unabhängig von seinem Radius in genau eine Zelle + /// einsortiert. Spielelemente "zwei Zellen weiter" werden daher auch dann + /// nicht gefunden, wenn sie (durch ihren Radius) eigentlich nahe genug + /// am Referenzelement liegen. + /// + /// Typ der Spielelemente. + /// Wolfgang Gallo (wolfgang@antme.net) + internal class Grid : ICollection + where T : ICoordinate + { + + #region Statischer Teil, Fabrikmethode + + #region Struktur GridSize + + /// + /// Speichert die Abmessungen eines Gitters. + /// + private struct GridSize + { + /// + /// Die Breite des Gitters. + /// + public readonly int Width; + + /// + /// Die Höhe des Gitters. + /// + public readonly int Height; + + /// + /// Die Seitenlänge einer Gitterzelle. + /// + public readonly int SideLength; + + /// + /// Erzeugt eine neue Instanz der Struktur. + /// + /// Die Breite des Gitters. + /// Die Höhe des Gitters. + /// Die Seitenlänge einer Gitterzelle. + public GridSize(int width, int height, int sideLength) + { + Width = width; + Height = height; + SideLength = sideLength; + } + } + + #endregion + + // Liste aller bereits erzeugten Gitter. + private static readonly Dictionary> grids = + new Dictionary>(); + + /// + /// Erzeugt ein Gitter mit den angegebenen Maßen oder gibt ein vorhandenes + /// Gitter mit diesem Maßen zurück. + /// + /// Breite des Gitters. + /// Höhe des Gitters. + /// Seitenlänge einer Gitterzelle. Bestimmt die + /// maximale Entfernung bis zu der ein Spielelement ein anderes sehen kann. + public static Grid Create(int width, int height, int sideLength) + { + GridSize size = new GridSize(width, height, sideLength); + if (!grids.ContainsKey(size)) + grids.Add(size, new Grid(size)); + return grids[size]; + } + + #endregion + + // Die Abmessungen des Gitters. + private readonly int columns; + private readonly int rows; + private readonly int sideLength; + + // Die einzelnen Gitterzellen. + private readonly List[,] cells; + + #region Konstruktoren + + /// + /// Erzeugt eine neue Instanz der Klasse. + /// + /// Die Maße des Gitters. + private Grid(GridSize size) + { + sideLength = size.SideLength; + columns = size.Width / size.SideLength + 1; + rows = size.Height / size.SideLength + 1; + + cells = new List[columns, rows]; + for (int c = 0; c < columns; c++) + for (int r = 0; r < rows; r++) + cells[c, r] = new List(); + } + + /// + /// Erzeugt einen neue Instanz der Klasse. + /// + /// Breite des Gitters. + /// Höhe des Gitters. + /// Seitenlänge einer Gitterzelle. Bestimmt die + /// maximale Entfernung bis zu der ein Spielelement ein anderes sehen kann. + public Grid(int width, int height, int sideLength) + { + this.sideLength = sideLength; + this.columns = width / sideLength + 1; + this.rows = height / sideLength + 1; + + cells = new List[this.columns, this.rows]; + for (int c = 0; c < this.columns; c++) + for (int r = 0; r < this.rows; r++) + cells[c, r] = new List(); + } + + #endregion + + #region Schnittstelle IEnumerable + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public IEnumerator GetEnumerator() + { + for (int c = 0; c < columns; c++) + for (int r = 0; r < rows; r++) + for (int i = 0; i < cells[c, r].Count; i++) + yield return cells[c, r][i]; + } + + #endregion + + #region Schnittstelle ICollection + + private int count = 0; + + public int Count + { + get { return count; } + } + + public void Clear() + { + for (int x = 0; x < columns; x++) + for (int y = 0; y < rows; y++) + cells[x, y].Clear(); + count = 0; + } + + public void Add(T element) + { + int c = element.CoordinateBase.X / sideLength; + int r = element.CoordinateBase.Y / sideLength; + if (c < 0 || c >= columns || r < 0 || r >= rows) + return; + + cells[c, r].Add(element); + count++; + } + + /// + /// Fügt dem Gitter mehrere Spielelemente hinzu. + /// + /// Eine Liste von Spielelementen. + public void Add(List elemente) + { + for (int i = 0; i < elemente.Count; i++) + Add(elemente[i]); + } + + public bool Remove(T element) + { + int c = element.CoordinateBase.X / sideLength; + int r = element.CoordinateBase.Y / sideLength; + if (c < 0 || c >= columns || r < 0 || r >= rows) + return false; + + bool success = cells[c, r].Remove(element); + if (success) + count--; + return success; + } + + /// + /// Entfernt mehrere Elemente aus dem Gitter. + /// + /// Eine Liste von Spielelementen. + public void Remove(List elemente) + { + for (int i = 0; i < elemente.Count; i++) + Remove(elemente[i]); + } + + public bool Contains(T element) + { + int c = element.CoordinateBase.X / sideLength; + int r = element.CoordinateBase.Y / sideLength; + if (c < 0 || c >= columns || r < 0 || r >= rows) + return false; + return cells[c, r].Contains(element); + } + + public void CopyTo(T[] array, int arrayIndex) + { + for (int c = 0; c < columns; c++) + for (int r = 0; c < rows; c++) + { + cells[c, r].CopyTo(array, arrayIndex); + arrayIndex += cells[c, r].Count; + } + } + + public bool IsReadOnly + { + get { return false; } + } + + #endregion + + #region Finden vom Spielelementen + + #region Klassen Tupel und TupelComparer, Sortieren von Spielelementen nach Entfernung + + private readonly TupelComparer comparer = new TupelComparer(); + + private class Tupel + { + public readonly ICoordinate Element; + public readonly int Distance; + + public Tupel(ICoordinate element, int distance) + { + Element = element; + Distance = distance; + } + } + + private class TupelComparer : IComparer where T : Tupel + { + public int Compare(T t1, T t2) + { + return t1.Distance.CompareTo(t2.Distance); + } + } + + #endregion + + /// + /// Findet alle Spielelemente innerhalb des gegebenen Sichtkreis des gegebenen Spielelements. + /// + /// Das Referenzspielelement. + /// Die maximale Entfernung. + /// Eine nach Entfernung sortierte Liste von Spielelementen. + public List FindSorted(ICoordinate coordinate, int maximumDistance) + { + // Speichert alle gefundenen Tupel (Spielelement, Entfernung). + List tupels = new List(); + + // Bestimme die Zelle in der das übergebene Spielelement sich befindet. + int col = coordinate.CoordinateBase.X / sideLength; + int row = coordinate.CoordinateBase.Y / sideLength; + + // Betrachte die Zelle und die acht Zellen daneben. + for (int c = -1; c <= 1; c++) + if (col + c >= 0 && col + c < columns) + for (int r = -1; r <= 1; r++) + if (row + r >= 0 && row + r < rows) + { + List cell = cells[col + c, row + r]; + for (int i = 0; i < cell.Count; i++) + { + if (cell[i].Equals(coordinate)) + continue; + + int distance = CoreCoordinate.BestimmeEntfernungI(coordinate.CoordinateBase, cell[i].CoordinateBase); + if (distance <= maximumDistance) + tupels.Add(new Tupel(cell[i], distance)); + } + } + + // Sortiere die Tupel und gib die Spielelemente zurück. + tupels.Sort(comparer); + List elements = new List(tupels.Count); + for (int i = 0; i < tupels.Count; i++) + elements.Add((T)tupels[i].Element); + return elements; + } + + /// + /// Findet alle Spielelemente innerhalb des Sichtkreis der gegebenen Wanze. + /// + /// + /// Die Simulation legt ein Gitter mit der maximalen Sichtweite der Wanzen als + /// Seitenlänge an und benutzt diese Methode auf dieser Instanz zum Finden von + /// Ameisen. In dieses Gitter werden nur Ameisen einsortiert. + /// + /// Die Referenzwanze. + /// Eine Liste von Ameisen. + public List FindAnts(CoreBug bug) + { + // Speichert alle gefundenen Ameisen. + List ants = new List(); + + // Bestimme die Zelle in der die übergebene Wanze sich befindet. + int col = bug.CoordinateBase.X / sideLength; + int row = bug.CoordinateBase.Y / sideLength; + + // Betrachte die Zelle und die acht Zellen daneben. + for (int c = -1; c <= 1; c++) + if (col + c >= 0 && col + c < columns) + for (int r = -1; r <= 1; r++) + if (row + r >= 0 && row + r < rows) + { + List cell = cells[col + c, row + r]; + for (int i = 0; i < cell.Count; i++) + { + int distance = CoreCoordinate.BestimmeEntfernungI(bug.CoordinateBase, cell[i].CoordinateBase); + if (distance <= sideLength) + ants.Add(cell[i]); + } + } + + return ants; + } + + /// + /// Findet die Markierung, die die gegebene Ameise noch nicht gerochen hat + /// und die der Ameise am nächsten liegt. + /// + /// + /// Die Simulation legt ein Gitter mit dem maximalen Radius einer Markierung als + /// Seitenlänge an und benutzt diese Methode auf dieser Instanz zum Finden von + /// Markierungen. In dieses Gitter werden nur Markierungen einsortiert. + /// + /// Die Referenzameise. + /// Eine Markierung. + public CoreMarker FindMarker(CoreAnt ant) + { + CoreMarker nearestMarker = null; + int nearestMarkerDistance = int.MaxValue; + + // Bestimme die Zelle in der die übergebene Ameise sich befindet. + int col = ant.CoordinateBase.X / sideLength; + int row = ant.CoordinateBase.Y / sideLength; + + // Betrachte die Zelle und die acht Zellen daneben. + for (int c = -1; c <= 1; c++) + if (col + c >= 0 && col + c < columns) + for (int r = -1; r <= 1; r++) + if (row + r >= 0 && row + r < rows) + { + List cell = cells[col + c, row + r]; + + // Betrachte alle Markierungen in der aktuellen Zelle. + for (int i = 0; i < cell.Count; i++) + { + CoreMarker marker = cell[i] as CoreMarker; + Debug.Assert(marker != null); + + // Bestimme die Entfernung der Mittelpunkte und der Kreise. + int distance = CoreCoordinate.BestimmeEntfernungDerMittelpunkteI(ant.CoordinateBase, marker.CoordinateBase); + int circleDistance = distance - ant.CoordinateBase.Radius - marker.CoordinateBase.Radius; + + // Die neue Markierung wurde noch nicht gerochen und + // liegt näher als die gemerkte. + if (circleDistance <= 0 && distance < nearestMarkerDistance && + !ant.SmelledMarker.Contains(marker)) + { + nearestMarkerDistance = distance; + nearestMarker = marker; + } + } + } + + return nearestMarker; + } + + /// + /// Findet die Wanze, die feindliche Ameise und die befreundete Ameise mit der + /// geringsten Entfernung innerhalb des Sichtkreis der gegebenen Ameise und + /// zählt die Anzahl an Wanzen, feindlichen und befreundeten Ameisen im Sichtkreis. + /// + /// + /// Wird für Ameisen verwendet. Die Simulation legt für jeden vorkommenden Sichtradius + /// eine eigenes Gitter an und benutzt diese Methode auf der passenden Instanz zum Finden + /// von Insekten. Die Seitenlänge dieses Gitters ist also der Sichradius der Ameise. + /// In diese Gitter werden Wanzen und Ameisen einsortiert. + /// + /// Die Referenzameise. + /// Eine Wanze. + /// Die Anzahl an Wanzen. + /// Eine feindliche Ameise. + /// Die Anzahl an feindlichen Ameisen. + /// Eine befreundete Ameise. + /// Die Anzahl an befreundeten Ameisen. + /// Die Anzahl an befreundeten Ameisen der selben Kaste. + public void FindAndCountInsects(CoreAnt ant, out CoreBug nearestBug, out int bugCount, + out CoreAnt nearestEnemyAnt, out int enemyAntCount, out CoreAnt nearestColonyAnt, + out int colonyAntCount, out int casteAntCount, out CoreAnt nearestTeamAnt, + out int teamAntCount) + { + // Die nächstliegenden gefundenen Wanzen und Ameisen. + nearestBug = null; + nearestEnemyAnt = null; + nearestColonyAnt = null; + nearestTeamAnt = null; + + // Die Entfernungen zu den nächstliegenden gefundenen Wanzen und Ameisen. + int nearestBugDistance = int.MaxValue; + int nearestEnemyAntDistance = int.MaxValue; + int nearestColonyAntDistance = int.MaxValue; + int nearestTeamAntDistance = int.MaxValue; + + // Die Anzahlen der gefundenen Wanzen und Ameisen. + bugCount = 0; + enemyAntCount = 0; + colonyAntCount = 0; + casteAntCount = 0; + teamAntCount = 0; + + // Bestimme die Zelle in der die übergebene Ameise sich befindet. + int col = ant.CoordinateBase.X / sideLength; + int row = ant.CoordinateBase.Y / sideLength; + + // Betrachte die Zelle und die acht Zellen daneben. + for (int c = -1; c <= 1; c++) + if (col + c >= 0 && col + c < columns) + for (int r = -1; r <= 1; r++) + if (row + r >= 0 && row + r < rows) + { + + // Betrachte alle Insekten in der aktuellen Zelle. + List cell = cells[col + c, row + r]; + for (int i = 0; i < cell.Count; i++) + { + CoreInsect insect = cell[i] as CoreInsect; + Debug.Assert(insect != null); + + if (insect == ant) + continue; + + // Vergleiche die Entfernung zum aktuellen Insekt mit der + // Sichtweite der Ameise bzw. der Seitenlänge des Gitters. + int distance = CoreCoordinate.BestimmeEntfernungI(ant.CoordinateBase, insect.CoordinateBase); + if (distance > sideLength) + continue; + + // Selbes Volk. Die Abfrage "insect is CoreAnt" ist unnötig. + if (insect.colony == ant.colony) + { + colonyAntCount++; + if (insect.CasteIndexBase == ant.CasteIndexBase) + casteAntCount++; + + // Die neue Ameise liegt näher als die gemerkte. + if (distance < nearestColonyAntDistance) + { + nearestColonyAntDistance = distance; + nearestColonyAnt = (CoreAnt)insect; + } + } + + // Selbes Team. + else if (insect.colony.Team == ant.colony.Team) + { + teamAntCount++; + + // Die neue Ameise liegt näher als die gemerkte. + if (distance < nearestTeamAntDistance) + { + nearestTeamAntDistance = distance; + nearestTeamAnt = (CoreAnt)insect; + } + } + + // Wanze. + else if (insect is CoreBug) + { + bugCount++; + + // Die neue Wanze liegt näher als die gemerkte. + if (distance < nearestBugDistance) + { + nearestBugDistance = distance; + nearestBug = (CoreBug)insect; + } + } + + // Feindliche Ameise. + else + { + enemyAntCount++; + + // Die neue Ameise liegt näher als die gemerkte. + if (distance < nearestEnemyAntDistance) + { + nearestEnemyAntDistance = distance; + nearestEnemyAnt = (CoreAnt)insect; + } + } + } + } + } + + #endregion + + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/ICoordinate.cs b/SimulationCore/Simulation/ICoordinate.cs new file mode 100644 index 0000000..d7e8d90 --- /dev/null +++ b/SimulationCore/Simulation/ICoordinate.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AntMe.Simulation +{ + /// + /// Ermöglicht es, die Koordinate eines Objekts auf dem Spielfeld abzufragen. + /// + /// Wolfgang Gallo (wolfgang@antme.net) + public interface ICoordinate + { + /// + /// Liest die Koordinate eines Objekts auf dem Spielfeld aus. + /// + CoreCoordinate CoordinateBase { get; } + } +} diff --git a/SimulationCore/Simulation/PlayerCall.cs b/SimulationCore/Simulation/PlayerCall.cs new file mode 100644 index 0000000..b28b007 --- /dev/null +++ b/SimulationCore/Simulation/PlayerCall.cs @@ -0,0 +1,370 @@ +using System; +using System.Security; +using System.Security.Permissions; + +namespace AntMe.Simulation { + /// + /// Static Class to encapsulate player-calls to his ant. + /// + internal static class PlayerCall { + private static readonly PermissionSet playerRights; + + /// + /// Creates a static instance of PlayerCall + /// + static PlayerCall() { + // set the rights for players + playerRights = new PermissionSet(PermissionState.None); + playerRights.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution)); + } + + public static event AreaChangeEventHandler AreaChanged; + + #region Movement + + /// + /// Perform call to "Waits()" on given ant. + /// + /// ant + public static void Waits(CoreAnt ant) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.Waits)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.WartetBase(); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der Wartet()-Methode", ex); + } + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + /// + /// Perform call to "BecomesTired()" on given ant. + /// + /// ant + public static void BecomesTired(CoreAnt ant) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.BecomesTired)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.WirdMüdeBase(); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der WirdMüde()-Methode", ex); + } + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + #endregion + + #region Food + + /// + /// Perform call to "Spots(Sugar)" on given ant. + /// + /// ant + /// sugar + public static void Spots(CoreAnt ant, CoreSugar sugar) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsSugar)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.SiehtBase(sugar); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der Sieht(Zucker)-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + /// + /// Perform call to "Spots(Fruit)" on given ant. + /// + /// ant + /// fruit + public static void Spots(CoreAnt ant, CoreFruit fruit) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsFruit)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.SiehtBase(fruit); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der Sieht(Obst)-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + /// + /// Perform call to "TargetReached(Sugar)" on given ant. + /// + /// ant + /// sugar + public static void TargetReached(CoreAnt ant, CoreSugar sugar) { + AreaChanged( + null, + new AreaChangeEventArgs(ant.colony.Player, Area.ReachedSugar)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.ZielErreichtBase(sugar); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der ZielErreicht(Zucker)-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + /// + /// Perform call to "TargetReached(Fruit)" on given ant. + /// + /// ant + /// fruit + public static void TargetReached(CoreAnt ant, CoreFruit fruit) { + AreaChanged( + null, + new AreaChangeEventArgs(ant.colony.Player, Area.ReachedFruit)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.ZielErreichtBase(fruit); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der ZielErreicht(Obst)-Methode", ex); + } + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + #endregion + + #region Communication + + /// + /// Perform call to "SmellsFriend()" on given ant. + /// + /// ant + /// marker + public static void SmellsFriend(CoreAnt ant, CoreMarker marker) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.SmellsFriend)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.RiechtFreundBase(marker); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der RiechtFreund(Markierung)-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + /// + /// Perform call to "SpotsFriend()" on given ant. + /// + /// ant + /// friendly ant + public static void SpotsFriend(CoreAnt ant, CoreAnt friend) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsFriend)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.SiehtFreundBase(friend); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der SiehtFreund(Ameise)-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + /// + /// Perform call to "SpotsTeamMember()" on given ant. + /// + /// ant + /// friendly ant + public static void SpotsTeamMember(CoreAnt ant, CoreAnt friend) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsTeamMember)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.SiehtVerbündetenBase(friend); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der SiehtVerbündeten(Ameise)-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + #endregion + + #region Fight + + /// + /// Perform call to "Spots(Bug)" on given ant. + /// + /// ant + /// bug + public static void SpotsEnemy(CoreAnt ant, CoreBug bug) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsBug)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.SiehtFeindBase(bug); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der SiehtFeind(Wanze)-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + /// + /// Perform call to "Spots(Ant)" on given ant. + /// + /// ant + /// foreign ant + public static void SpotsEnemy(CoreAnt ant, CoreAnt enemy) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsEnemy)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.SiehtFeindBase(enemy); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der SiehtFeind(Ameise)-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + /// + /// Perform call to "UnderAttack(Ant)" on given ant. + /// + /// ant + /// enemy + public static void UnderAttack(CoreAnt ant, CoreAnt enemy) { + AreaChanged( + null, + new AreaChangeEventArgs(ant.colony.Player, Area.UnderAttackByAnt)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.WirdAngegriffenBase(enemy); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der WirdAngegriffen(Ameise)-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + /// + /// Perform call to "UnderAttack(Bug)" on given ant. + /// + /// ant + /// bug + public static void UnderAttack(CoreAnt ant, CoreBug bug) { + AreaChanged( + null, + new AreaChangeEventArgs( + ant.colony.Player, Area.UnderAttackByBug)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.WirdAngegriffenBase(bug); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der WirdAngegriffen(Wanze)-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + #endregion + + #region Misc + + /// + /// Perform call to "HasDied()" on given ant. + /// + /// ant + /// kind of death + public static void HasDied(CoreAnt ant, CoreKindOfDeath kindOfDeath) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.HasDied)); + playerRights.PermitOnly(); + try { + ant.IstGestorbenBase(kindOfDeath); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der IstGestorben()-Methode", ex); + } + + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + /// + /// Perform call to "Tick()" on given ant. + /// + /// ant + public static void Tick(CoreAnt ant) { + AreaChanged( + null, new AreaChangeEventArgs(ant.colony.Player, Area.Tick)); + playerRights.PermitOnly(); + ant.NimmBefehleEntgegen = true; + try { + ant.TickBase(); + } + catch (Exception ex) { + throw new AiException("KI-Fehler in der Tick()-Methode", ex); + } + + ant.NimmBefehleEntgegen = false; + AreaChanged( + null, new AreaChangeEventArgs(null, Area.Unknown)); + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/PlayerInfo.cs b/SimulationCore/Simulation/PlayerInfo.cs new file mode 100644 index 0000000..1dcf59e --- /dev/null +++ b/SimulationCore/Simulation/PlayerInfo.cs @@ -0,0 +1,259 @@ +using System; +using System.Collections.Generic; +using System.Reflection; + +namespace AntMe.Simulation { + /// + /// Holds all meta-information about a player. + /// + [Serializable] + public class PlayerInfo : ICloneable { + #region lokale Variablen + + /// + /// List of all castes. + /// + private readonly List castes; + + /// + /// Reference to the ai-assembly-file. + /// + internal Assembly assembly; + + /// + /// true, if the Ai gives some debug-information. + /// + public bool HasDebugInformation; + + /// + /// Guid of player. + /// + public Guid Guid; + + /// + /// Name of colony. + /// + public string ColonyName; + + /// + /// Complete Class-name of colony-class. + /// + public string ClassName; + + /// + /// true, if the colony needs access to a database. + /// + public bool RequestDatabaseAccess; + + /// + /// true, if the colony needs access to files. + /// + public bool RequestFileAccess; + + /// + /// true, if the colony needs access to the network. + /// + public bool RequestNetworkAccess; + + /// + /// Additional information about access-requests. + /// + public string RequestInformation; + + /// + /// true, if the colony has references to other assemblies. + /// + public bool RequestReferences; + + /// + /// true, if the colony needs access to user-interfaces. + /// + public bool RequestUserInterfaceAccess; + + /// + /// Last name of colony-author. + /// + public string LastName; + + /// + /// First name of colony-author. + /// + public string FirstName; + + /// + /// Language of colony. + /// + public PlayerLanguages Language; + + /// + /// true, if the colony uses any static types. + /// + public bool Static; + + /// + /// Simulator-Version of this colony. + /// + public PlayerSimulationVersions SimulationVersion; + + #endregion + + #region Constructor and Initializaion + + /// + /// Creates a new instance of PlayerInfo. + /// + public PlayerInfo() { + // Init default-values + Guid = System.Guid.NewGuid(); + ColonyName = string.Empty; + FirstName = string.Empty; + LastName = string.Empty; + ClassName = string.Empty; + SimulationVersion = PlayerSimulationVersions.Version_1_6; + Language = PlayerLanguages.Unknown; + Static = true; + castes = new List(); + HasDebugInformation = false; + RequestUserInterfaceAccess = false; + RequestDatabaseAccess = false; + RequestFileAccess = false; + RequestReferences = false; + RequestNetworkAccess = false; + RequestInformation = string.Empty; + } + + /// + /// Creates a new instance of PlayerInfo. + /// + /// Base-info + public PlayerInfo(PlayerInfo info) { + // Daten kopieren + Guid = info.Guid; + ColonyName = info.ColonyName; + FirstName = info.FirstName; + LastName = info.LastName; + ClassName = info.ClassName; + SimulationVersion = info.SimulationVersion; + Language = info.Language; + Static = info.Static; + castes = info.castes; + HasDebugInformation = info.HasDebugInformation; + RequestUserInterfaceAccess = info.RequestUserInterfaceAccess; + RequestDatabaseAccess = info.RequestDatabaseAccess; + RequestFileAccess = info.RequestFileAccess; + RequestReferences = info.RequestReferences; + RequestNetworkAccess = info.RequestNetworkAccess; + RequestInformation = info.RequestInformation; + } + + /// + /// Creates a new instance of PlayerInfo. + /// + /// Guid of colony + /// Name of colony + /// Last name of author + /// First name of author + /// Class-name of colony + /// Colony uses static types + /// Version of simulator of this colony + /// Language of this colony + /// List of castes + /// Colony produces debug-information + /// Needs access to user-interfaces + /// Needs access to databases + /// Needs access to files + /// Needs access to network + /// Needs references to other assemblies + /// Additional information about security-requests + public PlayerInfo( + Guid guid, + string colonyName, + string firstName, + string lastName, + string className, + PlayerSimulationVersions simulationVersion, + PlayerLanguages language, + bool staticVariables, + List castes, + bool haveDebugInformation, + bool requestUserinterfaceAccess, + bool requestDatabaseAccess, + bool requestFileAccess, + bool requestNetworkAccess, + bool requestReferences, + string requestInformation) + { + // Ameisenkasten überprüfen + if (castes == null) { + this.castes = new List(); + } + else { + this.castes = castes; + } + + // Restliche Daten übertragen + Guid = guid; + ColonyName = colonyName; + FirstName = firstName; + LastName = lastName; + ClassName = className; + SimulationVersion = simulationVersion; + Language = language; + Static = staticVariables; + HasDebugInformation = haveDebugInformation; + RequestUserInterfaceAccess = requestUserinterfaceAccess; + RequestDatabaseAccess = requestDatabaseAccess; + RequestFileAccess = requestFileAccess; + RequestNetworkAccess = requestNetworkAccess; + RequestReferences = requestReferences; + RequestInformation = requestInformation; + } + + #endregion + + #region Hilfsmethoden + + /// + /// Checks the rules. + /// + /// + public void RuleCheck() { + + // Invalidate colonies without a name + if (string.IsNullOrEmpty(ColonyName)) { + throw new RuleViolationException( + string.Format(Resource.SimulationCorePlayerRuleNoName, ClassName)); + } + + // Check included castes + foreach (CasteInfo caste in castes) { + caste.Rulecheck(ClassName); + } + } + + #endregion + + #region Eigenschaften + + /// + /// Delivers the list of castes. + /// + public List Castes { + get { return castes; } + } + + #endregion + + #region ICloneable Member + + /// + /// Clones the whole object + /// + /// clone + public object Clone() { + return MemberwiseClone(); + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/PlayerInfoFiledump.cs b/SimulationCore/Simulation/PlayerInfoFiledump.cs new file mode 100644 index 0000000..38bde36 --- /dev/null +++ b/SimulationCore/Simulation/PlayerInfoFiledump.cs @@ -0,0 +1,45 @@ +using System; + +namespace AntMe.Simulation { + /// + /// SpielerInfo Klasse mit der angabe eines zusätzlichen Dumps einer Spieler-KI + /// + [Serializable] + public sealed class PlayerInfoFiledump : PlayerInfo { + #region interne Variablen + + /// + /// Kopie der KI-Assembly + /// + public byte[] File; + + #endregion + + #region Initialisierung und Konstruktor + + /// + /// Creates an instance of PlayerInfoFiledump + /// + public PlayerInfoFiledump() {} + + /// + /// Konstruktor der SpielerInfo mit Dateikopie + /// Kopie der Datei in Form eines Byte[] + /// + public PlayerInfoFiledump(byte[] file) { + File = file; + } + + /// + /// Konstruktor der SpielerInfo mit Dateikopie + /// + /// Basis SpielerInfo + /// Kopie der Datei in Form eines Byte[] + public PlayerInfoFiledump(PlayerInfo info, byte[] file) + : base(info) { + File = file; + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/PlayerInfoFilename.cs b/SimulationCore/Simulation/PlayerInfoFilename.cs new file mode 100644 index 0000000..d76a9ce --- /dev/null +++ b/SimulationCore/Simulation/PlayerInfoFilename.cs @@ -0,0 +1,61 @@ +using System; + +namespace AntMe.Simulation { + /// + /// Spielerinfo mit zusätzlicher Angabe eines Dateinamens + /// + [Serializable] + public sealed class PlayerInfoFilename : PlayerInfo { + #region interne Variablen + + /// + /// Pfad zur KI-Datei + /// + public string File; + + #endregion + + #region Initialisierung und Konstruktor + + /// + /// Creates an instance of PlayerInfoFilename + /// + public PlayerInfoFilename() {} + + /// + /// Konstruktor der SpielerInfo mit Dateinamen + /// + public PlayerInfoFilename(string file) { + File = file; + } + + /// + /// Konstruktor der SpielerInfo mit Dateinamen + /// + /// + /// + public PlayerInfoFilename(PlayerInfo info, string file) : base(info) { + File = file; + } + + #endregion + + /// + /// Ermittelt, ob die KIs gleich sind + /// + /// + /// + public override bool Equals(object obj) { + PlayerInfoFilename other = (PlayerInfoFilename) obj; + return (GetHashCode() == other.GetHashCode()); + } + + /// + /// Erzeugt einen Hash aus den gegebenen Daten + /// + /// Hashcode + public override int GetHashCode() { + return File.GetHashCode() ^ ClassName.GetHashCode(); + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/PlayerLanguage.cs b/SimulationCore/Simulation/PlayerLanguage.cs new file mode 100644 index 0000000..917e178 --- /dev/null +++ b/SimulationCore/Simulation/PlayerLanguage.cs @@ -0,0 +1,23 @@ +using System; +namespace AntMe.Simulation { + /// + /// List of possible player-languages. + /// + [Flags] + public enum PlayerLanguages { + /// + /// Unknown language + /// + Unknown = 0, + + /// + /// German + /// + Deutsch = 1, + + /// + /// English + /// + English = 2 + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/PlayerSimulationVersion.cs b/SimulationCore/Simulation/PlayerSimulationVersion.cs new file mode 100644 index 0000000..60ae15d --- /dev/null +++ b/SimulationCore/Simulation/PlayerSimulationVersion.cs @@ -0,0 +1,35 @@ +using System; + +namespace AntMe.Simulation { + /// + /// List of possible versions of simulation. + /// + [Flags] + public enum PlayerSimulationVersions { + + /// + /// Version 1.1 - Singleplayer-Variante + /// + Version_1_1 = 1, + + /// + /// Version 1.5 - war nur als Beta verfügbar und stellt die erste Multiplayer-Variante dar + /// + Version_1_5 = 2, + + /// + /// Version 1.6 - die Basis für die erste Online-Version + /// + Version_1_6 = 4, + + /// + /// fx 4.0 Port of Version 1.6 + /// + Version_1_7 = 8, + + /// + /// Version 2.0 - Bisher nicht vorhanden + /// + Version_2_0 = 16 + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/PlayerStatistics.cs b/SimulationCore/Simulation/PlayerStatistics.cs new file mode 100644 index 0000000..37ba408 --- /dev/null +++ b/SimulationCore/Simulation/PlayerStatistics.cs @@ -0,0 +1,89 @@ +using System; + +namespace AntMe.Simulation { + /// + /// Speichert die Statistik eines Spielers. + /// + [Serializable] + public struct PlayerStatistics { + /// + /// Die aktuelle Anzahl an Ameisen. + /// + public int CurrentAntCount; + + private int LoopCount; + + /// + /// Die Anzahl der durch eigene Ameisen besiegten feindlichen Ameisen. + /// + public int KilledAnts; + + /// + /// Die Anzahl der besiegten Wanzen. + /// + public int KilledBugs; + + /// + /// Die Anzahl der gesammelten Nahrungspunkte. + /// + public int CollectedFood; + + /// + /// Anzahl gesammeltem Obst. + /// + public int CollectedFruits; + + /// + /// Die Anzahl der verhungerten Ameisen. + /// + public int StarvedAnts; + + /// + /// Die Anzahl der von feindlichen Ameisen besiegten eigenen Ameisen. + /// + public int BeatenAnts; + + /// + /// Die Anzahl der von Wanzen gefressenen Ameisen. + /// + public int EatenAnts; + + /// + /// Gibt die Gesamtpunktzahl zurück. + /// + public int Points { + get { + return ( + (int)(SimulationSettings.Custom.PointsForFoodMultiplier * CollectedFood) + + (SimulationSettings.Custom.PointsForFruits * CollectedFruits) + + (SimulationSettings.Custom.PointsForBug * KilledBugs) + + (SimulationSettings.Custom.PointsForForeignAnt * KilledAnts) + + (SimulationSettings.Custom.PointsForBeatenAnts * BeatenAnts) + + (SimulationSettings.Custom.PointsForEatenAnts * EatenAnts) + + (SimulationSettings.Custom.PointsForStarvedAnts * StarvedAnts) + )/Math.Max(LoopCount, 1); + } + } + + /// + /// Zählt zwei Statistiken zusammen. + /// + /// Statistik 1. + /// Statistik 2. + /// Statistik 1 + Statistik 2. + public static PlayerStatistics + operator +(PlayerStatistics s1, PlayerStatistics s2) { + PlayerStatistics s = new PlayerStatistics(); + s.CollectedFood = s1.CollectedFood + s2.CollectedFood; + s.CollectedFruits = s1.CollectedFruits + s2.CollectedFruits; + s.CurrentAntCount = s1.CurrentAntCount + s2.CurrentAntCount; + s.StarvedAnts = s1.StarvedAnts + s2.StarvedAnts; + s.EatenAnts = s1.EatenAnts + s2.EatenAnts; + s.BeatenAnts = s1.BeatenAnts + s2.BeatenAnts; + s.KilledAnts = s1.KilledAnts + s2.KilledAnts; + s.KilledBugs = s1.KilledBugs + s2.KilledBugs; + s.LoopCount = Math.Max(s1.LoopCount + s2.LoopCount, 2); + return s; + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/RuleViolationException.cs b/SimulationCore/Simulation/RuleViolationException.cs new file mode 100644 index 0000000..557c385 --- /dev/null +++ b/SimulationCore/Simulation/RuleViolationException.cs @@ -0,0 +1,36 @@ +using System; +using System.Runtime.Serialization; +using AntMe.SharedComponents; + +namespace AntMe.Simulation { + /// + /// Wird bei einer Regelverletzung der AntMe-Spielregeln geworfen + /// + [Serializable] + public sealed class RuleViolationException : AntMeException { + /// + /// KOnstruktor der Regelverletzung ohne weitere Angaben + /// + public RuleViolationException() { } + + /// + /// Konsruktor der Regelverletzung mit der Übergabe einer Beschreibung zur Verletzung + /// + /// Beschreibung der Regelverletzung + public RuleViolationException(string message) : base(message) { } + + /// + /// Konstruktor zur Regelverletung mit übergabe einer Nachricht sowie einer verursachenden Exception + /// + /// Beschreibung zum Problem + /// Verursachende Exception + public RuleViolationException(string message, Exception innerException) : base(message, innerException) { } + + /// + /// Konstruktor für die Serialisierung dieser Exception + /// + /// + /// + public RuleViolationException(SerializationInfo info, StreamingContext context) : base(info, context) { } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/SimulationCasteSettings.cs b/SimulationCore/Simulation/SimulationCasteSettings.cs new file mode 100644 index 0000000..8822dc6 --- /dev/null +++ b/SimulationCore/Simulation/SimulationCasteSettings.cs @@ -0,0 +1,74 @@ +using System; +using System.Configuration; + +namespace AntMe.Simulation { + /// + /// Holds the set of caste-Settings. + /// + [Serializable] + public struct SimulationCasteSettings { + /// + /// Offset to shift the array-index. + /// + public int Offset; + + /// + /// Sum of all points. + /// + public int Sum; + + /// + /// List of caste-setting-columns. + /// + public SimulationCasteSettingsColumn[] Columns; + + /// + /// Gives the lowest Column-Index. + /// + public int MinIndex { + get { return Offset; } + } + + /// + /// Gives the highest Column-Index. + /// + public int MaxIndex { + get { return Offset + Columns.Length -1; } + } + + /// + /// Delivers the right caste-column. + /// + /// index of column + /// caste-Column + public SimulationCasteSettingsColumn this[int index] { + get { + if (index < Offset) { + throw new IndexOutOfRangeException(Resource.SimulationCoreSettingsCasteColumnToSmall); + } + else if (index > MaxIndex) { + throw new IndexOutOfRangeException(Resource.SimulationCoreSettingsCasteColumnToBig); + } + + // Deliver the right column + return Columns[index - Offset]; + } + } + + /// + /// Checks the value-ranges of all properties. + /// + public void RuleCheck() { + + if (Offset > 0) + { + throw new ConfigurationErrorsException("Ein Kasten-Offset darf nicht größer als 0 sein"); + } + + foreach (SimulationCasteSettingsColumn column in Columns) + { + column.RuleCheck(); + } + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/SimulationCasteSettingsColumn.cs b/SimulationCore/Simulation/SimulationCasteSettingsColumn.cs new file mode 100644 index 0000000..12b9420 --- /dev/null +++ b/SimulationCore/Simulation/SimulationCasteSettingsColumn.cs @@ -0,0 +1,184 @@ +using System; +using System.Configuration; + +namespace AntMe.Simulation { + /// + /// Holds a set of caste-Settings in one column. + /// + [Serializable] + public struct SimulationCasteSettingsColumn { + + /// + /// Minimum attack-value + /// + public const int ATTACK_MINIMUM = 0; + + /// + /// Maximum attack-value + /// + public const int ATTACK_MAXIMUM = 999999; + + /// + /// Minimum rotationspeed + /// + public const int ROTATIONSPEED_MINIMUM = 0; + + /// + /// Maximum rotationspeed + /// + public const int ROTATIONSPEED_MAXIMUM = 360; + + /// + /// Minimum rotationspeed + /// + public const int ENERGY_MINIMUM = 1; + /// + /// Maximum rotationspeed + /// + public const int ENERGY_MAXIMUM = 999999; + + /// + /// Minimum rotationspeed + /// + public const int SPEED_MINIMUM = 0; + /// + /// Maximum rotationspeed + /// + public const int SPEED_MAXIMUM = 9999; + + /// + /// Minimum load + /// + public const int LOAD_MINIMUM = 0; + + /// + /// Maximum load + /// + public const int LOAD_MAXIMUM = 9999; + + /// + /// Minimum range + /// + public const int RANGE_MINIMUM = 1; + + /// + /// Maximum range + /// + public const int RANGE_MAXIMUM = 999999; + + /// + /// Minimum viewrange + /// + public const int VIEWRANGE_MINIMUM = 0; + + /// + /// Maximum viewrange + /// + public const int VIEWRANGE_MAXIMUM = 9999; + + /// + /// Attack-Value (Hit-points per Round) + /// + public int Attack; + + /// + /// Rotation-speed (Degrees per Round) + /// + public int RotationSpeed; + + /// + /// Hit-points-Value (Total points) + /// + public int Energy; + + /// + /// Speed-Value (Steps per Round) + /// + public int Speed; + + /// + /// Load-Value (total food-load) + /// + public int Load; + + /// + /// Range-Value (total count of steps per life) + /// + public int Range; + + /// + /// View-range-Value (range in steps) + /// + public int ViewRange; + + /// + /// Checks, if values are valid + /// + public void RuleCheck() { + + if (Attack < ATTACK_MINIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei Attack (Aktuell: {0}) muss größer oder gleich {1} sein", Attack, ATTACK_MINIMUM)); + } + if (Attack > ATTACK_MAXIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei Attack (Aktuell: {0}) muss kleiner oder gleich {1} sein", Attack, ATTACK_MINIMUM)); + } + + + if (RotationSpeed < ROTATIONSPEED_MINIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei RotationSpeed (Aktuell: {0}) muss größer oder gleich {1} sein", RotationSpeed, ROTATIONSPEED_MINIMUM)); + } + if (RotationSpeed > ROTATIONSPEED_MAXIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei RotationSpeed (Aktuell: {0}) muss kleiner oder gleich {1} sein", RotationSpeed, ROTATIONSPEED_MAXIMUM)); + } + + if (Energy < ENERGY_MINIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei Energy (Aktuell: {0}) muss größer oder gleich {1} sein", Energy, ENERGY_MINIMUM)); + } + if (Energy > ENERGY_MAXIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei Energy (Aktuell: {0}) muss kleiner oder gleich {1} sein", Energy, ENERGY_MAXIMUM)); + } + + if (Speed < SPEED_MINIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei Speed (Aktuell: {0}) muss größer oder gleich {1} sein", Speed, SPEED_MINIMUM)); + } + if (Speed > SPEED_MAXIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei Speed (Aktuell: {0}) muss kleiner oder gleich {1} sein", Speed, SPEED_MAXIMUM)); + } + + if (Load < LOAD_MINIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei Load (Aktuell: {0}) muss größer oder gleich {1} sein", Load, LOAD_MINIMUM)); + } + if (Load > LOAD_MAXIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei Load (Aktuell: {0}) muss kleiner oder gleich {1} sein", Load, LOAD_MAXIMUM)); + } + + if (Range < RANGE_MINIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei Range (Aktuell: {0}) muss größer oder gleich {1} sein", Range, RANGE_MINIMUM)); + } + if (Range > RANGE_MAXIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei Range (Aktuell: {0}) muss kleiner oder gleich {1} sein", Range, RANGE_MAXIMUM)); + } + + if (ViewRange < VIEWRANGE_MINIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei ViewRange (Aktuell: {0}) muss größer oder gleich {1} sein", ViewRange, VIEWRANGE_MINIMUM)); + } + if (ViewRange > VIEWRANGE_MAXIMUM) + { + throw new ConfigurationErrorsException(string.Format("Der Wert bei ViewRange (Aktuell: {0}) muss kleiner oder gleich {1} sein", ViewRange, VIEWRANGE_MINIMUM)); + } + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/SimulationEnvironment.cs b/SimulationCore/Simulation/SimulationEnvironment.cs new file mode 100644 index 0000000..ab0d785 --- /dev/null +++ b/SimulationCore/Simulation/SimulationEnvironment.cs @@ -0,0 +1,445 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Security; + +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation { + /// + /// Holds all simulation-elements. + /// + internal sealed partial class SimulationEnvironment { + #region Constants + + public const int PLAYGROUND_UNIT = 64; + + #endregion + + #region private variables + + private int currentRound; + private int playerCount; + + #endregion + + #region Constructor and Init + + /// + /// Creates a new instance of SimulationEnvironment + /// + public SimulationEnvironment() { + precalculateAngles(); + PlayerCall.AreaChanged += playerCallAreaChanged; + } + + /// + /// Weitergabe des Verantwortungswechsels + /// + /// + /// + private void playerCallAreaChanged(object sender, AreaChangeEventArgs e) { + AreaChange(this, e); + } + + /// + /// Initialisiert die Simulation um mit Runde 1 zu beginnen + /// + /// Konfiguration der Simulation + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + public void Init(SimulatorConfiguration configuration) { + // Init some varialbes + currentRound = 0; + + // count players + playerCount = 0; + foreach (TeamInfo team in configuration.Teams) { + playerCount += team.Player.Count; + } + + // Sugar-relevant stuff + sugarDelay = 0; + sugarCountDown = (int) (SimulationSettings.Custom.SugarTotalCount* + (1 + (SimulationSettings.Custom.SugarTotalCountPlayerMultiplier*playerCount))); + sugarLimit = (int) (SimulationSettings.Custom.SugarSimultaneousCount* + (1 + (SimulationSettings.Custom.SugarCountPlayerMultiplier*playerCount))); + + // Fruit-relevant stuff + fruitDelay = 0; + fruitCountDown = (int) (SimulationSettings.Custom.FruitTotalCount* + (1 + (SimulationSettings.Custom.FruitTotalCountPlayerMultiplier*playerCount))); + fruitLimit = (int) (SimulationSettings.Custom.FruitSimultaneousCount* + (1 + (SimulationSettings.Custom.FruitCountPlayerMultiplier*playerCount))); + + // Ant-relevant stuff + int antCountDown = (int) (SimulationSettings.Custom.AntTotalCount* + (1 + (SimulationSettings.Custom.AntTotalCountPlayerMultiplier*playerCount))); + antLimit = (int) (SimulationSettings.Custom.AntSimultaneousCount* + (1 + (SimulationSettings.Custom.AntCountPlayerMultiplier*playerCount))); + + // Spielfeld erzeugen + float area = SimulationSettings.Custom.PlayGroundBaseSize; + area *= 1 + (playerCount * SimulationSettings.Custom.PlayGroundSizePlayerMultiplier); + int playgroundWidth = (int)Math.Round(Math.Sqrt(area * 4 / 3)); + int playgroundHeight = (int)Math.Round(Math.Sqrt(area * 3 / 4)); + Playground = new CorePlayground(playgroundWidth, playgroundHeight, configuration.MapInitialValue); + + // Bugs-relevant stuff + Bugs = new CoreColony(Playground); + Bugs.insectCountDown = (int) (SimulationSettings.Custom.BugTotalCount* + (1 + (SimulationSettings.Custom.BugTotalCountPlayerMultiplier*playerCount))); + bugLimit = (int) (SimulationSettings.Custom.BugSimultaneousCount* + (1 + (SimulationSettings.Custom.BugCountPlayerMultiplier*playerCount))); + + // Völker erzeugen + Teams = new CoreTeam[configuration.Teams.Count]; + for (int i = 0; i < configuration.Teams.Count; i++) { + TeamInfo team = configuration.Teams[i]; + Teams[i] = new CoreTeam(i, team.Guid, team.Name); + Teams[i].Colonies = new CoreColony[team.Player.Count]; + + // Völker erstellen + for (int j = 0; j < team.Player.Count; j++) { + PlayerInfo player = team.Player[j]; + CoreColony colony = new CoreColony(Playground, player, Teams[i]); + Teams[i].Colonies[j] = colony; + + colony.AntHills.Add(Playground.NeuerBau(colony.Id)); + colony.insectCountDown = antCountDown; + } + } + } + + #endregion + + #region Public Methods + + /// + /// Berechnet einen neuen Spielschritt + /// + /// Zustandskopie des Simulationsstandes nachdem der Schritt ausgeführt wurde + /// RuleViolationException + /// Exception + public void Step(SimulationState simulationState) { + currentRound++; + + #region Food + + removeSugar(); + spawnSugar(); + spawnFruit(); + + #endregion + + #region Bugs + + Bugs.Grids[0].Clear(); + for (int i = 0; i < Teams.Length; i++) { + for (int j = 0; j < Teams[i].Colonies.Length; j++) { + Bugs.Grids[0].Add(Teams[i].Colonies[j].Insects); + } + } + + // Lasse die Wanzen von der Spiel Befehle entgegen nehmen. + //foreach (CoreBug wanze in Bugs.Insects) { + // wanze.NimmBefehleEntgegen = true; + //} + + // Schleife über alle Wanzen. + for (int bugIndex = 0; bugIndex < Bugs.Insects.Count; bugIndex++) { + CoreBug bug = Bugs.Insects[bugIndex] as CoreBug; + Debug.Assert(bug != null); + + bug.NimmBefehleEntgegen = true; + + // Finde Ameisen in Angriffsreichweite. + List ants = Bugs.Grids[0].FindAnts(bug); + + // Bestimme wie der Schaden auf die Ameisen verteilt wird. + if (ants.Count >= SimulationSettings.Custom.BugAttack) { + // Es sind mehr Ameisen in der SpielUmgebung als die Wanze + // Schadenpunke verteilen kann. Daher werden den Ameisen am + // Anfang der Liste jeweils ein Energiepunkt abgezogen. + for (int index = 0; index < SimulationSettings.Custom.BugAttack; index++) { + ants[index].AktuelleEnergieBase--; + //((Ameise)ameisen[i]).WirdAngegriffen(wanze); + PlayerCall.UnderAttack((CoreAnt) ants[index], bug); + if (ants[index].AktuelleEnergieBase <= 0) { + ants[index].colony.EatenInsects.Add(ants[index]); + } + } + } + else if (ants.Count > 0) { + // Bestimme die Energie die von jeder Ameise abgezogen wird. + // Hier können natürlich Rundungsfehler auftreten, die die Wanze + // abschwächen, die ignorieren wir aber. + int schaden = SimulationSettings.Custom.BugAttack/ants.Count; + for (int index = 0; index < ants.Count; index++) { + ants[index].AktuelleEnergieBase -= schaden; + //((Ameise)ameisen[i]).WirdAngegriffen(wanze); + PlayerCall.UnderAttack((CoreAnt) ants[index], bug); + if (ants[index].AktuelleEnergieBase <= 0) { + ants[index].colony.EatenInsects.Add(ants[index]); + } + } + } + + // Während eines Kampfes kann die Wanze sich nicht bewegen. + if (ants.Count > 0) { + continue; + } + + // Bewege die Wanze. + bug.Bewegen(); + if (bug.RestStreckeBase == 0) { + bug.DreheInRichtungBase(AntMe.English.RandomNumber.Number(360)); + bug.GeheGeradeausBase(AntMe.English.RandomNumber.Number(160, 320)); + } + bug.NimmBefehleEntgegen = false; + } + + // Verhindere, daß ein Spieler einer gesichteten Wanze Befehle gibt. + //for(int i = 0; i < Bugs.Insects.Count; i++) { + // CoreBug wanze = Bugs.Insects[i] as CoreBug; + // if(wanze != null) { + // wanze.NimmBefehleEntgegen = false; + // } + //} + + #endregion + + #region Ants + + // Loop through all teams. + for (int teamIndex = 0; teamIndex < Teams.Length; teamIndex++) { + // Loop through all colonies in that team. + for (int colonyIndex = 0; colonyIndex < Teams[teamIndex].Colonies.Length; colonyIndex++) { + CoreColony colony = Teams[teamIndex].Colonies[colonyIndex]; + + // Leere alle Buckets. + for (int casteIndex = 0; casteIndex < colony.AnzahlKasten; casteIndex++) { + colony.Grids[casteIndex].Clear(); + } + + // Fülle alle Buckets, aber befülle keinen Bucket doppelt. + for (int casteIndex = 0; casteIndex < colony.AnzahlKasten; casteIndex++) { + if (colony.Grids[casteIndex].Count == 0) { + colony.Grids[casteIndex].Add(Bugs.Insects); + for (int j = 0; j < Teams.Length; j++) { + for (int i = 0; i < Teams[j].Colonies.Length; i++) { + CoreColony v = Teams[j].Colonies[i]; + colony.Grids[casteIndex].Add(v.Insects); + } + } + } + } + + // Schleife über alle Ameisen. + for (int antIndex = 0; antIndex < colony.Insects.Count; antIndex++) { + CoreAnt ameise = colony.Insects[antIndex] as CoreAnt; + Debug.Assert(ameise != null); + + // Finde und Zähle die Insekten im Sichtkreis der Ameise. + CoreBug wanze; + CoreAnt feind; + CoreAnt freund; + CoreAnt teammember; + int bugCount, enemyAntCount, colonyAntCount, casteAntCount, teamAntCount; + colony.Grids[ameise.CasteIndexBase].FindAndCountInsects( + ameise, + out wanze, + out bugCount, + out feind, + out enemyAntCount, + out freund, + out colonyAntCount, + out casteAntCount, + out teammember, + out teamAntCount); + ameise.BugsInViewrange = bugCount; + ameise.ForeignAntsInViewrange = enemyAntCount; + ameise.FriendlyAntsInViewrange = colonyAntCount; + ameise.FriendlyAntsFromSameCasteInViewrange = casteAntCount; + ameise.TeamAntsInViewrange = teamAntCount; + + // Bewege die Ameise. + ameise.Bewegen(); + + #region Reichweite + + // Ameise hat ihre Reichweite überschritten. + if (ameise.ZurückgelegteStreckeI > colony.ReichweiteI[ameise.CasteIndexBase]) { + ameise.AktuelleEnergieBase = 0; + colony.VerhungerteInsekten.Add(ameise); + continue; + } + + // Ameise hat ein Drittel ihrer Reichweite zurückgelegt. + else if (ameise.ZurückgelegteStreckeI > colony.ReichweiteI[ameise.CasteIndexBase]/3) { + if (ameise.IstMüdeBase == false) { + ameise.IstMüdeBase = true; + PlayerCall.BecomesTired(ameise); + } + } + + #endregion + + #region Kampf + + // Rufe die Ereignisse auf, falls die Ameise nicht schon ein + // entsprechendes Ziel hat. + if (wanze != null && !(ameise.ZielBase is CoreBug)) { + PlayerCall.SpotsEnemy(ameise, wanze); + } + if (feind != null && !(ameise.ZielBase is CoreAnt) || + (ameise.ZielBase is CoreAnt && ((CoreAnt) ameise.ZielBase).colony == colony)) { + PlayerCall.SpotsEnemy(ameise, feind); + } + if (freund != null && !(ameise.ZielBase is CoreAnt) || + (ameise.ZielBase is CoreAnt && ((CoreAnt) ameise.ZielBase).colony != colony)) { + PlayerCall.SpotsFriend(ameise, freund); + } + if (teammember != null && !(ameise.ZielBase is CoreAnt) || + (ameise.ZielBase is CoreAnt && ((CoreAnt) ameise.ZielBase).colony != colony)) { + PlayerCall.SpotsTeamMember(ameise, teammember); + } + + // Kampf mit Wanze. + if (ameise.ZielBase is CoreBug) { + CoreBug k = (CoreBug) ameise.ZielBase; + if (k.AktuelleEnergieBase > 0) { + int entfernung = + CoreCoordinate.BestimmeEntfernungI(ameise.CoordinateBase, ameise.ZielBase.CoordinateBase); + if (entfernung < SimulationSettings.Custom.BattleRange*PLAYGROUND_UNIT) { + k.AktuelleEnergieBase -= ameise.AngriffBase; + if (k.AktuelleEnergieBase <= 0) { + Bugs.EatenInsects.Add(k); + colony.Statistik.KilledBugs++; + ameise.BleibStehenBase(); + } + } + } + else { + ameise.ZielBase = null; + } + } + + // Kampf mit feindlicher Ameise. + else if (ameise.ZielBase is CoreAnt) { + CoreAnt a = (CoreAnt) ameise.ZielBase; + if (a.colony != colony && a.AktuelleEnergieBase > 0) { + int entfernung = + CoreCoordinate.BestimmeEntfernungI(ameise.CoordinateBase, ameise.ZielBase.CoordinateBase); + if (entfernung < SimulationSettings.Custom.BattleRange*PLAYGROUND_UNIT) { + PlayerCall.UnderAttack(a, ameise); + a.AktuelleEnergieBase -= ameise.AngriffBase; + if (a.AktuelleEnergieBase <= 0) { + a.colony.BeatenInsects.Add(a); + colony.Statistik.KilledAnts++; + ameise.BleibStehenBase(); + } + } + } + else { + ameise.ZielBase = null; + } + } + + #endregion + + // Prüfe ob die Ameise an ihrem Ziel angekommen ist. + if (ameise.AngekommenBase) { + ameiseUndZiel(ameise); + } + + // Prüfe ob die Ameise einen Zuckerhaufen oder ein Obststück sieht. + ameiseUndZucker(ameise); + if (ameise.GetragenesObstBase == null) { + ameiseUndObst(ameise); + } + + // Prüfe ob die Ameise eine Markierung bemerkt. + ameiseUndMarkierungen(ameise); + + if (ameise.ZielBase == null && ameise.RestStreckeBase == 0) { + PlayerCall.Waits(ameise); + } + + PlayerCall.Tick(ameise); + } + + removeAnt(colony); + spawnAnt(colony); + + aktualisiereMarkierungen(colony); + removeFruit(colony); + } + } + + #endregion + + #region Bugs again + + removeBugs(); + healBugs(); + spawnBug(); + + #endregion + + bewegeObstUndInsekten(); + + erzeugeZustand(simulationState); + } + + #endregion + + #region Helpermethods + + /// + /// Erzeugt einen Zustand aus dem aktuellen Spielumstand + /// + /// aktueller Spielstand + private void erzeugeZustand(SimulationState zustand) { + zustand.PlaygroundWidth = Playground.Width; + zustand.PlaygroundHeight = Playground.Height; + zustand.CurrentRound = currentRound; + + for (int i = 0; i < Teams.Length; i++) { + zustand.TeamStates.Add(Teams[i].CreateState()); + } + + for (int i = 0; i < Bugs.Insects.Count; i++) { + zustand.BugStates.Add(((CoreBug) Bugs.Insects[i]).ErzeugeInfo()); + } + + for (int i = 0; i < Playground.SugarHills.Count; i++) { + zustand.SugarStates.Add(Playground.SugarHills[i].CreateState()); + } + + for (int i = 0; i < Playground.Fruits.Count; i++) { + zustand.FruitStates.Add(Playground.Fruits[i].ErzeugeInfo()); + } + } + + #endregion + + #region Events + + public event AreaChangeEventHandler AreaChange; + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/SimulationEnvironmentHelper.cs b/SimulationCore/Simulation/SimulationEnvironmentHelper.cs new file mode 100644 index 0000000..1f4d687 --- /dev/null +++ b/SimulationCore/Simulation/SimulationEnvironmentHelper.cs @@ -0,0 +1,627 @@ +using System; +using System.Collections.Generic; + +namespace AntMe.Simulation { + internal partial class SimulationEnvironment + { + #region common stuff + + /// + /// Holds the current playground. + /// + internal CorePlayground Playground; + + /// + /// Holds a list of active teams. + /// + internal CoreTeam[] Teams; + + /// + /// Holds the "colony" of bugs. + /// + internal CoreColony Bugs; + + #endregion + + + #region angle-precalculation + + /// + /// Holds the calculated sin- and cos-values. + /// + public static int[,] Cos, Sin; + + /// + /// Calculates all possible angles. + /// + private static void precalculateAngles() + { + int max = SimulationSettings.Custom.MaximumSpeed * PLAYGROUND_UNIT + 1; + + Cos = new int[max + 1, 360]; + Sin = new int[max + 1, 360]; + + // Cosinus und Sinus Werte vorberechnen. + for (int amplitude = 0; amplitude <= max; amplitude++) + { + for (int winkel = 0; winkel < 360; winkel++) + { + Cos[amplitude, winkel] = + (int)Math.Round(amplitude * Math.Cos(winkel * Math.PI / 180d)); + Sin[amplitude, winkel] = + (int)Math.Round(amplitude * Math.Sin(winkel * Math.PI / 180d)); + } + } + } + + public static int Cosinus(int amplitude, int winkel) + { + return (int)Math.Round(amplitude * Math.Cos(winkel * Math.PI / 180d)); + } + + public static int Sinus(int amplitude, int winkel) + { + return (int)Math.Round(amplitude * Math.Sin(winkel * Math.PI / 180d)); + } + + #endregion + + + #region sugar-handling + + /// + /// Delay-counter for sugar-respawn. + /// + private int sugarDelay; + + /// + /// Counts down the total number of allowed sugar-hills. + /// + private int sugarCountDown; + + /// + /// Gets the count of simultaneous existing sugar-hills. + /// + private int sugarLimit; + + /// + /// Removes all empty sugar-hills from list. + /// + private void removeSugar() + { + // TODO: speedup + //List gemerkterZucker = new List(); + for (int i = 0; i < Playground.SugarHills.Count; i++) + { + CoreSugar zucker = Playground.SugarHills[i]; + if (zucker != null) + { + if (zucker.Menge == 0) + { + //gemerkterZucker.Add(zucker); + //Löschen + Playground.SugarHills.Remove(zucker); + i--; + } + } + } + //for(int i = 0; i < gemerkterZucker.Count; i++) { + // CoreSugar zucker = gemerkterZucker[i]; + // if(zucker != null) { + // Playground.SugarHills.Remove(zucker); + // } + //} + //gemerkterZucker.Clear(); + } + + /// + /// Spawns new sugar, if its time. + /// + private void spawnSugar() + { + if (Playground.SugarHills.Count < sugarLimit && + sugarDelay <= 0 && + sugarCountDown > 0) + { + sugarDelay = SimulationSettings.Custom.SugarRespawnDelay; + sugarCountDown--; + Playground.NeuerZucker(); + } + sugarDelay--; + } + + #endregion + + + #region fruit-handling + + /// + /// Delay-counter for fruit-respawn. + /// + private int fruitDelay; + + /// + /// Counts down the total number of allowed fruits. + /// + private int fruitCountDown; + + /// + /// Gets the count of simultaneous existing fruits. + /// + private int fruitLimit; + + /// + /// Spawns new fruit, if its time. + /// + private void spawnFruit() + { + if (Playground.Fruits.Count < fruitLimit && + fruitDelay <= 0 && + fruitCountDown > 0) + { + fruitDelay = SimulationSettings.Custom.FruitRespawnDelay; + fruitCountDown--; + Playground.NeuesObst(); + } + fruitDelay--; + } + + /// + /// Removes fruit from list. + /// + /// winning colony + private void removeFruit(CoreColony colony) + { + //List gemerktesObst = new List(); + for (int j = 0; j < Playground.Fruits.Count; j++) + { + CoreFruit obst = Playground.Fruits[j]; + for (int i = 0; i < colony.AntHills.Count; i++) + { + CoreAnthill bau = colony.AntHills[i]; + if (bau != null) + { + int entfernung = CoreCoordinate.BestimmeEntfernungI(obst.CoordinateBase, bau.CoordinateBase); + if (entfernung <= PLAYGROUND_UNIT) + { + //gemerktesObst.Add(obst); + + // Löschen + colony.Statistik.CollectedFood += obst.Menge; + obst.Menge = 0; + for (int z = 0; z < obst.TragendeInsekten.Count; z++) + { + CoreInsect insect = obst.TragendeInsekten[z]; + if (insect != null) + { + insect.GetragenesObstBase = null; + insect.AktuelleLastBase = 0; + insect.RestStreckeI = 0; + insect.RestWinkelBase = 0; + insect.GeheZuBauBase(); + } + } + obst.TragendeInsekten.Clear(); + Playground.Fruits.Remove(obst); + j--; + } + } + } + } + } + + #endregion + + + #region ant-handling + + /// + /// Gets the count of simultaneous existing ants. + /// + private int antLimit; + + /// + /// Prüft ob eine Ameise an ihrem Ziel angekommen ist. + /// + /// betroffene Ameise + private static void ameiseUndZiel(CoreAnt ant) + { + // Ameisenbau. + if (ant.ZielBase is CoreAnthill) + { + if (ant.GetragenesObstBase == null) + { + ant.ZurückgelegteStreckeI = 0; + ant.ZielBase = null; + ant.SmelledMarker.Clear(); + ant.colony.Statistik.CollectedFood += ant.AktuelleLastBase; + ant.AktuelleLastBase = 0; + ant.AktuelleEnergieBase = ant.MaximaleEnergieBase; + ant.IstMüdeBase = false; + } + } + + // Zuckerhaufen. + else if (ant.ZielBase is CoreSugar) + { + CoreSugar zucker = (CoreSugar)ant.ZielBase; + ant.ZielBase = null; + if (zucker.Menge > 0) + { + PlayerCall.TargetReached(ant, zucker); + } + } + + // Obststück. + else if (ant.ZielBase is CoreFruit) + { + CoreFruit obst = (CoreFruit)ant.ZielBase; + ant.ZielBase = null; + if (obst.Menge > 0) + { + PlayerCall.TargetReached(ant, obst); + } + } + + // Insekt. + else if (ant.ZielBase is CoreInsect) { } + + // Anderes Ziel. + else + { + ant.ZielBase = null; + } + } + + /// + /// Prüft ob eine Ameise einen Zuckerhaufen sieht. + /// + /// betroffene Ameise + private void ameiseUndZucker(CoreAnt ant) + { + for (int i = 0; i < Playground.SugarHills.Count; i++) + { + CoreSugar sugar = Playground.SugarHills[i]; + int entfernung = CoreCoordinate.BestimmeEntfernungI(ant.CoordinateBase, sugar.CoordinateBase); + if (ant.ZielBase != sugar && entfernung <= ant.SichtweiteI) + { + PlayerCall.Spots(ant, sugar); + } + } + } + + /// + /// Prüft ob eine Ameise ein Obsstück sieht. + /// + /// betroffene Ameise + private void ameiseUndObst(CoreAnt ameise) + { + for (int i = 0; i < Playground.Fruits.Count; i++) + { + CoreFruit obst = Playground.Fruits[i]; + int entfernung = CoreCoordinate.BestimmeEntfernungI(ameise.CoordinateBase, obst.CoordinateBase); + if (ameise.ZielBase != obst && entfernung <= ameise.SichtweiteI) + { + PlayerCall.Spots(ameise, obst); + } + } + } + + /// + /// Prüft ob die Ameise eine Markierung bemerkt. + /// + /// betroffene Ameise + private static void ameiseUndMarkierungen(CoreAnt ameise) + { + CoreMarker marker = ameise.colony.Marker.FindMarker(ameise); + if (marker != null) + { + PlayerCall.SmellsFriend(ameise, marker); + ameise.SmelledMarker.Add(marker); + } + } + + /// + /// Erntfernt Ameisen die keine Energie mehr haben. + /// + /// betroffenes Volk + private void removeAnt(CoreColony colony) + { + List liste = new List(); + + for (int i = 0; i < colony.VerhungerteInsekten.Count; i++) + { + CoreAnt ant = colony.VerhungerteInsekten[i] as CoreAnt; + if (ant != null && !liste.Contains(ant)) + { + liste.Add(ant); + colony.Statistik.StarvedAnts++; + PlayerCall.HasDied(ant, CoreKindOfDeath.Starved); + } + } + + for (int i = 0; i < colony.EatenInsects.Count; i++) + { + CoreAnt ant = colony.EatenInsects[i] as CoreAnt; + if (ant != null && !liste.Contains(ant)) + { + liste.Add(ant); + colony.Statistik.EatenAnts++; + PlayerCall.HasDied(ant, CoreKindOfDeath.Eaten); + } + } + + for (int i = 0; i < colony.BeatenInsects.Count; i++) + { + CoreAnt ant = colony.BeatenInsects[i] as CoreAnt; + if (ant != null) + { + if (!liste.Contains(ant)) + { + liste.Add(ant); + colony.Statistik.BeatenAnts++; + PlayerCall.HasDied(ant, CoreKindOfDeath.Beaten); + } + } + } + + for (int i = 0; i < liste.Count; i++) + { + CoreAnt ant = liste[i]; + if (ant != null) + { + colony.EntferneInsekt(ant); + + for (int j = 0; j < Playground.Fruits.Count; j++) + { + CoreFruit fruit = Playground.Fruits[j]; + fruit.TragendeInsekten.Remove(ant); + } + } + } + + colony.VerhungerteInsekten.Clear(); + colony.EatenInsects.Clear(); + colony.BeatenInsects.Clear(); + } + + /// + /// Erzeugt neue Ameisen. + /// + /// betroffenes Volk + private void spawnAnt(CoreColony colony) + { + if (colony.Insects.Count < antLimit && + colony.insectDelay < 0 && + colony.insectCountDown > 0) + { + colony.NeuesInsekt(); + colony.insectDelay = SimulationSettings.Custom.AntRespawnDelay; + colony.insectCountDown--; + } + colony.insectDelay--; + } + + // Bewegt Obsstücke und alle Insekten die das Obsstück tragen. + private void bewegeObstUndInsekten() + { + Playground.Fruits.ForEach(delegate(CoreFruit fruit) + { + if (fruit.TragendeInsekten.Count > 0) + { + int dx = 0; + int dy = 0; + int last = 0; + + fruit.TragendeInsekten.ForEach(delegate(CoreInsect insect) + { + if (insect.ZielBase != fruit && insect.RestWinkelBase == 0) + { + dx += Cos[insect.aktuelleGeschwindigkeitI, insect.RichtungBase]; + dy += Sin[insect.aktuelleGeschwindigkeitI, insect.RichtungBase]; + last += insect.AktuelleLastBase; + } + }); + + last = Math.Min((int)(last * SimulationSettings.Custom.FruitLoadMultiplier), fruit.Menge); + dx = dx * last / fruit.Menge / fruit.TragendeInsekten.Count; + dy = dy * last / fruit.Menge / fruit.TragendeInsekten.Count; + + fruit.CoordinateBase = new CoreCoordinate(fruit.CoordinateBase, dx, dy); + fruit.TragendeInsekten.ForEach( + delegate(CoreInsect insect) { insect.CoordinateBase = new CoreCoordinate(insect.CoordinateBase, dx, dy); }); + } + }); + //foreach(CoreFruit obst in Playground.Fruits) { + // if(obst.TragendeInsekten.Count > 0) { + // int dx = 0; + // int dy = 0; + // int last = 0; + + // foreach(CoreInsect insekt in obst.TragendeInsekten) { + // if(insekt.ZielBase != obst && insekt.RestWinkelBase == 0) { + // dx += Cos[insekt.aktuelleGeschwindigkeitI, insekt.RichtungBase]; + // dy += Sin[insekt.aktuelleGeschwindigkeitI, insekt.RichtungBase]; + // last += insekt.AktuelleLastBase; + // } + // } + + // last = Math.Min((int)(last * SimulationSettings.Settings.FruitLoadMultiplier), obst.Menge); + // dx = dx * last / obst.Menge / obst.TragendeInsekten.Count; + // dy = dy * last / obst.Menge / obst.TragendeInsekten.Count; + + // obst.Coordinate = new CoreCoordinate(obst.Coordinate, dx, dy); + + // foreach(CoreInsect insekt in obst.TragendeInsekten) { + // insekt.Coordinate = new CoreCoordinate(insekt.Coordinate, dx, dy); + // } + // } + //} + } + + #endregion + + + #region marker-handling + + /// + /// Entfernt abgelaufene Markierungen und erzeugt neue Markierungen. + /// + /// betroffenes Volk + private static void aktualisiereMarkierungen(CoreColony colony) + { + // TODO: Settings berücksichtigen + // Markierungen aktualisieren und inaktive Markierungen löschen. + List gemerkteMarkierungen = new List(); + + foreach (CoreMarker markierung in colony.Marker) + { + if (markierung.IstAktiv) + { + markierung.Aktualisieren(); + } + else + { + gemerkteMarkierungen.Add(markierung); + } + } + gemerkteMarkierungen.ForEach(delegate(CoreMarker marker) + { + colony.Insects.ForEach(delegate(CoreInsect insect) + { + CoreAnt ant = insect as CoreAnt; + if (ant != null) + { + ant.SmelledMarker.Remove(marker); + } + }); + }); + //for(int i = 0; i < gemerkteMarkierungen.Count; i++) { + // CoreMarker markierung = gemerkteMarkierungen[i]; + // for(int j = 0; j < volk.Insects.Count; j++) { + // CoreAnt ameise = volk.Insects[j] as CoreAnt; + // if(ameise != null) { + // ameise.GerocheneMarkierungen.Remove(markierung); + // } + // } + //} + colony.Marker.Remove(gemerkteMarkierungen); + + // Neue Markierungen überprüfen und hinzufügen. + gemerkteMarkierungen.Clear(); + colony.NewMarker.ForEach(delegate(CoreMarker newMarker) + { + bool zuNah = false; + //for(int i = 0; i < volk.Marker.Count; i++) { + // CoreMarker marker = volk.Marker[i]; + // if(marker != null) { + // int distance = + // CoreCoordinate.BestimmeEntfernungDerMittelpunkteI + // (marker.Coordinate, newMarker.Coordinate); + // if(distance < SimulationSettings.Settings.MarkerDistance * SPIELFELD_EINHEIT) { + // zuNah = true; + // break; + // } + // } + + //} + foreach (CoreMarker markierung in colony.Marker) + { + int entfernung = + CoreCoordinate.BestimmeEntfernungDerMittelpunkteI + (markierung.CoordinateBase, newMarker.CoordinateBase); + if (entfernung < SimulationSettings.Custom.MarkerDistance * PLAYGROUND_UNIT) + { + zuNah = true; + break; + } + } + if (!zuNah) + { + colony.Marker.Add(newMarker); + } + }); + //foreach (CoreMarker neueMarkierung in volk.NewMarker) { + // bool zuNah = false; + // foreach (CoreMarker markierung in volk.Marker) { + // int entfernung = + // CoreCoordinate.BestimmeEntfernungDerMittelpunkteI + // (markierung.Coordinate, neueMarkierung.Coordinate); + // if (entfernung < SimulationSettings.Settings.MarkerDistance * SPIELFELD_EINHEIT) { + // zuNah = true; + // break; + // } + // } + // if (!zuNah) { + // volk.Marker.Add(neueMarkierung); + // } + //} + colony.NewMarker.Clear(); + } + + #endregion + + + #region bug-handling + + /// + /// Gets the count of simultaneous existing bugs. + /// + private int bugLimit; + + /// + /// Remove dead bugs. + /// + private void removeBugs() + { + for (int i = 0; i < Bugs.EatenInsects.Count; i++) + { + CoreBug bug = Bugs.EatenInsects[i] as CoreBug; + if (bug != null) + { + Bugs.Insects.Remove(bug); + } + } + Bugs.EatenInsects.Clear(); + } + + /// + /// Heals the bugs, if its time. + /// + private void healBugs() + { + if (currentRound % SimulationSettings.Custom.BugRegenerationDelay == 0) + { + for (int i = 0; i < Bugs.Insects.Count; i++) + { + CoreBug bug = Bugs.Insects[i] as CoreBug; + if (bug != null) + { + if (bug.AktuelleEnergieBase < bug.MaximaleEnergieBase) + { + bug.AktuelleEnergieBase += SimulationSettings.Custom.BugRegenerationValue; + } + } + } + } + } + + /// + /// Spawn new bugs, if needed. + /// + private void spawnBug() + { + if (Bugs.Insects.Count < bugLimit && + Bugs.insectDelay < 0 && + Bugs.insectCountDown > 0) + { + Bugs.NeuesInsekt(); + Bugs.insectDelay = SimulationSettings.Custom.BugRespawnDelay; + Bugs.insectCountDown--; + } + Bugs.insectDelay--; + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/SimulationSettings.cs b/SimulationCore/Simulation/SimulationSettings.cs new file mode 100644 index 0000000..22573ed --- /dev/null +++ b/SimulationCore/Simulation/SimulationSettings.cs @@ -0,0 +1,740 @@ +using System; +using System.Configuration; +using System.IO; +using System.Xml.Serialization; + +namespace AntMe.Simulation { + /// + /// Simulation-Settings from application-configuration. + /// + [Serializable] + public struct SimulationSettings { + #region internal Varialbes + + /// + /// Sets or gets the name of this settings-set. + /// + public string SettingsName; + + /// + /// Gets or sets Guid of that settings-set. + /// + public Guid Guid; + + #region Playground + + /// + /// Gets the size of the playground in SquareAntSteps. + /// + public int PlayGroundBaseSize; + + /// + /// Gets the multiplier of additional playground-size per player. + /// + public float PlayGroundSizePlayerMultiplier; + + /// + /// Gets the radius of anthills. + /// + public int AntHillRadius; + + /// + /// Minimum Battle-Distance in steps between two insects. + /// + public int BattleRange; + + #endregion + + #region Livetime and Respawn + + /// + /// Gets the maximum count of ants simultaneous on playground. + /// + public int AntSimultaneousCount; + + /// + /// Gets the maximum count of bugs simultaneous on playground. + /// + public int BugSimultaneousCount; + + /// + /// Gets the maximum count of sugar simultaneous on playground. + /// + public int SugarSimultaneousCount; + + /// + /// Gets the maximum count of fruit simultaneous on playground. + /// + public int FruitSimultaneousCount; + + /// + /// Gets the multiplier for maximum count of bugs simultaneous on playground per player. + /// + public float BugCountPlayerMultiplier; + + /// + /// Gets the multiplier for maximum count of sugar simultaneous on playground per player. + /// + public float SugarCountPlayerMultiplier; + + /// + /// Gets the multiplier for maximum count of fruit simultaneous on playground per player. + /// + public float FruitCountPlayerMultiplier; + + /// + /// Gets the multiplier for maximum count of ants simultaneous on playground per player. + /// + public float AntCountPlayerMultiplier; + + /// + /// Gets the maximum count of ants in the whole simulation. + /// + public int AntTotalCount; + + /// + /// Gets the maximum count of bugs in the whole simulation. + /// + public int BugTotalCount; + + /// + /// Gets the maximum count of sugar in the whole simulation. + /// + public int SugarTotalCount; + + /// + /// Gets the maximum count of fruit in the whole simulation. + /// + public int FruitTotalCount; + + /// + /// Gets the multiplier for maximum count of ants per player in the whole simulation. + /// + public float AntTotalCountPlayerMultiplier; + + /// + /// Gets the multiplier for maximum count of bugs per player in the whole simulation. + /// + public float BugTotalCountPlayerMultiplier; + + /// + /// Gets the multiplier for maximum count of sugar per player in the whole simulation. + /// + public float SugarTotalCountPlayerMultiplier; + + /// + /// Gets the multiplier for maximum count of fruit per player in the whole simulation. + /// + public float FruitTotalCountPlayerMultiplier; + + /// + /// Gets the delay for ant before next respawn in rounds. + /// + public int AntRespawnDelay; + + /// + /// Gets the delay for bugs before next respawn in rounds. + /// + public int BugRespawnDelay; + + /// + /// Gets the delay for sugar before next respawn in rounds. + /// + public int SugarRespawnDelay; + + /// + /// Gets the delay for fruits before next respawn in rounds. + /// + public int FruitRespawnDelay; + + #endregion + + #region Bugsettings + + /// + /// Gets the attack-value of bugs. + /// + public int BugAttack; + + /// + /// Gets the rotation speed of bugs. + /// + public int BugRotationSpeed; + + /// + /// Gets the energy of bugs. + /// + public int BugEnergy; + + /// + /// Gets the speed of bugs. + /// + public int BugSpeed; + + /// + /// Gets the attack-range of bugs. + /// + public int BugRadius; + + /// + /// Gets the regeneration-value of bugs. + /// + public int BugRegenerationValue; + + /// + /// Gets the delay in rounds between the regeneration-steps of bugs. + /// + public int BugRegenerationDelay; + + #endregion + + #region Foodstuff + + /// + /// Gets the minimal amount of food in sugar-hills. + /// + public int SugarAmountMinimum; + + /// + /// Gets the maximum amount of food in sugar-hills. + /// + public int SugarAmountMaximum; + + /// + /// Gets the minimal amount of food in fruits. + /// + public int FruitAmountMinimum; + + /// + /// Gets the maximum amount of food in fruits. + /// + public int FruitAmountMaximum; + + /// + /// Gets the multiplier for fruits between load and amount of food. + /// + public float FruitLoadMultiplier; + + /// + /// Gets the multiplier for fruits between radius and amount of food. + /// + public float FruitRadiusMultiplier; + + #endregion + + #region Marker + + /// + /// Gets the minimal size of a marker. + /// + public int MarkerSizeMinimum; + + /// + /// Gets the minimal allowed distance between to marker. + /// + public int MarkerDistance; + + /// + /// Gets the maximum age in rounds of a marker. + /// + public int MarkerMaximumAge; + + #endregion + + #region Points + + /// + /// Multiplier for the calculation from food to points. + /// + public float PointsForFoodMultiplier; + + /// + /// Gets the amount of points for collected fruits. + /// + public int PointsForFruits; + + /// + /// Gets the amount of points for killed bugs. + /// + public int PointsForBug; + + /// + /// Gets the amount of points for killed foreign ants. + /// + public int PointsForForeignAnt; + + /// + /// Gets the amount of points for own dead ants killed by bugs. + /// + public int PointsForEatenAnts; + + /// + /// Gets the amount of points for own dead ants killed by foreign ants. + /// + public int PointsForBeatenAnts; + + /// + /// Gets the amount of points for own dead starved ants. + /// + public int PointsForStarvedAnts; + + #endregion + + #region Castes + + /// + /// Gives the caste-Settings. + /// + public SimulationCasteSettings CasteSettings; + + #endregion + + #endregion + + #region Singleton + + private static SimulationSettings defaultSettings = new SimulationSettings(); + private static SimulationSettings customSettings = new SimulationSettings(); + private static bool initDefault; + private static bool initCustom; + + /// + /// Gets the default settings. + /// + public static SimulationSettings Default + { + get { + if (!initDefault) { + defaultSettings.SetDefaults(); + initDefault = true; + } + return defaultSettings; + } + } + + /// + /// Gives the current simulation-settings + /// + public static SimulationSettings Custom { + get { + if (!initCustom) { + return Default; + } + return customSettings; + } + } + + /// + /// Sets a custom set of settings. + /// + /// custom settings + public static void SetCustomSettings(SimulationSettings settings) { + settings.RuleCheck(); + customSettings = settings; + initCustom = true; + } + + #endregion + + #region Default-Methods + + /// + /// Resets the values to the default settings. + /// + public void SetDefaults() { + SettingsName = Resource.SettingsDefaultName; + + // Guid + Guid = new Guid("{C010EC26-0F4C-442c-8C36-0D6A71842A41}"); + + // Playground + PlayGroundBaseSize = 550000; + PlayGroundSizePlayerMultiplier = 1; + AntHillRadius = 32; + BattleRange = 5; + + // Livetime and Respawn + AntSimultaneousCount = 100; + BugSimultaneousCount = 5; + SugarSimultaneousCount = 1; + FruitSimultaneousCount = 2; + + BugCountPlayerMultiplier = 1f; + SugarCountPlayerMultiplier = 1f; + FruitCountPlayerMultiplier = 1f; + AntCountPlayerMultiplier = 0f; + + AntTotalCount = 999999; + BugTotalCount = 999999; + SugarTotalCount = 999999; + FruitTotalCount = 999999; + + AntTotalCountPlayerMultiplier = 0f; + BugTotalCountPlayerMultiplier = 0f; + SugarTotalCountPlayerMultiplier = 0f; + FruitTotalCountPlayerMultiplier = 0f; + + AntRespawnDelay = 15; + BugRespawnDelay = 75; + SugarRespawnDelay = 150; + FruitRespawnDelay = 225; + + // Bugsettings + BugAttack = 50; + BugRotationSpeed = 3; + BugEnergy = 1000; + BugSpeed = 3; + BugRadius = 4; + BugRegenerationValue = 1; + BugRegenerationDelay = 5; + + // Foodstuff + SugarAmountMinimum = 1000; + SugarAmountMaximum = 1000; + FruitAmountMinimum = 250; + FruitAmountMaximum = 250; + FruitLoadMultiplier = 5; + FruitRadiusMultiplier = 1; + + // Marker + MarkerSizeMinimum = 20; + MarkerDistance = 13; + MarkerMaximumAge = 150; + + // Points + PointsForFoodMultiplier = 1; + PointsForFruits = 0; + PointsForBug = 150; + PointsForForeignAnt = 5; + PointsForEatenAnts = 0; + PointsForBeatenAnts = -5; + PointsForStarvedAnts = 0; + + // Castes + CasteSettings = new SimulationCasteSettings(); + CasteSettings.Offset = -1; + CasteSettings.Columns = new SimulationCasteSettingsColumn[4]; + + CasteSettings.Columns[0].Attack = 0; + CasteSettings.Columns[0].Energy = 50; + CasteSettings.Columns[0].Load = 4; + CasteSettings.Columns[0].Range = 1800; + CasteSettings.Columns[0].RotationSpeed = 6; + CasteSettings.Columns[0].Speed = 3; + CasteSettings.Columns[0].ViewRange = 45; + + CasteSettings.Columns[1].Attack = 10; + CasteSettings.Columns[1].Energy = 100; + CasteSettings.Columns[1].Load = 5; + CasteSettings.Columns[1].Range = 2250; + CasteSettings.Columns[1].RotationSpeed = 8; + CasteSettings.Columns[1].Speed = 4; + CasteSettings.Columns[1].ViewRange = 60; + + CasteSettings.Columns[2].Attack = 20; + CasteSettings.Columns[2].Energy = 175; + CasteSettings.Columns[2].Load = 7; + CasteSettings.Columns[2].Range = 3400; + CasteSettings.Columns[2].RotationSpeed = 12; + CasteSettings.Columns[2].Speed = 5; + CasteSettings.Columns[2].ViewRange = 75; + + CasteSettings.Columns[3].Attack = 30; + CasteSettings.Columns[3].Energy = 250; + CasteSettings.Columns[3].Load = 10; + CasteSettings.Columns[3].Range = 4500; + CasteSettings.Columns[3].RotationSpeed = 16; + CasteSettings.Columns[3].Speed = 6; + CasteSettings.Columns[3].ViewRange = 90; + } + + /// + /// Checks the value-ranges of all properties. + /// + public void RuleCheck() { + + // TODO: Strings into res-files + + // Playground + if (PlayGroundBaseSize < 100000) { + throw new ConfigurationErrorsException("Grundgröße des Spielfeldes muss größer 100.000 sein"); + } + + if (PlayGroundSizePlayerMultiplier < 0) { + throw new ConfigurationErrorsException("Playground Playermultiplikator darf nicht kleiner 0 sein"); + } + + if (AntHillRadius < 0) { + throw new ConfigurationErrorsException("Ameisenbau braucht einen Radius >= 0"); + } + + if (BattleRange < 0) { + throw new ConfigurationErrorsException("Angriffsradius der Wanze darf nicht kleiner 0 sein"); + } + + // Livetime and Respawn + if (AntSimultaneousCount < 0) { + throw new ConfigurationErrorsException("Weniger als 0 simultane Ameisen sind nicht möglich"); + } + + if (BugSimultaneousCount < 0) { + throw new ConfigurationErrorsException("Weniger als 0 simultane Wanzen sind nicht möglich"); + } + + if (SugarSimultaneousCount < 0) { + throw new ConfigurationErrorsException("Weniger als 0 simultane Zuckerberge sind nicht möglich"); + } + + if (FruitSimultaneousCount < 0) { + throw new ConfigurationErrorsException("Weniger als 0 simultanes Obst sind nicht möglich"); + } + + if (BugCountPlayerMultiplier < 0) { + throw new ConfigurationErrorsException("Negative Spielermuliplikatoren bei Wanzen ist nicht zulässig"); + } + + if (SugarCountPlayerMultiplier < 0) { + throw new ConfigurationErrorsException("Negative Spielermuliplikatoren bei Zucker ist nicht zulässig"); + } + + if (FruitCountPlayerMultiplier < 0) { + throw new ConfigurationErrorsException("Negative Spielermuliplikatoren bei Obst ist nicht zulässig"); + } + + if (AntCountPlayerMultiplier < 0) { + throw new ConfigurationErrorsException("Negative Spielermuliplikatoren bei Ameisen ist nicht zulässig"); + } + + if (AntTotalCount < 0) { + throw new ConfigurationErrorsException("Negative Gesamtmenge bei Ameisen ist nicht zulässig"); + } + + if (BugTotalCount < 0) { + throw new ConfigurationErrorsException("Negative Gesamtmenge bei Wanzen ist nicht zulässig"); + } + + if (SugarTotalCount < 0) { + throw new ConfigurationErrorsException("Negative Gesamtmenge bei Zucker ist nicht zulässig"); + } + + if (FruitTotalCount < 0) { + throw new ConfigurationErrorsException("Negative Gesamtmenge bei Obst ist nicht zulässig"); + } + + if (AntTotalCountPlayerMultiplier < 0) { + throw new ConfigurationErrorsException("Negative Spielermuliplikatoren bei Ameisen ist nicht zulässig"); + } + + if (BugTotalCountPlayerMultiplier < 0) { + throw new ConfigurationErrorsException("Negative Spielermuliplikatoren bei Wanzen ist nicht zulässig"); + } + + if (SugarTotalCountPlayerMultiplier < 0) { + throw new ConfigurationErrorsException("Negative Spielermuliplikatoren bei Zucker ist nicht zulässig"); + } + + if (FruitTotalCountPlayerMultiplier < 0) { + throw new ConfigurationErrorsException("Negative Spielermuliplikatoren bei Obst ist nicht zulässig"); + } + + if (AntRespawnDelay < 0) { + throw new ConfigurationErrorsException("Negative Respawnzeit bei Ameisen ist nicht zulässig"); + } + + if (BugRespawnDelay < 0) { + throw new ConfigurationErrorsException("Negative Respawnzeit bei Wanzen ist nicht zulässig"); + } + + if (SugarRespawnDelay < 0) { + throw new ConfigurationErrorsException("Negative Respawnzeit bei Zucker ist nicht zulässig"); + } + + if (FruitRespawnDelay < 0) { + throw new ConfigurationErrorsException("Negative Respawnzeit bei Obst ist nicht zulässig"); + } + + // Bugsettings + if (BugAttack < 0) { + throw new ConfigurationErrorsException("Negativer Angriffswert für Wanzen ist nicht zulässig"); + } + + if (BugRotationSpeed < 0) { + throw new ConfigurationErrorsException("Negative Rotationsgeschwindigkeit für Wanzen ist nicht zulässig"); + } + + if (BugEnergy < 0) { + throw new ConfigurationErrorsException("Negativer Energiewert für Wanzen ist nicht zulässig"); + } + + if (BugSpeed < 0) { + throw new ConfigurationErrorsException("Negativer Geschwindigkeitswert für Wanzen ist nicht zulässig"); + } + + if (BugRadius < 0) { + throw new ConfigurationErrorsException("Negativer Radius für Wanzen ist nicht zulässig"); + } + + if (BugRegenerationValue < 0) { + throw new ConfigurationErrorsException("Negativer Regenerationswert für Wanzen ist nicht zulässig"); + } + + if (BugRegenerationDelay < 0) { + throw new ConfigurationErrorsException("Negativer Regenerationsdelay für Wanzen ist nicht zulässig"); + } + + // Foodstuff + if (SugarAmountMinimum < 0) { + throw new ConfigurationErrorsException("Negativer Nahrungswert bei Zucker ist nicht zulässig"); + } + + if (SugarAmountMaximum < 0) { + throw new ConfigurationErrorsException("Negativer Nahrungswert bei Zucker ist nicht zulässig"); + } + + if (FruitAmountMinimum < 0) { + throw new ConfigurationErrorsException("Negativer Nahrungswert bei Obst ist nicht zulässig"); + } + + if (FruitAmountMaximum < 0) { + throw new ConfigurationErrorsException("Negativer Nahrungswert bei Obst ist nicht zulässig"); + } + + if (FruitLoadMultiplier < 0) { + throw new ConfigurationErrorsException("Negativer Loadmultiplikator bei Obst ist nicht zulässig"); + } + + if (FruitRadiusMultiplier < 0) { + throw new ConfigurationErrorsException("Negativer Radiusmultiplikator bei Obst ist nicht zulässig"); + } + + // Marker + + if (MarkerSizeMinimum < 0) { + throw new ConfigurationErrorsException("Negative Minimalgröße bei Markierung ist nicht zulässig"); + } + + if (MarkerDistance < 0) { + throw new ConfigurationErrorsException("Negative Mindestdistanz bei Markierung ist nicht zulässig"); + } + + if (MarkerMaximumAge < 0) { + throw new ConfigurationErrorsException("Negative maximallebensdauer bei Markierungen ist nicht zulässig"); + } + + // Castes + CasteSettings.RuleCheck(); + } + + #endregion + + #region Properties + + /// + /// Gets the maximal Speed of an insect. + /// + public int MaximumSpeed { + get { + int maxValue = BugSpeed; + for (int i = 0; i < CasteSettings.Columns.Length; i++) { + maxValue = Math.Max(maxValue, CasteSettings.Columns[i].Speed); + } + return maxValue; + } + } + + /// + /// Gets the maximal size of a marker. + /// + public int MarkerSizeMaximum { + get { + return MarkerSizeMinimum * MarkerMaximumAge; + } + } + + /// + /// Gets the maximal size of a marker (without radius) + /// + public int MarkerRangeMaximum { + get { + return MarkerSizeMaximum - MarkerSizeMinimum; + } + } + + #endregion + + #region Serialization + + /// + /// Saves the settings to a setting-file. + /// + /// settings to save + /// filename of target file + public static void SaveSettings(SimulationSettings settings, string filename) { + // Open Filestream + FileStream target = new FileStream(filename, FileMode.Create, FileAccess.Write); + + // Serialize + try { + XmlSerializer serializer = new XmlSerializer(typeof (SimulationSettings)); + serializer.Serialize(target, settings); + } + finally { + target.Close(); + } + } + + /// + /// Loads settings from a setting-file. + /// + /// filename of target file + /// Loaded settings + public static SimulationSettings LoadSettings(string filename) { + + // Open File + using (FileStream source = new FileStream(filename, FileMode.Open, FileAccess.Read)) + { + return LoadSettings(source); + } + } + + public static SimulationSettings LoadSettings(Stream stream) + { + XmlSerializer serializer = new XmlSerializer(typeof(SimulationSettings)); + return (SimulationSettings)serializer.Deserialize(stream); + } + + #endregion + + /// + /// Gives the name of the settings. + /// + /// Name of Settings + public override string ToString() + { + return SettingsName; + } + + /// + /// Checks, if two different simulation-sets are equal. + /// + /// + /// + public override bool Equals(object obj) + { + if (!(obj is SimulationSettings)) { + return false; + } + + return Guid.Equals(((SimulationSettings)obj).Guid); + } + + /// + /// Generates a Hash-Code for that object. + /// + /// Hash-Code + public override int GetHashCode() + { + return Guid.GetHashCode(); + } + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/Simulator.cs b/SimulationCore/Simulation/Simulator.cs new file mode 100644 index 0000000..87d1189 --- /dev/null +++ b/SimulationCore/Simulation/Simulator.cs @@ -0,0 +1,299 @@ +using System; +using System.Collections.Generic; +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation +{ + /// + /// Represents a complete encapsulated simulation-core. + /// + /// Tom Wendel (tom@antme.net) + public sealed class Simulator : IDisposable + { + #region private variables + + private readonly SimulatorConfiguration configuration; + + private int currentLoop; + private int currentRound; + + private long loopTime; + private long totalTime; + private SimulatorHostState lastHostState; + private readonly Dictionary totalPlayerTime; + private SimulatorProxy proxy; + private long roundTime; + + private SimulatorState state; + private SimulationState lastSimulationState; + + #endregion + + #region Constructor and Init + + /// + /// Creates an Instance of simulator. Should be called only from factory. + /// + /// configuration + public Simulator(SimulatorConfiguration configuration) + { + // Leere Konfiguration prüfen + if (configuration == null) + { + throw new ArgumentNullException("configuration", Resource.SimulationCoreFactoryConfigIsNull); + } + + // Copy config + this.configuration = (SimulatorConfiguration) configuration.Clone(); + + // Reload PlayerInfo + if (this.configuration.Teams != null) { + foreach (TeamInfo team in this.configuration.Teams) { + if (team.Player != null) + { + for (int i = 0; i < team.Player.Count; i++) { + PlayerInfo player = team.Player[i]; + if (player is PlayerInfoFiledump) { + team.Player[i] = + AiAnalysis.FindPlayerInformation( + ((PlayerInfoFiledump) player).File, player.ClassName); + } + else if (player is PlayerInfoFilename) { + team.Player[i] = + AiAnalysis.FindPlayerInformation( + ((PlayerInfoFilename)player).File, player.ClassName); + } + else { + // TODO: Throw unknown type... + } + team.Player[i].Guid = player.Guid; + } + } + } + } + + // Regelprüfung der Konfig anwerfen + configuration.Rulecheck(); + + + // Init values + currentLoop = 0; + currentRound = 0; + roundTime = 0; + loopTime = 0; + totalTime = 0; + + // TODO: Need another key to manage times + totalPlayerTime = new Dictionary(); + //for (int i = 0; i < configuration.Teams.Count; i++) + //{ + // for (int j = 0; j < configuration.Teams[i].Player.Count; j++) + // { + // totalPlayerTime.Add(configuration.Teams[i].Player[j], 0); + // } + //} + + // Set initial state + state = SimulatorState.Ready; + } + + #endregion + + #region public methods + + /// + /// Calculates the next step and deliver through parameter. + /// + /// empty + public void Step(ref SimulationState simulationState) + { + lastSimulationState = simulationState; + switch (state) + { + case SimulatorState.Ready: + case SimulatorState.Simulating: + + // Create proxy + if (proxy == null) + { + proxy = new SimulatorProxy(); + proxy.Init(configuration); + currentLoop++; + currentRound = 0; + loopTime = 0; + for (int i = 0; i < configuration.Teams.Count; i++) + { + for (int j = 0; j < configuration.Teams[i].Player.Count; j++) + { + totalPlayerTime[configuration.Teams[i].Player[j]] = 0; + } + } + state = SimulatorState.Simulating; + } + + // Calculate step + currentRound++; + lastHostState = proxy.Step(ref lastSimulationState); + simulationState = lastSimulationState; + + // Calculate times + roundTime = lastHostState.ElapsedRoundTime; + loopTime += lastHostState.ElapsedRoundTime; + totalTime += lastHostState.ElapsedRoundTime; + for (int i = 0; i < configuration.Teams.Count; i++) + { + for (int j = 0; j < configuration.Teams[i].Player.Count; j++) + { + // TODO: Fix Dictionary-Problem with time-list + PlayerInfo info = configuration.Teams[i].Player[j]; + //totalPlayerTime[info] += lastHostState.ElapsedPlayerTimes[info]; + } + } + + // After one loop, unload appdomain + if (currentRound >= configuration.RoundCount) + { + proxy.Unload(); + proxy = null; + GC.Collect(); + } + + // Mark Simulator as finished after all loops + if (currentRound >= configuration.RoundCount && + currentLoop >= configuration.LoopCount) + { + state = SimulatorState.Finished; + } + break; + + case SimulatorState.Finished: + + // Throw exception, if step was called on a finished simulator + throw new InvalidOperationException( + Resource.SimulationCoreSimulatorRestartFailed); + } + lastSimulationState = null; + } + + /// + /// Disposes open resources. + /// + ~Simulator() + { + Unload(); + } + + /// + /// Disposes open resources. + /// + public void Dispose() + { + Unload(); + } + + /// + /// Unloads simulator. + /// + public void Unload() + { + if (proxy != null) + { + proxy.Unload(); + proxy = null; + GC.Collect(); + } + state = SimulatorState.Finished; + } + + #endregion + + #region Properties + + /// + /// Gets the current simulator-state. + /// + public SimulatorState State + { + get { return state; } + } + + /// + /// Gets the current round of simulation. + /// + public int CurrentRound + { + get { return currentRound; } + } + + /// + /// Gets the current loop of simulation. + /// + public int CurrentLoop + { + get { return currentLoop; } + } + + /// + /// Gets the number of ticks the last round was running. + /// + public long RoundTime + { + get { + // TODO: Deliver a bether timeformat. + return roundTime; + } + } + + /// + /// Gets the total number of ticks the current Loop is running. + /// + public TimeSpan LoopTime + { + get { + // TODO: Deliver a bether timeformat. + return new TimeSpan(loopTime); + } + } + + /// + /// Gets the total number of ticks the current simulator is working. + /// + public TimeSpan TotalTime + { + get { + // TODO: Deliver a bether timeformat. + return new TimeSpan(totalTime); + } + } + + /// + /// Gets a the total time of ticks a player needed in the last round. + /// + public Dictionary PlayerRoundTimes + { + // TODO: Deliver a bether timeformat. + get + { + if (lastHostState != null) + { + return null;// lastHostState.ElapsedPlayerTimes; + } + else + { + return null; + } + } + } + + /// + /// Gets the total number of ticks a player needed in the whole loop till now. + /// + public Dictionary PlayerLoopTimes + { + // TODO: Deliver a bether format. + get { return totalPlayerTime; } + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/SimulatorConfiguration.cs b/SimulationCore/Simulation/SimulatorConfiguration.cs new file mode 100644 index 0000000..9a060db --- /dev/null +++ b/SimulationCore/Simulation/SimulatorConfiguration.cs @@ -0,0 +1,314 @@ +using System; +using System.Collections.Generic; +using System.Configuration; + +namespace AntMe.Simulation { + /// + /// Klasse zur Haltung aller relevanten Konfigurationsdaten einer Simulation. + /// + [Serializable] + public sealed class SimulatorConfiguration : ICloneable { + + /// + /// Maximum count of players per Simulation. + /// + public const int PLAYERLIMIT = 8; + + /// + /// Minimum count of rounds for a valid simulation. + /// + public const int ROUNDSMIN = 1; + + /// + /// Maximum count of rounds for a valid simulation. + /// + public const int ROUNDSMAX = Int16.MaxValue; + + /// + /// Minimum count of loops for a valid simulation. + /// + public const int LOOPSMIN = 1; + /// + /// + /// Maximum count of loops for a valid simulation. + /// + public const int LOOPSMAX = Int16.MaxValue; + + /// + /// Minimum value for round-timeouts. + /// + public const int ROUNDTIMEOUTMIN = 1; + + /// + /// Minimum value for loop-timeouts. + /// + public const int LOOPTIMEOUTMIN = 1; + + #region lokale Variablen + + // Runden- und Spielereinstellungen + private int loopCount; + private int roundCount; + private bool allowDebuginformation; + private int loopTimeout; + + // Zusätzliche Rechte anforderbar + private bool allowDatabaseAccess; + private bool allowFileAccess; + private bool allowReferences; + private bool allowUserinterfaceAccess; + private bool allowNetworkAccess; + + /// + /// Timeout-Handling + /// + private bool ignoreTimeouts; + + private int roundTimeout; + private List teams; + + // Sonstiges + private int mapInitialValue; + private SimulationSettings settings; + + #endregion + + #region Initialisierung und Konstruktoren + + /// + /// Initialisiert eine leere Spielerliste + /// + public SimulatorConfiguration() { + roundCount = 5000; + loopCount = 1; + teams = new List(); + + ignoreTimeouts = true; + roundTimeout = 1000; + loopTimeout = 6000; + + allowDatabaseAccess = false; + allowReferences = false; + allowUserinterfaceAccess = false; + allowFileAccess = false; + allowNetworkAccess = false; + + allowDebuginformation = false; + mapInitialValue = 0; + + settings.SetDefaults(); + } + + /// + /// Initialsiert mit den übergebenen Werten + /// + /// Anzahl Durchläufe + /// Anzahl Runden + /// Teamliste + public SimulatorConfiguration(int loops, int rounds, List teams) : this() { + if (teams != null) { + this.teams = teams; + } + roundCount = rounds; + loopCount = loops; + ignoreTimeouts = false; + } + + #endregion + + #region öffentliche Methoden + + /// + /// Ermittelt, ob die Angaben der Konfiguration simulationsfähig sind + /// + /// Regelkonformer Konfigurationsinhalt + public void Rulecheck() { + // Rundenanzahl prüfen + if (roundCount < ROUNDSMIN) { + throw new ConfigurationErrorsException(Resource.SimulationCoreConfigurationRoundCountTooSmall); + } + if (roundCount > ROUNDSMAX) { + throw new ConfigurationErrorsException( + string.Format(Resource.SimulationCoreConfigurationRoundCountTooBig, ROUNDSMAX)); + } + + // Durchlaufmenge prüfen + if (loopCount < LOOPSMIN) { + throw new ConfigurationErrorsException(Resource.SimulationCoreConfigurationLoopCountTooSmall); + } + if (loopCount > LOOPSMAX) { + throw new ConfigurationErrorsException( + string.Format(Resource.SimulationCoreConfigurationLoopCountTooBig, LOOPSMAX)); + } + + // Timeoutwerte + if (!ignoreTimeouts) { + if (loopTimeout < LOOPTIMEOUTMIN) { + throw new ConfigurationErrorsException( + Resource.SimulationCoreConfigurationLoopTimeoutTooSmall); + } + if (roundTimeout < ROUNDTIMEOUTMIN) { + throw new ConfigurationErrorsException( + Resource.SimulationCoreConfigurationRoundTimeoutTooSmall); + } + } + + // Teams checken + if (teams == null || teams.Count < 0) { + throw new ConfigurationErrorsException( + Resource.SimulationCoreConfigurationNoTeams); + } + + // Regelcheck der Teams + int playerCount = 0; + foreach (TeamInfo team in teams) { + team.Rulecheck(); + playerCount += team.Player.Count; + } + + if (playerCount > PLAYERLIMIT) { + // TODO: Put string into res-file + throw new ConfigurationErrorsException("Too many players"); + } + + // Regeln für die kern-Einstellungen + Settings.RuleCheck(); + } + + #endregion + + #region Eigenschaften + + /// + /// Gibt die Anzahl der Runden insgesamt an, die in der Simulation durchlaufen werden sollen oder legt diese fest. + /// + public int RoundCount { + get { return roundCount; } + set { roundCount = value; } + } + + /// + /// Gibt die Anzahl Durchläufe insgesamt an, die in der Simulation durchlaufen werden sollen oder legt diese fest. + /// + public int LoopCount { + get { return loopCount; } + set { loopCount = value; } + } + + /// + /// Legt fest, ob die Simulation zu debugzwecken Timeouts ignorieren soll. + /// + public bool IgnoreTimeouts { + get { return ignoreTimeouts; } + set { ignoreTimeouts = value; } + } + + /// + /// Legt die Timeout-Zeit von Runden in ms fest + /// + public int RoundTimeout { + get { return roundTimeout; } + set { roundTimeout = value; } + } + + /// + /// Legt die Timeout-Zeit von Durchläufen in ms fest + /// + public int LoopTimeout { + get { return loopTimeout; } + set { loopTimeout = value; } + } + + /// + /// Liefert die Liste der Mitspieler in dieser Simulation. + /// + public List Teams { + get { return teams; } + } + + /// + /// Legt fest, ob es den Spielern erlaubt ist auf das Userinterface zuzugreifen + /// + public bool AllowUserinterfaceAccess { + set { allowUserinterfaceAccess = value; } + get { return allowUserinterfaceAccess; } + } + + /// + /// Legt fest, ob es den Spielern erlaubt ist auf das Dateisystem zuzugreifen + /// + public bool AllowFileAccess { + set { allowFileAccess = value; } + get { return allowFileAccess; } + } + + /// + /// Legt fest, ob es den Spielern erlaubt ist auf fremde Bibliotheken zuzugreifen + /// + public bool AllowReferences { + set { allowReferences = value; } + get { return allowReferences; } + } + + /// + /// Legt fest, ob es den Spielern erlaubt ist Datenbankverbindungen zu öffnen + /// + public bool AllowDatabaseAccess { + set { allowDatabaseAccess = value; } + get { return allowDatabaseAccess; } + } + + /// + /// Legt fest, ob es den Spielern erlaubt ist eine Netzwerkverbindung zu öffnen + /// + public bool AllowNetworkAccess { + set { allowNetworkAccess = value; } + get { return allowNetworkAccess; } + } + + /// + /// Gibt an, ob die Simulation Debuginformationen ausgeben soll + /// + public bool AllowDebuginformation { + set { allowDebuginformation = value; } + get { return allowDebuginformation; } + } + + /// + /// Gibt einen Startwert für die Initialisierung des Zufallsgenerators an. Durch einen gleichen + /// Startwert werden gleiche Startbedingungen garantiert. + /// + public int MapInitialValue { + set { mapInitialValue = value; } + get { return mapInitialValue; } + } + + /// + /// Gets or sets the simulation-settings for this simulation. + /// + public SimulationSettings Settings { + set { settings = value; } + get { return settings; } + } + + #endregion + + #region ICloneable Member + + /// + /// Erstellt eine Kopie der Konfiguration + /// + /// Kopie der aktuellen Konfiguration + public object Clone() { + // Kopie erstellen und Spielerliste kopieren + SimulatorConfiguration output = (SimulatorConfiguration) MemberwiseClone(); + output.teams = new List(teams.Count); + foreach (TeamInfo team in teams) { + output.teams.Add((TeamInfo) team.Clone()); + } + return output; + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/SimulatorHost.cs b/SimulationCore/Simulation/SimulatorHost.cs new file mode 100644 index 0000000..b2dd61d --- /dev/null +++ b/SimulationCore/Simulation/SimulatorHost.cs @@ -0,0 +1,241 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; +using System.Threading; +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation +{ + /// + /// Class, to host an simulation-Environment inside an . + /// + internal sealed class SimulatorHost : MarshalByRefObject + { + #region internal Variables + + private Area currentArea; + private PlayerInfo currentPlayer; + private Exception exception; + private SimulatorConfiguration configuration; + private Dictionary playerTimes; + private SimulatorHostState lastHostState; + private SimulationState lastSimulationState; + + private readonly Stopwatch playerWatch = new Stopwatch(); + private readonly Stopwatch stepWatch = new Stopwatch(); + private SimulationEnvironment environment; + + #endregion + + #region Constructor and Init + + /// + /// Initialize the simulation-environment. + /// + /// configuration + public bool Init(SimulatorConfiguration config) + { + // Prepare values + configuration = config; + SimulationSettings.SetCustomSettings(config.Settings); + environment = null; + + // Prepare time-counting + playerTimes = new Dictionary(); + currentPlayer = null; + currentArea = Area.Unknown; + + // Load Playerfiles + foreach (TeamInfo team in configuration.Teams) + { + foreach (PlayerInfo spieler in team.Player) + { + if (spieler is PlayerInfoFiledump) + { + // Try, to load filedump + try + { + spieler.assembly = Assembly.Load(((PlayerInfoFiledump) spieler).File); + } + catch (Exception ex) + { + exception = ex; + return false; + } + } + else if (spieler is PlayerInfoFilename) + { + // Try, to load filename + try + { + spieler.assembly = Assembly.LoadFile(((PlayerInfoFilename) spieler).File); + } + catch (Exception ex) + { + exception = ex; + return false; + } + } + else + { + exception = + new InvalidOperationException( + Resource.SimulationCoreHostWrongPlayerInfo); + return false; + } + + // Add player to counter-list + // TODO: Need another key for times + // playerTimes.Add(spieler, 0); + } + } + + // Init environment + try + { + environment = new SimulationEnvironment(); + environment.AreaChange += umgebung_Verantwortungswechsel; + environment.Init(configuration); + } + catch (Exception ex) + { + exception = ex; + return false; + } + + // Everything nice... + return true; + } + + #endregion + + #region Public Methods + + /// + /// Executes one single step in simulation and returns hostState. + /// + /// Summery of the executed simulationStep + public SimulatorHostState Step(ref SimulationState simulationState) + { + if (environment == null) + { + throw new InvalidOperationException(Resource.SimulationCoreHostEnvironmentNotInit); + } + + // Reset of times + stepWatch.Reset(); + foreach (TeamInfo team in configuration.Teams) + { + foreach (PlayerInfo spieler in team.Player) + { + // TODO: need another key + // playerTimes[spieler] = 0; + } + } + + // Init Step-Thread + exception = null; + lastSimulationState = simulationState; + Thread stepThread = new Thread(step); + stepWatch.Start(); + stepThread.Start(); + if (configuration.IgnoreTimeouts) + { + // Wait without any timeout + stepThread.Join(); + } + else + { + // Wait for thread with timeout + if (!stepThread.Join(configuration.RoundTimeout)) + { + throw new TimeoutException(Resource.SimulationCoreHostRoundTimeout); + } + } + stepWatch.Stop(); + + // Bei Exceptions null zurück liefern, um Fehler zu signalisieren + if (exception != null) + { + return null; + } + + // Add player-times + lastHostState.ElapsedRoundTime = stepWatch.ElapsedTicks; + for (int i = 0; i < configuration.Teams.Count; i++) + { + for (int j = 0; j < configuration.Teams[i].Player.Count; j++) + { + // TODO: Fix Dictionary-Problem + PlayerInfo player = configuration.Teams[i].Player[j]; + //lastHostState.ElapsedPlayerTimes.Add(player, playerTimes[player]); + } + } + + // deliver host-state + return lastHostState; + } + + #endregion + + #region Properties + + /// + /// Gets the last thrown exception. + /// + public Exception Exception + { + get { return exception; } + } + + #endregion + + #region Helper-Methods + + /// + /// Internal step-Method to calculate the next step + /// + private void step() + { + lastHostState = new SimulatorHostState(); + try + { + environment.Step(lastSimulationState); + lastSimulationState.TotalRounds = (ushort) configuration.RoundCount; + } + catch (Exception ex) + { + exception = ex; + } + } + + #endregion + + #region Eventhandler + + private void umgebung_Verantwortungswechsel(object sender, AreaChangeEventArgs e) + { + // Aktuellen Timer stoppen + if (currentPlayer != e.Player && currentPlayer != null) + { + playerWatch.Stop(); + // TODO: need another key + // playerTimes[currentPlayer] += playerWatch.ElapsedTicks; + currentPlayer = null; + currentArea = Area.Unknown; + } + + // Neuen Timer starten + if (e.Player != null) + { + currentPlayer = e.Player; + currentArea = e.Area; + playerWatch.Reset(); + playerWatch.Start(); + } + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/SimulatorHostState.cs b/SimulationCore/Simulation/SimulatorHostState.cs new file mode 100644 index 0000000..0b42133 --- /dev/null +++ b/SimulationCore/Simulation/SimulatorHostState.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; + +namespace AntMe.Simulation { + /// + /// Statusklasse zur Weitergabe des aktuellen Spielstandes aus dem Host zurück zum Simulator + /// + /// Tom Wendel (tom@antme.net) + [Serializable] + internal sealed class SimulatorHostState { + public List DebugMessages = new List(); + public long ElapsedRoundTime; + //public Dictionary ElapsedPlayerTimes = new Dictionary(); + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/SimulatorProxy.cs b/SimulationCore/Simulation/SimulatorProxy.cs new file mode 100644 index 0000000..d075389 --- /dev/null +++ b/SimulationCore/Simulation/SimulatorProxy.cs @@ -0,0 +1,197 @@ +using System; +using System.Configuration; +using System.Reflection; +using System.Security; +using System.Security.Permissions; + +using AntMe.SharedComponents.States; + +namespace AntMe.Simulation { + /// + /// Proxy-Class to host an AppDomain für the encapsulated simulation. + /// + /// Tom Wendel (tom@antme.net) + internal sealed class SimulatorProxy { + #region internal Variables + + /// + /// Appdomain to host the simulation in. + /// + private AppDomain appDomain; + + /// + /// Proxy for the simulationHost inside the appDomain. + /// + private SimulatorHost host; + + #endregion + + #region public Methods + + /// + /// Initialisierung der Simulation + /// + /// Simulationskonfiguration + public void Init(SimulatorConfiguration configuration) { + // unload possible appdomains. + Unload(); + + // load involved ai's + for (int team = 0; team < configuration.Teams.Count; team++) { + for (int i = 0; i < configuration.Teams[team].Player.Count; i++) { + + // externe Guid-Info speichern + Guid guid = configuration.Teams[team].Player[i].Guid; + + if (configuration.Teams[team].Player[i] is PlayerInfoFiledump) { + // use filedump + configuration.Teams[team].Player[i] = + AiAnalysis.FindPlayerInformation( + ((PlayerInfoFiledump) configuration.Teams[team].Player[i]).File, + configuration.Teams[team].Player[i].ClassName); + } + else if (configuration.Teams[team].Player[i] is PlayerInfoFilename) { + // use filename + configuration.Teams[team].Player[i] = + AiAnalysis.FindPlayerInformation( + ((PlayerInfoFilename) configuration.Teams[team].Player[i]).File, + configuration.Teams[team].Player[i].ClassName); + } + else { + // not supported PlayerInfo-type + throw new InvalidOperationException( + Resource.SimulationCoreProxyWrongPlayerInfo); + } + + // Rückspeicherung der externen Guid + configuration.Teams[team].Player[i].Guid = guid; + } + } + + // setup appDomain + AppDomainSetup setup = new AppDomainSetup(); + setup.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase; + setup.ShadowCopyDirectories = AppDomain.CurrentDomain.SetupInformation.ShadowCopyDirectories; + setup.ShadowCopyFiles = "false"; + setup.PrivateBinPath = ""; + + // setup some access-rights für appdomain + PermissionSet rechte = new PermissionSet(PermissionState.None); + rechte.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution)); + rechte.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess)); + + bool IoAccess = false; + bool UiAccess = false; + bool DbAccess = false; + bool NetAccess = false; + + // allow access to the needed ai-files + foreach (TeamInfo team in configuration.Teams) { + foreach (PlayerInfo info in team.Player) { + if (info is PlayerInfoFilename) { + rechte.AddPermission( + new FileIOPermission( + FileIOPermissionAccess.Read | + FileIOPermissionAccess.PathDiscovery, + ((PlayerInfoFilename) info).File)); + } + if (info.RequestDatabaseAccess) DbAccess = true; + if (info.RequestFileAccess) IoAccess = true; + if (info.RequestNetworkAccess) NetAccess = true; + if (info.RequestUserInterfaceAccess) UiAccess = true; + } + } + + // Grand special rights + if (IoAccess) { + if (configuration.AllowFileAccess) { + rechte.AddPermission(new FileIOPermission(PermissionState.Unrestricted)); + } + else { + throw new ConfigurationErrorsException(Resource.SimulationCoreRightsConflictIo); + } + } + + if (UiAccess) { + if (configuration.AllowUserinterfaceAccess) { + rechte.AddPermission(new UIPermission(PermissionState.Unrestricted)); + } + else { + throw new ConfigurationErrorsException(Resource.SimulationCoreRightsConflictUi); + } + } + + if (DbAccess) { + if (configuration.AllowDatabaseAccess) { + // TODO: Grand rights + } + else { + throw new ConfigurationErrorsException(Resource.SimulationCoreRightsConflictDb); + } + } + + if (NetAccess) { + if (configuration.AllowNetworkAccess) { + rechte.AddPermission(new System.Net.WebPermission(PermissionState.Unrestricted)); + rechte.AddPermission(new System.Net.SocketPermission(PermissionState.Unrestricted)); + rechte.AddPermission(new System.Net.DnsPermission(PermissionState.Unrestricted)); + } + else { + throw new ConfigurationErrorsException(Resource.SimulationCoreRightsConflictNet); + } + } + + // create appdomain and load simulation-host + appDomain = AppDomain.CreateDomain("Simulation", AppDomain.CurrentDomain.Evidence, setup, rechte); + + host = + (SimulatorHost) + appDomain.CreateInstanceAndUnwrap( + Assembly.GetExecutingAssembly().FullName, "AntMe.Simulation.SimulatorHost"); + + // initialize host + if (!host.Init(configuration)) { + // got some exceptions - unload appdomain und throw exception + Exception ex = host.Exception; + Unload(); + throw ex; + } + } + + /// + /// Executes one single step in simulation and returns hostState. + /// + /// The prefilled simulationState to put the currrent simulation-Snapshot in. + /// Summery of the executed simulationStep. + public SimulatorHostState Step(ref SimulationState simulationState) { + // check, of proxy is still usable + if (host == null) { + throw new InvalidOperationException(Resource.SimulationCoreProxyUnloaded); + } + + // execute step inside the appdomain via host + SimulatorHostState state = host.Step(ref simulationState); + + // in case of an exception + if (state == null) { + throw host.Exception; + } + + // return success + return state; + } + + /// + /// Unloads the appdomain, if needed and reset the proxy. + /// + public void Unload() { + if (appDomain != null) { + AppDomain.Unload(appDomain); + appDomain = null; + host = null; + } + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/SimulatorState.cs b/SimulationCore/Simulation/SimulatorState.cs new file mode 100644 index 0000000..ee41bc3 --- /dev/null +++ b/SimulationCore/Simulation/SimulatorState.cs @@ -0,0 +1,21 @@ +namespace AntMe.Simulation { + /// + /// Liste der möglichen Stati eines Simulators + /// + public enum SimulatorState { + /// + /// Der Simulator ist initialisiert, aber noch nicht gestartet worden + /// + Ready, + + /// + /// Der Simulator simuliert gerade + /// + Simulating, + + /// + /// Die Simulation wurde beendet + /// + Finished + } +} \ No newline at end of file diff --git a/SimulationCore/Simulation/TeamInfo.cs b/SimulationCore/Simulation/TeamInfo.cs new file mode 100644 index 0000000..dfa8cac --- /dev/null +++ b/SimulationCore/Simulation/TeamInfo.cs @@ -0,0 +1,124 @@ +using System; +using System.Collections.Generic; + +namespace AntMe.Simulation { + /// + /// Repräsentiert ein Team innerhalb der Simulationskonfiguration + /// + [Serializable] + public sealed class TeamInfo : ICloneable { + + /// + /// Guid des Teams + /// + public Guid Guid; + + /// + /// Name des Teams + /// + public string Name; + + /// + /// Liste der enthaltenen Spieler + /// + private List player; + + #region Initialisierung und Konstruktor + + /// + /// Konstruktor des Teams + /// + public TeamInfo() { + Guid = System.Guid.NewGuid(); + player = new List(); + } + + /// + /// Konstruktor des Teams + /// + /// Liste der Spieler + public TeamInfo(List player) : this() { + this.player = player; + } + + /// + /// Konstruktor des Teams + /// + /// Guid des Teams + /// Liste der Spieler + public TeamInfo(Guid guid, List player) : this(player) { + Guid = guid; + } + + /// + /// Konstruktor des Teams + /// + /// Name des Teams + /// Liste der Spieler + public TeamInfo(string name, List player) : this(player) { + Name = name; + } + + /// + /// Konstruktor des Teams + /// + /// Guid des Teams + /// Name des Teams + /// Liste der Spieler + public TeamInfo(Guid guid, string name, List player) + : this(player) { + Guid = guid; + Name = name; + } + + #endregion + + #region Eigenschaften + + /// + /// Liste der spieler dieses Teams + /// + public List Player { + get { return player; } + } + + #endregion + + #region öffentliche Methoden + + /// + /// Prüft, ob das Team regelkonform aufgebaut ist + /// + public void Rulecheck() { + // Menge der Spieler prüfen + if (player == null || player.Count < 1) { + // TODO: Name der Resource ist Mist + throw new InvalidOperationException(Resource.SimulationCoreTeamInfoNoName); + } + + // Regelcheck bei den enthaltenen Spielern + foreach (PlayerInfo info in player) { + info.RuleCheck(); + } + } + + #endregion + + #region ICloneable Member + + /// + /// Erstellt eine Kopie des Teams + /// + /// Kopie des Teams + public object Clone() { + TeamInfo output = (TeamInfo) MemberwiseClone(); + output.player = new List(player.Count); + foreach (PlayerInfo info in player) { + output.player.Add((PlayerInfo) info.Clone()); + } + return output; + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationCore/SimulationCore.csproj b/SimulationCore/SimulationCore.csproj new file mode 100644 index 0000000..8b57db7 --- /dev/null +++ b/SimulationCore/SimulationCore.csproj @@ -0,0 +1,226 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {35753E72-07F3-4F18-916C-479850EC375F} + Library + Properties + AntMe + AntMe.Simulation + SAK + SAK + SAK + SAK + true + AntMe.snk + + + 3.5 + + + false + v4.0 + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + true + + + + true + ..\bin\ + DEBUG;TRACE + ..\bin\AntMe.Simulation.XML + full + x86 + true + GlobalSuppressions.cs + prompt + AllRules.ruleset + + + ..\bin\ + TRACE + ..\bin\AntMe.Simulation.XML + true + pdbonly + x86 + true + GlobalSuppressions.cs + prompt + AllRules.ruleset + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + True + True + Settings.settings + + + True + True + Resource.resx + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + + + 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 + + + + + {415F50C3-BD70-4634-B1F7-A15B42F0B0C6} + SharedComponents + + + + + Designer + + + ResXFileCodeGenerator + Resource.Designer.cs + Designer + + + + + \ No newline at end of file diff --git a/SimulationPlugin/AntMe.snk b/SimulationPlugin/AntMe.snk new file mode 100644 index 0000000..cdd75a4 Binary files /dev/null and b/SimulationPlugin/AntMe.snk differ diff --git a/SimulationPlugin/AntProperties.Designer.cs b/SimulationPlugin/AntProperties.Designer.cs new file mode 100644 index 0000000..8c2444c --- /dev/null +++ b/SimulationPlugin/AntProperties.Designer.cs @@ -0,0 +1,552 @@ +namespace AntMe.Plugin.Simulation { + partial class AntProperties + { + /// + /// 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(AntProperties)); + this.okButton = new System.Windows.Forms.Button(); + this.tabControl = new System.Windows.Forms.TabControl(); + this.common = new System.Windows.Forms.TabPage(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.klassennameTextBox = new System.Windows.Forms.TextBox(); + this.label28 = new System.Windows.Forms.Label(); + this.dateinameTextBox = new System.Windows.Forms.TextBox(); + this.statischLabel = new System.Windows.Forms.Label(); + this.label30 = new System.Windows.Forms.Label(); + this.debugLabel = new System.Windows.Forms.Label(); + this.label4 = new System.Windows.Forms.Label(); + this.datumLabel = new System.Windows.Forms.Label(); + this.dateigrößeLabel = new System.Windows.Forms.Label(); + this.spracheLabel = new System.Windows.Forms.Label(); + this.versionLabel = new System.Windows.Forms.Label(); + this.autorLabel = new System.Windows.Forms.Label(); + this.label27 = new System.Windows.Forms.Label(); + this.label26 = new System.Windows.Forms.Label(); + this.label25 = new System.Windows.Forms.Label(); + this.label24 = new System.Windows.Forms.Label(); + this.label23 = new System.Windows.Forms.Label(); + this.label22 = new System.Windows.Forms.Label(); + this.kiNameLabel1 = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.castes = new System.Windows.Forms.TabPage(); + this.pictureBox2 = new System.Windows.Forms.PictureBox(); + this.kiNameLabel2 = new System.Windows.Forms.Label(); + this.label29 = new System.Windows.Forms.Label(); + this.casteGroupBox = new System.Windows.Forms.GroupBox(); + this.rangeLabel = new System.Windows.Forms.Label(); + this.viewRangelabel = new System.Windows.Forms.Label(); + this.label10 = new System.Windows.Forms.Label(); + this.energyLabel = new System.Windows.Forms.Label(); + this.loadLabel = new System.Windows.Forms.Label(); + this.speedLabel = new System.Windows.Forms.Label(); + this.attackLabel = new System.Windows.Forms.Label(); + this.rotationSpeedLabel = new System.Windows.Forms.Label(); + this.casteNameLabel = new System.Windows.Forms.Label(); + this.label13 = new System.Windows.Forms.Label(); + this.label12 = new System.Windows.Forms.Label(); + this.label11 = new System.Windows.Forms.Label(); + this.label9 = new System.Windows.Forms.Label(); + this.label8 = new System.Windows.Forms.Label(); + this.label7 = new System.Windows.Forms.Label(); + this.label6 = new System.Windows.Forms.Label(); + this.label5 = new System.Windows.Forms.Label(); + this.castesListView = new System.Windows.Forms.ListView(); + this.imageList = new System.Windows.Forms.ImageList(this.components); + this.security = new System.Windows.Forms.TabPage(); + this.pictureBox3 = new System.Windows.Forms.PictureBox(); + this.zusatzinfosTextBox = new System.Windows.Forms.TextBox(); + this.kiNameLabel3 = new System.Windows.Forms.Label(); + this.label31 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.label1 = new System.Windows.Forms.Label(); + this.rechteListView = new System.Windows.Forms.ListView(); + this.tabControl.SuspendLayout(); + this.common.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.castes.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).BeginInit(); + this.casteGroupBox.SuspendLayout(); + this.security.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox3)).BeginInit(); + this.SuspendLayout(); + // + // okButton + // + resources.ApplyResources(this.okButton, "okButton"); + this.okButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.okButton.Name = "okButton"; + this.okButton.UseVisualStyleBackColor = true; + // + // tabControl + // + resources.ApplyResources(this.tabControl, "tabControl"); + this.tabControl.Controls.Add(this.common); + this.tabControl.Controls.Add(this.castes); + this.tabControl.Controls.Add(this.security); + this.tabControl.Name = "tabControl"; + this.tabControl.SelectedIndex = 0; + // + // common + // + this.common.Controls.Add(this.pictureBox1); + this.common.Controls.Add(this.klassennameTextBox); + this.common.Controls.Add(this.label28); + this.common.Controls.Add(this.dateinameTextBox); + this.common.Controls.Add(this.statischLabel); + this.common.Controls.Add(this.label30); + this.common.Controls.Add(this.debugLabel); + this.common.Controls.Add(this.label4); + this.common.Controls.Add(this.datumLabel); + this.common.Controls.Add(this.dateigrößeLabel); + this.common.Controls.Add(this.spracheLabel); + this.common.Controls.Add(this.versionLabel); + this.common.Controls.Add(this.autorLabel); + this.common.Controls.Add(this.label27); + this.common.Controls.Add(this.label26); + this.common.Controls.Add(this.label25); + this.common.Controls.Add(this.label24); + this.common.Controls.Add(this.label23); + this.common.Controls.Add(this.label22); + this.common.Controls.Add(this.kiNameLabel1); + this.common.Controls.Add(this.label3); + resources.ApplyResources(this.common, "common"); + this.common.Name = "common"; + this.common.UseVisualStyleBackColor = true; + // + // pictureBox1 + // + this.pictureBox1.Image = global::AntMe.Plugin.Simulation.Properties.Resources.colony_nonstatic_32x32; + resources.ApplyResources(this.pictureBox1, "pictureBox1"); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.TabStop = false; + // + // klassennameTextBox + // + resources.ApplyResources(this.klassennameTextBox, "klassennameTextBox"); + this.klassennameTextBox.Name = "klassennameTextBox"; + this.klassennameTextBox.ReadOnly = true; + // + // label28 + // + resources.ApplyResources(this.label28, "label28"); + this.label28.Name = "label28"; + // + // dateinameTextBox + // + resources.ApplyResources(this.dateinameTextBox, "dateinameTextBox"); + this.dateinameTextBox.Name = "dateinameTextBox"; + this.dateinameTextBox.ReadOnly = true; + // + // statischLabel + // + resources.ApplyResources(this.statischLabel, "statischLabel"); + this.statischLabel.Name = "statischLabel"; + // + // label30 + // + resources.ApplyResources(this.label30, "label30"); + this.label30.Name = "label30"; + // + // debugLabel + // + resources.ApplyResources(this.debugLabel, "debugLabel"); + this.debugLabel.Name = "debugLabel"; + // + // label4 + // + resources.ApplyResources(this.label4, "label4"); + this.label4.Name = "label4"; + // + // datumLabel + // + resources.ApplyResources(this.datumLabel, "datumLabel"); + this.datumLabel.Name = "datumLabel"; + // + // dateigrößeLabel + // + resources.ApplyResources(this.dateigrößeLabel, "dateigrößeLabel"); + this.dateigrößeLabel.Name = "dateigrößeLabel"; + // + // spracheLabel + // + resources.ApplyResources(this.spracheLabel, "spracheLabel"); + this.spracheLabel.Name = "spracheLabel"; + // + // versionLabel + // + resources.ApplyResources(this.versionLabel, "versionLabel"); + this.versionLabel.Name = "versionLabel"; + // + // autorLabel + // + resources.ApplyResources(this.autorLabel, "autorLabel"); + this.autorLabel.Name = "autorLabel"; + // + // label27 + // + resources.ApplyResources(this.label27, "label27"); + this.label27.Name = "label27"; + // + // label26 + // + resources.ApplyResources(this.label26, "label26"); + this.label26.Name = "label26"; + // + // label25 + // + resources.ApplyResources(this.label25, "label25"); + this.label25.Name = "label25"; + // + // label24 + // + resources.ApplyResources(this.label24, "label24"); + this.label24.Name = "label24"; + // + // label23 + // + resources.ApplyResources(this.label23, "label23"); + this.label23.Name = "label23"; + // + // label22 + // + resources.ApplyResources(this.label22, "label22"); + this.label22.Name = "label22"; + // + // kiNameLabel1 + // + resources.ApplyResources(this.kiNameLabel1, "kiNameLabel1"); + this.kiNameLabel1.Name = "kiNameLabel1"; + // + // label3 + // + resources.ApplyResources(this.label3, "label3"); + this.label3.Name = "label3"; + // + // castes + // + this.castes.Controls.Add(this.pictureBox2); + this.castes.Controls.Add(this.kiNameLabel2); + this.castes.Controls.Add(this.label29); + this.castes.Controls.Add(this.casteGroupBox); + this.castes.Controls.Add(this.label5); + this.castes.Controls.Add(this.castesListView); + resources.ApplyResources(this.castes, "castes"); + this.castes.Name = "castes"; + this.castes.UseVisualStyleBackColor = true; + // + // pictureBox2 + // + this.pictureBox2.Image = global::AntMe.Plugin.Simulation.Properties.Resources.colony_nonstatic_32x32; + resources.ApplyResources(this.pictureBox2, "pictureBox2"); + this.pictureBox2.Name = "pictureBox2"; + this.pictureBox2.TabStop = false; + // + // kiNameLabel2 + // + resources.ApplyResources(this.kiNameLabel2, "kiNameLabel2"); + this.kiNameLabel2.Name = "kiNameLabel2"; + // + // label29 + // + resources.ApplyResources(this.label29, "label29"); + this.label29.Name = "label29"; + // + // casteGroupBox + // + resources.ApplyResources(this.casteGroupBox, "casteGroupBox"); + this.casteGroupBox.Controls.Add(this.rangeLabel); + this.casteGroupBox.Controls.Add(this.viewRangelabel); + this.casteGroupBox.Controls.Add(this.label10); + this.casteGroupBox.Controls.Add(this.energyLabel); + this.casteGroupBox.Controls.Add(this.loadLabel); + this.casteGroupBox.Controls.Add(this.speedLabel); + this.casteGroupBox.Controls.Add(this.attackLabel); + this.casteGroupBox.Controls.Add(this.rotationSpeedLabel); + this.casteGroupBox.Controls.Add(this.casteNameLabel); + this.casteGroupBox.Controls.Add(this.label13); + this.casteGroupBox.Controls.Add(this.label12); + this.casteGroupBox.Controls.Add(this.label11); + this.casteGroupBox.Controls.Add(this.label9); + this.casteGroupBox.Controls.Add(this.label8); + this.casteGroupBox.Controls.Add(this.label7); + this.casteGroupBox.Controls.Add(this.label6); + this.casteGroupBox.Name = "casteGroupBox"; + this.casteGroupBox.TabStop = false; + // + // rangeLabel + // + resources.ApplyResources(this.rangeLabel, "rangeLabel"); + this.rangeLabel.Name = "rangeLabel"; + // + // viewRangelabel + // + resources.ApplyResources(this.viewRangelabel, "viewRangelabel"); + this.viewRangelabel.Name = "viewRangelabel"; + // + // label10 + // + resources.ApplyResources(this.label10, "label10"); + this.label10.Name = "label10"; + // + // energyLabel + // + resources.ApplyResources(this.energyLabel, "energyLabel"); + this.energyLabel.Name = "energyLabel"; + // + // loadLabel + // + resources.ApplyResources(this.loadLabel, "loadLabel"); + this.loadLabel.Name = "loadLabel"; + // + // speedLabel + // + resources.ApplyResources(this.speedLabel, "speedLabel"); + this.speedLabel.Name = "speedLabel"; + // + // attackLabel + // + resources.ApplyResources(this.attackLabel, "attackLabel"); + this.attackLabel.Name = "attackLabel"; + // + // rotationSpeedLabel + // + resources.ApplyResources(this.rotationSpeedLabel, "rotationSpeedLabel"); + this.rotationSpeedLabel.Name = "rotationSpeedLabel"; + // + // casteNameLabel + // + resources.ApplyResources(this.casteNameLabel, "casteNameLabel"); + this.casteNameLabel.Name = "casteNameLabel"; + // + // label13 + // + resources.ApplyResources(this.label13, "label13"); + this.label13.Name = "label13"; + // + // label12 + // + resources.ApplyResources(this.label12, "label12"); + this.label12.Name = "label12"; + // + // label11 + // + resources.ApplyResources(this.label11, "label11"); + this.label11.Name = "label11"; + // + // label9 + // + resources.ApplyResources(this.label9, "label9"); + this.label9.Name = "label9"; + // + // label8 + // + resources.ApplyResources(this.label8, "label8"); + this.label8.Name = "label8"; + // + // label7 + // + resources.ApplyResources(this.label7, "label7"); + this.label7.Name = "label7"; + // + // label6 + // + resources.ApplyResources(this.label6, "label6"); + this.label6.Name = "label6"; + // + // label5 + // + resources.ApplyResources(this.label5, "label5"); + this.label5.Name = "label5"; + // + // castesListView + // + resources.ApplyResources(this.castesListView, "castesListView"); + this.castesListView.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.castesListView.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.Nonclickable; + this.castesListView.Name = "castesListView"; + this.castesListView.ShowItemToolTips = true; + this.castesListView.SmallImageList = this.imageList; + this.castesListView.UseCompatibleStateImageBehavior = false; + this.castesListView.View = System.Windows.Forms.View.List; + this.castesListView.SelectedIndexChanged += new System.EventHandler(this.select_caste); + // + // imageList + // + this.imageList.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList.ImageStream"))); + this.imageList.TransparentColor = System.Drawing.Color.Transparent; + this.imageList.Images.SetKeyName(0, "security_closed"); + this.imageList.Images.SetKeyName(1, "ant"); + // + // security + // + this.security.Controls.Add(this.pictureBox3); + this.security.Controls.Add(this.zusatzinfosTextBox); + this.security.Controls.Add(this.kiNameLabel3); + this.security.Controls.Add(this.label31); + this.security.Controls.Add(this.label2); + this.security.Controls.Add(this.label1); + this.security.Controls.Add(this.rechteListView); + resources.ApplyResources(this.security, "security"); + this.security.Name = "security"; + this.security.UseVisualStyleBackColor = true; + // + // pictureBox3 + // + this.pictureBox3.Image = global::AntMe.Plugin.Simulation.Properties.Resources.colony_nonstatic_32x32; + resources.ApplyResources(this.pictureBox3, "pictureBox3"); + this.pictureBox3.Name = "pictureBox3"; + this.pictureBox3.TabStop = false; + // + // zusatzinfosTextBox + // + resources.ApplyResources(this.zusatzinfosTextBox, "zusatzinfosTextBox"); + this.zusatzinfosTextBox.Name = "zusatzinfosTextBox"; + this.zusatzinfosTextBox.ReadOnly = true; + // + // kiNameLabel3 + // + resources.ApplyResources(this.kiNameLabel3, "kiNameLabel3"); + this.kiNameLabel3.Name = "kiNameLabel3"; + // + // label31 + // + resources.ApplyResources(this.label31, "label31"); + this.label31.Name = "label31"; + // + // label2 + // + resources.ApplyResources(this.label2, "label2"); + this.label2.Name = "label2"; + // + // label1 + // + resources.ApplyResources(this.label1, "label1"); + this.label1.Name = "label1"; + // + // rechteListView + // + resources.ApplyResources(this.rechteListView, "rechteListView"); + this.rechteListView.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.rechteListView.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.Nonclickable; + this.rechteListView.Name = "rechteListView"; + this.rechteListView.ShowItemToolTips = true; + this.rechteListView.SmallImageList = this.imageList; + this.rechteListView.Sorting = System.Windows.Forms.SortOrder.Ascending; + this.rechteListView.UseCompatibleStateImageBehavior = false; + this.rechteListView.View = System.Windows.Forms.View.List; + // + // AntProperties + // + this.AcceptButton = this.okButton; + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.okButton; + this.Controls.Add(this.tabControl); + this.Controls.Add(this.okButton); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "AntProperties"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.tabControl.ResumeLayout(false); + this.common.ResumeLayout(false); + this.common.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.castes.ResumeLayout(false); + this.castes.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).EndInit(); + this.casteGroupBox.ResumeLayout(false); + this.casteGroupBox.PerformLayout(); + this.security.ResumeLayout(false); + this.security.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox3)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button okButton; + private System.Windows.Forms.TabControl tabControl; + private System.Windows.Forms.TabPage common; + private System.Windows.Forms.TabPage castes; + private System.Windows.Forms.TabPage security; + private System.Windows.Forms.GroupBox casteGroupBox; + private System.Windows.Forms.Label rangeLabel; + private System.Windows.Forms.Label viewRangelabel; + private System.Windows.Forms.Label label10; + private System.Windows.Forms.Label energyLabel; + private System.Windows.Forms.Label loadLabel; + private System.Windows.Forms.Label speedLabel; + private System.Windows.Forms.Label attackLabel; + private System.Windows.Forms.Label rotationSpeedLabel; + private System.Windows.Forms.Label casteNameLabel; + private System.Windows.Forms.Label label13; + private System.Windows.Forms.Label label12; + private System.Windows.Forms.Label label11; + private System.Windows.Forms.Label label9; + private System.Windows.Forms.Label label8; + private System.Windows.Forms.Label label7; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.ListView castesListView; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.ListView rechteListView; + private System.Windows.Forms.Label label27; + private System.Windows.Forms.Label label26; + private System.Windows.Forms.Label label25; + private System.Windows.Forms.Label label24; + private System.Windows.Forms.Label label23; + private System.Windows.Forms.Label label22; + private System.Windows.Forms.Label kiNameLabel1; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label datumLabel; + private System.Windows.Forms.Label dateigrößeLabel; + private System.Windows.Forms.Label spracheLabel; + private System.Windows.Forms.Label versionLabel; + private System.Windows.Forms.Label autorLabel; + private System.Windows.Forms.Label kiNameLabel2; + private System.Windows.Forms.Label label29; + private System.Windows.Forms.Label kiNameLabel3; + private System.Windows.Forms.Label label31; + private System.Windows.Forms.Label statischLabel; + private System.Windows.Forms.Label label30; + private System.Windows.Forms.Label debugLabel; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.TextBox dateinameTextBox; + private System.Windows.Forms.TextBox klassennameTextBox; + private System.Windows.Forms.Label label28; + private System.Windows.Forms.TextBox zusatzinfosTextBox; + private System.Windows.Forms.ImageList imageList; + private System.Windows.Forms.PictureBox pictureBox1; + private System.Windows.Forms.PictureBox pictureBox2; + private System.Windows.Forms.PictureBox pictureBox3; + } +} \ No newline at end of file diff --git a/SimulationPlugin/AntProperties.cs b/SimulationPlugin/AntProperties.cs new file mode 100644 index 0000000..a5cf6b3 --- /dev/null +++ b/SimulationPlugin/AntProperties.cs @@ -0,0 +1,106 @@ +using System.IO; +using System.Windows.Forms; + +using AntMe.Simulation; + +namespace AntMe.Plugin.Simulation { + internal sealed partial class AntProperties : Form { + private readonly PlayerInfoFilename player; + + public AntProperties(PlayerInfoFilename playerInfo) { + player = playerInfo; + InitializeComponent(); + + // Daten einfüllen + kiNameLabel1.Text = player.ColonyName; + kiNameLabel3.Text = player.ColonyName; + kiNameLabel2.Text = player.ColonyName; + Text = string.Format(Resource.SimulatorPluginAntPropertiesTitle, player.ColonyName); + + autorLabel.Text = string.Format(Resource.SimulatorPluginAntPropertiesAuthorFormat, player.FirstName, player.LastName); + versionLabel.Text = player.SimulationVersion.ToString(); + spracheLabel.Text = player.Language.ToString(); + statischLabel.Text = player.Static ? Resource.Yes : Resource.No; + debugLabel.Text = player.HasDebugInformation ? Resource.Yes : Resource.No; + klassennameTextBox.Text = player.ClassName; + + dateinameTextBox.Text = player.File; + try { + FileInfo info = new FileInfo(player.File); + dateigrößeLabel.Text = info.Length + " Byte"; + datumLabel.Text = info.CreationTime.ToLongDateString() + " " + info.CreationTime.ToShortTimeString(); + } + catch { + dateigrößeLabel.Text = Resource.SimulatorPluginAntPropertiesUnknown; + datumLabel.Text = Resource.SimulatorPluginAntPropertiesUnknown; + } + + // Ameisenkasten einfügen + castesListView.Items.Clear(); + foreach (CasteInfo info in player.Castes) { + ListViewItem item = castesListView.Items.Add(info.Name, "ant"); + item.Tag = info; + } + select_caste(null, null); + + // Sicherheitsliste + int count = 0; + if (player.RequestFileAccess) { + rechteListView.Items.Add(Resource.SimulatorPluginAntPropertiesIoAccess, "security_closed"); + count++; + } + if (player.RequestDatabaseAccess) { + rechteListView.Items.Add(Resource.SimulatorPluginAntPropertiesDbAccess, "security_closed"); + count++; + } + if (player.RequestReferences) { + rechteListView.Items.Add(Resource.SimulatorPluginAntPropertiesRefAccess, "security_closed"); + count++; + } + if (player.RequestUserInterfaceAccess) { + rechteListView.Items.Add(Resource.SimulatorPluginAntPropertiesUiAccess, "security_closed"); + count++; + } + if (player.RequestNetworkAccess) { + rechteListView.Items.Add(Resource.SimulatorPluginAntPropertiesNetAccess, "security_closed"); + count++; + } + if (count==0) { + rechteListView.Items.Add(Resource.SimulatorPluginAntPropertiesNoAccess, "security_closed"); + } + zusatzinfosTextBox.Text = player.RequestInformation == string.Empty + ? Resource.SimulatorPluginAntPropertiesNoAdditionalInfos + : player.RequestInformation; + + } + + private void select_caste(object sender, System.EventArgs e) + { + // TODO: Resultierende Werte aus den Settings hinzu schreiben + if (castesListView.SelectedItems.Count > 0) { + casteGroupBox.Enabled = true; + CasteInfo info = (CasteInfo) castesListView.SelectedItems[0].Tag; + casteNameLabel.Text = info.Name; + attackLabel.Text = info.Attack.ToString(); + energyLabel.Text = info.Energy.ToString(); + loadLabel.Text = info.Load.ToString(); + speedLabel.Text = info.Speed.ToString(); + rotationSpeedLabel.Text = info.RotationSpeed.ToString(); + rangeLabel.Text = info.Range.ToString(); + viewRangelabel.Text = info.ViewRange.ToString(); + + } + else { + casteGroupBox.Enabled = false; + casteNameLabel.Text = string.Empty; + attackLabel.Text = string.Empty; + energyLabel.Text = string.Empty; + loadLabel.Text = string.Empty; + speedLabel.Text = string.Empty; + rotationSpeedLabel.Text = string.Empty; + rangeLabel.Text = string.Empty; + viewRangelabel.Text = string.Empty; + } + } + } +} \ No newline at end of file diff --git a/SimulationPlugin/AntProperties.de.resx b/SimulationPlugin/AntProperties.de.resx new file mode 100644 index 0000000..d493da7 --- /dev/null +++ b/SimulationPlugin/AntProperties.de.resx @@ -0,0 +1,259 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Allgemein + + + + 73, 13 + + + Klassenname: + + + 95, 13 + + + Statische Variable: + + + 106, 13 + + + Debug-Nachrichten: + + + 90, 13 + + + Erstellungsdatum: + + + 62, 13 + + + Dateigröße: + + + 50, 13 + + + Sprache: + + + 35, 13 + + + Datei: + + + 35, 13 + + + Autor: + + + 31, 13 + + + Volk: + + + Kasten + + + 31, 13 + + + Volk: + + + 59, 13 + + + Sichtweite: + + + 88, 13 + + + Geschwindigkeit: + + + 30, 13 + + + Last: + + + 63, 13 + + + Reichweite: + + + 46, 13 + + + Energie: + + + 109, 13 + + + Drehgeschwindigkeit: + + + 40, 13 + + + Angriff: + + + Kaste: + + + 43, 13 + + + Kasten: + + + Sicherheit + + + 31, 13 + + + Volk: + + + 131, 13 + + + Zusätzliche Informationen: + + + 93, 13 + + + Benötigte Rechte: + + \ No newline at end of file diff --git a/SimulationPlugin/AntProperties.resx b/SimulationPlugin/AntProperties.resx new file mode 100644 index 0000000..5d30d53 --- /dev/null +++ b/SimulationPlugin/AntProperties.resx @@ -0,0 +1,1667 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + Bottom, Right + + + + 307, 438 + + + 75, 23 + + + + 1 + + + OK + + + okButton + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 1 + + + Top, Bottom, Left, Right + + + 15, 15 + + + 32, 32 + + + 20 + + + pictureBox1 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 0 + + + Top, Left, Right + + + 118, 267 + + + 231, 20 + + + 19 + + + klassennameTextBox + + + System.Windows.Forms.TextBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 1 + + + True + + + 15, 270 + + + 64, 13 + + + 18 + + + Class name: + + + label28 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 2 + + + Top, Left, Right + + + 118, 166 + + + 231, 20 + + + 11 + + + dateinameTextBox + + + System.Windows.Forms.TextBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 3 + + + True + + + 115, 130 + + + 38, 13 + + + 9 + + + [static] + + + statischLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 4 + + + True + + + 15, 130 + + + 82, 13 + + + 8 + + + Static variables: + + + label30 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 5 + + + True + + + 115, 250 + + + 43, 13 + + + 17 + + + [debug] + + + debugLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 6 + + + True + + + 15, 250 + + + 92, 13 + + + 16 + + + Debug messages: + + + label4 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 7 + + + True + + + 115, 209 + + + 34, 13 + + + 15 + + + [date] + + + datumLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 8 + + + True + + + 115, 189 + + + 31, 13 + + + 13 + + + [size] + + + dateigrößeLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 9 + + + True + + + 115, 110 + + + 57, 13 + + + 7 + + + [language] + + + spracheLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 10 + + + True + + + 115, 90 + + + 47, 13 + + + 5 + + + [version] + + + versionLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 11 + + + True + + + 115, 70 + + + 43, 13 + + + 3 + + + [author] + + + autorLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 12 + + + True + + + 15, 209 + + + 47, 13 + + + 14 + + + Created: + + + label27 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 13 + + + True + + + 15, 189 + + + 30, 13 + + + 12 + + + Size: + + + label26 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 14 + + + True + + + 15, 110 + + + 58, 13 + + + 6 + + + Language: + + + label25 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 15 + + + True + + + 15, 90 + + + 45, 13 + + + 4 + + + Version: + + + label24 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 16 + + + True + + + 15, 169 + + + 26, 13 + + + 10 + + + File: + + + label23 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 17 + + + True + + + 15, 70 + + + 41, 13 + + + 2 + + + Author: + + + label22 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 18 + + + True + + + Microsoft Sans Serif, 9.75pt, style=Bold + + + 53, 28 + + + 102, 16 + + + 1 + + + [colonyname] + + + kiNameLabel1 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 19 + + + True + + + 53, 15 + + + 42, 13 + + + 0 + + + Colony: + + + label3 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + common + + + 20 + + + 4, 22 + + + 3, 3, 3, 3 + + + 369, 400 + + + 0 + + + Common + + + common + + + System.Windows.Forms.TabPage, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + tabControl + + + 0 + + + NoControl + + + 15, 15 + + + 32, 32 + + + 21 + + + pictureBox2 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + castes + + + 0 + + + True + + + Microsoft Sans Serif, 9.75pt, style=Bold + + + 53, 28 + + + 102, 16 + + + 1 + + + [colonyname] + + + kiNameLabel2 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + castes + + + 1 + + + True + + + 53, 15 + + + 42, 13 + + + 0 + + + Colony: + + + label29 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + castes + + + 2 + + + Bottom, Left, Right + + + True + + + 130, 120 + + + 33, 13 + + + 7 + + + [mod] + + + rangeLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 0 + + + True + + + 130, 140 + + + 33, 13 + + + 9 + + + [mod] + + + viewRangelabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 1 + + + True + + + 15, 140 + + + 63, 13 + + + 8 + + + View range: + + + label10 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 2 + + + True + + + 268, 80 + + + 33, 13 + + + 11 + + + [mod] + + + energyLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 3 + + + True + + + 268, 120 + + + 33, 13 + + + 15 + + + [mod] + + + loadLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 4 + + + True + + + 130, 100 + + + 33, 13 + + + 5 + + + [mod] + + + speedLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 5 + + + True + + + 268, 100 + + + 33, 13 + + + 13 + + + [mod] + + + attackLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 6 + + + True + + + 130, 80 + + + 33, 13 + + + 3 + + + [mod] + + + rotationSpeedLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 7 + + + True + + + Microsoft Sans Serif, 8.25pt, style=Bold + + + 15, 38 + + + 79, 13 + + + 1 + + + [CasteName] + + + casteNameLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 8 + + + True + + + 15, 100 + + + 41, 13 + + + 4 + + + Speed: + + + label13 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 9 + + + True + + + 200, 120 + + + 34, 13 + + + 14 + + + Load: + + + label12 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 10 + + + True + + + 15, 120 + + + 42, 13 + + + 6 + + + Range: + + + label11 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 11 + + + True + + + 200, 80 + + + 43, 13 + + + 10 + + + Energy: + + + label9 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 12 + + + True + + + 15, 80 + + + 82, 13 + + + 2 + + + Rotation speed: + + + label8 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 13 + + + True + + + 200, 100 + + + 41, 13 + + + 12 + + + Attack: + + + label7 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 14 + + + True + + + 15, 25 + + + 37, 13 + + + 0 + + + Caste: + + + label6 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + casteGroupBox + + + 15 + + + 15, 202 + + + 338, 186 + + + 4 + + + Details: + + + casteGroupBox + + + System.Windows.Forms.GroupBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + castes + + + 3 + + + True + + + 15, 70 + + + 42, 13 + + + 2 + + + Castes: + + + label5 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + castes + + + 4 + + + Top, Bottom, Left, Right + + + 15, 86 + + + 338, 104 + + + 17, 17 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAACg + CAAAAk1TRnQBSQFMAgEBAgEAAQQBAAEEAQABEAEAARABAAT/AQkBAAj/AUIBTQE2AQQGAAE2AQQCAAEo + AwABQAMAARADAAEBAQABCAYAAQQYAAGAAgABgAMAAoABAAGAAwABgAEAAYABAAKAAgADwAEAAcAB3AHA + AQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEAAykBAANVAQADTQEAA0IBAAM5 + AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8BAAHWAucBAAGQAakBrQIAAf8BMwMA + AWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHMAgABMwH/AgABZgMAAWYBMwIAAmYCAAFm + AZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgACmQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHM + AWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZAgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEA + ATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8BMwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEz + AWYCAAEzAWYBMwEAATMCZgEAATMBZgGZAQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZ + AWYBAAEzApkBAAEzAZkBzAEAATMBmQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLM + AQABMwHMAf8BAAEzAf8BMwEAATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEA + AWYBAAFmAQABZgEAAZkBAAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEA + AWYBMwHMAQABZgEzAf8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZ + AWYBAAFmApkBAAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/ + AQABZgH/AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEA + AZkBAAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm + ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwBAAKZ + Af8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIAAZkB/wEz + AQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYBAAHMAQABmQEA + AcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEzAf8BAAHMAWYCAAHM + AWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwBmQEzAQABzAGZAWYBAAHM + ApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEAA8wBAALMAf8BAAHMAf8CAAHM + Af8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwBAAEzAQAB/wEAAWYBAAH/AQABmQEA + AcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEAAf8BMwH/AQAB/wFmAgAB/wFmATMBAAHM + AmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkCAAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZ + AcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHMAWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEz + AQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8BAAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFm + AQABIQEAAaUBAANfAQADdwEAA4YBAAOWAQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHw + AfsB/wEAAaQCoAEAA4ADAAH/AgAB/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD/wEAAv8BGgF6CiwJ/wEH + CP8gAAL/AVMKLAFTCf8BkwH0B/8gABf/AQcBkwH/AZMF/yAAAv8BegpTAXoF/wEaAUYBbwL/AW8B/wFv + Bf8gAAL/ARoBegosBf8BRgIfAW8B/wFvAQcBkwX/IAAC/wFTCiwBUwX/AW8DHwGTAW8B8wFvBf8gABD/ + AfMD/wFvAekBHwFGAZMB/wFvARoE/yAAAv8BegpTAXoC/wGTAW8BkwL/ARoBbwLpAZMCbwT/IAAC/wEa + AXoKLAT/AZMDbwGTAUYBHwHpAW8B8wT/IAAC/wFTCiwBUwT/AvQBGgH0Af8BkwHpAR8B6QGTAW8DkyAA + A/8B8QFtAfIE/wHyAW0BvAX/Bm8BkwPpAZMBGgL/IAAD/wHxAW0B8QT/AfEBbQEHCf8BGgFvARoBkwHp + AR8B6QGTARoB/yAAA/8B8QFtAbwE/wG8AW0B8Qz/AW8BkwHpAZMB/wGTAf8gAAT/AesB7AHzAv8B8wHs + AesM/wH0AZMBGgGTBP8gAAT/AfEBbQHsApIB6wFtAfAM/wEaAQcB9AKTA/8gAAX/AfIB7wJtAe0B8g3/ + ARoB8wL/ARoD/yAAAUIBTQE+BwABPgMAASgDAAFAAwABEAMAAQEBAAEBBQABgBcAA/+BAAs= + + + + 3 + + + castesListView + + + System.Windows.Forms.ListView, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + castes + + + 5 + + + 4, 22 + + + 3, 3, 3, 3 + + + 369, 400 + + + 1 + + + Castes + + + castes + + + System.Windows.Forms.TabPage, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + tabControl + + + 1 + + + NoControl + + + 15, 15 + + + 32, 32 + + + 22 + + + pictureBox3 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + security + + + 0 + + + Top, Bottom, Left, Right + + + 15, 250 + + + True + + + Vertical + + + 338, 136 + + + 5 + + + zusatzinfosTextBox + + + System.Windows.Forms.TextBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + security + + + 1 + + + True + + + Microsoft Sans Serif, 9.75pt, style=Bold + + + 53, 28 + + + 102, 16 + + + 1 + + + [colonyname] + + + kiNameLabel3 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + security + + + 2 + + + True + + + 53, 15 + + + 42, 13 + + + 0 + + + Colony: + + + label31 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + security + + + 3 + + + True + + + 15, 234 + + + 110, 13 + + + 4 + + + Additional information: + + + label2 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + security + + + 4 + + + True + + + 15, 70 + + + 110, 13 + + + 2 + + + Required permissions: + + + label1 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + security + + + 5 + + + Top, Left, Right + + + 15, 86 + + + 338, 142 + + + 3 + + + rechteListView + + + System.Windows.Forms.ListView, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + security + + + 6 + + + 4, 22 + + + 369, 400 + + + 2 + + + Security + + + security + + + System.Windows.Forms.TabPage, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + tabControl + + + 2 + + + 5, 6 + + + 377, 426 + + + 0 + + + tabControl + + + System.Windows.Forms.TabControl, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 0 + + + True + + + 6, 13 + + + 387, 466 + + + CenterParent + + + [properties] + + + imageList + + + System.Windows.Forms.ImageList, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + AntProperties + + + System.Windows.Forms.Form, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/SimulationPlugin/CreateForm.Designer.cs b/SimulationPlugin/CreateForm.Designer.cs new file mode 100644 index 0000000..765ef0e --- /dev/null +++ b/SimulationPlugin/CreateForm.Designer.cs @@ -0,0 +1,187 @@ +namespace AntMe.Plugin.Simulation +{ + partial class CreateForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(CreateForm)); + this.cancelButton = new System.Windows.Forms.Button(); + this.okButton = new System.Windows.Forms.Button(); + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.label4 = new System.Windows.Forms.Label(); + this.codeComboBox = new System.Windows.Forms.ComboBox(); + this.languageComboBox = new System.Windows.Forms.ComboBox(); + this.browseButton = new System.Windows.Forms.Button(); + this.label3 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.label1 = new System.Windows.Forms.Label(); + this.folderTextBox = new System.Windows.Forms.TextBox(); + this.nameTextBox = new System.Windows.Forms.TextBox(); + this.folderBrowserDialog = new System.Windows.Forms.FolderBrowserDialog(); + this.label5 = new System.Windows.Forms.Label(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.groupBox1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.SuspendLayout(); + // + // cancelButton + // + resources.ApplyResources(this.cancelButton, "cancelButton"); + this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.cancelButton.Name = "cancelButton"; + this.cancelButton.UseVisualStyleBackColor = true; + // + // okButton + // + resources.ApplyResources(this.okButton, "okButton"); + this.okButton.DialogResult = System.Windows.Forms.DialogResult.OK; + this.okButton.Name = "okButton"; + this.okButton.UseVisualStyleBackColor = true; + // + // groupBox1 + // + this.groupBox1.Controls.Add(this.label4); + this.groupBox1.Controls.Add(this.codeComboBox); + this.groupBox1.Controls.Add(this.languageComboBox); + this.groupBox1.Controls.Add(this.browseButton); + this.groupBox1.Controls.Add(this.label3); + this.groupBox1.Controls.Add(this.label2); + this.groupBox1.Controls.Add(this.label1); + this.groupBox1.Controls.Add(this.folderTextBox); + this.groupBox1.Controls.Add(this.nameTextBox); + resources.ApplyResources(this.groupBox1, "groupBox1"); + this.groupBox1.Name = "groupBox1"; + this.groupBox1.TabStop = false; + // + // label4 + // + resources.ApplyResources(this.label4, "label4"); + this.label4.Name = "label4"; + // + // codeComboBox + // + this.codeComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.codeComboBox.FormattingEnabled = true; + resources.ApplyResources(this.codeComboBox, "codeComboBox"); + this.codeComboBox.Name = "codeComboBox"; + // + // languageComboBox + // + this.languageComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.languageComboBox.FormattingEnabled = true; + resources.ApplyResources(this.languageComboBox, "languageComboBox"); + this.languageComboBox.Name = "languageComboBox"; + // + // browseButton + // + resources.ApplyResources(this.browseButton, "browseButton"); + this.browseButton.Name = "browseButton"; + this.browseButton.UseVisualStyleBackColor = true; + this.browseButton.Click += new System.EventHandler(this.browseButton_Click); + // + // label3 + // + resources.ApplyResources(this.label3, "label3"); + this.label3.Name = "label3"; + // + // label2 + // + resources.ApplyResources(this.label2, "label2"); + this.label2.Name = "label2"; + // + // label1 + // + resources.ApplyResources(this.label1, "label1"); + this.label1.Name = "label1"; + // + // folderTextBox + // + resources.ApplyResources(this.folderTextBox, "folderTextBox"); + this.folderTextBox.Name = "folderTextBox"; + this.folderTextBox.ReadOnly = true; + // + // nameTextBox + // + resources.ApplyResources(this.nameTextBox, "nameTextBox"); + this.nameTextBox.Name = "nameTextBox"; + // + // label5 + // + resources.ApplyResources(this.label5, "label5"); + this.label5.Name = "label5"; + // + // pictureBox1 + // + this.pictureBox1.Image = global::AntMe.Plugin.Simulation.Properties.Resources.toddler; + resources.ApplyResources(this.pictureBox1, "pictureBox1"); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.TabStop = false; + // + // CreateForm + // + this.AcceptButton = this.okButton; + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.cancelButton; + this.Controls.Add(this.pictureBox1); + this.Controls.Add(this.label5); + this.Controls.Add(this.groupBox1); + this.Controls.Add(this.okButton); + this.Controls.Add(this.cancelButton); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "CreateForm"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.CreateForm_FormClosing); + this.groupBox1.ResumeLayout(false); + this.groupBox1.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button cancelButton; + private System.Windows.Forms.Button okButton; + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.ComboBox codeComboBox; + private System.Windows.Forms.ComboBox languageComboBox; + private System.Windows.Forms.Button browseButton; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox folderTextBox; + private System.Windows.Forms.TextBox nameTextBox; + private System.Windows.Forms.FolderBrowserDialog folderBrowserDialog; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.PictureBox pictureBox1; + } +} \ No newline at end of file diff --git a/SimulationPlugin/CreateForm.cs b/SimulationPlugin/CreateForm.cs new file mode 100644 index 0000000..b113fbd --- /dev/null +++ b/SimulationPlugin/CreateForm.cs @@ -0,0 +1,100 @@ +using AntMe.Plugin.Simulation.Generators; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.IO; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +using System.Windows.Forms; + +namespace AntMe.Plugin.Simulation +{ + public partial class CreateForm : Form + { + private List generators; + + public string GeneratedSolutionFile { get; private set; } + + public CreateForm() + { + InitializeComponent(); + + generators = new List(); + generators.Add(new GermanCSharpGenerator()); + generators.Add(new EnglishCSharpGenerator()); + + foreach (var language in generators.Select(g => g.Language).Distinct()) + languageComboBox.Items.Add(language); + if (languageComboBox.Items.Count > 0) + languageComboBox.SelectedIndex = 0; + + // TODO: Später abhängig von der ausgewählten Sprache auflisten (vielleicht...) + foreach (var language in generators.Select(g => g.ProgrammingLanguage).Distinct()) + codeComboBox.Items.Add(language); + if (codeComboBox.Items.Count > 0) + codeComboBox.SelectedIndex = 0; + + // Identify Visual Studio Folder + DirectoryInfo root = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)); + DirectoryInfo hit = root.GetDirectories("Visual Studio *").OrderByDescending(d => d.Name).FirstOrDefault(); + if (hit != null) + folderTextBox.Text = hit.FullName + @"\Projects"; + } + + private void browseButton_Click(object sender, EventArgs e) + { + if (!string.IsNullOrEmpty(folderTextBox.Text)) + folderBrowserDialog.SelectedPath = folderTextBox.Text; + + if (folderBrowserDialog.ShowDialog(this) == System.Windows.Forms.DialogResult.OK) + folderTextBox.Text = folderBrowserDialog.SelectedPath; + } + + private void CreateForm_FormClosing(object sender, FormClosingEventArgs e) + { + if (DialogResult != System.Windows.Forms.DialogResult.OK) + return; + + // Check den Namen (muss den Namenskonventionen von Klassennamen entsprechen) + if (!Regex.IsMatch(nameTextBox.Text, @"^[a-zA-Z][a-zA-Z0-9]{1,19}$")) + { + MessageBox.Show("Der Name darf nur Buchstaben und Zahlen enthalten, nicht mit einer Zahl beginnen und zwischen 2 und 20 Zeichen lang sein."); + e.Cancel = true; + return; + } + + // Finde Generator + var generator = generators.Where(g => g.Language.Equals(languageComboBox.Text) && g.ProgrammingLanguage.Equals(codeComboBox.Text)).FirstOrDefault(); + if (generator == null) + { + MessageBox.Show("Falsche Einstellungen bei den Sprachen"); + e.Cancel = true; + return; + } + + // Prüfen, ob das Ausgabeverzeichnis existiert + DirectoryInfo root = new DirectoryInfo(folderTextBox.Text); + if (!root.Exists) + { + MessageBox.Show("Ausgabeverzeichnis existiert nicht"); + e.Cancel = true; + return; + } + + try + { + string solution = generator.Generate(nameTextBox.Text, folderTextBox.Text); + GeneratedSolutionFile = solution; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message); + e.Cancel = true; + return; + } + } + } +} diff --git a/SimulationPlugin/CreateForm.de.resx b/SimulationPlugin/CreateForm.de.resx new file mode 100644 index 0000000..e61118c --- /dev/null +++ b/SimulationPlugin/CreateForm.de.resx @@ -0,0 +1,167 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Abbrechen + + + Einstellungen + + + + 103, 13 + + + Programmiersprache + + + 153, 94 + + + 153, 67 + + + 397, 120 + + + 61, 13 + + + Verzeichnis + + + 47, 13 + + + Sprache + + + 153, 121 + + + 153, 41 + + + Erstelle hier eine neue Ameisenkolonie für AntMe! +An dieser Stelle kannst du eine ganze Menge Einstellungen treffen. Die vermutlich wichtigste: Die Programmiersprache, in der du deine Ameisen kommandieren willst. Außerdem kannst du hier aber auch die Sprache wählen, die deine Ameisen verstehen werden. + + + Ameisenkolonie erstellen + + \ No newline at end of file diff --git a/SimulationPlugin/CreateForm.resx b/SimulationPlugin/CreateForm.resx new file mode 100644 index 0000000..5e89a12 --- /dev/null +++ b/SimulationPlugin/CreateForm.resx @@ -0,0 +1,493 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + Bottom, Right + + + + 409, 343 + + + 75, 23 + + + + 0 + + + Cancel + + + cancelButton + + + System.Windows.Forms.Button, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 4 + + + Bottom, Right + + + 328, 343 + + + 75, 23 + + + 1 + + + OK + + + okButton + + + System.Windows.Forms.Button, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 3 + + + True + + + 40, 97 + + + 83, 13 + + + 8 + + + Code Language + + + label4 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox1 + + + 0 + + + 136, 94 + + + 110, 21 + + + 7 + + + codeComboBox + + + System.Windows.Forms.ComboBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox1 + + + 1 + + + 136, 67 + + + 110, 21 + + + 6 + + + languageComboBox + + + System.Windows.Forms.ComboBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox1 + + + 2 + + + 380, 120 + + + 37, 20 + + + 5 + + + ... + + + browseButton + + + System.Windows.Forms.Button, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox1 + + + 3 + + + True + + + 40, 124 + + + 71, 13 + + + 4 + + + Output Folder + + + label3 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox1 + + + 4 + + + True + + + 40, 70 + + + 55, 13 + + + 3 + + + Language + + + label2 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox1 + + + 5 + + + True + + + 40, 44 + + + 35, 13 + + + 2 + + + Name + + + label1 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox1 + + + 6 + + + 136, 121 + + + 238, 20 + + + 1 + + + folderTextBox + + + System.Windows.Forms.TextBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox1 + + + 7 + + + 136, 41 + + + 281, 20 + + + 0 + + + nameTextBox + + + System.Windows.Forms.TextBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox1 + + + 8 + + + 12, 150 + + + 472, 177 + + + 2 + + + Settings + + + groupBox1 + + + System.Windows.Forms.GroupBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 2 + + + 17, 17 + + + 12, 26 + + + 303, 96 + + + 3 + + + Create a totally new Ant Colony to play with in AntMe! +Here you can choose some very important things. First: The Language you want to code in. Most people take C#, but there are some more to try. You also can choose your mother language. This affects not only the comments, but also the language your ants will understand. + + + label5 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 1 + + + 321, 12 + + + 159, 120 + + + 4 + + + pictureBox1 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 0 + + + True + + + 6, 13 + + + 492, 373 + + + CenterParent + + + Create Colony + + + folderBrowserDialog + + + System.Windows.Forms.FolderBrowserDialog, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + CreateForm + + + System.Windows.Forms.Form, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/SimulationPlugin/Generators/EnglishCSharpGenerator.cs b/SimulationPlugin/Generators/EnglishCSharpGenerator.cs new file mode 100644 index 0000000..703fb4e --- /dev/null +++ b/SimulationPlugin/Generators/EnglishCSharpGenerator.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Plugin.Simulation.Generators +{ + internal sealed class EnglishCSharpGenerator : VsGenerator, IGenerator + { + public string Language + { + get { return "English"; } + } + + public string ProgrammingLanguage + { + get { return "C#"; } + } + + public string Generate(string name, string path) + { + return Generate(name, path, + GeneratorFiles.solution, + GeneratorFiles.project, + GeneratorFiles.user, + GeneratorFiles.class_en, + GeneratorFiles.properties); + } + } +} diff --git a/SimulationPlugin/Generators/GeneratorFiles.Designer.cs b/SimulationPlugin/Generators/GeneratorFiles.Designer.cs new file mode 100644 index 0000000..7af087b --- /dev/null +++ b/SimulationPlugin/Generators/GeneratorFiles.Designer.cs @@ -0,0 +1,191 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Plugin.Simulation.Generators { + 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 GeneratorFiles { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal GeneratorFiles() { + } + + /// + /// 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("AntMe.Plugin.Simulation.Generators.GeneratorFiles", typeof(GeneratorFiles).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; + } + } + + /// + /// Looks up a localized string similar to using AntMe.Deutsch; + ///using System; + ///using System.Collections.Generic; + ///using System.Linq; + ///using System.Text; + /// + ///namespace AntMe.Player + ///{ + /// [Spieler( + /// Volkname = "Template", + /// Vorname = "Tom", + /// Nachname = "Wendel" + /// )] + /// [Kaste( + /// Name = "Standard", + /// AngriffModifikator = 0, + /// DrehgeschwindigkeitModifikator = 0, + /// EnergieModifikator = 0, + /// GeschwindigkeitModifikator = 0, + /// LastModifikator = 0, + /// ReichweiteModifikator = 0, + /// [rest of string was truncated]";. + /// + internal static string class_de { + get { + return ResourceManager.GetString("class_de", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to using AntMe.English; + ///using System; + ///using System.Collections.Generic; + ///using System.Linq; + ///using System.Text; + /// + ///namespace AntMe.Player.Template + ///{ + /// [Player( + /// ColonyName = "English Ants", + /// FirstName = "Tom", + /// LastName = "Wendel" + /// )] + /// [Caste( + /// Name = "Default", + /// AttackModificator = 0, + /// EnergyModificator = 0, + /// LoadModificator = 0, + /// RangeModificator = 0, + /// RotationSpeedModificator = 0, + /// SpeedModificator = 0, + /// Vi [rest of string was truncated]";. + /// + internal static string class_en { + get { + return ResourceManager.GetString("class_en", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to <?xml version="1.0" encoding="utf-8"?> + ///<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + /// <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> + /// <PropertyGroup> + /// <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + /// <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + /// [rest of string was truncated]";. + /// + internal static string project { + get { + return ResourceManager.GetString("project", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to <?xml version="1.0" encoding="utf-8"?> + ///<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + /// <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + /// <StartAction>Program</StartAction> + /// <StartProgram>C:\Program Files %28x86%29\AntMe 1.7\AntMe.exe</StartProgram> + /// <StartArguments>/file="C:\Users\Tom\Documents\Visual Studio 2013\Projects\AntMe! 1.7 Template\bin\Debug\AntMe.Player.Template.dll"</StartArguments> + /// </PropertyGroup> + ///</Proje [rest of string was truncated]";. + /// + internal static string properties { + get { + return ResourceManager.GetString("properties", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to + ///Microsoft Visual Studio Solution File, Format Version 12.00 + ///# Visual Studio 2013 + ///VisualStudioVersion = 12.0.31101.0 + ///MinimumVisualStudioVersion = 10.0.40219.1 + ///Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AntMe! 1.7 Template", "AntMe! 1.7 Template.csproj", "{CF0D4569-6684-4406-8E9D-D18C24106DDF}" + ///EndProject + ///Global + /// GlobalSection(SolutionConfigurationPlatforms) = preSolution + /// Debug|Any CPU = Debug|Any CPU + /// Release|Any CPU = Release|Any CPU + /// EndGlobalSection + /// GlobalSection(ProjectConfigur [rest of string was truncated]";. + /// + internal static string solution { + get { + return ResourceManager.GetString("solution", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to <?xml version="1.0" encoding="utf-8"?> + ///<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + /// <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + /// <StartAction>Program</StartAction> + /// <StartProgram>C:\Program Files %28x86%29\AntMe 1.7\AntMe.exe</StartProgram> + /// <StartArguments>/file="C:\Users\Tom\Documents\Visual Studio 2013\Projects\AntMe! 1.7 Template\bin\Debug\AntMe.Player.Template.dll"</StartArguments> + /// </PropertyGroup> + ///</Proje [rest of string was truncated]";. + /// + internal static string user { + get { + return ResourceManager.GetString("user", resourceCulture); + } + } + } +} diff --git a/SimulationPlugin/Generators/GeneratorFiles.resx b/SimulationPlugin/Generators/GeneratorFiles.resx new file mode 100644 index 0000000..471420b --- /dev/null +++ b/SimulationPlugin/Generators/GeneratorFiles.resx @@ -0,0 +1,139 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\Resources\class_de.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\class_en.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\project.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\properties.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\solution.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\user.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + \ No newline at end of file diff --git a/SimulationPlugin/Generators/GermanCSharpGenerator.cs b/SimulationPlugin/Generators/GermanCSharpGenerator.cs new file mode 100644 index 0000000..d9da83f --- /dev/null +++ b/SimulationPlugin/Generators/GermanCSharpGenerator.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Plugin.Simulation.Generators +{ + internal sealed class GermanCSharpGenerator : VsGenerator, IGenerator + { + public string Language + { + get { return "Deutsch"; } + } + + public string ProgrammingLanguage + { + get { return "C#"; } + } + + public string Generate(string name, string path) + { + return Generate(name, path, + GeneratorFiles.solution, + GeneratorFiles.project, + GeneratorFiles.user, + GeneratorFiles.class_de, + GeneratorFiles.properties); + } + } +} diff --git a/SimulationPlugin/Generators/IGenerator.cs b/SimulationPlugin/Generators/IGenerator.cs new file mode 100644 index 0000000..0f35e8d --- /dev/null +++ b/SimulationPlugin/Generators/IGenerator.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Plugin.Simulation.Generators +{ + internal interface IGenerator + { + string Language { get; } + + string ProgrammingLanguage { get; } + + string Generate(string name, string path); + } +} diff --git a/SimulationPlugin/Generators/VsGenerator.cs b/SimulationPlugin/Generators/VsGenerator.cs new file mode 100644 index 0000000..943c074 --- /dev/null +++ b/SimulationPlugin/Generators/VsGenerator.cs @@ -0,0 +1,89 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Text.RegularExpressions; + +namespace AntMe.Plugin.Simulation.Generators +{ + internal abstract class VsGenerator + { + private DirectoryInfo _outputPath; + private string _classname; + private string _solutionname; + private string _projectname; + private Guid _solutionguid; + private Guid _projectguid; + private string _playername; + private string _antmeroot; + + /// + /// Generates the project files + /// {0}: Name der Ameisenklasse + /// {1}: Solution Name + /// {2}: Projekt Name + /// {3}: Solution Guid + /// {4}: Projekt Guid + /// {5}: Player Display Name + /// {6}: AntMe Install Path + /// {7}: Project Root + /// + /// + /// + /// + /// + /// + /// + /// + /// Path to Solution File + protected string Generate(string name, string path, string solutionFile, string projectFile, string projectUserFile, string classFile, string propertiesFile) + { + // Check KI Name + if (!Regex.IsMatch(name, @"^[a-zA-Z][a-zA-Z0-9]{1,19}$")) + throw new ArgumentException("Der Name darf nur Buchstaben und Zahlen enthalten, nicht mit einer Zahl beginnen und zwischen 2 und 20 Zeichen lang sein."); + + // Prüfen, ob das Ausgabeverzeichnis existiert + DirectoryInfo root = new DirectoryInfo(path); + if (!root.Exists) + throw new ArgumentException("Ausgabeverzeichnis existiert nicht"); + + // Verzeichnis erzeugen + _outputPath = root.CreateSubdirectory(name); + _outputPath.CreateSubdirectory("Properties"); + + // Identify AntMe! Root + _antmeroot = new FileInfo(Assembly.GetEntryAssembly().Location).DirectoryName; + + _classname = name + "Class"; + _solutionname = name; + _projectname = name; + _solutionguid = Guid.NewGuid(); + _projectguid = Guid.NewGuid(); + _playername = name; + + GenerateFile(_outputPath.FullName + "\\" + _solutionname + ".sln", solutionFile); + GenerateFile(_outputPath.FullName + "\\" + _projectname + ".csproj", projectFile); + GenerateFile(_outputPath.FullName + "\\" + _projectname + ".csproj.user", projectUserFile); + GenerateFile(_outputPath.FullName + "\\" + _classname + ".cs", classFile); + GenerateFile(_outputPath.FullName + "\\Properties\\AssemblyInfo.cs", propertiesFile); + + return _outputPath.FullName + "\\" + _solutionname + ".sln"; + } + + private void GenerateFile(string filename, string content) + { + content = content.Replace("{0}", _classname); + content = content.Replace("{1}", _solutionname); + content = content.Replace("{2}", _projectname); + content = content.Replace("{3}", _solutionguid.ToString()); + content = content.Replace("{4}", _projectguid.ToString()); + content = content.Replace("{5}", _playername); + content = content.Replace("{6}", _antmeroot); + content = content.Replace("{7}", _outputPath.FullName); + + File.WriteAllText(filename, content); + } + } +} diff --git a/SimulationPlugin/PlayerItem.cs b/SimulationPlugin/PlayerItem.cs new file mode 100644 index 0000000..98bf323 --- /dev/null +++ b/SimulationPlugin/PlayerItem.cs @@ -0,0 +1,74 @@ +using System; +using AntMe.Simulation; + +namespace AntMe.Plugin.Simulation { + /// + /// Represents an instance of a player in a team. + /// + [Serializable] + public sealed class PlayerItem : ICloneable { + + /// + /// Creates an empty PlayerItem. + /// + public PlayerItem() { + } + + /// + /// Creates a new instance of PlayerItem. + /// + /// base + public PlayerItem(PlayerInfoFilename info) { + PlayerInfo = info; + ColonyName = info.ColonyName; + FileName = info.File; + ClassName = info.ClassName; + AuthorName = string.Format(Resource.SimulatorPluginAntPropertiesAuthorFormat, info.FirstName, info.LastName); + } + + /// + /// Unique ID of this + /// + public Guid Guid = System.Guid.NewGuid(); + + /// + /// Represents the Playerinfo + /// + public PlayerInfoFilename PlayerInfo; + + /// + /// Name of the colony. + /// + public string ColonyName; + + /// + /// Name of the file. + /// + public string FileName; + + /// + /// Name of the class. + /// + public string ClassName; + + /// + /// Name of Colony-Author. + /// + public string AuthorName; + + #region ICloneable Member + + /// + /// Clones the current . + /// + /// copy of item + public object Clone() + { + PlayerItem item = (PlayerItem) MemberwiseClone(); + item.Guid = Guid.NewGuid(); + return item; + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationPlugin/Presets.Designer.cs b/SimulationPlugin/Presets.Designer.cs new file mode 100644 index 0000000..1d5ce01 --- /dev/null +++ b/SimulationPlugin/Presets.Designer.cs @@ -0,0 +1,113 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Plugin.Simulation { + 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 Presets { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Presets() { + } + + /// + /// 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("AntMe.Plugin.Simulation.Presets", typeof(Presets).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; + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] CaptureTheApple { + get { + object obj = ResourceManager.GetObject("CaptureTheApple", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] Debugging { + get { + object obj = ResourceManager.GetObject("Debugging", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] Heros { + get { + object obj = ResourceManager.GetObject("Heros", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] SugarRun { + get { + object obj = ResourceManager.GetObject("SugarRun", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] SurvivalOfTheFittest { + get { + object obj = ResourceManager.GetObject("SurvivalOfTheFittest", resourceCulture); + return ((byte[])(obj)); + } + } + } +} diff --git a/SimulationPlugin/Presets.resx b/SimulationPlugin/Presets.resx new file mode 100644 index 0000000..cb50a52 --- /dev/null +++ b/SimulationPlugin/Presets.resx @@ -0,0 +1,136 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + Resources\captureTheApple.ant.config;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Resources\debugging.ant.config;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Resources\heros.ant.config;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Resources\sugarRun.ant.config;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Resources\SurvivalOfTheFittest.ant.config;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/SimulationPlugin/Properties/AssemblyInfo.cs b/SimulationPlugin/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..0dae271 --- /dev/null +++ b/SimulationPlugin/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// Allgemeine Informationen über eine Assembly werden über die folgenden +// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern, +// die mit einer Assembly verknüpft sind. +[assembly: AssemblyTitle("AntMe! Simulation Plugin")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("AntMe! GmbH")] +[assembly: AssemblyProduct("AntMe!")] +[assembly: AssemblyCopyright("Copyright © 2014 AntMe! GmbH")] +[assembly: AssemblyTrademark("AntMe!")] +[assembly: AssemblyCulture("")] + +// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar +// für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von +// COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest. +[assembly: ComVisible(false)] + +// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird +[assembly: Guid("695fa268-62fa-473d-865f-10c278053bd9")] + +// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +// +// Hauptversion +// Nebenversion +// Buildnummer +// Revision +// +// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern +// übernehmen, indem Sie "*" eingeben: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.7.1.207")] +[assembly: AssemblyFileVersion("1.7.1.207")] diff --git a/SimulationPlugin/Properties/Resources.Designer.cs b/SimulationPlugin/Properties/Resources.Designer.cs new file mode 100644 index 0000000..5457f19 --- /dev/null +++ b/SimulationPlugin/Properties/Resources.Designer.cs @@ -0,0 +1,232 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Plugin.Simulation.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("AntMe.Plugin.Simulation.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; + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap add { + get { + object obj = ResourceManager.GetObject("add", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap colony_nonstatic_32x32 { + get { + object obj = ResourceManager.GetObject("colony_nonstatic_32x32", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap debug_messages_32x32 { + get { + object obj = ResourceManager.GetObject("debug_messages_32x32", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap delete_16x16 { + get { + object obj = ResourceManager.GetObject("delete_16x16", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap duration_32x32 { + get { + object obj = ResourceManager.GetObject("duration_32x32", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap load_16x16 { + get { + object obj = ResourceManager.GetObject("load_16x16", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap map_generation_32x32 { + get { + object obj = ResourceManager.GetObject("map_generation_32x32", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap properties_16x16 { + get { + object obj = ResourceManager.GetObject("properties_16x16", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap resetteams { + get { + object obj = ResourceManager.GetObject("resetteams", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap save_16x16 { + get { + object obj = ResourceManager.GetObject("save_16x16", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap security_32x32 { + get { + object obj = ResourceManager.GetObject("security_32x32", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap settings_16x16 { + get { + object obj = ResourceManager.GetObject("settings_16x16", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap settings_32x32 { + get { + object obj = ResourceManager.GetObject("settings_32x32", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap settings_new { + get { + object obj = ResourceManager.GetObject("settings_new", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized string similar to *.dll. + /// + internal static string SimulatorPluginFolkFileFilter { + get { + return ResourceManager.GetString("SimulatorPluginFolkFileFilter", resourceCulture); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap timeout_32x32 { + get { + object obj = ResourceManager.GetObject("timeout_32x32", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap toddler { + get { + object obj = ResourceManager.GetObject("toddler", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/SimulationPlugin/Properties/Resources.resx b/SimulationPlugin/Properties/Resources.resx new file mode 100644 index 0000000..93ebae5 --- /dev/null +++ b/SimulationPlugin/Properties/Resources.resx @@ -0,0 +1,173 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\Resources\save_16x16.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\settings_new.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\properties_16x16.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\resetteams.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\colony_nonstatic_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + *.dll + The filter to find folks (TeamSetup.cs) + + + ..\Resources\delete_16x16.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\security_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\load_16x16.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\add.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\debug_messages_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\timeout_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\duration_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\settings_16x16.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\map_generation_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\settings_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\toddler.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/SimulationPlugin/Resource.Designer.cs b/SimulationPlugin/Resource.Designer.cs new file mode 100644 index 0000000..b447812 --- /dev/null +++ b/SimulationPlugin/Resource.Designer.cs @@ -0,0 +1,297 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Plugin.Simulation { + 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 Resource { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resource() { + } + + /// + /// 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("AntMe.Plugin.Simulation.Resource", typeof(Resource).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; + } + } + + /// + /// Looks up a localized string similar to no. + /// + internal static string No { + get { + return ResourceManager.GetString("No", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to There was a problem during runtime: {0}. + /// + internal static string SimulationPluginExcetionIntro { + get { + return ResourceManager.GetString("SimulationPluginExcetionIntro", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to {0} from {3}. + /// + internal static string SimulationPluginKicklistEntry { + get { + return ResourceManager.GetString("SimulationPluginKicklistEntry", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The following colonies are not valid anymore: . + /// + internal static string SimulationPluginKicklistHead { + get { + return ResourceManager.GetString("SimulationPluginKicklistHead", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to AntMe! - Simulation. + /// + internal static string SimulationPluginMessageBoxTitle { + get { + return ResourceManager.GetString("SimulationPluginMessageBoxTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Following rights are not granted in the settings:. + /// + internal static string SimulationPluginRightsLocked { + get { + return ResourceManager.GetString("SimulationPluginRightsLocked", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to This colony creates a ruleViolation with current settings: {0}. + /// + internal static string SimulationPluginRuleViolation { + get { + return ResourceManager.GetString("SimulationPluginRuleViolation", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to {0} {1}. + /// + internal static string SimulatorPluginAntPropertiesAuthorFormat { + get { + return ResourceManager.GetString("SimulatorPluginAntPropertiesAuthorFormat", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Access to a database. + /// + internal static string SimulatorPluginAntPropertiesDbAccess { + get { + return ResourceManager.GetString("SimulatorPluginAntPropertiesDbAccess", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Access to the file system. + /// + internal static string SimulatorPluginAntPropertiesIoAccess { + get { + return ResourceManager.GetString("SimulatorPluginAntPropertiesIoAccess", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Access to the network. + /// + internal static string SimulatorPluginAntPropertiesNetAccess { + get { + return ResourceManager.GetString("SimulatorPluginAntPropertiesNetAccess", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Full access limitation. + /// + internal static string SimulatorPluginAntPropertiesNoAccess { + get { + return ResourceManager.GetString("SimulatorPluginAntPropertiesNoAccess", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to No further information available.. + /// + internal static string SimulatorPluginAntPropertiesNoAdditionalInfos { + get { + return ResourceManager.GetString("SimulatorPluginAntPropertiesNoAdditionalInfos", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Ant references external assembly or assemblies.. + /// + internal static string SimulatorPluginAntPropertiesRefAccess { + get { + return ResourceManager.GetString("SimulatorPluginAntPropertiesRefAccess", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Properties of {0}. + /// + internal static string SimulatorPluginAntPropertiesTitle { + get { + return ResourceManager.GetString("SimulatorPluginAntPropertiesTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Access to the user interface. + /// + internal static string SimulatorPluginAntPropertiesUiAccess { + get { + return ResourceManager.GetString("SimulatorPluginAntPropertiesUiAccess", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Unknown. + /// + internal static string SimulatorPluginAntPropertiesUnknown { + get { + return ResourceManager.GetString("SimulatorPluginAntPropertiesUnknown", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Ant simulation. + /// + internal static string SimulatorPluginDescription { + get { + return ResourceManager.GetString("SimulatorPluginDescription", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Simulation. + /// + internal static string SimulatorPluginName { + get { + return ResourceManager.GetString("SimulatorPluginName", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Simulation has not been started.. + /// + internal static string SimulatorPluginNotStarted { + get { + return ResourceManager.GetString("SimulatorPluginNotStarted", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The file {0} coun't be loaded. The detailed errormessage is '{1}'. + /// + internal static string SimulatorPluginTeamSetupFileloadException { + get { + return ResourceManager.GetString("SimulatorPluginTeamSetupFileloadException", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to In the file {0} was no AI found.. + /// + internal static string SimulatorPluginTeamSetupNoFolksFound { + get { + return ResourceManager.GetString("SimulatorPluginTeamSetupNoFolksFound", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The file {0} contains AI, but they are already contained in the list.. + /// + internal static string SimulatorPluginTeamSetupStillLoaded { + get { + return ResourceManager.GetString("SimulatorPluginTeamSetupStillLoaded", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Shows simulation statistics.. + /// + internal static string StatisticPluginDescription { + get { + return ResourceManager.GetString("StatisticPluginDescription", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Statistics. + /// + internal static string StatisticPluginName { + get { + return ResourceManager.GetString("StatisticPluginName", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to yes. + /// + internal static string Yes { + get { + return ResourceManager.GetString("Yes", resourceCulture); + } + } + } +} diff --git a/SimulationPlugin/Resource.de.Designer.cs b/SimulationPlugin/Resource.de.Designer.cs new file mode 100644 index 0000000..e69de29 diff --git a/SimulationPlugin/Resource.de.resx b/SimulationPlugin/Resource.de.resx new file mode 100644 index 0000000..bc5dfeb --- /dev/null +++ b/SimulationPlugin/Resource.de.resx @@ -0,0 +1,237 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Nein + Various use of no (AntProperties.cs) + + + Es kam während des Betriebs zu einem Problem: {0} + common intro for all exception-messageboxes (TeamSetup.cs) +0: Exceptionmessage + + + {0} von {3} + Pattern for one Entry of kicklist-messagebox (TeamSetup.cs) +0: Colony-Name +1: Filename +2: Classname +3: Authorname + + + Die nachfolgenden Ameisenvölker entsprechen nicht mehr den aktuellen Regeleinstellungen und werden entfernt: + Header for the kicklist-messagebox (TeamSetup.cs) + + + AntMe! - Simulation + Caption of every Messagebox (TeamSetup.cs) + + + Folgende Rechte wurden in den Einstellungen nicht frei geschaltet: + Header of a list of not granted rights (RightsRequest.cs) + + + Dieses Volk verursacht unter aktuellen Einstellungen eine Regelverletzung: {0} + Is used to show errormessage in listview-Tooltip (TeamSetup.cs) +0: Message of RuleViolation + + + {0} {1} + Format of author-tag (AntProperties.cs) +0: First Name +1: Last Name + + + Zugriff auf eine Datenbank + To tell the user, that the ant needs DB-Access (AntProperties.cs) + + + Zugriff auf das Dateisystem + To tell the user, that the ant needs IO-Access (AntProperties.cs) + + + Zugriff auf das Netzwerk + To tell the user, that the ant needs Network-Access (AntProperties.cs) + + + Volle Zugriffseinschränkung + To tell the user, that the ant needs no Access (AntProperties.cs) + + + Keine weiteren Infos + Text, if there are no additional info to access-requests (AntProperties.cs) + + + Ameise bindet fremde Assemblies ein + To tell the user, that the ant needs Ref-Access (AntProperties.cs) + + + Eigenschaften von {0} + Title-Bar of ant-property-window (AntProperties.cs) +0: Folkname + + + Zugriff auf das Userinterface + To tell the user, that the ant needs UI-Access (AntProperties.cs) + + + Unbekannt + Unknown information at filesize and filecreationtime (AntProperties.cs) + + + Ameisensimulation + Description of Simulator-Application (SimulatorPlugin.cs) + + + Simulation + Name of Simulator-Application (SimulatorPlugin.cs) + + + Simulation wurde nicht gestartet + Try to get a state, but simulation is not running (SimulatorPlugin.cs) + + + Die Datei {0} konnte nicht geladen werden. Die detailierte Fehlermeldung lautet '{1}' + Errormessage for Exceptions during the load of new AIs (TeamSetup.cs) +0: filename +1: inner exception-message + + + In der Datei {0} konnten keine KIs gefunden werden. + the file has no valid folks inside. (TeamSetup.cs) +0: filename + + + Die Datei {0} enthält zwar KIs, sind aber schon in der Liste enthalten + the file, which should be loaded, has only still loaded folks (TeamSetup.cs) +0: filename + + + Zeigt die statistische Auswertung einer Simulation + Description of Statistic-Plugin (StatisticPlugin.cs) + + + Statistik + Name of Statistic-Plugin (StatisticPlugin.cs) + + + Ja + Various use of yes (AntProperties.cs) + + \ No newline at end of file diff --git a/SimulationPlugin/Resource.resx b/SimulationPlugin/Resource.resx new file mode 100644 index 0000000..0ee3875 --- /dev/null +++ b/SimulationPlugin/Resource.resx @@ -0,0 +1,237 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + no + Various uses of no (AntProperties.cs) + + + There was a problem during runtime: {0} + common intro for all exception-messageboxes (TeamSetup.cs) +0: Exceptionmessage + + + {0} from {3} + Pattern for one Entry of kicklist-messagebox (TeamSetup.cs) +0: Colony-Name +1: Filename +2: Classname +3: Authorname + + + The following colonies are not valid anymore: + Header for the kicklist-messagebox (TeamSetup.cs) + + + AntMe! - Simulation + Caption of every Messagebox (TeamSetup.cs) + + + Following rights are not granted in the settings: + Header of a list of not granted rights (RightsRequest.cs) + + + This colony creates a ruleViolation with current settings: {0} + Is used to show errormessage in listview-Tooltip (TeamSetup.cs) +0: Message of RuleViolation + + + {0} {1} + Format of author-tag (AntProperties.cs) +0: First Name +1: Last Name + + + Access to a database + To tell the user, that the ant needs DB-Access (AntProperties.cs) + + + Access to the file system + To tell the user, that the ant needs IO-Access (AntProperties.cs) + + + Access to the network + To tell the user, that the ant needs Network-Access (AntProperties.cs) + + + Full access limitation + To tell the user, that the ant needs no Access (AntProperties.cs) + + + No further information available. + Text, if there are no additional info to access-requests (AntProperties.cs) + + + Ant references external assembly or assemblies. + To tell the user, that the ant needs Ref-Access (AntProperties.cs) + + + Properties of {0} + Title-Bar of ant-property-window (AntProperties.cs) +0: Folkname + + + Access to the user interface + To tell the user, that the ant needs UI-Access (AntProperties.cs) + + + Unknown + Unknown information at filesize and filecreationtime (AntProperties.cs) + + + Ant simulation + Description of Simulator-Application (SimulatorPlugin.cs) + + + Simulation + Name of Simulator-Application (SimulatorPlugin.cs) + + + Simulation has not been started. + Try to get a state, but simulation is not running (SimulatorPlugin.cs) + + + The file {0} coun't be loaded. The detailed errormessage is '{1}' + Errormessage for Exceptions during the load of new AIs (TeamSetup.cs) +0: filename +1: inner exception-message + + + In the file {0} was no AI found. + the file has no valid folks inside. (TeamSetup.cs) +0: filename + + + The file {0} contains AI, but they are already contained in the list. + the file, which should be loaded, has only still loaded folks (TeamSetup.cs) +0: Filename + + + Shows simulation statistics. + Description of Statistic-Plugin (StatisticPlugin.cs) + + + Statistics + Name of Statistic-Plugin (StatisticPlugin.cs) + + + yes + Various uses of yes (AntProperties.cs) + + \ No newline at end of file diff --git a/SimulationPlugin/Resources/SurvivalOfTheFittest.ant.config b/SimulationPlugin/Resources/SurvivalOfTheFittest.ant.config new file mode 100644 index 0000000..23ff9fe --- /dev/null +++ b/SimulationPlugin/Resources/SurvivalOfTheFittest.ant.config @@ -0,0 +1,94 @@ + + + Survival of the fittest + 88024c03-84f3-4fc8-8269-02a72ba155fc + 550000 + 1 + 32 + 5 + 100 + 5 + 1 + 2 + 1 + 1 + 1 + 0 + 100 + 999999 + 999999 + 999999 + 0 + 0 + 0 + 0 + 0 + 75 + 150 + 225 + 50 + 3 + 1000 + 3 + 4 + 1 + 5 + 1000 + 1000 + 250 + 250 + 5 + 1 + 20 + 13 + 150 + 1 + 1 + 150 + 5 + 0 + -5 + 0 + + -1 + 0 + + + 0 + 6 + 50 + 3 + 4 + 1800 + 45 + + + 10 + 8 + 100 + 4 + 5 + 2250 + 60 + + + 20 + 12 + 175 + 5 + 7 + 3400 + 75 + + + 30 + 16 + 250 + 6 + 10 + 4500 + 90 + + + + \ No newline at end of file diff --git a/SimulationPlugin/Resources/add.png b/SimulationPlugin/Resources/add.png new file mode 100644 index 0000000..071a2bb Binary files /dev/null and b/SimulationPlugin/Resources/add.png differ diff --git a/SimulationPlugin/Resources/captureTheApple.ant.config b/SimulationPlugin/Resources/captureTheApple.ant.config new file mode 100644 index 0000000..dc52ab1 --- /dev/null +++ b/SimulationPlugin/Resources/captureTheApple.ant.config @@ -0,0 +1,94 @@ + + + Capture the Apple + 86cf9a2a-e615-4407-a9d9-8775956cdbfc + 550000 + 1 + 32 + 5 + 100 + 5 + 1 + 2 + 1 + 1 + 1 + 0 + 999999 + 999999 + 0 + 1 + 0 + 0 + 0 + 0 + 15 + 75 + 150 + 225 + 50 + 3 + 1000 + 3 + 4 + 1 + 5 + 1000 + 1000 + 1000 + 1000 + 5 + 1 + 20 + 13 + 150 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + + -1 + 0 + + + 0 + 6 + 50 + 3 + 4 + 1800 + 45 + + + 10 + 8 + 100 + 4 + 5 + 2250 + 60 + + + 20 + 12 + 175 + 5 + 7 + 3400 + 75 + + + 30 + 16 + 250 + 6 + 10 + 4500 + 90 + + + + \ No newline at end of file diff --git a/SimulationPlugin/Resources/class_de.txt b/SimulationPlugin/Resources/class_de.txt new file mode 100644 index 0000000..12673cb --- /dev/null +++ b/SimulationPlugin/Resources/class_de.txt @@ -0,0 +1,111 @@ +using AntMe.Deutsch; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Player.{2} +{ + [Spieler( + Volkname = "{2}", + Vorname = "", + Nachname = "" + )] + [Kaste( + Name = "Standard", + AngriffModifikator = 0, + DrehgeschwindigkeitModifikator = 0, + EnergieModifikator = 0, + GeschwindigkeitModifikator = 0, + LastModifikator = 0, + ReichweiteModifikator = 0, + SichtweiteModifikator = 0 + )] + public class {0} : Basisameise + { + #region Kasten + + public override string BestimmeKaste(Dictionary anzahl) + { + return "Standard"; + } + + #endregion + + #region Fortbewegung + + public override void Wartet() + { + } + + public override void WirdMüde() + { + } + + public override void IstGestorben(Todesart todesart) + { + } + + public override void Tick() + { + } + + #endregion + + #region Nahrung + + public override void Sieht(Obst obst) + { + } + + public override void Sieht(Zucker zucker) + { + } + + public override void ZielErreicht(Obst obst) + { + } + + public override void ZielErreicht(Zucker zucker) + { + } + + #endregion + + #region Kommunikation + + public override void RiechtFreund(Markierung markierung) + { + } + + public override void SiehtFreund(Ameise ameise) + { + } + + public override void SiehtVerbündeten(Ameise ameise) + { + } + + #endregion + + #region Kampf + + public override void SiehtFeind(Ameise ameise) + { + } + + public override void SiehtFeind(Wanze wanze) + { + } + + public override void WirdAngegriffen(Ameise ameise) + { + } + + public override void WirdAngegriffen(Wanze wanze) + { + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationPlugin/Resources/class_en.txt b/SimulationPlugin/Resources/class_en.txt new file mode 100644 index 0000000..2e31f5c --- /dev/null +++ b/SimulationPlugin/Resources/class_en.txt @@ -0,0 +1,111 @@ +using AntMe.English; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Player.{2} +{ + [Player( + ColonyName = "{2}", + FirstName = "", + LastName = "" + )] + [Caste( + Name = "Default", + AttackModificator = 0, + EnergyModificator = 0, + LoadModificator = 0, + RangeModificator = 0, + RotationSpeedModificator = 0, + SpeedModificator = 0, + ViewRangeModificator = 0 + )] + public class {0} : BaseAnt + { + #region Caste + + public override string ChooseType(Dictionary typeCount) + { + return "Default"; + } + + #endregion + + #region Movement + + public override void Waits() + { + } + + public override void BecomesTired() + { + } + + public override void HasDied(KindOfDeath kindOfDeath) + { + } + + public override void Tick() + { + } + + #endregion + + #region Food + + public override void Spots(Fruit fruit) + { + } + + public override void Spots(Sugar sugar) + { + } + + public override void TargetReached(Fruit fruit) + { + } + + public override void TargetReached(Sugar sugar) + { + } + + #endregion + + #region Communication + + public override void SmellsFriend(Marker marker) + { + } + + public override void SpotsFriend(Ant ant) + { + } + + public override void SpotsPartner(Ant ant) + { + } + + #endregion + + #region Fight + + public override void SpotsEnemy(Ant ant) + { + } + + public override void SpotsEnemy(Bug bug) + { + } + + public override void UnderAttack(Ant ant) + { + } + + public override void UnderAttack(Bug bug) + { + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationPlugin/Resources/colony_nonstatic_32x32.png b/SimulationPlugin/Resources/colony_nonstatic_32x32.png new file mode 100644 index 0000000..d0ebe76 Binary files /dev/null and b/SimulationPlugin/Resources/colony_nonstatic_32x32.png differ diff --git a/SimulationPlugin/Resources/debug_messages_32x32.png b/SimulationPlugin/Resources/debug_messages_32x32.png new file mode 100644 index 0000000..0acb34c Binary files /dev/null and b/SimulationPlugin/Resources/debug_messages_32x32.png differ diff --git a/SimulationPlugin/Resources/debugging.ant.config b/SimulationPlugin/Resources/debugging.ant.config new file mode 100644 index 0000000..f415fdb --- /dev/null +++ b/SimulationPlugin/Resources/debugging.ant.config @@ -0,0 +1,94 @@ + + + Debugging + 8d4e2596-f217-46a9-8593-f95badc42c0e + 550000 + 1 + 32 + 5 + 100 + 10 + 1 + 2 + 1 + 1 + 1 + 0 + 999999 + 999999 + 0 + 0 + 0 + 0 + 0 + 0 + 15 + 75 + 150 + 225 + 25 + 6 + 500 + 3 + 4 + 1 + 5 + 1000 + 1000 + 250 + 250 + 5 + 1 + 20 + 13 + 150 + 1 + 1 + 300 + 5 + 0 + -5 + 0 + + -1 + 0 + + + 0 + 6 + 50 + 3 + 4 + 1800 + 45 + + + 10 + 8 + 100 + 4 + 5 + 2250 + 60 + + + 20 + 12 + 175 + 5 + 7 + 3400 + 75 + + + 30 + 16 + 250 + 6 + 10 + 4500 + 90 + + + + \ No newline at end of file diff --git a/SimulationPlugin/Resources/delete_16x16.png b/SimulationPlugin/Resources/delete_16x16.png new file mode 100644 index 0000000..460ceec Binary files /dev/null and b/SimulationPlugin/Resources/delete_16x16.png differ diff --git a/SimulationPlugin/Resources/duration_32x32.png b/SimulationPlugin/Resources/duration_32x32.png new file mode 100644 index 0000000..9f765b7 Binary files /dev/null and b/SimulationPlugin/Resources/duration_32x32.png differ diff --git a/SimulationPlugin/Resources/heros.ant.config b/SimulationPlugin/Resources/heros.ant.config new file mode 100644 index 0000000..e90223b --- /dev/null +++ b/SimulationPlugin/Resources/heros.ant.config @@ -0,0 +1,94 @@ + + + Heros of the Hill + e5dfe988-ea32-4537-a5b9-f50b0188122f + 550000 + 1 + 32 + 5 + 10 + 5 + 1 + 2 + 1 + 1 + 1 + 0 + 10 + 999999 + 999999 + 999999 + 0 + 0 + 0 + 0 + 5 + 75 + 150 + 225 + 50 + 3 + 1000 + 3 + 4 + 1 + 5 + 1000 + 1000 + 250 + 250 + 5 + 1 + 20 + 13 + 150 + 1 + 1 + 150 + 5 + 0 + -5 + 0 + + -1 + 0 + + + 0 + 24 + 200 + 12 + 16 + 7200 + 180 + + + 40 + 32 + 400 + 16 + 20 + 9000 + 240 + + + 80 + 48 + 700 + 20 + 28 + 13600 + 300 + + + 120 + 64 + 1000 + 24 + 40 + 18000 + 320 + + + + \ No newline at end of file diff --git a/SimulationPlugin/Resources/load_16x16.png b/SimulationPlugin/Resources/load_16x16.png new file mode 100644 index 0000000..32bc053 Binary files /dev/null and b/SimulationPlugin/Resources/load_16x16.png differ diff --git a/SimulationPlugin/Resources/map_generation_32x32.png b/SimulationPlugin/Resources/map_generation_32x32.png new file mode 100644 index 0000000..ca92184 Binary files /dev/null and b/SimulationPlugin/Resources/map_generation_32x32.png differ diff --git a/SimulationPlugin/Resources/project.txt b/SimulationPlugin/Resources/project.txt new file mode 100644 index 0000000..6388847 --- /dev/null +++ b/SimulationPlugin/Resources/project.txt @@ -0,0 +1,63 @@ + + + + + Debug + AnyCPU + {{4}} + Library + Properties + AntMe.Player.{2} + AntMe.Player.{2} + v4.0 + 512 + + + true + full + false + bin\ + DEBUG;TRACE + prompt + 4 + x86 + + + pdbonly + true + bin\ + TRACE + prompt + 4 + x86 + + + + {6}\AntMe.SharedComponents.dll + True + + + {6}\AntMe.Simulation.dll + True + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/SimulationPlugin/Resources/properties.txt b/SimulationPlugin/Resources/properties.txt new file mode 100644 index 0000000..2058894 --- /dev/null +++ b/SimulationPlugin/Resources/properties.txt @@ -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 attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("AntMe! Player")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("AntMe!")] +[assembly: AssemblyCopyright("")] +[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("{4}")] + +// 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("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] \ No newline at end of file diff --git a/SimulationPlugin/Resources/properties_16x16.png b/SimulationPlugin/Resources/properties_16x16.png new file mode 100644 index 0000000..fe7ce90 Binary files /dev/null and b/SimulationPlugin/Resources/properties_16x16.png differ diff --git a/SimulationPlugin/Resources/resetteams.png b/SimulationPlugin/Resources/resetteams.png new file mode 100644 index 0000000..7b61e60 Binary files /dev/null and b/SimulationPlugin/Resources/resetteams.png differ diff --git a/SimulationPlugin/Resources/save_16x16.png b/SimulationPlugin/Resources/save_16x16.png new file mode 100644 index 0000000..9256a75 Binary files /dev/null and b/SimulationPlugin/Resources/save_16x16.png differ diff --git a/SimulationPlugin/Resources/security_32x32.png b/SimulationPlugin/Resources/security_32x32.png new file mode 100644 index 0000000..23327cb Binary files /dev/null and b/SimulationPlugin/Resources/security_32x32.png differ diff --git a/SimulationPlugin/Resources/settings_16x16.png b/SimulationPlugin/Resources/settings_16x16.png new file mode 100644 index 0000000..dbdbb51 Binary files /dev/null and b/SimulationPlugin/Resources/settings_16x16.png differ diff --git a/SimulationPlugin/Resources/settings_32x32.png b/SimulationPlugin/Resources/settings_32x32.png new file mode 100644 index 0000000..4adaf32 Binary files /dev/null and b/SimulationPlugin/Resources/settings_32x32.png differ diff --git a/SimulationPlugin/Resources/settings_new.png b/SimulationPlugin/Resources/settings_new.png new file mode 100644 index 0000000..ba6d99c Binary files /dev/null and b/SimulationPlugin/Resources/settings_new.png differ diff --git a/SimulationPlugin/Resources/solution.txt b/SimulationPlugin/Resources/solution.txt new file mode 100644 index 0000000..11caab1 --- /dev/null +++ b/SimulationPlugin/Resources/solution.txt @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.31101.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{{3}}") = "{2}", "{2}.csproj", "{{4}}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {{4}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {{4}}.Debug|Any CPU.Build.0 = Debug|Any CPU + {{4}}.Release|Any CPU.ActiveCfg = Release|Any CPU + {{4}}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal \ No newline at end of file diff --git a/SimulationPlugin/Resources/sugarRun.ant.config b/SimulationPlugin/Resources/sugarRun.ant.config new file mode 100644 index 0000000..421b928 --- /dev/null +++ b/SimulationPlugin/Resources/sugarRun.ant.config @@ -0,0 +1,94 @@ + + + Sugar Run! + 535c6019-8aeb-48a2-996f-f00bb2a4c1f1 + 550000 + 1 + 32 + 5 + 100 + 5 + 1 + 2 + 1 + 1 + 1 + 0 + 999999 + 999999 + 1 + 0 + 0 + 0 + 0 + 0 + 15 + 75 + 150 + 225 + 50 + 3 + 1000 + 3 + 4 + 1 + 5 + 20000 + 20000 + 250 + 250 + 5 + 1 + 20 + 13 + 150 + 1 + 1 + 150 + 5 + 0 + -5 + 0 + + -1 + 0 + + + 0 + 6 + 50 + 3 + 4 + 1800 + 45 + + + 10 + 8 + 100 + 4 + 5 + 2250 + 60 + + + 20 + 12 + 175 + 5 + 7 + 3400 + 75 + + + 30 + 16 + 250 + 6 + 10 + 4500 + 90 + + + + \ No newline at end of file diff --git a/SimulationPlugin/Resources/timeout_32x32.png b/SimulationPlugin/Resources/timeout_32x32.png new file mode 100644 index 0000000..6d22ed6 Binary files /dev/null and b/SimulationPlugin/Resources/timeout_32x32.png differ diff --git a/SimulationPlugin/Resources/toddler.png b/SimulationPlugin/Resources/toddler.png new file mode 100644 index 0000000..b275e0f Binary files /dev/null and b/SimulationPlugin/Resources/toddler.png differ diff --git a/SimulationPlugin/Resources/user.txt b/SimulationPlugin/Resources/user.txt new file mode 100644 index 0000000..d0e1c0c --- /dev/null +++ b/SimulationPlugin/Resources/user.txt @@ -0,0 +1,8 @@ + + + + Program + {6}\AntMe.exe + /file="{7}\bin\AntMe.Player.{2}.dll" + + \ No newline at end of file diff --git a/SimulationPlugin/RightsRequest.Designer.cs b/SimulationPlugin/RightsRequest.Designer.cs new file mode 100644 index 0000000..c3b5948 --- /dev/null +++ b/SimulationPlugin/RightsRequest.Designer.cs @@ -0,0 +1,277 @@ +namespace AntMe.Plugin.Simulation +{ + partial class RightsRequest + { + /// + /// 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(RightsRequest)); + this.yesButton = new System.Windows.Forms.Button(); + this.noButton = new System.Windows.Forms.Button(); + this.acceptCheckBox = new System.Windows.Forms.CheckBox(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.label1 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.colonyLabel = new System.Windows.Forms.Label(); + this.authorLabel = new System.Windows.Forms.Label(); + this.rightsListView = new System.Windows.Forms.ListView(); + this.imageList = new System.Windows.Forms.ImageList(this.components); + this.detailsButton = new System.Windows.Forms.Button(); + this.acceptPanel = new System.Windows.Forms.Panel(); + this.label5 = new System.Windows.Forms.Label(); + this.sorryPanel = new System.Windows.Forms.Panel(); + this.label4 = new System.Windows.Forms.Label(); + this.closeButton = new System.Windows.Forms.Button(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.acceptPanel.SuspendLayout(); + this.sorryPanel.SuspendLayout(); + this.SuspendLayout(); + // + // yesButton + // + this.yesButton.AccessibleDescription = null; + this.yesButton.AccessibleName = null; + resources.ApplyResources(this.yesButton, "yesButton"); + this.yesButton.BackgroundImage = null; + this.yesButton.DialogResult = System.Windows.Forms.DialogResult.Yes; + this.yesButton.Font = null; + this.yesButton.Name = "yesButton"; + this.yesButton.UseVisualStyleBackColor = true; + // + // noButton + // + this.noButton.AccessibleDescription = null; + this.noButton.AccessibleName = null; + resources.ApplyResources(this.noButton, "noButton"); + this.noButton.BackgroundImage = null; + this.noButton.DialogResult = System.Windows.Forms.DialogResult.No; + this.noButton.Font = null; + this.noButton.Name = "noButton"; + this.noButton.UseVisualStyleBackColor = true; + // + // acceptCheckBox + // + this.acceptCheckBox.AccessibleDescription = null; + this.acceptCheckBox.AccessibleName = null; + resources.ApplyResources(this.acceptCheckBox, "acceptCheckBox"); + this.acceptCheckBox.BackgroundImage = null; + this.acceptCheckBox.Font = null; + this.acceptCheckBox.Name = "acceptCheckBox"; + this.acceptCheckBox.UseVisualStyleBackColor = true; + this.acceptCheckBox.CheckedChanged += new System.EventHandler(this.acceptCheckBox_CheckedChanged); + // + // pictureBox1 + // + this.pictureBox1.AccessibleDescription = null; + this.pictureBox1.AccessibleName = null; + resources.ApplyResources(this.pictureBox1, "pictureBox1"); + this.pictureBox1.BackgroundImage = null; + this.pictureBox1.Font = null; + this.pictureBox1.Image = global::AntMe.Plugin.Simulation.Properties.Resources.security_32x32; + this.pictureBox1.ImageLocation = null; + this.pictureBox1.InitialImage = null; + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.TabStop = false; + // + // label1 + // + this.label1.AccessibleDescription = null; + this.label1.AccessibleName = null; + resources.ApplyResources(this.label1, "label1"); + this.label1.Font = null; + this.label1.Name = "label1"; + // + // label2 + // + this.label2.AccessibleDescription = null; + this.label2.AccessibleName = null; + resources.ApplyResources(this.label2, "label2"); + this.label2.Font = null; + this.label2.Name = "label2"; + // + // label3 + // + this.label3.AccessibleDescription = null; + this.label3.AccessibleName = null; + resources.ApplyResources(this.label3, "label3"); + this.label3.Font = null; + this.label3.Name = "label3"; + // + // colonyLabel + // + this.colonyLabel.AccessibleDescription = null; + this.colonyLabel.AccessibleName = null; + resources.ApplyResources(this.colonyLabel, "colonyLabel"); + this.colonyLabel.Name = "colonyLabel"; + // + // authorLabel + // + this.authorLabel.AccessibleDescription = null; + this.authorLabel.AccessibleName = null; + resources.ApplyResources(this.authorLabel, "authorLabel"); + this.authorLabel.Font = null; + this.authorLabel.Name = "authorLabel"; + // + // rightsListView + // + this.rightsListView.AccessibleDescription = null; + this.rightsListView.AccessibleName = null; + resources.ApplyResources(this.rightsListView, "rightsListView"); + this.rightsListView.BackgroundImage = null; + this.rightsListView.Font = null; + this.rightsListView.Name = "rightsListView"; + this.rightsListView.SmallImageList = this.imageList; + this.rightsListView.UseCompatibleStateImageBehavior = false; + this.rightsListView.View = System.Windows.Forms.View.List; + // + // imageList + // + this.imageList.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList.ImageStream"))); + this.imageList.TransparentColor = System.Drawing.Color.Transparent; + this.imageList.Images.SetKeyName(0, "closed"); + this.imageList.Images.SetKeyName(1, "open"); + // + // detailsButton + // + this.detailsButton.AccessibleDescription = null; + this.detailsButton.AccessibleName = null; + resources.ApplyResources(this.detailsButton, "detailsButton"); + this.detailsButton.BackgroundImage = null; + this.detailsButton.Font = null; + this.detailsButton.Name = "detailsButton"; + this.detailsButton.UseVisualStyleBackColor = true; + this.detailsButton.Click += new System.EventHandler(this.detailsButton_Click); + // + // acceptPanel + // + this.acceptPanel.AccessibleDescription = null; + this.acceptPanel.AccessibleName = null; + resources.ApplyResources(this.acceptPanel, "acceptPanel"); + this.acceptPanel.BackgroundImage = null; + this.acceptPanel.Controls.Add(this.label5); + this.acceptPanel.Controls.Add(this.yesButton); + this.acceptPanel.Controls.Add(this.noButton); + this.acceptPanel.Controls.Add(this.acceptCheckBox); + this.acceptPanel.Font = null; + this.acceptPanel.Name = "acceptPanel"; + // + // label5 + // + this.label5.AccessibleDescription = null; + this.label5.AccessibleName = null; + resources.ApplyResources(this.label5, "label5"); + this.label5.Font = null; + this.label5.Name = "label5"; + // + // sorryPanel + // + this.sorryPanel.AccessibleDescription = null; + this.sorryPanel.AccessibleName = null; + resources.ApplyResources(this.sorryPanel, "sorryPanel"); + this.sorryPanel.BackgroundImage = null; + this.sorryPanel.Controls.Add(this.label4); + this.sorryPanel.Controls.Add(this.closeButton); + this.sorryPanel.Font = null; + this.sorryPanel.Name = "sorryPanel"; + // + // label4 + // + this.label4.AccessibleDescription = null; + this.label4.AccessibleName = null; + resources.ApplyResources(this.label4, "label4"); + this.label4.Font = null; + this.label4.Name = "label4"; + // + // closeButton + // + this.closeButton.AccessibleDescription = null; + this.closeButton.AccessibleName = null; + resources.ApplyResources(this.closeButton, "closeButton"); + this.closeButton.BackgroundImage = null; + this.closeButton.DialogResult = System.Windows.Forms.DialogResult.No; + this.closeButton.Font = null; + this.closeButton.Name = "closeButton"; + this.closeButton.UseVisualStyleBackColor = true; + // + // RightsRequest + // + this.AcceptButton = this.yesButton; + this.AccessibleDescription = null; + this.AccessibleName = null; + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackgroundImage = null; + this.CancelButton = this.noButton; + this.Controls.Add(this.detailsButton); + this.Controls.Add(this.rightsListView); + this.Controls.Add(this.authorLabel); + this.Controls.Add(this.colonyLabel); + this.Controls.Add(this.label3); + this.Controls.Add(this.label2); + this.Controls.Add(this.label1); + this.Controls.Add(this.pictureBox1); + this.Controls.Add(this.acceptPanel); + this.Controls.Add(this.sorryPanel); + this.Font = null; + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = null; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "RightsRequest"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.acceptPanel.ResumeLayout(false); + this.acceptPanel.PerformLayout(); + this.sorryPanel.ResumeLayout(false); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button yesButton; + private System.Windows.Forms.Button noButton; + private System.Windows.Forms.CheckBox acceptCheckBox; + private System.Windows.Forms.PictureBox pictureBox1; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Label colonyLabel; + private System.Windows.Forms.Label authorLabel; + private System.Windows.Forms.ListView rightsListView; + private System.Windows.Forms.ImageList imageList; + private System.Windows.Forms.Button detailsButton; + private System.Windows.Forms.Panel acceptPanel; + private System.Windows.Forms.Panel sorryPanel; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.Button closeButton; + private System.Windows.Forms.Label label5; + } +} \ No newline at end of file diff --git a/SimulationPlugin/RightsRequest.cs b/SimulationPlugin/RightsRequest.cs new file mode 100644 index 0000000..29c9acd --- /dev/null +++ b/SimulationPlugin/RightsRequest.cs @@ -0,0 +1,238 @@ +using System; +using System.Collections.Generic; +using System.Windows.Forms; + +using AntMe.Simulation; + +namespace AntMe.Plugin.Simulation { + public partial class RightsRequest : Form { + private readonly PlayerInfoFilename playerInfo; + private const string open = "open"; + private const string closed = "closed"; + private readonly bool locked = false; + + public RightsRequest(SimulationPluginConfiguration config, PlayerInfoFilename player) { + playerInfo = player; + InitializeComponent(); + yesButton.Enabled = acceptCheckBox.Checked; + + colonyLabel.Text = player.ColonyName; + authorLabel.Text = + string.Format(Resource.SimulatorPluginAntPropertiesAuthorFormat, player.FirstName, player.LastName); + + if (player.RequestFileAccess) { + if (config.configuration.AllowFileAccess) { + rightsListView.Items.Add(Resource.SimulatorPluginAntPropertiesIoAccess, open); + } + else { + locked = true; + rightsListView.Items.Add(Resource.SimulatorPluginAntPropertiesIoAccess, closed); + } + } + if (player.RequestDatabaseAccess) { + if (config.configuration.AllowDatabaseAccess) { + rightsListView.Items.Add(Resource.SimulatorPluginAntPropertiesDbAccess, open); + } + else { + locked = true; + rightsListView.Items.Add(Resource.SimulatorPluginAntPropertiesDbAccess, closed); + } + } + if (player.RequestReferences) { + if (config.configuration.AllowReferences) { + rightsListView.Items.Add(Resource.SimulatorPluginAntPropertiesRefAccess, open); + } + else { + locked = true; + rightsListView.Items.Add(Resource.SimulatorPluginAntPropertiesRefAccess, closed); + } + } + if (player.RequestUserInterfaceAccess) { + if (config.configuration.AllowUserinterfaceAccess) { + rightsListView.Items.Add(Resource.SimulatorPluginAntPropertiesUiAccess, open); + } + else { + locked = true; + rightsListView.Items.Add(Resource.SimulatorPluginAntPropertiesUiAccess, closed); + } + } + if (player.RequestNetworkAccess) { + if (config.configuration.AllowNetworkAccess) { + rightsListView.Items.Add(Resource.SimulatorPluginAntPropertiesNetAccess, open); + } + else { + locked = true; + rightsListView.Items.Add(Resource.SimulatorPluginAntPropertiesNetAccess, closed); + } + } + + if (locked) { + sorryPanel.Visible = true; + acceptPanel.Visible = false; + AcceptButton = closeButton; + CancelButton = closeButton; + } + else { + sorryPanel.Visible = false; + acceptPanel.Visible = true; + AcceptButton = yesButton; + CancelButton = noButton; + } + } + + /// + /// Finds out, if the given player needs a security-request + /// + /// true, if request is needed + public bool NeedRequest() { + return + playerInfo.RequestFileAccess || + playerInfo.RequestDatabaseAccess || + playerInfo.RequestReferences || + playerInfo.RequestUserInterfaceAccess || + playerInfo.RequestNetworkAccess; + } + + /// + /// Finds out, if the given player is locked through the antme-settings. + /// + /// true, if player is locked + public bool IsLocked() { + return locked; + } + + private void acceptCheckBox_CheckedChanged(object sender, EventArgs e) { + yesButton.Enabled = acceptCheckBox.Checked; + } + + private void detailsButton_Click(object sender, EventArgs e) { + AntProperties properties = new AntProperties(playerInfo); + properties.ShowDialog(this); + } + + /// + /// Checks, if the player is still valid. + /// + /// player + /// true, if player is valid. + public static bool IsValidPlayer(PlayerInfo player) { + bool output; + try { + player.RuleCheck(); + output = true; + } + catch (RuleViolationException) { + output = false; + } + return output; + } + + /// + /// Delivers the RuleViolationException-Message for that player. + /// + /// player + /// RuleViolation-Message + public static string GetRuleViolationMessage(PlayerInfo player) { + string message = string.Empty; + try { + player.RuleCheck(); + } + catch (RuleViolationException ex) { + message = string.Format(Resource.SimulationPluginRuleViolation, ex.Message); + } + return message; + } + + /// + /// Checks player for right-requests. + /// + /// player + /// true, if player requests rights + public static bool RequestRights(PlayerInfo player) { + return + player.RequestFileAccess || + player.RequestDatabaseAccess || + player.RequestReferences || + player.RequestUserInterfaceAccess || + player.RequestNetworkAccess; + } + + public static bool LockedRights(SimulationPluginConfiguration config, PlayerInfo player) { + // Global check. If the player needs no rights there is no way to lock + if (!RequestRights(player)) { + return false; + } + + // Fileaccess + if (player.RequestFileAccess && !config.configuration.AllowFileAccess) { + return true; + } + + // Database + if (player.RequestDatabaseAccess && !config.configuration.AllowDatabaseAccess) { + return true; + } + + // Refs + if (player.RequestReferences && !config.configuration.AllowReferences) { + return true; + } + + // Userinterfaces + if (player.RequestUserInterfaceAccess && !config.configuration.AllowUserinterfaceAccess) { + return true; + } + + // Network + if (player.RequestNetworkAccess && !config.configuration.AllowNetworkAccess) { + return true; + } + + // No locks + return false; + } + + public static string RequiredRightsList(SimulationPluginConfiguration config, PlayerInfo player) { + List securityRequests = new List(); + + // Security-Settings + if (player.RequestFileAccess) { + if (!config.configuration.AllowFileAccess) { + securityRequests.Add("- " + Resource.SimulatorPluginAntPropertiesIoAccess); + } + } + + if (player.RequestDatabaseAccess) { + if (!config.configuration.AllowDatabaseAccess) { + securityRequests.Add("- " + Resource.SimulatorPluginAntPropertiesDbAccess); + } + } + + if (player.RequestUserInterfaceAccess) { + if (!config.configuration.AllowUserinterfaceAccess) { + securityRequests.Add("- " + Resource.SimulatorPluginAntPropertiesUiAccess); + } + } + + if (player.RequestReferences) { + if (!config.configuration.AllowReferences) { + securityRequests.Add("- " + Resource.SimulatorPluginAntPropertiesRefAccess); + } + } + + if (player.RequestNetworkAccess) { + if (!config.configuration.AllowNetworkAccess) { + securityRequests.Add("- " + Resource.SimulatorPluginAntPropertiesNetAccess); + } + } + + if (securityRequests.Count > 0) { + return + Resource.SimulationPluginRightsLocked + Environment.NewLine + + string.Join(Environment.NewLine, securityRequests.ToArray()); + } + + return string.Empty; + } + } +} \ No newline at end of file diff --git a/SimulationPlugin/RightsRequest.de.resx b/SimulationPlugin/RightsRequest.de.resx new file mode 100644 index 0000000..27c370a --- /dev/null +++ b/SimulationPlugin/RightsRequest.de.resx @@ -0,0 +1,208 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Ja + + + Nein + + + + 108, 17 + + + Ja, ich bin sicher. + + + Du versuchst gerade ein potentiell gefährliches Ameisenvolk zur aktuellen Teamzusammenstellung hinzuzufügen. Dieses Volk würde dadurch Zugriff auf zusätzliche Resourcen erhalten. + +Hier kannst du nachsehen welche Rechte dieses Volk angefordert hat und entscheiden, ob du dies erlauben willst. Beachte, dass Zugriffsrechte, die du diesem Volk gewährst, anschließend auch von den anderen Völkern verwendet werden können. + + + 88, 13 + + + Betroffenes Volk: + + + 109, 13 + + + Angeforderte Rechte: + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAABM + CAAAAk1TRnQBSQFMAgEBAgEAAQQBAAEEAQABEAEAARABAAT/AQkBAAj/AUIBTQE2AQQGAAE2AQQCAAEo + AwABQAMAARADAAEBAQABCAYAAQQYAAGAAgABgAMAAoABAAGAAwABgAEAAYABAAKAAgADwAEAAcAB3AHA + AQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEAAykBAANVAQADTQEAA0IBAAM5 + AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8BAAHWAucBAAGQAakBrQIAAf8BMwMA + AWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHMAgABMwH/AgABZgMAAWYBMwIAAmYCAAFm + AZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgACmQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHM + AWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZAgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEA + ATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8BMwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEz + AWYCAAEzAWYBMwEAATMCZgEAATMBZgGZAQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZ + AWYBAAEzApkBAAEzAZkBzAEAATMBmQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLM + AQABMwHMAf8BAAEzAf8BMwEAATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEA + AWYBAAFmAQABZgEAAZkBAAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEA + AWYBMwHMAQABZgEzAf8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZ + AWYBAAFmApkBAAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/ + AQABZgH/AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEA + AZkBAAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm + ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwBAAKZ + Af8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIAAZkB/wEz + AQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYBAAHMAQABmQEA + AcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEzAf8BAAHMAWYCAAHM + AWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwBmQEzAQABzAGZAWYBAAHM + ApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEAA8wBAALMAf8BAAHMAf8CAAHM + Af8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwBAAEzAQAB/wEAAWYBAAH/AQABmQEA + AcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEAAf8BMwH/AQAB/wFmAgAB/wFmATMBAAHM + AmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkCAAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZ + AcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHMAWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEz + AQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8BAAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFm + AQABIQEAAaUBAANfAQADdwEAA4YBAAOWAQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHw + AfsB/wEAAaQCoAEAA4ADAAH/AgAB/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD/wEAAv8BGgF6CiwC/wEa + AXoILAb/IAAC/wFTCiwBUwL/AVMILAFTBv8gACD/IAAC/wF6ClMBegL/AXoIUwF6Bv8gAAL/ARoBegos + Av8BGgF6CCwG/yAAAv8BUwosAVMC/wFTCCwBUwb/IAAg/yAAAv8BegpTAXoC/wF6CFMBegb/IAAC/wEa + AXoKLAL/ARoBeggsBv8gAAL/AVMKLAFTAv8BUwgsAVMG/yAAA/8B8QFtAfIE/wHyAW0BvAr/AewB7wX/ + Ae8B7CAAA/8B8QFtAfEE/wHxAW0BBwr/AW0B7QX/Ae0BbSAAA/8B8QFtAbwE/wG8AW0B8Qr/AW0B7QX/ + Ae0B6yAABP8B6wHsAfMC/wHzAewB6wv/AesB7QG8A/8BvAFtAfcgAAT/AfEBbQHsApIB6wFtAfAL/wH0 + AW0B7AH3Ae8B7QFtAewB9CAABf8B8gHvAm0B7QHyDf8B9AHvAm0B7AHvAfQB/yAAAUIBTQE+BwABPgMA + ASgDAAFAAwABEAMAAQEBAAEBBQABgBcAA/+BAAs= + + + + 378, 13 + + + Bist du sicher, dass du diesem Volk die angeforderten Rechte gewähren willst? + + + Leider sind nicht alle angefragten Zugriffsrechte in den Grundeinstellungen von AntMe! freigegeben. Willst du aber dennoch dieses Volk zur Simulation hinzufügen, so musst du nur in die Simulationseinstellungen welchsen und dort im Tab "Sicherheit" die nötigen Zugriffsrechte bestätigen. + + + Schließen + + + AntMe! Sicherheitsabfrage + + \ No newline at end of file diff --git a/SimulationPlugin/RightsRequest.resx b/SimulationPlugin/RightsRequest.resx new file mode 100644 index 0000000..74c0f66 --- /dev/null +++ b/SimulationPlugin/RightsRequest.resx @@ -0,0 +1,624 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + 72, 13 + + + System.Windows.Forms.ImageList, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 3 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 136, 160 + + + 75, 23 + + + 303, 80 + + + 85, 13 + + + $this + + + $this + + + + Bottom, Right + + + 378, 77 + + + + 5 + + + 1 + + + imageList + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + No + + + CenterParent + + + 303, 80 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + label5 + + + 7 + + + label2 + + + 139, 193 + + + $this + + + 6 + + + Bottom, Right + + + 12, 337 + + + System.Windows.Forms.Panel, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ListView, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 4 + + + Unfortunally there are not all required rights granted in the settings of AntMe!. To accept this colony, its neccessary to go to the settings, check the requested rights at the security-tab. After that, you can here accept the requested rights. + + + 6, 13 + + + 50, 12 + + + 0 + + + Top, Bottom, Left, Right + + + 6 + + + 8 + + + acceptPanel + + + 222, 17 + + + 10 + + + 340, 114 + + + 0 + + + authorLabel + + + 2 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAABM + CAAAAk1TRnQBSQFMAgEBAgEAAQQBAAEEAQABEAEAARABAAT/AQkBEAj/AUIBTQE2AQQGAAE2AQQCAAEo + AwABQAMAARADAAEBAQABCAYAAQQYAAGAAgABgAMAAoABAAGAAwABgAEAAYABAAKAAgADwAEAAcAB3AHA + AQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEAAykBAANVAQADTQEAA0IBAAM5 + AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8BAAHWAucBAAGQAakBrQIAAf8BMwMA + AWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHMAgABMwH/AgABZgMAAWYBMwIAAmYCAAFm + AZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgACmQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHM + AWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZAgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEA + ATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8BMwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEz + AWYCAAEzAWYBMwEAATMCZgEAATMBZgGZAQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZ + AWYBAAEzApkBAAEzAZkBzAEAATMBmQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLM + AQABMwHMAf8BAAEzAf8BMwEAATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEA + AWYBAAFmAQABZgEAAZkBAAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEA + AWYBMwHMAQABZgEzAf8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZ + AWYBAAFmApkBAAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/ + AQABZgH/AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEA + AZkBAAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm + ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwBAAKZ + Af8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIAAZkB/wEz + AQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYBAAHMAQABmQEA + AcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEzAf8BAAHMAWYCAAHM + AWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwBmQEzAQABzAGZAWYBAAHM + ApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEAA8wBAALMAf8BAAHMAf8CAAHM + Af8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwBAAEzAQAB/wEAAWYBAAH/AQABmQEA + AcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEAAf8BMwH/AQAB/wFmAgAB/wFmATMBAAHM + AmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkCAAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZ + AcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHMAWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEz + AQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8BAAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFm + AQABIQEAAaUBAANfAQADdwEAA4YBAAOWAQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHw + AfsB/wEAAaQCoAEAA4ADAAH/AgAB/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD/wEAAv8BGgF6CiwC/wEa + AXoILAb/IAAC/wFTCiwBUwL/AVMILAFTBv8gACD/IAAC/wF6ClMBegL/AXoIUwF6Bv8gAAL/ARoBegos + Av8BGgF6CCwG/yAAAv8BUwosAVMC/wFTCCwBUwb/IAAg/yAAAv8BegpTAXoC/wF6CFMBegb/IAAC/wEa + AXoKLAL/ARoBeggsBv8gAAL/AVMKLAFTAv8BUwgsAVMG/yAAA/8B8QFtAfIE/wHyAW0BvAr/AewB7wX/ + Ae8B7CAAA/8B8QFtAfEE/wHxAW0BBwr/AW0B7QX/Ae0BbSAAA/8B8QFtAbwE/wG8AW0B8Qr/AW0B7QX/ + Ae0B6yAABP8B6wHsAfMC/wHzAewB6wv/AesB7QG8A/8BvAFtAfcgAAT/AfEBbQHsApIB6wFtAfAL/wH0 + AW0B7AH3Ae8B7QFtAewB9CAABf8B8gHvAm0B7QHyDf8B9AHvAm0B7AHvAfQB/yAAAUIBTQE+BwABPgMA + ASgDAAFAAwABEAMAAQEBAAEBBQABgBcAA/+XAAs= + + + + Bottom, Left, Right + + + [AuthorName] + + + 3 + + + 118, 13 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Yes + + + True + + + Requesting Ant-Colony: + + + 12, 337 + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 7 + + + 0 + + + $this + + + 32, 32 + + + True + + + 95, 13 + + + 0, 55 + + + 75, 23 + + + True + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Requested Rights: + + + True + + + RightsRequest + + + 3 + + + AntMe! Security-Request + + + You try to add an potential dangerous Ant-colony to the current match-settings. This means you grant an ant special access to various ressources. + +Following, you can see the requested rights of that ant. Note, that the granted access-rights have also effect to the other colonies you add to the match. + + + sorryPanel + + + $this + + + 5 + + + True + + + label1 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 8 + + + acceptPanel + + + Microsoft Sans Serif, 8.25pt, style=Bold + + + sorryPanel + + + yesButton + + + label3 + + + 266, 13 + + + 12, 143 + + + colonyLabel + + + 3 + + + Yes, I'm sure I know what I'm doning here + + + 0 + + + acceptCheckBox + + + pictureBox1 + + + 251, 122 + + + System.Windows.Forms.Form, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + [ColonyName] + + + 315, 138 + + + 4 + + + 1 + + + 9 + + + 222, 80 + + + noButton + + + Close + + + 378, 103 + + + Details + + + Bottom, Left, Right + + + label4 + + + detailsButton + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 136, 143 + + + 2 + + + True + + + acceptPanel + + + Sure, you want to grant higher rights to this ant-colony? + + + Bottom, Right + + + 402, 452 + + + False + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Top, Left, Right + + + 12, 12 + + + 1 + + + closeButton + + + 11 + + + 12, 193 + + + $this + + + Bottom, Left + + + System.Windows.Forms.Panel, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 1 + + + 378, 103 + + + 2 + + + rightsListView + + + acceptPanel + + + 1 + + + 75, 23 + + + acceptPanel + + + Top, Bottom, Left, Right + + + $this + + + 3, 0 + + + sorryPanel + + + 0 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Top, Right + + + 75, 23 + + + 0, 0 + + + 9 + + + 12 + + + True + + + 17, 17 + + \ No newline at end of file diff --git a/SimulationPlugin/SimulationPlugin.csproj b/SimulationPlugin/SimulationPlugin.csproj new file mode 100644 index 0000000..133330f --- /dev/null +++ b/SimulationPlugin/SimulationPlugin.csproj @@ -0,0 +1,312 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {D622F308-35A9-4A86-8F2C-4E68CECA7C11} + Library + Properties + AntMe.Plugin.Simulation + AntMe.Plugin.Simulation + v4.0 + 512 + SAK + SAK + SAK + SAK + + + 3.5 + + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + + true + ..\bin\ + DEBUG;TRACE + full + x86 + true + GlobalSuppressions.cs + prompt + AllRules.ruleset + + + ..\bin\ + TRACE + true + pdbonly + x86 + true + GlobalSuppressions.cs + prompt + + + AllRules.ruleset + + + + + + + + + + + Form + + + AntProperties.cs + + + Form + + + CreateForm.cs + + + + True + True + GeneratorFiles.resx + + + + + + True + True + Presets.resx + + + Form + + + RightsRequest.cs + + + + + True + True + Resources.resx + + + True + True + Resource.de.resx + + + True + True + Resource.resx + + + + UserControl + + + StatisticControl.cs + + + + + + + + + UserControl + + + TeamSetup.cs + + + + + + Form + + + SimulationProperties.cs + + + + + AntProperties.cs + Designer + + + AntProperties.cs + Designer + + + CreateForm.cs + + + CreateForm.cs + + + ResXFileCodeGenerator + GeneratorFiles.Designer.cs + + + ResXFileCodeGenerator + Presets.Designer.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + Designer + ResXFileCodeGenerator + Resource.de.Designer.cs + + + ResXFileCodeGenerator + Resource.Designer.cs + Designer + + + RightsRequest.cs + + + RightsRequest.cs + + + SimulationProperties.cs + Designer + + + StatisticControl.cs + Designer + + + StatisticControl.cs + Designer + + + TeamSetup.cs + Designer + + + TeamSetup.cs + Designer + + + SimulationProperties.cs + Designer + + + + + {415F50C3-BD70-4634-B1F7-A15B42F0B0C6} + SharedComponents + + + {35753E72-07F3-4F18-916C-479850EC375F} + SimulationCore + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + true + + + False + Windows Installer 3.1 + true + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/SimulationPlugin/SimulationPluginConfiguration.cs b/SimulationPlugin/SimulationPluginConfiguration.cs new file mode 100644 index 0000000..6048232 --- /dev/null +++ b/SimulationPlugin/SimulationPluginConfiguration.cs @@ -0,0 +1,54 @@ +using System; +using System.Collections.Generic; + +using AntMe.Simulation; + +namespace AntMe.Plugin.Simulation { + /// + /// Class, to holds all configuration-information. + /// + [Serializable] + public sealed class SimulationPluginConfiguration { + private const int TEAMLIMIT = 8; + + /// + /// Creates a new instance of SimulationPluginConfiguration. + /// + public SimulationPluginConfiguration() { + teams = new TeamItem[8]; + for (int i = 0; i < TEAMLIMIT; i++) { + teams[i] = new TeamItem(); + } + } + + /// + /// List of known player-files. + /// + public List knownPlayerFiles = new List(); + + /// + /// List of known player. + /// + public List knownPlayer = new List(); + + /// + /// List of teams. + /// + public TeamItem[] teams; + + /// + /// Holds the current simulation-configuration. + /// + public SimulatorConfiguration configuration = new SimulatorConfiguration(); + + /// + /// List of known settings-Files. + /// + public List knownSettingFiles = new List(); + + /// + /// Holds the path to the default settings-file. + /// + public string settingFile = string.Empty; + } +} \ No newline at end of file diff --git a/SimulationPlugin/SimulationProperties.Designer.cs b/SimulationPlugin/SimulationProperties.Designer.cs new file mode 100644 index 0000000..348befc --- /dev/null +++ b/SimulationPlugin/SimulationProperties.Designer.cs @@ -0,0 +1,787 @@ +namespace AntMe.Plugin.Simulation +{ + partial class SimulationProperties + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(SimulationProperties)); + this.okButton = new System.Windows.Forms.Button(); + this.cancelButton = new System.Windows.Forms.Button(); + this.tabControl = new System.Windows.Forms.TabControl(); + this.mapTab = new System.Windows.Forms.TabPage(); + this.groupBox2 = new System.Windows.Forms.GroupBox(); + this.pictureBox2 = new System.Windows.Forms.PictureBox(); + this.mapInitCheckBox = new System.Windows.Forms.CheckBox(); + this.label3 = new System.Windows.Forms.Label(); + this.mapGeneratorMaskedTextBox = new System.Windows.Forms.MaskedTextBox(); + this.label25 = new System.Windows.Forms.Label(); + this.mapGeneratorButton = new System.Windows.Forms.Button(); + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.roundsNumericUpDown = new System.Windows.Forms.NumericUpDown(); + this.label24 = new System.Windows.Forms.Label(); + this.loopsNumericUpDown = new System.Windows.Forms.NumericUpDown(); + this.label2 = new System.Windows.Forms.Label(); + this.label23 = new System.Windows.Forms.Label(); + this.debugTab = new System.Windows.Forms.TabPage(); + this.groupBox4 = new System.Windows.Forms.GroupBox(); + this.pictureBox3 = new System.Windows.Forms.PictureBox(); + this.label1 = new System.Windows.Forms.Label(); + this.debugInfoCheckBox = new System.Windows.Forms.CheckBox(); + this.groupBox3 = new System.Windows.Forms.GroupBox(); + this.pictureBox4 = new System.Windows.Forms.PictureBox(); + this.label10 = new System.Windows.Forms.Label(); + this.label9 = new System.Windows.Forms.Label(); + this.label4 = new System.Windows.Forms.Label(); + this.roundTimeoutNumericUpDown = new System.Windows.Forms.NumericUpDown(); + this.label27 = new System.Windows.Forms.Label(); + this.loopTimeoutNumericUpDown = new System.Windows.Forms.NumericUpDown(); + this.label26 = new System.Windows.Forms.Label(); + this.ignoreTimeoutsCheckBox = new System.Windows.Forms.CheckBox(); + this.securityTab = new System.Windows.Forms.TabPage(); + this.groupBox5 = new System.Windows.Forms.GroupBox(); + this.allowNetworkCheckBox = new System.Windows.Forms.CheckBox(); + this.pictureBox5 = new System.Windows.Forms.PictureBox(); + this.label5 = new System.Windows.Forms.Label(); + this.allowRefCheckBox = new System.Windows.Forms.CheckBox(); + this.allowUiCheckBox = new System.Windows.Forms.CheckBox(); + this.allowIoCheckBox = new System.Windows.Forms.CheckBox(); + this.allowDbCheckBox = new System.Windows.Forms.CheckBox(); + this.settingsTab = new System.Windows.Forms.TabPage(); + this.groupBox6 = new System.Windows.Forms.GroupBox(); + this.label6 = new System.Windows.Forms.Label(); + this.label8 = new System.Windows.Forms.Label(); + this.presetComboBox = new System.Windows.Forms.ComboBox(); + this.label7 = new System.Windows.Forms.Label(); + this.settingCreateButton = new System.Windows.Forms.Button(); + this.settingLoadButton = new System.Windows.Forms.Button(); + this.openFileDialog = new System.Windows.Forms.OpenFileDialog(); + this.saveFileDialog = new System.Windows.Forms.SaveFileDialog(); + this.tabControl.SuspendLayout(); + this.mapTab.SuspendLayout(); + this.groupBox2.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).BeginInit(); + this.groupBox1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.roundsNumericUpDown)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.loopsNumericUpDown)).BeginInit(); + this.debugTab.SuspendLayout(); + this.groupBox4.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox3)).BeginInit(); + this.groupBox3.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox4)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.roundTimeoutNumericUpDown)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.loopTimeoutNumericUpDown)).BeginInit(); + this.securityTab.SuspendLayout(); + this.groupBox5.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox5)).BeginInit(); + this.settingsTab.SuspendLayout(); + this.groupBox6.SuspendLayout(); + this.SuspendLayout(); + // + // okButton + // + this.okButton.AccessibleDescription = null; + this.okButton.AccessibleName = null; + resources.ApplyResources(this.okButton, "okButton"); + this.okButton.BackgroundImage = null; + this.okButton.DialogResult = System.Windows.Forms.DialogResult.OK; + this.okButton.Font = null; + this.okButton.Name = "okButton"; + this.okButton.UseVisualStyleBackColor = true; + // + // cancelButton + // + this.cancelButton.AccessibleDescription = null; + this.cancelButton.AccessibleName = null; + resources.ApplyResources(this.cancelButton, "cancelButton"); + this.cancelButton.BackgroundImage = null; + this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.cancelButton.Font = null; + this.cancelButton.Name = "cancelButton"; + this.cancelButton.UseVisualStyleBackColor = true; + // + // tabControl + // + this.tabControl.AccessibleDescription = null; + this.tabControl.AccessibleName = null; + resources.ApplyResources(this.tabControl, "tabControl"); + this.tabControl.BackgroundImage = null; + this.tabControl.Controls.Add(this.mapTab); + this.tabControl.Controls.Add(this.debugTab); + this.tabControl.Controls.Add(this.securityTab); + this.tabControl.Controls.Add(this.settingsTab); + this.tabControl.Font = null; + this.tabControl.Name = "tabControl"; + this.tabControl.SelectedIndex = 0; + // + // mapTab + // + this.mapTab.AccessibleDescription = null; + this.mapTab.AccessibleName = null; + resources.ApplyResources(this.mapTab, "mapTab"); + this.mapTab.BackgroundImage = null; + this.mapTab.Controls.Add(this.groupBox2); + this.mapTab.Controls.Add(this.groupBox1); + this.mapTab.Font = null; + this.mapTab.Name = "mapTab"; + this.mapTab.UseVisualStyleBackColor = true; + // + // groupBox2 + // + this.groupBox2.AccessibleDescription = null; + this.groupBox2.AccessibleName = null; + resources.ApplyResources(this.groupBox2, "groupBox2"); + this.groupBox2.BackgroundImage = null; + this.groupBox2.Controls.Add(this.pictureBox2); + this.groupBox2.Controls.Add(this.mapInitCheckBox); + this.groupBox2.Controls.Add(this.label3); + this.groupBox2.Controls.Add(this.mapGeneratorMaskedTextBox); + this.groupBox2.Controls.Add(this.label25); + this.groupBox2.Controls.Add(this.mapGeneratorButton); + this.groupBox2.Font = null; + this.groupBox2.Name = "groupBox2"; + this.groupBox2.TabStop = false; + // + // pictureBox2 + // + this.pictureBox2.AccessibleDescription = null; + this.pictureBox2.AccessibleName = null; + resources.ApplyResources(this.pictureBox2, "pictureBox2"); + this.pictureBox2.BackgroundImage = null; + this.pictureBox2.Font = null; + this.pictureBox2.Image = global::AntMe.Plugin.Simulation.Properties.Resources.map_generation_32x32; + this.pictureBox2.ImageLocation = null; + this.pictureBox2.Name = "pictureBox2"; + this.pictureBox2.TabStop = false; + // + // mapInitCheckBox + // + this.mapInitCheckBox.AccessibleDescription = null; + this.mapInitCheckBox.AccessibleName = null; + resources.ApplyResources(this.mapInitCheckBox, "mapInitCheckBox"); + this.mapInitCheckBox.BackgroundImage = null; + this.mapInitCheckBox.Font = null; + this.mapInitCheckBox.Name = "mapInitCheckBox"; + this.mapInitCheckBox.UseVisualStyleBackColor = true; + this.mapInitCheckBox.CheckedChanged += new System.EventHandler(this.check_mapInit); + // + // label3 + // + this.label3.AccessibleDescription = null; + this.label3.AccessibleName = null; + resources.ApplyResources(this.label3, "label3"); + this.label3.Font = null; + this.label3.Name = "label3"; + // + // mapGeneratorMaskedTextBox + // + this.mapGeneratorMaskedTextBox.AccessibleDescription = null; + this.mapGeneratorMaskedTextBox.AccessibleName = null; + resources.ApplyResources(this.mapGeneratorMaskedTextBox, "mapGeneratorMaskedTextBox"); + this.mapGeneratorMaskedTextBox.BackgroundImage = null; + this.mapGeneratorMaskedTextBox.Name = "mapGeneratorMaskedTextBox"; + // + // label25 + // + this.label25.AccessibleDescription = null; + this.label25.AccessibleName = null; + resources.ApplyResources(this.label25, "label25"); + this.label25.Font = null; + this.label25.Name = "label25"; + // + // mapGeneratorButton + // + this.mapGeneratorButton.AccessibleDescription = null; + this.mapGeneratorButton.AccessibleName = null; + resources.ApplyResources(this.mapGeneratorButton, "mapGeneratorButton"); + this.mapGeneratorButton.BackgroundImage = null; + this.mapGeneratorButton.Font = null; + this.mapGeneratorButton.Name = "mapGeneratorButton"; + this.mapGeneratorButton.UseVisualStyleBackColor = true; + this.mapGeneratorButton.Click += new System.EventHandler(this.button_generateMapInit); + // + // groupBox1 + // + this.groupBox1.AccessibleDescription = null; + this.groupBox1.AccessibleName = null; + resources.ApplyResources(this.groupBox1, "groupBox1"); + this.groupBox1.BackgroundImage = null; + this.groupBox1.Controls.Add(this.pictureBox1); + this.groupBox1.Controls.Add(this.roundsNumericUpDown); + this.groupBox1.Controls.Add(this.label24); + this.groupBox1.Controls.Add(this.loopsNumericUpDown); + this.groupBox1.Controls.Add(this.label2); + this.groupBox1.Controls.Add(this.label23); + this.groupBox1.Font = null; + this.groupBox1.Name = "groupBox1"; + this.groupBox1.TabStop = false; + // + // pictureBox1 + // + this.pictureBox1.AccessibleDescription = null; + this.pictureBox1.AccessibleName = null; + resources.ApplyResources(this.pictureBox1, "pictureBox1"); + this.pictureBox1.BackgroundImage = null; + this.pictureBox1.Font = null; + this.pictureBox1.Image = global::AntMe.Plugin.Simulation.Properties.Resources.duration_32x32; + this.pictureBox1.ImageLocation = null; + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.TabStop = false; + // + // roundsNumericUpDown + // + this.roundsNumericUpDown.AccessibleDescription = null; + this.roundsNumericUpDown.AccessibleName = null; + resources.ApplyResources(this.roundsNumericUpDown, "roundsNumericUpDown"); + this.roundsNumericUpDown.Font = null; + this.roundsNumericUpDown.Minimum = new decimal(new int[] { + 1, + 0, + 0, + 0}); + this.roundsNumericUpDown.Name = "roundsNumericUpDown"; + this.roundsNumericUpDown.Value = new decimal(new int[] { + 1, + 0, + 0, + 0}); + // + // label24 + // + this.label24.AccessibleDescription = null; + this.label24.AccessibleName = null; + resources.ApplyResources(this.label24, "label24"); + this.label24.Font = null; + this.label24.Name = "label24"; + // + // loopsNumericUpDown + // + this.loopsNumericUpDown.AccessibleDescription = null; + this.loopsNumericUpDown.AccessibleName = null; + resources.ApplyResources(this.loopsNumericUpDown, "loopsNumericUpDown"); + this.loopsNumericUpDown.Font = null; + this.loopsNumericUpDown.Minimum = new decimal(new int[] { + 1, + 0, + 0, + 0}); + this.loopsNumericUpDown.Name = "loopsNumericUpDown"; + this.loopsNumericUpDown.Value = new decimal(new int[] { + 1, + 0, + 0, + 0}); + // + // label2 + // + this.label2.AccessibleDescription = null; + this.label2.AccessibleName = null; + resources.ApplyResources(this.label2, "label2"); + this.label2.Font = null; + this.label2.Name = "label2"; + // + // label23 + // + this.label23.AccessibleDescription = null; + this.label23.AccessibleName = null; + resources.ApplyResources(this.label23, "label23"); + this.label23.Font = null; + this.label23.Name = "label23"; + // + // debugTab + // + this.debugTab.AccessibleDescription = null; + this.debugTab.AccessibleName = null; + resources.ApplyResources(this.debugTab, "debugTab"); + this.debugTab.BackgroundImage = null; + this.debugTab.Controls.Add(this.groupBox4); + this.debugTab.Controls.Add(this.groupBox3); + this.debugTab.Font = null; + this.debugTab.Name = "debugTab"; + this.debugTab.UseVisualStyleBackColor = true; + // + // groupBox4 + // + this.groupBox4.AccessibleDescription = null; + this.groupBox4.AccessibleName = null; + resources.ApplyResources(this.groupBox4, "groupBox4"); + this.groupBox4.BackgroundImage = null; + this.groupBox4.Controls.Add(this.pictureBox3); + this.groupBox4.Controls.Add(this.label1); + this.groupBox4.Controls.Add(this.debugInfoCheckBox); + this.groupBox4.Font = null; + this.groupBox4.Name = "groupBox4"; + this.groupBox4.TabStop = false; + // + // pictureBox3 + // + this.pictureBox3.AccessibleDescription = null; + this.pictureBox3.AccessibleName = null; + resources.ApplyResources(this.pictureBox3, "pictureBox3"); + this.pictureBox3.BackgroundImage = null; + this.pictureBox3.Font = null; + this.pictureBox3.Image = global::AntMe.Plugin.Simulation.Properties.Resources.debug_messages_32x32; + this.pictureBox3.ImageLocation = null; + this.pictureBox3.Name = "pictureBox3"; + this.pictureBox3.TabStop = false; + // + // label1 + // + this.label1.AccessibleDescription = null; + this.label1.AccessibleName = null; + resources.ApplyResources(this.label1, "label1"); + this.label1.Font = null; + this.label1.Name = "label1"; + // + // debugInfoCheckBox + // + this.debugInfoCheckBox.AccessibleDescription = null; + this.debugInfoCheckBox.AccessibleName = null; + resources.ApplyResources(this.debugInfoCheckBox, "debugInfoCheckBox"); + this.debugInfoCheckBox.BackgroundImage = null; + this.debugInfoCheckBox.Font = null; + this.debugInfoCheckBox.Name = "debugInfoCheckBox"; + this.debugInfoCheckBox.UseVisualStyleBackColor = true; + // + // groupBox3 + // + this.groupBox3.AccessibleDescription = null; + this.groupBox3.AccessibleName = null; + resources.ApplyResources(this.groupBox3, "groupBox3"); + this.groupBox3.BackgroundImage = null; + this.groupBox3.Controls.Add(this.pictureBox4); + this.groupBox3.Controls.Add(this.label10); + this.groupBox3.Controls.Add(this.label9); + this.groupBox3.Controls.Add(this.label4); + this.groupBox3.Controls.Add(this.roundTimeoutNumericUpDown); + this.groupBox3.Controls.Add(this.label27); + this.groupBox3.Controls.Add(this.loopTimeoutNumericUpDown); + this.groupBox3.Controls.Add(this.label26); + this.groupBox3.Controls.Add(this.ignoreTimeoutsCheckBox); + this.groupBox3.Font = null; + this.groupBox3.Name = "groupBox3"; + this.groupBox3.TabStop = false; + // + // pictureBox4 + // + this.pictureBox4.AccessibleDescription = null; + this.pictureBox4.AccessibleName = null; + resources.ApplyResources(this.pictureBox4, "pictureBox4"); + this.pictureBox4.BackgroundImage = null; + this.pictureBox4.Font = null; + this.pictureBox4.Image = global::AntMe.Plugin.Simulation.Properties.Resources.timeout_32x32; + this.pictureBox4.ImageLocation = null; + this.pictureBox4.Name = "pictureBox4"; + this.pictureBox4.TabStop = false; + // + // label10 + // + this.label10.AccessibleDescription = null; + this.label10.AccessibleName = null; + resources.ApplyResources(this.label10, "label10"); + this.label10.Font = null; + this.label10.Name = "label10"; + // + // label9 + // + this.label9.AccessibleDescription = null; + this.label9.AccessibleName = null; + resources.ApplyResources(this.label9, "label9"); + this.label9.Font = null; + this.label9.Name = "label9"; + // + // label4 + // + this.label4.AccessibleDescription = null; + this.label4.AccessibleName = null; + resources.ApplyResources(this.label4, "label4"); + this.label4.Font = null; + this.label4.Name = "label4"; + // + // roundTimeoutNumericUpDown + // + this.roundTimeoutNumericUpDown.AccessibleDescription = null; + this.roundTimeoutNumericUpDown.AccessibleName = null; + resources.ApplyResources(this.roundTimeoutNumericUpDown, "roundTimeoutNumericUpDown"); + this.roundTimeoutNumericUpDown.Font = null; + this.roundTimeoutNumericUpDown.Minimum = new decimal(new int[] { + 1, + 0, + 0, + 0}); + this.roundTimeoutNumericUpDown.Name = "roundTimeoutNumericUpDown"; + this.roundTimeoutNumericUpDown.Value = new decimal(new int[] { + 1, + 0, + 0, + 0}); + // + // label27 + // + this.label27.AccessibleDescription = null; + this.label27.AccessibleName = null; + resources.ApplyResources(this.label27, "label27"); + this.label27.Font = null; + this.label27.Name = "label27"; + // + // loopTimeoutNumericUpDown + // + this.loopTimeoutNumericUpDown.AccessibleDescription = null; + this.loopTimeoutNumericUpDown.AccessibleName = null; + resources.ApplyResources(this.loopTimeoutNumericUpDown, "loopTimeoutNumericUpDown"); + this.loopTimeoutNumericUpDown.Font = null; + this.loopTimeoutNumericUpDown.Minimum = new decimal(new int[] { + 1, + 0, + 0, + 0}); + this.loopTimeoutNumericUpDown.Name = "loopTimeoutNumericUpDown"; + this.loopTimeoutNumericUpDown.Value = new decimal(new int[] { + 1, + 0, + 0, + 0}); + // + // label26 + // + this.label26.AccessibleDescription = null; + this.label26.AccessibleName = null; + resources.ApplyResources(this.label26, "label26"); + this.label26.Font = null; + this.label26.Name = "label26"; + // + // ignoreTimeoutsCheckBox + // + this.ignoreTimeoutsCheckBox.AccessibleDescription = null; + this.ignoreTimeoutsCheckBox.AccessibleName = null; + resources.ApplyResources(this.ignoreTimeoutsCheckBox, "ignoreTimeoutsCheckBox"); + this.ignoreTimeoutsCheckBox.BackgroundImage = null; + this.ignoreTimeoutsCheckBox.Font = null; + this.ignoreTimeoutsCheckBox.Name = "ignoreTimeoutsCheckBox"; + this.ignoreTimeoutsCheckBox.UseVisualStyleBackColor = true; + this.ignoreTimeoutsCheckBox.CheckedChanged += new System.EventHandler(this.check_timeouts); + // + // securityTab + // + this.securityTab.AccessibleDescription = null; + this.securityTab.AccessibleName = null; + resources.ApplyResources(this.securityTab, "securityTab"); + this.securityTab.BackgroundImage = null; + this.securityTab.Controls.Add(this.groupBox5); + this.securityTab.Font = null; + this.securityTab.Name = "securityTab"; + this.securityTab.UseVisualStyleBackColor = true; + // + // groupBox5 + // + this.groupBox5.AccessibleDescription = null; + this.groupBox5.AccessibleName = null; + resources.ApplyResources(this.groupBox5, "groupBox5"); + this.groupBox5.BackgroundImage = null; + this.groupBox5.Controls.Add(this.allowNetworkCheckBox); + this.groupBox5.Controls.Add(this.pictureBox5); + this.groupBox5.Controls.Add(this.label5); + this.groupBox5.Controls.Add(this.allowRefCheckBox); + this.groupBox5.Controls.Add(this.allowUiCheckBox); + this.groupBox5.Controls.Add(this.allowIoCheckBox); + this.groupBox5.Controls.Add(this.allowDbCheckBox); + this.groupBox5.Font = null; + this.groupBox5.Name = "groupBox5"; + this.groupBox5.TabStop = false; + // + // allowNetworkCheckBox + // + this.allowNetworkCheckBox.AccessibleDescription = null; + this.allowNetworkCheckBox.AccessibleName = null; + resources.ApplyResources(this.allowNetworkCheckBox, "allowNetworkCheckBox"); + this.allowNetworkCheckBox.BackgroundImage = null; + this.allowNetworkCheckBox.Font = null; + this.allowNetworkCheckBox.Name = "allowNetworkCheckBox"; + this.allowNetworkCheckBox.UseVisualStyleBackColor = true; + // + // pictureBox5 + // + this.pictureBox5.AccessibleDescription = null; + this.pictureBox5.AccessibleName = null; + resources.ApplyResources(this.pictureBox5, "pictureBox5"); + this.pictureBox5.BackgroundImage = null; + this.pictureBox5.Font = null; + this.pictureBox5.Image = global::AntMe.Plugin.Simulation.Properties.Resources.security_32x32; + this.pictureBox5.ImageLocation = null; + this.pictureBox5.Name = "pictureBox5"; + this.pictureBox5.TabStop = false; + // + // label5 + // + this.label5.AccessibleDescription = null; + this.label5.AccessibleName = null; + resources.ApplyResources(this.label5, "label5"); + this.label5.Font = null; + this.label5.Name = "label5"; + // + // allowRefCheckBox + // + this.allowRefCheckBox.AccessibleDescription = null; + this.allowRefCheckBox.AccessibleName = null; + resources.ApplyResources(this.allowRefCheckBox, "allowRefCheckBox"); + this.allowRefCheckBox.BackgroundImage = null; + this.allowRefCheckBox.Font = null; + this.allowRefCheckBox.Name = "allowRefCheckBox"; + this.allowRefCheckBox.UseVisualStyleBackColor = true; + // + // allowUiCheckBox + // + this.allowUiCheckBox.AccessibleDescription = null; + this.allowUiCheckBox.AccessibleName = null; + resources.ApplyResources(this.allowUiCheckBox, "allowUiCheckBox"); + this.allowUiCheckBox.BackgroundImage = null; + this.allowUiCheckBox.Font = null; + this.allowUiCheckBox.Name = "allowUiCheckBox"; + this.allowUiCheckBox.UseVisualStyleBackColor = true; + // + // allowIoCheckBox + // + this.allowIoCheckBox.AccessibleDescription = null; + this.allowIoCheckBox.AccessibleName = null; + resources.ApplyResources(this.allowIoCheckBox, "allowIoCheckBox"); + this.allowIoCheckBox.BackgroundImage = null; + this.allowIoCheckBox.Font = null; + this.allowIoCheckBox.Name = "allowIoCheckBox"; + this.allowIoCheckBox.UseVisualStyleBackColor = true; + // + // allowDbCheckBox + // + this.allowDbCheckBox.AccessibleDescription = null; + this.allowDbCheckBox.AccessibleName = null; + resources.ApplyResources(this.allowDbCheckBox, "allowDbCheckBox"); + this.allowDbCheckBox.BackgroundImage = null; + this.allowDbCheckBox.Font = null; + this.allowDbCheckBox.Name = "allowDbCheckBox"; + this.allowDbCheckBox.UseVisualStyleBackColor = true; + // + // settingsTab + // + this.settingsTab.AccessibleDescription = null; + this.settingsTab.AccessibleName = null; + resources.ApplyResources(this.settingsTab, "settingsTab"); + this.settingsTab.BackgroundImage = null; + this.settingsTab.Controls.Add(this.groupBox6); + this.settingsTab.Font = null; + this.settingsTab.Name = "settingsTab"; + this.settingsTab.UseVisualStyleBackColor = true; + // + // groupBox6 + // + this.groupBox6.AccessibleDescription = null; + this.groupBox6.AccessibleName = null; + resources.ApplyResources(this.groupBox6, "groupBox6"); + this.groupBox6.BackgroundImage = null; + this.groupBox6.Controls.Add(this.label6); + this.groupBox6.Controls.Add(this.label8); + this.groupBox6.Controls.Add(this.presetComboBox); + this.groupBox6.Controls.Add(this.label7); + this.groupBox6.Controls.Add(this.settingCreateButton); + this.groupBox6.Controls.Add(this.settingLoadButton); + this.groupBox6.Font = null; + this.groupBox6.Name = "groupBox6"; + this.groupBox6.TabStop = false; + // + // label6 + // + this.label6.AccessibleDescription = null; + this.label6.AccessibleName = null; + resources.ApplyResources(this.label6, "label6"); + this.label6.Font = null; + this.label6.Name = "label6"; + // + // label8 + // + this.label8.AccessibleDescription = null; + this.label8.AccessibleName = null; + resources.ApplyResources(this.label8, "label8"); + this.label8.Font = null; + this.label8.Name = "label8"; + // + // presetComboBox + // + this.presetComboBox.AccessibleDescription = null; + this.presetComboBox.AccessibleName = null; + resources.ApplyResources(this.presetComboBox, "presetComboBox"); + this.presetComboBox.BackgroundImage = null; + this.presetComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.presetComboBox.Font = null; + this.presetComboBox.FormattingEnabled = true; + this.presetComboBox.Name = "presetComboBox"; + // + // label7 + // + this.label7.AccessibleDescription = null; + this.label7.AccessibleName = null; + resources.ApplyResources(this.label7, "label7"); + this.label7.Font = null; + this.label7.Name = "label7"; + // + // settingCreateButton + // + this.settingCreateButton.AccessibleDescription = null; + this.settingCreateButton.AccessibleName = null; + resources.ApplyResources(this.settingCreateButton, "settingCreateButton"); + this.settingCreateButton.BackgroundImage = null; + this.settingCreateButton.Font = null; + this.settingCreateButton.Name = "settingCreateButton"; + this.settingCreateButton.UseVisualStyleBackColor = true; + this.settingCreateButton.Click += new System.EventHandler(this.settingCreateButton_Click); + // + // settingLoadButton + // + this.settingLoadButton.AccessibleDescription = null; + this.settingLoadButton.AccessibleName = null; + resources.ApplyResources(this.settingLoadButton, "settingLoadButton"); + this.settingLoadButton.BackgroundImage = null; + this.settingLoadButton.Font = null; + this.settingLoadButton.Name = "settingLoadButton"; + this.settingLoadButton.UseVisualStyleBackColor = true; + this.settingLoadButton.Click += new System.EventHandler(this.button_loadSettings); + // + // openFileDialog + // + this.openFileDialog.DefaultExt = "ant.config"; + resources.ApplyResources(this.openFileDialog, "openFileDialog"); + // + // saveFileDialog + // + this.saveFileDialog.DefaultExt = "ant.config"; + resources.ApplyResources(this.saveFileDialog, "saveFileDialog"); + // + // SimulationProperties + // + this.AcceptButton = this.okButton; + this.AccessibleDescription = null; + this.AccessibleName = null; + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackgroundImage = null; + this.CancelButton = this.cancelButton; + this.Controls.Add(this.tabControl); + this.Controls.Add(this.cancelButton); + this.Controls.Add(this.okButton); + this.Font = null; + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = null; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "SimulationProperties"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.form_closing); + this.tabControl.ResumeLayout(false); + this.mapTab.ResumeLayout(false); + this.groupBox2.ResumeLayout(false); + this.groupBox2.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).EndInit(); + this.groupBox1.ResumeLayout(false); + this.groupBox1.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.roundsNumericUpDown)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.loopsNumericUpDown)).EndInit(); + this.debugTab.ResumeLayout(false); + this.groupBox4.ResumeLayout(false); + this.groupBox4.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox3)).EndInit(); + this.groupBox3.ResumeLayout(false); + this.groupBox3.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox4)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.roundTimeoutNumericUpDown)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.loopTimeoutNumericUpDown)).EndInit(); + this.securityTab.ResumeLayout(false); + this.groupBox5.ResumeLayout(false); + this.groupBox5.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox5)).EndInit(); + this.settingsTab.ResumeLayout(false); + this.groupBox6.ResumeLayout(false); + this.groupBox6.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button okButton; + private System.Windows.Forms.Button cancelButton; + private System.Windows.Forms.TabControl tabControl; + private System.Windows.Forms.TabPage settingsTab; + private System.Windows.Forms.TabPage securityTab; + private System.Windows.Forms.TabPage debugTab; + private System.Windows.Forms.TabPage mapTab; + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.NumericUpDown roundsNumericUpDown; + private System.Windows.Forms.Label label24; + private System.Windows.Forms.NumericUpDown loopsNumericUpDown; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label23; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.MaskedTextBox mapGeneratorMaskedTextBox; + private System.Windows.Forms.Button mapGeneratorButton; + private System.Windows.Forms.Label label25; + private System.Windows.Forms.GroupBox groupBox2; + private System.Windows.Forms.GroupBox groupBox3; + private System.Windows.Forms.Label label27; + private System.Windows.Forms.Label label26; + private System.Windows.Forms.CheckBox ignoreTimeoutsCheckBox; + private System.Windows.Forms.CheckBox debugInfoCheckBox; + private System.Windows.Forms.NumericUpDown loopTimeoutNumericUpDown; + private System.Windows.Forms.NumericUpDown roundTimeoutNumericUpDown; + private System.Windows.Forms.GroupBox groupBox4; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.GroupBox groupBox5; + private System.Windows.Forms.CheckBox allowRefCheckBox; + private System.Windows.Forms.CheckBox allowUiCheckBox; + private System.Windows.Forms.CheckBox allowIoCheckBox; + private System.Windows.Forms.CheckBox allowDbCheckBox; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.GroupBox groupBox6; + private System.Windows.Forms.Button settingCreateButton; + private System.Windows.Forms.Button settingLoadButton; + private System.Windows.Forms.Label label7; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.Label label8; + private System.Windows.Forms.ComboBox presetComboBox; + private System.Windows.Forms.OpenFileDialog openFileDialog; + private System.Windows.Forms.CheckBox mapInitCheckBox; + private System.Windows.Forms.Label label10; + private System.Windows.Forms.Label label9; + private System.Windows.Forms.PictureBox pictureBox1; + private System.Windows.Forms.PictureBox pictureBox2; + private System.Windows.Forms.PictureBox pictureBox3; + private System.Windows.Forms.PictureBox pictureBox4; + private System.Windows.Forms.PictureBox pictureBox5; + private System.Windows.Forms.SaveFileDialog saveFileDialog; + private System.Windows.Forms.CheckBox allowNetworkCheckBox; + } +} diff --git a/SimulationPlugin/SimulationProperties.cs b/SimulationPlugin/SimulationProperties.cs new file mode 100644 index 0000000..425a27d --- /dev/null +++ b/SimulationPlugin/SimulationProperties.cs @@ -0,0 +1,227 @@ +using System; +using System.Windows.Forms; + +using AntMe.Simulation; +using System.Collections.Generic; +using System.IO; + +namespace AntMe.Plugin.Simulation { + internal sealed partial class SimulationProperties : Form { + private readonly SimulationPluginConfiguration config; + + public SimulationProperties(SimulationPluginConfiguration configuration) { + config = configuration; + InitializeComponent(); + + fillControls(); + } + + private void fillControls() { + #region Game-Settings + + // Limits + roundsNumericUpDown.Minimum = SimulatorConfiguration.ROUNDSMIN; + roundsNumericUpDown.Maximum = SimulatorConfiguration.ROUNDSMAX; + loopsNumericUpDown.Minimum = SimulatorConfiguration.LOOPSMIN; + loopsNumericUpDown.Maximum = SimulatorConfiguration.LOOPSMAX; + + // Values + roundsNumericUpDown.Value = config.configuration.RoundCount; + loopsNumericUpDown.Value = config.configuration.LoopCount; + + int initValue = Math.Abs(config.configuration.MapInitialValue); + mapInitCheckBox.Checked = (initValue != 0); + check_mapInit(null, null); + mapGeneratorMaskedTextBox.Text = initValue.ToString("000000000"); + + #endregion + + #region Debug and Timeouts + + // Limits + loopTimeoutNumericUpDown.Minimum = SimulatorConfiguration.LOOPTIMEOUTMIN; + loopTimeoutNumericUpDown.Maximum = int.MaxValue; + roundTimeoutNumericUpDown.Minimum = SimulatorConfiguration.ROUNDTIMEOUTMIN; + roundTimeoutNumericUpDown.Maximum = int.MaxValue; + + // Values + debugInfoCheckBox.Checked = config.configuration.AllowDebuginformation; + check_timeouts(null, null); + ignoreTimeoutsCheckBox.Checked = config.configuration.IgnoreTimeouts; + loopTimeoutNumericUpDown.Value = config.configuration.LoopTimeout; + roundTimeoutNumericUpDown.Value = config.configuration.RoundTimeout; + + #endregion + + #region Security + + // Values + allowIoCheckBox.Checked = config.configuration.AllowFileAccess; + allowDbCheckBox.Checked = config.configuration.AllowDatabaseAccess; + allowUiCheckBox.Checked = config.configuration.AllowUserinterfaceAccess; + allowRefCheckBox.Checked = config.configuration.AllowReferences; + allowNetworkCheckBox.Checked = config.configuration.AllowNetworkAccess; + + #endregion + + #region Core-Settings + + // Set Default + presetComboBox.Items.Add(SimulationSettings.Default); + + // Other Presets + using (var stream = new MemoryStream(Presets.CaptureTheApple)) + presetComboBox.Items.Add(SimulationSettings.LoadSettings(stream)); + using (var stream = new MemoryStream(Presets.Debugging)) + presetComboBox.Items.Add(SimulationSettings.LoadSettings(stream)); + using (var stream = new MemoryStream(Presets.Heros)) + presetComboBox.Items.Add(SimulationSettings.LoadSettings(stream)); + using (var stream = new MemoryStream(Presets.SugarRun)) + presetComboBox.Items.Add(SimulationSettings.LoadSettings(stream)); + using (var stream = new MemoryStream(Presets.SurvivalOfTheFittest)) + presetComboBox.Items.Add(SimulationSettings.LoadSettings(stream)); + + // Enumerate all known settingsfiles and add them to the combobox + List lostSettingsFiles = new List(); + foreach (string knownSettingFile in config.knownSettingFiles) { + try { + SimulationSettings settings = SimulationSettings.LoadSettings(knownSettingFile); + presetComboBox.Items.Add(settings); + } + catch (Exception) { + // TODO: Lokalisieren + MessageBox.Show("Fehler beim Laden der Settings-Datei " + knownSettingFile + ". Diese Datei wird aus der Liste der bekannten Settings entfernt."); + lostSettingsFiles.Add(knownSettingFile); + } + } + + // Remove all lost settingsfiles + foreach (string lostSettingsFile in lostSettingsFiles) { + config.knownSettingFiles.Remove(lostSettingsFile); + } + + // Preselect current settings + presetComboBox.SelectedItem = config.configuration.Settings; + + #endregion + } + + private void readControls() { + #region Game-Settings + + config.configuration.RoundCount = (int) roundsNumericUpDown.Value; + config.configuration.LoopCount = (int) loopsNumericUpDown.Value; + + config.configuration.MapInitialValue = 0; + if (mapInitCheckBox.Checked) { + config.configuration.MapInitialValue = int.Parse(mapGeneratorMaskedTextBox.Text); + } + + #endregion + + #region Debug and Timeouts + + config.configuration.AllowDebuginformation = debugInfoCheckBox.Checked; + config.configuration.IgnoreTimeouts = ignoreTimeoutsCheckBox.Checked; + config.configuration.LoopTimeout = (int) loopTimeoutNumericUpDown.Value; + config.configuration.RoundTimeout = (int) roundTimeoutNumericUpDown.Value; + + #endregion + + #region Security + + config.configuration.AllowFileAccess = allowIoCheckBox.Checked; + config.configuration.AllowDatabaseAccess = allowDbCheckBox.Checked; + config.configuration.AllowUserinterfaceAccess = allowUiCheckBox.Checked; + config.configuration.AllowReferences = allowRefCheckBox.Checked; + config.configuration.AllowNetworkAccess = allowNetworkCheckBox.Checked; + + #endregion + + #region Core-Settings + + // Set selected Setting + if (presetComboBox.SelectedIndex > -1) { + SimulationSettings selectedSettings = (SimulationSettings) presetComboBox.SelectedItem; + if (!selectedSettings.Equals(config.configuration.Settings)) { + SimulationSettings.SetCustomSettings(selectedSettings); + config.configuration.Settings = selectedSettings; + } + } + + #endregion + } + + private void form_closing(object sender, FormClosingEventArgs e) { + if (DialogResult == DialogResult.OK) { + readControls(); + } + } + + private void button_generateMapInit(object sender, EventArgs e) { + Random rand = new Random(); + mapGeneratorMaskedTextBox.Text = rand.Next(1, 999999999).ToString("000000000"); + } + + private void check_mapInit(object sender, EventArgs e) { + if (mapInitCheckBox.Checked) { + mapGeneratorMaskedTextBox.Enabled = true; + mapGeneratorButton.Enabled = true; + } + else { + mapGeneratorMaskedTextBox.Enabled = false; + mapGeneratorButton.Enabled = false; + } + } + + private void check_timeouts(object sender, EventArgs e) { + if (ignoreTimeoutsCheckBox.Checked) { + roundTimeoutNumericUpDown.Enabled = false; + loopTimeoutNumericUpDown.Enabled = false; + } + else { + roundTimeoutNumericUpDown.Enabled = true; + loopTimeoutNumericUpDown.Enabled = true; + } + } + + private void button_loadSettings(object sender, EventArgs e) { + if (openFileDialog.ShowDialog(this) == DialogResult.OK) { + string filename = openFileDialog.FileName; + + // Try to load this settings + try { + SimulationSettings setting = SimulationSettings.LoadSettings(filename); + setting.RuleCheck(); + + // Add to list + if (!config.knownSettingFiles.Contains(filename.ToLower())) { + config.knownSettingFiles.Add(filename.ToLower()); + presetComboBox.Items.Add(setting); + presetComboBox.SelectedItem = setting; + } + } + catch (Exception ex) { + // TODO: Make that right + MessageBox.Show(ex.Message); + } + } + } + + private void settingCreateButton_Click(object sender, EventArgs e) { + if (saveFileDialog.ShowDialog(this) == DialogResult.OK) { + string filename = saveFileDialog.FileName; + + try { + SimulationSettings settings = SimulationSettings.Default; + settings.Guid = Guid.NewGuid(); + SimulationSettings.SaveSettings(settings, filename); + } + catch (Exception ex) { + // TODO: Make that right + MessageBox.Show(ex.Message); + } + } + } + } +} \ No newline at end of file diff --git a/SimulationPlugin/SimulationProperties.de.resx b/SimulationPlugin/SimulationProperties.de.resx new file mode 100644 index 0000000..f30cfcb --- /dev/null +++ b/SimulationPlugin/SimulationProperties.de.resx @@ -0,0 +1,276 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Abbrechen + + + Spieleinstellungen + + + Kartengenerierung + + + + 257, 17 + + + Verwende einen Initialwert zur Kartengenerierung + + + Normalerweise werden die Karten einer Simulation auf Basis eines Zufallsgenerators erstellt. Es gibts aber Situationen, da macht es Sinn vergleichbare Karten in verschiedenen Simulationen zu haben - für Debug- und Vergleichszwecke zum Beipsiel. + + + 54, 13 + + + Initialwert: + + + Generieren + + + Simulationsdauer + + + 48, 131 + + + 62, 13 + + + Durchläufe: + + + Hier kannst du einstellen wie viele Runden eine Simulation dauern soll. Zudem lässt sich hier auch festlegen, wie oft eine Simulation wiederholt werden soll. + + + 62, 105 + + + 48, 13 + + + Runden: + + + Debug und Zeitlimits + + + Debugnachrichten + + + Um Fehler im Verhalten der Ameisen zu finden kann es manchmal nützlich sein, nachvollziehen zu können was in der Simulation so alles passiert ist. Ist der folgende Haken gesetzt, werden diese Informationen für Auswertungen gesammelt. + + + 251, 17 + + + Sammle Debuginformationen der Ameisenvölker + + + Zeitlimits + + + Lege hier die maximale Wartezeit für Runden und Simulationsdurchläufe fest, bevor eine Simulation automatisch abgebrochen wird. + + + 52, 183 + + + 80, 13 + + + Durchlauf-Limit: + + + 67, 157 + + + 65, 13 + + + Rundenlimit: + + + 110, 17 + + + Ignoriere Zeitlimits + + + Sicherheit + + + Unter normalen Umständen werden alle Ameisenvölker unter strengen Sicherheitseinschränkungen simuliert, um größte Sicherheit zu gewährleisten. Manche Ameisen benötigen aber eventuell Zugriff auf bestimme Ressourcen um richtig zu funktionieren. Sie benötigen vielleicht Zugriff auf das Dateisystem oder zu Datenbanken. Sollte ein Ameisenvolk solche speziellen Zugriffsrechte benötigen, wird das in der Volkübersicht mit einem Vorhängeschloss gekennzeichnet. + +Solltest du in deiner Simulation Ameisen verwenden, die besondere Zugriffsrechte bekommen sollen, so kannst das mit den folgenden Optionen aktivieren. + + + 175, 17 + + + Erlaube zusätzliche Referenzen + + + 246, 17 + + + Erlaube den Zugriff auf die Benutzeroberfläche + + + 174, 17 + + + Erlaube den Zugriff auf Dateien + + + 202, 17 + + + Erlaube den Zugriff auf Datenbanken + + + Kern-Einstellungen + + + Kern-Einstellungen + + + Um eine neue Einstellungsdatei zu erzeugen verwende den Knopf "Einstellungsdatei erzeugen". Die daraufhin erstellte Datei kann mit einem XML-Editor oder Notepad bearbeitet werden. + + + 89, 13 + + + Einstellungsdatei: + + + Die Kern-Einstellungen enthalten Grundeinstellungen der Simulation. Darin enthalten sind Rahmenparameter der Physik bis hin zur Angabe der maximalen Anzahl der Ameisen pro Simulation. + + + Einstellungsdatei erzeugen + + + Laden + + + Simulationseinstellungen + + \ No newline at end of file diff --git a/SimulationPlugin/SimulationProperties.resx b/SimulationPlugin/SimulationProperties.resx new file mode 100644 index 0000000..e578a0e --- /dev/null +++ b/SimulationPlugin/SimulationProperties.resx @@ -0,0 +1,1445 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + groupBox6 + + + 0 + + + + NoControl + + + System.Windows.Forms.NumericUpDown, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + True + + + 2 + + + 0 + + + + 58, 20 + + + pictureBox3 + + + Under normal circumstances simulations are running in a highly restriced environment to ensure the safety of the simulating computer. There are situations, however, where it might be necessary to grant access to resources such as a database or the file system. If an ant requires access to such special resources, you can see this in the ant's properties. + +In case you want to use such an ant in your simulation, you can specify the desired access-permissions here. + + + label10 + + + True + + + 30, 160 + + + System.Windows.Forms.GroupBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 4 + + + 3 + + + 0 + + + 2 + + + 330, 203 + + + 15, 25 + + + groupBox1 + + + 1 + + + 1 + + + 8 + + + 0 + + + groupBox6 + + + 1 + + + 411, 420 + + + Map value: + + + groupBox6 + + + groupBox2 + + + 18, 138 + + + Top, Bottom, Left, Right + + + label5 + + + 4 + + + 30, 310 + + + 2 + + + 4 + + + groupBox3 + + + True + + + 0 + + + 4 + + + CenterParent + + + 426, 484 + + + 000000000 + + + tabControl + + + loopsNumericUpDown + + + Bottom, Right + + + 3 + + + 343, 457 + + + groupBox5 + + + label8 + + + Top, Bottom, Left, Right + + + 0 + + + AntMe! CoreSettings|*.ant.config + + + SimulationProperties + + + 58, 20 + + + 4 + + + 5 + + + 1 + + + 7 + + + System.Windows.Forms.NumericUpDown, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + allowRefCheckBox + + + 411, 420 + + + 262, 457 + + + 419, 446 + + + groupBox3 + + + 5 + + + groupBox3 + + + 0 + + + 3 + + + 30, 343 + + + 3 + + + 172, 17 + + + 4 + + + 1 + + + 3, 3 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 0 + + + 6 + + + Allow external assemblies + + + System.Windows.Forms.NumericUpDown, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 63, 105 + + + 368, 60 + + + 53, 25 + + + 2 + + + 8 + + + 39, 13 + + + 362, 21 + + + 116, 129 + + + 4 + + + Top, Bottom, Left, Right + + + 0 + + + 3, 3, 3, 3 + + + System.Windows.Forms.ComboBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + True + + + debugTab + + + 5 + + + System.Windows.Forms.TabPage, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 1 + + + 6 + + + Bottom, Right + + + True + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + settingCreateButton + + + groupBox3 + + + 91, 21 + + + 75, 23 + + + 18, 295 + + + 3 + + + Security + + + tabControl + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 322, 60 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + label25 + + + System.Windows.Forms.GroupBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 3 + + + 53, 25 + + + 2 + + + Cancel + + + 5 + + + System.Windows.Forms.GroupBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox5 + + + System.Windows.Forms.TabControl, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 1 + + + 1 + + + 75, 21 + + + 0 + + + 6 + + + groupBox6 + + + 75, 23 + + + 405, 190 + + + System.Windows.Forms.GroupBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 3 + + + Random + + + label24 + + + Rounds: + + + 145, 17 + + + mapTab + + + groupBox2 + + + roundsNumericUpDown + + + 30, 294 + + + 47, 13 + + + 3, 182 + + + True + + + 152, 17 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 30, 327 + + + 60, 13 + + + tabControl + + + groupBox1 + + + 2 + + + 116, 103 + + + True + + + System.Windows.Forms.OpenFileDialog, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 1 + + + 39, 13 + + + $this + + + 67, 13 + + + 47, 13 + + + 411, 420 + + + 145, 23 + + + saveFileDialog + + + groupBox2 + + + 121, 17 + + + 4, 22 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + label6 + + + 4 + + + label9 + + + 56, 25 + + + groupBox3 + + + allowIoCheckBox + + + label26 + + + groupBox5 + + + $this + + + 3, 3 + + + 220, 17 + + + loopTimeoutNumericUpDown + + + 4, 22 + + + 1 + + + tabControl + + + 138, 181 + + + AntMe! CoreSettings|*.ant.config + + + label27 + + + 3, 3 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + True + + + 145, 17 + + + 0 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Core-Settings hold the basic settings for the simulation-core. This includes the physic of the simulation and further stuff like the count of ants your colony can have. + + + groupBox1 + + + Duration + + + tabControl + + + 15, 25 + + + groupBox5 + + + 87, 157 + + + 0 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Collect debug information for ant-colonies + + + NoControl + + + groupBox5 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 0 + + + 1 + + + 95, 183 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Generating Maps + + + 5 + + + groupBox2 + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Game Settings + + + 32, 32 + + + 5 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox3 + + + System.Windows.Forms.GroupBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 0 + + + groupBox1 + + + 32, 32 + + + 0 + + + 0 + + + 3 + + + Usually the maps in AntMe! are autogenerated based on random values. This makes sure that every time you run a simulation there will be a new map, different from the previous one. Should you wish to use the same map in every simulation - which might be useful in debugging scenarios - switch on the initial value. This way, the same map will be regenerated each time. + + + ms + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Timeouts + + + mapTab + + + 402, 218 + + + groupBox1 + + + 191, 17 + + + 2 + + + label2 + + + groupBox2 + + + groupBox4 + + + label23 + + + Rounds: + + + mapInitCheckBox + + + allowDbCheckBox + + + 15, 25 + + + Debug Messages + + + 15, 25 + + + ignoreTimeoutsCheckBox + + + Allow access to files + + + Courier New, 9pt + + + 53, 25 + + + System.Windows.Forms.Form, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 3, 3 + + + 5 + + + settingsTab + + + groupBox3 + + + groupBox1 + + + 3, 3, 3, 3 + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 405, 235 + + + Loops: + + + groupBox6 + + + Security + + + System.Windows.Forms.TabPage, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 202, 183 + + + 2 + + + 0 + + + System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 20, 13 + + + 0 + + + 405, 173 + + + 4, 22 + + + True + + + mapTab + + + Use initial value for map-generation + + + Core Settings + + + 5 + + + roundTimeoutNumericUpDown + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox4 + + + 0 + + + debugInfoCheckBox + + + label3 + + + Top, Left, Right + + + 15, 222 + + + 405, 414 + + + 71, 131 + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + OK + + + 30, 117 + + + allowUiCheckBox + + + 3 + + + groupBox3 + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + groupBox6 + + + 202, 157 + + + 405, 414 + + + okButton + + + groupBox3 + + + 319, 82 + + + 2 + + + NoControl + + + Simulation Settings + + + groupBox6 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 0 + + + NoControl + + + mapGeneratorButton + + + 411, 420 + + + 6, 13 + + + settingLoadButton + + + 58, 20 + + + 53, 25 + + + False + + + debugTab + + + Top, Left, Right + + + 0 + + + label1 + + + 7 + + + 75, 23 + + + 1 + + + For debug reasons it might be interesting to get detailed information about what is happening in a single ant's life and how the ant has reacted. To collect this information enable the following option. + + + settingsTab + + + 15, 95 + + + 2 + + + groupBox5 + + + True + + + NoControl + + + groupBox4 + + + Top, Bottom, Left, Right + + + 332, 60 + + + 4 + + + 32, 32 + + + 1 + + + groupBox5 + + + 1 + + + Top, Left, Right + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 2 + + + 32, 32 + + + 1 + + + groupBox4 + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Top, Bottom, Left, Right + + + 0 + + + 32, 32 + + + True + + + securityTab + + + groupBox1 + + + System.Windows.Forms.SaveFileDialog, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.GroupBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Loops: + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 2 + + + groupBox5 + + + 0 + + + $this + + + 0 + + + 368, 60 + + + 2 + + + True + + + System.Windows.Forms.CheckBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + mapGeneratorMaskedTextBox + + + 6 + + + So create a new settings-file, you can use the create-button to save a setting-file with default-settings on disc. After that, you can edit this file with a XML-Editor. + + + 6 + + + Setting-Files: + + + Allow access to user interfaces + + + MiddleRight + + + 20, 13 + + + True + + + cancelButton + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 1 + + + groupBox2 + + + 18, 111 + + + 3 + + + 213, 156 + + + presetComboBox + + + 7 + + + 3, 5 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Debug and Timeout + + + True + + + label4 + + + pictureBox5 + + + 4, 22 + + + 102, 17 + + + 3 + + + 1 + + + 15, 25 + + + 1 + + + Set the number of rounds you want to simulate. If you need more than one simulation, set the loops to the desired value. + + + Here you can set timeouts for rounds and loops. + + + 30, 114 + + + allowNetworkCheckBox + + + 4 + + + groupBox3 + + + pictureBox4 + + + 329, 60 + + + openFileDialog + + + System.Windows.Forms.NumericUpDown, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ms + + + debugTab + + + 138, 155 + + + groupBox2 + + + pictureBox2 + + + Ignore Timeouts + + + System.Windows.Forms.TabPage, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.MaskedTextBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 1 + + + 1 + + + 2 + + + 3 + + + 30, 360 + + + Load + + + System.Windows.Forms.PictureBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 58, 20 + + + Create new Setting-File + + + 2 + + + True + + + System.Windows.Forms.TabPage, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 6 + + + Allow external assemblies + + + Core Settings + + + 15, 25 + + + True + + + pictureBox1 + + + 3, 199 + + + Allow access to databases + + + 116, 156 + + + 30, 125 + + + securityTab + + + label7 + + + True + + + 150, 17 + + + 17, 17 + + \ No newline at end of file diff --git a/SimulationPlugin/SimulatorPlugin.cs b/SimulationPlugin/SimulatorPlugin.cs new file mode 100644 index 0000000..ae8328c --- /dev/null +++ b/SimulationPlugin/SimulatorPlugin.cs @@ -0,0 +1,261 @@ +using System; +using System.IO; +using System.Reflection; +using System.Windows.Forms; +using System.Xml.Serialization; + +using AntMe.SharedComponents.Plugin; +using AntMe.SharedComponents.States; +using AntMe.Simulation; +using System.Collections.Generic; + +namespace AntMe.Plugin.Simulation { + /// + /// Plugin-Class to handle access to simulation-core. + /// + [Preselected] + public class SimulatorPlugin : IProducerPlugin { + private readonly string name = Resource.SimulatorPluginName; + private readonly string description = Resource.SimulatorPluginDescription; + private readonly Version version = Assembly.GetExecutingAssembly().GetName().Version; + private readonly Guid guid = new Guid("BC5609C4-AFEE-4ebe-B541-D00230349EAA"); + + private readonly TeamSetup teamSetup; + private SimulationPluginConfiguration config = new SimulationPluginConfiguration(); + private readonly List players = new List(); + private Simulator sim; + private bool paused; + + /// + /// Creates a new instance of this plugin. + /// + public SimulatorPlugin() { + teamSetup = new TeamSetup(config, players); + } + + #region IProducerPlugin Members + + /// + /// Gives the state of this plugin. + /// + public PluginState State { + get { + if (sim == null) { + int count = 0; + for (int i = 0; i < config.teams.Length; i++) { + count += config.teams[i].Players.Count; + } + + teamSetup.Active = false; + return count > 0 ? PluginState.Ready : PluginState.NotReady; + } + else { + teamSetup.Active = true; + return paused ? PluginState.Paused : PluginState.Running; + } + } + } + + /// + /// Gives the control for plugin-tab. + /// + public Control Control { + get { return teamSetup; } + } + + /// + /// Gets or sets the plugin-configuration. + /// + public byte[] Settings { + get { + + // Enumerate all known files to find outdated items without a relation to knownPlayers + List knownPlayer = new List(); + for (int i = 0; i < config.knownPlayerFiles.Count; i++) { + + try { + bool hit = false; + List result = AiAnalysis.Analyse(config.knownPlayerFiles[i]); + + // Enumerate included Player + foreach (PlayerInfo info in result) { + PlayerInfoFilename infoFile = new PlayerInfoFilename(info, config.knownPlayerFiles[i]); + if (config.knownPlayer.Contains(infoFile.GetHashCode())) { + hit = true; + } + knownPlayer.Add(infoFile.GetHashCode()); + } + + // If there was no hit to the knownPlayer-List, remove File from known-List + if (!hit) { + config.knownPlayerFiles.RemoveAt(i--); + } + } + catch (Exception) { + config.knownPlayerFiles.RemoveAt(i--); + } + } + + // Also enumerate all knownPlayers to find outdated items + for (int i = 0; i < config.knownPlayer.Count; i++) { + if (!knownPlayer.Contains(config.knownPlayer[i])) { + config.knownPlayer.RemoveAt(i--); + } + } + + // Cleanup before serialize + config.configuration.Teams.Clear(); + + // Serialize + XmlSerializer serializer = new XmlSerializer(typeof (SimulationPluginConfiguration)); + MemoryStream puffer = new MemoryStream(); + serializer.Serialize(puffer, config); + return puffer.ToArray(); + } + set { + if (value != null && value.Length > 0) { + XmlSerializer serializer = new XmlSerializer(typeof (SimulationPluginConfiguration)); + MemoryStream puffer = new MemoryStream(value); + config = (SimulationPluginConfiguration) serializer.Deserialize(puffer); + teamSetup.Configuration = config; + + // Special Simulation-Settings + SimulationSettings.SetCustomSettings(config.configuration.Settings); + } + } + } + + /// + /// Starts the simulation. + /// + public void Start() { + if (State == PluginState.Ready) { + // Create new simulator + config.configuration.Teams.Clear(); + + // Create the teams + for (int i = 0; i < config.teams.Length; i++) { + if (config.teams[i].Players.Count > 0) { + TeamInfo team = new TeamInfo(); + team.Guid = Guid.NewGuid(); + team.Name = config.teams[i].Name; + + for (int j = 0; j < config.teams[i].Players.Count; j++) { + PlayerItem player = config.teams[i].Players[j]; + + for (int k = 0; k < players.Count; k++) { + if (players[k].File == player.FileName && + players[k].ClassName == player.ClassName) { + team.Player.Add(players[k]); + } + } + } + + config.configuration.Teams.Add(team); + } + } + + sim = new Simulator(config.configuration); + + // und starten + teamSetup.Active = true; + } + + if (State == PluginState.Paused) { + paused = false; + } + } + + /// + /// Stops all running simulations. + /// + public void Stop() { + if (State == PluginState.Running || State == PluginState.Paused) { + sim.Unload(); + sim = null; + teamSetup.Active = false; + } + } + + /// + /// Suspend running simulation. + /// + public void Pause() { + paused = true; + } + + /// + /// Gives start-parameter to the plugin. + /// + /// startup-parameter + public void StartupParameter(string[] parameter) { + teamSetup.AutoDiscoverAiFiles(); + + foreach (string param in parameter) { + if (param.ToUpper().StartsWith("/FILE")) { + teamSetup.DirectStart(param.Substring(6).Trim()); + } + } + } + + /// + /// Set the visibility of this plugin. + /// + /// visibility + public void SetVisibility(bool visible) {} + + /// + /// Updates UI + /// + /// current state of simulation + public void UpdateUI(SimulationState state) {} + + /// + /// Gets the name of plugin. + /// + public string Name { + get { return name; } + } + + /// + /// Gets the description of plugin. + /// + public string Description { + get { return description; } + } + + /// + /// Gets the version of plugin. + /// + public Version Version { + get { return version; } + } + + /// + /// Gets the guid of plugin. + /// + public Guid Guid { + get { return guid; } + } + + /// + /// Fills the given state with simulation-states. + /// + /// state + public void CreateState(ref SimulationState state) { + if (sim == null) { + throw new Exception(Resource.SimulatorPluginNotStarted); + } + + sim.Step(ref state); + + if (sim.State == SimulatorState.Finished) { + sim.Unload(); + sim = null; + paused = false; + } + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationPlugin/StatisticControl.Designer.cs b/SimulationPlugin/StatisticControl.Designer.cs new file mode 100644 index 0000000..48758ae --- /dev/null +++ b/SimulationPlugin/StatisticControl.Designer.cs @@ -0,0 +1,256 @@ +namespace AntMe.Plugin.Simulation +{ + partial class StatisticControl + { + /// + /// Erforderliche Designervariable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Verwendete Ressourcen bereinigen. + /// + /// True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Vom Komponenten-Designer generierter Code + + /// + /// Erforderliche Methode für die Designerunterstützung. + /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(StatisticControl)); + this.splitContainer1 = new System.Windows.Forms.SplitContainer(); + this.loopsTreeView = new System.Windows.Forms.TreeView(); + this.treeContext = new System.Windows.Forms.ContextMenuStrip(this.components); + this.imageList = new System.Windows.Forms.ImageList(this.components); + this.summaryListView = new System.Windows.Forms.ListView(); + this.playerColumn = new System.Windows.Forms.ColumnHeader(); + this.collectedFoodColumn = new System.Windows.Forms.ColumnHeader(resources.GetString("summaryListView.Columns")); + this.collectedFruitColumn = new System.Windows.Forms.ColumnHeader(resources.GetString("summaryListView.Columns1")); + this.killedAntsColumn = new System.Windows.Forms.ColumnHeader(resources.GetString("summaryListView.Columns2")); + this.killedBugsColumn = new System.Windows.Forms.ColumnHeader(resources.GetString("summaryListView.Columns3")); + this.starvedAntsColumn = new System.Windows.Forms.ColumnHeader(resources.GetString("summaryListView.Columns4")); + this.beatenAntsColumn = new System.Windows.Forms.ColumnHeader(resources.GetString("summaryListView.Columns5")); + this.eatenAntsColumn = new System.Windows.Forms.ColumnHeader(resources.GetString("summaryListView.Columns6")); + this.pointsColumn = new System.Windows.Forms.ColumnHeader(resources.GetString("summaryListView.Columns7")); + this.toolStrip = new System.Windows.Forms.ToolStrip(); + this.loadButton = new System.Windows.Forms.ToolStripButton(); + this.deleteButton = new System.Windows.Forms.ToolStripButton(); + this.saveButton = new System.Windows.Forms.ToolStripButton(); + this.titelLabel = new System.Windows.Forms.Label(); + this.timer = new System.Windows.Forms.Timer(this.components); + this.splitContainer1.Panel1.SuspendLayout(); + this.splitContainer1.Panel2.SuspendLayout(); + this.splitContainer1.SuspendLayout(); + this.toolStrip.SuspendLayout(); + this.SuspendLayout(); + // + // splitContainer1 + // + resources.ApplyResources(this.splitContainer1, "splitContainer1"); + this.splitContainer1.FixedPanel = System.Windows.Forms.FixedPanel.Panel1; + this.splitContainer1.Name = "splitContainer1"; + // + // splitContainer1.Panel1 + // + this.splitContainer1.Panel1.Controls.Add(this.loopsTreeView); + // + // splitContainer1.Panel2 + // + this.splitContainer1.Panel2.Controls.Add(this.summaryListView); + // + // loopsTreeView + // + this.loopsTreeView.ContextMenuStrip = this.treeContext; + resources.ApplyResources(this.loopsTreeView, "loopsTreeView"); + this.loopsTreeView.HideSelection = false; + this.loopsTreeView.ImageList = this.imageList; + this.loopsTreeView.Name = "loopsTreeView"; + this.loopsTreeView.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.tree_select); + // + // treeContext + // + this.treeContext.Name = "treeContext"; + resources.ApplyResources(this.treeContext, "treeContext"); + // + // imageList + // + this.imageList.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList.ImageStream"))); + this.imageList.TransparentColor = System.Drawing.Color.Transparent; + this.imageList.Images.SetKeyName(0, "loop_complete"); + this.imageList.Images.SetKeyName(1, "loop_incomplete"); + this.imageList.Images.SetKeyName(2, "loop_running"); + this.imageList.Images.SetKeyName(3, "simset_running"); + this.imageList.Images.SetKeyName(4, "simset_complete"); + this.imageList.Images.SetKeyName(5, "simset_incomplete"); + this.imageList.Images.SetKeyName(6, "beaten_ants"); + this.imageList.Images.SetKeyName(7, "collected_fruit"); + this.imageList.Images.SetKeyName(8, "collected_sugar"); + this.imageList.Images.SetKeyName(9, "colony"); + this.imageList.Images.SetKeyName(10, "eaten_ants"); + this.imageList.Images.SetKeyName(11, "killed_ants"); + this.imageList.Images.SetKeyName(12, "killed_bugs"); + this.imageList.Images.SetKeyName(13, "starved_ants"); + this.imageList.Images.SetKeyName(14, "total_points"); + // + // summaryListView + // + this.summaryListView.AllowColumnReorder = true; + this.summaryListView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.playerColumn, + this.collectedFoodColumn, + this.collectedFruitColumn, + this.killedAntsColumn, + this.killedBugsColumn, + this.starvedAntsColumn, + this.beatenAntsColumn, + this.eatenAntsColumn, + this.pointsColumn}); + resources.ApplyResources(this.summaryListView, "summaryListView"); + this.summaryListView.GridLines = true; + this.summaryListView.Groups.AddRange(new System.Windows.Forms.ListViewGroup[] { + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("summaryListView.Groups"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("summaryListView.Groups1"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("summaryListView.Groups2"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("summaryListView.Groups3"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("summaryListView.Groups4"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("summaryListView.Groups5"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("summaryListView.Groups6"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("summaryListView.Groups7")))}); + this.summaryListView.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.Nonclickable; + this.summaryListView.Name = "summaryListView"; + this.summaryListView.SmallImageList = this.imageList; + this.summaryListView.UseCompatibleStateImageBehavior = false; + this.summaryListView.View = System.Windows.Forms.View.Details; + // + // playerColumn + // + resources.ApplyResources(this.playerColumn, "playerColumn"); + // + // collectedFoodColumn + // + resources.ApplyResources(this.collectedFoodColumn, "collectedFoodColumn"); + // + // collectedFruitColumn + // + resources.ApplyResources(this.collectedFruitColumn, "collectedFruitColumn"); + // + // killedAntsColumn + // + resources.ApplyResources(this.killedAntsColumn, "killedAntsColumn"); + // + // killedBugsColumn + // + resources.ApplyResources(this.killedBugsColumn, "killedBugsColumn"); + // + // starvedAntsColumn + // + resources.ApplyResources(this.starvedAntsColumn, "starvedAntsColumn"); + // + // beatenAntsColumn + // + resources.ApplyResources(this.beatenAntsColumn, "beatenAntsColumn"); + // + // eatenAntsColumn + // + resources.ApplyResources(this.eatenAntsColumn, "eatenAntsColumn"); + // + // pointsColumn + // + resources.ApplyResources(this.pointsColumn, "pointsColumn"); + // + // toolStrip + // + this.toolStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.loadButton, + this.deleteButton, + this.saveButton}); + resources.ApplyResources(this.toolStrip, "toolStrip"); + this.toolStrip.Name = "toolStrip"; + // + // loadButton + // + this.loadButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.loadButton.Image = global::AntMe.Plugin.Simulation.Properties.Resources.load_16x16; + resources.ApplyResources(this.loadButton, "loadButton"); + this.loadButton.Name = "loadButton"; + // + // deleteButton + // + this.deleteButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.deleteButton.Image = global::AntMe.Plugin.Simulation.Properties.Resources.delete_16x16; + resources.ApplyResources(this.deleteButton, "deleteButton"); + this.deleteButton.Name = "deleteButton"; + // + // saveButton + // + this.saveButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.saveButton.Image = global::AntMe.Plugin.Simulation.Properties.Resources.save_16x16; + resources.ApplyResources(this.saveButton, "saveButton"); + this.saveButton.Name = "saveButton"; + // + // titelLabel + // + this.titelLabel.BackColor = System.Drawing.SystemColors.AppWorkspace; + resources.ApplyResources(this.titelLabel, "titelLabel"); + this.titelLabel.ForeColor = System.Drawing.SystemColors.HighlightText; + this.titelLabel.Name = "titelLabel"; + // + // timer + // + this.timer.Interval = 1000; + this.timer.Tick += new System.EventHandler(this.timer_Tick); + // + // StatisticControl + // + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.splitContainer1); + this.Controls.Add(this.toolStrip); + this.Controls.Add(this.titelLabel); + this.Name = "StatisticControl"; + this.splitContainer1.Panel1.ResumeLayout(false); + this.splitContainer1.Panel2.ResumeLayout(false); + this.splitContainer1.ResumeLayout(false); + this.toolStrip.ResumeLayout(false); + this.toolStrip.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.ToolStrip toolStrip; + private System.Windows.Forms.Label titelLabel; + private System.Windows.Forms.TreeView loopsTreeView; + private System.Windows.Forms.SplitContainer splitContainer1; + private System.Windows.Forms.ListView summaryListView; + private System.Windows.Forms.ImageList imageList; + private System.Windows.Forms.ColumnHeader playerColumn; + private System.Windows.Forms.ColumnHeader collectedFoodColumn; + private System.Windows.Forms.ColumnHeader collectedFruitColumn; + private System.Windows.Forms.ColumnHeader killedAntsColumn; + private System.Windows.Forms.ColumnHeader killedBugsColumn; + private System.Windows.Forms.ColumnHeader starvedAntsColumn; + private System.Windows.Forms.ColumnHeader beatenAntsColumn; + private System.Windows.Forms.ColumnHeader eatenAntsColumn; + private System.Windows.Forms.ColumnHeader pointsColumn; + private System.Windows.Forms.ContextMenuStrip treeContext; + private System.Windows.Forms.Timer timer; + private System.Windows.Forms.ToolStripButton loadButton; + private System.Windows.Forms.ToolStripButton deleteButton; + private System.Windows.Forms.ToolStripButton saveButton; + } +} diff --git a/SimulationPlugin/StatisticControl.cs b/SimulationPlugin/StatisticControl.cs new file mode 100644 index 0000000..afb3219 --- /dev/null +++ b/SimulationPlugin/StatisticControl.cs @@ -0,0 +1,241 @@ +using System; +using System.Collections.Generic; +using System.Windows.Forms; + +using AntMe.SharedComponents.States; + +namespace AntMe.Plugin.Simulation { + internal sealed partial class StatisticControl : UserControl { + private readonly SummaryRoot root = new SummaryRoot(); + + private SummarySimulation currentSim; + private SummaryLoop currentLoop; + + private TreeNode currentSimNode; + private TreeNode currentLoopNode; + private int loopCount = 0; + + public StatisticControl() { + InitializeComponent(); + } + + public void Start() { + currentSim = new SummarySimulation(); + root.simulations.Add(currentSim); + loopCount = 0; + + // Create Node + currentSimNode = loopsTreeView.Nodes.Add(currentSim.startDate.ToString()); + currentSimNode.Tag = currentSim; + currentSimNode.ImageKey = "simset_running"; + + timer.Enabled = true; + } + + public void Stop() { + currentSimNode.ImageKey = "simset_complete"; + currentSim = null; + + timer.Enabled = false; + } + + public void SimulationState(SimulationState state) { + if (state.CurrentRound == 1) { + currentLoop = new SummaryLoop(); + currentLoop.rounds = state.TotalRounds; + currentSim.loops.Add(currentLoop); + + // Create Node + currentLoopNode = currentSimNode.Nodes.Add("Loop " + (++loopCount)); + currentLoopNode.Tag = currentLoop; + currentLoopNode.ImageKey = "loop_running"; + currentLoopNode.EnsureVisible(); + loopsTreeView.SelectedNode = currentLoopNode; + } + + foreach (TeamState teamState in state.TeamStates) + { + SummaryTeam team; + + if (!currentLoop.teams.ContainsKey(teamState.Guid)) + { + team = new SummaryTeam(); + team.name = teamState.Name; + team.guid = teamState.Guid; + currentLoop.teams.Add(team.guid, team); + } + else + { + team = currentLoop.teams[teamState.Guid]; + } + + foreach (ColonyState colonyState in teamState.ColonyStates) + { + SummaryPlayer player; + + if (!team.players.ContainsKey(colonyState.Guid)) + { + player = new SummaryPlayer(); + player.name = colonyState.ColonyName; + player.guid = colonyState.Guid; + team.players.Add(player.guid, player); + } + else + { + player = team.players[colonyState.Guid]; + } + + SummaryValueSet valueSet = new SummaryValueSet(); + valueSet.collectedFood = colonyState.CollectedFood; + valueSet.collectedFruit = colonyState.CollectedFruits; + valueSet.killedAnts = colonyState.KilledEnemies; + valueSet.killedBugs = colonyState.KilledBugs; + valueSet.starvedAnts = colonyState.StarvedAnts; + valueSet.beatenAnts = colonyState.BeatenAnts; + valueSet.eatenAnts = colonyState.EatenAnts; + valueSet.totalPoints = colonyState.Points; + player.values.Add(valueSet); + } + } + + if (state.CurrentRound == state.TotalRounds) { + currentLoopNode.ImageKey = "loop_complete"; + currentLoop.completed = true; + currentLoop = null; + } + } + + private void tree_select(object sender, TreeViewEventArgs e) + { + if (loopsTreeView.SelectedNode != null) { + + summaryListView.Items.Clear(); + + // In case of a selected loop + if (loopsTreeView.SelectedNode.Tag is SummaryLoop) { + SummaryLoop loop = (SummaryLoop) loopsTreeView.SelectedNode.Tag; + + int teamcount = 0; + foreach (SummaryTeam team in loop.teams.Values) { + teamcount++; + + ListViewGroup teamGroup = summaryListView.Groups["team" + teamcount + "Group"]; + + foreach (SummaryPlayer player in team.players.Values) { + SummaryValueSet set = player.values[player.values.Count - 1]; + + ListViewItem item = summaryListView.Items.Add(player.name, "colony"); + item.SubItems.Add(set.collectedFood.ToString()); + item.SubItems.Add(set.collectedFruit.ToString()); + item.SubItems.Add(set.killedAnts.ToString()); + item.SubItems.Add(set.killedBugs.ToString()); + item.SubItems.Add(set.starvedAnts.ToString()); + item.SubItems.Add(set.beatenAnts.ToString()); + item.SubItems.Add(set.eatenAnts.ToString()); + item.SubItems.Add(set.totalPoints.ToString()); + item.Group = teamGroup; + } + } + } + + // In case of a selected simulation-set + if (loopsTreeView.SelectedNode.Tag is SummarySimulation) { + SummarySimulation simulation = (SummarySimulation) loopsTreeView.SelectedNode.Tag; + + // Check for any Teaminformation + if (simulation.loops.Count > 0) { + + // Create the summary for included loops + int loops = 0; + Dictionary teams = + new Dictionary(simulation.loops[0].teams.Count); + foreach (SummaryTeam team in simulation.loops[0].teams.Values) { + + // Clone team + SummaryTeam summaryTeam = new SummaryTeam(); + summaryTeam.guid = team.guid; + summaryTeam.name = team.name; + summaryTeam.players = new Dictionary(team.players.Count); + teams.Add(team.guid, summaryTeam); + + foreach (SummaryPlayer player in team.players.Values) { + + // Clone player + SummaryPlayer summaryPlayer = new SummaryPlayer(); + summaryPlayer.guid = player.guid; + summaryPlayer.name = player.name; + summaryPlayer.values = new List(1); + summaryPlayer.values.Add(new SummaryValueSet()); + summaryTeam.players.Add(summaryPlayer.guid, summaryPlayer); + } + } + + // Sum up all loops + foreach (SummaryLoop loop in simulation.loops) { + if (loop.completed) { + loops++; + + foreach (SummaryTeam team in loop.teams.Values) { + foreach (SummaryPlayer player in team.players.Values) { + SummaryValueSet set = player.values[player.values.Count - 1]; + teams[team.guid].players[player.guid].values[0].Add(set); + } + } + } + } + + // Fill into Listview + int teamcount = 0; + foreach (SummaryTeam team in teams.Values) + { + teamcount++; + + ListViewGroup teamGroup = summaryListView.Groups["team" + teamcount + "Group"]; + + foreach (SummaryPlayer player in team.players.Values) + { + SummaryValueSet set = player.values[0]; + + if (loops > 0) { + // Calculate average values + float collectedFood = (float) set.collectedFood/loops; + float collectedFruit = (float) set.collectedFruit/loops; + float killedAnts = (float) set.killedAnts/loops; + float killedBugs = (float) set.killedBugs/loops; + float starvedAnts = (float) set.starvedAnts/loops; + float beatenAnts = (float) set.beatenAnts/loops; + float eatenAnts = (float) set.eatenAnts/loops; + float totalPoints = (float) set.totalPoints/loops; + + // push it to listview + ListViewItem item = summaryListView.Items.Add(player.name, "colony"); + item.SubItems.Add(collectedFood.ToString("0.00")); + item.SubItems.Add(collectedFruit.ToString("0.00")); + item.SubItems.Add(killedAnts.ToString("0.00")); + item.SubItems.Add(killedBugs.ToString("0.00")); + item.SubItems.Add(starvedAnts.ToString("0.00")); + item.SubItems.Add(beatenAnts.ToString("0.00")); + item.SubItems.Add(eatenAnts.ToString("0.00")); + item.SubItems.Add(totalPoints.ToString("0.00")); + item.Group = teamGroup; + } + else { + // push empty row + ListViewItem item = summaryListView.Items.Add(player.name, "colony"); + item.Group = teamGroup; + } + } + } + + } + } + + } + } + + private void timer_Tick(object sender, EventArgs e) + { + tree_select(null, null); + } + } +} \ No newline at end of file diff --git a/SimulationPlugin/StatisticControl.de.resx b/SimulationPlugin/StatisticControl.de.resx new file mode 100644 index 0000000..5aafdc7 --- /dev/null +++ b/SimulationPlugin/StatisticControl.de.resx @@ -0,0 +1,331 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAADQ + EwAAAk1TRnQBSQFMAgEBDwEAARQBAAEEAQABEAEAARABAAT/AQkBAAj/AUIBTQE2AQQGAAE2AQQCAAEo + AwABQAMAAUADAAEBAQABCAYAARAYAAGAAgABgAMAAoABAAGAAwABgAEAAYABAAKAAgADwAEAAcAB3AHA + AQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEAAykBAANVAQADTQEAA0IBAAM5 + AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8BAAHWAucBAAGQAakBrQIAAf8BMwMA + AWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHMAgABMwH/AgABZgMAAWYBMwIAAmYCAAFm + AZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgACmQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHM + AWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZAgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEA + ATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8BMwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEz + AWYCAAEzAWYBMwEAATMCZgEAATMBZgGZAQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZ + AWYBAAEzApkBAAEzAZkBzAEAATMBmQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLM + AQABMwHMAf8BAAEzAf8BMwEAATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEA + AWYBAAFmAQABZgEAAZkBAAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEA + AWYBMwHMAQABZgEzAf8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZ + AWYBAAFmApkBAAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/ + AQABZgH/AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEA + AZkBAAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm + ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwBAAKZ + Af8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIAAZkB/wEz + AQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYBAAHMAQABmQEA + AcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEzAf8BAAHMAWYCAAHM + AWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwBmQEzAQABzAGZAWYBAAHM + ApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEAA8wBAALMAf8BAAHMAf8CAAHM + Af8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwBAAEzAQAB/wEAAWYBAAH/AQABmQEA + AcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEAAf8BMwH/AQAB/wFmAgAB/wFmATMBAAHM + AmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkCAAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZ + AcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHMAWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEz + AQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8BAAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFm + AQABIQEAAaUBAANfAQADdwEAA4YBAAOWAQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHw + AfsB/wEAAaQCoAEAA4ADAAH/AgAB/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD/wwAAv8UAA//EwAB9AEH + AZIB7wHwAf8CAAHzAZIB/wMAAf8BRgGTAf8BAAH/Am8B/wEAAf8BkwFGAf8BAAH0AuwB7QLsAu0C7AHt + AuwB7QH3AfQSAAHwBW0B7AH/AQAB9AFtAf8DAAHzAR8B6QH/AQAB/wIfAf8BAAH/AekBHwHzAQAB8wHt + Af8CGgH/ARoBBwH/AfQBmgH0Af8BBwHyEgAB8wdtAfcB8AGSAewB/wHzAf8CAAHyAfQDAALzAwAB9AHy + AgAB8wH3ARsCLAEbAiABGgF1ASwBegEaAiAB/xEAAe8KbQHrAuwB8hAAAfMB9wEaAiwBGgIgARoBdQEs + AXoBBwEgAUYB9BAAAf8B7AttAQcSAAHzAZIB8wJTAfQCIAEaAXUBLAF6AQcBIAFGAfQQAAH/AewIbQHr + AW0B7QH/EgAB8wHtAQAD/wIgARoBdQEsAXoBBwEgAUYB9BEAAf8B8QFtAfQB6wHyAvcC/wH0Af8TAAHz + AewB/wIAAf8CIAEaAXUBLAF6AQcBIAFGAfQSAAH3Ae8BAAHrAfMB8gHrFwAB/wHwBAAB9AHyAf8BUwEs + AXoBBwEgAUYB9BIAAfcB8wEAAW0B8gH/AW0B9B8AAVMBLAF6ARoBIAFGAfQVAAHzAf8BAAL/HwABGwF6 + AfMBBwEgAUYB9DwAAZMCIAH0PAABGgFGAW8B/z0AAf+iAAf/AQcI/wYAAf8ZAAHxBe0B8QEAAfEF7QHx + AQAH/wGTAfQH/wMAAf8BmgJTAXUBGgH2BwABGgFGAW8B/wEAAfIBRgFvAfQBAAH/AW8BRgEaAQAB7QH3 + A/EB9wHtAQAB7QH3A/EB9wHtAQAH/wEHAZMB/wGTBf8CAAEaBiwBmgYAARoDHwFvAf8B6QIfAUYB/wFv + Ax8BGgHtAfEDAAHxAe0BAAHtAfEDAAHxAe0BAAP/ARoBRgFvAv8BbwH/AW8F/wEAAfYGLAEaBwABkwMf + AUYB/wQfAf8BRgMfAZMB7QHxAwAB8QHtAQAB7QHxAwAB8QHtAQAD/wFGAh8BbwH/AW8BBwGTBf8BAAF6 + BCwBegH2AQAB/wIAAf8DAAH/AW8CHwEaAQABbwIfAZMBAAEaAh8BbwH/Ae0B8QMAAfEB7QEAAe0B8QMA + AfEB7QEAA/8BbwMfAZMBbwHzAW8G/wFTAiwBUwEbAgABkwEgARoB9AEgAW8B/wIAAf8B8gH0AwAC8wMA + AfQB8gH/AQAB7QH3A/EB9wHtAQAB7QH3A/EB9wHtAQAB8wP/AW8B6QEfAUYBkwH/AW8BGgT/AfYBUwIs + AZoCAAH/AiABkwEaAiAB/xEAAfEF7QHxAQAB8QXtAfEBAAGTAW8BkwL/ARoBbwLpAZMCbwX/AVMDLAFT + ARoBAAHzAZMC/wGTARoWAAHxBe0B8QUAAv8BkwNvAZMBRgEfAekBbwHzBP8BAAGaBSwBdQH2GwAB7QH3 + A/EB9wHtBQAC/wL0ARoB9AH/AZMB6QEfAekBkwFvA5MBAAH/AVMGLAF1Af8ZAAHtAfEDAAHxAe0FAAL/ + Bm8BkwPpAZMBGgL/AgAB/wF1BSwBmgH/GQAB7QHxAwAB8QHtBQAG/wEaAW8BGgGTAekBHwHpAZMBGgH/ + BAAB9AEaAZoBGgH2GwAB7QHxAwAB8QHtBQAJ/wFvAZMB6QGTAf8BkwH/JAAB7QH3A/EB9wHtBQAI/wH0 + AZMBGgGTBP8kAAHxBe0B8QUACP8BGgEHAfQCkwP/MAAI/wEaAfMC/wEaA/8gACD/IAAB8wFvCUYBbwT/ + AfMB7QnsAe0B9AP/CAAB9AFvAUYB6QFGAW8B/wUAAf8C9AL/AvQB/wQAAZMLIAEaA/8B7wvqAfAD/wgA + Af8B9APzAfQB/wQAAfQBRgIgAkYCIAFGAfQDAAGTASAJRgEgARoD/wHvAeoJ7AHqAfAD/xIAAf8KIAH/ + AgABkwEgCBoBkwEgARoC8gH/Ae8B6gG8B/ABBwHqAfAC8gH/CgABvAHvAQcB/wQAAZMKIAGTAgABkwsg + ARoB7AHyAf8B7wvqAfAB7AHyAf8KAAHsAm0B/wQAAUYKIAFGAgABkwEgCG8BRgEgARoB7AHyAf8B7wHq + AZIH7wHtAeoB8AHsAfIB/woAAewCbQH/BAABRgogAUYCAAGTASABbwcaAW8BIAEaAewB8gEHAe8B6gH3 + B/AB9wHqAfAB7AHyAQcBAAH/B/MB/wHtAm0B/wQAAW8KIAFvAgABkwsgARoB7AHyAewB7wvqAfAB7AHy + AewBAAEHB20BvAH3Am0B/wQAARoKIAEaAgABvQtGARsB7AHyAewB8grsAe0B8wHsAfIB7AEAAbwHbQHw + AZICbQH/BQABkwMgAm8DIAGTAwAN/wHsAfIB7A3/AewB8gHsAQAJ/wHsAm0B/wYAAfMCGgPzARoB9AQA + A/8B8AnvAewB8QHsA/8B8AnvAewB8QHsCgAB7AFtAe8KAAK8AfQBvAHyAf8DAAP/Ae8J7QEHAfQB7AP/ + Ae8J7AEHAfQB7AoAAesB7AH/CgAB8AEHA20B8gMAD/8B7A//AewKAAEHAfQLAAG8AfAB9AG8AfIB/wMA + Bf8B7wntAW0F/wHvCewBbRcAAv8HAAX/AfIJ8QHyBf8B8gnxAfIgACT/AfIC8QHyAfQL/wHyAvEB8gH0 + B/8B9AF1CVMBdQT/AfQLvAf/AVMDLAGZAfMB/wLyB/8BRgMgAZMB8wH/AvIE/wGaCywBGgP/AfEL7wHx + Bv8BGgMsAXUB8QHrAewBvAHxAfQF/wG9AyABbwHxAesB7AG8AfEB9AL/AZoBLAlTASwBGgP/AfEB7wEH + B7wBBwHvAfEG/wGaAywBdQHxA20BBwHyBf8BkwMgAW8B8QNtAQcB8gL/AZoBLAgaAZoBLAEaAfIB8wH/ + AfEB7wjzAfEB7wHxAfIB8wT/AiwBUwEsAXoB9AHzAewBbQHrAfAB8wT/AiABRgEgAW8B9AHzAewBbQHr + AfAB8wH/AZoLLAEaAewB8wH/AfEL7wHxAewB8wP/AZoBLAFTAfMCmgL/AfQB7AFtAfcB8gP/AZMBIAFG + AfMCkwL/AfQB7AFtAfcB8gH/AZoBLAF1B3oBUwEsARoB7AHzAf8B8QHvAfAH8QG8Ae8B8QHsAfMD/wFT + ASwBmgb/AbwBbQHsAfED/wFGASABkwb/AbwBbQHsAfEB/wGaASwBmgcaAXoBLAEaAewB8wEHAfEB7wjx + AfAB7wHxAewB8wEHAv8CLAEaBv8B8wJtAfED/wIgAQcG/wHzAm0B8QH/AZoLLAEaAewB8wHsAfEL7wHx + AewB8wHsAv8CLAEaAfQF/wHyAm0B8gP/AiABvAH0Bf8B8gJtAfIB/wEaC1MBGwHsAfMB7AH0C7wB9AHs + AfMB7AL/AVMBLAGaAfID/wL0AQcBbQHsAfMD/wFGASABkwHyA/8C9AEHAW0B7AHzDv8B7AHzAewN/wHs + AfMB7AL/AZoBLAFTAfAB8gH/AgcB8AHsAW0B9wT/AZMBIAFGAfAB8gH/AgcB8AHsAW0B9wX/AfAJ7wHs + AfMB7AP/AfAJ7wHsAfMB7AL/AfYCLAFTARoB8QHvAW0B7AFtAesB8wT/AfQCIAFGAbwB8QHvAW0B7AFt + AesB8wX/Ae8J7QEHAfQB7AP/Ae8J7AEHAfQB7AP/AZoDLAEaAe8DbQHvBv8BlAMgAbwB7wNtAe8S/wHs + D/8B7AT/ARoBUwEsARsB7wJtAesBvAHyBv8BvQFGASABGwHvAm0B6wG8AfIH/wHvCe0BbQX/Ae8J7AFt + CP8B8QHrAm0B7Av/AfEB6wJtAewI/wHyCfEB8gX/AfIJ8QHyIP8BQgFNAT4HAAE+AwABKAMAAUADAAFA + AwABAQEAAQEGAAECFgAD/wEAAf8B5wL/AYADAAHgAWMBhAEhBAABwAEjAYQBIQEAAQECAAGAAQABzgFz + BAABgAEAAv8FAAEDAv8FAAEDAv8BIAMAAYABBwL/ARgDAAHIAX8C/wE8AwAByAE/A/8BgAIAAfkBPwP/ + AYACAAX/AfACAAX/AfACAAX/AfsCAAb/AgAG/wIAAv8CAAH9A/8CAQIAAeABPwGEASECAQIAAcABPwIA + AjkCAAGAAX8CAAI5AgABgAG3AQQBIAI5AgABAwEBAY4BcQIBAgABBgEBAv8CAQIAAQEBAwL/AfABHwIA + AYABfwL/AfABHwIAAYABHwL/AfMBnwIAAcABHwL/AfMBnwIAAfABfwL/AfMBnwIABP8B8AEfAgAE/wHw + AR8CAAb/AgAE/wQABP8EAAH/AQEB8AEPBAAB/wEBAeABBwQAAv8BwAEDBAAB/wHDAcABAwQAAf8BwwHA + AQMEAAH/AcMBwAEDBAABgAEDAcABAwQAAYABAwHAAQMEAAGAAQMB4AEHBAABgAEDAfABDwQAAf8BxwH+ + AQcEAAH/AccB/gEHBAAB/wHPAf4BBwQAAv8B/gF/BAAE/4AACw== + + + + Spieler + + + Nahrung + + + Obst + + + Getötete Ameisen + + + Getötete Wanzen + + + Verhungerte Ameisen + + + Geschlagene Ameisen + + + Gefressene Ameisen + + + Gesamtpunkte + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDEF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtMUdyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDIF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtMkdyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDMF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtM0dyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDQF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtNEdyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDUF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtNUdyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDYF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtNkdyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDcF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtN0dyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDgF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtOEdyb3VwCw== + + + + Laden + + + Löschen + + + Speichern + + + Simulationsauswertung + + \ No newline at end of file diff --git a/SimulationPlugin/StatisticControl.resx b/SimulationPlugin/StatisticControl.resx new file mode 100644 index 0000000..d9b6f36 --- /dev/null +++ b/SimulationPlugin/StatisticControl.resx @@ -0,0 +1,697 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + Fill + + + + 0, 52 + + + 218, 17 + + + 61, 4 + + + treeContext + + + System.Windows.Forms.ContextMenuStrip, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Fill + + + + 0 + + + 115, 17 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAADQ + EwAAAk1TRnQBSQFMAgEBDwEAARQBAAEEAQABEAEAARABAAT/AQkBAAj/AUIBTQE2AQQGAAE2AQQCAAEo + AwABQAMAAUADAAEBAQABCAYAARAYAAGAAgABgAMAAoABAAGAAwABgAEAAYABAAKAAgADwAEAAcAB3AHA + AQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEAAykBAANVAQADTQEAA0IBAAM5 + AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8BAAHWAucBAAGQAakBrQIAAf8BMwMA + AWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHMAgABMwH/AgABZgMAAWYBMwIAAmYCAAFm + AZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgACmQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHM + AWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZAgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEA + ATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8BMwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEz + AWYCAAEzAWYBMwEAATMCZgEAATMBZgGZAQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZ + AWYBAAEzApkBAAEzAZkBzAEAATMBmQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLM + AQABMwHMAf8BAAEzAf8BMwEAATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEA + AWYBAAFmAQABZgEAAZkBAAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEA + AWYBMwHMAQABZgEzAf8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZ + AWYBAAFmApkBAAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/ + AQABZgH/AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEA + AZkBAAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm + ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwBAAKZ + Af8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIAAZkB/wEz + AQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYBAAHMAQABmQEA + AcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEzAf8BAAHMAWYCAAHM + AWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwBmQEzAQABzAGZAWYBAAHM + ApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEAA8wBAALMAf8BAAHMAf8CAAHM + Af8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwBAAEzAQAB/wEAAWYBAAH/AQABmQEA + AcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEAAf8BMwH/AQAB/wFmAgAB/wFmATMBAAHM + AmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkCAAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZ + AcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHMAWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEz + AQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8BAAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFm + AQABIQEAAaUBAANfAQADdwEAA4YBAAOWAQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHw + AfsB/wEAAaQCoAEAA4ADAAH/AgAB/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD/wwAAv8UAA//EwAB9AEH + AZIB7wHwAf8CAAHzAZIB/wMAAf8BRgGTAf8BAAH/Am8B/wEAAf8BkwFGAf8BAAH0AuwB7QLsAu0C7AHt + AuwB7QH3AfQSAAHwBW0B7AH/AQAB9AFtAf8DAAHzAR8B6QH/AQAB/wIfAf8BAAH/AekBHwHzAQAB8wHt + Af8CGgH/ARoBBwH/AfQBmgH0Af8BBwHyEgAB8wdtAfcB8AGSAewB/wHzAf8CAAHyAfQDAALzAwAB9AHy + AgAB8wH3ARsCLAEbAiABGgF1ASwBegEaAiAB/xEAAe8KbQHrAuwB8hAAAfMB9wEaAiwBGgIgARoBdQEs + AXoBBwEgAUYB9BAAAf8B7AttAQcSAAHzAZIB8wJTAfQCIAEaAXUBLAF6AQcBIAFGAfQQAAH/AewIbQHr + AW0B7QH/EgAB8wHtAQAD/wIgARoBdQEsAXoBBwEgAUYB9BEAAf8B8QFtAfQB6wHyAvcC/wH0Af8TAAHz + AewB/wIAAf8CIAEaAXUBLAF6AQcBIAFGAfQSAAH3Ae8BAAHrAfMB8gHrFwAB/wHwBAAB9AHyAf8BUwEs + AXoBBwEgAUYB9BIAAfcB8wEAAW0B8gH/AW0B9B8AAVMBLAF6ARoBIAFGAfQVAAHzAf8BAAL/HwABGwF6 + AfMBBwEgAUYB9DwAAZMCIAH0PAABGgFGAW8B/z0AAf+iAAf/AQcI/wYAAf8ZAAHxBe0B8QEAAfEF7QHx + AQAH/wGTAfQH/wMAAf8BmgJTAXUBGgH2BwABGgFGAW8B/wEAAfIBRgFvAfQBAAH/AW8BRgEaAQAB7QH3 + A/EB9wHtAQAB7QH3A/EB9wHtAQAH/wEHAZMB/wGTBf8CAAEaBiwBmgYAARoDHwFvAf8B6QIfAUYB/wFv + Ax8BGgHtAfEDAAHxAe0BAAHtAfEDAAHxAe0BAAP/ARoBRgFvAv8BbwH/AW8F/wEAAfYGLAEaBwABkwMf + AUYB/wQfAf8BRgMfAZMB7QHxAwAB8QHtAQAB7QHxAwAB8QHtAQAD/wFGAh8BbwH/AW8BBwGTBf8BAAF6 + BCwBegH2AQAB/wIAAf8DAAH/AW8CHwEaAQABbwIfAZMBAAEaAh8BbwH/Ae0B8QMAAfEB7QEAAe0B8QMA + AfEB7QEAA/8BbwMfAZMBbwHzAW8G/wFTAiwBUwEbAgABkwEgARoB9AEgAW8B/wIAAf8B8gH0AwAC8wMA + AfQB8gH/AQAB7QH3A/EB9wHtAQAB7QH3A/EB9wHtAQAB8wP/AW8B6QEfAUYBkwH/AW8BGgT/AfYBUwIs + AZoCAAH/AiABkwEaAiAB/xEAAfEF7QHxAQAB8QXtAfEBAAGTAW8BkwL/ARoBbwLpAZMCbwX/AVMDLAFT + ARoBAAHzAZMC/wGTARoWAAHxBe0B8QUAAv8BkwNvAZMBRgEfAekBbwHzBP8BAAGaBSwBdQH2GwAB7QH3 + A/EB9wHtBQAC/wL0ARoB9AH/AZMB6QEfAekBkwFvA5MBAAH/AVMGLAF1Af8ZAAHtAfEDAAHxAe0FAAL/ + Bm8BkwPpAZMBGgL/AgAB/wF1BSwBmgH/GQAB7QHxAwAB8QHtBQAG/wEaAW8BGgGTAekBHwHpAZMBGgH/ + BAAB9AEaAZoBGgH2GwAB7QHxAwAB8QHtBQAJ/wFvAZMB6QGTAf8BkwH/JAAB7QH3A/EB9wHtBQAI/wH0 + AZMBGgGTBP8kAAHxBe0B8QUACP8BGgEHAfQCkwP/MAAI/wEaAfMC/wEaA/8gACD/IAAB8wFvCUYBbwT/ + AfMB7QnsAe0B9AP/CAAB9AFvAUYB6QFGAW8B/wUAAf8C9AL/AvQB/wQAAZMLIAEaA/8B7wvqAfAD/wgA + Af8B9APzAfQB/wQAAfQBRgIgAkYCIAFGAfQDAAGTASAJRgEgARoD/wHvAeoJ7AHqAfAD/xIAAf8KIAH/ + AgABkwEgCBoBkwEgARoC8gH/Ae8B6gG8B/ABBwHqAfAC8gH/CgABvAHvAQcB/wQAAZMKIAGTAgABkwsg + ARoB7AHyAf8B7wvqAfAB7AHyAf8KAAHsAm0B/wQAAUYKIAFGAgABkwEgCG8BRgEgARoB7AHyAf8B7wHq + AZIH7wHtAeoB8AHsAfIB/woAAewCbQH/BAABRgogAUYCAAGTASABbwcaAW8BIAEaAewB8gEHAe8B6gH3 + B/AB9wHqAfAB7AHyAQcBAAH/B/MB/wHtAm0B/wQAAW8KIAFvAgABkwsgARoB7AHyAewB7wvqAfAB7AHy + AewBAAEHB20BvAH3Am0B/wQAARoKIAEaAgABvQtGARsB7AHyAewB8grsAe0B8wHsAfIB7AEAAbwHbQHw + AZICbQH/BQABkwMgAm8DIAGTAwAN/wHsAfIB7A3/AewB8gHsAQAJ/wHsAm0B/wYAAfMCGgPzARoB9AQA + A/8B8AnvAewB8QHsA/8B8AnvAewB8QHsCgAB7AFtAe8KAAK8AfQBvAHyAf8DAAP/Ae8J7QEHAfQB7AP/ + Ae8J7AEHAfQB7AoAAesB7AH/CgAB8AEHA20B8gMAD/8B7A//AewKAAEHAfQLAAG8AfAB9AG8AfIB/wMA + Bf8B7wntAW0F/wHvCewBbRcAAv8HAAX/AfIJ8QHyBf8B8gnxAfIgACT/AfIC8QHyAfQL/wHyAvEB8gH0 + B/8B9AF1CVMBdQT/AfQLvAf/AVMDLAGZAfMB/wLyB/8BRgMgAZMB8wH/AvIE/wGaCywBGgP/AfEL7wHx + Bv8BGgMsAXUB8QHrAewBvAHxAfQF/wG9AyABbwHxAesB7AG8AfEB9AL/AZoBLAlTASwBGgP/AfEB7wEH + B7wBBwHvAfEG/wGaAywBdQHxA20BBwHyBf8BkwMgAW8B8QNtAQcB8gL/AZoBLAgaAZoBLAEaAfIB8wH/ + AfEB7wjzAfEB7wHxAfIB8wT/AiwBUwEsAXoB9AHzAewBbQHrAfAB8wT/AiABRgEgAW8B9AHzAewBbQHr + AfAB8wH/AZoLLAEaAewB8wH/AfEL7wHxAewB8wP/AZoBLAFTAfMCmgL/AfQB7AFtAfcB8gP/AZMBIAFG + AfMCkwL/AfQB7AFtAfcB8gH/AZoBLAF1B3oBUwEsARoB7AHzAf8B8QHvAfAH8QG8Ae8B8QHsAfMD/wFT + ASwBmgb/AbwBbQHsAfED/wFGASABkwb/AbwBbQHsAfEB/wGaASwBmgcaAXoBLAEaAewB8wEHAfEB7wjx + AfAB7wHxAewB8wEHAv8CLAEaBv8B8wJtAfED/wIgAQcG/wHzAm0B8QH/AZoLLAEaAewB8wHsAfEL7wHx + AewB8wHsAv8CLAEaAfQF/wHyAm0B8gP/AiABvAH0Bf8B8gJtAfIB/wEaC1MBGwHsAfMB7AH0C7wB9AHs + AfMB7AL/AVMBLAGaAfID/wL0AQcBbQHsAfMD/wFGASABkwHyA/8C9AEHAW0B7AHzDv8B7AHzAewN/wHs + AfMB7AL/AZoBLAFTAfAB8gH/AgcB8AHsAW0B9wT/AZMBIAFGAfAB8gH/AgcB8AHsAW0B9wX/AfAJ7wHs + AfMB7AP/AfAJ7wHsAfMB7AL/AfYCLAFTARoB8QHvAW0B7AFtAesB8wT/AfQCIAFGAbwB8QHvAW0B7AFt + AesB8wX/Ae8J7QEHAfQB7AP/Ae8J7AEHAfQB7AP/AZoDLAEaAe8DbQHvBv8BlAMgAbwB7wNtAe8S/wHs + D/8B7AT/ARoBUwEsARsB7wJtAesBvAHyBv8BvQFGASABGwHvAm0B6wG8AfIH/wHvCe0BbQX/Ae8J7AFt + CP8B8QHrAm0B7Av/AfEB6wJtAewI/wHyCfEB8gX/AfIJ8QHyIP8BQgFNAT4HAAE+AwABKAMAAUADAAFA + AwABAQEAAQEGAAECFgAD/wEAAf8B5wL/AYADAAHgAWMBhAEhBAABwAEjAYQBIQEAAQECAAGAAQABzgFz + BAABgAEAAv8FAAEDAv8FAAEDAv8BIAMAAYABBwL/ARgDAAHIAX8C/wE8AwAByAE/A/8BgAIAAfkBPwP/ + AYACAAX/AfACAAX/AfACAAX/AfsCAAb/AgAG/wIAAv8CAAH9A/8CAQIAAeABPwGEASECAQIAAcABPwIA + AjkCAAGAAX8CAAI5AgABgAG3AQQBIAI5AgABAwEBAY4BcQIBAgABBgEBAv8CAQIAAQEBAwL/AfABHwIA + AYABfwL/AfABHwIAAYABHwL/AfMBnwIAAcABHwL/AfMBnwIAAfABfwL/AfMBnwIABP8B8AEfAgAE/wHw + AR8CAAb/AgAE/wQABP8EAAH/AQEB8AEPBAAB/wEBAeABBwQAAv8BwAEDBAAB/wHDAcABAwQAAf8BwwHA + AQMEAAH/AcMBwAEDBAABgAEDAcABAwQAAYABAwHAAQMEAAGAAQMB4AEHBAABgAEDAfABDwQAAf8BxwH+ + AQcEAAH/AccB/gEHBAAB/wHPAf4BBwQAAv8B/gF/BAAE/4AACw== + + + + 0, 0 + + + total_points + + + 283, 424 + + + 0 + + + loopsTreeView + + + System.Windows.Forms.TreeView, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + splitContainer1.Panel1 + + + 0 + + + splitContainer1.Panel1 + + + System.Windows.Forms.SplitterPanel, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + splitContainer1 + + + 0 + + + Player + + + 76 + + + collected_sugar + + + Collected Food + + + Right + + + 95 + + + collected_fruit + + + Collected Fruit + + + Right + + + 92 + + + killed_ants + + + Killed Ants + + + Right + + + killed_bugs + + + Killed Bugs + + + Right + + + starved_ants + + + Starved Ants + + + Right + + + beaten_ants + + + Beaten Ants + + + Right + + + eaten_ants + + + Eaten Ants + + + Right + + + total_points + + + Total Points + + + Right + + + Fill + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDEF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtMUdyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDIF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtMkdyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDMF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtM0dyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDQF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtNEdyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDUF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtNUdyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDYF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtNkdyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDcF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtN0dyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDgF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtOEdyb3VwCw== + + + + 0, 0 + + + 610, 424 + + + 0 + + + summaryListView + + + System.Windows.Forms.ListView, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + splitContainer1.Panel2 + + + 0 + + + splitContainer1.Panel2 + + + System.Windows.Forms.SplitterPanel, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + splitContainer1 + + + 1 + + + 897, 424 + + + 283 + + + 10 + + + splitContainer1 + + + System.Windows.Forms.SplitContainer, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 1 + + + 0, 27 + + + Magenta + + + 23, 22 + + + Load + + + False + + + Magenta + + + 23, 22 + + + Delete + + + False + + + Magenta + + + 23, 22 + + + Save + + + False + + + 0, 27 + + + 897, 25 + + + 1 + + + toolStrip1 + + + toolStrip + + + System.Windows.Forms.ToolStrip, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 2 + + + Top + + + Microsoft Sans Serif, 11.25pt, style=Bold + + + 0, 0 + + + 4, 4, 4, 4 + + + 897, 27 + + + 0 + + + Statistics Summary + + + titelLabel + + + System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 3 + + + 333, 17 + + + True + + + 6, 13 + + + 897, 476 + + + imageList + + + System.Windows.Forms.ImageList, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + playerColumn + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + collectedFoodColumn + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + collectedFruitColumn + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + killedAntsColumn + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + killedBugsColumn + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + starvedAntsColumn + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + beatenAntsColumn + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + eatenAntsColumn + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + pointsColumn + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + loadButton + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + deleteButton + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + saveButton + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + timer + + + System.Windows.Forms.Timer, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + StatisticControl + + + System.Windows.Forms.UserControl, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/SimulationPlugin/StatisticPlugin.cs b/SimulationPlugin/StatisticPlugin.cs new file mode 100644 index 0000000..1b36322 --- /dev/null +++ b/SimulationPlugin/StatisticPlugin.cs @@ -0,0 +1,68 @@ +using System; +using System.Reflection; +using System.Windows.Forms; + +using AntMe.SharedComponents.Plugin; +using AntMe.SharedComponents.States; + +namespace AntMe.Plugin.Simulation { + [Preselected] + public sealed class StatisticPlugin : IConsumerPlugin { + private readonly string name = Resource.StatisticPluginName; + private readonly string description = Resource.StatisticPluginDescription; + private readonly Version version = Assembly.GetExecutingAssembly().GetName().Version; + private readonly Guid guid = new Guid("C83570BF-E5A7-492c-BEF2-9D25C005D6A9"); + + public StatisticPlugin() { + control = new StatisticControl(); + pluginState = PluginState.Ready; + } + + #region IConsumerPlugin Member + + private PluginState pluginState; + private StatisticControl control; + + public bool Interrupt { get { return false; } } + public void CreateState(ref SimulationState state) {} + public void CreatingState(ref SimulationState state) {} + public void CreatedState(ref SimulationState state) {} + + #endregion + + #region IPlugin Member + + public string Description { get { return description; } } + public Guid Guid { get { return guid; } } + public string Name { get { return name; } } + public Version Version { get { return version; } } + public PluginState State { get { return pluginState; } } + public Control Control { get { return control; } } + + public byte[] Settings { + get { return new byte[0]; } + set { } + } + + public void Start() { + control.Start(); + pluginState = PluginState.Running; + } + public void Stop() { + control.Stop(); + pluginState = PluginState.Ready; + } + public void Pause() { pluginState = PluginState.Paused; } + + public void StartupParameter(string[] parameter) {} + public void SetVisibility(bool visible) { + + } + + public void UpdateUI(SimulationState state) { + control.SimulationState(state); + } + + #endregion + } +} \ No newline at end of file diff --git a/SimulationPlugin/SummaryLoop.cs b/SimulationPlugin/SummaryLoop.cs new file mode 100644 index 0000000..9f7eaae --- /dev/null +++ b/SimulationPlugin/SummaryLoop.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AntMe.Plugin.Simulation +{ + /// + /// Class, to hold a summary of a single simulation-loop. + /// + internal sealed class SummaryLoop + { + public bool completed; + public int rounds; + public Dictionary teams = new Dictionary(); + } +} diff --git a/SimulationPlugin/SummaryPlayer.cs b/SimulationPlugin/SummaryPlayer.cs new file mode 100644 index 0000000..d988556 --- /dev/null +++ b/SimulationPlugin/SummaryPlayer.cs @@ -0,0 +1,10 @@ +using System; +using System.Collections.Generic; + +namespace AntMe.Plugin.Simulation { + internal sealed class SummaryPlayer { + public string name = string.Empty; + public Guid guid; + public List values = new List(); + } +} \ No newline at end of file diff --git a/SimulationPlugin/SummaryRoot.cs b/SimulationPlugin/SummaryRoot.cs new file mode 100644 index 0000000..cc927a3 --- /dev/null +++ b/SimulationPlugin/SummaryRoot.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AntMe.Plugin.Simulation +{ + /// + /// Class, to hold all statistic collections. + /// + internal sealed class SummaryRoot + { + public List simulations = new List(); + } +} diff --git a/SimulationPlugin/SummarySimulation.cs b/SimulationPlugin/SummarySimulation.cs new file mode 100644 index 0000000..8313f71 --- /dev/null +++ b/SimulationPlugin/SummarySimulation.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AntMe.Plugin.Simulation +{ + /// + /// Class, to hold the summary of a simulation-set. + /// + internal sealed class SummarySimulation + { + public DateTime startDate = DateTime.Now; + public List loops = new List(); + + } +} diff --git a/SimulationPlugin/SummaryTeam.cs b/SimulationPlugin/SummaryTeam.cs new file mode 100644 index 0000000..79c31ac --- /dev/null +++ b/SimulationPlugin/SummaryTeam.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AntMe.Plugin.Simulation +{ + internal sealed class SummaryTeam + { + public string name = string.Empty; + public Guid guid; + public Dictionary players = new Dictionary(); + } +} diff --git a/SimulationPlugin/SummaryValueSet.cs b/SimulationPlugin/SummaryValueSet.cs new file mode 100644 index 0000000..23c05c4 --- /dev/null +++ b/SimulationPlugin/SummaryValueSet.cs @@ -0,0 +1,68 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AntMe.Plugin.Simulation +{ + /// + /// Holds a single set of values for a simulation-round. + /// + [Serializable] + public sealed class SummaryValueSet + { + /// + /// Amount of collected food. + /// + public int collectedFood; + + /// + /// Amount of colleted fruit. + /// + public int collectedFruit; + + /// + /// Amount of killed foreign ants. + /// + public int killedAnts; + + /// + /// Amount of killed bugs. + /// + public int killedBugs; + + /// + /// Amount of starved ants. + /// + public int starvedAnts; + + /// + /// Amount of beaten ants. + /// + public int beatenAnts; + + /// + /// Amount of eaten ants. + /// + public int eatenAnts; + + /// + /// Total count of points. + /// + public int totalPoints; + + /// + /// Adds another valueSet to the current one. + /// + /// valueSet to add to this set. + public void Add(SummaryValueSet valueSet) { + collectedFood += valueSet.collectedFood; + collectedFruit += valueSet.collectedFruit; + killedAnts += valueSet.killedAnts; + killedBugs += valueSet.killedBugs; + starvedAnts += valueSet.starvedAnts; + beatenAnts += valueSet.beatenAnts; + eatenAnts += valueSet.eatenAnts; + totalPoints += valueSet.totalPoints; + } + } +} diff --git a/SimulationPlugin/TeamItem.cs b/SimulationPlugin/TeamItem.cs new file mode 100644 index 0000000..717731e --- /dev/null +++ b/SimulationPlugin/TeamItem.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; + +namespace AntMe.Plugin.Simulation { + /// + /// Holds information about team-configuration. + /// + [Serializable] + public sealed class TeamItem { + + /// + /// Name of team. + /// + public string Name = string.Empty; + + /// + /// List of included players. + /// + public List Players = new List(); + } +} \ No newline at end of file diff --git a/SimulationPlugin/TeamSetup.Designer.cs b/SimulationPlugin/TeamSetup.Designer.cs new file mode 100644 index 0000000..a6904de --- /dev/null +++ b/SimulationPlugin/TeamSetup.Designer.cs @@ -0,0 +1,573 @@ +namespace AntMe.Plugin.Simulation { + partial class TeamSetup + { + /// + /// Erforderliche Designervariable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Verwendete Ressourcen bereinigen. + /// + /// True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Vom Komponenten-Designer generierter Code + + /// + /// Erforderliche Methode für die Designerunterstützung. + /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(TeamSetup)); + this.splitContainer1 = new System.Windows.Forms.SplitContainer(); + this.playerListView = new System.Windows.Forms.ListView(); + this.nameColumn = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.authorColumn = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.playerContextMenu = new System.Windows.Forms.ContextMenuStrip(this.components); + this.createMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.loadMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem1 = new System.Windows.Forms.ToolStripSeparator(); + this.removeMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.propertiesMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator2 = new System.Windows.Forms.ToolStripSeparator(); + this.chooseMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.newTeamMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.chooseTeam1MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.chooseTeam2MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.chooseTeam3MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.chooseTeam4MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.chooseTeam5MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.chooseTeam6MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.chooseTeam7MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.chooseTeam8MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.imageList = new System.Windows.Forms.ImageList(this.components); + this.teamListView = new System.Windows.Forms.ListView(); + this.playerColumn = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.author2Column = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.teamContextMenu = new System.Windows.Forms.ContextMenuStrip(this.components); + this.kickMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.moveMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.moveNewTeamMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.moveTeam1MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.moveTeam2MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.moveTeam3MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.moveTeam4MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.moveTeam5MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.moveTeam6MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.moveTeam7MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.moveTeam8MenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStrip = new System.Windows.Forms.ToolStrip(); + this.createButton = new System.Windows.Forms.ToolStripButton(); + this.loadButton = new System.Windows.Forms.ToolStripButton(); + this.removeButton = new System.Windows.Forms.ToolStripButton(); + this.propertiesButton = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator(); + this.settingsButton = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator3 = new System.Windows.Forms.ToolStripSeparator(); + this.resetButton = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator4 = new System.Windows.Forms.ToolStripSeparator(); + this.settingsLabelLabel = new System.Windows.Forms.ToolStripLabel(); + this.settingsLabel = new System.Windows.Forms.ToolStripLabel(); + this.openFileDialog = new System.Windows.Forms.OpenFileDialog(); + this.titelLabel = new System.Windows.Forms.Label(); + this.timer = new System.Windows.Forms.Timer(this.components); + ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit(); + this.splitContainer1.Panel1.SuspendLayout(); + this.splitContainer1.Panel2.SuspendLayout(); + this.splitContainer1.SuspendLayout(); + this.playerContextMenu.SuspendLayout(); + this.teamContextMenu.SuspendLayout(); + this.toolStrip.SuspendLayout(); + this.SuspendLayout(); + // + // splitContainer1 + // + resources.ApplyResources(this.splitContainer1, "splitContainer1"); + this.splitContainer1.FixedPanel = System.Windows.Forms.FixedPanel.Panel2; + this.splitContainer1.Name = "splitContainer1"; + // + // splitContainer1.Panel1 + // + resources.ApplyResources(this.splitContainer1.Panel1, "splitContainer1.Panel1"); + this.splitContainer1.Panel1.Controls.Add(this.playerListView); + // + // splitContainer1.Panel2 + // + resources.ApplyResources(this.splitContainer1.Panel2, "splitContainer1.Panel2"); + this.splitContainer1.Panel2.Controls.Add(this.teamListView); + // + // playerListView + // + resources.ApplyResources(this.playerListView, "playerListView"); + this.playerListView.AllowDrop = true; + this.playerListView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.nameColumn, + this.authorColumn}); + this.playerListView.ContextMenuStrip = this.playerContextMenu; + this.playerListView.Groups.AddRange(new System.Windows.Forms.ListViewGroup[] { + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("playerListView.Groups"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("playerListView.Groups1")))}); + this.playerListView.LargeImageList = this.imageList; + this.playerListView.Name = "playerListView"; + this.playerListView.ShowItemToolTips = true; + this.playerListView.SmallImageList = this.imageList; + this.playerListView.Sorting = System.Windows.Forms.SortOrder.Ascending; + this.playerListView.UseCompatibleStateImageBehavior = false; + this.playerListView.View = System.Windows.Forms.View.Tile; + this.playerListView.ItemDrag += new System.Windows.Forms.ItemDragEventHandler(this.drag_playerList); + this.playerListView.SelectedIndexChanged += new System.EventHandler(this.select_playerList); + this.playerListView.DragDrop += new System.Windows.Forms.DragEventHandler(this.dragDrop_playerList); + this.playerListView.DragOver += new System.Windows.Forms.DragEventHandler(this.dragOver_playerList); + this.playerListView.DoubleClick += new System.EventHandler(this.button_newTeam); + // + // nameColumn + // + resources.ApplyResources(this.nameColumn, "nameColumn"); + // + // authorColumn + // + resources.ApplyResources(this.authorColumn, "authorColumn"); + // + // playerContextMenu + // + resources.ApplyResources(this.playerContextMenu, "playerContextMenu"); + this.playerContextMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.createMenuItem, + this.loadMenuItem, + this.toolStripMenuItem1, + this.removeMenuItem, + this.propertiesMenuItem, + this.toolStripSeparator2, + this.chooseMenuItem}); + this.playerContextMenu.Name = "contextMenuStrip1"; + this.playerContextMenu.Opening += new System.ComponentModel.CancelEventHandler(this.context_open); + // + // createMenuItem + // + resources.ApplyResources(this.createMenuItem, "createMenuItem"); + this.createMenuItem.Name = "createMenuItem"; + this.createMenuItem.Click += new System.EventHandler(this.button_create); + // + // loadMenuItem + // + resources.ApplyResources(this.loadMenuItem, "loadMenuItem"); + this.loadMenuItem.Name = "loadMenuItem"; + this.loadMenuItem.Click += new System.EventHandler(this.button_load); + // + // toolStripMenuItem1 + // + resources.ApplyResources(this.toolStripMenuItem1, "toolStripMenuItem1"); + this.toolStripMenuItem1.Name = "toolStripMenuItem1"; + // + // removeMenuItem + // + resources.ApplyResources(this.removeMenuItem, "removeMenuItem"); + this.removeMenuItem.Name = "removeMenuItem"; + this.removeMenuItem.Click += new System.EventHandler(this.button_remove); + // + // propertiesMenuItem + // + resources.ApplyResources(this.propertiesMenuItem, "propertiesMenuItem"); + this.propertiesMenuItem.Name = "propertiesMenuItem"; + this.propertiesMenuItem.Click += new System.EventHandler(this.button_antProperties); + // + // toolStripSeparator2 + // + resources.ApplyResources(this.toolStripSeparator2, "toolStripSeparator2"); + this.toolStripSeparator2.Name = "toolStripSeparator2"; + // + // chooseMenuItem + // + resources.ApplyResources(this.chooseMenuItem, "chooseMenuItem"); + this.chooseMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.newTeamMenuItem, + this.chooseTeam1MenuItem, + this.chooseTeam2MenuItem, + this.chooseTeam3MenuItem, + this.chooseTeam4MenuItem, + this.chooseTeam5MenuItem, + this.chooseTeam6MenuItem, + this.chooseTeam7MenuItem, + this.chooseTeam8MenuItem}); + this.chooseMenuItem.Name = "chooseMenuItem"; + // + // newTeamMenuItem + // + resources.ApplyResources(this.newTeamMenuItem, "newTeamMenuItem"); + this.newTeamMenuItem.Name = "newTeamMenuItem"; + this.newTeamMenuItem.Click += new System.EventHandler(this.button_newTeam); + // + // chooseTeam1MenuItem + // + resources.ApplyResources(this.chooseTeam1MenuItem, "chooseTeam1MenuItem"); + this.chooseTeam1MenuItem.Name = "chooseTeam1MenuItem"; + this.chooseTeam1MenuItem.Click += new System.EventHandler(this.button_newTeam1); + // + // chooseTeam2MenuItem + // + resources.ApplyResources(this.chooseTeam2MenuItem, "chooseTeam2MenuItem"); + this.chooseTeam2MenuItem.Name = "chooseTeam2MenuItem"; + this.chooseTeam2MenuItem.Click += new System.EventHandler(this.button_newTeam2); + // + // chooseTeam3MenuItem + // + resources.ApplyResources(this.chooseTeam3MenuItem, "chooseTeam3MenuItem"); + this.chooseTeam3MenuItem.Name = "chooseTeam3MenuItem"; + this.chooseTeam3MenuItem.Click += new System.EventHandler(this.button_newTeam3); + // + // chooseTeam4MenuItem + // + resources.ApplyResources(this.chooseTeam4MenuItem, "chooseTeam4MenuItem"); + this.chooseTeam4MenuItem.Name = "chooseTeam4MenuItem"; + this.chooseTeam4MenuItem.Click += new System.EventHandler(this.button_newTeam4); + // + // chooseTeam5MenuItem + // + resources.ApplyResources(this.chooseTeam5MenuItem, "chooseTeam5MenuItem"); + this.chooseTeam5MenuItem.Name = "chooseTeam5MenuItem"; + this.chooseTeam5MenuItem.Click += new System.EventHandler(this.button_newTeam5); + // + // chooseTeam6MenuItem + // + resources.ApplyResources(this.chooseTeam6MenuItem, "chooseTeam6MenuItem"); + this.chooseTeam6MenuItem.Name = "chooseTeam6MenuItem"; + this.chooseTeam6MenuItem.Click += new System.EventHandler(this.button_newTeam6); + // + // chooseTeam7MenuItem + // + resources.ApplyResources(this.chooseTeam7MenuItem, "chooseTeam7MenuItem"); + this.chooseTeam7MenuItem.Name = "chooseTeam7MenuItem"; + this.chooseTeam7MenuItem.Click += new System.EventHandler(this.button_newTeam7); + // + // chooseTeam8MenuItem + // + resources.ApplyResources(this.chooseTeam8MenuItem, "chooseTeam8MenuItem"); + this.chooseTeam8MenuItem.Name = "chooseTeam8MenuItem"; + this.chooseTeam8MenuItem.Click += new System.EventHandler(this.button_newTeam8); + // + // imageList + // + this.imageList.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList.ImageStream"))); + this.imageList.TransparentColor = System.Drawing.Color.Transparent; + this.imageList.Images.SetKeyName(0, "nonstatic"); + this.imageList.Images.SetKeyName(1, "nonstatic_disabled"); + this.imageList.Images.SetKeyName(2, "nonstatic_disabled_secure"); + this.imageList.Images.SetKeyName(3, "nonstatic_secure"); + this.imageList.Images.SetKeyName(4, "static"); + this.imageList.Images.SetKeyName(5, "static_disabled"); + this.imageList.Images.SetKeyName(6, "static_secure"); + this.imageList.Images.SetKeyName(7, "static_disabled_secure"); + // + // teamListView + // + resources.ApplyResources(this.teamListView, "teamListView"); + this.teamListView.AllowDrop = true; + this.teamListView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.playerColumn, + this.author2Column}); + this.teamListView.ContextMenuStrip = this.teamContextMenu; + this.teamListView.Groups.AddRange(new System.Windows.Forms.ListViewGroup[] { + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("teamListView.Groups"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("teamListView.Groups1"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("teamListView.Groups2"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("teamListView.Groups3"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("teamListView.Groups4"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("teamListView.Groups5"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("teamListView.Groups6"))), + ((System.Windows.Forms.ListViewGroup)(resources.GetObject("teamListView.Groups7")))}); + this.teamListView.LargeImageList = this.imageList; + this.teamListView.Name = "teamListView"; + this.teamListView.ShowItemToolTips = true; + this.teamListView.SmallImageList = this.imageList; + this.teamListView.UseCompatibleStateImageBehavior = false; + this.teamListView.View = System.Windows.Forms.View.Tile; + this.teamListView.ItemDrag += new System.Windows.Forms.ItemDragEventHandler(this.drag_teamList); + this.teamListView.SelectedIndexChanged += new System.EventHandler(this.select_teamList); + this.teamListView.DragDrop += new System.Windows.Forms.DragEventHandler(this.dragDrop_teamList); + this.teamListView.DragOver += new System.Windows.Forms.DragEventHandler(this.dragOver_teamList); + // + // playerColumn + // + resources.ApplyResources(this.playerColumn, "playerColumn"); + // + // author2Column + // + resources.ApplyResources(this.author2Column, "author2Column"); + // + // teamContextMenu + // + resources.ApplyResources(this.teamContextMenu, "teamContextMenu"); + this.teamContextMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.kickMenuItem, + this.moveMenuItem}); + this.teamContextMenu.Name = "teamContextMenu"; + // + // kickMenuItem + // + resources.ApplyResources(this.kickMenuItem, "kickMenuItem"); + this.kickMenuItem.Name = "kickMenuItem"; + this.kickMenuItem.Click += new System.EventHandler(this.button_removeFromTeam); + // + // moveMenuItem + // + resources.ApplyResources(this.moveMenuItem, "moveMenuItem"); + this.moveMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.moveNewTeamMenuItem, + this.moveTeam1MenuItem, + this.moveTeam2MenuItem, + this.moveTeam3MenuItem, + this.moveTeam4MenuItem, + this.moveTeam5MenuItem, + this.moveTeam6MenuItem, + this.moveTeam7MenuItem, + this.moveTeam8MenuItem}); + this.moveMenuItem.Name = "moveMenuItem"; + // + // moveNewTeamMenuItem + // + resources.ApplyResources(this.moveNewTeamMenuItem, "moveNewTeamMenuItem"); + this.moveNewTeamMenuItem.Name = "moveNewTeamMenuItem"; + this.moveNewTeamMenuItem.Click += new System.EventHandler(this.button_moveNewTeam); + // + // moveTeam1MenuItem + // + resources.ApplyResources(this.moveTeam1MenuItem, "moveTeam1MenuItem"); + this.moveTeam1MenuItem.Name = "moveTeam1MenuItem"; + this.moveTeam1MenuItem.Click += new System.EventHandler(this.button_moveTeam1); + // + // moveTeam2MenuItem + // + resources.ApplyResources(this.moveTeam2MenuItem, "moveTeam2MenuItem"); + this.moveTeam2MenuItem.Name = "moveTeam2MenuItem"; + this.moveTeam2MenuItem.Click += new System.EventHandler(this.button_moveTeam2); + // + // moveTeam3MenuItem + // + resources.ApplyResources(this.moveTeam3MenuItem, "moveTeam3MenuItem"); + this.moveTeam3MenuItem.Name = "moveTeam3MenuItem"; + this.moveTeam3MenuItem.Click += new System.EventHandler(this.button_moveTeam3); + // + // moveTeam4MenuItem + // + resources.ApplyResources(this.moveTeam4MenuItem, "moveTeam4MenuItem"); + this.moveTeam4MenuItem.Name = "moveTeam4MenuItem"; + this.moveTeam4MenuItem.Click += new System.EventHandler(this.button_moveTeam4); + // + // moveTeam5MenuItem + // + resources.ApplyResources(this.moveTeam5MenuItem, "moveTeam5MenuItem"); + this.moveTeam5MenuItem.Name = "moveTeam5MenuItem"; + this.moveTeam5MenuItem.Click += new System.EventHandler(this.button_moveTeam5); + // + // moveTeam6MenuItem + // + resources.ApplyResources(this.moveTeam6MenuItem, "moveTeam6MenuItem"); + this.moveTeam6MenuItem.Name = "moveTeam6MenuItem"; + this.moveTeam6MenuItem.Click += new System.EventHandler(this.button_moveTeam6); + // + // moveTeam7MenuItem + // + resources.ApplyResources(this.moveTeam7MenuItem, "moveTeam7MenuItem"); + this.moveTeam7MenuItem.Name = "moveTeam7MenuItem"; + this.moveTeam7MenuItem.Click += new System.EventHandler(this.button_moveTeam7); + // + // moveTeam8MenuItem + // + resources.ApplyResources(this.moveTeam8MenuItem, "moveTeam8MenuItem"); + this.moveTeam8MenuItem.Name = "moveTeam8MenuItem"; + this.moveTeam8MenuItem.Click += new System.EventHandler(this.button_moveTeam8); + // + // toolStrip + // + resources.ApplyResources(this.toolStrip, "toolStrip"); + this.toolStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.createButton, + this.loadButton, + this.removeButton, + this.propertiesButton, + this.toolStripSeparator1, + this.settingsButton, + this.toolStripSeparator3, + this.resetButton, + this.toolStripSeparator4, + this.settingsLabelLabel, + this.settingsLabel}); + this.toolStrip.Name = "toolStrip"; + // + // createButton + // + resources.ApplyResources(this.createButton, "createButton"); + this.createButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.createButton.Image = global::AntMe.Plugin.Simulation.Properties.Resources.add; + this.createButton.Name = "createButton"; + this.createButton.Click += new System.EventHandler(this.button_create); + // + // loadButton + // + resources.ApplyResources(this.loadButton, "loadButton"); + this.loadButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.loadButton.Image = global::AntMe.Plugin.Simulation.Properties.Resources.load_16x16; + this.loadButton.Name = "loadButton"; + this.loadButton.Click += new System.EventHandler(this.button_load); + // + // removeButton + // + resources.ApplyResources(this.removeButton, "removeButton"); + this.removeButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.removeButton.Image = global::AntMe.Plugin.Simulation.Properties.Resources.delete_16x16; + this.removeButton.Name = "removeButton"; + this.removeButton.Click += new System.EventHandler(this.button_remove); + // + // propertiesButton + // + resources.ApplyResources(this.propertiesButton, "propertiesButton"); + this.propertiesButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.propertiesButton.Image = global::AntMe.Plugin.Simulation.Properties.Resources.properties_16x16; + this.propertiesButton.Name = "propertiesButton"; + this.propertiesButton.Click += new System.EventHandler(this.button_antProperties); + // + // toolStripSeparator1 + // + resources.ApplyResources(this.toolStripSeparator1, "toolStripSeparator1"); + this.toolStripSeparator1.Name = "toolStripSeparator1"; + // + // settingsButton + // + resources.ApplyResources(this.settingsButton, "settingsButton"); + this.settingsButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.settingsButton.Image = global::AntMe.Plugin.Simulation.Properties.Resources.settings_16x16; + this.settingsButton.Name = "settingsButton"; + this.settingsButton.Click += new System.EventHandler(this.button_settings); + // + // toolStripSeparator3 + // + resources.ApplyResources(this.toolStripSeparator3, "toolStripSeparator3"); + this.toolStripSeparator3.Name = "toolStripSeparator3"; + // + // resetButton + // + resources.ApplyResources(this.resetButton, "resetButton"); + this.resetButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.resetButton.Image = global::AntMe.Plugin.Simulation.Properties.Resources.resetteams; + this.resetButton.Name = "resetButton"; + this.resetButton.Click += new System.EventHandler(this.button_reset); + // + // toolStripSeparator4 + // + resources.ApplyResources(this.toolStripSeparator4, "toolStripSeparator4"); + this.toolStripSeparator4.Name = "toolStripSeparator4"; + // + // settingsLabelLabel + // + resources.ApplyResources(this.settingsLabelLabel, "settingsLabelLabel"); + this.settingsLabelLabel.Name = "settingsLabelLabel"; + // + // settingsLabel + // + resources.ApplyResources(this.settingsLabel, "settingsLabel"); + this.settingsLabel.Name = "settingsLabel"; + // + // openFileDialog + // + this.openFileDialog.DefaultExt = "*.dll"; + resources.ApplyResources(this.openFileDialog, "openFileDialog"); + this.openFileDialog.Multiselect = true; + // + // titelLabel + // + resources.ApplyResources(this.titelLabel, "titelLabel"); + this.titelLabel.BackColor = System.Drawing.SystemColors.AppWorkspace; + this.titelLabel.ForeColor = System.Drawing.SystemColors.HighlightText; + this.titelLabel.Name = "titelLabel"; + // + // timer + // + this.timer.Tick += new System.EventHandler(this.timer_Tick); + // + // TeamSetup + // + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.splitContainer1); + this.Controls.Add(this.toolStrip); + this.Controls.Add(this.titelLabel); + this.Name = "TeamSetup"; + this.splitContainer1.Panel1.ResumeLayout(false); + this.splitContainer1.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit(); + this.splitContainer1.ResumeLayout(false); + this.playerContextMenu.ResumeLayout(false); + this.teamContextMenu.ResumeLayout(false); + this.toolStrip.ResumeLayout(false); + this.toolStrip.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.ContextMenuStrip playerContextMenu; + private System.Windows.Forms.ToolStripMenuItem loadMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripMenuItem1; + private System.Windows.Forms.ToolStripMenuItem removeMenuItem; + private System.Windows.Forms.ToolStripMenuItem propertiesMenuItem; + private System.Windows.Forms.OpenFileDialog openFileDialog; + private System.Windows.Forms.SplitContainer splitContainer1; + private System.Windows.Forms.ListView playerListView; + private System.Windows.Forms.ColumnHeader nameColumn; + private System.Windows.Forms.ColumnHeader authorColumn; + private System.Windows.Forms.ListView teamListView; + private System.Windows.Forms.ColumnHeader playerColumn; + private System.Windows.Forms.ToolStrip toolStrip; + private System.Windows.Forms.ToolStripButton loadButton; + private System.Windows.Forms.ToolStripButton removeButton; + private System.Windows.Forms.ToolStripButton propertiesButton; + private System.Windows.Forms.Label titelLabel; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator1; + private System.Windows.Forms.ToolStripButton settingsButton; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator2; + private System.Windows.Forms.ToolStripMenuItem chooseMenuItem; + private System.Windows.Forms.ToolStripMenuItem newTeamMenuItem; + private System.Windows.Forms.ToolStripMenuItem chooseTeam1MenuItem; + private System.Windows.Forms.ToolStripMenuItem chooseTeam2MenuItem; + private System.Windows.Forms.ToolStripMenuItem chooseTeam3MenuItem; + private System.Windows.Forms.ToolStripMenuItem chooseTeam4MenuItem; + private System.Windows.Forms.ToolStripMenuItem chooseTeam5MenuItem; + private System.Windows.Forms.ToolStripMenuItem chooseTeam6MenuItem; + private System.Windows.Forms.ToolStripMenuItem chooseTeam7MenuItem; + private System.Windows.Forms.ToolStripMenuItem chooseTeam8MenuItem; + private System.Windows.Forms.ContextMenuStrip teamContextMenu; + private System.Windows.Forms.ToolStripMenuItem kickMenuItem; + private System.Windows.Forms.ToolStripMenuItem moveMenuItem; + private System.Windows.Forms.ToolStripMenuItem moveNewTeamMenuItem; + private System.Windows.Forms.ToolStripMenuItem moveTeam1MenuItem; + private System.Windows.Forms.ToolStripMenuItem moveTeam2MenuItem; + private System.Windows.Forms.ToolStripMenuItem moveTeam3MenuItem; + private System.Windows.Forms.ToolStripMenuItem moveTeam4MenuItem; + private System.Windows.Forms.ToolStripMenuItem moveTeam5MenuItem; + private System.Windows.Forms.ToolStripMenuItem moveTeam6MenuItem; + private System.Windows.Forms.ToolStripMenuItem moveTeam7MenuItem; + private System.Windows.Forms.ToolStripMenuItem moveTeam8MenuItem; + private System.Windows.Forms.ImageList imageList; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator3; + private System.Windows.Forms.ToolStripButton resetButton; + private System.Windows.Forms.Timer timer; + private System.Windows.Forms.ColumnHeader author2Column; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator4; + private System.Windows.Forms.ToolStripLabel settingsLabelLabel; + private System.Windows.Forms.ToolStripLabel settingsLabel; + private System.Windows.Forms.ToolStripButton createButton; + private System.Windows.Forms.ToolStripMenuItem createMenuItem; + } +} \ No newline at end of file diff --git a/SimulationPlugin/TeamSetup.cs b/SimulationPlugin/TeamSetup.cs new file mode 100644 index 0000000..1ee92f0 --- /dev/null +++ b/SimulationPlugin/TeamSetup.cs @@ -0,0 +1,1057 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.IO; +using System.Windows.Forms; + +using AntMe.Plugin.Simulation.Properties; +using AntMe.Simulation; +using System.Diagnostics; + +namespace AntMe.Plugin.Simulation { + internal partial class TeamSetup : UserControl { + private SimulationPluginConfiguration config; + private readonly List players; + private bool ignoreUpdates; + private bool active; + + public TeamSetup(SimulationPluginConfiguration config, List players) { + this.players = players; + Configuration = config; + + InitializeComponent(); + ignoreUpdates = true; + + ignoreUpdates = false; + timer.Enabled = true; + UpdatePanel(); + } + + #region internal Methods + + /// + /// Loads all players from filename and add them to the global player-list. + /// + /// filename + /// if only known players should be added + /// true, if there was no Exception + /// starts silent start without error-messages + private List loadPlayerFile(string filename, bool knownOnly, bool silent) { + List foundPlayers = new List(); + List output = new List(); + try { + FileInfo file = new FileInfo(filename.ToLower()); + + // Load playerinfo + try { + foundPlayers.AddRange(AiAnalysis.Analyse(file.FullName, false)); + } + catch (Exception ex) { + if (!silent) { + showException(ex); + } + return output; + } + + // Add found players + if (foundPlayers.Count > 0) { + if (!config.knownPlayerFiles.Contains(file.FullName)) { + config.knownPlayerFiles.Add(file.FullName); + } + bool found = false; + foreach (PlayerInfo playerInfo in foundPlayers) { + PlayerInfoFilename info = new PlayerInfoFilename(playerInfo, file.FullName); + output.Add(info); + + if (!players.Contains(info)) { + if (knownOnly) { + if (!config.knownPlayer.Contains(info.GetHashCode())) { + continue; + } + } + else { + if (!config.knownPlayer.Contains(info.GetHashCode())) { + config.knownPlayer.Add(info.GetHashCode()); + } + } + players.Add(info); + found = true; + } + } + + if (!found && !knownOnly && !silent) { + MessageBox.Show( + this, + string.Format(Resource.SimulatorPluginTeamSetupStillLoaded, file.FullName), + Resource.SimulationPluginMessageBoxTitle, + MessageBoxButtons.OK, + MessageBoxIcon.Information); + } + } + else { + if (!silent) { + MessageBox.Show( + this, + string.Format(Resource.SimulatorPluginTeamSetupNoFolksFound, file.FullName), + Resource.SimulationPluginMessageBoxTitle, + MessageBoxButtons.OK, + MessageBoxIcon.Information); + } + } + } + catch (Exception ex) { + showException( + new Exception( + string.Format( + Resource.SimulatorPluginTeamSetupFileloadException, + filename, + ex.Message), + ex)); + } + + UpdatePanel(); + return output; + } + + /// + /// removes the whole player from game. + /// + /// + private void removePlayer(PlayerInfoFilename player) { + // Remove from List + if (players.Contains(player)) { + players.Remove(player); + } + + // Remove from known players + players.Remove(player); + config.knownPlayer.Remove(player.GetHashCode()); + + // Remove from teams + for (int i = 0; i < config.teams.Length; i++) { + for (int j = 0; j < config.teams[i].Players.Count; j++) { + PlayerItem item = config.teams[i].Players[j]; + + if (item.FileName == player.File && item.ClassName == player.ClassName) { + config.teams[i].Players.Remove(item); + j--; + } + } + } + + // Remove known files, if no more players enabled + bool hit = false; + for (int i = 0; i < players.Count; i++) { + if (players[i].File == player.File) { + hit = true; + break; + } + } + if (!hit) { + config.knownPlayerFiles.Remove(player.File); + } + + UpdatePanel(); + } + + /// + /// Shows the property-window for ants. + /// + /// target player + private void playerProperties(PlayerInfoFilename player) { + AntProperties properties = new AntProperties(player); + properties.ShowDialog(this); + } + + /// + /// Adds a to a team + /// + /// item + /// team, or null for a new team + private void addPlayerToTeam(PlayerItem[] item, TeamItem team) { + // Find the right team, if target-team is null + if (team == null) { + int items = SimulatorConfiguration.PLAYERLIMIT + 1; + + // If team is null, search for empty team + for (int i = 0; i < config.teams.Length; i++) { + if (config.teams[i].Players.Count < items) { + team = config.teams[i]; + items = team.Players.Count; + } + } + + // If there are no more empty teams, use the last one + if (team == null) { + team = config.teams[config.teams.Length - 1]; + } + } + + // Find out, how many players are enabled + int activePlayers = 0; + for (int i = 0; i < config.teams.Length; i++) { + activePlayers += config.teams[i].Players.Count; + } + + // Add to playerlist + for (int i = 0; i < item.Length; i++) { + if (activePlayers >= SimulatorConfiguration.PLAYERLIMIT) { + break; + } + + team.Players.Add(item[i]); + activePlayers++; + } + + UpdatePanel(); + } + + /// + /// Adds a player to a team. + /// + /// player + /// team + private void addPlayerToTeam(PlayerInfoFilename info, TeamItem team) { + if (ReadyCheck(info, false, false)) { + addPlayerToTeam(new PlayerItem[] {new PlayerItem(info)}, team); + } + } + + /// + /// Adds player to a new team. + /// + /// List of players to add + /// silent mode + private void addPlayerToTeam(PlayerInfoFilename[] info, bool silent) { + List items = new List(); + for (int i = 0; i < info.Length; i++) { + if (ReadyCheck(info[i], silent, silent)) { + items.Add(new PlayerItem(info[i])); + } + } + addPlayerToTeam(items.ToArray(), null); + } + + /// + /// Checks the given player for match-readyness. + /// + /// requested player + /// shows no messageboxes and requests + /// asume, that the testet player is secure + /// true, if everything is fine + private bool ReadyCheck(PlayerInfoFilename player, bool silent, bool secure) { + + // Rulevalidation + if (!RightsRequest.IsValidPlayer(player)) { + + // Messagebox, if not silent + if (!silent) { + MessageBox.Show( + this, + RightsRequest.GetRuleViolationMessage(player), + Resource.SimulationPluginMessageBoxTitle, + MessageBoxButtons.OK, + MessageBoxIcon.Exclamation); + } + + return false; + } + + // if colony is ready to start without request, do that + if (!RightsRequest.RequestRights(player)) { + return true; + } + + // Security-override + if (secure && !RightsRequest.LockedRights(config, player)) { + return true; + } + + // Ask for request + RightsRequest form = new RightsRequest(config, player); + if (!silent && form.ShowDialog(this) == DialogResult.Yes) { + return true; + } + return false; + } + + /// + /// Removes a player from team + /// + /// player + private void removePlayerFromTeam(IEnumerable item) { + removePlayerFromTeam(item, true); + } + + /// + /// Removes a player from team + /// + /// player + /// should empty teams bubble out + private void removePlayerFromTeam(IEnumerable item, bool bubble) { + // Remove item from all teams + foreach (PlayerItem playerItem in item) { + for (int i = 0; i < config.teams.Length; i++) { + if (config.teams[i].Players.Contains(playerItem)) { + config.teams[i].Players.Remove(playerItem); + } + } + } + + if (bubble) { + bubbleTeams(); + UpdatePanel(); + } + } + + /// + /// Moves a player to another team. + /// + /// player + /// target team + private void movePlayerToTeam(PlayerItem[] item, TeamItem targetTeam) { + removePlayerFromTeam(item, false); + addPlayerToTeam(item, targetTeam); + bubbleTeams(); + UpdatePanel(); + } + + private void bubbleTeams() { + int gap = 0; + for (int i = 0; i < config.teams.Length; i++) { + if (config.teams[i].Players.Count == 0) { + gap++; + } + else if (config.teams[i - gap].Players.Count == 0) { + TeamItem lower = config.teams[i - gap]; + TeamItem current = config.teams[i]; + lower.Players.AddRange(current.Players); + current.Players.Clear(); + } + } + } + + /// + /// resets the whole team-settings. + /// + private void resetTeams() { + for (int i = 0; i < config.teams.Length; i++) { + config.teams[i].Players.Clear(); + } + UpdatePanel(); + } + + /// + /// Updates the view. + /// + public void UpdatePanel() { + if (ignoreUpdates) { + return; + } + + ignoreUpdates = true; + + settingsLabel.Text = config.configuration.Settings.SettingsName; + + #region playerListUpdate + + // Delete items + for (int i = 0; i < playerListView.Items.Count; i++) { + if (!players.Contains((PlayerInfoFilename) playerListView.Items[i].Tag)) { + playerListView.Items.RemoveAt(i); + i--; + } + } + + // Create new items + ListViewGroup staticGroup = playerListView.Groups["staticGroup"]; + ListViewGroup nonstaticGroup = playerListView.Groups["nonStaticGroup"]; + for (int i = 0; i < players.Count; i++) { + PlayerInfoFilename info = players[i]; + if (!playerListView.Items.ContainsKey(info.GetHashCode().ToString())) { + ListViewItem item = playerListView.Items.Add(info.GetHashCode().ToString(), info.ColonyName, 0); + item.Tag = info; + item.Group = info.Static ? staticGroup : nonstaticGroup; + item.SubItems.Add( + string.Format(Resource.SimulatorPluginAntPropertiesAuthorFormat, info.FirstName, info.LastName)); + } + } + + // Update Icon + foreach (ListViewItem listViewItem in playerListView.Items) { + + // collect infos + PlayerInfoFilename playerInfo = (PlayerInfoFilename) listViewItem.Tag; + + bool playerStatic = playerInfo.Static; + bool playerEnabled = true; + bool playerSecure = RightsRequest.RequestRights(playerInfo); + string hintText = string.Empty; + + if (!RightsRequest.IsValidPlayer(playerInfo)) { + playerEnabled = false; + hintText = RightsRequest.GetRuleViolationMessage(playerInfo); + } + else if (RightsRequest.LockedRights(config, playerInfo)) { + playerEnabled = false; + hintText = RightsRequest.RequiredRightsList(config, playerInfo); + } + + // Set Information to Item + listViewItem.ImageKey = + (playerStatic ? "static" : "nonstatic") + + (!playerEnabled ? "_disabled" : string.Empty) + + (playerSecure ? "_secure" : string.Empty); + listViewItem.ToolTipText = hintText; + } + + #endregion + + #region teamListUpdate + + // Kick player + List kickedPlayer = new List(); + for (int i = 0; i < teamListView.Items.Count; i++) { + PlayerItem player = (PlayerItem) teamListView.Items[i].Tag; + if (!config.teams[0].Players.Contains(player) && + !config.teams[1].Players.Contains(player) && + !config.teams[2].Players.Contains(player) && + !config.teams[3].Players.Contains(player) && + !config.teams[4].Players.Contains(player) && + !config.teams[5].Players.Contains(player) && + !config.teams[6].Players.Contains(player) && + !config.teams[7].Players.Contains(player)) { + teamListView.Items.RemoveAt(i); + i--; + continue; + } + + for (int j = 0; j < 8; j++) { + if (config.teams[j].Players.Contains(player)) { + if (!RightsRequest.IsValidPlayer(player.PlayerInfo) || + RightsRequest.LockedRights(config, player.PlayerInfo)) { + + kickedPlayer.Add( + string.Format( + Resource.SimulationPluginKicklistEntry, + player.ColonyName, + player.FileName, + player.ClassName, + player.AuthorName)); + teamListView.Items.RemoveAt(i); + config.teams[j].Players.Remove(player); + i--; + } + break; + } + } + } + + if (kickedPlayer.Count > 0) { + MessageBox.Show( + this, + Resource.SimulationPluginKicklistHead + Environment.NewLine + Environment.NewLine + + string.Join(Environment.NewLine, kickedPlayer.ToArray()), + Resource.SimulationPluginMessageBoxTitle, + MessageBoxButtons.OK, + MessageBoxIcon.Information); + } + + // Create new items and update Context-menues + for (int i = 0; i < config.teams.Length; i++) { + ListViewGroup group = teamListView.Groups["teamGroup" + i]; + + for (int j = 0; j < config.teams[i].Players.Count; j++) { + PlayerItem player = config.teams[i].Players[j]; + + if (teamListView.Items.ContainsKey(player.Guid.ToString())) { + ListViewItem item = teamListView.Items[player.Guid.ToString()]; + if (item.Group != group) { + item.Group = group; + } + } + else { + ListViewItem item = teamListView.Items.Add( + player.Guid.ToString(), + player.ColonyName, + (player.PlayerInfo.Static ? "static" : "nonstatic")); + item.SubItems.Add(player.AuthorName); + item.Tag = player; + item.Group = group; + } + } + } + + // Update Team-Lists in Context-Menues + newTeamMenuItem.Enabled = (config.teams[7].Players.Count == 0); + chooseTeam1MenuItem.Visible = (config.teams[0].Players.Count > 0); + chooseTeam2MenuItem.Visible = (config.teams[1].Players.Count > 0); + chooseTeam3MenuItem.Visible = (config.teams[2].Players.Count > 0); + chooseTeam4MenuItem.Visible = (config.teams[3].Players.Count > 0); + chooseTeam5MenuItem.Visible = (config.teams[4].Players.Count > 0); + chooseTeam6MenuItem.Visible = (config.teams[5].Players.Count > 0); + chooseTeam7MenuItem.Visible = (config.teams[6].Players.Count > 0); + chooseTeam8MenuItem.Visible = (config.teams[7].Players.Count > 0); + + moveNewTeamMenuItem.Enabled = (config.teams[7].Players.Count == 0); + moveTeam1MenuItem.Visible = (config.teams[0].Players.Count > 0); + moveTeam2MenuItem.Visible = (config.teams[1].Players.Count > 0); + moveTeam3MenuItem.Visible = (config.teams[2].Players.Count > 0); + moveTeam4MenuItem.Visible = (config.teams[3].Players.Count > 0); + moveTeam5MenuItem.Visible = (config.teams[4].Players.Count > 0); + moveTeam6MenuItem.Visible = (config.teams[5].Players.Count > 0); + moveTeam7MenuItem.Visible = (config.teams[6].Players.Count > 0); + moveTeam8MenuItem.Visible = (config.teams[7].Players.Count > 0); + + #endregion + + ignoreUpdates = false; + } + + /// + /// Shows a nice message-box with exception-information. + /// + /// exception + private void showException(Exception ex) { + MessageBox.Show( + this, + string.Format(Resource.SimulationPluginExcetionIntro, ex.Message), + Resource.SimulationPluginMessageBoxTitle, + MessageBoxButtons.OK, + MessageBoxIcon.Exclamation); + } + + /// + /// Searches in the current application-path for valid folks. + /// + public void AutoDiscoverAiFiles() { + string path = Directory.GetCurrentDirectory(); + + string[] potentialFiles = Directory.GetFiles(path, Resources.SimulatorPluginFolkFileFilter); + + foreach (string file in potentialFiles) { + loadPlayerFile(file, false, true); + } + UpdatePanel(); + } + + #endregion + + #region Properties + + public bool Active { + get { return active; } + set { active = value; } + } + + public SimulationPluginConfiguration Configuration { + get { return config; } + set { + if (value == null) { + throw new ArgumentNullException("value"); + } + + config = value; + + // Reset lists + players.Clear(); + + // Initialize known stuff + for (int i = 0; i < config.knownPlayerFiles.Count; i++) { + loadPlayerFile(config.knownPlayerFiles[i], true, true); + } + + // Check, if the used player in saved teamsettings still there + for (int i = 0; i < config.teams.Length; i++) { + // If Team is still null + if (config.teams[i] == null) { + config.teams[i] = new TeamItem(); + continue; + } + + for (int j = 0; j < config.teams[i].Players.Count; j++) { + // If Player is still null + if (config.teams[i].Players == null) { + config.teams[i].Players = new List(); + continue; + } + + // Search for player + PlayerItem item = config.teams[i].Players[j]; + bool hit = false; + foreach (PlayerInfoFilename player in players) { + if (player.File == item.FileName && + player.ClassName == item.ClassName) { + hit = true; + break; + } + } + + // kick playerItem, if there is no suitable player + if (!hit) { + config.teams[i].Players.RemoveAt(j); + j--; + } + } + } + + // Load Settings + if (config.settingFile != string.Empty) { + try { + config.configuration.Settings = SimulationSettings.LoadSettings(config.settingFile); + SimulationSettings.SetCustomSettings(config.configuration.Settings); + } + catch (Exception ex) { + showException(ex); + config.configuration.Settings.SetDefaults(); + config.settingFile = string.Empty; + config.knownSettingFiles.Remove(config.settingFile); + } + } + else { + config.configuration.Settings.SetDefaults(); + SimulationSettings.SetCustomSettings(SimulationSettings.Default); + } + } + } + + #endregion + + #region public Methods + + /// + /// Prepares Simulation for a direct start via debugger + /// + /// target file + public void DirectStart(string filename) { + resetTeams(); + loadPlayerFile(filename, false, true); + + foreach (PlayerInfoFilename player in players) { + if (filename.ToLower() == player.File) { + addPlayerToTeam(new PlayerInfoFilename[] {player}, true); + } + } + } + + #endregion + + #region Form-Events + + #region Buttons + + private void button_create(object sender, EventArgs e) + { + using (CreateForm form = new CreateForm()) + { + if (form.ShowDialog(this) == DialogResult.OK) + { + // Start Visual Studio + Process.Start(form.GeneratedSolutionFile); + } + } + } + + private void button_load(object sender, EventArgs e) { + if (openFileDialog.ShowDialog(this) == DialogResult.OK) { + foreach (string fileName in openFileDialog.FileNames) { + loadPlayerFile(fileName, false, false); + } + } + } + + private void button_remove(object sender, EventArgs e) { + foreach (ListViewItem listViewItem in playerListView.SelectedItems) { + PlayerInfoFilename info = (PlayerInfoFilename) listViewItem.Tag; + removePlayer(info); + } + } + + private void button_antProperties(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + PlayerInfoFilename info = (PlayerInfoFilename) playerListView.SelectedItems[0].Tag; + playerProperties(info); + } + } + + private void button_settings(object sender, EventArgs e) { + SimulationProperties form = new SimulationProperties(config); + if (form.ShowDialog(this) == DialogResult.OK) { + UpdatePanel(); + } + } + + private void button_newTeam(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + PlayerInfoFilename[] selectedPlayer = new PlayerInfoFilename[playerListView.SelectedItems.Count]; + for (int i = 0; i < playerListView.SelectedItems.Count; i++) { + selectedPlayer[i] = (PlayerInfoFilename) playerListView.SelectedItems[i].Tag; + } + addPlayerToTeam(selectedPlayer, false); + } + } + + private void button_newTeam1(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + foreach (ListViewItem item in playerListView.SelectedItems) { + PlayerInfoFilename info = (PlayerInfoFilename) item.Tag; + addPlayerToTeam(info, config.teams[0]); + } + } + } + + private void button_newTeam2(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + foreach (ListViewItem item in playerListView.SelectedItems) { + PlayerInfoFilename info = (PlayerInfoFilename) item.Tag; + addPlayerToTeam(info, config.teams[1]); + } + } + } + + private void button_newTeam3(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + foreach (ListViewItem item in playerListView.SelectedItems) { + PlayerInfoFilename info = (PlayerInfoFilename) item.Tag; + addPlayerToTeam(info, config.teams[2]); + } + } + } + + private void button_newTeam4(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + foreach (ListViewItem item in playerListView.SelectedItems) { + PlayerInfoFilename info = (PlayerInfoFilename) item.Tag; + addPlayerToTeam(info, config.teams[3]); + } + } + } + + private void button_newTeam5(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + foreach (ListViewItem item in playerListView.SelectedItems) { + PlayerInfoFilename info = (PlayerInfoFilename) item.Tag; + addPlayerToTeam(info, config.teams[4]); + } + } + } + + private void button_newTeam6(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + foreach (ListViewItem item in playerListView.SelectedItems) { + PlayerInfoFilename info = (PlayerInfoFilename) item.Tag; + addPlayerToTeam(info, config.teams[5]); + } + } + } + + private void button_newTeam7(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + foreach (ListViewItem item in playerListView.SelectedItems) { + PlayerInfoFilename info = (PlayerInfoFilename) item.Tag; + addPlayerToTeam(info, config.teams[6]); + } + } + } + + private void button_newTeam8(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + foreach (ListViewItem item in playerListView.SelectedItems) { + PlayerInfoFilename info = (PlayerInfoFilename) item.Tag; + addPlayerToTeam(info, config.teams[7]); + } + } + } + + private void button_removeFromTeam(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + PlayerItem[] playerItems = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + playerItems[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + removePlayerFromTeam(playerItems); + } + } + + private void button_moveNewTeam(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + PlayerItem[] playerItems = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + playerItems[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + movePlayerToTeam(playerItems, null); + } + } + + private void button_moveTeam1(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + PlayerItem[] playerItems = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + playerItems[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + movePlayerToTeam(playerItems, config.teams[0]); + } + } + + private void button_moveTeam2(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + PlayerItem[] playerItems = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + playerItems[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + movePlayerToTeam(playerItems, config.teams[1]); + } + } + + private void button_moveTeam3(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + PlayerItem[] playerItems = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + playerItems[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + movePlayerToTeam(playerItems, config.teams[2]); + } + } + + private void button_moveTeam4(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + PlayerItem[] playerItems = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + playerItems[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + movePlayerToTeam(playerItems, config.teams[3]); + } + } + + private void button_moveTeam5(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + PlayerItem[] playerItems = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + playerItems[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + movePlayerToTeam(playerItems, config.teams[4]); + } + } + + private void button_moveTeam6(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + PlayerItem[] playerItems = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + playerItems[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + movePlayerToTeam(playerItems, config.teams[5]); + } + } + + private void button_moveTeam7(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + PlayerItem[] playerItems = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + playerItems[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + movePlayerToTeam(playerItems, config.teams[6]); + } + } + + private void button_moveTeam8(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + PlayerItem[] playerItems = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + playerItems[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + movePlayerToTeam(playerItems, config.teams[7]); + } + } + + private void button_reset(object sender, EventArgs e) { + resetTeams(); + } + + #endregion + + #region Selections + + private void select_teamList(object sender, EventArgs e) { + if (teamListView.SelectedItems.Count > 0) { + kickMenuItem.Enabled = true; + moveMenuItem.Enabled = true; + } + else { + kickMenuItem.Enabled = false; + moveMenuItem.Enabled = false; + } + } + + private void select_playerList(object sender, EventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + removeButton.Enabled = true; + removeMenuItem.Enabled = true; + propertiesButton.Enabled = true; + propertiesMenuItem.Enabled = true; + } + else { + removeButton.Enabled = false; + removeMenuItem.Enabled = false; + propertiesButton.Enabled = false; + propertiesMenuItem.Enabled = false; + } + } + + #endregion + + #region Context-menues + + private void context_open(object sender, CancelEventArgs e) { + if (playerListView.SelectedItems.Count > 0) { + // Calculate active playerCount + int activePlayers = 0; + for (int i = 0; i < config.teams.Length; i++) { + activePlayers += config.teams[i].Players.Count; + } + + chooseMenuItem.Enabled = activePlayers < SimulatorConfiguration.PLAYERLIMIT; + } + else { + chooseMenuItem.Enabled = false; + } + } + + #endregion + + #region DragDrop + + private void dragOver_playerList(object sender, DragEventArgs e) { + if (e.Data.GetDataPresent("FileDrop")) { + e.Effect = DragDropEffects.Copy; + } + else { + e.Effect = DragDropEffects.None; + } + } + + private void dragOver_teamList(object sender, DragEventArgs e) { + if ( + e.Data.GetDataPresent("FileDrop") || + e.Data.GetDataPresent("AntMe.Simulation.PlayerInfoFilename[]") || + e.Data.GetDataPresent("AntMe.Plugin.Simulation.PlayerItem[]")) { + // Move Item, if no Control-Key is pressed + if (e.Data.GetDataPresent("AntMe.Plugin.Simulation.PlayerItem[]") && + (e.KeyState & 8) == 0) { + e.Effect = DragDropEffects.Move; + } + else { + e.Effect = DragDropEffects.Copy; + } + } + else { + e.Effect = DragDropEffects.None; + } + } + + private void dragDrop_playerList(object sender, DragEventArgs e) { + string[] files = (string[]) e.Data.GetData("FileDrop"); + foreach (string file in files) { + loadPlayerFile(file, false, false); + } + } + + private void dragDrop_teamList(object sender, DragEventArgs e) { + // Drop some files + if (e.Data.GetDataPresent("FileDrop")) { + string[] files = (string[]) e.Data.GetData("FileDrop"); + foreach (string file in files) { + List hits = loadPlayerFile(file, false, true); + foreach (PlayerInfoFilename hit in hits) { + addPlayerToTeam(hit, null); + } + } + } + + // Drop new playerInfos + if (e.Data.GetDataPresent("AntMe.Simulation.PlayerInfoFilename[]")) { + PlayerInfoFilename[] player = + (PlayerInfoFilename[]) e.Data.GetData("AntMe.Simulation.PlayerInfoFilename[]"); + + Point dropPoint = new Point(e.X, e.Y); + ListViewItem hit = teamListView.HitTest(teamListView.PointToClient(dropPoint)).Item; + if (hit != null) { + ListViewGroup group = hit.Group; + int team = teamListView.Groups.IndexOf(group); + for (int i = 0; i < player.Length; i++) { + addPlayerToTeam(player[i], config.teams[team]); + } + } + else { + addPlayerToTeam(player, false); + } + } + + // Move PlayerItems + if (e.Data.GetDataPresent("AntMe.Plugin.Simulation.PlayerItem[]")) { + PlayerItem[] player = (PlayerItem[]) e.Data.GetData("AntMe.Plugin.Simulation.PlayerItem[]"); + + Point dropPoint = new Point(e.X, e.Y); + ListViewItem hit = teamListView.HitTest(teamListView.PointToClient(dropPoint)).Item; + if (hit != null) { + ListViewGroup group = hit.Group; + int team = teamListView.Groups.IndexOf(group); + if ((e.KeyState & 8) > 0) { + PlayerItem[] newPlayer = new PlayerItem[player.Length]; + for (int i = 0; i < player.Length; i++) { + newPlayer[i] = (PlayerItem) player[i].Clone(); + } + addPlayerToTeam(newPlayer, config.teams[team]); + } + else { + movePlayerToTeam(player, config.teams[team]); + } + } + else { + if ((e.KeyState & 8) > 0) { + PlayerItem[] newPlayer = new PlayerItem[player.Length]; + for (int i = 0; i < player.Length; i++) { + newPlayer[i] = (PlayerItem) player[i].Clone(); + } + addPlayerToTeam(newPlayer, null); + } + else { + movePlayerToTeam(player, null); + } + } + } + } + + private void drag_playerList(object sender, ItemDragEventArgs e) { + if (e.Button == MouseButtons.Left) { + PlayerInfoFilename[] player = new PlayerInfoFilename[playerListView.SelectedItems.Count]; + for (int i = 0; i < playerListView.SelectedItems.Count; i++) { + player[i] = (PlayerInfoFilename) playerListView.SelectedItems[i].Tag; + } + DoDragDrop(player, DragDropEffects.Copy); + } + } + + private void drag_teamList(object sender, ItemDragEventArgs e) { + if (e.Button == MouseButtons.Left) { + PlayerItem[] player = new PlayerItem[teamListView.SelectedItems.Count]; + for (int i = 0; i < teamListView.SelectedItems.Count; i++) { + player[i] = (PlayerItem) teamListView.SelectedItems[i].Tag; + } + DoDragDrop(player, DragDropEffects.Move | DragDropEffects.Copy); + } + } + + #endregion + + #region Timer + + private void timer_Tick(object sender, EventArgs e) { + Enabled = !active; + } + + #endregion + + #endregion + } +} \ No newline at end of file diff --git a/SimulationPlugin/TeamSetup.de.resx b/SimulationPlugin/TeamSetup.de.resx new file mode 100644 index 0000000..17e11ff --- /dev/null +++ b/SimulationPlugin/TeamSetup.de.resx @@ -0,0 +1,579 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Autor + + + + 152, 22 + + + Volk erstellen + + + 152, 22 + + + Volk laden + + + 149, 6 + + + 152, 22 + + + Entfernen + + + 152, 22 + + + Eigenschaften + + + 149, 6 + + + 140, 22 + + + Neues Team + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 152, 22 + + + Auswählen + + + 153, 148 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAABFTdGF0aXNjaGUgVsO2bGtlcgX8////KFN5c3RlbS5XaW5kb3dzLkZvcm1zLkhvcml6b250YWxB + bGlnbm1lbnQBAAAAB3ZhbHVlX18ACAIAAAAAAAAACgYFAAAAC3N0YXRpY0dyb3VwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAABZOaWNodHN0YXRpc2NoZSBWw7Zsa2VyBfz///8oU3lzdGVtLldpbmRvd3MuRm9ybXMuSG9yaXpv + bnRhbEFsaWdubWVudAEAAAAHdmFsdWVfXwAIAgAAAAAAAAAKBgUAAAAObm9uU3RhdGljR3JvdXAL + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAADy + LgAAAk1TRnQBSQFMAgEBCAEAAQwBAAEMAQABIAEAASABAAT/ARkBAAj/AUIBTQE2BwABNgMAASgDAAGA + AwABYAMAAQEBAAEYBgABkP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A + /wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AGAAAvoB+wLa + AexaAAP7A+P/ABsAA/4CuAHfAvsB/FcAA/4DzAP8bwAD/wP1AfEB8wH0AfMC9AHzAvQB8wL0AfMC9AHz + AvQB8wL0AfMC9AHzBfQD/jkAA/8D9QPzG/QD/iQAAuAB7gLRAegGAAL6AfsD/U4AA+cD3AYAA/oD/UgA + A/8D/RUAA/cBuwHaAf8BRAGVAf8BLAGLAf8BLAGMAf8BLAGMAf8BLAGMAf8BLAGMAf8BLAGMAf8BLAGM + Af8BLQGFAf8BmQHHAf8D9h4AA/8D/RUAA/cD3QOeA5QSlQOPA8wD9iQAA/0CnQHWA/8DAALGAeQC1wHq + TgAD/QO6A/8DAAPVA+BIAAP+Ar8B4QL9Af4SAAP2Aa0B0gH/AT0BkAH/AQABaAH/AQABagH/AQABagH/ + AQABagH/AQABagH/AQABagH/AQABagH/AQABXwH/AVkBpAH/A/UeAAP+A9AD/RIAA/YD1gOZA3QSdgNs + A6wD9RUAAvoB+wL6AfsMAAK1Ad4C4gHvAwAC4AHuAscB5T8ABvsMAAPKA+kDAAPnA9ZLAALZAesC2wHs + BgAD/gkAA/kB0QHlAf4BYgGlAf8BcwGzAf8BdAGzAf8BdAGzAf8BdAGzAf8BdAGzAf8BdAGzAf8BcwGz + Af8BdAGwAf8B1wHpAf8D+CEAA+ID4wYAA/4JAAP5A+cDrRW5A7YD6wP4EgACvAHhAh8BsAIdAa4CkAHS + Av0B/gYAAu0B9AKYAdQDAALeAe0CvAHhPAADzgNnA2YDsQP9BgAD8QO2AwAD5gPOSwAD/AKnAdoGAAK1 + Ad4C+AH6BgAD9gGzAdYB/wFGAZQB/wEUAX4B/wEUAX8B/wEUAX8B/wEUAX8B/wEUAX8B/wEUAX8B/wEU + AX8B/wEUAXYB/wF+AbcB/wP1IQAD/APABgADygP5BgAD9gPZA50DiBKJA4EDvQP1DwAD/gIrAbMCBgGo + AgYBqAIGAagCdgHKCQACgAHMAvwB/QLiAe8C0QHoOQAD/gNvCVcDoAkAA6YD/QPpA90/AAP8DAACsgHd + AuwB9AMAAsEB4gLvAfUGAAP2AaoB0QH/ATgBjAH/AQMBdAH/AQMBdQH/AQMBdgH/AQMBdgH/AQMBdgH/ + AQMBdgH/AQMBdgH/AQMBbAH/AXABsQH/A/UVAAP8DAADyAPwAwAD0gPyBgAD9gPUA5UDfwOADIEDgAN4 + A7gD9Q8AA/4CMwG1AgYBqAIGAagCBgGoAgYDqAHZAwAD/AKOAdED/gLbAewC3AHtOQAD/gN0DFcDwQMA + A/wDrwP+A+MD5TkAAvsB/AJoAcUCJAGxAmoBxQLyAfcGAALpAfICqAHZAwACxAHjAusB8wYAA/kB0wHm + Af4BWwGiAf8BbAGvAf8BbAGvAf8BbAGvAf8BbAGvAf8BbAGvAf8BbAGvAf8BbAGvAf8BbQGsAf8B1wHp + Af8D+A8AA/sDlwNqA5gD9AYAA+4DwQMAA9QD7wYAA/kD5wOpFbUDsgPrA/gSAAKhAdcCBgGoAgYBqAIG + AagCBgGoAgYBqALuAfUC3wHuAr4B4QMAAsMB4wLEAeM8AAO8D1cD8QPmA9ADAAPTA9Q5AALaAewCBgGo + AgYBqAIGAagCKwGzAvgB+gYAAoYBzwMAAskB5QLzAfcGAAP2AaUBzgH/ATMBiwH/AQABbQH/AQABbgH/ + AQABbgH/AQABbgH/AQABbgH/AQABbgH/AQABbgH/AQABYwH/AV8BqAH/A/UPAAPjCVcDbwP5BgADqgMA + A9cD9QYAA/YD0gOVA3gDeQ96A3ADrwP1EgAD/gKmAdkCBgGoAgYBqAIGAagCBgGoArUB3gK3Ad8C8AH2 + AwAC7wH1AoABzDwAA/4DwAxXA8oDywPzAwAD8gOmOQAC4AHuAgYBqAIGAagCBgGoAgYBqAJaAcED/wL4 + AfoCmwHVAwACtgHfAvYB+QYAA/cBtQHXAf8BNAGLAf8BGQGGAf8BEQF+Af8BGAGBAf8BGQGCAf8BGQGC + Af8BEQF+Af8BGQGHAf8BEwF3Af8BjQHBAf8D9Q8AA+cMVwONA/8D+QO4AwADygP3BgAD9wPaA5UDkQOJ + A4sDjAOLA4gDkQOCA8YD9QMAAuoB8wL1AfgPAALtAfQCgwHNAhUBrQIGAagCigHQAo4B0QLpAfIGAALX + AesCvAHhKgAD7wP2DwAD8AOoA2ADVwOtA68D7gYAA+EDzjYAAvwB/QJOAb0CBgGoAgYBqAIGAagCBgGo + AssB5gLUAekC1QHqAwACmAHUAuwB9AYAA/4D9AHeAegB8gGcAaQBsAHhAeoB8wHoAe8B+AHoAe8B+AHo + Ae8B9wHlAe8B+AGeAaYBsgHZAeEB6wP0A/4PAAP9A4UMVwPYA98D4AMAA7YD8AYAA/4D9APpA6UD6wbw + A+8D8AOoA+ID9AP+AwAC7AHzArkB3wKyAd0C5QHwDwAC8wH3AuoB8wJKAbwCDwGrAmUBxALiAe8CygHl + AsAB4gJoAcUD/ycAA/ADzAPIA+oPAAP1A+8DgwNcA5QD6APYA9EDlwP/NgAC+wH8ApsB1QIKAaoCBgGo + AgYBqAKbAdUCtAHeAvUB+AMAAugB8gKhAdcMAAHkAeEB3QFmAWABXQHnAeUB4gkAAfAB7gHrAWsBZgFi + AdcB1AHRA/0VAAP8A7gDWQZXA7gDyQP2AwAD7AO8DAAD4ANgA+UJAAPtA2UD0wP9DAAC8AH2ArMB3QKP + AdECwgHjAvMB9wLkAfACqAHZApgB1AKVAdMCagHFAggBqAIGAagCCAGoAqAB2ALOAecC+gH7MAAD8wPI + A7AD0gP1A+oDwQO2A7QDmANZA1cDWQO8A9sD+yoAAs8B5wLRAegC+AH6DAAC8wH3AqwB2wJ3AckCUwG/ + AlcBvwLRAegGAAKtAdsCzQHnBgAD/gPjAXICcAPbA/sDAAP+A+sBZwJlAdgC1wP8BgAD2wPcA/kMAAP1 + A8QDoAOJA4sD3AYAA8QD2gYAA/4D4wNwA9sD+wMAA/4D6wNlA9cD/BIAAvoB+wLJAeUCigHQAq0B2wLm + AfED/gL6AfsCsAHdAggBqAIGAagCDwGrArIB3QLXAeoC4AHuDwAC+wH8A/4hAAP7A9cDrQPEA+sD/gP7 + A8YDWQNXA1wDyAPgA+cPAAP7A/4VAAL8Af0C5AHwAqYB2QKvAdwC5gHxBgAC+wH8AtoB7ALNAecCdgHK + AgYBqAIdAa4CewHLAoYBzwKYAdQC5gHxCQAD8QGxArABtgK1A+4D9AP2AZ0CnAFyAnAD8AkAA/0D6gPA + A8YD6wYAA/sD4wPaA6ADVwNmA6MDqgO2A+sJAAPxA7ADtQPuA/QD9gOcA3AD8CoAAvcB+QIqAbICGwGu + AgYBqAIGAagCjgHRAtQB6QKpAdoC0QHoAsQB4wLBAeICvAHhAscB5QL7Afw2AAP4A24DZQZXA68D3wPC + A9wD1APSA84D1gP7HgAC7AHzArAB3QKGAc4CmQHUApoB1QLLAeYCzAHmAncByQIKAaoCBgGoAh0BrgLg + A+4B9QwAA/kB6QHoAeABqAOmAqUBnwKeAYECgAFfAl0D0gP1EgAD8APGA6oDtwO4A9gD2QOgA1kDVwNm + A+cD8QwAA/kD5QOmA6UDngOAA10D0gP1DwAC/AH9Aq0B2wK8AeECwAHiAsEB4gK9AeECrgHcAtYB6gMA + AuMB7wKVAdMC5gHxAgYBqAIGAagCYAHCAqEB1wLfAe4C2gHsAukB8gL5AfsD/iEAA/wDxAPOA9ED0gPP + A8UD4AMAA+kDtAPrBlcDkQO8A+YD4wPuA/oD/ioAA/0C9wH5CQAC+QH6AhYBrAIGAagCBgGoAhcBrAKj + AdgCvwHhAusB8wLvAfUC4AHuAtsB6wLCAeUD5gG5ArgBiwKJAaACnwHgAt8D9BsAA/0D+AkAA/oDYQZX + A2IDvgPQA+8D8gPnA+ID1APmA7gDiQOfA98D9BIAA/8C7wH1AuIB7wLdAe0C5QHwAukB8gLeAe0CnAHV + ArAB3QLHAeUCwwPjAe8CowHYAooB0AJEAbsCBgGoAkYBugP+A/8C7wH1JAAD/wPyA+kD5QPqA+4D5gO5 + A8YD1gPTA+kDvgOtA38DVwOBA/4D/wPyJAAC9gH5As4B5wLdAe0C3wHuAuIB7wLaAewC5QHwAwAC8gH3 + AoQBzgKyAd0CBgGoAgYBqAKnAdoCywHmAsYB5AK+AeEC3AHsAusB8wP9A/sD9Qb0A/oVAAP3A9sD5QPm + A+kD4wPqAwAD9AOpA8gGVwPAA9gD1QPQA+QD7wP9A/sD9Qb0A/otAALcAe0CiAHPAvoB+wLoAfIC0wHp + ArIB3QIGAagCBgGoAgYBqAJvAccCuwHgApkB1AL1Afg5AAPlA6sD+gPsA94DyAlXA5sDzgO3A/YhAAL6 + AfsC0gHpAsUB5ALDAeMC1QHqAscB5QKZAdQCsQHdAtgB6wK/AeEC5AHwAoMBzQJmAcQCHwGwAgYBqALc + Ae0DAAL7AfwqAAP7A90D1APTA+AD1gO3A8cD4gPQA+oDqAOVA2cDVwPlAwAD/E4AAq8B3ALvAfUCWgHB + AgYBqAIGAagCnAHVA/4C+wH8AroB4EUAA8YD8gONBlcDuQP+A/sDzTYAAuAB7gJ4AcoC9gH4At0B7QLf + Ae4CbwHHAgYBqAIGAagCFwGsArUB3gKcAdUC4gHvPAAD5wOhA/cD5QPmA5sGVwNiA8oDuQPpSwACuwHg + AucB8QL9Af4CegHLAqUB2QP+BgACyQHlAusB80IAA84D7AP9A6IDvwP+BgAD1wPvPAAD/QKuAdwC5QHw + Ah8BsAIGAagCJAGxAu8B9QMAArUB3gP8QgAD/QPFA+oDZwNXA2oD8gMAA8oD/EgAAqgB2QL7AfwC+gH7 + AroB4AwAA/0C+wH8CQAD/gH2AfgB+gH5AfoB+zAAA8ED/AP7A80MAAP9A/sJAAP+A/gD+i0AAqYB2QL8 + Af0C8gH2AmwBxgLxAfYGAALoAfIC3AHtRQADwAP8A/QDmgPzBgAD7APlRQAC+gH7ArYB3wMAAuAB7gKr + AdsD/RIAAfAB9AH4AZQBwAH1ASABhAH8AQABdAH/AQIBdgH/AvsB/CoAA/sDygMAA+cDwwP9EgAD9APE + A44DfwOBA/snAAL8Af0CsAHdAwAC0QHoAuoB8wwAA/0GAAP/AfAB9AH4AdkB5gH1AfEB9QH5MAAD/QPG + AwAD3APuDAAD/QYAA/8D9APnA/UzAALkAfAC2QHrBgAC5gHxArAB3QLYAesD/gkAAasBzAH0AQABdAH/ + AQABdAH/AWMBpgH3AacBygH0Ac0B3wH0A/4qAAPqA+IGAAPrA8YD4gP+CQAD0AZ/A60DzgPhA/4nAALs + AfQCzwHnAwACxwHlAsMB4wL6AfsMAAP/Ab4B1wH0ASgBiQH7AQABdAH/AQABdAH/AYYBuQH1MAAD8APb + AwAD1gPTA/oMAAP/A9kDkgZ/A74zAALXAesC+AH6CQAD/gLhAe8D/QYAAYoBugH1AQABdAH/AXoBsgH2 + AfUB9wH6NgAD4QP5CQAD/gPoA/0GAAO/A38DuAP3MwACzQHnAvAB9QYAAusB8wKwAd0C6wHzBgAB+gH7 + AfwBVgGfAfgBAAF0Af8BcgGuAfYB2QHmAvUB9wH6A/4wAAPaA/MGAAPvA8YD7wYAA/sDpwN/A7QD5wP3 + A/4zAAP/GAABvwHXAfQBAAF0Af8BogHHAfQGAAHhAesB9gGaAcMB9AGYAcIB9QL9Af4qAAP/GAAD2gN/ + A8sGAAPsA8cDxgP9JwAC7gH1A/8MAAP8AwAB/QL+AUoBmQH4AQQBdgH/AeIB6wH2BgAB+AH5AfsB/AL9 + MAAD8QP/DAAD/AMAA/4DoQOBA+wGAAP5A/1LAAH6AfsB/AELAXkB/gFYAaEB+AMAA/4BfQG0AfUBAAF0 + Af8BAAF0Af8BOQGQAfoB+wL8QgAD+wOEA6gDAAP+A7kGfwOZA/w/AAGjAcgB9AEAAXQB/wHpAe8B9wMA + AdcB5QH1ATIBjgH7AQABdAH/AYQBtwH1SAADzAN/A/ADAAPmA5YDfwO8SwABvwHXAfQBAAF0Af8B6gHw + AfcDAAGPAb0B9QEAAXQB/wGrAcwB9AH5AfoB+0gAA9oDfwPxAwADwgN/A88D+kIAAfoB+wH8AQABdAH/ + AZgBwgH0AwABzgHgAfUBAAF0Af8BXwGlAfcB0gHiAfUB9gH4AfpFAAP7A38DxgMAA+EDfwOrA+MD+EsA + AWYBqAH3ARwBggH8AwAB9QH3AfoBAAF0Af8BjgG9AfUDAAP+AeoB8AH3A/5CAAOuA4wDAAP4A38DwQMA + A/4D8QP+PAAB1QHkAfUBAAF0Af8B9AH3AfkD/QEJAXkB/gF3AbEB9gYAA/9FAAPlA38D9wP9A4MDtgYA + A/9LAAEZAYEB/QFPAZwB+AMAAcwB3gH1AQABdAH/AeoB8AH3AwABXAGjAfcBAAF0Af8BlAHAAfVCAAOL + A6QDAAPgA38D8QMAA6kDfwPEPAABpAHJAfQBAAF0Af8DAAHeAekB9gEAAXQB/wHwAfQB+QP9AVIBngH5 + ASwBiwH7Ae4B8gH4QgADzAN/AwAD6gN/A/QD/QOlA5QD80gAAYYBuQH1AbIB0AH0AwAB5QHtAfYBXQGj + AfcB+wL8A/4BDQF7Af4BAAF0Af8BUwGeAfhCAAO+A9MDAAPuA6oD/AP+A4UDfwOlPAABxwHbAfQBZgGo + AfcDAAHmAe4B9wFNAZsB+AP+AfAB9AH5AQABdAH/AQABdAH/AcYB2wH0QgAD3gOuAwAD7gOiA/4D9AZ/ + A91dAAHlAe0B9wGfAcYB9AHyAfUB+VcAA+4DyQP1TgAD/wHFAdoB9AGsAc0B9AH8Av1UAAP/A9wD0AP9 + /wC0AALvAfVdAAPy/wAeAALBAeIC8AH2WgAD0gPzZgAD/wP1A/Mb9AP+PwAD+wHxAfIB9AHyAfMB9AHz + AvQB8wL0AfMC9AHzAvQB8wL0AfMC9AP1MAAC8wH3AqwB21oAA/UDxGYAA/cD3QOeA5QSlQOPA8wD9j8A + Ae0B8QH1AXMBswH/AS4BiwH/ASoBigH/ASoBiwH/ASoBiwH/ASoBiwH/ASoBiwH/ASoBhAH/AYkBvwH/ + A/cwAAKgAdcC9gH5CQAC9AH3A/5LAAO7A/cJAAP1A/5UAAP2A9YDmQN0EnYDbAOsA/UnAAP+AswB5gP+ + DwAB6wHwAfYBawGuAf8BFAF+Af8BDgF6Af8BDgF8Af8BDgF8Af8BDgF8Af8BDgF8Af8BDgFzAf8BdgGz + Af8D9zAAAtgB6wK3Ad8JAAJ3AckC8QH2SwAD4gPLCQADoAPzQgAD/A8AA/kD5wOtFbkDtgPrA/gqAALM + AeYC3QHtDwAB8AHyAfQBcgGyAf8BUgGeAf8BVQGjAf8BVQGjAf8BVQGjAf8BVQGjAf8BVQGjAf8BVgGe + Af8BvgHbAf4D+jAAA/0CegHLA/4GAAKqAdoC6wHzSwAD/QOiA/4GAAPCA+9CAAPSA/cMAAP2A9kDnQOI + EokDgQO9A/UqAAL7AfwCoAHXCQAG/gHqAfAB9wFcAaYB/wEAAWwB/wEAAWYB/wEAAWgB/wEAAWgB/wEA + AWgB/wEAAWgB/wEAAV4B/wFUAaIB/wP2GAAC8gH3ArwB4QK9AeEC7wH1DwACnwHWAtcB6wYAAq8B3ALk + AfAzAAP0A84DzwPyDwADugPhBgADxgPqQgAD8QPQDAAD9gPUA5UDfwOADIEDgAN4A7gD9S0AAqoB2gLr + AfMGAALaAewCxgHiAfIB8wH0AXMBswH/AVUBnwH/AVgBpAH/AVgBpAH/AVgBpAH/AVgBpAH/AVgBpAH/ + AVgBnwH/AcEB3QH+A/oVAALyAfYCEQGrAgYBqAIGAagCBgGoAqkB2gwAAukB8gJ7AcsGAAKnAdoC4QHv + MAAD9ANeCVcDwgwAA+4DowYAA8AD6EUAA7wD+wYAA+sD8QPrA6kVtQOyA+sD+C0AAugB8gKhAdcGAALv + AfUCsAHaAfIC9QFpAa0B/wEPAXsB/wEIAXcB/wEIAXgB/wEIAXgB/wEIAXgB/wEIAXkB/wEIAXAB/wFu + AbAB/wP2FQACvgHhAgYBqAIGAagCBgGoAgYBqAIGAagCtAHeDAACYQHCAvQB+AMAAqcB2gLsAfMwAAPQ + D1cDyQwAA5ID9gMAA8AD8EUAA9wD1wYAA80D2QPXA5UDeAN5D3oDcAOvA/UVAAL7AfwCygHlArUB3gLi + Ae8MAAP/AnsBywL6AfsDAALyAfcCqQHYAfIB9AH1AXEBsgH/AS8BjwH/ASwBjQH/ATYBkQH/ATYBkgH/ + ATIBjwH/AS4BjgH/ASsBhwH/AY8BwgH/A/gVAAK1Ad4CBgGoAgYBqAIGAagCBgGoAgYBqAIGAagC1wHr + BgAC/QH+Am8BxwL7AfwDAAKiAdcC7wH1MAADyhJXA+EGAAP9A5sD+wMAA70D8jMAA/YD+wwAA/sDqwYA + A+YD0gPfA5UDkQOJA4sDjAOLA4gDkQOCA8YD9RUAAm8BxwIGAagCBgGoAgYBqAJ6AcsD/gkAArgB3wK7 + AeADAALyAfYCnQHVA/wC9gH3AagBpwGmAeUB5AHjBvQD9QG5AbcBtgHJAcgBxgP1GAAC3wHuAgYBqAIG + AagCBgGoAgYBqAIGAagCBgGoAhcBrAL1AfgDAALaAewCmQHUBgACmAHUAu4B9TAAA+YSVwNiA/YDAAPj + A7cGAAO2A/EtAAP7A40DVwNmA7YD/gkAA7YD6wMAA+ED2QP0A+kDpQPrBvAD7wPwA6gD4gP0A/4SAAL6 + AfsCEwGrAgYBqAIGAagCBgGoAgYBqAKBAc0JAALwAfYCdgHKAwAC8AH2ArQB3QMAA/QBewF4AXcB1AHT + AdEGAAP3AZYBlAGTAacBpAGjA/sYAAP+Al8BwwIGAagCBgGoAgYBqAIGAagCBgGoAgYBqAJ7AcsDAAKO + AdEC5AHwBgACegHLAuMB7zAAA/4DkBJXA6MDAAOvA+oGAAOiA+ktAAPbDFcDpwkAA+YDswMAA9sD5gMA + A+ADYAPlCQAD7QNlA9MD/RUAAvsB/AIbAa4CBgGoAgYBqAIGAagCBgGoAgYBqAKxAd0GAALUAeoCqgHa + AwAC6gHzAroB4AMAA/QBpwKmAcQCwwP1A/sD9AF4AnYDxgP8GwAC/AH9ApgB1AIGAagCBgGoAgYBqAIG + AagCBgGoAjABtQL5AfoCcQHIA/8GAALWAeoCfAHLMwAD/QO2D1cDcgP6A50D/wYAA+ADpC0AA9MPVwPD + BgAD4gPEAwAD0wPsAwAD4wNwA9sD+wMAA/4D6wNlA9cD/BgAAmwBxgIGAagCBgGoAgYBqAIGAagCBgGo + AgYBqALmAfEDAAKGAc8C7QH0AwAC3gHtApoB1QMAA/sD3gGpAqgBuwK6AbwCuwGAAn4BkAKOA/IJAAP8 + GAAC6AHyAm8BxwIGAagCBgGoAgYBqAItAbMC+gH7AmMBxAL8Af0JAAKgAdcCyQHlGwAD/BgAA+wDmwlX + A3AD+wOTA/0JAAO7A9cqAAPwElcD5wMAA7AD8QMAA8YD5gMAA/EDsAO1A+4D9AP2A5wDcAPwGwAC8wH3 + AkgBvAIGAagCBgGoAgYBqAIGAagCBgGoAnYBygL5AfoChAHOBgAC7QH0AmEBwgYAA/YD4AGpAqgBhAKD + AawCqgHxAvAD/gkAAtsB7AKrAdsC4AHuA/8VAALpAfICsAHdApUB0wI7AbcCWQHAAlYBwALFAeQMAAJF + AboC+AH6GAAD4wPDA+cD/xUAA+4DxgO0A3kDjQOLA9QMAAN/A/kqAAPDD1cDjwP4A64GAAPNA8YDAAP3 + A90DpgOlA54DgANdA9ID9R4AA/0CrQHbAhkBrgIGAagCBgGoAgYBqAJrAcYC7QH0ApkB1AkAAqwB2wLE + AeMGAAP8A/UD9AP3EgAC9wH5ArsB4AKMAdACwAHiAvYB+RIAAvYB+QP9As0B5wIWAawCLwG0AgYBqAKm + AdkCfgHMAnMByQJ/AcwCZQHEAvsB/BsAA/gDzgOuA9ED9xIAA/cD/QPaA2EDcgNXA8ADpQOeA6UDlAP7 + LQAD5wOHCVcDhAPsA70GAAP8A6AD9gMAA/UD5QO4A4kDnwPfA/QMAALQAegC3gHtA/4SAAL3AfkCqQHa + Aj8BuQIkAbECNwG2ArQB3gJjAcQD/wkAAoABzALqAfMnAAL7AfwCywHmAoEBzQKOAdEC2QHrAvsB/ALu + AfUCrQHbAnEByAJ7AcsCXwHDAoEBzQJKAbwCBgGoAgYBqAIGAagCjAHQAtYB6gLvAfUnAAP8A9gDpwOv + A+ID/APxA8QDnQOjA5ADpwODCVcDrgPgA/IeAAPcA+MD/Q8AA/4D3QOYA3kDcgO7A5gD/wYAA/kDpQP+ + AwAD+wP1BvQD+g8AAvcB+QLPAecCmQHUAsMB4wL2AfgSAAP8A/0CigHQAgYBqAIpAbMCfwHMAt4B7QK8 + AeECwwHjAlMBvwLUAekwAALjAe8CjAHQAl8BwwKBAc0CyQHlAvgB+gMAAv0B/gLRAegCDwGrAgYBqAIG + AagCBgGoAnoBywLzAfcC3gHtAvIB9y0AA+kDrgOQA6cD1wP5AwAD/QPdA1wJVwOiA/UD5gP0GwAD+gPg + A7gDzwP0DwAD+wP3A8gDVwNjA6UD0AO3A74DlwP+JwAD/QLUAeoCkAHSApMB0gLaAewC/QH+A/0C2wHs + ApgB1AJ3AckCegHLApYB0wIvAbQCBgGoAgYBqAIRAasCjAHQArYB3wLqAfM5AAP9EgACsQHdAgYBqAIG + AagCBgGoAgYBqAIGAagCpwHaApYB0wK1Ad4D/QMAA/4C9gH4Au0B9ALcAewCzQHnAuYB8RgAA/0SAAPH + D1cDwAO1A8oD/QMAA/4D9wPwA+QD2gPrBgAD/gPjA7UDsAPdA/YD3wOyA6sDoQOiA20GVwNyA9QD6gP+ + MwAC6QHyAp0B1gJoAcUCegHLAqAB2ALkAfAC/AH9AvMB9wKnAdoCBgGoAgYBqAIGAagCHQGuAuQB8AL1 + AfgC7wH1TgACbwHHApMB0gJuAccCBgGoAgYBqAIGAagCtQHeA/4C0gHpAoEBzQKKAdAClQHTAqMB2ALD + AeMC2QHrAvEB9gL8Af0tAAObA7MDmglXA8oD/gPdA6cDrQO0A74D0wPiA/QD/Q8AA/EDvgOlA8gD8QYA + A+UDawZXA20G3QPpEgAD/gP/IQAC+gH7AvwB/Q8AAnMByQIGAagCBgGoAgYBqAIGAagCZwHEArEB3QKi + AdcC9gH4AwAD/ALyAfcC6gHzAtcB6wLQAegD/Q8AAvMB9wJzAckCnAHVAqIB1wKgAdgCoQHXAqMB2AKW + AdMCigHQAuAB7gYAAmEBwgLkAfAD/AIGAagCBgGoAgYBqAKGAc4COgG4AsYB5AL9Af4C+AH6A/4YAAP1 + A54DuQO9BrwDvgO1A60D5wYAA5ID6gP8CVcDqgN5A9UD/QP5A/42AAOqA1wJVwPAA9cDvgPuA+wD3APX + A84D1AP8FQAD/QP+GAAD/gJEAbsCsQHdAjcBtgIGAagCBgGoAjMBtQL7AfwC5AHwApkB1AKKAdACogHX + Aq4B3ALPAecC4wHvAvYB+QP/DwAD/wL2AfgC7AHzAucB8QLnAfEC7gH1AvAB9gLsAfMC2AHrAnABxwKv + AdwDAAJzAckC9gH4AuIB7wKdAdYCpwHaApMB0gJhAcICBgGoAgYBqAK2Ad8GAAL8Af0VAAP/A/cD8Abs + A/ED8wPwA+IDnAPGAwADngP3A+kDugPAA7MDkgZXA8oGAAP9FQAD5QPqA/AG7wPuA+wD+gYAA4UD6gOV + BlcDogPgA+oDwQPQA+AD8QP6GwACzQHnAoYBzwKiAdcCnAHVAqEB1wKnAdoCjAHQAmoBxQK7AeAGAAJN + Ab0DAALEAeMCBgGoAgYBqAJqAcUCOwG3AmgBxQP8A/0/AAKyAd0CVwG/AnMByQMAAuAB7gK6AeADAAIi + Aa8CBgGoAgYBqAIGAagCBgGoAugB8gLPAecCfwHMAtsB7DAAA8gDiwOeAwAD5wPNAwADaQxXA+wD2wOl + A+MSAAPhA8QDvQO8A8wDygO5A5cD3gMAA5UD/wPGA4sDhQOYA1cDmi0AAv0B/gL3AfkC9AP4AfoD/QL7 + AfwC8wH3AqMB2AKPAdEC6QHyAmsBxgMAAqAB1wLeAe0CqwHbAmcBxAIGAagCBgGoAlUBvwP+AwAC5gHx + A/45AALyAfcC+wH8AwAD/gKQAdIC9wH5AnQByQIGAagCBgGoAgYBqAIGAagCXAHBAtEB6AP9AqUB2QL7 + AfwwAAP0A/sDAAP+A7ED+AOfDFcDjwPdA/0DvwP7JAAD/AO6A5wDqgMAA7cD+wOmA1wGVwOrA/UDugPi + OQAC4AHuAmEBwgLNAecDAAK1Ad4C7QH0ArMB3QIGAagCBgGoAgYBqAIGAagCmgHVArAB3QKgAdgCzQHn + RQAC3AHtArsB4AP/AmMBxAIGAagCBgGoAgYBqALyAfcGAALoAfICyQHlPAAD5QPOA/8DkwlXA/QGAAPt + A9cqAAPpA/gDAAPfA94DxAlXA1wDwAPxA8cD+kIAAvoB+wKcAdUC+gH7AkgBvAIGAagCBgGoAgYBqAKA + AcwC9QH4AwACrwHcAvgB+kIAAvMB9wKPAdEDAAL9Af4CrAHbAloBwQLnAfEMAAKpAdoC9wH5OQAD9QOw + AwAD/QPEA40D7AwAA8ID+DAAA/4DtQMAA7MGVwOtBgAD8wPURQACqAHZAu4B9QL5AfoCbAHGAg0BqQJh + AcIC/AH9BgAC8QH2AroB4AP/PwAC0QHoAsYB5AYAAr0B4QLqAfMPAAL2AfgC+QH6OQAD3QPVBgADzwPv + DwAD9wP6MwADswP8AwADwwPFA/4JAAPQA/lCAAKgAdcC8wH3AwAC+AH6Ap0B1g8AAs0B5wP8PwACrQHb + AvAB9QMAAuMB7wKmAdlRAAPEA/MDAAPpA8BIAAP4A8ADAAP6A8UD/wwABv4/AAP8Ap8B1gMAA/4CpgHZ + AvUB+FEAA/4CpgHZA/4DAALqAfMCmwHVAuYB8UsAA/4DwAP+AwAD7wO4A+tFAAPmA9wDAAPlA75UAALp + AfICwwHjAwAC+wH8AowB0ALsAfRRAALxAfYCwgHjCQAC+gH7Ar8B4QKwAd0C6wHzA/9CAAP0A9IJAAP7 + A9ADxgPvA/88AAPSA/UDAAP/A+UDwQPnA/1LAALLAeYC6wHzBgAC+wH8AsAB4gK1Ad4C7wH1A/9IAALU + AekC7QH0DwAC9gH4As0B5wP+QgAD3wPwDwAD9wPaA/45AAP9A9MMAAP8A9oD8EgAA/4CwAHiA/4MAAL0 + AfgCxgHkA/xIAALxAfYD/loAA/MD/lEAA/wD9V0AAv0B/gLyAfYtAAFCAU0BPgcAAT4DAAEoAwABgAMA + AWADAAEBAQABAQYAAQYWAAP//wD/AAMAAf8BzwP/Ac8L/wHHA/8BxwT/AcABAQL/AcABAQH/AeYBfwL/ + AeYBfwL/AZ8BwAEBAf8BnwHAAQEB/wHiAX8C/wHiAX8C/wGPAcABAQH/AY8BwAEBAfwB8gF/Af8B/AHy + AX8C/wHNAcABAQH/Ac0BwAEBAfgBMgF/Af8B+AEyAX8C/wHMAcABAQH/AcwBwAEBAfABOAF/Af8B8AE4 + AX8B/wH9AeQBwAEBAf0B5AHAAQEB8AEQAX8B/wHwARABfwH/AfABZAHAAQEB8AFkAcABAQH4AQIBfwH/ + AfgBAgF/Af8B8AE0AcABAQHwATQBwAEBAfgBAgF/Af8B+AECAX8B/wHwAQQBwAEBAfABBAHAAQEBPgED + AT8B/wE+AQMBPwH/AfABBAHAAQEB8AEEAcABAQEPAYABHwH/AQ8BgAEfAf8B+AEEAfEBwwH4AQQB8QHD + AcABAAE/Af8BwAEAAT8B/wEeAQYBYAGDAR4BBgFgAYMB8AEAAT4BfwHwAQABPgF/AQYBAAFwAQcBBgEA + AXABBwH/AeABAAF/Af8B4AEAAX8B4AEAAfABBwHgAQAB8AEHAcABIAEBAf8BwAEgAQEB/wH5AcABAAEP + AfkBwAEAAQ8BwAEAAQMB/wHAAQABAwH/AcABQAEAAR8BwAFAAQABHwH/AcABAQL/AcABAQH/AcABAAEv + Af8BwAEAAS8C/wH8AQEC/wH8AQEC/wGAAQcC/wGAAQcC/wH8AQwC/wH8AQwC/wHwARMC/wHwARMC/wH8 + ATwB4wH/AfwBPAHjAf8B+AEzAv8B+AEzAv8B+QEfAYEB/wH5AR8BgQH/AfIBewEPAf8B8gF7AQ8B/wH5 + AYcBAQH/AfkBhwEBAf8B8gE8AQ8B/wHyATwBDwH/AfkBxgEfAf8B+QHGAR8B/wHzARgBDwH/AfMBGAEP + Af8B+wH8AWEB/wH7AfwBYQH/AfMB0AHPAf8B8wHQAc8C/wH4AYEC/wH4AYEC/wHxAQ8C/wHxAQ8C/wH4 + AYcC/wH4AYcC/wHiAQ8C/wHiAQ8C/wH5AREC/wH5AREC/wHgAW8C/wHgAW8C/wH5AREC/wH5AREC/wHk + AQcC/wHkAQcC/wH5AQEC/wH5AQEC/wHkAQcC/wHkAQcD/wHxA/8B8QP/AYcD/wGHEf8B/QP/Af0L/wH8 + A/8B/AT/AcABAQL/AfABAwH/AfwD/wH8BP8BwAEBAv8B8AEBAf8B/gFzAv8B/gFzA/8BwAEBAf8B8QHw + AQEB/wH+AXMC/wH+AXMC/wH3AcABAQH/AfkB8AEBAf8B/gEzAv8B/gEzAv8B8wHAAQEB/wH5AcABAQH+ + AR8BMwH/Af4BHwEzAv8B8wHAAQEB/wH8AcABAQH8AQ8BMwH/AfwBDwEzAv8B+QGAAQEB/wH8AcABAQH8 + AQcBkwH/AfwBBwGTAv8B+QGAAQEB/AE8AUABAQH8AQMBEwH/AfwBAwETAf8B/gF5AYABAQH8AQ4BQAED + AfwBAQEzAf8B/AEBATMB/wH4ARwBgAEBAfgBDgFIAcMB/AEBATMB/wH8AQEBMwH/AfgBHAGRAcMB+AEG + AUgBAwH+AQABMwH/Af4BAAEzAf8B+AEMAZABgwH8AQIBSAEHAX8BgAE5Af8BfwGAATkB/wH4AQQBkAEH + AfwBAAHMAQcBDwHgATwB/wEPAeABPAH/AfwBAQGQAQcB/gEAAeYBHwGDAfABAAH/AYMB8AEAAf8B/gEB + AYgBDwEfAYABcwH/AeABAAEDAf8B4AEAAQMB/wEfAQABxAEfAQcB4AEDAf8B/AEIAQEB/wH8AQgBAQH/ + AQcBwAEHAf8BwAEAAQcC/wF+AQABQAH/AX4BAAFAAcABAAEPAf8B+AEAAQcC/wH+AgAB/wH+AgAB+AEw + AQ8BzwH+AXwBAQEDAeABBgEAAR8B4AEGAQABHwH/AfgBAAEPAecB+AEAAQMB4AECAQABbwHgAQIBAAFv + AeABGAEAAT8B4AENAQAC/wH4AZABBwH/AfgBkAEHAeABCAEHAf8B8AEBAQABnwH/AfwBgAEDAf8B/AGA + AQMB/wHCAQABfwH/AfEBAAEfAv8BwAEzAv8BwAEzAf8B8gEAAT8C/wEAAU8C/wHIAXkC/wHIAXkB/wH+ + AUMBPwL/AYABxwL/AcwB+QL/AcwB+QL/ASMBnwL/AZMB5wL/AckD/wHJAv8B/gFHAZ8C/wEjA/8BiAP/ + AYgC/wH+AU8D/wEjA/8BnAEfAv8BnAEfAf8B/gFBA/8BMAF/Av8BnwEfAv8BnwEfAf8B/AHxAv8B/gE8 + AX8C/wGfA/8BnwL/AfwD/wH+AX8B/ws= + + + + Volkname + + + Autor + + + 138, 22 + + + Entfernen + + + 140, 22 + + + Neues Team + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 140, 22 + + + 138, 22 + + + Verschieben + + + 139, 48 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDEF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXAwCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDIF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXAxCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDMF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXAyCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDQF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXAzCw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDUF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXA0Cw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDYF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXA1Cw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDcF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXA2Cw== + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDgF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXA3Cw== + + + + Erstellen + + + Laden + + + Entfernen + + + Eigenschaften + + + Einstellungen + + + Teams zurücksetzen + + + 127, 22 + + + Aktuelle Einstellungen: + + + Teamzusammenstellung + + \ No newline at end of file diff --git a/SimulationPlugin/TeamSetup.resx b/SimulationPlugin/TeamSetup.resx new file mode 100644 index 0000000..4db4971 --- /dev/null +++ b/SimulationPlugin/TeamSetup.resx @@ -0,0 +1,1232 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + 110, 22 + + + Remove + + + Team 1 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + splitContainer1.Panel1 + + + Team 4 + + + Magenta + + + + Fill + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDYF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXA1Cw== + + + + propertiesMenuItem + + + + False + + + 0 + + + False + + + toolStripSeparator4 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + moveTeam8MenuItem + + + 131, 22 + + + 4 + + + loadMenuItem + + + Create Colony + + + toolStripSeparator3 + + + author2Column + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 23, 22 + + + 0 + + + 131, 22 + + + False + + + Properties + + + Team 8 + + + Load Colony + + + 131, 22 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripSeparator, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + chooseTeam1MenuItem + + + playerContextMenu + + + Team 1 + + + Remove + + + 131, 22 + + + 23, 22 + + + chooseTeam5MenuItem + + + loadButton + + + Team 4 + + + False + + + removeButton + + + playerColumn + + + 3 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDgF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXA3Cw== + + + + nameColumn + + + propertiesButton + + + 131, 22 + + + False + + + 131, 22 + + + 0 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + removeMenuItem + + + splitContainer1.Panel2 + + + False + + + Author + + + 146, 6 + + + moveTeam1MenuItem + + + Team 7 + + + TeamSetup + + + resetButton + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDQF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXAzCw== + + + + System.Windows.Forms.ToolStripLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAA1TdGF0aWMgQ29sb255Bfz///8oU3lzdGVtLldpbmRvd3MuRm9ybXMuSG9yaXpvbnRhbEFsaWdu + bWVudAEAAAAHdmFsdWVfXwAIAgAAAAAAAAAKBgUAAAALc3RhdGljR3JvdXAL + + + + False + + + splitContainer1 + + + System.Windows.Forms.ContextMenuStrip, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 817, 494 + + + 146, 6 + + + 23, 22 + + + splitContainer1 + + + False + + + splitContainer1.Panel1 + + + openFileDialog + + + False + + + settingsLabel + + + chooseTeam4MenuItem + + + 588 + + + createMenuItem + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDEF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXAwCw== + + + + moveTeam3MenuItem + + + Team 6 + + + moveTeam2MenuItem + + + False + + + 0 + + + False + + + settingsButton + + + 0, 0 + + + 149, 22 + + + teamListView + + + chooseTeam3MenuItem + + + Load + + + 137 + + + System.Windows.Forms.ListView, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Team 2 + + + playerListView + + + toolStripMenuItem1 + + + chooseMenuItem + + + 23, 22 + + + Segoe UI, 9pt, style=Bold + + + Team 6 + + + False + + + imageList + + + $this + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAABBOb25zdGF0aWMgQ29sb255Bfz///8oU3lzdGVtLldpbmRvd3MuRm9ybXMuSG9yaXpvbnRhbEFs + aWdubWVudAEAAAAHdmFsdWVfXwAIAgAAAAAAAAAKBgUAAAAObm9uU3RhdGljR3JvdXAL + + + + chooseTeam8MenuItem + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + Team 5 + + + 131, 22 + + + Top + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripSeparator, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 171 + + + 2 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 225, 494 + + + authorColumn + + + Create + + + 149, 22 + + + 0, 0 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDMF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXAyCw== + + + + teamContextMenu + + + 131, 22 + + + 817, 27 + + + System.Windows.Forms.ToolStripSeparator, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + False + + + 0, 52 + + + splitContainer1 + + + Author + + + 131, 22 + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 149, 22 + + + False + + + Colony + + + New Team + + + Fill + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + chooseTeam7MenuItem + + + Properties + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Team 2 + + + moveMenuItem + + + 146 + + + 817, 25 + + + settingsLabelLabel + + + moveTeam6MenuItem + + + System.Windows.Forms.ToolStripSeparator, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Team 3 + + + AntMe! Colony|*.dll + + + System.Windows.Forms.ContextMenuStrip, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDUF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXA0Cw== + + + + 131, 22 + + + False + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDIF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXAxCw== + + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + timer + + + False + + + chooseTeam6MenuItem + + + moveTeam4MenuItem + + + newTeamMenuItem + + + Microsoft Sans Serif, 11.25pt, style=Bold + + + System.Windows.Forms.ToolStrip, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 131, 22 + + + Capture The Apple + + + Current Settings: + + + 131, 22 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Settings + + + System.Windows.Forms.ToolStripSeparator, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 817, 546 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + splitContainer1.Panel2 + + + 23, 22 + + + 131, 22 + + + False + + + 149, 22 + + + 95, 22 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.UserControl, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Selected ColonyStates + + + 149, 22 + + + 6, 25 + + + Team 8 + + + 150, 126 + + + Reset Teams + + + 6, 25 + + + System.Windows.Forms.ColumnHeader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Magenta + + + Move + + + False + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBAAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh + ZwROYW1lAQQCAShTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAIAAAAG + AwAAAAZUZWFtIDcF/P///yhTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AQAA + AAd2YWx1ZV9fAAgCAAAAAAAAAAoGBQAAAAp0ZWFtR3JvdXA2Cw== + + + + toolStripSeparator2 + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + kickMenuItem + + + 4, 4, 4, 4 + + + 6, 25 + + + createButton + + + 23, 22 + + + 6, 13 + + + System.Windows.Forms.SplitterPanel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + Magenta + + + Team 3 + + + System.Windows.Forms.SplitterPanel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + moveNewTeamMenuItem + + + 117, 22 + + + False + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 0 + + + Team 7 + + + Fill + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Magenta + + + Magenta + + + Select + + + moveTeam5MenuItem + + + Remove + + + System.Windows.Forms.OpenFileDialog, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 131, 22 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAAD0 + LgAAAk1TRnQBSQFMAgEBCAEAATQBAAE4AQABIAEAASABAAT/ARkBEAj/AUIBTQE2BwABNgMAASgDAAGA + AwABYAMAAQEBAAEYBgABkP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A + /wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AGAAAvoB+wLa + AexaAAP7A+P/ABsAA/4CuAHfAvsB/FcAA/4DzAP8bwAD/wP1AfEB8wH0AfMC9AHzAvQB8wL0AfMC9AHz + AvQB8wL0AfMC9AHzBfQD/jkAA/8D9QPzG/QD/iQAAuAB7gLRAegGAAL6AfsD/U4AA+cD3AYAA/oD/UgA + A/8D/RUAA/cBuwHaAf8BRAGVAf8BLAGLAf8BLAGMAf8BLAGMAf8BLAGMAf8BLAGMAf8BLAGMAf8BLAGM + Af8BLQGFAf8BmQHHAf8D9h4AA/8D/RUAA/cD3QOeA5QSlQOPA8wD9iQAA/0CnQHWA/8DAALGAeQC1wHq + TgAD/QO6A/8DAAPVA+BIAAP+Ar8B4QL9Af4SAAP2Aa0B0gH/AT0BkAH/AQABaAH/AQABagH/AQABagH/ + AQABagH/AQABagH/AQABagH/AQABagH/AQABXwH/AVkBpAH/A/UeAAP+A9AD/RIAA/YD1gOZA3QSdgNs + A6wD9RUAAvoB+wL6AfsMAAK1Ad4C4gHvAwAC4AHuAscB5T8ABvsMAAPKA+kDAAPnA9ZLAALZAesC2wHs + BgAD/gkAA/kB0QHlAf4BYgGlAf8BcwGzAf8BdAGzAf8BdAGzAf8BdAGzAf8BdAGzAf8BdAGzAf8BcwGz + Af8BdAGwAf8B1wHpAf8D+CEAA+ID4wYAA/4JAAP5A+cDrRW5A7YD6wP4EgACvAHhAh8BsAIdAa4CkAHS + Av0B/gYAAu0B9AKYAdQDAALeAe0CvAHhPAADzgNnA2YDsQP9BgAD8QO2AwAD5gPOSwAD/AKnAdoGAAK1 + Ad4C+AH6BgAD9gGzAdYB/wFGAZQB/wEUAX4B/wEUAX8B/wEUAX8B/wEUAX8B/wEUAX8B/wEUAX8B/wEU + AX8B/wEUAXYB/wF+AbcB/wP1IQAD/APABgADygP5BgAD9gPZA50DiBKJA4EDvQP1DwAD/gIrAbMCBgGo + AgYBqAIGAagCdgHKCQACgAHMAvwB/QLiAe8C0QHoOQAD/gNvCVcDoAkAA6YD/QPpA90/AAP8DAACsgHd + AuwB9AMAAsEB4gLvAfUGAAP2AaoB0QH/ATgBjAH/AQMBdAH/AQMBdQH/AQMBdgH/AQMBdgH/AQMBdgH/ + AQMBdgH/AQMBdgH/AQMBbAH/AXABsQH/A/UVAAP8DAADyAPwAwAD0gPyBgAD9gPUA5UDfwOADIEDgAN4 + A7gD9Q8AA/4CMwG1AgYBqAIGAagCBgGoAgYDqAHZAwAD/AKOAdED/gLbAewC3AHtOQAD/gN0DFcDwQMA + A/wDrwP+A+MD5TkAAvsB/AJoAcUCJAGxAmoBxQLyAfcGAALpAfICqAHZAwACxAHjAusB8wYAA/kB0wHm + Af4BWwGiAf8BbAGvAf8BbAGvAf8BbAGvAf8BbAGvAf8BbAGvAf8BbAGvAf8BbAGvAf8BbQGsAf8B1wHp + Af8D+A8AA/sDlwNqA5gD9AYAA+4DwQMAA9QD7wYAA/kD5wOpFbUDsgPrA/gSAAKhAdcCBgGoAgYBqAIG + AagCBgGoAgYBqALuAfUC3wHuAr4B4QMAAsMB4wLEAeM8AAO8D1cD8QPmA9ADAAPTA9Q5AALaAewCBgGo + AgYBqAIGAagCKwGzAvgB+gYAAoYBzwMAAskB5QLzAfcGAAP2AaUBzgH/ATMBiwH/AQABbQH/AQABbgH/ + AQABbgH/AQABbgH/AQABbgH/AQABbgH/AQABbgH/AQABYwH/AV8BqAH/A/UPAAPjCVcDbwP5BgADqgMA + A9cD9QYAA/YD0gOVA3gDeQ96A3ADrwP1EgAD/gKmAdkCBgGoAgYBqAIGAagCBgGoArUB3gK3Ad8C8AH2 + AwAC7wH1AoABzDwAA/4DwAxXA8oDywPzAwAD8gOmOQAC4AHuAgYBqAIGAagCBgGoAgYBqAJaAcED/wL4 + AfoCmwHVAwACtgHfAvYB+QYAA/cBtQHXAf8BNAGLAf8BGQGGAf8BEQF+Af8BGAGBAf8BGQGCAf8BGQGC + Af8BEQF+Af8BGQGHAf8BEwF3Af8BjQHBAf8D9Q8AA+cMVwONA/8D+QO4AwADygP3BgAD9wPaA5UDkQOJ + A4sDjAOLA4gDkQOCA8YD9QMAAuoB8wL1AfgPAALtAfQCgwHNAhUBrQIGAagCigHQAo4B0QLpAfIGAALX + AesCvAHhKgAD7wP2DwAD8AOoA2ADVwOtA68D7gYAA+EDzjYAAvwB/QJOAb0CBgGoAgYBqAIGAagCBgGo + AssB5gLUAekC1QHqAwACmAHUAuwB9AYAA/4D9AHeAegB8gGcAaQBsAHhAeoB8wHoAe8B+AHoAe8B+AHo + Ae8B9wHlAe8B+AGeAaYBsgHZAeEB6wP0A/4PAAP9A4UMVwPYA98D4AMAA7YD8AYAA/4D9APpA6UD6wbw + A+8D8AOoA+ID9AP+AwAC7AHzArkB3wKyAd0C5QHwDwAC8wH3AuoB8wJKAbwCDwGrAmUBxALiAe8CygHl + AsAB4gJoAcUD/ycAA/ADzAPIA+oPAAP1A+8DgwNcA5QD6APYA9EDlwP/NgAC+wH8ApsB1QIKAaoCBgGo + AgYBqAKbAdUCtAHeAvUB+AMAAugB8gKhAdcMAAHkAeEB3QFmAWABXQHnAeUB4gkAAfAB7gHrAWsBZgFi + AdcB1AHRA/0VAAP8A7gDWQZXA7gDyQP2AwAD7AO8DAAD4ANgA+UJAAPtA2UD0wP9DAAC8AH2ArMB3QKP + AdECwgHjAvMB9wLkAfACqAHZApgB1AKVAdMCagHFAggBqAIGAagCCAGoAqAB2ALOAecC+gH7MAAD8wPI + A7AD0gP1A+oDwQO2A7QDmANZA1cDWQO8A9sD+yoAAs8B5wLRAegC+AH6DAAC8wH3AqwB2wJ3AckCUwG/ + AlcBvwLRAegGAAKtAdsCzQHnBgAD/gPjAXICcAPbA/sDAAP+A+sBZwJlAdgC1wP8BgAD2wPcA/kMAAP1 + A8QDoAOJA4sD3AYAA8QD2gYAA/4D4wNwA9sD+wMAA/4D6wNlA9cD/BIAAvoB+wLJAeUCigHQAq0B2wLm + AfED/gL6AfsCsAHdAggBqAIGAagCDwGrArIB3QLXAeoC4AHuDwAC+wH8A/4hAAP7A9cDrQPEA+sD/gP7 + A8YDWQNXA1wDyAPgA+cPAAP7A/4VAAL8Af0C5AHwAqYB2QKvAdwC5gHxBgAC+wH8AtoB7ALNAecCdgHK + AgYBqAIdAa4CewHLAoYBzwKYAdQC5gHxCQAD8QGxArABtgK1A+4D9AP2AZ0CnAFyAnAD8AkAA/0D6gPA + A8YD6wYAA/sD4wPaA6ADVwNmA6MDqgO2A+sJAAPxA7ADtQPuA/QD9gOcA3AD8CoAAvcB+QIqAbICGwGu + AgYBqAIGAagCjgHRAtQB6QKpAdoC0QHoAsQB4wLBAeICvAHhAscB5QL7Afw2AAP4A24DZQZXA68D3wPC + A9wD1APSA84D1gP7HgAC7AHzArAB3QKGAc4CmQHUApoB1QLLAeYCzAHmAncByQIKAaoCBgGoAh0BrgLg + A+4B9QwAA/kB6QHoAeABqAOmAqUBnwKeAYECgAFfAl0D0gP1EgAD8APGA6oDtwO4A9gD2QOgA1kDVwNm + A+cD8QwAA/kD5QOmA6UDngOAA10D0gP1DwAC/AH9Aq0B2wK8AeECwAHiAsEB4gK9AeECrgHcAtYB6gMA + AuMB7wKVAdMC5gHxAgYBqAIGAagCYAHCAqEB1wLfAe4C2gHsAukB8gL5AfsD/iEAA/wDxAPOA9ED0gPP + A8UD4AMAA+kDtAPrBlcDkQO8A+YD4wPuA/oD/ioAA/0C9wH5CQAC+QH6AhYBrAIGAagCBgGoAhcBrAKj + AdgCvwHhAusB8wLvAfUC4AHuAtsB6wLCAeUD5gG5ArgBiwKJAaACnwHgAt8D9BsAA/0D+AkAA/oDYQZX + A2IDvgPQA+8D8gPnA+ID1APmA7gDiQOfA98D9BIAA/8C7wH1AuIB7wLdAe0C5QHwAukB8gLeAe0CnAHV + ArAB3QLHAeUCwwPjAe8CowHYAooB0AJEAbsCBgGoAkYBugP+A/8C7wH1JAAD/wPyA+kD5QPqA+4D5gO5 + A8YD1gPTA+kDvgOtA38DVwOBA/4D/wPyJAAC9gH5As4B5wLdAe0C3wHuAuIB7wLaAewC5QHwAwAC8gH3 + AoQBzgKyAd0CBgGoAgYBqAKnAdoCywHmAsYB5AK+AeEC3AHsAusB8wP9A/sD9Qb0A/oVAAP3A9sD5QPm + A+kD4wPqAwAD9AOpA8gGVwPAA9gD1QPQA+QD7wP9A/sD9Qb0A/otAALcAe0CiAHPAvoB+wLoAfIC0wHp + ArIB3QIGAagCBgGoAgYBqAJvAccCuwHgApkB1AL1Afg5AAPlA6sD+gPsA94DyAlXA5sDzgO3A/YhAAL6 + AfsC0gHpAsUB5ALDAeMC1QHqAscB5QKZAdQCsQHdAtgB6wK/AeEC5AHwAoMBzQJmAcQCHwGwAgYBqALc + Ae0DAAL7AfwqAAP7A90D1APTA+AD1gO3A8cD4gPQA+oDqAOVA2cDVwPlAwAD/E4AAq8B3ALvAfUCWgHB + AgYBqAIGAagCnAHVA/4C+wH8AroB4EUAA8YD8gONBlcDuQP+A/sDzTYAAuAB7gJ4AcoC9gH4At0B7QLf + Ae4CbwHHAgYBqAIGAagCFwGsArUB3gKcAdUC4gHvPAAD5wOhA/cD5QPmA5sGVwNiA8oDuQPpSwACuwHg + AucB8QL9Af4CegHLAqUB2QP+BgACyQHlAusB80IAA84D7AP9A6IDvwP+BgAD1wPvPAAD/QKuAdwC5QHw + Ah8BsAIGAagCJAGxAu8B9QMAArUB3gP8QgAD/QPFA+oDZwNXA2oD8gMAA8oD/EgAAqgB2QL7AfwC+gH7 + AroB4AwAA/0C+wH8CQAD/gH2AfgB+gH5AfoB+zAAA8ED/AP7A80MAAP9A/sJAAP+A/gD+i0AAqYB2QL8 + Af0C8gH2AmwBxgLxAfYGAALoAfIC3AHtRQADwAP8A/QDmgPzBgAD7APlRQAC+gH7ArYB3wMAAuAB7gKr + AdsD/RIAAfAB9AH4AZQBwAH1ASABhAH8AQABdAH/AQIBdgH/AvsB/CoAA/sDygMAA+cDwwP9EgAD9APE + A44DfwOBA/snAAL8Af0CsAHdAwAC0QHoAuoB8wwAA/0GAAP/AfAB9AH4AdkB5gH1AfEB9QH5MAAD/QPG + AwAD3APuDAAD/QYAA/8D9APnA/UzAALkAfAC2QHrBgAC5gHxArAB3QLYAesD/gkAAasBzAH0AQABdAH/ + AQABdAH/AWMBpgH3AacBygH0Ac0B3wH0A/4qAAPqA+IGAAPrA8YD4gP+CQAD0AZ/A60DzgPhA/4nAALs + AfQCzwHnAwACxwHlAsMB4wL6AfsMAAP/Ab4B1wH0ASgBiQH7AQABdAH/AQABdAH/AYYBuQH1MAAD8APb + AwAD1gPTA/oMAAP/A9kDkgZ/A74zAALXAesC+AH6CQAD/gLhAe8D/QYAAYoBugH1AQABdAH/AXoBsgH2 + AfUB9wH6NgAD4QP5CQAD/gPoA/0GAAO/A38DuAP3MwACzQHnAvAB9QYAAusB8wKwAd0C6wHzBgAB+gH7 + AfwBVgGfAfgBAAF0Af8BcgGuAfYB2QHmAvUB9wH6A/4wAAPaA/MGAAPvA8YD7wYAA/sDpwN/A7QD5wP3 + A/4zAAP/GAABvwHXAfQBAAF0Af8BogHHAfQGAAHhAesB9gGaAcMB9AGYAcIB9QL9Af4qAAP/GAAD2gN/ + A8sGAAPsA8cDxgP9JwAC7gH1A/8MAAP8AwAB/QL+AUoBmQH4AQQBdgH/AeIB6wH2BgAB+AH5AfsB/AL9 + MAAD8QP/DAAD/AMAA/4DoQOBA+wGAAP5A/1LAAH6AfsB/AELAXkB/gFYAaEB+AMAA/4BfQG0AfUBAAF0 + Af8BAAF0Af8BOQGQAfoB+wL8QgAD+wOEA6gDAAP+A7kGfwOZA/w/AAGjAcgB9AEAAXQB/wHpAe8B9wMA + AdcB5QH1ATIBjgH7AQABdAH/AYQBtwH1SAADzAN/A/ADAAPmA5YDfwO8SwABvwHXAfQBAAF0Af8B6gHw + AfcDAAGPAb0B9QEAAXQB/wGrAcwB9AH5AfoB+0gAA9oDfwPxAwADwgN/A88D+kIAAfoB+wH8AQABdAH/ + AZgBwgH0AwABzgHgAfUBAAF0Af8BXwGlAfcB0gHiAfUB9gH4AfpFAAP7A38DxgMAA+EDfwOrA+MD+EsA + AWYBqAH3ARwBggH8AwAB9QH3AfoBAAF0Af8BjgG9AfUDAAP+AeoB8AH3A/5CAAOuA4wDAAP4A38DwQMA + A/4D8QP+PAAB1QHkAfUBAAF0Af8B9AH3AfkD/QEJAXkB/gF3AbEB9gYAA/9FAAPlA38D9wP9A4MDtgYA + A/9LAAEZAYEB/QFPAZwB+AMAAcwB3gH1AQABdAH/AeoB8AH3AwABXAGjAfcBAAF0Af8BlAHAAfVCAAOL + A6QDAAPgA38D8QMAA6kDfwPEPAABpAHJAfQBAAF0Af8DAAHeAekB9gEAAXQB/wHwAfQB+QP9AVIBngH5 + ASwBiwH7Ae4B8gH4QgADzAN/AwAD6gN/A/QD/QOlA5QD80gAAYYBuQH1AbIB0AH0AwAB5QHtAfYBXQGj + AfcB+wL8A/4BDQF7Af4BAAF0Af8BUwGeAfhCAAO+A9MDAAPuA6oD/AP+A4UDfwOlPAABxwHbAfQBZgGo + AfcDAAHmAe4B9wFNAZsB+AP+AfAB9AH5AQABdAH/AQABdAH/AcYB2wH0QgAD3gOuAwAD7gOiA/4D9AZ/ + A91dAAHlAe0B9wGfAcYB9AHyAfUB+VcAA+4DyQP1TgAD/wHFAdoB9AGsAc0B9AH8Av1UAAP/A9wD0AP9 + /wC0AALvAfVdAAPy/wAeAALBAeIC8AH2WgAD0gPzZgAD/wP1A/Mb9AP+PwAD+wHxAfIB9AHyAfMB9AHz + AvQB8wL0AfMC9AHzAvQB8wL0AfMC9AP1MAAC8wH3AqwB21oAA/UDxGYAA/cD3QOeA5QSlQOPA8wD9j8A + Ae0B8QH1AXMBswH/AS4BiwH/ASoBigH/ASoBiwH/ASoBiwH/ASoBiwH/ASoBiwH/ASoBhAH/AYkBvwH/ + A/cwAAKgAdcC9gH5CQAC9AH3A/5LAAO7A/cJAAP1A/5UAAP2A9YDmQN0EnYDbAOsA/UnAAP+AswB5gP+ + DwAB6wHwAfYBawGuAf8BFAF+Af8BDgF6Af8BDgF8Af8BDgF8Af8BDgF8Af8BDgF8Af8BDgFzAf8BdgGz + Af8D9zAAAtgB6wK3Ad8JAAJ3AckC8QH2SwAD4gPLCQADoAPzQgAD/A8AA/kD5wOtFbkDtgPrA/gqAALM + AeYC3QHtDwAB8AHyAfQBcgGyAf8BUgGeAf8BVQGjAf8BVQGjAf8BVQGjAf8BVQGjAf8BVQGjAf8BVgGe + Af8BvgHbAf4D+jAAA/0CegHLA/4GAAKqAdoC6wHzSwAD/QOiA/4GAAPCA+9CAAPSA/cMAAP2A9kDnQOI + EokDgQO9A/UqAAL7AfwCoAHXCQAG/gHqAfAB9wFcAaYB/wEAAWwB/wEAAWYB/wEAAWgB/wEAAWgB/wEA + AWgB/wEAAWgB/wEAAV4B/wFUAaIB/wP2GAAC8gH3ArwB4QK9AeEC7wH1DwACnwHWAtcB6wYAAq8B3ALk + AfAzAAP0A84DzwPyDwADugPhBgADxgPqQgAD8QPQDAAD9gPUA5UDfwOADIEDgAN4A7gD9S0AAqoB2gLr + AfMGAALaAewCxgHiAfIB8wH0AXMBswH/AVUBnwH/AVgBpAH/AVgBpAH/AVgBpAH/AVgBpAH/AVgBpAH/ + AVgBnwH/AcEB3QH+A/oVAALyAfYCEQGrAgYBqAIGAagCBgGoAqkB2gwAAukB8gJ7AcsGAAKnAdoC4QHv + MAAD9ANeCVcDwgwAA+4DowYAA8AD6EUAA7wD+wYAA+sD8QPrA6kVtQOyA+sD+C0AAugB8gKhAdcGAALv + AfUCsAHaAfIC9QFpAa0B/wEPAXsB/wEIAXcB/wEIAXgB/wEIAXgB/wEIAXgB/wEIAXkB/wEIAXAB/wFu + AbAB/wP2FQACvgHhAgYBqAIGAagCBgGoAgYBqAIGAagCtAHeDAACYQHCAvQB+AMAAqcB2gLsAfMwAAPQ + D1cDyQwAA5ID9gMAA8AD8EUAA9wD1wYAA80D2QPXA5UDeAN5D3oDcAOvA/UVAAL7AfwCygHlArUB3gLi + Ae8MAAP/AnsBywL6AfsDAALyAfcCqQHYAfIB9AH1AXEBsgH/AS8BjwH/ASwBjQH/ATYBkQH/ATYBkgH/ + ATIBjwH/AS4BjgH/ASsBhwH/AY8BwgH/A/gVAAK1Ad4CBgGoAgYBqAIGAagCBgGoAgYBqAIGAagC1wHr + BgAC/QH+Am8BxwL7AfwDAAKiAdcC7wH1MAADyhJXA+EGAAP9A5sD+wMAA70D8jMAA/YD+wwAA/sDqwYA + A+YD0gPfA5UDkQOJA4sDjAOLA4gDkQOCA8YD9RUAAm8BxwIGAagCBgGoAgYBqAJ6AcsD/gkAArgB3wK7 + AeADAALyAfYCnQHVA/wC9gH3AagBpwGmAeUB5AHjBvQD9QG5AbcBtgHJAcgBxgP1GAAC3wHuAgYBqAIG + AagCBgGoAgYBqAIGAagCBgGoAhcBrAL1AfgDAALaAewCmQHUBgACmAHUAu4B9TAAA+YSVwNiA/YDAAPj + A7cGAAO2A/EtAAP7A40DVwNmA7YD/gkAA7YD6wMAA+ED2QP0A+kDpQPrBvAD7wPwA6gD4gP0A/4SAAL6 + AfsCEwGrAgYBqAIGAagCBgGoAgYBqAKBAc0JAALwAfYCdgHKAwAC8AH2ArQB3QMAA/QBewF4AXcB1AHT + AdEGAAP3AZYBlAGTAacBpAGjA/sYAAP+Al8BwwIGAagCBgGoAgYBqAIGAagCBgGoAgYBqAJ7AcsDAAKO + AdEC5AHwBgACegHLAuMB7zAAA/4DkBJXA6MDAAOvA+oGAAOiA+ktAAPbDFcDpwkAA+YDswMAA9sD5gMA + A+ADYAPlCQAD7QNlA9MD/RUAAvsB/AIbAa4CBgGoAgYBqAIGAagCBgGoAgYBqAKxAd0GAALUAeoCqgHa + AwAC6gHzAroB4AMAA/QBpwKmAcQCwwP1A/sD9AF4AnYDxgP8GwAC/AH9ApgB1AIGAagCBgGoAgYBqAIG + AagCBgGoAjABtQL5AfoCcQHIA/8GAALWAeoCfAHLMwAD/QO2D1cDcgP6A50D/wYAA+ADpC0AA9MPVwPD + BgAD4gPEAwAD0wPsAwAD4wNwA9sD+wMAA/4D6wNlA9cD/BgAAmwBxgIGAagCBgGoAgYBqAIGAagCBgGo + AgYBqALmAfEDAAKGAc8C7QH0AwAC3gHtApoB1QMAA/sD3gGpAqgBuwK6AbwCuwGAAn4BkAKOA/IJAAP8 + GAAC6AHyAm8BxwIGAagCBgGoAgYBqAItAbMC+gH7AmMBxAL8Af0JAAKgAdcCyQHlGwAD/BgAA+wDmwlX + A3AD+wOTA/0JAAO7A9cqAAPwElcD5wMAA7AD8QMAA8YD5gMAA/EDsAO1A+4D9AP2A5wDcAPwGwAC8wH3 + AkgBvAIGAagCBgGoAgYBqAIGAagCBgGoAnYBygL5AfoChAHOBgAC7QH0AmEBwgYAA/YD4AGpAqgBhAKD + AawCqgHxAvAD/gkAAtsB7AKrAdsC4AHuA/8VAALpAfICsAHdApUB0wI7AbcCWQHAAlYBwALFAeQMAAJF + AboC+AH6GAAD4wPDA+cD/xUAA+4DxgO0A3kDjQOLA9QMAAN/A/kqAAPDD1cDjwP4A64GAAPNA8YDAAP3 + A90DpgOlA54DgANdA9ID9R4AA/0CrQHbAhkBrgIGAagCBgGoAgYBqAJrAcYC7QH0ApkB1AkAAqwB2wLE + AeMGAAP8A/UD9AP3EgAC9wH5ArsB4AKMAdACwAHiAvYB+RIAAvYB+QP9As0B5wIWAawCLwG0AgYBqAKm + AdkCfgHMAnMByQJ/AcwCZQHEAvsB/BsAA/gDzgOuA9ED9xIAA/cD/QPaA2EDcgNXA8ADpQOeA6UDlAP7 + LQAD5wOHCVcDhAPsA70GAAP8A6AD9gMAA/UD5QO4A4kDnwPfA/QMAALQAegC3gHtA/4SAAL3AfkCqQHa + Aj8BuQIkAbECNwG2ArQB3gJjAcQD/wkAAoABzALqAfMnAAL7AfwCywHmAoEBzQKOAdEC2QHrAvsB/ALu + AfUCrQHbAnEByAJ7AcsCXwHDAoEBzQJKAbwCBgGoAgYBqAIGAagCjAHQAtYB6gLvAfUnAAP8A9gDpwOv + A+ID/APxA8QDnQOjA5ADpwODCVcDrgPgA/IeAAPcA+MD/Q8AA/4D3QOYA3kDcgO7A5gD/wYAA/kDpQP+ + AwAD+wP1BvQD+g8AAvcB+QLPAecCmQHUAsMB4wL2AfgSAAP8A/0CigHQAgYBqAIpAbMCfwHMAt4B7QK8 + AeECwwHjAlMBvwLUAekwAALjAe8CjAHQAl8BwwKBAc0CyQHlAvgB+gMAAv0B/gLRAegCDwGrAgYBqAIG + AagCBgGoAnoBywLzAfcC3gHtAvIB9y0AA+kDrgOQA6cD1wP5AwAD/QPdA1wJVwOiA/UD5gP0GwAD+gPg + A7gDzwP0DwAD+wP3A8gDVwNjA6UD0AO3A74DlwP+JwAD/QLUAeoCkAHSApMB0gLaAewC/QH+A/0C2wHs + ApgB1AJ3AckCegHLApYB0wIvAbQCBgGoAgYBqAIRAasCjAHQArYB3wLqAfM5AAP9EgACsQHdAgYBqAIG + AagCBgGoAgYBqAIGAagCpwHaApYB0wK1Ad4D/QMAA/4C9gH4Au0B9ALcAewCzQHnAuYB8RgAA/0SAAPH + D1cDwAO1A8oD/QMAA/4D9wPwA+QD2gPrBgAD/gPjA7UDsAPdA/YD3wOyA6sDoQOiA20GVwNyA9QD6gP+ + MwAC6QHyAp0B1gJoAcUCegHLAqAB2ALkAfAC/AH9AvMB9wKnAdoCBgGoAgYBqAIGAagCHQGuAuQB8AL1 + AfgC7wH1TgACbwHHApMB0gJuAccCBgGoAgYBqAIGAagCtQHeA/4C0gHpAoEBzQKKAdAClQHTAqMB2ALD + AeMC2QHrAvEB9gL8Af0tAAObA7MDmglXA8oD/gPdA6cDrQO0A74D0wPiA/QD/Q8AA/EDvgOlA8gD8QYA + A+UDawZXA20G3QPpEgAD/gP/IQAC+gH7AvwB/Q8AAnMByQIGAagCBgGoAgYBqAIGAagCZwHEArEB3QKi + AdcC9gH4AwAD/ALyAfcC6gHzAtcB6wLQAegD/Q8AAvMB9wJzAckCnAHVAqIB1wKgAdgCoQHXAqMB2AKW + AdMCigHQAuAB7gYAAmEBwgLkAfAD/AIGAagCBgGoAgYBqAKGAc4COgG4AsYB5AL9Af4C+AH6A/4YAAP1 + A54DuQO9BrwDvgO1A60D5wYAA5ID6gP8CVcDqgN5A9UD/QP5A/42AAOqA1wJVwPAA9cDvgPuA+wD3APX + A84D1AP8FQAD/QP+GAAD/gJEAbsCsQHdAjcBtgIGAagCBgGoAjMBtQL7AfwC5AHwApkB1AKKAdACogHX + Aq4B3ALPAecC4wHvAvYB+QP/DwAD/wL2AfgC7AHzAucB8QLnAfEC7gH1AvAB9gLsAfMC2AHrAnABxwKv + AdwDAAJzAckC9gH4AuIB7wKdAdYCpwHaApMB0gJhAcICBgGoAgYBqAK2Ad8GAAL8Af0VAAP/A/cD8Abs + A/ED8wPwA+IDnAPGAwADngP3A+kDugPAA7MDkgZXA8oGAAP9FQAD5QPqA/AG7wPuA+wD+gYAA4UD6gOV + BlcDogPgA+oDwQPQA+AD8QP6GwACzQHnAoYBzwKiAdcCnAHVAqEB1wKnAdoCjAHQAmoBxQK7AeAGAAJN + Ab0DAALEAeMCBgGoAgYBqAJqAcUCOwG3AmgBxQP8A/0/AAKyAd0CVwG/AnMByQMAAuAB7gK6AeADAAIi + Aa8CBgGoAgYBqAIGAagCBgGoAugB8gLPAecCfwHMAtsB7DAAA8gDiwOeAwAD5wPNAwADaQxXA+wD2wOl + A+MSAAPhA8QDvQO8A8wDygO5A5cD3gMAA5UD/wPGA4sDhQOYA1cDmi0AAv0B/gL3AfkC9AP4AfoD/QL7 + AfwC8wH3AqMB2AKPAdEC6QHyAmsBxgMAAqAB1wLeAe0CqwHbAmcBxAIGAagCBgGoAlUBvwP+AwAC5gHx + A/45AALyAfcC+wH8AwAD/gKQAdIC9wH5AnQByQIGAagCBgGoAgYBqAIGAagCXAHBAtEB6AP9AqUB2QL7 + AfwwAAP0A/sDAAP+A7ED+AOfDFcDjwPdA/0DvwP7JAAD/AO6A5wDqgMAA7cD+wOmA1wGVwOrA/UDugPi + OQAC4AHuAmEBwgLNAecDAAK1Ad4C7QH0ArMB3QIGAagCBgGoAgYBqAIGAagCmgHVArAB3QKgAdgCzQHn + RQAC3AHtArsB4AP/AmMBxAIGAagCBgGoAgYBqALyAfcGAALoAfICyQHlPAAD5QPOA/8DkwlXA/QGAAPt + A9cqAAPpA/gDAAPfA94DxAlXA1wDwAPxA8cD+kIAAvoB+wKcAdUC+gH7AkgBvAIGAagCBgGoAgYBqAKA + AcwC9QH4AwACrwHcAvgB+kIAAvMB9wKPAdEDAAL9Af4CrAHbAloBwQLnAfEMAAKpAdoC9wH5OQAD9QOw + AwAD/QPEA40D7AwAA8ID+DAAA/4DtQMAA7MGVwOtBgAD8wPURQACqAHZAu4B9QL5AfoCbAHGAg0BqQJh + AcIC/AH9BgAC8QH2AroB4AP/PwAC0QHoAsYB5AYAAr0B4QLqAfMPAAL2AfgC+QH6OQAD3QPVBgADzwPv + DwAD9wP6MwADswP8AwADwwPFA/4JAAPQA/lCAAKgAdcC8wH3AwAC+AH6Ap0B1g8AAs0B5wP8PwACrQHb + AvAB9QMAAuMB7wKmAdlRAAPEA/MDAAPpA8BIAAP4A8ADAAP6A8UD/wwABv4/AAP8Ap8B1gMAA/4CpgHZ + AvUB+FEAA/4CpgHZA/4DAALqAfMCmwHVAuYB8UsAA/4DwAP+AwAD7wO4A+tFAAPmA9wDAAPlA75UAALp + AfICwwHjAwAC+wH8AowB0ALsAfRRAALxAfYCwgHjCQAC+gH7Ar8B4QKwAd0C6wHzA/9CAAP0A9IJAAP7 + A9ADxgPvA/88AAPSA/UDAAP/A+UDwQPnA/1LAALLAeYC6wHzBgAC+wH8AsAB4gK1Ad4C7wH1A/9IAALU + AekC7QH0DwAC9gH4As0B5wP+QgAD3wPwDwAD9wPaA/45AAP9A9MMAAP8A9oD8EgAA/4CwAHiA/4MAAL0 + AfgCxgHkA/xIAALxAfYD/loAA/MD/lEAA/wD9V0AAv0B/gLyAfYtAAFCAU0BPgcAAT4DAAEoAwABgAMA + AWADAAEBAQABAQYAAQYWAAP//wD/AAMAAf8BzwP/Ac8L/wHHA/8BxwT/AcABAQL/AcABAQH/AeYBfwL/ + AeYBfwL/AZ8BwAEBAf8BnwHAAQEB/wHiAX8C/wHiAX8C/wGPAcABAQH/AY8BwAEBAfwB8gF/Af8B/AHy + AX8C/wHNAcABAQH/Ac0BwAEBAfgBMgF/Af8B+AEyAX8C/wHMAcABAQH/AcwBwAEBAfABOAF/Af8B8AE4 + AX8B/wH9AeQBwAEBAf0B5AHAAQEB8AEQAX8B/wHwARABfwH/AfABZAHAAQEB8AFkAcABAQH4AQIBfwH/ + AfgBAgF/Af8B8AE0AcABAQHwATQBwAEBAfgBAgF/Af8B+AECAX8B/wHwAQQBwAEBAfABBAHAAQEBPgED + AT8B/wE+AQMBPwH/AfABBAHAAQEB8AEEAcABAQEPAYABHwH/AQ8BgAEfAf8B+AEEAfEBwwH4AQQB8QHD + AcABAAE/Af8BwAEAAT8B/wEeAQYBYAGDAR4BBgFgAYMB8AEAAT4BfwHwAQABPgF/AQYBAAFwAQcBBgEA + AXABBwH/AeABAAF/Af8B4AEAAX8B4AEAAfABBwHgAQAB8AEHAcABIAEBAf8BwAEgAQEB/wH5AcABAAEP + AfkBwAEAAQ8BwAEAAQMB/wHAAQABAwH/AcABQAEAAR8BwAFAAQABHwH/AcABAQL/AcABAQH/AcABAAEv + Af8BwAEAAS8C/wH8AQEC/wH8AQEC/wGAAQcC/wGAAQcC/wH8AQwC/wH8AQwC/wHwARMC/wHwARMC/wH8 + ATwB4wH/AfwBPAHjAf8B+AEzAv8B+AEzAv8B+QEfAYEB/wH5AR8BgQH/AfIBewEPAf8B8gF7AQ8B/wH5 + AYcBAQH/AfkBhwEBAf8B8gE8AQ8B/wHyATwBDwH/AfkBxgEfAf8B+QHGAR8B/wHzARgBDwH/AfMBGAEP + Af8B+wH8AWEB/wH7AfwBYQH/AfMB0AHPAf8B8wHQAc8C/wH4AYEC/wH4AYEC/wHxAQ8C/wHxAQ8C/wH4 + AYcC/wH4AYcC/wHiAQ8C/wHiAQ8C/wH5AREC/wH5AREC/wHgAW8C/wHgAW8C/wH5AREC/wH5AREC/wHk + AQcC/wHkAQcC/wH5AQEC/wH5AQEC/wHkAQcC/wHkAQcD/wHxA/8B8QP/AYcD/wGHEf8B/QP/Af0L/wH8 + A/8B/AT/AcABAQL/AfABAwH/AfwD/wH8BP8BwAEBAv8B8AEBAf8B/gFzAv8B/gFzA/8BwAEBAf8B8QHw + AQEB/wH+AXMC/wH+AXMC/wH3AcABAQH/AfkB8AEBAf8B/gEzAv8B/gEzAv8B8wHAAQEB/wH5AcABAQH+ + AR8BMwH/Af4BHwEzAv8B8wHAAQEB/wH8AcABAQH8AQ8BMwH/AfwBDwEzAv8B+QGAAQEB/wH8AcABAQH8 + AQcBkwH/AfwBBwGTAv8B+QGAAQEB/AE8AUABAQH8AQMBEwH/AfwBAwETAf8B/gF5AYABAQH8AQ4BQAED + AfwBAQEzAf8B/AEBATMB/wH4ARwBgAEBAfgBDgFIAcMB/AEBATMB/wH8AQEBMwH/AfgBHAGRAcMB+AEG + AUgBAwH+AQABMwH/Af4BAAEzAf8B+AEMAZABgwH8AQIBSAEHAX8BgAE5Af8BfwGAATkB/wH4AQQBkAEH + AfwBAAHMAQcBDwHgATwB/wEPAeABPAH/AfwBAQGQAQcB/gEAAeYBHwGDAfABAAH/AYMB8AEAAf8B/gEB + AYgBDwEfAYABcwH/AeABAAEDAf8B4AEAAQMB/wEfAQABxAEfAQcB4AEDAf8B/AEIAQEB/wH8AQgBAQH/ + AQcBwAEHAf8BwAEAAQcC/wF+AQABQAH/AX4BAAFAAcABAAEPAf8B+AEAAQcC/wH+AgAB/wH+AgAB+AEw + AQ8BzwH+AXwBAQEDAeABBgEAAR8B4AEGAQABHwH/AfgBAAEPAecB+AEAAQMB4AECAQABbwHgAQIBAAFv + AeABGAEAAT8B4AENAQAC/wH4AZABBwH/AfgBkAEHAeABCAEHAf8B8AEBAQABnwH/AfwBgAEDAf8B/AGA + AQMB/wHCAQABfwH/AfEBAAEfAv8BwAEzAv8BwAEzAf8B8gEAAT8C/wEAAU8C/wHIAXkC/wHIAXkB/wH+ + AUMBPwL/AYABxwL/AcwB+QL/AcwB+QL/ASMBnwL/AZMB5wL/AckD/wHJAv8B/gFHAZ8C/wEjA/8BiAP/ + AYgC/wH+AU8D/wEjA/8BnAEfAv8BnAEfAf8B/gFBA/8BMAF/Av8BnwEfAv8BnwEfAf8B/AHxAv8B/gE8 + AX8C/wGfA/8BnwL/AfwD/wH+AX8B/xYACw== + + + + 131, 22 + + + moveTeam7MenuItem + + + toolStripSeparator1 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 0 + + + System.Windows.Forms.SplitContainer, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 0 + + + 117, 22 + + + Simulation-Teams + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + toolStrip + + + 5 + + + Magenta + + + New Team + + + 131, 22 + + + 118, 48 + + + System.Windows.Forms.ListView, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 131, 22 + + + 0, 27 + + + System.Windows.Forms.Timer, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + False + + + System.Windows.Forms.ToolStripLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ImageList, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Windows.Forms.ToolStripButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 1 + + + Team 5 + + + 0, 0 + + + 588, 494 + + + 131, 22 + + + titelLabel + + + chooseTeam2MenuItem + + + True + + + 374, 17 + + + de + + + 0, 27 + + + 115, 21 + + + 667, 17 + + + 514, 17 + + + 274, 21 + + \ No newline at end of file diff --git a/XnaPlugin/XnaPlugin/AntMe.snk b/XnaPlugin/XnaPlugin/AntMe.snk new file mode 100644 index 0000000..cdd75a4 Binary files /dev/null and b/XnaPlugin/XnaPlugin/AntMe.snk differ diff --git a/XnaPlugin/XnaPlugin/Camera.cs b/XnaPlugin/XnaPlugin/Camera.cs new file mode 100644 index 0000000..6261bad --- /dev/null +++ b/XnaPlugin/XnaPlugin/Camera.cs @@ -0,0 +1,300 @@ +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Input; +using System; + + +namespace AntMe.Plugin.Xna +{ + internal sealed class Camera + { + #region Constants + + private const int DISTANCE_MAX = 12000; + private const int SCROLLDISTANCE_MAX = 1000; + private const float CAMERAANGLE_MAX = ((float)Math.PI / 2) - 0.01f; + private const int DISTANCE_MIN = 100; + private const float CAMERAANGLE_MIN = 0.1f; + + #endregion + + #region Variables + + private Vector3 viewerCenter; + private bool moveArea; + private bool hasFocus; + private Vector3 cameraDirection; + private Vector3 cameraUpvector; + private Vector3 cameraPosition; + + private int mouseX; + private int mouseY; + private int mouseWheel = 0; + private int distanceMax; + private bool rotateCamera; + + private GameWindow gameWindow; + private Matrix projectionMatrix; + + #endregion + + #region Construction and init + + /// + /// Creates a new instance of camera + /// + /// render-Form + public Camera(GameWindow gameWindow) + { + this.gameWindow = gameWindow; + this.gameWindow.ClientSizeChanged += gameWindow_ClientSizeChanged; + gameWindow_ClientSizeChanged(null, null); + + // Reset Camera-position + viewerCenter = new Vector3(0, 2, 0); + cameraPosition = new Vector3(0, DISTANCE_MAX, 0); + cameraUpvector = new Vector3(0, 1, 1); + cameraDirection = + new Vector3(((float)Math.PI * 3) / 2, CAMERAANGLE_MAX, DISTANCE_MAX); + + cameraUpvector.Normalize(); + } + + + #endregion + + #region Form-Events + + void gameWindow_ClientSizeChanged(object sender, EventArgs e) + { + projectionMatrix = Matrix.CreatePerspectiveFieldOfView( + MathHelper.PiOver4, + (float)gameWindow.ClientBounds.Width / (float)gameWindow.ClientBounds.Height, + 1, 50000); + } + + public void Update(GameTime time) + { + MouseState mouse = Mouse.GetState(); + + // Mouse Wheel + cameraDirection.Z -= ((float)(mouse.ScrollWheelValue - mouseWheel) / 5f); + mouseWheel = mouse.ScrollWheelValue; + + // check distance-limits + if (cameraDirection.Z < DISTANCE_MIN) + { + cameraDirection.Z = DISTANCE_MIN; + } + else if (cameraDirection.Z > DISTANCE_MAX) + { + cameraDirection.Z = DISTANCE_MAX; + } + + // Mouse buttons + moveArea = mouse.LeftButton == ButtonState.Pressed; + rotateCamera = mouse.RightButton == ButtonState.Pressed; + + // calculate deltas + int deltaX = mouse.X - mouseX; + int deltaY = mouse.Y - mouseY; + + // calculate movement + if (moveArea) + { + float sinX = (float)Math.Sin(cameraDirection.X); + float cosX = (float)Math.Cos(cameraDirection.X); + viewerCenter.X -= sinX * deltaX; + viewerCenter.X -= cosX * deltaY; + viewerCenter.Z += cosX * deltaX; + viewerCenter.Z -= sinX * deltaY; + + cameraPosition.X -= sinX * deltaX; + cameraPosition.X -= cosX * deltaY; + cameraPosition.Z += cosX * deltaX; + cameraPosition.Z -= sinX * deltaY; + + // check scrolling-limits + if (viewerCenter.X < -SCROLLDISTANCE_MAX) + { + cameraPosition.X = -SCROLLDISTANCE_MAX + (cameraPosition.X - viewerCenter.X); + viewerCenter.X = -SCROLLDISTANCE_MAX; + } + else if (viewerCenter.X > SCROLLDISTANCE_MAX) + { + cameraPosition.X = SCROLLDISTANCE_MAX + (cameraPosition.X - viewerCenter.X); + viewerCenter.X = SCROLLDISTANCE_MAX; + } + + if (viewerCenter.Z < -SCROLLDISTANCE_MAX) + { + cameraPosition.Z = -SCROLLDISTANCE_MAX + (cameraPosition.Z - viewerCenter.Z); + viewerCenter.Z = -SCROLLDISTANCE_MAX; + } + else if (viewerCenter.Z > SCROLLDISTANCE_MAX) + { + cameraPosition.Z = SCROLLDISTANCE_MAX + (cameraPosition.Z - viewerCenter.Z); + viewerCenter.Z = SCROLLDISTANCE_MAX; + } + } + + // calculate rotation + if (rotateCamera) + { + cameraDirection.X += (float)deltaX / 1000; + cameraDirection.Y += (float)deltaY / 1000; + + // check, rotationlimits + if (cameraDirection.Y < CAMERAANGLE_MIN) + { + cameraDirection.Y = CAMERAANGLE_MIN; + } + else if (cameraDirection.Y > CAMERAANGLE_MAX) + { + cameraDirection.Y = CAMERAANGLE_MAX; + } + } + + // save new mouse-position + mouseX = mouse.X; + mouseY = mouse.Y; + + cameraUpvector.X = cameraPosition.X - viewerCenter.X; + cameraUpvector.Z = cameraPosition.Z - viewerCenter.Z; + cameraUpvector.Y = cameraPosition.Y; + cameraUpvector.Normalize(); + } + + #endregion + + public Matrix WorldMatrix + { + get { return Matrix.CreateWorld(cameraPosition, Vector3.Forward, Vector3.Up); } + } + public Matrix ViewMatrix + { + get { return Matrix.CreateLookAt(cameraPosition, viewerCenter, cameraUpvector); } + } + + public Matrix ProjectionMatrix + { + get { return projectionMatrix; } + } + + #region Properties + + /// + /// Gets the current Pickray. + /// + public Pickray Pickray + { + get + { + if (mouseX != -1) + { + + Matrix projektionsMatrix = projectionMatrix; + Pickray outputRay = new Pickray(); + // create ray + outputRay.Origin = new Vector3(0.0f, 0.0f, 0.0f); + outputRay.Direction = + new Vector3 + ( + (((2.0f * mouseX) / gameWindow.ClientBounds.Width) - 1.0f) / projektionsMatrix.M11, + (((-2.0f * mouseY) / gameWindow.ClientBounds.Height) + 1.0f) / projektionsMatrix.M22, + -1.0f); + + // tranform ray to view + Matrix viewMatrix = ViewMatrix; + viewMatrix = Matrix.Invert(viewMatrix); + outputRay.Origin = Vector3.Transform(outputRay.Origin, viewMatrix); + outputRay.Direction = Vector3.TransformNormal(outputRay.Direction, viewMatrix); + outputRay.Direction.Normalize(); + + + return outputRay; + } + else + { + // Empty ray, if there is no mouse + return new Pickray(); + } + } + } + public Vector3 Unproject(Vector3 source, Matrix projection, Matrix view, Matrix world) + { + float MaxDepth = 1.0f, MinDepth = 0.0f; + Matrix matrix = Matrix.Invert(Matrix.Multiply(Matrix.Multiply(world, view), projection)); + source.X = (((source.X - gameWindow.ClientBounds.X) / ((float)gameWindow.ClientBounds.Width)) * 2f) - 1f; + source.Y = -((((source.Y - gameWindow.ClientBounds.Y) / ((float)gameWindow.ClientBounds.Height)) * 2f) - 1f); + source.Z = (source.Z - MinDepth) / (MaxDepth - MinDepth); + Vector3 vector = Vector3.Transform(source, matrix); + float a = (((source.X * matrix.M14) + (source.Y * matrix.M24)) + (source.Z * matrix.M34)) + matrix.M44; + if (!WithinEpsilon(a, 1f)) + { + vector = (Vector3)(vector / a); + } + return vector; + } + private static bool WithinEpsilon(float a, float b) + { + float num = a - b; + return ((-1.401298E-45f <= num) && (num <= float.Epsilon)); + } + + + + + + /// + /// Gets the current Mouse-Position. + /// + public Point MousePosition + { + get + { + if (mouseX != -1) + { + return new Point(mouseX, mouseY); + } + else + { + return new Point(0, 0); + } + } + } + + /// + /// Gets the current Camera-Position. + /// + public Vector3 CameraPosition + { + get { return cameraPosition; } + } + + #endregion + + public void Resize(int playgroundWidth, int playgroundHeight) + { + // Maximale Distanz neu ermitteln + distanceMax = playgroundWidth; + + // Maximalentfernung korrigieren + if (cameraDirection.Z > distanceMax) + { + cameraDirection.Z = distanceMax; + } + + // Camerapos ermitteln + float distance = (float)(Math.Cos(cameraDirection.Y) * cameraDirection.Z); + cameraPosition.Y = (float)(Math.Sin(cameraDirection.Y) * cameraDirection.Z); + cameraPosition.Z = (float)(Math.Sin(cameraDirection.X) * distance) + viewerCenter.Z; + cameraPosition.X = (float)(Math.Cos(cameraDirection.X) * distance) + viewerCenter.X; + + // Upvector ermitteln + cameraUpvector.X = cameraPosition.X - viewerCenter.X; + cameraUpvector.Z = cameraPosition.Z - viewerCenter.Z; + cameraUpvector.Y = cameraPosition.Y; + cameraUpvector.Normalize(); + } + } +} \ No newline at end of file diff --git a/XnaPlugin/XnaPlugin/CubeMesh.cs b/XnaPlugin/XnaPlugin/CubeMesh.cs new file mode 100644 index 0000000..8823ede --- /dev/null +++ b/XnaPlugin/XnaPlugin/CubeMesh.cs @@ -0,0 +1,110 @@ +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Plugin.Xna +{ + // A cube mesh for the skybox + public class CubeMesh + { + const int NUMBER_OF_VERTICES = 8; + const int NUMBER_OF_INDICES = 36; + + VertexBuffer vertices; + IndexBuffer indices; + GraphicsDevice graphics; + + + public CubeMesh(GraphicsDevice graphics, Vector3 size) + { + this.graphics = graphics; + + Vector3[] cubeVertices = new Vector3[NUMBER_OF_VERTICES]; + + cubeVertices[0] = new Vector3(-size.X, -size.Y, -size.Z); + cubeVertices[1] = new Vector3(-size.X, -size.Y, +size.Z); + cubeVertices[2] = new Vector3(+size.X, -size.Y, +size.Z); + cubeVertices[3] = new Vector3(+size.X, -size.Y, -size.Z); + cubeVertices[4] = new Vector3(-size.X, +size.Y, -size.Z); + cubeVertices[5] = new Vector3(-size.X, +size.Y, +size.Z); + cubeVertices[6] = new Vector3(+size.X, +size.Y, +size.Z); + cubeVertices[7] = new Vector3(+size.X, +size.Y, -size.Z); + + VertexDeclaration VertexPositionDeclaration = new VertexDeclaration( + new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0) + ); + + vertices = new VertexBuffer(graphics, VertexPositionDeclaration, NUMBER_OF_VERTICES, BufferUsage.WriteOnly); + vertices.SetData(cubeVertices); + + + UInt16[] cubeIndices = new UInt16[NUMBER_OF_INDICES]; + + //bottom face + cubeIndices[0] = 0; + cubeIndices[1] = 2; + cubeIndices[2] = 3; + cubeIndices[3] = 0; + cubeIndices[4] = 1; + cubeIndices[5] = 2; + + //top face + cubeIndices[6] = 4; + cubeIndices[7] = 6; + cubeIndices[8] = 5; + cubeIndices[9] = 4; + cubeIndices[10] = 7; + cubeIndices[11] = 6; + + //front face + cubeIndices[12] = 5; + cubeIndices[13] = 2; + cubeIndices[14] = 1; + cubeIndices[15] = 5; + cubeIndices[16] = 6; + cubeIndices[17] = 2; + + //back face + cubeIndices[18] = 0; + cubeIndices[19] = 7; + cubeIndices[20] = 4; + cubeIndices[21] = 0; + cubeIndices[22] = 3; + cubeIndices[23] = 7; + + //left face + cubeIndices[24] = 0; + cubeIndices[25] = 4; + cubeIndices[26] = 1; + cubeIndices[27] = 1; + cubeIndices[28] = 4; + cubeIndices[29] = 5; + + //right face + cubeIndices[30] = 2; + cubeIndices[31] = 6; + cubeIndices[32] = 3; + cubeIndices[33] = 3; + cubeIndices[34] = 6; + cubeIndices[35] = 7; + + indices = new IndexBuffer(graphics, IndexElementSize.SixteenBits, NUMBER_OF_INDICES, BufferUsage.WriteOnly); + indices.SetData(cubeIndices); + + } + + + public void Draw() + { + graphics.SetVertexBuffer(vertices); + graphics.Indices = indices; + + + graphics.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, NUMBER_OF_VERTICES, 0, NUMBER_OF_INDICES / 3); + + } + } +} diff --git a/XnaPlugin/XnaPlugin/DebugMessage.cs b/XnaPlugin/XnaPlugin/DebugMessage.cs new file mode 100644 index 0000000..1c24bbe --- /dev/null +++ b/XnaPlugin/XnaPlugin/DebugMessage.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Plugin.Xna +{ + internal sealed class DebugMessage + { + public const int ROUNDS_TO_LIFE = 15; + + public int CreateRound { get; set; } + + public string Message { get; set; } + } +} diff --git a/XnaPlugin/XnaPlugin/DebugRenderer.cs b/XnaPlugin/XnaPlugin/DebugRenderer.cs new file mode 100644 index 0000000..c22fa3a --- /dev/null +++ b/XnaPlugin/XnaPlugin/DebugRenderer.cs @@ -0,0 +1,90 @@ +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +// if using XNA with non-reach profile: +// using indexer = System.Int32 + +// if using XNA with reach profile: +using indexer = System.Int16; + +// if using mono game: +// using indexer = System.UInt32 + + +namespace AntMe.Plugin.Xna +{ + internal class DebugRenderer + { + BasicEffect effect; + Camera camera; + + internal DebugRenderer(GraphicsDevice graphicsDevice, Camera camera) + { + this.camera = camera; + this.effect = new BasicEffect(graphicsDevice) { VertexColorEnabled = true }; + } + + public Vector2 WorldToScreen(Vector3 worldPoint, Vector2 screenOffset) + { + Vector3 screen = effect.GraphicsDevice.Viewport.Project(worldPoint, camera.ProjectionMatrix, camera.ViewMatrix, Matrix.Identity); + return new Vector2(screen.X + screenOffset.X, screen.Y + screenOffset.Y); + } + + public void DrawLine(Vector3 start, Vector3 end, Color color) + { + DrawLineStrip(color, false, start, end); + } + + public void DrawHorizontalCircle(Vector3 center, float radius, int segmentCount, Color color) + { + float angleStep = MathHelper.TwoPi / segmentCount; + Vector3[] positions = new Vector3[segmentCount]; + + for(int i = 0; i < segmentCount; i++) + { + float angle = i * angleStep; + positions[i] = center + radius * new Vector3((float)Math.Cos(angle), 0, (float)Math.Sin(angle)); + } + + DrawLineStrip(color, true, positions); + } + + private void DrawLineStrip(Color color, bool isClosed, params Vector3[] points) + { + int count = (isClosed) + ? points.Length + 1 + : points.Length; + + + VertexPositionColor[] vertices = new VertexPositionColor[count]; + indexer[] indices = new indexer[count]; + + for (int i = 0; i < count; i++) + { + Vector3 pos = points[i % points.Length]; + vertices[i] = new VertexPositionColor(pos, color); + indices[i] = (indexer)(i % points.Length); + } + + effect.Projection = camera.ProjectionMatrix; + effect.View = camera.ViewMatrix; + effect.CurrentTechnique.Passes[0].Apply(); + + effect.GraphicsDevice.DrawUserIndexedPrimitives(PrimitiveType.LineStrip, vertices, 0, count, indices, 0, count - 1); + } + + + internal void Unload() + { + if (effect != null) + effect.Dispose(); + + effect = null; + camera = null; + } + } +} diff --git a/XnaPlugin/XnaPlugin/ModelManager.cs b/XnaPlugin/XnaPlugin/ModelManager.cs new file mode 100644 index 0000000..5da750d --- /dev/null +++ b/XnaPlugin/XnaPlugin/ModelManager.cs @@ -0,0 +1,525 @@ +using System; +using System.Collections.Generic; +using System.IO; + +using AntMe.SharedComponents.States; +using AntMe.SharedComponents.Tools; + +using Microsoft.Xna.Framework; + +namespace AntMe.Plugin.Xna +{ + /// + /// class, to manage and render all model-resources. + /// + //internal sealed class ModellManager + //{ + // #region Constants + + // private const int ROWHEIGHT = 13; // Distance between rows in statistic-box + // private const int MARKERTRANSPARENCY = 16; // alpha-value for marker + // private const float FONTSIZE = 9.0f; // font-size for text in the statistic-box + // private const string FONTFAMILY = "Airal"; // font-family for text in the statistic-box + + // #endregion + + // #region private Variables + + // private readonly Dictionary antMaterial; + // private readonly Material fruitMaterial; + // private readonly ColorFinder colorFinder; + // private readonly Material bugMaterial; + // private readonly Line line; + // private readonly Dictionary markerMaterials; + + // private readonly Font fontNormal; + // private readonly Font fontBold; + // private readonly Material selectionMaterial; + // private readonly Material playgroundMaterial; + // private readonly Device renderDevice; + // private readonly Material sugarMaterial; + // private Mesh antHillMesh; + // private Mesh antMesh; + // private Mesh fruitMesh; + // private Mesh bugMesh; + // private Mesh collisionBox; + // private Mesh markerMesh; + + // private int playgroundWidth; + // private int playgroundHeight; + // private Mesh playgroundMesh; + // private Mesh sugarMesh; + // private Mesh sugarCubeMesh; + + // #endregion + + // #region Construction and init + + // public ModellManager(Device renderDevice) + // { + // this.renderDevice = renderDevice; + + // antMaterial = new Dictionary(); + // markerMaterials = new Dictionary(); + // colorFinder = new ColorFinder(); + + // playgroundMaterial = new Material(); + // playgroundMaterial.Ambient = Color.FromArgb(114, 114, 73); + // playgroundMaterial.Emissive = Color.FromArgb(90, 90, 58); + // playgroundMaterial.Specular = Color.FromArgb(114, 114, 73); + // colorFinder.BelegeFarbe(new Farbe(114, 114, 73)); + + // sugarMaterial = new Material(); + // sugarMaterial.Emissive = Color.FromArgb(200, 200, 200); + // sugarMaterial.Specular = Color.FromArgb(255, 255, 255); + // colorFinder.BelegeFarbe(new Farbe(200, 200, 200)); + + // bugMaterial = new Material(); + // bugMaterial.Emissive = Color.DarkBlue; + // bugMaterial.Specular = Color.FromArgb(0, 0, 150); + // colorFinder.BelegeFarbe(new Farbe(Color.DarkBlue.R, Color.DarkBlue.G, Color.DarkBlue.B)); + + // fruitMaterial = new Material(); + // fruitMaterial.Emissive = Color.Green; + // fruitMaterial.Specular = Color.FromArgb(0, 255, 0); + // colorFinder.BelegeFarbe(new Farbe(Color.Green.R, Color.Green.G, Color.Green.B)); + + // selectionMaterial = new Material(); + // selectionMaterial.Emissive = Color.FromArgb(120, 0, 0); + // selectionMaterial.Specular = Color.Red; + + // fontNormal = new Font(renderDevice, new System.Drawing.Font(FONTFAMILY, FONTSIZE, FontStyle.Regular)); + // fontBold = new Font(renderDevice, new System.Drawing.Font(FONTFAMILY, FONTSIZE, FontStyle.Bold)); + // line = new Line(renderDevice); + + // createResources(); + // } + + // #endregion + + // #region Resource-Management + + // /// + // /// Initializes all resources after a device reset. + // /// + // public void DeviceReset() + // { + // Dispose(); + // createResources(); + // } + + // /// + // /// Creates all needed resources. + // /// + // private void createResources() + // { + // collisionBox = Mesh.Box(renderDevice, 30.0f, 30.0f, 30.0f); + // playgroundMesh = Mesh.Box(renderDevice, 1.0f, 1.0f, 1.0f); + // sugarCubeMesh = Mesh.Box(renderDevice, 2.0f, 1.5f, 2.0f); + // markerMesh = Mesh.Sphere(renderDevice, 1.0f, 10, 10); + // antMesh = Mesh.FromStream(new MemoryStream(Models.ant), MeshFlags.DoNotClip, renderDevice); + // bugMesh = Mesh.FromStream(new MemoryStream(Models.bug), MeshFlags.DoNotClip, renderDevice); + // sugarMesh = + // Mesh.FromStream(new MemoryStream(Models.sugar), MeshFlags.DoNotClip, renderDevice); + // antHillMesh = + // Mesh.FromStream(new MemoryStream(Models.anthill), MeshFlags.DoNotClip, renderDevice); + // fruitMesh = Mesh.FromStream(new MemoryStream(Models.apple), MeshFlags.DoNotClip, renderDevice); + // } + + // /// + // /// Disposes all resources. + // /// + // public void Dispose() + // { + // playgroundMesh.Dispose(); + // sugarCubeMesh.Dispose(); + // antMesh.Dispose(); + // bugMesh.Dispose(); + // sugarMesh.Dispose(); + // antHillMesh.Dispose(); + // collisionBox.Dispose(); + // } + + // /// + // /// Prepares all needed Colony-Materials + // /// + // /// Colony-ID + // public void PrepareColony(int colony) + // { + // if (!antMaterial.ContainsKey(colony)) + // { + // // choose another color + // Farbe color; + // switch (colony) + // { + // case 0: + // color = new Farbe(0, 0, 0); + // break; + // case 1: + // color = new Farbe(255, 0, 0); + // break; + // case 2: + // color = new Farbe(0, 0, 255); + // break; + // case 3: + // color = new Farbe(255, 255, 0); + // break; + // default: + // color = colorFinder.ErzeugeFarbe(); + // break; + // } + // colorFinder.BelegeFarbe(color); + + // // Material for ants and flag + // Material material = new Material(); + // material.Emissive = Color.FromArgb(color.Rot, color.Grün, color.Blau); + // material.Specular = Color.FromArgb(200, 200, 200); + // antMaterial.Add(colony, material); + + // // Material for markers + // material = new Material(); + // material.Ambient = Color.FromArgb(MARKERTRANSPARENCY, color.Rot, color.Grün, color.Blau); + // material.Diffuse = Color.FromArgb(MARKERTRANSPARENCY, color.Rot, color.Grün, color.Blau); + // material.Emissive = Color.FromArgb(MARKERTRANSPARENCY, color.Rot, color.Grün, color.Blau); + // material.Specular = Color.FromArgb(MARKERTRANSPARENCY, color.Rot, color.Grün, color.Blau); + // markerMaterials.Add(colony, material); + // } + // } + + // #endregion + + // #region Render-functions + + // /// + // /// Sets the size of playground. + // /// + // /// Width of playground + // /// Height of playground + // public void SetPlaygroundSize(int width, int height) + // { + // playgroundWidth = width / 2; + // playgroundHeight = height / 2; + // } + + // /// + // /// Renders playground. + // /// + // public void RenderPlayground() + // { + // Matrix matrix = Matrix.Scaling(playgroundWidth * 2, 1.0f, playgroundHeight * 2); + // matrix.M42 = -0.5f; + // renderDevice.Transform.World = matrix; + // renderDevice.Material = playgroundMaterial; + // playgroundMesh.DrawSubset(0); + // } + + // /// + // /// Renders a bug. + // /// + // /// for additional information + // /// current PickRay + // /// true, if bug is selected + // /// distance from viewer to item, if hits + // public float RenderBug(BugState state, Pickray pickray, bool selected) + // { + // Matrix matrix = Matrix.Identity; + // matrix.RotateY((float)(state.Direction * Math.PI) / 180); + // matrix.M41 = (state.PositionX) - playgroundWidth; + // matrix.M43 = (-state.PositionY) + playgroundHeight; + // renderDevice.Material = (selected ? selectionMaterial : bugMaterial); + // renderDevice.Transform.World = matrix; + // bugMesh.DrawSubset(0); + + // // Check for pickray-collision + // matrix.Invert(); + // pickray.Origin.TransformCoordinate(matrix); + // pickray.Direction.TransformNormal(matrix); + // if (collisionBox.Intersect(pickray.Origin, pickray.Direction)) + // { + // return + // Vector3.Subtract + // ( + // pickray.Origin, + // new Vector3((state.PositionX) - playgroundWidth, 0, (-state.PositionY) + playgroundHeight)). + // Length(); + // } + + // return 0.0f; + // } + + // /// + // /// Renders an ant. + // /// + // /// ID of Colony + // /// State + // /// + // /// true, if ant is selected + // /// distance from viewer to item, if hits + // public float RenderAnt(int colony, AntState state, Pickray pickray, bool selected) + // { + // Matrix matrix = Matrix.Identity; + // matrix.RotateY((float)(state.Direction * Math.PI) / 180); + // matrix.M41 = state.PositionX - playgroundWidth; + // matrix.M43 = -state.PositionY + playgroundHeight; + // renderDevice.Material = (selected ? selectionMaterial : antMaterial[colony]); + // renderDevice.Transform.World = matrix; + // antMesh.DrawSubset(0); + + // // Draw sugar-block, if ant has sugar loaded + // if (state.LoadType == LoadType.Sugar) + // { + // matrix.M42 = 3.5f; + // renderDevice.Material = sugarMaterial; + // renderDevice.Transform.World = matrix; + // sugarCubeMesh.DrawSubset(0); + // } + + // if (selected && state.TargetPositionX != 0) + // { + // renderDevice.Transform.World = Matrix.Identity; + // renderDevice.Material = sugarMaterial; + + // CustomVertex.PositionColored[] verts = new CustomVertex.PositionColored[2]; + // verts[0].X = (float)state.PositionX - playgroundWidth; + // verts[0].Z = (float)-state.PositionY + playgroundHeight; + // verts[0].Y = 2; + + // verts[1].X = (float)state.TargetPositionX - playgroundWidth; + // verts[1].Z = (float)-state.TargetPositionY + playgroundHeight; + // verts[1].Y = 2; + + // renderDevice.VertexFormat = CustomVertex.PositionColored.Format; + // renderDevice.DrawUserPrimitives(PrimitiveType.LineList, 1, verts); + // } + + // // Check for pickray-collision + // matrix.M42 = 0.0f; + // matrix.Invert(); + // pickray.Origin.TransformCoordinate(matrix); + // pickray.Direction.TransformNormal(matrix); + // if (collisionBox.Intersect(pickray.Origin, pickray.Direction)) + // { + // return + // Vector3.Subtract + // ( + // pickray.Origin, + // new Vector3(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight)).Length + // (); + // } + + // return 0.0f; + // } + + // /// + // /// Renders sugar. + // /// + // /// + // /// + // /// true, if selected + // /// distance from viewer to item, if hits + // public float RenderSugar(SugarState state, Pickray pickray, bool selected) + // { + // Matrix matrix = + // Matrix.Translation(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight); + // matrix.M11 = matrix.M22 = matrix.M33 = state.Radius / 50.0f; + // renderDevice.Material = (selected ? selectionMaterial : sugarMaterial); + // renderDevice.Transform.World = matrix; + // sugarMesh.DrawSubset(0); + + // // Check for pickray-collision + // matrix.M42 = 0.0f; + // matrix.Invert(); + // pickray.Origin.TransformCoordinate(matrix); + // pickray.Direction.TransformNormal(matrix); + // if (collisionBox.Intersect(pickray.Origin, pickray.Direction)) + // { + // return + // Vector3.Subtract + // ( + // pickray.Origin, + // new Vector3(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight)).Length + // (); + // } + // return 0.0f; + // } + + // /// + // /// Renders Fruit. + // /// + // /// + // /// + // /// true, if selected + // /// distance from viewer to item, if hits + // public float RenderFruit(FruitState state, Pickray pickray, bool selected) + // { + // Matrix matrix = + // Matrix.Translation(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight); + // matrix.M11 = state.Radius / 4.5f; + // matrix.M22 = state.Radius / 4.5f; + // matrix.M33 = state.Radius / 4.5f; + // renderDevice.Material = (selected ? selectionMaterial : fruitMaterial); + // renderDevice.Transform.World = matrix; + // fruitMesh.DrawSubset(0); + + // // Check for pickray-collision + // matrix.M42 = 0.0f; + // matrix.Invert(); + // pickray.Origin.TransformCoordinate(matrix); + // pickray.Direction.TransformNormal(matrix); + // if (collisionBox.Intersect(pickray.Origin, pickray.Direction)) + // { + // return + // Vector3.Subtract + // ( + // pickray.Origin, + // new Vector3(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight)).Length(); + // } + // return 0.0f; + // } + + // /// + // /// Render Anthill. + // /// + // /// Colony-ID + // /// + // /// + // /// true, if selected + // /// distance from viewer to item, if hits + // public float RenderAnthill(int colony, AnthillState state, Pickray pickray, bool selected) + // { + // Matrix matrix = + // Matrix.Translation(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight); + // renderDevice.Material = (selected ? selectionMaterial : antMaterial[colony]); + // renderDevice.Transform.World = matrix; + // antHillMesh.DrawSubset(0); + + // // Check for pickray-collision + // matrix.M42 = 0.0f; + // matrix.Invert(); + // pickray.Origin.TransformCoordinate(matrix); + // pickray.Direction.TransformNormal(matrix); + // if (collisionBox.Intersect(pickray.Origin, pickray.Direction)) + // { + // return + // Vector3.Subtract + // ( + // pickray.Origin, + // new Vector3(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight)).Length(); + // } + // return 0.0f; + // } + + // /// + // /// Render Marker. + // /// + // /// Colony-ID + // /// + // public void RenderMarker(int colony, MarkerState state) + // { + // Matrix matrix = + // Matrix.Translation + // (state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight); + // matrix.M11 = state.Radius; + // matrix.M22 = state.Radius; + // matrix.M33 = state.Radius; + + // // Enable transperency + // renderDevice.RenderState.AlphaBlendEnable = true; + // renderDevice.RenderState.ZBufferWriteEnable = false; + // renderDevice.RenderState.SourceBlend = Blend.SourceAlpha; + // renderDevice.RenderState.DestinationBlend = Blend.InvSourceAlpha; + + // renderDevice.Material = markerMaterials[colony]; + // renderDevice.Transform.World = matrix; + // markerMesh.DrawSubset(0); + + // // Disable transparency + // renderDevice.RenderState.AlphaBlendEnable = false; + // renderDevice.RenderState.ZBufferWriteEnable = true; + // } + + // /// + // /// Renders the statistic-box. + // /// + // /// + // public void RenderInfobox(SimulationState state) + // { + // int player = 0; + // for (int i = 0; i < state.TeamStates.Count; i++) + // { + // player += state.TeamStates[i].ColonyStates.Count; + // } + + // int height = ROWHEIGHT * player + 60; + // int position = (height / 2) + 10; + // line.Width = height; + // line.Begin(); + // line.Draw + // ( + // new Vector2[] { new Vector2(10, position), new Vector2(500, position) }, + // Color.FromArgb(100, Color.White).ToArgb()); + // line.End(); + + // fontNormal.DrawText(null, Resource.InfoboxColumnColony2, 20, ROWHEIGHT + 20, Color.Black); + + // fontNormal.DrawText(null, Resource.InfoboxColumnCollectedFood1, 200, 20, Color.Green); + // fontNormal.DrawText(null, Resource.InfoboxColumnCollectedFood2, 200, ROWHEIGHT + 20, Color.Green); + + // fontNormal.DrawText(null, Resource.InfoboxColumnKilledAnts1, 290, 20, Color.Red); + // fontNormal.DrawText(null, Resource.InfoboxColumnKilledAnts2, 290, ROWHEIGHT + 20, Color.Red); + + // fontNormal.DrawText(null, Resource.InfoboxColumnKilledBugs1, 370, 20, Color.Blue); + // fontNormal.DrawText(null, Resource.InfoboxColumnKilledBugs2, 370, ROWHEIGHT + 20, Color.Blue); + + // fontNormal.DrawText(null, Resource.InfoboxColumnPoints2, 440, ROWHEIGHT + 20, Color.Black); + + // int count = 0; + + // for (int i = 0; i < state.TeamStates.Count; i++) + // { + // for (int j = 0; j < state.TeamStates[i].ColonyStates.Count; j++) + // { + // ColonyState colony = state.TeamStates[i].ColonyStates[j]; + // int killedAnts = colony.StarvedAnts + colony.EatenAnts + colony.BeatenAnts; + + // fontBold.DrawText + // (null, colony.ColonyName, 20, count * ROWHEIGHT + 55, antMaterial[count].Emissive); + // fontNormal.DrawText + // (null, colony.CollectedFood.ToString(), 200, count * ROWHEIGHT + 55, Color.Green); + // fontNormal.DrawText + // (null, killedAnts.ToString(), 290, count * ROWHEIGHT + 55, Color.Red); + // fontNormal.DrawText + // (null, colony.KilledBugs.ToString(), 370, count * ROWHEIGHT + 55, Color.Blue); + // fontBold.DrawText + // (null, colony.Points.ToString(), 440, count * ROWHEIGHT + 55, Color.Black); + // count++; + // } + // } + // } + + // /// + // /// Draws the information-box for hovered items. + // /// + // /// Position of Information-Box + // /// Content of line 1 + // /// Content of line 2 + // public void RenderInfoTag(Point position, String line1, String line2) + // { + // int height = 2 * ROWHEIGHT + 10; + // int positionY = (height / 2) + position.Y + 5; + + // line.Width = height; + // line.Begin(); + // line.Draw + // ( + // new Vector2[] { new Vector2(position.X, positionY), new Vector2(position.X + 200, positionY) }, + // Color.FromArgb(100, Color.White).ToArgb()); + // line.End(); + + // fontNormal.DrawText(null, line1, position.X + 10, position.Y + 10, Color.Black); + // fontNormal.DrawText(null, line2, position.X + 10, position.Y + ROWHEIGHT + 10, Color.Black); + // } + + // #endregion + //} +} \ No newline at end of file diff --git a/XnaPlugin/XnaPlugin/NineSlicedTexture.cs b/XnaPlugin/XnaPlugin/NineSlicedTexture.cs new file mode 100644 index 0000000..a7feb1a --- /dev/null +++ b/XnaPlugin/XnaPlugin/NineSlicedTexture.cs @@ -0,0 +1,104 @@ +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace AntMe.Plugin.Xna +{ + public class NineSlicedTexture + { + private Texture2D texture; + private Rectangle innerArea; + private Point overlap; + + public NineSlicedTexture(Texture2D texture, Rectangle innerArea) + { + this.texture = texture; + this.innerArea = innerArea; + + overlap = new Point(texture.Width - innerArea.Width, texture.Height - innerArea.Height); + } + + + public void Draw(SpriteBatch batch, Rectangle destinationRectangle, Color color) + { + // 1 | 2 | 3 TOP + // ____|_______|____ + // | | + // 4 | 5 | 6 MIDDLE + // ____|_______|____ + // | | + // 7 | 8 | 9 BOTTOM + // + // LEFT CENTER RIGHT + + int leftSlice = innerArea.X; + int rightSlice = innerArea.X + innerArea.Width; + + int topSlice = innerArea.Y; + int bottomSlice = innerArea.Y + innerArea.Height; + + int rightWidth = texture.Width - rightSlice; + int bottomHeight = texture.Height - bottomSlice; + + int destInnerWidth = destinationRectangle.Width - overlap.X; + int destInnerHeight = destinationRectangle.Height - overlap.Y; + + int destRight = destinationRectangle.X + destinationRectangle.Width - rightWidth; + int destBottom = destinationRectangle.Y + destinationRectangle.Height - bottomHeight; + + // TOP + // 1. Top left + Rectangle sourceTopLeft = new Rectangle(0, 0, leftSlice, topSlice); + Rectangle destTopLeft = new Rectangle(destinationRectangle.X, destinationRectangle.Y, sourceTopLeft.Width, sourceTopLeft.Height); + batch.Draw(texture, destTopLeft, sourceTopLeft, color); + + // 2. Top center + Rectangle sourceTopCenter = new Rectangle(leftSlice, 0, innerArea.Width, topSlice); + Rectangle destTopCenter = new Rectangle(destinationRectangle.X + leftSlice, destinationRectangle.Y, destInnerWidth, sourceTopCenter.Height); + batch.Draw(texture, destTopCenter, sourceTopCenter, color); + + // 3. Top right + Rectangle sourceTopRight = new Rectangle(rightSlice, 0, rightWidth, topSlice); + Rectangle destTopRight = new Rectangle(destRight, destinationRectangle.Y, sourceTopRight.Width, sourceTopRight.Height); + batch.Draw(texture, destTopRight, sourceTopRight, color); + + // MIDDLE + // 4. Middle left + Rectangle sourceMiddleLeft = new Rectangle(0, topSlice, leftSlice, innerArea.Height); + Rectangle destMiddleLeft = new Rectangle(destinationRectangle.X, destinationRectangle.Y + topSlice, sourceMiddleLeft.Width, destInnerHeight); + batch.Draw(texture, destMiddleLeft, sourceMiddleLeft, color); + + // 5. Middle center + Rectangle sourceMiddleCenter = innerArea; + Rectangle destMiddleCenter = new Rectangle(destinationRectangle.X + leftSlice, destinationRectangle.Y + topSlice, destInnerWidth, destInnerHeight); + batch.Draw(texture, destMiddleCenter, sourceMiddleCenter, color); + + // 6. Middle right + Rectangle sourceMiddleRight = new Rectangle(rightSlice, topSlice, rightWidth, innerArea.Height); + Rectangle destMiddleRight = new Rectangle(destRight, destinationRectangle.Y + topSlice, sourceMiddleRight.Width, destInnerHeight); + batch.Draw(texture, destMiddleRight, sourceMiddleRight, color); + + // BOTTOM + // 7. Bottom left + Rectangle sourceBottomLeft = new Rectangle(0, bottomSlice, leftSlice, bottomHeight); + Rectangle destBottomLeft = new Rectangle(destinationRectangle.X, destBottom, leftSlice, bottomHeight); + batch.Draw(texture, destBottomLeft, sourceBottomLeft, color); + + // 8. Bottom center + Rectangle sourceBottomCenter = new Rectangle(leftSlice, bottomSlice, innerArea.Width, bottomHeight); + Rectangle destBottomCenter = new Rectangle(destinationRectangle.X + leftSlice, destBottom, destInnerWidth, bottomHeight); + batch.Draw(texture, destBottomCenter, sourceBottomCenter, color); + + // 9. Bottom right + Rectangle sourceBottomRight = new Rectangle(rightSlice, bottomSlice, rightWidth, bottomHeight); + Rectangle destBottomRight = new Rectangle(destRight, destBottom, rightWidth, bottomHeight); + batch.Draw(texture, destBottomRight, sourceBottomRight, color); + + + + } + } +} diff --git a/XnaPlugin/XnaPlugin/Pickray.cs b/XnaPlugin/XnaPlugin/Pickray.cs new file mode 100644 index 0000000..20510ae --- /dev/null +++ b/XnaPlugin/XnaPlugin/Pickray.cs @@ -0,0 +1,20 @@ +using Microsoft.Xna.Framework; + +namespace AntMe.Plugin.Xna +{ + /// + /// Pickray for selection + /// + internal struct Pickray + { + /// + /// Gets or sets the current Ray-Direction. + /// + public Vector3 Direction; + + /// + /// Gets or sets the Ray-Origin. + /// + public Vector3 Origin; + } +} \ No newline at end of file diff --git a/XnaPlugin/XnaPlugin/Plugin.cs b/XnaPlugin/XnaPlugin/Plugin.cs new file mode 100644 index 0000000..61fc76b --- /dev/null +++ b/XnaPlugin/XnaPlugin/Plugin.cs @@ -0,0 +1,108 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +using AntMe.SharedComponents.Plugin; +using AntMe.SharedComponents.States; +using System.Windows.Forms; +using System.Threading; +using System.Reflection; + +namespace AntMe.Plugin.Xna +{ + [Preselected] + public sealed class Plugin : IConsumerPlugin + { + private readonly Version version = Assembly.GetExecutingAssembly().GetName().Version; + + private PluginState state = PluginState.Ready; + + private RenderWindow window; + + public Guid Guid { get { return Guid.Parse("{AC254307-B465-493B-B99C-9E7BC8F19234}"); } } + + public Version Version { get { return version; } } + + public string Name { get { return Resource.PluginName; } } + + public string Description { get { return Resource.PluginDescription; } } + + public void StartupParameter(string[] parameter) { } + + public void SetVisibility(bool visible) { } + + public bool Interrupt + { + get { return (state != PluginState.Ready && window == null); } + } + + public PluginState State { get { return state; } } + + public Control Control + { + get { return null; } + } + + public byte[] Settings + { + get + { + return new byte[0]; + } + set + { + } + } + + private void Loop() + { + window = new RenderWindow(); + window.Run(); + window.Dispose(); + window = null; + state = PluginState.Ready; + } + + public void Start() + { + if (window == null) + { + Thread t = new Thread(Loop); + t.IsBackground = true; + t.Start(); + } + state = PluginState.Running; + } + + public void Stop() + { + if (window != null) + window.Exit(); + } + + public void Pause() + { + state = PluginState.Paused; + } + + + public void CreateState(ref SimulationState state) + { + } + + public void CreatingState(ref SimulationState state) + { + } + + public void CreatedState(ref SimulationState state) + { + if (window != null) + window.CurrentState = state; + } + + public void UpdateUI(SimulationState state) + { + } + } +} diff --git a/XnaPlugin/XnaPlugin/Properties/AssemblyInfo.cs b/XnaPlugin/XnaPlugin/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..8c87921 --- /dev/null +++ b/XnaPlugin/XnaPlugin/Properties/AssemblyInfo.cs @@ -0,0 +1,35 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("AntMe! XNA Plugin")] +[assembly: AssemblyProduct("AntMe!")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyCompany("AntMe! GmbH")] +[assembly: AssemblyCopyright("Copyright © 2014 AntMe! GmbH")] +[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. Only Windows +// assemblies support COM. +[assembly: ComVisible(false)] + +// On Windows, the following GUID is for the ID of the typelib if this +// project is exposed to COM. On other platforms, it unique identifies the +// title storage container when deploying this assembly to the device. +[assembly: Guid("fc5ec731-98e5-4399-9a34-91abedadecd6")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("1.7.1.461")] +[assembly: AssemblyFileVersionAttribute("1.7.1.461")] diff --git a/XnaPlugin/XnaPlugin/RenderWindow.cs b/XnaPlugin/XnaPlugin/RenderWindow.cs new file mode 100644 index 0000000..8846867 --- /dev/null +++ b/XnaPlugin/XnaPlugin/RenderWindow.cs @@ -0,0 +1,991 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Audio; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; +using Microsoft.Xna.Framework.Media; +using AntMe.SharedComponents.States; + +namespace AntMe.Plugin.Xna +{ + internal sealed class RenderWindow : Game + { + private const int ROWHEIGHT = 13; // Distance between rows in statistic-box + private const int MARKERTRANSPARENCY = 16; // alpha-value for marker + private const float VIEWRANGE_MAX = 50000.0f; + private const float VIEWRANGE_MIN = 1.0f; + + static readonly Vector3 LIGHT_0_DIRECTION = Vector3.Normalize(new Vector3(1, -3, 1)); + static readonly Vector3 LIGHT_1_DIRECTION = Vector3.Normalize(new Vector3(0, 1, -2)); + static readonly Vector3 LIGHT_2_DIRECTION = Vector3.Normalize(new Vector3(-2, 1, 0)); + + KeyboardState previousKeyboardState; + + GraphicsDeviceManager graphics; + SpriteBatch spriteBatch; + Camera camera; + + Texture2D textFieldBackground; + Texture2D groundTexture; // free texture from: http://www.textureking.com + Texture2D borderTexture; // free texture from: http://www.textureking.com + TextureCube skyTex; + Effect skyEffect; + CubeMesh skyMesh; + + NineSlicedTexture infoBox; + + Model bug; + Model ant; + Model anthill; + Model apple; + Model sugar; + Model marker; + Model box; + + SpriteFont hudFont; + BasicEffect effect; + Vector3[] playerColors; + + int playgroundWidth; + int playgroundHeight; + + VertexPositionNormalTexture[] plainVertices; + + Dictionary debugMessages = new Dictionary(); + + bool showDebugInfo = false; + DebugRenderer debugRenderer; + + RasterizerState defaultRasterizerState, markerRasterizerState; + DepthStencilState defaultDepthStencilState, markerDepthStencilState; + + public SimulationState CurrentState { get; set; } + + public RenderWindow() + { + graphics = new GraphicsDeviceManager(this); + Content.RootDirectory = "Content"; + + Window.Title = "AntMe! XNA"; + IsMouseVisible = true; + Window.AllowUserResizing = true; + } + + protected override void Initialize() + { + camera = new Camera(Window); + previousKeyboardState = Keyboard.GetState(); + + base.Initialize(); + } + + protected override void LoadContent() + { + spriteBatch = new SpriteBatch(GraphicsDevice); + debugRenderer = new DebugRenderer(GraphicsDevice, camera); + + defaultRasterizerState = GraphicsDevice.RasterizerState; + markerRasterizerState = new RasterizerState() + { + CullMode = CullMode.CullCounterClockwiseFace, + FillMode = FillMode.Solid, + DepthBias = 0f, + SlopeScaleDepthBias = 1f, + }; + + defaultDepthStencilState = GraphicsDevice.DepthStencilState; + markerDepthStencilState = new DepthStencilState() { DepthBufferEnable = false }; + + // default effect + effect = new BasicEffect(GraphicsDevice); + effect.LightingEnabled = true; + effect.DirectionalLight0.Enabled = false; + effect.DirectionalLight1.Enabled = false; + effect.DirectionalLight2.Enabled = false; + effect.World = Matrix.Identity; + effect.View = Matrix.CreateLookAt(new Vector3(0, 0, -2), new Vector3(0, 0, 0), new Vector3(0, 1, 0)); + effect.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, 4f / 3f, 1f, 50000f); + + // Textures + groundTexture = Content.Load("dirt"); + borderTexture = Content.Load("borderTex"); + + textFieldBackground = Content.Load("textbox"); + infoBox = new NineSlicedTexture(textFieldBackground, new Rectangle(10, 10, 12, 12)); + + // Sky + skyTex = Content.Load("sky"); + skyEffect = Content.Load("SkyEffect"); + skyEffect.Parameters["tex"].SetValue(skyTex); + VertexDeclaration skyDeclaration = new VertexDeclaration(new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0)); + skyMesh = new CubeMesh(GraphicsDevice, Vector3.One); + + // Common Meshes + bug = Content.Load("bug"); + ant = Content.Load("ant"); + anthill = Content.Load("anthill"); + apple = Content.Load("apple"); + sugar = Content.Load("sugar"); + marker = Content.Load("sphere"); + box = Content.Load("box"); + + hudFont = Content.Load("HudFont"); + + + // Create Plane Mesh + plainVertices = new VertexPositionNormalTexture[] + { + new VertexPositionNormalTexture(new Vector3(-0.5f, 0, -0.5f),new Vector3(0, 1, 0), new Vector2(0, 0)), + new VertexPositionNormalTexture(new Vector3(+0.5f, 0, -0.5f),new Vector3(0, 1, 0), new Vector2(1, 0)), + new VertexPositionNormalTexture(new Vector3(+0.5f, 0, +0.5f),new Vector3(0, 1, 0), new Vector2(1, 1)), + + new VertexPositionNormalTexture(new Vector3(-0.5f, 0, -0.5f),new Vector3(0, 1, 0), new Vector2(0, 0)), + new VertexPositionNormalTexture(new Vector3(+0.5f, 0, +0.5f),new Vector3(0, 1, 0), new Vector2(1, 1)), + new VertexPositionNormalTexture(new Vector3(-0.5f, 0, +0.5f),new Vector3(0, 1, 0), new Vector2(0, 1)), + }; + + + // Create Player Color + playerColors = new Vector3[] + { + new Vector3(0f, 0f, 0f), + new Vector3(1f, 0f, 0f), + new Vector3(0f, 0f, 1f), + new Vector3(0f, 1f, 0f), + new Vector3(0f, 1f, 1f), + new Vector3(1f, 1f, 0f), + new Vector3(1f, 0f, 1f), + new Vector3(1f, 1f, 1f), + }; + } + + /// + /// UnloadContent will be called once per game and is the place to unload + /// all content. + /// + protected override void UnloadContent() + { + debugRenderer.Unload(); + Content.Unload(); + } + + /// + /// Allows the game to run logic such as updating the world, + /// checking for collisions, gathering input, and playing audio. + /// + /// Provides a snapshot of timing values. + protected override void Update(GameTime gameTime) + { + if (CurrentState != null) + { + playgroundWidth = CurrentState.PlaygroundWidth / 2; + playgroundHeight = CurrentState.PlaygroundHeight / 2; + camera.Resize(CurrentState.PlaygroundWidth, CurrentState.PlaygroundHeight); + } + + var ks = Keyboard.GetState(); + if (ks.IsKeyUp(Keys.D) && previousKeyboardState.IsKeyDown(Keys.D)) + { + showDebugInfo = !showDebugInfo; + } + previousKeyboardState = ks; + + + camera.Update(gameTime); + + base.Update(gameTime); + } + + /// + /// This is called when the game should draw itself. + /// + /// Provides a snapshot of timing values. + protected override void Draw(GameTime gameTime) + { + GraphicsDevice.Clear(Color.CornflowerBlue); + GraphicsDevice.DepthStencilState = DepthStencilState.Default; + + SimulationState state = CurrentState; + if (state == null) + return; + + DrawSky(); + + effect.CurrentTechnique.Passes[0].Apply(); + effect.Projection = camera.ProjectionMatrix; + effect.View = camera.ViewMatrix; + + DrawPlayground(); + + Selection selectedItem = new Selection(); + Pickray pickray = camera.Pickray; + Point mousePosition = camera.MousePosition; + + // Selektionsinfos zurücksetzen + selectedItem.SelectionType = SelectionType.Nothing; + selectedItem.Item = null; + float distanceToSelectedItem = VIEWRANGE_MAX * VIEWRANGE_MAX; + + + // Draw Bugs + float distance; + foreach (var bug in state.BugStates) + { + if ((distance = DrawBug(bug, pickray, false)) > 0) + { + if (distance < distanceToSelectedItem) + { + distanceToSelectedItem = distance; + selectedItem.Item = bug; + selectedItem.SelectionType = SelectionType.Bug; + } + } + } + + // Draw Sugar + foreach (var sugar in state.SugarStates) + { + if ((distance = DrawSugar(sugar, pickray, false)) > 0) + { + if (distance < distanceToSelectedItem) + { + distanceToSelectedItem = distance; + selectedItem.Item = sugar; + selectedItem.SelectionType = SelectionType.Sugar; + } + } + } + + // Draw Fruit + foreach (var fruit in state.FruitStates) + { + if ((distance = DrawFruit(fruit, pickray, false)) > 0) + { + if (distance < distanceToSelectedItem) + { + distanceToSelectedItem = distance; + selectedItem.Item = fruit; + selectedItem.SelectionType = SelectionType.Fruit; + } + } + } + + // Draw Colony Base + foreach (var colony in state.ColonyStates) + { + // Draw AntHills + foreach (var anthill in colony.AnthillStates) + { + if ((distance = DrawAnthill(colony.Id, anthill, pickray, false)) > 0) + { + if (distance < distanceToSelectedItem) + { + distanceToSelectedItem = distance; + selectedItem.Item = anthill; + selectedItem.SelectionType = SelectionType.Anthill; + selectedItem.AdditionalInfo = CurrentState.ColonyStates[anthill.ColonyId - 1].ColonyName; + } + } + } + + // Draw Ants + foreach (var ant in colony.AntStates) + { + // Debug Messages aktualisieren + if (!string.IsNullOrEmpty(ant.DebugMessage)) + { + DebugMessage msg; + if (debugMessages.ContainsKey(ant.Id)) + msg = debugMessages[ant.Id]; + else + { + msg = new DebugMessage(); + debugMessages.Add(ant.Id, msg); + } + + msg.CreateRound = state.CurrentRound; + msg.Message = ant.DebugMessage; + } + + // Draw + if ((distance = DrawAnt(colony.Id, ant, pickray, false)) > 0) + { + if (distance < distanceToSelectedItem) + { + distanceToSelectedItem = distance; + selectedItem.Item = ant; + selectedItem.SelectionType = SelectionType.Ant; + selectedItem.AdditionalInfo = CurrentState.ColonyStates[ant.ColonyId - 1].ColonyName; + } + } + } + + // Remove old Messages + foreach (var key in debugMessages.Keys.ToArray()) + { + DebugMessage msg = debugMessages[key]; + if (state.CurrentRound - msg.CreateRound > DebugMessage.ROUNDS_TO_LIFE) + debugMessages.Remove(key); + } + } + + // Draw Marker + foreach (var colony in state.ColonyStates) + { + foreach (var marker in colony.MarkerStates) + { + DrawMarker(colony.Id, marker); + + } + } + + // render all sprites in one SpriteBatch.Begin()-End() cycle to save performance + spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied); + + + + // Draw debug ant-thoughts + if (showDebugInfo) + { + foreach (var colony in CurrentState.ColonyStates) + { + foreach (var ant in colony.AntStates) + { + // Draw actual debug text + if (debugMessages.ContainsKey(ant.Id)) + { + DebugMessage msg = debugMessages[ant.Id]; + Vector3 pos = new Vector3(ant.PositionX - playgroundWidth, 4, -ant.PositionY + playgroundHeight); + Vector2 screenPos = debugRenderer.WorldToScreen(pos, new Vector2(0, -20)); + Color boxCol = new Color(0.5f * playerColors[ant.ColonyId - 1]); + boxCol.A = 128; + DrawTextBox(msg.Message, screenPos, boxCol, Color.White); + } + } + } + } + + // Draw Infobox + DrawInfobox(state); + + // Draw Info-Tag at selected item + if (selectedItem.SelectionType != SelectionType.Nothing) + { + string line1; + string line2; + switch (selectedItem.SelectionType) + { + case SelectionType.Ant: + + AntState ameise = (AntState)selectedItem.Item; + string name = "Ant"; + //if (!antNames.ContainsKey(ameise.Id)) + //{ + // name = names[random.Next(names.Length)]; + // antNames.Add(ameise.Id, name); + //} + //else + //{ + // name = antNames[ameise.Id]; + //} + + line1 = string.Format(Resource.HovertextAntLine1, name, selectedItem.AdditionalInfo); + line2 = string.Format(Resource.HovertextAntLine2, ameise.Vitality); + break; + case SelectionType.Anthill: + line1 = Resource.HovertextAnthillLine1; + line2 = string.Format(Resource.HovertextAnthillLine2, selectedItem.AdditionalInfo); + break; + case SelectionType.Bug: + BugState bugState = (BugState)selectedItem.Item; + line1 = Resource.HovertextBugLine1; + line2 = string.Format(Resource.HovertextBugLine2, bugState.Vitality); + break; + case SelectionType.Fruit: + FruitState fruitState = (FruitState)selectedItem.Item; + line1 = Resource.HovertextFruitLine1; + line2 = string.Format(Resource.HovertextFruitLine2, fruitState.Amount); + break; + case SelectionType.Sugar: + SugarState sugar = (SugarState)selectedItem.Item; + line1 = Resource.HovertextSugarLine1; + line2 = string.Format(Resource.HovertextSugarLine2, sugar.Amount); + break; + default: + line1 = String.Empty; + line2 = String.Empty; + break; + } + + // Text an Mausposition ausgeben + if (line1 != String.Empty || line2 != String.Empty) + { + DrawInfoTag(mousePosition, line1, line2); + } + } + + + spriteBatch.End(); + + base.Draw(gameTime); + } + + #region Render Methode + + private void DrawSky() + { + skyEffect.Parameters["WVP"].SetValue(camera.WorldMatrix * camera.ViewMatrix * camera.ProjectionMatrix); + skyEffect.CurrentTechnique.Passes[0].Apply(); + + skyMesh.Draw(); + } + + private void DrawPlayground() + { + Matrix matrix = Matrix.CreateScale(playgroundWidth * 2, 1.0f, playgroundHeight * 2); + effect.World = matrix; + effect.EmissiveColor = new Vector3(0.6f, 0.52f, 0.43f);//new Vector3(0.45f, 0.45f, 0.29f); // 114, 114, 73 + + effect.TextureEnabled = true; + effect.Texture = groundTexture; + + //effect.LightingEnabled = true; + //effect.DirectionalLight0.Enabled = true; + //effect.DirectionalLight0.Direction = LIGHT_0_DIRECTION; + + effect.CurrentTechnique.Passes[0].Apply(); + GraphicsDevice.DrawUserPrimitives(PrimitiveType.TriangleList, plainVertices, 0, 2); + + + // Draw Border + const int BORDER_WIDTH = 200; + const int BORDER_POS_Y = -BORDER_WIDTH / 2 + 10; + + for (int i = 0; i < 4; i++) + { + Vector3 scale, pos; + float rotation; + switch (i) + { + case 0: + scale = new Vector3(BORDER_WIDTH, BORDER_WIDTH, 2 * playgroundWidth + BORDER_WIDTH); + pos = new Vector3(BORDER_WIDTH / 2, BORDER_POS_Y, playgroundHeight + BORDER_WIDTH / 2); + rotation = MathHelper.PiOver2; + break; + case 1: + scale = new Vector3(BORDER_WIDTH, BORDER_WIDTH, 2 * playgroundWidth + BORDER_WIDTH); + pos = new Vector3(-BORDER_WIDTH / 2, BORDER_POS_Y, -playgroundHeight - BORDER_WIDTH / 2); + rotation = MathHelper.PiOver2; + break; + case 2: + scale = new Vector3(BORDER_WIDTH, BORDER_WIDTH, 2 * playgroundHeight + BORDER_WIDTH); + pos = new Vector3(playgroundWidth + BORDER_WIDTH / 2, BORDER_POS_Y, -BORDER_WIDTH / 2); + rotation = 0; + break; + case 3: + scale = new Vector3(BORDER_WIDTH, BORDER_WIDTH, 2 * playgroundHeight + BORDER_WIDTH); + pos = new Vector3(-playgroundWidth - BORDER_WIDTH / 2, BORDER_POS_Y, BORDER_WIDTH / 2); + rotation = 0; + break; + default: + throw new IndexOutOfRangeException(); + } + + Matrix world = Matrix.CreateScale(scale) * Matrix.CreateRotationY(rotation) * Matrix.CreateTranslation(pos); + + foreach (var mesh in box.Meshes) + { + foreach (BasicEffect eff in mesh.Effects) + { + + eff.World = world; + eff.View = camera.ViewMatrix; + eff.Projection = camera.ProjectionMatrix; + + eff.DiffuseColor = Color.White.ToVector3(); + + eff.TextureEnabled = true; + eff.Texture = borderTexture; + + eff.LightingEnabled = true; + + eff.DirectionalLight0.Enabled = true; + eff.DirectionalLight0.Direction = LIGHT_0_DIRECTION; + + eff.DirectionalLight1.Enabled = true; + eff.DirectionalLight1.Direction = LIGHT_1_DIRECTION; + + eff.DirectionalLight2.Enabled = true; + eff.DirectionalLight2.Direction = LIGHT_2_DIRECTION; + } + mesh.Draw(); + } + + } + + } + + public float DrawBug(BugState state, Pickray pickray, bool selected) + { + Matrix matrix = Matrix.CreateRotationY((float)(state.Direction * Math.PI) / 180); + matrix.M41 = (state.PositionX) - playgroundWidth; + matrix.M43 = (-state.PositionY) + playgroundHeight; + foreach (var mesh in bug.Meshes) + { + foreach (BasicEffect eff in mesh.Effects) + { + eff.World = matrix; + eff.View = camera.ViewMatrix; + eff.Projection = camera.ProjectionMatrix; + + + if (mesh.Name == "Sphere02" || mesh.Name == "Sphere03") + { + eff.LightingEnabled = false; + + // change the bugs eye color depending on its vitality + eff.EmissiveColor = Vector3.Lerp(new Vector3(1, 0, 0), new Vector3(0f, 0.6f, 1f), state.Vitality / 1000f); + + } + else if (mesh.Name == "Sphere01") + { + eff.LightingEnabled = true; + eff.DiffuseColor = new Vector3(0.1f, 0.1f, 0.1f); + eff.EmissiveColor = new Vector3(0f, 0f, 0f); + + eff.PreferPerPixelLighting = true; + eff.DirectionalLight0.Enabled = true; + eff.DirectionalLight0.Direction = LIGHT_0_DIRECTION; + eff.DirectionalLight0.SpecularColor = new Vector3(0.6f, 1f, 1f);//new Vector3(0.7f, 0.3f, 0f);// + + eff.DirectionalLight1.Enabled = false; + eff.DirectionalLight2.Enabled = false; + } + else + { + eff.LightingEnabled = false; + } + } + mesh.Draw(); + } + BoundingSphere sphere = getBoundingSphere(bug, matrix); + + + float? distance = sphere.Intersects(new Ray(pickray.Origin, pickray.Direction)); + if (distance != null) + return distance.Value; + + return 0.0f; + } + private BoundingSphere getBoundingSphere(Model model, Matrix world) + { + BoundingSphere sphere = new BoundingSphere(); + foreach (ModelMesh mesh in model.Meshes) + { + if (sphere.Radius == 0) + sphere = mesh.BoundingSphere; + else + sphere = BoundingSphere. + CreateMerged(sphere, mesh.BoundingSphere); + } + return sphere.Transform(world); + } + + public float DrawAnt(int colony, AntState state, Pickray pickray, bool selected) + { + Matrix matrix = Matrix.CreateRotationY((float)(state.Direction * Math.PI) / 180); + Vector3 position = new Vector3(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight); + + matrix.M41 = position.X; + matrix.M43 = position.Z; + + foreach (var mesh in ant.Meshes) + { + foreach (BasicEffect eff in mesh.Effects) + { + eff.World = matrix; + eff.View = camera.ViewMatrix; + eff.Projection = camera.ProjectionMatrix; + + eff.LightingEnabled = true; + if (mesh.Name == "Sphere01" || mesh.Name == "Sphere02") + { + // eff.EmissiveColor = playerColors[colony]; + eff.DiffuseColor = playerColors[colony - 1]; + } + else + { + // eff.EmissiveColor = new Vector3(0, 0, 0); + eff.DiffuseColor = 0.2f * playerColors[colony - 1];//new Vector3(0.2f, 0.2f, 0.2f); + } + + //eff.SpecularColor = new Vector3(0.5f, 0.5f, 0.5f) + playerColors[colony]; + + eff.DirectionalLight0.Enabled = true; + eff.DirectionalLight0.Direction = LIGHT_0_DIRECTION; + eff.DirectionalLight0.SpecularColor = new Vector3(1f, 1f, 1f);// + playerColors[colony]; + + eff.DirectionalLight1.Enabled = true; + eff.DirectionalLight1.Direction = LIGHT_1_DIRECTION; + + eff.DirectionalLight2.Enabled = true; + eff.DirectionalLight2.Direction = LIGHT_2_DIRECTION; + } + mesh.Draw(); + } + + // Draw sugar-block, if ant has sugar loaded + if (state.LoadType == LoadType.Sugar) + { + Matrix sugarWorld = + Matrix.CreateScale(2) + * Matrix.CreateTranslation(new Vector3(-1.5f, 4, 0)) + * matrix; + + foreach (var mesh in box.Meshes) + { + foreach (BasicEffect eff in mesh.Effects) + { + eff.World = sugarWorld; + eff.View = camera.ViewMatrix; + eff.Projection = camera.ProjectionMatrix; + + + eff.TextureEnabled = false; + eff.DiffuseColor = Color.White.ToVector3(); + } + mesh.Draw(); + } + + } + + + // Debug info + if (showDebugInfo) + { + Color color = new Color(playerColors[state.ColonyId - 1]); + Vector3 antPosition = position + Vector3.Up; + + float sightRadius = state.ViewRange; + debugRenderer.DrawHorizontalCircle(antPosition, sightRadius, 16, color); + + if (state.TargetType != TargetType.None) + { + Vector3 targetPos = new Vector3(state.TargetPositionX - playgroundWidth, 1, -state.TargetPositionY + playgroundHeight); + debugRenderer.DrawLine(antPosition, targetPos, color); + } + } + + float? distance = getBoundingSphere(ant, matrix).Intersects(new Ray(pickray.Origin, pickray.Direction)); + if (distance.HasValue) + return distance.Value; + + + return 0.0f; + } + + public float DrawSugar(SugarState state, Pickray pickray, bool selected) + { + Matrix matrix = Matrix.CreateTranslation(state.PositionX - playgroundWidth, + 0, -state.PositionY + playgroundHeight); + matrix.M11 = matrix.M22 = matrix.M33 = state.Radius / 50.0f; + foreach (var mesh in sugar.Meshes) + { + foreach (BasicEffect eff in mesh.Effects) + { + eff.World = matrix; + eff.View = camera.ViewMatrix; + eff.Projection = camera.ProjectionMatrix; + + eff.LightingEnabled = true; + eff.DiffuseColor = new Vector3(0.85f, 0.85f, 0.75f); + eff.EmissiveColor = new Vector3(0.3f, 0.3f, 0.25f); + + eff.DirectionalLight0.Enabled = true; + eff.DirectionalLight0.Direction = LIGHT_0_DIRECTION; + + eff.DirectionalLight1.Enabled = true; + eff.DirectionalLight1.Direction = LIGHT_1_DIRECTION; + + eff.DirectionalLight2.Enabled = true; + eff.DirectionalLight2.Direction = LIGHT_2_DIRECTION; + } + mesh.Draw(); + } + + float? distance = getBoundingSphere(sugar, matrix).Intersects(new Ray(pickray.Origin, pickray.Direction)); + if (distance.HasValue) + return distance.Value; + + return 0.0f; + } + + public float DrawFruit(FruitState state, Pickray pickray, bool selected) + { + Matrix matrix = Matrix.CreateTranslation(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight); + matrix.M11 = state.Radius / 4.5f; + matrix.M22 = state.Radius / 4.5f; + matrix.M33 = state.Radius / 4.5f; + foreach (var mesh in apple.Meshes) + { + foreach (BasicEffect eff in mesh.Effects) + { + eff.World = matrix; + eff.View = camera.ViewMatrix; + eff.Projection = camera.ProjectionMatrix; + + eff.LightingEnabled = true; + eff.DiffuseColor = new Vector3(0.6f, 0.7f, 0.1f); + eff.EmissiveColor = new Vector3(0.1f, 0.3f, 0f); + + eff.DirectionalLight0.Enabled = true; + eff.DirectionalLight0.Direction = LIGHT_0_DIRECTION; + eff.DirectionalLight0.DiffuseColor = new Vector3(0.7f, 0.4f, 0f); + eff.DirectionalLight0.SpecularColor = new Vector3(0.1f, 0.5f, 0f); + + eff.DirectionalLight1.Enabled = true; + eff.DirectionalLight1.Direction = LIGHT_1_DIRECTION; + eff.DirectionalLight1.DiffuseColor = new Vector3(0.3f, 0.1f, 0f); + + eff.DirectionalLight2.Enabled = false; + eff.DirectionalLight2.Direction = LIGHT_2_DIRECTION; + eff.DirectionalLight2.DiffuseColor = new Vector3(0.3f, 0.4f, 0f); + eff.DirectionalLight0.SpecularColor = new Vector3(0.1f, 0.5f, 0f); + + } + mesh.Draw(); + } + + //// Check for pickray-collision + + float? distance = getBoundingSphere(apple, matrix).Intersects(new Ray(pickray.Origin, pickray.Direction)); + if (distance.HasValue) + return distance.Value; + + return 0.0f; + } + + public float DrawAnthill(int colony, AnthillState state, Pickray pickray, bool selected) + { + Matrix matrix = Matrix.CreateTranslation(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight); + BoundingSphere collisionBox = new BoundingSphere( + new Vector3(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight), + state.Radius); + + // Cone + var mesh = anthill.Meshes[0]; + foreach (BasicEffect eff in mesh.Effects) + { + eff.World = matrix; + eff.View = camera.ViewMatrix; + eff.Projection = camera.ProjectionMatrix; + + eff.LightingEnabled = true; + eff.EmissiveColor = new Vector3(0.1f, 0.05f, 0f); + + eff.DirectionalLight0.Enabled = true; + eff.DirectionalLight0.Direction = LIGHT_0_DIRECTION; + eff.DirectionalLight0.DiffuseColor = new Vector3(0.4f, 0.4f, 0.4f); + + eff.DirectionalLight1.Enabled = true; + eff.DirectionalLight1.Direction = LIGHT_1_DIRECTION; + eff.DirectionalLight1.DiffuseColor = new Vector3(0.1f, 0.1f, 0.2f); + + eff.DirectionalLight2.Enabled = true; + eff.DirectionalLight2.Direction = LIGHT_2_DIRECTION; + eff.DirectionalLight2.DiffuseColor = new Vector3(0.1f, 0.1f, 0.2f); + } + mesh.Draw(); + + // Bar + mesh = anthill.Meshes[1]; + foreach (BasicEffect eff in mesh.Effects) + { + eff.World = matrix; + eff.View = camera.ViewMatrix; + eff.Projection = camera.ProjectionMatrix; + + eff.LightingEnabled = true; + eff.EmissiveColor = new Vector3(0.5f, 0.5f, 0.5f); + + eff.DirectionalLight0.Enabled = true; + eff.DirectionalLight0.Direction = LIGHT_0_DIRECTION; + + eff.DirectionalLight1.Enabled = true; + eff.DirectionalLight1.Direction = LIGHT_1_DIRECTION; + + eff.DirectionalLight2.Enabled = true; + eff.DirectionalLight2.Direction = LIGHT_2_DIRECTION; + } + mesh.Draw(); + + // Flag + mesh = anthill.Meshes[2]; + foreach (BasicEffect eff in mesh.Effects) + { + eff.World = matrix; + eff.View = camera.ViewMatrix; + eff.Projection = camera.ProjectionMatrix; + + eff.LightingEnabled = true; + eff.EmissiveColor = playerColors[colony - 1]; + + eff.DirectionalLight0.Enabled = true; + eff.DirectionalLight0.Direction = LIGHT_0_DIRECTION; + + eff.DirectionalLight1.Enabled = true; + eff.DirectionalLight1.Direction = LIGHT_1_DIRECTION; + + eff.DirectionalLight2.Enabled = true; + eff.DirectionalLight2.Direction = LIGHT_2_DIRECTION; + } + mesh.Draw(); + + + // Check for pickray-collision + float? distance = collisionBox.Intersects(new Ray(pickray.Origin, pickray.Direction)); + if (distance.HasValue) + { + return distance.Value; + } + return 0.0f; + } + + public void DrawMarker(int colony, MarkerState state) + { + + GraphicsDevice.RasterizerState = markerRasterizerState; + GraphicsDevice.DepthStencilState = markerDepthStencilState; + + GraphicsDevice.BlendState = BlendState.AlphaBlend; + //GraphicsDevice.BlendState = new BlendState() + //{ + // AlphaBlendFunction = BlendFunction.Add, + // ColorBlendFunction = BlendFunction.Add, + + // AlphaSourceBlend = Blend.SourceAlpha, + // ColorSourceBlend = Blend.SourceColor, + + // AlphaDestinationBlend = Blend.InverseSourceAlpha, + // ColorDestinationBlend = Blend.InverseSourceColor, + //}; + Vector3 pos = new Vector3(state.PositionX - playgroundWidth, 0, -state.PositionY + playgroundHeight); + + Matrix matrix = Matrix.CreateTranslation(pos); + + matrix.M11 = matrix.M22 = matrix.M33 = state.Radius; + + foreach (var mesh in marker.Meshes) + { + foreach (BasicEffect eff in mesh.Effects) + { + eff.World = matrix; + eff.View = camera.ViewMatrix; + eff.Projection = camera.ProjectionMatrix; + + eff.LightingEnabled = false; + eff.Alpha = 0.05f; + eff.EmissiveColor = 0.33f * playerColors[state.ColonyId - 1]; + eff.DiffuseColor = 0.33f * playerColors[state.ColonyId - 1]; + } + mesh.Draw(); + } + + GraphicsDevice.RasterizerState = defaultRasterizerState; + GraphicsDevice.DepthStencilState = defaultDepthStencilState; + + // draw debug + if (showDebugInfo) + { + debugRenderer.DrawHorizontalCircle(pos, state.Radius, 16, new Color(0.33f * playerColors[state.ColonyId - 1])); + } + } + + public void DrawInfobox(SimulationState state) + { + int height = ROWHEIGHT * state.ColonyStates.Count + 60; + int position = (height / 2) + 10; + + + // Box and Header + //spriteBatch.Draw(textFieldBackground, new Rectangle(10, 10, 500, height), new Color(0.5f, 0.5f, 0.5f, 0.5f)); + infoBox.Draw(spriteBatch, new Rectangle(10, 10, 525, height), new Color(1f, 1f, 1f, 0.7f)); + //InfoBox.Draw(spriteBatch, new Rectangle(15, 50, 510, height - 45), new Color(0.5f, 0.5f, 0.5f, 0.5f)); + infoBox.Draw(spriteBatch, new Rectangle(175, 15, 80, height - 10), new Color(0.3f, 0.9f, 0.3f, 0.3f)); + infoBox.Draw(spriteBatch, new Rectangle(265, 15, 80, height - 10), new Color(0.9f, 0.3f, 0.3f, 0.3f)); + infoBox.Draw(spriteBatch, new Rectangle(355, 15, 80, height - 10), new Color(0.3f, 0.3f, 0.9f, 0.3f)); + infoBox.Draw(spriteBatch, new Rectangle(445, 15, 80, height - 10), new Color(1f, 1f, 1f, 0.3f)); + + spriteBatch.DrawString(hudFont, Resource.InfoboxColumnColony2, new Vector2(20, ROWHEIGHT + 20), Color.Black); + spriteBatch.DrawString(hudFont, Resource.InfoboxColumnCollectedFood1, new Vector2(180, 20), Color.Black); //Green); + spriteBatch.DrawString(hudFont, Resource.InfoboxColumnCollectedFood2, new Vector2(180, ROWHEIGHT + 20), Color.Black); //Green); + spriteBatch.DrawString(hudFont, Resource.InfoboxColumnKilledAnts1, new Vector2(270, 20), Color.Black); //Red); + spriteBatch.DrawString(hudFont, Resource.InfoboxColumnKilledAnts2, new Vector2(270, ROWHEIGHT + 20), Color.Black); //Red); + spriteBatch.DrawString(hudFont, Resource.InfoboxColumnKilledBugs1, new Vector2(360, 20), Color.Black); //Blue); + spriteBatch.DrawString(hudFont, Resource.InfoboxColumnKilledBugs2, new Vector2(360, ROWHEIGHT + 20), Color.Black); //Blue); + spriteBatch.DrawString(hudFont, Resource.InfoboxColumnPoints2, new Vector2(450, /*ROWHEIGHT +*/ 20), Color.Black); + + //int count = 0; + for (int i = 0; i < state.ColonyStates.Count; i++) + { + Color color = new Color(0.5f * playerColors[i]); + ColonyState colony = state.ColonyStates[i]; + int killedAnts = colony.StarvedAnts + colony.EatenAnts + colony.BeatenAnts; + int posY = i * ROWHEIGHT + 55; + + spriteBatch.DrawString(hudFont, colony.ColonyName, new Vector2(20, i * ROWHEIGHT + 55), color); + + // DrawTextRightAligned(colony.ColonyName, 20, posY, color); + DrawTextRightAligned(colony.CollectedFood.ToString(), 250, posY, color); + DrawTextRightAligned(killedAnts.ToString(), 340, posY, color); + DrawTextRightAligned(colony.KilledBugs.ToString(), 430, posY, color); + DrawTextRightAligned(colony.Points.ToString(), 520, posY, color); + + } + + + } + + private void DrawTextRightAligned(string text, int posX, int posY, Color color) + { + int width = (int)hudFont.MeasureString(text).X; + spriteBatch.DrawString(hudFont, text, new Vector2(posX - width, posY), color); + } + + public void DrawInfoTag(Point position, String line1, String line2) + { + int height = 2 * ROWHEIGHT + 10; + int posY = position.Y - height - 5; + + int widthLine1 = (int)hudFont.MeasureString(line1).X; + int widthLine2 = (int)hudFont.MeasureString(line2).X; + int width = (int)Math.Max(widthLine1, widthLine2) + 20; + int posX = position.X - width / 2; + + + infoBox.Draw(spriteBatch, new Rectangle(posX, posY, width, height), new Color(1f, 1f, 1f, 0.8f)); + + spriteBatch.DrawString(hudFont, line1, new Vector2(posX + 10, posY + 5), Color.Black); + spriteBatch.DrawString(hudFont, line2, new Vector2(posX + 10, posY + ROWHEIGHT + 5), Color.Black); + + + } + + private void DrawTextBox(string text, Vector2 pos, Color boxColor, Color textColor) + { + Vector2 textSize = hudFont.MeasureString(text); + pos = new Vector2((int)(pos.X - 0.5f * textSize.X), (int)(pos.Y - 0.5f * textSize.Y)); + + Rectangle rect = new Rectangle((int)pos.X - 10, (int)pos.Y - 10, (int)textSize.X + 20, (int)textSize.Y + 20); + + infoBox.Draw(spriteBatch, rect, boxColor); + spriteBatch.DrawString(hudFont, text, pos, textColor); + + } + + #endregion + } +} diff --git a/XnaPlugin/XnaPlugin/Resource.Designer.cs b/XnaPlugin/XnaPlugin/Resource.Designer.cs new file mode 100644 index 0000000..a70023a --- /dev/null +++ b/XnaPlugin/XnaPlugin/Resource.Designer.cs @@ -0,0 +1,333 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AntMe.Plugin.Xna { + 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 Resource { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resource() { + } + + /// + /// 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("AntMe.Plugin.Xna.Resource", typeof(Resource).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; + } + } + + /// + /// Looks up a localized string similar to Anthill. + /// + internal static string HovertextAnthillLine1 { + get { + return ResourceManager.GetString("HovertextAnthillLine1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Colony: {0}. + /// + internal static string HovertextAnthillLine2 { + get { + return ResourceManager.GetString("HovertextAnthillLine2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to {0} ({1}). + /// + internal static string HovertextAntLine1 { + get { + return ResourceManager.GetString("HovertextAntLine1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Energy: {0}. + /// + internal static string HovertextAntLine2 { + get { + return ResourceManager.GetString("HovertextAntLine2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Bug. + /// + internal static string HovertextBugLine1 { + get { + return ResourceManager.GetString("HovertextBugLine1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Energy: {0}. + /// + internal static string HovertextBugLine2 { + get { + return ResourceManager.GetString("HovertextBugLine2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Apple. + /// + internal static string HovertextFruitLine1 { + get { + return ResourceManager.GetString("HovertextFruitLine1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Food: {0}. + /// + internal static string HovertextFruitLine2 { + get { + return ResourceManager.GetString("HovertextFruitLine2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Sugar. + /// + internal static string HovertextSugarLine1 { + get { + return ResourceManager.GetString("HovertextSugarLine1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Food: {0}. + /// + internal static string HovertextSugarLine2 { + get { + return ResourceManager.GetString("HovertextSugarLine2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to beaten. + /// + internal static string InfoboxColumnBeatenAnts1 { + get { + return ResourceManager.GetString("InfoboxColumnBeatenAnts1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Ants. + /// + internal static string InfoboxColumnBeatenAnts2 { + get { + return ResourceManager.GetString("InfoboxColumnBeatenAnts2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to collected. + /// + internal static string InfoboxColumnCollectedFood1 { + get { + return ResourceManager.GetString("InfoboxColumnCollectedFood1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Food. + /// + internal static string InfoboxColumnCollectedFood2 { + get { + return ResourceManager.GetString("InfoboxColumnCollectedFood2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to collected. + /// + internal static string InfoboxColumnCollectedFruits1 { + get { + return ResourceManager.GetString("InfoboxColumnCollectedFruits1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Fruit. + /// + internal static string InfoboxColumnCollectedFruits2 { + get { + return ResourceManager.GetString("InfoboxColumnCollectedFruits2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to . + /// + internal static string InfoboxColumnColony1 { + get { + return ResourceManager.GetString("InfoboxColumnColony1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to colony name. + /// + internal static string InfoboxColumnColony2 { + get { + return ResourceManager.GetString("InfoboxColumnColony2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to eaten. + /// + internal static string InfoboxColumnEatenAnts1 { + get { + return ResourceManager.GetString("InfoboxColumnEatenAnts1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Ants. + /// + internal static string InfoboxColumnEatenAnts2 { + get { + return ResourceManager.GetString("InfoboxColumnEatenAnts2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to killed. + /// + internal static string InfoboxColumnKilledAnts1 { + get { + return ResourceManager.GetString("InfoboxColumnKilledAnts1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Ants. + /// + internal static string InfoboxColumnKilledAnts2 { + get { + return ResourceManager.GetString("InfoboxColumnKilledAnts2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to killed. + /// + internal static string InfoboxColumnKilledBugs1 { + get { + return ResourceManager.GetString("InfoboxColumnKilledBugs1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Bugs. + /// + internal static string InfoboxColumnKilledBugs2 { + get { + return ResourceManager.GetString("InfoboxColumnKilledBugs2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to . + /// + internal static string InfoboxColumnPoints1 { + get { + return ResourceManager.GetString("InfoboxColumnPoints1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Points. + /// + internal static string InfoboxColumnPoints2 { + get { + return ResourceManager.GetString("InfoboxColumnPoints2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to starved. + /// + internal static string InfoboxColumnStarvedAnts1 { + get { + return ResourceManager.GetString("InfoboxColumnStarvedAnts1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Ants. + /// + internal static string InfoboxColumnStarvedAnts2 { + get { + return ResourceManager.GetString("InfoboxColumnStarvedAnts2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Display the simulation in 3D. + /// + internal static string PluginDescription { + get { + return ResourceManager.GetString("PluginDescription", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 3D-Visualization. + /// + internal static string PluginName { + get { + return ResourceManager.GetString("PluginName", resourceCulture); + } + } + } +} diff --git a/XnaPlugin/XnaPlugin/Resource.de.resx b/XnaPlugin/XnaPlugin/Resource.de.resx new file mode 100644 index 0000000..2b52f61 --- /dev/null +++ b/XnaPlugin/XnaPlugin/Resource.de.resx @@ -0,0 +1,247 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Ameisenbau + Text for anthill-hover-tag - Line 1 (RenderForm.cs) + + + Volk: {0} + Text for anthill-hover-tag - Line 2 (RenderForm.cs) +0: Colony-Name + + + {0} ({1}) + Text for ant-hover-tag - Line 1 (RenderForm.cs) +0: Name of ant +1: Colony-Name + + + Energie: {0} + Text for ant-hover-tag - Line 2 (RenderForm.cs) +0: Energy of ant + + + Wanze + Text for bug-hover-tag - Line 1 (RenderForm.cs) + + + Energie: {0} + Text for bug-hover-tag - Line 2 (RenderForm.cs) +0: Energy of bug + + + Apfel + Text for fruit-hover-tag - Line 1 (RenderForm.cs) + + + Nahrung: {0} + Text for fruit-hover-tag - Line 2 (RenderForm.cs) +0: Amount of food + + + Zucker + Text for sugar-hover-tag - Line 1 (RenderForm.cs) + + + Nahrung: {0} + Text for sugar-hover-tag - Line 2 (RenderForm.cs) +0: Amount of food + + + geschlagene + Line 1 of infobox-text for beaten ants (ModelManager.cs) + + + Ameisen + Line 2 of infobox-text for beaten ants (ModelManager.cs) + + + gesammelte + Line 1 of infobox-text for collected food (ModelManager.cs) + + + Nahrung + Line 2 of infobox-text for collected food (ModelManager.cs) + + + gesammeltes + Line 1 of infobox-text for collected fruits (ModelManager.cs) + + + Obst + Line 2 of infobox-text for collected fruits (ModelManager.cs) + + + + Line 1 of infobox-text for colony (ModelManager.cs) + + + Volkname + Line 2 of infobox-text for colony (ModelManager.cs) + + + gefressene + Line 1 of infobox-text for eaten ants (ModelManager.cs) + + + Ameisen + Line 2 of infobox-text for eaten ants (ModelManager.cs) + + + gestorbene + Line 1 of infobox-text for killed ants (ModelManager.cs) + + + Ameisen + Line 2 of infobox-text for killed ants (ModelManager.cs) + + + getötete + Line 1 of infobox-text for killed bugs (ModelManager.cs) + + + Wanzen + Line 2 of infobox-text for killed bugs (ModelManager.cs) + + + + Line 1 of infobox-text for points (ModelManager.cs) + + + Punkte + Line 2 of infobox-text for points (ModelManager.cs) + + + verhungerte + Line 1 of infobox-text for starved ants (ModelManager.cs) + + + Ameisen + Line 2 of infobox-text for starved ants (ModelManager.cs) + + + Zeigen Sie die Simulation in einer 3D-Welt an + Description of plugin (Plugin.cs) + + + 3D-Visualisierung + Name of Plugin (plugin.cs) + + \ No newline at end of file diff --git a/XnaPlugin/XnaPlugin/Resource.resx b/XnaPlugin/XnaPlugin/Resource.resx new file mode 100644 index 0000000..e32be4b --- /dev/null +++ b/XnaPlugin/XnaPlugin/Resource.resx @@ -0,0 +1,247 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Anthill + Text for anthill-hover-tag - Line 1 (RenderForm.cs) + + + Colony: {0} + Text for anthill-hover-tag - Line 2 (RenderForm.cs) +0: Colony-Name + + + {0} ({1}) + Text for ant-hover-tag - Line 1 (RenderForm.cs) +0: Name of ant +1: Colony-Name + + + Energy: {0} + Text for ant-hover-tag - Line 2 (RenderForm.cs) +0: Energy of ant + + + Bug + Text for bug-hover-tag - Line 1 (RenderForm.cs) + + + Energy: {0} + Text for bug-hover-tag - Line 2 (RenderForm.cs) +0: Energy of bug + + + Apple + Text for fruit-hover-tag - Line 1 (RenderForm.cs) + + + Food: {0} + Text for fruit-hover-tag - Line 2 (RenderForm.cs) +0: Amount of food + + + Sugar + Text for sugar-hover-tag - Line 1 (RenderForm.cs) + + + Food: {0} + Text for sugar-hover-tag - Line 2 (RenderForm.cs) +0: Amount of food + + + beaten + Line 1 of infobox-text for beaten ants (ModelManager.cs) + + + Ants + Line 2 of infobox-text for beaten ants (ModelManager.cs) + + + collected + Line 1 of infobox-text for collected food (ModelManager.cs) + + + Food + Line 2 of infobox-text for collected food (ModelManager.cs) + + + collected + Line 1 of infobox-text for collected fruits (ModelManager.cs) + + + Fruit + Line 2 of infobox-text for collected fruits (ModelManager.cs) + + + + Line 1 of infobox-text for colony (ModelManager.cs) + + + colony name + Line 2 of infobox-text for colony (ModelManager.cs) + + + eaten + Line 1 of infobox-text for eaten ants (ModelManager.cs) + + + Ants + Line 2 of infobox-text for eaten ants (ModelManager.cs) + + + killed + Line 1 of infobox-text for killed ants (ModelManager.cs) + + + Ants + Line 2 of infobox-text for killed ants (ModelManager.cs) + + + killed + Line 1 of infobox-text for killed bugs (ModelManager.cs) + + + Bugs + Line 2 of infobox-text for killed bugs (ModelManager.cs) + + + + Line 1 of infobox-text for points (ModelManager.cs) + + + Points + Line 2 of infobox-text for points (ModelManager.cs) + + + starved + Line 1 of infobox-text for starved ants (ModelManager.cs) + + + Ants + Line 2 of infobox-text for starved ants (ModelManager.cs) + + + Display the simulation in 3D + Description of plugin (Plugin.cs) + + + 3D-Visualization + Name of Plugin (plugin.cs) + + \ No newline at end of file diff --git a/XnaPlugin/XnaPlugin/Selection.cs b/XnaPlugin/XnaPlugin/Selection.cs new file mode 100644 index 0000000..f3de3b0 --- /dev/null +++ b/XnaPlugin/XnaPlugin/Selection.cs @@ -0,0 +1,23 @@ +namespace AntMe.Plugin.Xna +{ + /// + /// class, to hold selection-information. + /// + internal struct Selection + { + /// + /// Gets or sets the selected item or null, if empty + /// + public object Item; + + /// + /// Gets or sets the type of selected item. + /// + public SelectionType SelectionType; + + /// + /// Gets or sets additional information to the selected item. + /// + public string AdditionalInfo; + } +} \ No newline at end of file diff --git a/XnaPlugin/XnaPlugin/SelectionType.cs b/XnaPlugin/XnaPlugin/SelectionType.cs new file mode 100644 index 0000000..2b28649 --- /dev/null +++ b/XnaPlugin/XnaPlugin/SelectionType.cs @@ -0,0 +1,16 @@ +namespace AntMe.Plugin.Xna +{ + /// + /// List of all selectable items on map. + /// + internal enum SelectionType + { + Nothing, + Colony, + Anthill, + Ant, + Bug, + Sugar, + Fruit + } +} \ No newline at end of file diff --git a/XnaPlugin/XnaPlugin/XnaPlugin.csproj b/XnaPlugin/XnaPlugin/XnaPlugin.csproj new file mode 100644 index 0000000..61a661d --- /dev/null +++ b/XnaPlugin/XnaPlugin/XnaPlugin.csproj @@ -0,0 +1,154 @@ + + + + {4FDD2B0D-C481-401E-A794-2111BF15F39E} + {6D335F3A-9D43-41b4-9D22-F6F17C4BE596};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Debug + x86 + Library + Properties + AntMe.Plugin.Xna + AntMe.Plugin.Xna + v4.0 + Client + v4.0 + Windows + Reach + 656e7e1e-34e8-4acf-b792-574ebc8ac624 + Game + + + + + SAK + SAK + SAK + SAK + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + true + full + false + ..\..\bin\ + DEBUG;TRACE;WINDOWS + prompt + 4 + true + false + x86 + false + + + pdbonly + true + ..\..\bin\ + TRACE;WINDOWS + prompt + 4 + true + false + x86 + true + + + + + + true + + + AntMe.snk + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {415f50c3-bd70-4634-b1f7-a15b42f0b0c6} + SharedComponents + + + {B09C7823-AFF3-45A4-AAAC-88821B464DEC} + XnaPluginContent + Content + + + + + False + Microsoft .NET Framework 4 Client Profile %28x86 and x64%29 + true + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + false + + + False + Windows Installer 4.5 + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/XnaPlugin/XnaPluginContent/HudFont.spritefont b/XnaPlugin/XnaPluginContent/HudFont.spritefont new file mode 100644 index 0000000..73b7906 --- /dev/null +++ b/XnaPlugin/XnaPluginContent/HudFont.spritefont @@ -0,0 +1,60 @@ + + + + + + + Arial + + + 9 + + + 0 + + + true + + + + + + + + + + + + ÿ + + + + diff --git a/XnaPlugin/XnaPluginContent/SkyEffect.fx b/XnaPlugin/XnaPluginContent/SkyEffect.fx new file mode 100644 index 0000000..5104462 --- /dev/null +++ b/XnaPlugin/XnaPluginContent/SkyEffect.fx @@ -0,0 +1,45 @@ + +float4x4 WVP; +TextureCube tex; + +sampler cubeSampler = sampler_state { + texture = ; + AddressU = CLAMP; + AddressV = CLAMP; +}; + +struct VertexShaderInput +{ + float4 Position : POSITION0; +}; + +struct VertexShaderOutput +{ + float4 Position : POSITION0; + float3 PosTex : TEXCOORD0; +}; + +VertexShaderOutput VertexShaderFunction(VertexShaderInput input) +{ + VertexShaderOutput output; + output.Position = mul(input.Position, WVP).xyww; + output.PosTex = input.Position; + + return output; +} + +float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0 +{ + return texCUBE(cubeSampler,input.PosTex); +} + + +technique Technique1 +{ + pass Pass1 + { + CullMode = None; + VertexShader = compile vs_2_0 VertexShaderFunction(); + PixelShader = compile ps_2_0 PixelShaderFunction(); + } +} diff --git a/XnaPlugin/XnaPluginContent/XnaPluginContent.contentproj b/XnaPlugin/XnaPluginContent/XnaPluginContent.contentproj new file mode 100644 index 0000000..3f73308 --- /dev/null +++ b/XnaPlugin/XnaPluginContent/XnaPluginContent.contentproj @@ -0,0 +1,135 @@ + + + + {B09C7823-AFF3-45A4-AAAC-88821B464DEC} + {96E2B04D-8817-42c6-938A-82C39BA4D311};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Debug + x86 + Library + Properties + v4.0 + v4.0 + bin\$(Platform)\$(Configuration) + Content + SAK + SAK + SAK + SAK + + + x86 + + + x86 + + + XnaPluginContent + + + + + + + + + + + + ant + XImporter + ModelProcessor + + + anthill + XImporter + ModelProcessor + + + apple + XImporter + ModelProcessor + + + bug + XImporter + ModelProcessor + + + SkyEffect + EffectImporter + EffectProcessor + + + sugar + XImporter + ModelProcessor + + + + + HudFont + FontDescriptionImporter + FontDescriptionProcessor + + + + + pix + TextureImporter + TextureProcessor + + + + + dirt + TextureImporter + TextureProcessor + + + + + sky + TextureImporter + TextureProcessor + + + + + sphere + FbxImporter + ModelProcessor + 10 + + + + + box + FbxImporter + ModelProcessor + Designer + 90 + + + + + textbox + TextureImporter + TextureProcessor + + + + + borderTex + TextureImporter + TextureProcessor + + + + + \ No newline at end of file diff --git a/XnaPlugin/XnaPluginContent/ant.X b/XnaPlugin/XnaPluginContent/ant.X new file mode 100644 index 0000000..c6df52e Binary files /dev/null and b/XnaPlugin/XnaPluginContent/ant.X differ diff --git a/XnaPlugin/XnaPluginContent/anthill.x b/XnaPlugin/XnaPluginContent/anthill.x new file mode 100644 index 0000000..6661ccc Binary files /dev/null and b/XnaPlugin/XnaPluginContent/anthill.x differ diff --git a/XnaPlugin/XnaPluginContent/apple.x b/XnaPlugin/XnaPluginContent/apple.x new file mode 100644 index 0000000..1172ace Binary files /dev/null and b/XnaPlugin/XnaPluginContent/apple.x differ diff --git a/XnaPlugin/XnaPluginContent/borderTex.png b/XnaPlugin/XnaPluginContent/borderTex.png new file mode 100644 index 0000000..cbd3883 Binary files /dev/null and b/XnaPlugin/XnaPluginContent/borderTex.png differ diff --git a/XnaPlugin/XnaPluginContent/box.fbx b/XnaPlugin/XnaPluginContent/box.fbx new file mode 100644 index 0000000..3f05053 --- /dev/null +++ b/XnaPlugin/XnaPluginContent/box.fbx @@ -0,0 +1,337 @@ +; FBX 6.1.0 project file +; Copyright (C) 1997-2010 Autodesk Inc. and/or its licensors. +; All rights reserved. +; ---------------------------------------------------- + +FBXHeaderExtension: { + FBXHeaderVersion: 1003 + FBXVersion: 6100 + CreationTimeStamp: { + Version: 1000 + Year: 2015 + Month: 1 + Day: 28 + Hour: 17 + Minute: 56 + Second: 14 + Millisecond: 997 + } + Creator: "FBX SDK/FBX Plugins version 2013.3" +} + +; Document Description +;------------------------------------------------------------------ + +Document: { + Name: "" +} + +; Document References +;------------------------------------------------------------------ + +References: { +} + +; Object definitions +;------------------------------------------------------------------ + +Definitions: { + Version: 100 + Count: 4 + ObjectType: "Model" { + Count: 1 + } + ObjectType: "Material" { + Count: 1 + } + ObjectType: "SceneInfo" { + Count: 1 + } + ObjectType: "GlobalSettings" { + Count: 1 + } +} + +; Object properties +;------------------------------------------------------------------ + +Objects: { + Model: "Model::Box", "Mesh" { + Version: 232 + Properties60: { + Property: "QuaternionInterpolate", "enum", "",0 + Property: "RotationOffset", "Vector3D", "",0,0,0 + Property: "RotationPivot", "Vector3D", "",0,0,0 + Property: "ScalingOffset", "Vector3D", "",0,0,0 + Property: "ScalingPivot", "Vector3D", "",0,0,0 + Property: "TranslationActive", "bool", "",0 + Property: "TranslationMin", "Vector3D", "",0,0,0 + Property: "TranslationMax", "Vector3D", "",0,0,0 + Property: "TranslationMinX", "bool", "",0 + Property: "TranslationMinY", "bool", "",0 + Property: "TranslationMinZ", "bool", "",0 + Property: "TranslationMaxX", "bool", "",0 + Property: "TranslationMaxY", "bool", "",0 + Property: "TranslationMaxZ", "bool", "",0 + Property: "RotationOrder", "enum", "",0 + Property: "RotationSpaceForLimitOnly", "bool", "",0 + Property: "RotationStiffnessX", "double", "",0 + Property: "RotationStiffnessY", "double", "",0 + Property: "RotationStiffnessZ", "double", "",0 + Property: "AxisLen", "double", "",10 + Property: "PreRotation", "Vector3D", "",0,0,0 + Property: "PostRotation", "Vector3D", "",0,0,0 + Property: "RotationActive", "bool", "",1 + Property: "RotationMin", "Vector3D", "",0,0,0 + Property: "RotationMax", "Vector3D", "",0,0,0 + Property: "RotationMinX", "bool", "",0 + Property: "RotationMinY", "bool", "",0 + Property: "RotationMinZ", "bool", "",0 + Property: "RotationMaxX", "bool", "",0 + Property: "RotationMaxY", "bool", "",0 + Property: "RotationMaxZ", "bool", "",0 + Property: "InheritType", "enum", "",0 + Property: "ScalingActive", "bool", "",0 + Property: "ScalingMin", "Vector3D", "",0,0,0 + Property: "ScalingMax", "Vector3D", "",0,0,0 + Property: "ScalingMinX", "bool", "",0 + Property: "ScalingMinY", "bool", "",0 + Property: "ScalingMinZ", "bool", "",0 + Property: "ScalingMaxX", "bool", "",0 + Property: "ScalingMaxY", "bool", "",0 + Property: "ScalingMaxZ", "bool", "",0 + Property: "GeometricTranslation", "Vector3D", "",0,0,0 + Property: "GeometricRotation", "Vector3D", "",0,0,0 + Property: "GeometricScaling", "Vector3D", "",1,1,1 + Property: "MinDampRangeX", "double", "",0 + Property: "MinDampRangeY", "double", "",0 + Property: "MinDampRangeZ", "double", "",0 + Property: "MaxDampRangeX", "double", "",0 + Property: "MaxDampRangeY", "double", "",0 + Property: "MaxDampRangeZ", "double", "",0 + Property: "MinDampStrengthX", "double", "",0 + Property: "MinDampStrengthY", "double", "",0 + Property: "MinDampStrengthZ", "double", "",0 + Property: "MaxDampStrengthX", "double", "",0 + Property: "MaxDampStrengthY", "double", "",0 + Property: "MaxDampStrengthZ", "double", "",0 + Property: "PreferedAngleX", "double", "",0 + Property: "PreferedAngleY", "double", "",0 + Property: "PreferedAngleZ", "double", "",0 + Property: "LookAtProperty", "object", "" + Property: "UpVectorProperty", "object", "" + Property: "Show", "bool", "",1 + Property: "NegativePercentShapeSupport", "bool", "",1 + Property: "DefaultAttributeIndex", "int", "",0 + Property: "Freeze", "bool", "",0 + Property: "LODBox", "bool", "",0 + Property: "Lcl Translation", "Lcl Translation", "A",0,0,0 + Property: "Lcl Rotation", "Lcl Rotation", "A",0,0,0 + Property: "Lcl Scaling", "Lcl Scaling", "A",1,1,1 + Property: "Visibility", "Visibility", "A",1 + Property: "Color", "ColorRGB", "N",0.8,0.8,0.8 + Property: "BBoxMin", "Vector3D", "N",0,0,0 + Property: "BBoxMax", "Vector3D", "N",0,0,0 + Property: "Primary Visibility", "bool", "N",1 + Property: "Casts Shadows", "bool", "N",1 + Property: "Receive Shadows", "bool", "N",1 + Property: "PolygonPartNames", "stringlist", "UN",0, "Default" + } + MultiLayer: 0 + MultiTake: 0 + Shading: Y + Culling: "CullingOff" + Vertices: -0.5,-0.5,-0.5,-0.5,0.5,-0.5,0.5 + ,0.5,-0.5,0.5,-0.5,-0.5,-0.5,-0.5 + ,0.5,-0.5,0.5,0.5,0.5,0.5,0.5 + ,0.5,-0.5,0.5 + PolygonVertexIndex: 0,1,2,-4,4,5,1,-1,5,6,2,-2,6,7,3,-3,7,4,0,-4,4,7,6,-6 + Edges: 0,1,2,3,4,5,7,8,9,12,13,16 + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 101 + Name: "FBX_Normals" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + Normals: 0,0,-1,-1,0,0,0,1,0,1,0,0,0,-1,0,0,0,1 + NormalsIndex: 0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5 + } + LayerElementUV: 0 { + Version: 101 + Name: "Texture" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: 0.719985663890839,0.989880442619324,0.0100143272429705,0.989880442619324,0.98743861913681,0.726642191410065,0.719985663890839 + ,0.0101201180368662,0.0100143272429705,0.0101198200136423,0.732561469078064,0.728480756282806,0.0100143272429705 + ,0.0101198200136423,0.987438559532166,0.983357846736908,0.719985663890839,0.0101195480674505,0.732561469078064 + ,0.981519341468811,0.0100143272429705,0.989880442619324,0.719985663890839,0.989880442619324,0.719985663890839 + ,0.989880442619324,0.987438559532166,0.981519341468811,0.0100143272429705,0.989880442619324,0.719985663890839 + ,0.0101198200136423,0.732561469078064,0.983357846736908,0.0100143272429705,0.0101195480674505,0.0100143272429705 + ,0.0101201180368662,0.719985663890839,0.0101198200136423,0.987438559532166,0.728480756282806,0.0100143272429705 + ,0.989880442619324,0.732561469078064,0.726642191410065,0.719985663890839,0.989880442619324 + UVIndex: 3,0,21,18,15,12,1,4,13,9,22,2,10,6,19,23,7,16,5,20,17,8,11,14 + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygon" + ReferenceInformationType: "Direct" + Smoothing: 0,0,0,0,0,0 + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: 0 + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + NodeAttributeName: "Geometry::Box_ncl1_1" + } + SceneInfo: "SceneInfo::GlobalInfo", "UserData" { + Type: "UserData" + Version: 100 + MetaData: { + Version: 100 + Title: "Box" + Subject: "" + Author: "" + Keywords: "" + Revision: "" + Comment: "" + } + Properties60: { + Property: "DocumentUrl", "KString", "", "C:\Users\moeichinger\Desktop\Box.fbx" + Property: "SrcDocumentUrl", "KString", "", "C:\Users\moeichinger\Desktop\Box.fbx" + Property: "Original", "Compound", "" + Property: "Original|ApplicationVendor", "KString", "", "The Foundry" + Property: "Original|ApplicationName", "KString", "", "MODO" + Property: "Original|ApplicationVersion", "KString", "", "" + Property: "Original|DateTime_GMT", "DateTime", "", "28/01/2015 16:56:14.997" + Property: "Original|FileName", "KString", "", "C:\Users\moeichinger\Desktop\Box.fbx" + Property: "LastSaved", "Compound", "" + Property: "LastSaved|ApplicationVendor", "KString", "", "The Foundry" + Property: "LastSaved|ApplicationName", "KString", "", "MODO" + Property: "LastSaved|ApplicationVersion", "KString", "", "" + Property: "LastSaved|DateTime_GMT", "DateTime", "", "28/01/2015 16:56:14.997" + } + } + Material: "Material::Default", "" { + Version: 102 + ShadingModel: "phong" + MultiLayer: 0 + Properties60: { + Property: "ShadingModel", "KString", "", "Phong" + Property: "MultiLayer", "bool", "",0 + Property: "EmissiveColor", "Color", "A",1,1,1 + Property: "EmissiveFactor", "Number", "A",0 + Property: "AmbientColor", "Color", "A",0.2,0.2,0.2 + Property: "AmbientFactor", "Number", "A",1 + Property: "DiffuseColor", "Color", "A",0.6,0.6,0.6 + Property: "DiffuseFactor", "Number", "A",0.8 + Property: "Bump", "Vector3D", "",0,0,0 + Property: "NormalMap", "Vector3D", "",0,0,0 + Property: "BumpFactor", "double", "",1 + Property: "TransparentColor", "Color", "A",0,0,0 + Property: "TransparencyFactor", "Number", "A",0 + Property: "DisplacementColor", "ColorRGB", "",0,0,0 + Property: "DisplacementFactor", "double", "",1 + Property: "VectorDisplacementColor", "ColorRGB", "",0,0,0 + Property: "VectorDisplacementFactor", "double", "",1 + Property: "SpecularColor", "Color", "A",1,1,1 + Property: "SpecularFactor", "Number", "A",0.2 + Property: "ShininessExponent", "Number", "A",256 + Property: "ReflectionColor", "Color", "A",1,1,1 + Property: "ReflectionFactor", "Number", "A",0 + Property: "Emissive", "Vector3D", "",0,0,0 + Property: "Ambient", "Vector3D", "",0.2,0.2,0.2 + Property: "Diffuse", "Vector3D", "",0.48,0.48,0.48 + Property: "Specular", "Vector3D", "",0.2,0.2,0.2 + Property: "Shininess", "double", "",256 + Property: "Opacity", "double", "",1 + Property: "Reflectivity", "double", "",0 + } + } + GlobalSettings: { + Version: 1000 + Properties60: { + Property: "UpAxis", "int", "",1 + Property: "UpAxisSign", "int", "",1 + Property: "FrontAxis", "int", "",2 + Property: "FrontAxisSign", "int", "",1 + Property: "CoordAxis", "int", "",0 + Property: "CoordAxisSign", "int", "",1 + Property: "OriginalUpAxis", "int", "",-1 + Property: "OriginalUpAxisSign", "int", "",1 + Property: "UnitScaleFactor", "double", "",1 + Property: "OriginalUnitScaleFactor", "double", "",1 + Property: "AmbientColor", "ColorRGB", "",0,0,0 + Property: "DefaultCamera", "KString", "", "Producer Perspective" + Property: "TimeMode", "enum", "",0 + Property: "TimeSpanStart", "KTime", "",0 + Property: "TimeSpanStop", "KTime", "",46186158000 + Property: "CustomFrameRate", "double", "",-1 + } + } +} + +; Object connections +;------------------------------------------------------------------ + +Connections: { + Connect: "OO", "Model::Box", "Model::Scene" + Connect: "OO", "Material::Default", "Model::Box" +} +;Takes and animation section +;---------------------------------------------------- + +Takes: { + Current: "" +} +;Version 5 settings +;------------------------------------------------------------------ + +Version5: { + AmbientRenderSettings: { + Version: 101 + AmbientLightColor: 0,0,0,1 + } + FogOptions: { + FlogEnable: 0 + FogMode: 0 + FogDensity: 0.002 + FogStart: 0.3 + FogEnd: 1000 + FogColor: 1,1,1,1 + } + Settings: { + FrameRate: "30" + TimeFormat: 1 + SnapOnFrames: 0 + ReferenceTimeIndex: -1 + TimeLineStartTime: 0 + TimeLineStopTime: 46186158000 + } + RendererSetting: { + DefaultCamera: "Producer Perspective" + DefaultViewingMode: 0 + } +} diff --git a/XnaPlugin/XnaPluginContent/bug.X b/XnaPlugin/XnaPluginContent/bug.X new file mode 100644 index 0000000..34f81e6 Binary files /dev/null and b/XnaPlugin/XnaPluginContent/bug.X differ diff --git a/XnaPlugin/XnaPluginContent/dirt.png b/XnaPlugin/XnaPluginContent/dirt.png new file mode 100644 index 0000000..2ba8100 Binary files /dev/null and b/XnaPlugin/XnaPluginContent/dirt.png differ diff --git a/XnaPlugin/XnaPluginContent/pix.png b/XnaPlugin/XnaPluginContent/pix.png new file mode 100644 index 0000000..cd1c50a Binary files /dev/null and b/XnaPlugin/XnaPluginContent/pix.png differ diff --git a/XnaPlugin/XnaPluginContent/sky.dds b/XnaPlugin/XnaPluginContent/sky.dds new file mode 100644 index 0000000..420850a Binary files /dev/null and b/XnaPlugin/XnaPluginContent/sky.dds differ diff --git a/XnaPlugin/XnaPluginContent/sphere.fbx b/XnaPlugin/XnaPluginContent/sphere.fbx new file mode 100644 index 0000000..9c5fa94 --- /dev/null +++ b/XnaPlugin/XnaPluginContent/sphere.fbx @@ -0,0 +1,393 @@ +; FBX 6.1.0 project file +; Copyright (C) 1997-2010 Autodesk Inc. and/or its licensors. +; All rights reserved. +; ---------------------------------------------------- + +FBXHeaderExtension: { + FBXHeaderVersion: 1003 + FBXVersion: 6100 + CreationTimeStamp: { + Version: 1000 + Year: 2015 + Month: 1 + Day: 29 + Hour: 12 + Minute: 26 + Second: 30 + Millisecond: 244 + } + Creator: "FBX SDK/FBX Plugins version 2013.3" +} + +; Document Description +;------------------------------------------------------------------ + +Document: { + Name: "" +} + +; Document References +;------------------------------------------------------------------ + +References: { +} + +; Object definitions +;------------------------------------------------------------------ + +Definitions: { + Version: 100 + Count: 4 + ObjectType: "Model" { + Count: 1 + } + ObjectType: "Material" { + Count: 1 + } + ObjectType: "SceneInfo" { + Count: 1 + } + ObjectType: "GlobalSettings" { + Count: 1 + } +} + +; Object properties +;------------------------------------------------------------------ + +Objects: { + Model: "Model::Sphere", "Mesh" { + Version: 232 + Properties60: { + Property: "QuaternionInterpolate", "enum", "",0 + Property: "RotationOffset", "Vector3D", "",0,0,0 + Property: "RotationPivot", "Vector3D", "",0,0,0 + Property: "ScalingOffset", "Vector3D", "",0,0,0 + Property: "ScalingPivot", "Vector3D", "",0,0,0 + Property: "TranslationActive", "bool", "",0 + Property: "TranslationMin", "Vector3D", "",0,0,0 + Property: "TranslationMax", "Vector3D", "",0,0,0 + Property: "TranslationMinX", "bool", "",0 + Property: "TranslationMinY", "bool", "",0 + Property: "TranslationMinZ", "bool", "",0 + Property: "TranslationMaxX", "bool", "",0 + Property: "TranslationMaxY", "bool", "",0 + Property: "TranslationMaxZ", "bool", "",0 + Property: "RotationOrder", "enum", "",0 + Property: "RotationSpaceForLimitOnly", "bool", "",0 + Property: "RotationStiffnessX", "double", "",0 + Property: "RotationStiffnessY", "double", "",0 + Property: "RotationStiffnessZ", "double", "",0 + Property: "AxisLen", "double", "",10 + Property: "PreRotation", "Vector3D", "",0,0,0 + Property: "PostRotation", "Vector3D", "",0,0,0 + Property: "RotationActive", "bool", "",1 + Property: "RotationMin", "Vector3D", "",0,0,0 + Property: "RotationMax", "Vector3D", "",0,0,0 + Property: "RotationMinX", "bool", "",0 + Property: "RotationMinY", "bool", "",0 + Property: "RotationMinZ", "bool", "",0 + Property: "RotationMaxX", "bool", "",0 + Property: "RotationMaxY", "bool", "",0 + Property: "RotationMaxZ", "bool", "",0 + Property: "InheritType", "enum", "",0 + Property: "ScalingActive", "bool", "",0 + Property: "ScalingMin", "Vector3D", "",0,0,0 + Property: "ScalingMax", "Vector3D", "",0,0,0 + Property: "ScalingMinX", "bool", "",0 + Property: "ScalingMinY", "bool", "",0 + Property: "ScalingMinZ", "bool", "",0 + Property: "ScalingMaxX", "bool", "",0 + Property: "ScalingMaxY", "bool", "",0 + Property: "ScalingMaxZ", "bool", "",0 + Property: "GeometricTranslation", "Vector3D", "",0,0,0 + Property: "GeometricRotation", "Vector3D", "",0,0,0 + Property: "GeometricScaling", "Vector3D", "",1,1,1 + Property: "MinDampRangeX", "double", "",0 + Property: "MinDampRangeY", "double", "",0 + Property: "MinDampRangeZ", "double", "",0 + Property: "MaxDampRangeX", "double", "",0 + Property: "MaxDampRangeY", "double", "",0 + Property: "MaxDampRangeZ", "double", "",0 + Property: "MinDampStrengthX", "double", "",0 + Property: "MinDampStrengthY", "double", "",0 + Property: "MinDampStrengthZ", "double", "",0 + Property: "MaxDampStrengthX", "double", "",0 + Property: "MaxDampStrengthY", "double", "",0 + Property: "MaxDampStrengthZ", "double", "",0 + Property: "PreferedAngleX", "double", "",0 + Property: "PreferedAngleY", "double", "",0 + Property: "PreferedAngleZ", "double", "",0 + Property: "LookAtProperty", "object", "" + Property: "UpVectorProperty", "object", "" + Property: "Show", "bool", "",1 + Property: "NegativePercentShapeSupport", "bool", "",1 + Property: "DefaultAttributeIndex", "int", "",0 + Property: "Freeze", "bool", "",0 + Property: "LODBox", "bool", "",0 + Property: "Lcl Translation", "Lcl Translation", "A",0,0,0 + Property: "Lcl Rotation", "Lcl Rotation", "A",0,0,0 + Property: "Lcl Scaling", "Lcl Scaling", "A",1,1,1 + Property: "Visibility", "Visibility", "A",1 + Property: "Color", "ColorRGB", "N",0.8,0.8,0.8 + Property: "BBoxMin", "Vector3D", "N",0,0,0 + Property: "BBoxMax", "Vector3D", "N",0,0,0 + Property: "Primary Visibility", "bool", "N",1 + Property: "Casts Shadows", "bool", "N",1 + Property: "Receive Shadows", "bool", "N",1 + Property: "PolygonPartNames", "stringlist", "UN",0, "Default" + } + MultiLayer: 0 + MultiTake: 0 + Shading: Y + Culling: "CullingOff" + Vertices: 0,0,-0.0999927520751953,-0.0499993562698364,0,-0.0865936279296875,-0.0866025686264038,0,-0.0500202178955078,-0.100000202655792 + ,0,0,-0.0866025686264038,0,0.0500202178955078,-0.0499993562698364,0,0.0865936279296875,0,0,0.0999927520751953,0.0499993562698364 + ,0,0.0865936279296875,0.0866025686264038,0,0.0500202178955078,0.100000202655792,0,0,0.0866025686264038,0,-0.0500202178955078 + ,0.0499993562698364,0,-0.0865936279296875,0,0.0382691621780396,-0.0924110412597656,-0.0461935997009277,0.0382691621780396 + ,-0.0800132751464844,-0.0800102949142456,0.0382691621780396,-0.0462055206298828,-0.0923886895179749,0.0382691621780396 + ,0,-0.0800102949142456,0.0382691621780396,0.0462055206298828,-0.0461935997009277,0.0382691621780396,0.0800132751464844 + ,0,0.0382691621780396,0.0924110412597656,0.0461935997009277,0.0382691621780396,0.0800132751464844,0.0800102949142456 + ,0.0382691621780396,0.0462055206298828,0.0923886895179749,0.0382691621780396,0,0.0800102949142456,0.0382691621780396 + ,-0.0462055206298828,0.0461935997009277,0.0382691621780396,-0.0800132751464844,0,0.0707119703292847,-0.0707149505615234 + ,-0.0353559851646423,0.0707119703292847,-0.0612258911132813,-0.0612378120422363,0.0707119703292847,-0.0353336334228516 + ,-0.0707104802131653,0.0707119703292847,0,-0.0612378120422363,0.0707119703292847,0.0353336334228516,-0.0353559851646423 + ,0.0707119703292847,0.0612258911132813,0,0.0707119703292847,0.0707149505615234,0.0353559851646423,0.0707119703292847 + ,0.0612258911132813,0.0612378120422363,0.0707119703292847,0.0353336334228516,0.0707104802131653,0.0707119703292847 + ,0,0.0612378120422363,0.0707119703292847,-0.0353336334228516,0.0353559851646423,0.0707119703292847,-0.0612258911132813 + ,0,0.0923871994018555,-0.0382900238037109,-0.0191345810890198,0.0923871994018555,-0.0331401824951172,-0.0331416726112366 + ,0.0923871994018555,-0.0191211700439453,-0.0382676720619202,0.0923871994018555,0,-0.0331416726112366,0.0923871994018555 + ,0.0191211700439453,-0.0191345810890198,0.0923871994018555,0.0331401824951172,0,0.0923871994018555,0.0382900238037109 + ,0.0191345810890198,0.0923871994018555,0.0331401824951172,0.0331416726112366,0.0923871994018555,0.0191211700439453 + ,0.0382676720619202,0.0923871994018555,0,0.0331416726112366,0.0923871994018555,-0.0191211700439453,0.0191345810890198 + ,0.0923871994018555,-0.0331401824951172,0,0.0999987125396729,0 + PolygonVertexIndex: 12,0,1,-14,13,1,2,-15,14,2,3,-16,15,3,4,-17,16,4,5,-18,17,5,6,-19,18,6,7,-20,19,7,8,-21,20,8,9,-22,21,9,10,-23,22 + ,10,11,-24,23,11,0,-13,24,12,13,-26,25,13,14,-27,26,14,15,-28,27,15,16,-29,28,16,17,-30,29,17,18,-31,30,18,19,-32 + ,31,19,20,-33,32,20,21,-34,33,21,22,-35,34,22,23,-36,35,23,12,-25,36,24,25,-38,37,25,26,-39,38,26,27,-40,39,27,28 + ,-41,40,28,29,-42,41,29,30,-43,42,30,31,-44,43,31,32,-45,44,32,33,-46,45,33,34,-47,46,34,35,-48,47,35,24,-37,36,37 + ,-49,37,38,-49,38,39,-49,39,40,-49,40,41,-49,41,42,-49,42,43,-49,43,44,-49,44,45,-49,45,46,-49,46,47,-49,47,36,-49 + + Edges: 0,1,2,3,5,6,7,9,10,11,13,14,15,17,18,19,21,22,23,25,26,27,29,30,31,33,34,35,37,38,39,41,42,43,45,47,48,50,51,54,55 + ,58,59,62,63,66,67,70,71,74,75,78,79,82,83,86,87,90,91,95,96,98,99,102,103,106,107,110,111,114,115,118,119,122,123 + ,126,127,130,131,134,135,138,139,143,145,146,148,151,154,157,160,163,166,169,172,175 + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 101 + Name: "FBX_Normals" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + Normals: -6.22461948296404e-006,0.383476376533508,-0.923550665378571,-1.20797230920289e-005,1.57083519525258e-008,-1,-0.49996691942215 + ,-8.30873977974989e-006,-0.866044521331787,-0.46196249127388,0.38339900970459,-0.799747407436371,-0.865972757339478 + ,-2.85912301478675e-006,-0.500091135501862,-0.79977959394455,0.383569598197937,-0.461765050888062,-1,3.92718302322237e-009 + ,1.63370816608222e-006,-0.923507392406464,0.38358062505722,7.76776323618833e-006,-0.865978062152863,2.8749102511938e-006 + ,0.500082015991211,-0.799753725528717,0.383676499128342,0.46172109246254,-0.499969661235809,8.33687772683334e-006 + ,0.866042912006378,-0.461894154548645,0.383681386709213,0.799651443958282,1.20797230920289e-005,1.57083519525258e-008 + ,1,6.22461948296404e-006,0.383476376533508,0.923550665378571,0.49996691942215,-8.30873977974989e-006,0.866044521331787 + ,0.46196249127388,0.38339900970459,0.799747407436371,0.865972757339478,-2.85912301478675e-006,0.500091135501862 + ,0.79977959394455,0.383569598197937,0.461765050888062,1,3.92718302322237e-009,-1.63370816608222e-006,0.923507392406464 + ,0.38358062505722,-7.76776323618833e-006,0.865978062152863,2.8749102511938e-006,-0.500082015991211,0.799753725528717 + ,0.383676499128342,-0.46172109246254,0.499969661235809,8.33687772683334e-006,-0.866042912006378,0.461894154548645 + ,0.383681386709213,-0.799651443958282,-2.12229406315601e-005,0.708169221878052,-0.7060427069664,-0.353386223316193 + ,0.708029091358185,-0.611402451992035,-0.611564218997955,0.708067178726196,-0.353029847145081,-0.706117630004883 + ,0.708094537258148,6.50198217044817e-006,-0.611532986164093,0.70811802148819,0.352981954813004,-0.353312194347382 + ,0.708179593086243,0.61127096414566,2.12229406315601e-005,0.708169221878052,0.7060427069664,0.353386223316193 + ,0.708029091358185,0.611402451992035,0.611564218997955,0.708067178726196,0.353029847145081,0.706117630004883 + ,0.708094537258148,-6.50198217044817e-006,0.611532986164093,0.70811802148819,-0.352981954813004,0.353312194347382 + ,0.708179593086243,-0.61127096414566,-2.10131383937551e-005,0.924268066883087,-0.381744086742401,-0.191208526492119 + ,0.92419421672821,-0.33061209321022,-0.330713212490082,0.924225807189941,-0.190880656242371,-0.381774514913559 + ,0.92425549030304,-3.40132146448013e-007,-0.330691248178482,0.924237787723541,0.190860658884048,-0.19116373360157 + ,0.924241364002228,0.330506235361099,2.10131383937551e-005,0.924268066883087,0.381744086742401,0.191208526492119 + ,0.92419421672821,0.33061209321022,0.330713212490082,0.924225807189941,0.190880656242371,0.381774514913559,0.92425549030304 + ,3.40132146448013e-007,0.330691248178482,0.924237787723541,-0.190860658884048,0.19116373360157,0.924241364002228 + ,-0.330506235361099,0,1,0 + NormalsIndex: 0,1,2,3,3,2,4,5,5,4,6,7,7,6,8,9,9,8,10,11,11,10,12,13,13,12,14,15,15,14,16,17,17,16,18,19,19,18,20,21,21,20,22 + ,23,23,22,1,0,24,0,3,25,25,3,5,26,26,5,7,27,27,7,9,28,28,9,11,29,29,11,13,30,30,13,15,31,31,15,17,32,32,17,19 + ,33,33,19,21,34,34,21,23,35,35,23,0,24,36,24,25,37,37,25,26,38,38,26,27,39,39,27,28,40,40,28,29,41,41,29,30,42 + ,42,30,31,43,43,31,32,44,44,32,33,45,45,33,34,46,46,34,35,47,47,35,24,36,36,37,48,37,38,48,38,39,48,39,40,48 + ,40,41,48,41,42,48,42,43,48,43,44,48,44,45,48,45,46,48,46,47,48,47,36,48 + } + LayerElementUV: 0 { + Version: 101 + Name: "Texture" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: 0.833333313465118,0.875,0.16666667163372,0.875,0.5,0.75,0.833333313465118,0.625,0.16666667163372,0.625,0.5,0.5 + ,0.583333313465118,0.875,0.916666686534882,0.75,0.25,0.75,0.916666686534882,0.5,0.25,0.5,0.583333313465118,0.625 + ,0.0416666679084301,1,0.125,1,0.208333343267441,1,0.291666686534882,1,0.375,1,0.458333313465118,1,0.541666626930237 + ,1,0.625,1,0.708333373069763,1,0.791666626930237,1,0.875,1,0.958333373069763,1,0.333333343267441,0.875,0.666666686534882 + ,0.75,0,0.75,1,0.75,0,0.5,1,0.5,0.333333343267441,0.625,0.666666686534882,0.5,0.75,0.875,0.0833333358168602,0.875 + ,0.416666656732559,0.75,0.75,0.625,0.0833333358168602,0.625,0.416666656732559,0.5,0.5,0.875,0.833333313465118 + ,0.75,0.16666667163372,0.75,0.833333313465118,0.5,0.16666667163372,0.5,0.5,0.625,0.916666686534882,0.875,0.25 + ,0.875,0.583333313465118,0.75,0.916666686534882,0.625,0.25,0.625,0.583333313465118,0.5,0.666666686534882,0.875 + ,0,0.875,1,0.875,0.333333343267441,0.75,0,0.625,1,0.625,0.333333343267441,0.5,0.666666686534882,0.625,0.416666656732559 + ,0.875,0.75,0.75,0.0833333358168602,0.75,0.75,0.5,0.0833333358168602,0.5,0.416666656732559,0.625 + UVIndex: 54,28,62,36,36,62,42,4,4,42,10,48,48,10,56,30,30,56,37,63,63,37,5,43,43,5,49,11,11,49,31,57,57,31,61,35,35,61 + ,41,3,3,41,9,47,47,9,29,55,26,54,36,60,60,36,4,40,40,4,48,8,8,48,30,53,53,30,63,34,34,63,43,2,2,43,11,46,46,11 + ,57,25,25,57,35,59,59,35,3,39,39,3,47,7,7,47,55,27,51,26,60,33,33,60,40,1,1,40,8,45,45,8,53,24,24,53,34,58,58 + ,34,2,38,38,2,46,6,6,46,25,50,50,25,59,32,32,59,39,0,0,39,7,44,44,7,27,52,51,33,12,33,1,13,1,45,14,45,24,15,24 + ,58,16,58,38,17,38,6,18,6,50,19,50,32,20,32,0,21,0,44,22,44,52,23 + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygon" + ReferenceInformationType: "Direct" + Smoothing: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: 0 + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + NodeAttributeName: "Geometry::Sphere_ncl1_1" + } + SceneInfo: "SceneInfo::GlobalInfo", "UserData" { + Type: "UserData" + Version: 100 + MetaData: { + Version: 100 + Title: "Sphere" + Subject: "" + Author: "" + Keywords: "" + Revision: "" + Comment: "" + } + Properties60: { + Property: "DocumentUrl", "KString", "", "D:\moe\STUFFSUBMERGEUNIT\Sphere.fbx" + Property: "SrcDocumentUrl", "KString", "", "D:\moe\STUFFSUBMERGEUNIT\Sphere.fbx" + Property: "Original", "Compound", "" + Property: "Original|ApplicationVendor", "KString", "", "The Foundry" + Property: "Original|ApplicationName", "KString", "", "MODO" + Property: "Original|ApplicationVersion", "KString", "", "" + Property: "Original|DateTime_GMT", "DateTime", "", "29/01/2015 11:26:30.243" + Property: "Original|FileName", "KString", "", "D:\moe\STUFFSUBMERGEUNIT\Sphere.fbx" + Property: "LastSaved", "Compound", "" + Property: "LastSaved|ApplicationVendor", "KString", "", "The Foundry" + Property: "LastSaved|ApplicationName", "KString", "", "MODO" + Property: "LastSaved|ApplicationVersion", "KString", "", "" + Property: "LastSaved|DateTime_GMT", "DateTime", "", "29/01/2015 11:26:30.243" + } + } + Material: "Material::Default", "" { + Version: 102 + ShadingModel: "phong" + MultiLayer: 0 + Properties60: { + Property: "ShadingModel", "KString", "", "Phong" + Property: "MultiLayer", "bool", "",0 + Property: "EmissiveColor", "Color", "A",1,1,1 + Property: "EmissiveFactor", "Number", "A",0 + Property: "AmbientColor", "Color", "A",0.2,0.2,0.2 + Property: "AmbientFactor", "Number", "A",1 + Property: "DiffuseColor", "Color", "A",0.6,0.6,0.6 + Property: "DiffuseFactor", "Number", "A",0.8 + Property: "Bump", "Vector3D", "",0,0,0 + Property: "NormalMap", "Vector3D", "",0,0,0 + Property: "BumpFactor", "double", "",1 + Property: "TransparentColor", "Color", "A",0,0,0 + Property: "TransparencyFactor", "Number", "A",0 + Property: "DisplacementColor", "ColorRGB", "",0,0,0 + Property: "DisplacementFactor", "double", "",1 + Property: "VectorDisplacementColor", "ColorRGB", "",0,0,0 + Property: "VectorDisplacementFactor", "double", "",1 + Property: "SpecularColor", "Color", "A",1,1,1 + Property: "SpecularFactor", "Number", "A",0.2 + Property: "ShininessExponent", "Number", "A",256 + Property: "ReflectionColor", "Color", "A",1,1,1 + Property: "ReflectionFactor", "Number", "A",0 + Property: "Emissive", "Vector3D", "",0,0,0 + Property: "Ambient", "Vector3D", "",0.2,0.2,0.2 + Property: "Diffuse", "Vector3D", "",0.48,0.48,0.48 + Property: "Specular", "Vector3D", "",0.2,0.2,0.2 + Property: "Shininess", "double", "",256 + Property: "Opacity", "double", "",1 + Property: "Reflectivity", "double", "",0 + } + } + GlobalSettings: { + Version: 1000 + Properties60: { + Property: "UpAxis", "int", "",1 + Property: "UpAxisSign", "int", "",1 + Property: "FrontAxis", "int", "",2 + Property: "FrontAxisSign", "int", "",1 + Property: "CoordAxis", "int", "",0 + Property: "CoordAxisSign", "int", "",1 + Property: "OriginalUpAxis", "int", "",-1 + Property: "OriginalUpAxisSign", "int", "",1 + Property: "UnitScaleFactor", "double", "",1 + Property: "OriginalUnitScaleFactor", "double", "",1 + Property: "AmbientColor", "ColorRGB", "",0,0,0 + Property: "DefaultCamera", "KString", "", "Producer Perspective" + Property: "TimeMode", "enum", "",0 + Property: "TimeSpanStart", "KTime", "",0 + Property: "TimeSpanStop", "KTime", "",46186158000 + Property: "CustomFrameRate", "double", "",-1 + } + } +} + +; Object connections +;------------------------------------------------------------------ + +Connections: { + Connect: "OO", "Model::Sphere", "Model::Scene" + Connect: "OO", "Material::Default", "Model::Sphere" +} +;Takes and animation section +;---------------------------------------------------- + +Takes: { + Current: "" +} +;Version 5 settings +;------------------------------------------------------------------ + +Version5: { + AmbientRenderSettings: { + Version: 101 + AmbientLightColor: 0,0,0,1 + } + FogOptions: { + FlogEnable: 0 + FogMode: 0 + FogDensity: 0.002 + FogStart: 0.3 + FogEnd: 1000 + FogColor: 1,1,1,1 + } + Settings: { + FrameRate: "30" + TimeFormat: 1 + SnapOnFrames: 0 + ReferenceTimeIndex: -1 + TimeLineStartTime: 0 + TimeLineStopTime: 46186158000 + } + RendererSetting: { + DefaultCamera: "Producer Perspective" + DefaultViewingMode: 0 + } +} diff --git a/XnaPlugin/XnaPluginContent/sugar.X b/XnaPlugin/XnaPluginContent/sugar.X new file mode 100644 index 0000000..6c44e0a Binary files /dev/null and b/XnaPlugin/XnaPluginContent/sugar.X differ diff --git a/XnaPlugin/XnaPluginContent/textbox.png b/XnaPlugin/XnaPluginContent/textbox.png new file mode 100644 index 0000000..4e86302 Binary files /dev/null and b/XnaPlugin/XnaPluginContent/textbox.png differ