From 6341f881fada9794a137b4ab1117d048f32dbf2f Mon Sep 17 00:00:00 2001 From: iSmokeDrow Date: Thu, 14 Jan 2021 18:39:18 -0600 Subject: [PATCH] Updates and Bug fixes - Config.json IP corrected to avoid vague connection error - Config.json Properly implemented relative paths (replacing basic / implementation) - Config.json added DumpDirectory to the Grim section (used by DumpUpdater and SPR Generator) - Config.json implemented DumpUpdater SPR sections - Configuration\ConfigMan.cs GetByteArray and UpdateByteArray methods implemented to support use of Modified XOR Keys - Configuration\ConfigMan.cs GetDirectory logic reimplement to properly implement relative path usage - DB\DBEvent.cs database event arguments implemented to support upgrading DBHelper reporting through events - DB\DBHelper.cs missing table backup during export properly implemented - DB\DBHelper.cs missing table drop/restore during export properly implemented - DB\DBHelper.cs execute logic corrected and now supports open/closing connection and returning active DbDataReader - GUI/DumpUpdater.cs implemented - GUI/SPRGenerator.cs implemented - GUI/XOREditor.cs implemented - GUI/Main.cs altered to support DumpUpdater/SPRGenerator and XOREditor - GUI/MessageListBox.cs new constructer implemented to alter the message box to be a notice - Structures/Settings.cs updated to support new utilities and DBHelper updates - Structures/SprInfo.cs implemented to support SPR Generator - Tabs/Manager.cs updated to allowing clearing the Hasher tab like the other tab styles - Tabs/Styles/Data.cs check_locations method implemented to check misplaces files in a dump directory before a build to avoid vague errors - Tabs/Styles/Data.cs TS_File_New_Click event logic updated to check locations before indexing - Tabs/Styles/Data.cs insert_files logic improved to utilize update to DataCore so that single files/multiple files are processed accordingly (fixes backup crash loop when inserting many files) - Tabs/Styles/Hasher.cs Clear() logic implemented - Tabs/Styles/RDB.cs database related logic updated (now RDBTab hooks events from the DBHelper --- Config.json | 28 +- Configuration/ConfigMan.cs | 44 +- DB/DBEvents.cs | 50 + DB/DBHelper.cs | 296 ++-- GUI/DumpUpdater.Designer.cs | 185 +++ GUI/DumpUpdater.cs | 206 +++ GUI/DumpUpdater.resx | 144 ++ GUI/Main.Designer.cs | 48 +- GUI/Main.cs | 22 +- GUI/MessageListBox.Designer.cs | 5 +- GUI/MessageListBox.cs | 10 + GUI/MessageListBox.resx | 2313 -------------------------------- GUI/SPRGenerator.Designer.cs | 145 ++ GUI/SPRGenerator.cs | 258 ++++ GUI/SPRGenerator.resx | 120 ++ GUI/XOREditor.Designer.cs | 275 ++++ GUI/XOREditor.cs | 242 ++++ GUI/XOREditor.resx | 129 ++ Grimoire.csproj | 97 +- Properties/AssemblyInfo.cs | 4 +- Structures/Settings.cs | 59 +- Structures/SprInfo.cs | 53 + Tabs/Manager.cs | 4 + Tabs/Styles/Data.cs | 109 +- Tabs/Styles/Hasher.cs | 3 + Tabs/Styles/RDB.Designer.cs | 34 +- Tabs/Styles/RDB.cs | 57 +- packages.config | 8 +- 28 files changed, 2425 insertions(+), 2523 deletions(-) create mode 100644 DB/DBEvents.cs create mode 100644 GUI/DumpUpdater.Designer.cs create mode 100644 GUI/DumpUpdater.cs create mode 100644 GUI/DumpUpdater.resx create mode 100644 GUI/SPRGenerator.Designer.cs create mode 100644 GUI/SPRGenerator.cs create mode 100644 GUI/SPRGenerator.resx create mode 100644 GUI/XOREditor.Designer.cs create mode 100644 GUI/XOREditor.cs create mode 100644 GUI/XOREditor.resx create mode 100644 Structures/SprInfo.cs diff --git a/Config.json b/Config.json index c348c53..4edc343 100644 --- a/Config.json +++ b/Config.json @@ -1,19 +1,20 @@ { "Grim": { - "BuildDirectory": "/Output", + "BuildDirectory": ".\\Output", + "DumpDirectory": "", "Codepage": 1252 }, "Tab": { "Styles": [ "RDB", "DATA", - "HASHER", + "HASHER" ], "DefaultStyle": "NONE" }, "DB": { "Engine": 0, - "IP": "127.0.0.1", + "IP": "(local)", "Port": 1433, "Trusted": true, "WorldName": "Arcadia", @@ -21,17 +22,18 @@ "WorldPass": "", "Backup": false, "DropOnExport": false, + "ScriptsDirectory": ".\\Scripts", "Timeout": 0 }, "RDB": { "Struct_AutoLoad": true, - "Directory": "/Structures", + "Directory": ".\\Structures", "Encoding": "Western Europe", "LoadDirectory": "", "AppendASCII": true, "SaveHashed": true, - "CSV_Directory": "/CSV", - "SQL_Directory": "/SQL" + "CSV_Directory": ".\\CSV", + "SQL_Directory": ".\\SQL" }, "Data": { "LoadDirectory": "C:\\Webzen\\Rappelz US", @@ -48,19 +50,27 @@ "Type": 0 }, "Log": { - "Directory": "/Logs", + "Directory": ".\\Logs", "DisplayLevel": 0, "WriteLevel": 0, "RefreshInterval": 2, "SaveOnExit": true }, "Flag": { - "Directory": "/Flags", + "Directory": ".\\Flags", "Default": "use_flags_81", "ClearOnChange": false }, + "DumpUpdater": { + "OverwriteExisting": false + }, + "SPR": { + "IgnoreSize": true, + "ShowWarnings": true, + "ShowIgnored": true + }, "Localization": { - "Directory": "/Localization", + "Directory": ".\\Localization", "Locale": "en-US" } } \ No newline at end of file diff --git a/Configuration/ConfigMan.cs b/Configuration/ConfigMan.cs index 8c4403b..4dc9bed 100644 --- a/Configuration/ConfigMan.cs +++ b/Configuration/ConfigMan.cs @@ -139,7 +139,7 @@ public byte[] GetByteArray(string key) if (idx == -1) throw new KeyNotFoundException(); - int[] val = Options[idx].Value.ToArray(); + int[] val = Options[idx].Value; byte[] ret = new byte[val.Length]; for (int i = 0; i < ret.Length; i++) @@ -148,29 +148,35 @@ public byte[] GetByteArray(string key) return ret ?? null; } + public void UpdateByteArray(string key, byte[] array) + { + int idx = Options.FindIndex(o => o.Name == key); + + if (idx == -1) + throw new KeyNotFoundException(); + + int[] nArray = new int[array.Length]; + + for (int i = 0; i < nArray.Length; i++) + nArray[i] = (int)array[i]; + + Options[idx].Value = nArray; + } + public string GetDirectory(string key, string parent = null) { Option opt = (parent != null) ? GetOption(key, parent) : GetOption(key); - string fileDir = null; - string filePath = null; - string valStr = opt.Value; - - if (valStr.StartsWith("/")) //Only the folder name is given - { - string workingDir = Directory.GetCurrentDirectory(); - fileDir = workingDir; - valStr = valStr.Replace("/", "\\"); - } - else - fileDir = valStr; + string optPath = opt.Value; + bool isRelative = !Path.IsPathRooted(optPath); - if (fileDir == valStr) - filePath = fileDir; - else - filePath = $"{fileDir}{valStr as string}"; + if (!string.IsNullOrEmpty(optPath)) + if (!isRelative) + return optPath; + else + return Path.GetFullPath(optPath); - return filePath; + return null; } void parse() @@ -204,7 +210,7 @@ void parse() foreach (var item in val.Value.Children()) array.Add((int)item.Value); - value = array; + value = array.ToArray(); } else { diff --git a/DB/DBEvents.cs b/DB/DBEvents.cs new file mode 100644 index 0000000..09412ed --- /dev/null +++ b/DB/DBEvents.cs @@ -0,0 +1,50 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Grimoire.DB +{ + public class DBError : EventArgs + { + public DBError(string message) => Message = message; + + public string Message; + } + + public class DBProgressMax : EventArgs + { + public DBProgressMax(int maximum) => Maximum = maximum; + + public DBProgressMax(int maximum, string message) + { + Maximum = maximum; + Message = message; + } + + public int Maximum; + public string Message; + } + + public class DBProgressValue : EventArgs + { + public DBProgressValue(int value) => Value = value; + + public DBProgressValue(int value, string message) + { + Value = value; + Message = message; + } + + public int Value; + public string Message; + } + + public class DBMessage : EventArgs + { + public DBMessage(string message) => Message = message; + + public string Message; + } +} diff --git a/DB/DBHelper.cs b/DB/DBHelper.cs index 259a467..36f3778 100644 --- a/DB/DBHelper.cs +++ b/DB/DBHelper.cs @@ -3,6 +3,7 @@ using System.Data.Common; using System.Data.SqlClient; using System.Diagnostics; +using System.IO; using System.Collections.Specialized; using System.Threading.Tasks; using MySql.Data.MySqlClient; @@ -11,7 +12,8 @@ using Grimoire.Logs.Enums; using Daedalus.Enums; using Daedalus.Structures; -using System.Windows.Forms; +using Microsoft.SqlServer.Management.Common; +using Microsoft.SqlServer.Management.Smo; namespace Grimoire.DB { @@ -41,6 +43,21 @@ public class DBHelper : IDisposable Stopwatch actionSW; + public event EventHandler Error; + public event EventHandler ProgressMaxSet; + public event EventHandler ProgressValueSet; + public event EventHandler Message; + public event EventHandler ProgressReset; + + public void OnError(DBError e) => Error?.Invoke(this, e); + public void OnProgressMaxSet(DBProgressMax p) => ProgressMaxSet?.Invoke(this, p); + + public void OnProgressValueSet(DBProgressValue p) => ProgressValueSet?.Invoke(this, p); + + public void OnMessage(DBMessage m) => Message?.Invoke(this, m); + + public void OnProgressReset() => ProgressReset.Invoke(this, null); + /// /// Provides enumeration to the ConnectionState property /// @@ -80,11 +97,7 @@ public DBHelper(ConfigMan configManager, DbConType type = DbConType.MsSQL) { configMan = configManager; - string ip = configMan["IP"]; - string name = configMan["WorldName"]; - string user = configMan["WorldUser"]; - string pass = configMan["WorldPass"]; - bool trusted = configMan["Trusted", "DB"]; + connType = type; switch (type) { @@ -92,34 +105,61 @@ public DBHelper(ConfigMan configManager, DbConType type = DbConType.MsSQL) goto case DbConType.MsSQL; case DbConType.MySQL: - mySQL_conn = new MySqlConnection($"server={ip};database={name};user={user};password={pass}"); + mySQL_conn = new MySqlConnection(ConnectionString); mySQL_cmd = new MySqlCommand() { Connection = mySQL_conn }; break; case DbConType.MsSQL: - string connStr = $"Server={ip};Database={name};"; - - if (trusted) - connStr += "Trusted_Connection=true;"; - else - connStr += $"User ID={user};Password={pass}"; - - msSQL_conn = new SqlConnection(connStr); + msSQL_conn = new SqlConnection(ConnectionString); msSQL_cmd = new SqlCommand() { Connection = msSQL_conn }; break; } } - public async Task Execute(string text, DbParameter parameters, DbCmdType type = DbCmdType.NonQuery, bool keepAlive = false) + string ConnectionString + { + get + { + string ip = configMan["IP"]; + string name = configMan["WorldName"]; + string user = configMan["WorldUser"]; + string pass = configMan["WorldPass"]; + bool trusted = configMan["Trusted", "DB"]; + + switch (connType) + { + case DbConType.MySQL: + return $"server={ip};database={name};user={user};password={pass}"; + + case DbConType.MsSQL: + { + string connStr = $"Server={ip};Database={name};"; + + if (trusted) + connStr += "Trusted_Connection=true;"; + else + connStr += $"User ID={user};Password={pass}"; + + return connStr; + } + } + + return null; + } + + } + + public async Task Execute(string text, DbParameter parameters, DbCmdType type = DbCmdType.NonQuery) { try { - NewCommand(text); + NewCommand(text, parameters); + return await execute(type); } catch (Exception ex) { - MessageBox.Show($"An Exception has occured!\nMessage: {ex.Message}\nStack-Trace: {ex.StackTrace}", "Execute", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Information); + OnError(new DBError($"An Exception has occured!\nMessage: {ex.Message}\nStack-Trace: {ex.StackTrace}")); } return null; @@ -130,11 +170,12 @@ public async Task Execute(string text, DbCmdType type = DbCmdType.NonQu try { NewCommand(text); + return await execute(type); } catch (Exception ex) { - MessageBox.Show($"An Exception has occured!\nMessage: {ex.Message}\nStack-Trace: {ex.StackTrace}", "Execute", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Information); + OnError(new DBError($"An Exception has occured!\nMessage: {ex.Message}\nStack-Trace: {ex.StackTrace}")); } return null; @@ -149,7 +190,7 @@ public async Task Execute(DbCommand cmd, DbCmdType type = DbCmdType.Non } catch (Exception ex) { - MessageBox.Show($"An Exception has occured!\nMessage: {ex.Message}\nStack-Trace: {ex.StackTrace}", "execute", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Information); + OnError(new DBError($"An Exception has occured!\nMessage: {ex.Message}\nStack-Trace: {ex.StackTrace}")); } return null; @@ -157,37 +198,36 @@ public async Task Execute(DbCommand cmd, DbCmdType type = DbCmdType.Non async Task execute(DbCmdType type = DbCmdType.NonQuery) { - if (State == ConnectionState.Connected) - switch (connType) - { - case DbConType.MsSQL: - switch (type) - { - case DbCmdType.NonQuery: - return await msSQL_cmd.ExecuteNonQueryAsync().ConfigureAwait(true); + switch (connType) + { + case DbConType.MsSQL: + switch (type) + { + case DbCmdType.NonQuery: + return await msSQL_cmd.ExecuteNonQueryAsync().ConfigureAwait(true); - case DbCmdType.Scalar: - return await msSQL_cmd.ExecuteScalarAsync().ConfigureAwait(true); + case DbCmdType.Scalar: + return await msSQL_cmd.ExecuteScalarAsync().ConfigureAwait(true); - case DbCmdType.Reader: - return await msSQL_cmd.ExecuteReaderAsync().ConfigureAwait(true); - } - break; + case DbCmdType.Reader: + return await msSQL_cmd.ExecuteReaderAsync().ConfigureAwait(true); + } + break; - case DbConType.MySQL: - switch (type) - { - case DbCmdType.NonQuery: - return await mySQL_cmd.ExecuteNonQueryAsync().ConfigureAwait(true); + case DbConType.MySQL: + switch (type) + { + case DbCmdType.NonQuery: + return await mySQL_cmd.ExecuteNonQueryAsync().ConfigureAwait(true); - case DbCmdType.Scalar: - return await mySQL_cmd.ExecuteScalarAsync().ConfigureAwait(true); + case DbCmdType.Scalar: + return await mySQL_cmd.ExecuteScalarAsync().ConfigureAwait(true); - case DbCmdType.Reader: - return await mySQL_cmd.ExecuteReaderAsync().ConfigureAwait(true); - } - break; - } + case DbCmdType.Reader: + return await mySQL_cmd.ExecuteReaderAsync().ConfigureAwait(true); + } + break; + } return null; } @@ -215,7 +255,7 @@ public async Task ReadTable(string table) try { - Tabs.Manager.Instance.RDBTab.ProgressMax = rowCnt; + OnProgressMaxSet(new DBProgressMax(rowCnt)); int rowIdx = 0; @@ -227,6 +267,10 @@ public async Task ReadTable(string table) int sqlIdx = 0; + // TODO: implement null checking all possible sql fields + //if (iRow.IsDBNull(sqlIdx)) + // row[sqlIdx] = getDefault(iRow[sqlIdx].GetType()); + for (int i = 0; i < fieldList.Length; i++) { Cell field = fieldList[i]; @@ -346,7 +390,7 @@ public async Task ReadTable(string table) sqlIdx++; } - else + else //TODO: Fields defaults should be set by attempting to call Cell.Value when no value is present! { switch (field.Type) { @@ -383,35 +427,31 @@ public async Task ReadTable(string table) data[rowIdx++] = row; if ((rowIdx * 100 / rowCnt) != ((rowIdx - 1) * 100 / rowCnt)) - TabMan.RDBTab.ProgressVal = rowIdx; + OnProgressValueSet(new DBProgressValue(rowIdx)); } else - throw new Exception("dbRdr has no rows!"); + OnError(new DBError("dbRdr has no rows!")); else - throw new Exception("dbRdr is null!"); + OnError(new DBError("dbRdr is null!")); } catch (Exception ex) { - MessageBox.Show($"An Exception has occured!\nMessage: {ex.Message}\nStack-Trace: {ex.StackTrace}", "Read Table", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Information); + OnError(new DBError($"An Exception has occured!\nMessage: {ex.Message}\nStack-Trace: {ex.StackTrace}")); } finally { CloseConnection(true); - TabMan.RDBTab.ResetProgress(); + OnProgressReset(); actionSW.Stop(); - Logs.Manager.Instance.Enter(Sender.DATABASE, Level.DEBUG, $"{table} successfully loaded in {actionSW.ElapsedMilliseconds}ms"); + + OnMessage(new DBMessage($"{table} successfully loaded in {actionSW.ElapsedMilliseconds}ms")); } return data; } else - { - string msg = "Failed to open SQL Connection!"; - - MessageBox.Show(msg, "SQL Exception", MessageBoxButtons.OK, MessageBoxIcon.Error); - Logs.Manager.Instance.Enter(Sender.DATABASE, Level.ERROR, msg); - } + OnError(new DBError("Failed to connect to the Database!")); return null; } @@ -421,20 +461,16 @@ public async Task WriteTable(string table, Row[] data) actionSW = new Stopwatch(); actionSW.Start(); - Tabs.Styles.rdbTab rTab = TabMan.RDBTab; - int rowCnt = data.Length; - try { if (await OpenConnection()) { - if (configMan["DropOnExport", "DB"]) - await Execute($"drop table {table}"); - else - await Execute($"truncate table {table}"); + clearTable(table); DataTable dataTbl = generateDataTable(table); + OnProgressMaxSet(new DBProgressMax(data.Length, "Enumerating export data...")); + for (int r = 0; r < data.Length; r++) //loop rows { DataRow newRow = dataTbl.NewRow(); @@ -448,26 +484,28 @@ public async Task WriteTable(string table, Row[] data) } dataTbl.Rows.Add(newRow); + + if ((r * 100 / data.Length) != ((r - 1) * 100 / data.Length)) + OnProgressValueSet(new DBProgressValue(r)); } + OnProgressReset(); + executeBulk(dataTbl); - } - else - { - string msg = "Failed to open SQL Connection!"; - MessageBox.Show(msg, "SQL Exception", MessageBoxButtons.OK, MessageBoxIcon.Error); - Logs.Manager.Instance.Enter(Sender.DATABASE, Level.ERROR, msg); + return true; } + else + OnError(new DBError("Failed to connect to the Database!")); } catch (Exception ex) { - MessageBox.Show($"An error occured during the export!\nMessage: {ex.Message}\nStack-Trace: {ex.StackTrace}"); + OnError(new DBError($"An error occured during the export!\nMessage: {ex.Message}\nStack-Trace: {ex.StackTrace}")); } finally { CloseConnection(); - rTab.ResetProgress(); + OnProgressReset(); actionSW.Stop(); Logs.Manager.Instance.Enter(Sender.DATABASE, Level.DEBUG, $"{table} exported loaded in {actionSW.ElapsedMilliseconds}ms"); @@ -501,7 +539,7 @@ void executeBulk(DataTable table) int rowCnt = table.Rows.Count; long processed = 0; - Tabs.Manager.Instance.RDBTab.ProgressMax = rowCnt; + OnProgressMaxSet(new DBProgressMax(rowCnt, "Exporting data...")); switch (connType) { @@ -515,7 +553,7 @@ void executeBulk(DataTable table) processed += x.RowsCopied; if ((processed * 100 / rowCnt) != ((processed - 1) * 100 / rowCnt)) - TabMan.RDBTab.ProgressVal = (int)processed; + OnProgressValueSet(new DBProgressValue((int)processed)); }; } break; @@ -530,13 +568,13 @@ void executeBulk(DataTable table) processed += x.RowsCopied; if ((processed * 100 / rowCnt) != ((processed - 1) * 100 / rowCnt)) - TabMan.RDBTab.ProgressVal = (int)processed; + OnProgressValueSet(new DBProgressValue((int)processed)); }; } break; } - Tabs.Manager.Instance.RDBTab.ResetProgress(); + OnProgressReset(); } public async Task OpenConnection() @@ -633,6 +671,106 @@ string generateSelect(string table) return statement; } + async void clearTable(string table) + { + string scriptDir = configMan.GetDirectory("ScriptsDirectory", "DB"); + + if (configMan["Engine", "DB"] == 0) // This feature depends on MsSQL SMO and cannot be used on MySQL/MariaDB! + { + if (configMan["Backup", "DB"]) + await Task.Run(() => { scriptTable(table, true); }); + + if (configMan["DropOnExport", "DB"]) + { + scriptTable(table, false); + + await Execute($"drop table {table}"); + + string scriptPath = $"{scriptDir}\\{table}_{DateTime.Now.ToString("hhMMddyyy")}_so.sql"; + + if (await executeScript(scriptPath) == -1) + OnError(new DBError($"Failed to execute script: {scriptPath}")); + } + } + else + await Execute($"truncate table {table}"); + } + + void scriptTable(string tableName, bool scriptData) + { + Microsoft.Data.SqlClient.SqlConnection sqlCon = new Microsoft.Data.SqlClient.SqlConnection(ConnectionString); + ServerConnection svConn = new ServerConnection(sqlCon); + Server sv = new Server(svConn); + Database db = sv.Databases[configMan["WorldName", "DB"]]; + + string scriptDir = configMan.GetDirectory("ScriptsDirectory", "DB"); + + ScriptingOptions opts = new ScriptingOptions() + { + ScriptData = scriptData, + ScriptDrops = false, + ScriptSchema = true, + IncludeDatabaseContext = true, + FileName = string.Format(@"{0}\{1}_{2}{3}.sql", + scriptDir, + tableName, + DateTime.Now.ToString("hhMMddyyyy"), + (!scriptData) ? "_so" : string.Empty) + }; + + OnMessage(new DBMessage(string.Format("Scripting {0} {1}", tableName, (scriptData) ? "Data" : "Schema"))); + + if (db != null) + { + if (db.Tables.Contains(tableName)) + db.Tables[tableName].EnumScript(opts); + else + OnError(new DBError($"Database object does not contain table with key: {tableName}")); + } + + else + throw new NullReferenceException("Database object is null!"); + } + + async Task executeScript(string filename) + { + Microsoft.Data.SqlClient.SqlConnection sqlCon = new Microsoft.Data.SqlClient.SqlConnection(ConnectionString); + ServerConnection svConn = new ServerConnection(sqlCon); + Server sv = new Server(svConn); + + if (File.Exists(filename)) + { + string script = new StreamReader(filename).ReadToEnd(); //TODO: Check that the _so actually exists? + + if (string.IsNullOrEmpty(script)) + OnError(new DBError("Failed to load the schema (_so) script needed to restore the table!")); + else + { + if (sv != null) + try + { + return sv.ConnectionContext.ExecuteNonQuery(script); + } + catch (Exception ex) + { + OnError(new DBError($"An exception occured during script execution!\nMessage: {ex.Message}\n\nCall-Stack: {ex.StackTrace}")); + } + else + OnError(new DBError("Database object is null!")); + } + } + + return -1; + } + + object getDefault(Type type) + { + if (type.IsValueType) + return Activator.CreateInstance(type); + + return null; + } + #region IDisposable Support private bool disposedValue = false; // To detect redundant calls diff --git a/GUI/DumpUpdater.Designer.cs b/GUI/DumpUpdater.Designer.cs new file mode 100644 index 0000000..a2ce5d6 --- /dev/null +++ b/GUI/DumpUpdater.Designer.cs @@ -0,0 +1,185 @@ +namespace Grimoire.GUI +{ + partial class DumpUpdater + { + /// + /// 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.grid = new System.Windows.Forms.DataGridView(); + this.name = new System.Windows.Forms.DataGridViewTextBoxColumn(); + this.source = new System.Windows.Forms.DataGridViewTextBoxColumn(); + this.destination = new System.Windows.Forms.DataGridViewTextBoxColumn(); + this.exists = new System.Windows.Forms.DataGridViewTextBoxColumn(); + this.dumpDirTxtBox = new System.Windows.Forms.TextBox(); + this.dumpDirLbl = new System.Windows.Forms.Label(); + this.copyBtn = new System.Windows.Forms.Button(); + this.prgBar = new System.Windows.Forms.ProgressBar(); + this.statusLb = new System.Windows.Forms.Label(); + ((System.ComponentModel.ISupportInitialize)(this.grid)).BeginInit(); + this.SuspendLayout(); + // + // grid + // + this.grid.AllowUserToAddRows = false; + this.grid.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.grid.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize; + this.grid.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { + this.name, + this.source, + this.destination, + this.exists}); + this.grid.Location = new System.Drawing.Point(12, 44); + this.grid.Name = "grid"; + this.grid.ReadOnly = true; + this.grid.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.FullRowSelect; + this.grid.Size = new System.Drawing.Size(755, 418); + this.grid.TabIndex = 7; + this.grid.RowsRemoved += new System.Windows.Forms.DataGridViewRowsRemovedEventHandler(this.grid_RowsRemoved); + // + // name + // + this.name.HeaderText = "File Name"; + this.name.Name = "name"; + this.name.ReadOnly = true; + this.name.Width = 250; + // + // source + // + this.source.HeaderText = "Source"; + this.source.Name = "source"; + this.source.ReadOnly = true; + this.source.Resizable = System.Windows.Forms.DataGridViewTriState.False; + this.source.Width = 315; + // + // destination + // + this.destination.HeaderText = "Destination"; + this.destination.Name = "destination"; + this.destination.ReadOnly = true; + this.destination.Width = 65; + // + // exists + // + this.exists.HeaderText = "Exists"; + this.exists.Name = "exists"; + this.exists.ReadOnly = true; + this.exists.ToolTipText = "If yes the file already exists in the dump folder"; + this.exists.Width = 50; + // + // dumpDirTxtBox + // + this.dumpDirTxtBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.dumpDirTxtBox.Enabled = false; + this.dumpDirTxtBox.Location = new System.Drawing.Point(106, 15); + this.dumpDirTxtBox.Name = "dumpDirTxtBox"; + this.dumpDirTxtBox.ReadOnly = true; + this.dumpDirTxtBox.Size = new System.Drawing.Size(661, 20); + this.dumpDirTxtBox.TabIndex = 12; + this.dumpDirTxtBox.TextAlign = System.Windows.Forms.HorizontalAlignment.Center; + // + // dumpDirLbl + // + this.dumpDirLbl.AutoSize = true; + this.dumpDirLbl.Location = new System.Drawing.Point(12, 18); + this.dumpDirLbl.Name = "dumpDirLbl"; + this.dumpDirLbl.Size = new System.Drawing.Size(83, 13); + this.dumpDirLbl.TabIndex = 10; + this.dumpDirLbl.Text = "Dump Directory:"; + // + // copyBtn + // + this.copyBtn.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.copyBtn.Enabled = false; + this.copyBtn.Location = new System.Drawing.Point(692, 473); + this.copyBtn.Name = "copyBtn"; + this.copyBtn.Size = new System.Drawing.Size(75, 23); + this.copyBtn.TabIndex = 9; + this.copyBtn.Text = "Copy"; + this.copyBtn.UseVisualStyleBackColor = true; + this.copyBtn.Click += new System.EventHandler(this.copyBtn_Click); + // + // prgBar + // + this.prgBar.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left))); + this.prgBar.Location = new System.Drawing.Point(12, 473); + this.prgBar.Name = "prgBar"; + this.prgBar.Size = new System.Drawing.Size(100, 23); + this.prgBar.TabIndex = 8; + // + // statusLb + // + this.statusLb.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left))); + this.statusLb.AutoSize = true; + this.statusLb.Location = new System.Drawing.Point(118, 478); + this.statusLb.Name = "statusLb"; + this.statusLb.Size = new System.Drawing.Size(0, 13); + this.statusLb.TabIndex = 13; + // + // DumpUpdater + // + this.AllowDrop = true; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(778, 506); + this.Controls.Add(this.statusLb); + this.Controls.Add(this.grid); + this.Controls.Add(this.dumpDirTxtBox); + this.Controls.Add(this.dumpDirLbl); + this.Controls.Add(this.copyBtn); + this.Controls.Add(this.prgBar); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "DumpUpdater"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "Dump Updater"; + this.Load += new System.EventHandler(this.DumpUpdater_Load); + this.DragDrop += new System.Windows.Forms.DragEventHandler(this.DumpUpdater_DragDrop); + this.DragEnter += new System.Windows.Forms.DragEventHandler(this.DumpUpdater_DragEnter); + ((System.ComponentModel.ISupportInitialize)(this.grid)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.DataGridView grid; + private System.Windows.Forms.DataGridViewTextBoxColumn name; + private System.Windows.Forms.DataGridViewTextBoxColumn source; + private System.Windows.Forms.DataGridViewTextBoxColumn destination; + private System.Windows.Forms.DataGridViewTextBoxColumn exists; + private System.Windows.Forms.TextBox dumpDirTxtBox; + private System.Windows.Forms.Label dumpDirLbl; + private System.Windows.Forms.Button copyBtn; + private System.Windows.Forms.ProgressBar prgBar; + private System.Windows.Forms.Label statusLb; + } +} \ No newline at end of file diff --git a/GUI/DumpUpdater.cs b/GUI/DumpUpdater.cs new file mode 100644 index 0000000..d60bef6 --- /dev/null +++ b/GUI/DumpUpdater.cs @@ -0,0 +1,206 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.IO; +using System.Threading.Tasks; +using System.Windows.Forms; +using Grimoire.Configuration; +using Grimoire.Utilities; + +namespace Grimoire.GUI +{ + public partial class DumpUpdater : Form + { + ConfigMan configMan = GUI.Main.Instance.ConfigMan; + + string dumpDir; + + public DumpUpdater() + { + InitializeComponent(); + + grid.Columns[0].Width = 275; + grid.Columns[1].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill; + + dumpDir = configMan["DumpDirectory", "Grim"]; + } + + private void DumpUpdater_Load(object sender, EventArgs e) + { + dumpDirTxtBox.Text = dumpDir; + } + + private void DumpUpdater_DragEnter(object sender, DragEventArgs e) + { + if (e.Data.GetDataPresent(DataFormats.FileDrop)) + e.Effect = DragDropEffects.Copy; + } + + private async void DumpUpdater_DragDrop(object sender, DragEventArgs e) + { + string[] filenames = (string[])e.Data.GetData(DataFormats.FileDrop); + + if ((File.GetAttributes(filenames[0]) & FileAttributes.Directory) == FileAttributes.Directory) + filenames = Directory.GetFiles(filenames[0]); + + statusLb.Text = "Indexing..."; + + prgBar.Maximum = filenames.Length; + + await Task.Run(() => { process_files(filenames); }); + + prgBar.Maximum = 100; + prgBar.Value = 0; + + statusLb.Text = $"{filenames.Length} files indexed"; + } + + void process_files(string[] filenames) + { + for (int i = 0; i < filenames.Length; i++) + { + string filename = filenames[i]; + string name = Path.GetFileName(filename).ToLower(); + string dir = Path.GetDirectoryName(filename); + int extOffset = (name[name.Length - 3] == '.') ? 2 : 3; + string dest = name.Substring(name.Length - extOffset); + bool exists = File.Exists($"{dumpDir}//{dest}//{name}"); + + if (!grid.Disposing) + { + Invoke(new MethodInvoker(delegate + { + statusLb.Text = $"Indexing: {name}..."; + + DataGridViewRow dgvr = (DataGridViewRow)grid.RowTemplate.Clone(); + dgvr.CreateCells(grid); + dgvr.Cells[0].Value = name; + dgvr.Cells[1].Value = dir; + dgvr.Cells[2].Value = dest; + dgvr.Cells[3].Value = (exists) ? "Yes" : "No"; + + if (exists) + dgvr.DefaultCellStyle.BackColor = Color.FromArgb(255, 124, 124); + else + dgvr.DefaultCellStyle.BackColor = Color.PaleGreen; + + grid.Rows.Add(dgvr); + + if (i * 100 / filenames.Length != ((i - 1) * 100 / filenames.Length)) + prgBar.Value = i; + + if (grid.Rows.Count > 0) + copyBtn.Enabled = true; + })); + } + } + } + + private async void copyBtn_Click(object sender, EventArgs e) + { + if (MessageBox.Show("You are about to copy all the listed files into the choosen dump directory!\n\nDo you want to continue?", "Input Required", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) + return; + + bool copy = default; + + int total = grid.Rows.Count; + int count = total; + int failCount = 0; + + prgBar.Maximum = total; + + while (count > 0) + { + DataGridViewRow row = grid.Rows[0]; + + copy = false; + + string name = row.Cells["name"].Value.ToString(); + string sourceFldr = row.Cells["source"].Value.ToString(); + string extFldr = row.Cells["destination"].Value.ToString(); + string destFldr = $"{dumpDir}\\{extFldr}"; + string exists = row.Cells["exists"].Value.ToString(); + + string source = $"{sourceFldr}\\{name}"; + string destination = $"{dumpDir}\\{extFldr}\\{name}"; + + if (exists == "Yes") + { + if (configMan["OverwriteExisting", "DumpUpdater"]) + copy = true; + + if (!copy) + { + FileInfo srcInfo = new FileInfo(source); + FileInfo destInfo = new FileInfo(destination); + + string srcSize = StringExt.FormatToSize(srcInfo.Length); + string destSize = StringExt.FormatToSize(destInfo.Length); + + string srcDate = srcInfo.CreationTime.ToString("yyyy-MM-dd"); + string destDate = destInfo.CreationTime.ToString("yyyy-MM-dd"); + + if (MessageBox.Show($"{name} already exists in the dump!\n\n" + + $"Existing File: Created: {destDate} Size: {destSize}\n" + + $"New Info: Created: {srcDate} Size: {srcSize}\n\n" + + $"Do you want to overwrite it?", "File Conflict", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) + copy = true; + } + } + else + copy = true; + + if (copy) + { + if (File.Exists(destination)) + File.Delete(destination); + + if (!Directory.Exists(destFldr)) + { + copy = false; + MessageBox.Show($"The destination folder: {destFldr} does not exist!", "Directory Exception", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); + } + + if (copy) + { + try + { + statusLb.Text = $"Copying {name}..."; + + await Task.Run(() => { File.Copy(source, destination); }); + } + catch (Exception ex) + { + MessageBox.Show($"Could not copy {name}\n\nMessage: {ex.Message}", "Exception Occured", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + else + failCount++; + } + + grid.Rows.Remove(row); + + prgBar.Value = total - count; + + count--; + } + + if (failCount > 0) + MessageBox.Show($"{failCount} files could not be copied into the dump directory!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); + + prgBar.Maximum = 100; + prgBar.Value = 0; + statusLb.Text = string.Empty; + } + + private void grid_RowsRemoved(object sender, DataGridViewRowsRemovedEventArgs e) + { + if (e.RowCount == 0) + copyBtn.Enabled = false; + } + } +} diff --git a/GUI/DumpUpdater.resx b/GUI/DumpUpdater.resx new file mode 100644 index 0000000..108d183 --- /dev/null +++ b/GUI/DumpUpdater.resx @@ -0,0 +1,144 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + \ No newline at end of file diff --git a/GUI/Main.Designer.cs b/GUI/Main.Designer.cs index dc26863..279f628 100644 --- a/GUI/Main.Designer.cs +++ b/GUI/Main.Designer.cs @@ -40,8 +40,11 @@ private void InitializeComponent() this.aboutLbl = new System.Windows.Forms.Label(); this.ms = new System.Windows.Forms.MenuStrip(); this.ts_utilities = new System.Windows.Forms.ToolStripMenuItem(); - this.ts_bitflag_editor = new System.Windows.Forms.ToolStripMenuItem(); this.ts_log_viewer = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_bitflag_editor = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_dump_updater = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_spr_gen = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_xor_editor = new System.Windows.Forms.ToolStripMenuItem(); this.tabs_cMenu.SuspendLayout(); this.ms.SuspendLayout(); this.SuspendLayout(); @@ -139,32 +142,56 @@ private void InitializeComponent() this.ts_utilities}); this.ms.Location = new System.Drawing.Point(141, 5); this.ms.Name = "ms"; - this.ms.Size = new System.Drawing.Size(66, 24); + this.ms.Size = new System.Drawing.Size(186, 24); this.ms.TabIndex = 6; this.ms.Text = "menuStrip1"; // // ts_utilities // this.ts_utilities.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.ts_log_viewer, this.ts_bitflag_editor, - this.ts_log_viewer}); + this.ts_dump_updater, + this.ts_spr_gen, + this.ts_xor_editor}); this.ts_utilities.Name = "ts_utilities"; this.ts_utilities.Size = new System.Drawing.Size(58, 20); this.ts_utilities.Text = "Utilities"; // + // ts_log_viewer + // + this.ts_log_viewer.Name = "ts_log_viewer"; + this.ts_log_viewer.Size = new System.Drawing.Size(180, 22); + this.ts_log_viewer.Text = "Log Viewer"; + this.ts_log_viewer.Click += new System.EventHandler(this.ts_log_viewer_Click); + // // ts_bitflag_editor // this.ts_bitflag_editor.Name = "ts_bitflag_editor"; - this.ts_bitflag_editor.Size = new System.Drawing.Size(144, 22); + this.ts_bitflag_editor.Size = new System.Drawing.Size(180, 22); this.ts_bitflag_editor.Text = "BitFlag Editor"; this.ts_bitflag_editor.Click += new System.EventHandler(this.ts_bitflag_editor_Click); // - // ts_log_viewer + // ts_dump_updater // - this.ts_log_viewer.Name = "ts_log_viewer"; - this.ts_log_viewer.Size = new System.Drawing.Size(144, 22); - this.ts_log_viewer.Text = "Log Viewer"; - this.ts_log_viewer.Click += new System.EventHandler(this.ts_log_viewer_Click); + this.ts_dump_updater.Name = "ts_dump_updater"; + this.ts_dump_updater.Size = new System.Drawing.Size(180, 22); + this.ts_dump_updater.Text = "Dump Updater"; + this.ts_dump_updater.Click += new System.EventHandler(this.ts_dump_updater_Click); + // + // ts_spr_gen + // + this.ts_spr_gen.Name = "ts_spr_gen"; + this.ts_spr_gen.Size = new System.Drawing.Size(180, 22); + this.ts_spr_gen.Text = "SPR Generator"; + this.ts_spr_gen.Click += new System.EventHandler(this.ts_spr_gen_Click); + // + // ts_xor_editor + // + this.ts_xor_editor.Name = "ts_xor_editor"; + this.ts_xor_editor.Size = new System.Drawing.Size(180, 22); + this.ts_xor_editor.Text = "XOR Editor"; + this.ts_xor_editor.Click += new System.EventHandler(this.ts_xor_editor_Click); // // Main // @@ -211,6 +238,9 @@ private void InitializeComponent() private System.Windows.Forms.ToolStripMenuItem ts_utilities; private System.Windows.Forms.ToolStripMenuItem ts_bitflag_editor; private System.Windows.Forms.ToolStripMenuItem ts_log_viewer; + private System.Windows.Forms.ToolStripMenuItem ts_spr_gen; + private System.Windows.Forms.ToolStripMenuItem ts_dump_updater; + private System.Windows.Forms.ToolStripMenuItem ts_xor_editor; } } diff --git a/GUI/Main.cs b/GUI/Main.cs index e8ccdde..e729e90 100644 --- a/GUI/Main.cs +++ b/GUI/Main.cs @@ -13,6 +13,8 @@ namespace Grimoire.GUI { + // TODO: Update Grimoire to allow using proper relative paths ..\\..\\folder + public partial class Main : Form { readonly Tabs.Manager tManager; @@ -238,7 +240,7 @@ private void aboutLbl_Click(object sender, EventArgs e) string rCore_Version = FileVersionInfo.GetVersionInfo("Daedalus.dll").FileVersion; string aboutStr = string.Format("Grimoire v{0}\nDataCore v{1}\nDaedalus v{2}\n\nWritten by: iSmokeDrow" + "\n\nSpecial Thanks:\n\t- Glandu2\n\t- Gangor\n\t- InkDevil\n\t- XavierDeFawks\n\t- ThunderNikk\n\t- Exterminator\n\t"+ - "- Medaion\n\t- AziaMafia\n\t- ADRENALINE\n\t- Musta2\n\n" + + "- Medaion\n\t- AziaMafia\n\t- ADRENALINE\n\t- Musta2\n\t- OceanWisdom\n\t- Sandro\n\t- Smashley\n\n" + "And a very special thanks to everyone who uses Grimoire! Please report bugs you may find to iSmokeDrow#3102 on Discord!", gVersion, dCore_Version, rCore_Version); MessageBox.Show(aboutStr, "About Me", MessageBoxButtons.OK, MessageBoxIcon.Information); @@ -254,5 +256,23 @@ private void ts_log_viewer_Click(object sender, EventArgs e) { lManager.ShowViewer(); } + + private void ts_spr_gen_Click(object sender, EventArgs e) + { + using (SPRGenerator sprGenerator = new SPRGenerator()) + sprGenerator.ShowDialog(this); + } + + private void ts_dump_updater_Click(object sender, EventArgs e) + { + using (DumpUpdater dumpUpdater = new DumpUpdater()) + dumpUpdater.ShowDialog(this); + } + + private void ts_xor_editor_Click(object sender, EventArgs e) + { + using (XOREditor xorEditor = new XOREditor()) + xorEditor.ShowDialog(this); + } } } \ No newline at end of file diff --git a/GUI/MessageListBox.Designer.cs b/GUI/MessageListBox.Designer.cs index e5a338f..575bf39 100644 --- a/GUI/MessageListBox.Designer.cs +++ b/GUI/MessageListBox.Designer.cs @@ -28,7 +28,6 @@ protected override void Dispose(bool disposing) /// private void InitializeComponent() { - System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MessageListBox)); this.list = new System.Windows.Forms.ListBox(); this.yesBtn = new System.Windows.Forms.Button(); this.noBtn = new System.Windows.Forms.Button(); @@ -77,6 +76,8 @@ private void InitializeComponent() // // msg_grpBx // + this.msg_grpBx.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); this.msg_grpBx.Controls.Add(this.msg); this.msg_grpBx.Location = new System.Drawing.Point(9, 3); this.msg_grpBx.Margin = new System.Windows.Forms.Padding(2); @@ -89,6 +90,8 @@ private void InitializeComponent() // // msg // + this.msg.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); this.msg.BorderStyle = System.Windows.Forms.BorderStyle.None; this.msg.Location = new System.Drawing.Point(4, 17); this.msg.Margin = new System.Windows.Forms.Padding(2); diff --git a/GUI/MessageListBox.cs b/GUI/MessageListBox.cs index 52c7d98..29677a4 100644 --- a/GUI/MessageListBox.cs +++ b/GUI/MessageListBox.cs @@ -25,6 +25,16 @@ public MessageListBox(string title, string msg, string[] filePaths) //localize(); } + public MessageListBox(string title, string msg, List items) + { + InitializeComponent(); + Text = title; + this.msg.Text = msg; + list.Items.AddRange(items.ToArray()); + yesBtn.Visible = false; + noBtn.Text = "Ok"; + } + private void populateList(string[] filePaths) { foreach (string filePath in filePaths) diff --git a/GUI/MessageListBox.resx b/GUI/MessageListBox.resx index b326db1..1af7de1 100644 --- a/GUI/MessageListBox.resx +++ b/GUI/MessageListBox.resx @@ -117,2317 +117,4 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - - AAABAAQAEBAAAAEAIABoBAAARgAAACAgAAABACAAqBAAAK4EAAAwMAAAAQAgAKglAABWFQAAAAAAAAEA - IADV4QEA/joAACgAAAAQAAAAIAAAAAEAIAAAAAAAAAQAABMLAAATCwAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAHm6YAChgfQAYRGMPHz9YcxEyTswXLlN+Jz1fNg0pQA8EHigAAAAAAAAAAAAAAAAAAAAAAAAA - AAAOUoYAHmWOAAC1/wImZoY6KERWriQ3RfcfPVL/GkFr+jdUf+geQ2Z5AAEAAQAAAAAAAAAAAAAAABhZ - jQAOXZAAPlNZAB1plCEsWnSJMEZS6So8Qv8aKTL/JzpC/hhRef07XZD+M1qF0xA5VR8BERoAAAAAAAAA - AAAeYoYACGSeDyVggGYsTWHTM1Ne/yQ9S/8nOkP/GSgy/x0sNv4bRGL9J0+C+0NqnPggTnVvAAAAAAAA - AAAAAAAAFl+KSiJNabYvRlL6Jj5K/yZZb/8iVHH/O1JX/z5PUf8zQkv/IkZc/iFQffxBa6H8MWGQxw45 - VxYABQgAAAAAAENda9okP0//JDhG/y5KVv8xYHn/Q2t8/05uav9CZ1v/T2Nf/z5kav4bVX38L12V+j1u - pfMdUXpeJHi4AAAAAAB1XFGYLkFN/x0vO/9MZWD/S2dp/0htgP8xXHH/Wnhx/1hxbP8yYXv/J1Js/RlP - hfo5aan5KGCUtw42VA4CAAIAlG1YQkVSW+40SFL/S3F1/1d+aP8wXHn/JVF2/0VtgP9HdID/HFN4/yE8 - TP0bXYb7JV+i9i9op+sYUHxNE0d2ANh/SA1gX2O6RV9m/1tvY/9Yf3//P3mS/0Fzav9GbHD/Z39v/yVK - Y/4cLT79LVNn+xhdmfYsY6v0H1uTow4vUApnGkwAgGtqbUFle/5GcIH/WoWK/1l7ef9Zf33/ZIJ+/01o - af8dPFj+GjJQ/StCW/ojVIP2HVSg8SFfpNsTSnxF/85DAKt8byhOZn3lHVaE/ydfjv9edGv/U3R7/z1w - jv8qVnv/MFFq/ilEZP0uVnv6OnCe9leHuPBIf7zrJ2KaoAAAAADZqo8FcHSDpylPcv8YPGP/I0pu/yVW - f/8xcpL/LlV3/zJaef5Gjqz9dqnG+6DF3fqfxODqhqvSqVuGtk4AAAAAupSQAI6FjVg+Zob6HkJo/ytX - ff8uUnP/MmWG/0WPr/93utf/q9fs/7DP5/WXudu3faLNUXmZxQ0+b6YAAAAAAP//YwC7mZYaXnqU1idc - hP8wYIX/RI6v/3HB3f+r2u//uNTr+KC/37yHq9RXcpnJDnmdywCAossAqc3cAAAAAAAAAAAA/8eRAXKQ - p5BDkLj/c7nY/63b8P+82O73p8TivYyu11lwmMoPiqvWAIGm0ACt0t8AAAAAAAAAAAAAAAAAAAAAAPi1 - lQByuuI8b6ze2JnF6PWiwuPUj63WaHGWyROTsdsAgKbRAJzH2gAAAAAAAAAAAAAAAAAAAAAA/A8AAPAH - AADgBwAAgAcAAAADAAAAAwAAAAEAAAABAAAAAAAAgAAAAIAAAACAAAAAwAEAAMAHAADAHwAA4H8AACgA - AAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKYWEAIT1UAAALPQAcOlEwEDBJqQwiO5oUKEctGDE8Ay4/ - ZQAXLUgAECg8AGg9OQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALmaEABFplQAiPVQUH0BbcBs+WdoaQFz+CyxK/A8n - TN4kOFycLkBjUBctSC0SKj4iACZKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMVhzACBqkAA5YXoCGGGIQBlCXL4wPUj8JkBU/yQ5 - Sf0PPFv9DyxT/iZCb/89VH70JkFo5w81U7MfLz0PRAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ1dlACNjhwAOh8AAIG2WIyFqj40qV27qNDpA/yQt - Nf8WOE3+NzIx/R5Rbf0OSnD8HDtt/EdllPtFYZH7Hkpy7xQ1TE4SMEUAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1EMAACFUeQAXb6AAH2WNER9ul2koY4DWNktW/zUz - N/8lLzf/Fiw6/hcdIf4mMzn+NEdQ/RBumP0SN2X8OFiM+1VzofkzWYj6FD9fqiAmMwn/AAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtbdwAebpgAH0RpBRtsmEgka4+6M1Zo+zk9 - Qf8sMDT/KT43/x9CUf8ZOkv/HBwd/hsqMf45ODb+G2aL/Q1LdfwkRn77T3Gi+kttnfgdTnjoFTVMQBgp - OwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEZabQATVoUAAHXuAB9vmywTXImZKVp18DpJ - U/8xOkX/HzE//yI7S/9JWE//KD1J/xojKf8ZJCv+FyUt/iM2Qv4nSF/9Ckp2/RQ1Z/s+ZJz6VXen+DJe - j/oUQmKaJh8sBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeTnsAAFGQABBXixYUZpZ1KWqJ3jZN - W/81OUD/MFtn/ztvcv8aPlP/HDdJ/x4vPv8nNED/GCIp/xUrOv8YKTX+Gi45/jFBS/4RS3b9DzZi/CxR - jPpMcqf5SnCj+RxRfOEUMUoyIyEzAAAAAAAAAAAAAAAAAAAAAAAAAAAADWOUABtHeggLVo1SFFqGxC1R - Zv04PkT/KDA5/xszRP8oVmj/R3mC/yBRbP8aSmP/GjdO/ytCSP8xRUX/LT9N/x4qOP8VICn+KDpE/hhF - Zf0vYoj8H0R6+kNrpPlUe6z5MGOV+RRCY4otFiMCAAAAAAAAAAAAAAAAAAAAAAAAAAAOZpc1E12NoCJO - bPQzRE7/LzU9/zBERf8wUU//GjpP/x1PZf8bVXj/IVp9/ydcf/84XHH/dHNW/2ltU/9VZWT/X2hp/0BR - XP4YPFP+IlJr/SJZfvwQPW37M16Z+k95r/lGcqj4HFR+1xUuSCYtGisAAAAAAAAAAAAAAAAAAAAAAC96 - nNYqVm7/Kkxf/x84SP8dQlz/Lkxd/zVDSf8fQFP/IFl1/xxXff8YWX//Q2h7/2p6Zv9GZmr/F0pk/w1A - Xf8nS2X/eHVS/0RraP4cVHL+G1B1/Shfh/wnUor6RXKs+Ut2rvYtZZj2E0BieUcCBwEAAAAAAAAAAAAA - AAAAAAAAlGFKqkVRWv8kSmD/Gycv/xwvP/8mNkL/KzxK/zVYZv85b4z/OF53/0FwjP9jcWr/UnBw/ylh - bf9ngDP/Vnpa/yBMbP92c1P/bXJP/ydmhf4WUXP9GV2J/BNFevs0YJ75SHex9j5wqvcaVH7MFilFHDoN - GQAAAAAAAAAAAAAAAAC8bENRZ1JL9C5QY/8cJSv/GyMo/xgqNv8jPkT/b4Nv/3R7Y/9tdGH/eIh//1aK - lv8kT3H/RW91/7GyaP95j4L/PWVz/3l6Vv8/aoL/LF+D/iVLX/4zbY39D0h3+xtEgflDdLL2RXOx9Sdl - mfITPV9p/wAAAAAAAAAAAAAAAAAAANWWcRSJWUPHNllt/yM4RP8ZLDv/GzdL/1dxaf9temL/M1tx/xhF - Zv8wVHf/QnKT/x9Lb/8TRGj/HE5y/z5gdP91eFP/Vnd5/yxojv8iVXv+ID1N/j5UZf0OXpb7DDdv+TNi - pvY/cbH1NGyr9RdTfL8ZJEEURgAAAAAAAAAAAAAA////AJlyXX5MXWj/K0td/xorOP83Slb/aYR8/yVi - eP86bUr/O2xU/xpNb/8wWHv/KU5u/yhMcf8/bo3/V4eO/0t4f/8iZI3/E1yI/xRTf/4WM0b+MERO/Rpc - iPwLY5n6HkqO9zpusvQ4a6/zImSZ7BM6XVgAQHcAAAAAAAAAAAD24s4AyH9TNXZZTe0xWG3/HCs2/1Rk - Z/9UcHn/N21//7q/Yf+YrYX/KVh4/zphff8zXHj/I1F2/zRii/9vgnr/cINp/ypgh/8lZI//IUFZ/hkl - Lv0fRFf9NFBd/A+EvfoPSYT3MWSr9ThssfMta6vzFVB6rxsePA21AAMAAAAAAAAAAADis40Km2JGtj9c - bv8nRFn/YGxm/1t0b/8WS3b/NWeD/zNlgP8+dpb/L2eL/x9WdP8QUGb/D0hr/zddd/+Dg1P/SYGV/zB2 - mf8bNUr+GTRL/Ro2R/xBRET8IXCZ+gpspfceTZb1NGuz8jJosPAaYJXjEzZcSAgpWQAAAAAAAAAAALVH - AQCudlhpUmNx/SxZc/9Pamf/joA7/2RyYP9fcWD/apqS/2WvtP8hYIr/RX5t/4qlOf9ciXr/Ml1+/4+I - Uf93knn/LFBj/xUwSf4YLkX9HiQx/StEVfw+Ul76EHqz9w8+f/UpX63yMmix7yRmp+4TTHmeIRg+CAAA - AAAAAAAA///9ALWZhiV8ZmThMl96/zpqhP91gm7/Y3Zo/2WAcP9rmo7/f5F4/x9WgP9ljob/rryB/1qB - jP9Ye3r/h4dQ/zVdZ/8XLUf/FidD/hojN/0bITT9GzRN+0RGTvkyYob3EUmB9BtNnPItZrPuLGWv6hlb - kNkUL1o5GRxPAAAAAAAAAAAA/8+sBKlsWqFFYHj/KmSJ/yJmnv8gXpT/PYCo/1N9lP+Ehlf/P2d7/xlS - gf8pXYX/WXh+/3qOe/9Hb4H/Kk1r/yNEZf8UOGH+Hkx1/h8+Y/0dMEv7MFBx+TdWdfcaXJH0Dz+I8iVe - r+0rY7HpIGan6RNIeIwmED8FAAAAAAAAAADhtZYAxIJqU2ZkcfkvXnz/FE1+/yRzp/8qbp//KGqe/3iF - bf+UjUn/e4dk/3iLfP9ohIj/NmSK/zZpi/8pSGr/PWFo/zVqdP4fTHb+HDRW/SZOcfsnW4j5I1yP9xpZ - kvUgVI3yJFil7SRgsegfXq3nFFyTzBIsXzIAAAAAAAAAAP///wDQoo4Yfnd+0jZqif8kSW3/Hk12/xVI - fv8eWJD/UHSD/1BsaP9McX7/O2uO/x5dkP8dX5b/IlV+/x9Md/84WXf+L0Vg/iQ0Vf48RWD9Q1Vr+zJd - hfkwa5/3VIav9ISwzfKOt9fueajS6VeJw+Ypb6nlIkx+iwAAAAAAAAAAAAAAAJn//wGsgXiMTmyG/yxX - eP8YMlb/Gjxj/xU4YP8ZNFj/I0Ru/ydUf/8mWof/MH2i/12noP8lYYn/IUFo/yE2WP45RWL+SF5z/jOB - m/0yf6j7V4u0+ZC10Perz+T1sdfq8q/U6fCewt/tf6TO4WSMvalafqdPAAAAAAAAAAAAAAAAp97sAMyS - gT90cYDyM2mK/xtCaf8cQ2n/Fzti/x1HcP8kTG7/HUxw/x5Qff8eYIn/On6e/ypWev84SGf/SFty/zR9 - mP4op8/+UsHn/Y3A2/yx0uX6udvt+LPY6/agxOD1hKjR63eayLJ/oMlTqMTbDzVUiAAAAAAAAAAAAAAA - AAAAAAAA4LusDpx7fcE9cpT/J1Bz/xszU/8ePF//HU99/0x9jf83a4P/IEhx/yRIbv83TnD/SWB3/zZ+ - mP8kj7z/Vrjg/pvP6P632er9w+Dv/MLf7vutzeX8i6/W8nWaybp0mMVZn8HYEHCKwQCbvNUAaZSyAAAA - AAAAAAAAAAAAAAAAAAAAAAAAppKTdE9+nf4xZon/HTte/yhVgP8kX5H/KEx1/yZCaP81S23/SmF5/zqB - m/8np87/UL3l/5PK5v+72uz+xuLw/sXh8P200uj/krTZ+HygzsF+os1dm7/YEmWDvgCcvtgAYKXDAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP379ADMqJ8tgn6N5zd1mf8hTHT/HT9m/yFDbP80TXH/SWJ9/zyA - m/8lpcz/Qr/o/4zO6v++2+3/yePx/8nk8v651ev/l7jc+n6j0cV9o89hmb/YE2WGxACavtgAf7jPAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPDPwwariIqsRXqd/yp2ov8maJb/RWSA/zx4 - lv8oncb/Rr/o/4XO7P+43O7/yOTy/8vm9P++2e3/nLve+4Gk0sd9pNBklb3YFWOFxgCbwNoAi7/SAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37GiAMqYkF1mfpn7PnOT/zdz - lf8ok7//R7Xg/4zM6f+93e//y+b0/83o9f/C3PD/ob7g/ISm08p9o9BmkrnXFV2AxQCawNoAe7fLAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8A2a+nHW6d - uNkhmsz/RafW/4nI5/+93/D/zOj1/8/q9//F3/H/pMDi/Ian1Mt+otBoj7fWF1Z3wgCZvtoAiMHSAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AADh8vQCg9LxkWis3f+fxeX/ttju/8Lh8//E3vL/psDi+4ik0st9n85qjbTVGFNywACYvdoAlsrYAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAODi5QCTvuclToTSk1WR1s5intrqZaTa8G+g09Npj8R5hq/SHExiuQCXvNkAnM3bAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//4P///4 - Af//4AD//8AA//8AAH/8AAB/+AAAP+AAAD+AAAAfAAAAHwAAAA8AAAAPAAAADwAAAAeAAAAHgAAAA4AA - AAPAAAABwAAAAcAAAADgAAAA4AAAAOAAAADwAAAB8AAAB/gAAB/4AAB/+AAB//wAB//8AB///AB///4B - //8oAAAAMAAAAGAAAAABACAAAAAAAAAkAAATCwAAEwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAQ2R2AB8/VgAxTV4KFDVOYw0pQLQVJDpIOFVkBBMmSQAmPFcARmx+AAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAF+EiwAkP1UA////ASVFWjQYOVKjEjRN8g4vSP8GGjflESVInxgtTU0mPVYTIyNfACI1 - VgAPIzoACx4xADhQXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAD/81EANWyIAAA2ZgAoQVUbIUBafhg6VuMdRGD/HkVh/hpGYv0GKEb+DiVM/xcu - VfQqPWDIL0FkgSM2VTsVK0E2FSs+QEdfawMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEhmcwAhYoYASmRyAxhGY1EUPFnLLUZa/i44Q/8hP1f+HzZJ/RNB - YP0LOlj9CiRK/Bg2Zf0sRW//PVN7/S5DauobNFfnCS9K3R0uPzI6Q08AAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEVmMAJ2B/AACD0QAlYoMlH26VkBJXe+4oPkv/PDEu/ipA - T/4cTmv+QS8l/SEyQf0SS2/9Di9Q/BQyY/wmRnf8SWWS+0dikPoxS3n6FUht+hMxSIlSV14DAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5ddwAZbZgAKl15EiFrkm0ebZXYKVx1/z09 - Pv8+Njb/HSs1/hMsPP4OMUj+MDhA/kMyKP0PaJj9EmmM/QwqVPweQHb8QF+P+1RyoPpGYpL5JlB++RNB - XtcfLD4mS05aAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHY3IAImaLADVPYAYjZ4xMHW6YvSRn - iPs4SFD/Qjg1/zQ2O/8hKC//FCMt/xYbIP4aGRj+GTtM/kguIP0jU239EYOx/Qw9YPwWNmv8MVKH+1Jx - n/pVc6H5N1aJ9xdJb/YULkR5fnZ7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAX29vACBZfQAA//8AJGOGLx5t - mJwhb5bxMlVm/0I8Ov88OT7/JSoy/xkiK/8lQlP/GUVd/xcyQf4bGBb+Fyw1/jE5Pv5BODL9D3Sp/RFp - jPwOK1n8JEiC+0hpm/tYeKX5TGqa+CRUhPgSP1zMIy5AHFRPXgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtX30AAFCPACRY - ehgeapR4H3Oe4Ctkfv9AREb/QTs8/ywyOf8eJSz/J0I0/yFHQ/8fRlv/Fj9U/xsjJv8eHBv+HB4f/ho/ - Uf5LLx7+H1V2/RGCsf0MOmD8GTt0+zpelftSdKT6WXqm+DVZjvYWUHf0FS5FaQAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALFRwAB5r - kgAxVW4KE1OAVg1ajMcjao79PE9Y/0Q7Ov8zNz7/Hyw3/x0vPP8hPE//doFm/0dcVP8dM0P/Ghwg/xka - G/4ZHyP+Gxsb/hUuOv4tOEH+L0FQ/QtWhf0HOV78Dixe+ytRjftJbaP6WXyp+UtrnfciWIj5ETxZwCgx - QxRXZW8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1X - YAAZVoMAokILASRojDcfdaCpGGaT9SxPYv9FQD//OUBH/yZLY/8kRl7/HjxN/xk1R/8hPlL/ICs2/xsi - LP83VGb/GyMp/xQvPv8aNEP/FTNG/hUlMP4XQFj+Pzg2/hRUf/0SWYf9CyZN/BtBffs/ZZ/6THGm+Vl8 - qfg2XZX3FVB28BYsRFkDDS0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AABNaXoAJ1t/AABZpwAgV38fDVqNhhx0oeYtZn//QkdI/0A9QP8rNT//IlNm/0qSjP9Adm3/EztW/x06 - T/8aLjz/HDVG/y5BU/8kKjD/GxkY/xMpNf8XJjD/Gi07/hsgJP4WM0L+ODw+/iBJZP0NQ3H9Czti/A8x - ZfszWpf6RWqk+VV7qvlLbqP3IV2O+RE6WLIsNEgNb3uFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAADVnhgAKUYoAL1x8Dg9XimEIXpTPF1yC/ztNVP9EPj//MzhB/yEqMv8XM0f/G0lh/12C - e/9UgIP/JFt7/xdLYf8ZUm3/GC09/xYmMf8XMD//FjNF/xQuRv8RKkT/Exsm/xkZGv4ZIST+IkJT/jk3 - OP0CQ3T9L2SJ/DVUevsdQn/6RW2m+U11qflYf634NGKa9xRQdeoZK0RKGCI9AAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAHGqYAH2GiAIUUYQ+CU+IsQ9bivgvUGH/RkBA/zk7Qv8hKjL/Eycx/x4+ - Vf8XNEf/I0ld/xhfgf8rY4P/I1Bs/xpJZf8nUm7/FD9o/zxiev9kbk7/am1C/29vVP9mbGb/SVpp/x43 - Vv4SHCv+FzdH/jA8RP4TWn/9NWuP/CNVf/sLMmv6PGWh+khyqvlXgbD5SG2m9yFhkPgSN1WkNjxQCAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHGaSJRJejIYQYpbqI05r/z5DRP83PUP/KjI8/x0s - Of9AXFX/THla/x8/VP8bNUj/HVJo/x1IW/8WUXv/HmKK/y1ihP8pYoj/LFx4/2hrWf+EeFD/cXFb/0xk - Y/9GXmj/am1p/316Z/9BXnL+DzVS/h9EW/4jWXP9Ill9/RNAaPwKN2X7JE+O+kp1rflNeK34Unqu9zNn - n/YTT3TkGipEOykxSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG4m4yA9rmv8yT1v/OERK/x5O - bP8cLTb/Hj9W/xlHZf9CWGP/SVNS/xwoMv8cS2L/F1hz/yBZfv8YUnz/EF2E/x9Oaf9JdpH/XW5l/4B/ - V/9JanT/Gk5w/w49Xf8OQ2X/ETJS/1txc/+Icz3/SHZ8/g9Tdf4pUWn9Fktw/Slfhvwsa5H8GEV/+0Ft - qPlHc634T3uv90JqpvUfZJL3ETNSlEFFVwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc4eMu1JW - XP8uUmT/IVh3/xU+VP8kMj3/IElp/x9DXP8iOk7/JDVF/zVJW/8fPUz/MGF7/y1mjP8fUW//I2mR/yZT - fP9vd2X/foZj/zJtfv8QQ2H/GVNb/xBEOv8TSWD/EkVm/ztkfP+GcDH/fG0s/y57lP4ZT2/+GVJ2/RBJ - c/0wapL8JUt7+idQkflHdbD4R3Wu90l0rvUxa6L1Ektw3B0rRjA/SV8AAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAwHdSYolHKvgqWHL/NE9f/xkrN/8bHiL/Gyk0/xofI/8xQk3/MkRS/yAtM/9Ke4v/N3WW/zds - k/82U2z/VXqQ/0R3lv95bk3/Ynt5/xZOcP86dHT/eooZ/5uhNf9kimv/EUBj/0deb/+LgE//cmc6/1uD - hP8YXoX+HU9q/Q9diP0XW4n8CEd7+xA2dPpAbqz4RXSw90p5sfY+a6n0HGSR9BIwUIRPVWgCAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAxJ+LHqhWL9NBUV7/N1Zm/x45Sv8bGxz/Gx0f/xooMP8YJCv/Fxwe/y9n - cf9/koL/dHlf/3V2VP+GgVn/j4Zi/1qSlv9Ogpf/NVJs/xlNcP9wkH//3clJ/97Tgf+Hl5D/GlBx/2p+ - eP+Eby//SW2B/zVmkP8pXoH+JUdc/iRhff05faT8E1iE/AcwY/orV5r4RXaz90d3svZFca/0LG6l9RFH - a9IgK0ckWGl7AAAAAAAAAAAAAAAAAAAAAAAAAAAA0fn/ArluRo5sSTz/K1x2/y5LW/8ZICX/HSMn/xo9 - VP8UL0D/IktZ/2h9YP+Ofkn/eoBw/0xnav89WWz/X3CC/3OSoP9emaP/Ekd3/xBDZP8iVXf/U3iE/0l0 - hP8mT2j/Q295/4SBUv9ifXf/LHKZ/yhiiv8nUnT+GEVb/kFCQf1Fb4/9DE+G+wIqWfoTOnz4Pm+x90Fz - svVDc7H0OGqq8xljj/ITLE10jqGnAQAAAAAAAAAAAAAAAAAAAAAAAAAAztbTAMOKaEOUUDHzKl57/zpU - Yf8aLzz/GS9A/xcqOv8eO0//Vnd+/4WEVf9WdXf/IlR4/ww+Y/8PRWr/FDdb/ydYh/80ZY//KlZ2/w82 - XP8RR2v/CTpc/x1Lc/9dcHb/jH1F/3d9Vf9Ab4r/M2eI/yxnjv8hT3f+FDJC/jRGT/0/WGr9CXG1/BFW - hvsGKWH5LFuh9z1vsfU+cLD0O2qu8yhwp/QRQmfGJC5LGoaPmgAAAAAAAAAAAAAAAAAAAAAAAAAAALii - lBCSdGPERV9x/zVabf8iQlT/HTJC/xwsOP82T2L/fIlz/0iChv8PSmv/Glxl/xpWOf8WUVv/FExy/x9S - dv80WXv/M1Br/zFIY/8mTXP/Kl2G/0B5lf9WgYr/R2tt/zhniP8VVob/DliF/xBfjf8QVIf+Ey5F/hxL - Yf1FPDX9GlR+/BBwqvsJTX35Fj6E+Dpus/U6bbD0OWuv8zNrrPIWYIztFCpMZP///wAAAAAAAAAAAAAA - AAAAAAAAAAAAACb//wC9f1l6fU06/iphff8zUGD/GCMs/xwgJP9Vb33/gpB//x5Qc/81dIf/gp0v/7O3 - Qf+Fp3b/GE1w/zZVb/85YX//GFaB/yVKaf8rUoH/Snea/32en/9dkY//Wo6K/zt8nv8cZor/G2CH/xlf - kP8bQ2H+Gx4h/hg4R/0qSlv9J0ph/At7u/sQhLb6CC9r+C5gqfY4bbL0OGyw8zdorvIicKfyED1juCoz - URJcWmoAAAAAAAAAAAAAAAAAAAAAAKPx/ADHmnoypFky6TRddv87WWb/GjRE/yQtOf9sf33/bn97/xRK - cP9KgZD/z8ho/9/chf+Hn5j/H1l6/z5jgf82X3z/QWF0/z5gfP8XS2z/FU19/0tmjv+FhWb/jHky/054 - kf8nUHr/JmKL/y9slP8eJi/+Gycv/hYnM/0dVG/9TT8y/CBki/sNmdf6CUl8+BpFjvY3bbT0N22y8zZq - sPEubK7wE1yI6BYoTFMOGkIAAAAAAAAAAAAAAAAAAAAAAAAAAADHy8EIu29DsVpSVf8yYXf/J0da/yk8 - U/91e2n/cIh+/xBBaP8VUHr/Om6L/zx0jv8dTWv/IFeA/ztpmP8wZIL/Kldw/xZTfP8ORWv/E052/w02 - W/9Eboj/koJD/2SKe/8jbZ3/K3qj/ydbef4bKzr+Gz5b/hg3T/0VPVD8QkVE/EVIR/sJiM36D36w+Aox - cvYsYa71NGuz8zVrsfEyZK3vG26k7xA5YKkuOFgM4v//AAAAAAAAAAAAAAAAAAAAAADElHQAxYpkY4xS - PPsqZIT/N1Ni/yZPcf9xdVr/ko5R/zxfev8XSHX/EUNp/yxZe/9Og5j/a7Gz/1KYtf8PWoT/EFJ2/x9o - Zf8dYDb/G15l/xVTff8wY4r/jYZV/4CFVP9vm6X/TJiw/xY3T/4WL0b+FSxE/R0mMv0dKTX8I1Fr/Fk8 - Kvsba5n6DZvX9whGfPUaR5X0Lmay8zRrs/EyZ6/vI2ap7BJWgt8YKFBFERlFAAAAAAAAAAAAAAAAAAAA - AAD5//8AxKKLIpVsWN0xaYr/O1pp/xpchf9hcGH/k3cW/5aKSv9/hF//e4dh/5GSYP9sr6b/bLy2/zyC - oP8YTHX/RIeM/46iH//EyET/n7qE/yVWef88XXz/mZNe/5KDOf9xl4b/I01k/xofLP8UP2D+FjdX/h0i - MP0gIS38GEZi/EdERvtAT1f6DIXH+BFXifYLL3T1Jl2t8y9nsvEyabHuK2Cq6xhuousRNGCZOEdqB/// - /wAAAAAAAAAAAAAAAAAAAAAAiLvWA6eGc5xnWWD/L2N//ylegP9FbX//jIlY/3d5Uv90eFD/d3NK/2uR - b/9enZ3/lKN//05sgv8VVID/YZGV/9nTa//c24H/k6id/ydhg/9hh47/moEs/3eJX/8mYnz/Fhwu/xkg - M/4YIzj+Gx8v/RwfLv0dIC/9GixA/CZRbPtYPjT5KmKL9yFml/UIM2/0G0yc8ylisfEwabLtL2Ov6iJs - rOkSTHrWGSZRNis4ZAAAAAAAAAAAAAAAAAAAAAAAhqK5AM2Vd06ZWUn2K2aM/ztbb/8lbZ//Zoii/y1r - nv83bZz/LmmT/1Wnyf9ygnr/m4g5/059kP8LQnD/GViG/0J6lv8+dpb/IVN4/ztugP+QlF//f4tp/zBl - gP8XKED/I0xu/xFLf/4SJUn+GypF/hc1Wv0ZJUL9Gx0w/BxGa/pOQUf5SFdn9ydsnvUPToH0DjiD8yVd - sPEsZbPtLWax6ihfq+gXaJrpES5diUVUeAQAAAAAAAAAAAAAAAAAAAAAAAAAAMi6rxa4blPNR155/zlg - d/8cY43/EGCf/xhYkf8aVIn/Q4ms/0N3mv9KfaH/fXdJ/42bb/8rVX3/FU6A/w5Ccf8jV4X/YXyE/5Wb - dv9wiob/P2qL/yVQcP85YoD/MUZg/xQsT/4aPmf+JF2J/h5Tfv0lRW39Gx81/CNYgPouUHX5OkZd+Cls - nvYXWo70BzZ48xxQovAmYLLsK2Wy6Slfr+cfcbDnEUt8zB0pWyo+VXsAAAAAAAAAAAAAAAAAAAAAALH/ - /wHGiG6Gd1ld/yxrjv80WHL/DEt7/xljoP8qeqn/Onuk/xdWjP8weq7/Y3Zs/5iORv+WlVr/eo1y/3mN - dP+SmHb/ipN5/1+QoP8sYI//PHWV/0FykP8jM1D/Ij5Z/y1yYf4bUGv+IluH/hhNff0eL0v9ITZS+yRy - pvoXTob5I1qM+B1WkPYfXJb0EkmD8w86hfAeWa7tI1+x6SVgsOchX6zlFmud5BErYHdXc48CAAAAAAAA - AAAAAAAAAAAAALrx8ADMpZM7o2VX7yxslP8/YXf/Gjth/x1Yif8ifLD/JGmj/xFcmf8tZ53/epSX/46G - Rv+NgTH/iIlR/3SJeP9VgZv/PGiP/xdJfP8kSXf/NWmM/x9Aaf8jUHr/QmR9/5Wxl/4zXXv+JDpa/hso - Rf0eLk/9LlqA+0BZcvo5Um/5MHWl+BNWkvYaWpL0Toux80pyovBJe7rsNG646SVgsOccVKjlGHCt5A9E - eL4cLGAkAAAAAAAAAAAAAAAAAAAAAAAAAADGubgNmoqGvEdzkv83aYb/KVF1/xs/Zf8eO17/Fjhn/wpA - fv8fXZP/PW6O/zZqh/81aYr/MFyC/zlvmP8oUXn/GF+N/xVdoP8caqf/JWKL/xk7Yf8iV4P/JEx4/yI5 - Xf4bKEX+HS5Q/jJGa/1RVGv9VVBZ+zdTb/ooaZ75KGSb+EN0ovZ6pMH0lb3X86XN4/Gr0ufunMXf6om0 - 2OdpmMrlNXa14x5ll98mO3B4AAAAAAAAAAAAAAAAAAAAAAAAAAD/9AAAwZuMb4lkZ/0qcZr/O2B8/xcy - Vf8aLUz/HTdb/xc9Zv8WL1L/GS5N/xctT/8dNlz/H1eG/zVtl/8nX4v/KHyx/1Skpv9Sooz/F1eF/x5O - fv8oSW3/HC1K/hwvUf4vRm3+UFdw/lpZYv47dIX9JoKo/B5mnvpPgqz5fqLA+KDC2fas0Ob0sdbr87DW - 6vGs0ufurNLn6qPI4uh8os3oXYS632CItKtffaNRAAAAAAAAAAAAAAAAAAAAAAAAAABKyuwAyK+mKrBy - ZuQ3b5b/P2iB/xxHb/8UPWn/HEl0/xhFb/8TOmX/GjNT/yZXhv87WYD/KURm/yNCav8cTn7/EVaF/1uZ - of9yt7b/Mn+l/ydCZv8ZMFT/K0Zt/05Xc/5cWmT+P3OC/hWexf0Ut+n9S5/J/HKbvPqew9r5sNTo+LLX - 6/ax1+v1rtXp867U6PGmyePvgqbQ7miMwuV3l8WylLLRV5K91hFHRXQAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAuNvlBsWKeqdkaX//MnOU/y5cf/8YN13/Hz5g/xpHcP8YMVT/H1B5/xxIdP8UOVj/EElw/yFc - i/8dTHb/HF6J/xxunf8vb5r/Hkhr/ylFbf9LWXf/XFxo/kJrff4XmsD+EbPl/kC+6f1/yeb9n8rg/LLT - 5/u93e76u9zt+bXY6/e02Oz1qczl84Wo0PRrj8Xsd5jHupSy0lynzNwTu8DcAIKvzQAAW5QAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAxMTNAMuillqWbW/5Knij/z9og/8ZP2b/HDJR/xwzUv8bNFX/HT5m/yBW - hf9ro4//PH6C/yVXhv8kUXv/I0pv/x89Yf8pSHH/SVl5/11fa/9GcH//GIWu/w2QzP5GvOj+kMnl/qfP - 5P231+n9wt/v/MPg7/vB3+76v93t+bLS6PeMr9f4bJLG8WeNv7+KrM9gpszcFLjE4ACRudQAH3aoAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVP//AMi/vRy3gHfWO3ae/z9xjf8iVX//GzNU/x83 - WP8pWIT/IWmc/x1WiP9ce5r/OVt+/x47Xf8bNVn/J0Vv/0dbff9eYG//SnKA/x+cvv8NqN3/Oajb/3e9 - 3/6x0eX+vtjq/sLf7/3F4fD9w+Dv/MPh7/u51ur7k7TZ/XGVyfZ1mcrEkLLUZZ7I2xa0w+MAlLzVAD9t - owAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAML5/wKeoKWRYoGa/zB6 - of82Zon/Gjpf/yVCZP8pX5L/KmWZ/yZRff8cO2D/HDdb/yZIcv9FXID/XmJy/05yf/8imbr/DbTm/zi+ - 7P9/xub/rtHm/7rZ6/7E4fH+x+Px/sXi8P3D4O/9vdns/Zm53f9zmMv5dZrLyY+y1Gily9wXqrXdAJO9 - 1gBOh7UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL/j - 6gDJsatFp3l58y1+q/9Eb4v/HEt2/x83V/8dQGj/HUBp/x05Xv8mSHP/Q12C/11jdv9QcH//JZe3/w2z - 5f8pvOz/cMbo/6zQ5v+/2uz/xuPx/8jk8v7H4/H+x+Px/cDc7v2evN//dZrN+3SazM2Os9VsqM3dGamz - 3gCXvtcAX5/DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAADGys0RxYyDxFB4m/88eJf/JGeW/xhPff8bQmv/JEt0/0JehP9dZXr/UW9//yeV - tf8NsuT/Jrvs/2XF6P+dz+f/utnr/8Xi8f/J5fP/yOTy/8nk8v/F3/D+osDh/3mdz/x0m83Pi7HVb6jP - 3xqqtOIAnMPZAFCYvgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABy//8A0KKYeYd3hv4tgav/OHWZ/x2Qyf8rbp//V2l//1Ju - f/8lg6n/DKXZ/y687f9rxen/nNDn/7zb7f/I5PP/yub0/8nl8//L5vT/yOLy/6fD4/98ntD9c5nM0Yqx - 1XGlzd4coqvgAJzE2wBEj7kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACm9vwA0LizMbOCgek0ga//R22I/0xr - hP9OaHz/J4Cm/w6p3P8pqN7/cMHl/6rR5//A3O3/yub0/8vm9P/L5vT/zej1/8rk8/+rx+X/f6DR/nSZ - zdOKr9Vzps3eHZmr5ACaw9oAT5a8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnfCMuV - ja9eeZr/LoKp/yt6oP8LiMb/KKHa/3TG6P+n0ej/vtzt/8jl9P/L6PX/zOj1/87o9v/M5vX/r8rn/4Ki - 0/51mczViK3UdqXN3x5/ldwAn8XbAFuWvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAzrq+ALeyuGJYqMv7CKDb/y2p3/9qt9//ns7m/73c7v/I5vX/zen3/87p9//P6vj/z+j2/7PM - 6P+FotL/dZfM1oer03imzN4fc3rPAKHI3QBrnL0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAJP//ALbc7yF82vfcYrTe/5G/3v+32Oz/v+Hy/8bo9//M6vf/0u35/9Lr - +f+3z+r/iKLS/3WUyteFqNJ6pMveIGFayACjyd4AbKfGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJa82QOp1fCCVonR8GuW1f+Jsd//lLri/57C - 5f+kx+f/o8Hl/4Kez/1oisPWgaTPeqfM3yE9HKwAo8neAHGuywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJXH4wB+r+MMR4HTSjd/ - 04s1hNO8QI3W2kCP1elAk9TmTZTQym6ZyoN1q80nEQCOAKXK3wB0ss4AAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - AAAAAAAAAAAAAAAAAAAAAAAA///+D///AAD///gD//8AAP//8AAf/wAA///AAB//AAD//4AAD/8AAP/+ - AAAP/wAA//gAAAf/AAD/8AAAB/8AAP/AAAAH/wAA/wAAAAP/AAD8AAAAA/8AAPgAAAAB/wAA4AAAAAH/ - AACAAAAAAP8AAAAAAAAA/wAAAAAAAAB/AAAAAAAAAH8AAAAAAAAAPwAAAAAAAAA/AAAAAAAAAB8AAIAA - AAAAHwAAgAAAAAAfAADAAAAAAA8AAMAAAAAADwAAwAAAAAAHAADgAAAAAAcAAOAAAAAAAwAA4AAAAAAD - AADwAAAAAAEAAPAAAAAAAQAA8AAAAAAAAAD4AAAAAAAAAPgAAAAAAAAA/AAAAAAAAAD8AAAAAAEAAPwA - AAAABwAA/gAAAAAfAAD+AAAAAH8AAP4AAAAB/wAA/wAAAAf/AAD/AAAAH/8AAP+AAAB//wAA/4AAAf// - AAD/gAAH//8AAP/AAB///wAA/8AAf///AAD/wAH///8AAP/gB////wAAiVBORw0KGgoAAAANSUhEUgAA - AQAAAAEACAYAAABccqhmAACAAElEQVR42uz9d7Rk2XXeCf7OuT58PO9Nep+V5VGFggcNCNACAj0ggaIM - RVFm2JIodk+hZdb00ogjjTTqltQUTUuiKIlNI5KiBwHCVBXKp7fP2/D2+nPmjxuZwNJMT7d6JBaqUHut - WJnvRbwX8e6957v77P193xa8Hf+70dgZIkxHpH5bJL26UP6h0NGBlKoprFzBMMrLOS3KFa3tcRAVhKoi - ovFk2C3Ew46jkoFJmgiE0IaXHxqO19Ja7gkhDoVM66haI+pdH0ZDR6vUUdJyFUKqY+/982/0n/52vMVD - vNEf4GsxBkNNOgyIOg3wd5D9y4hjnyolg85c0q0dUf7Bso4OFqRqzhiqNSlVe8KQQdkwYtc0e4bQbUPH - TSMJWjKJOiKNB8L0NM6Yh7bHlLYmlHAnYiVyaRxZYRyWGtGwsBsOnDWtnNel6b6OlPeC3uHAKZSx3Dwr - T/3wG31Y3o63YJhv9Af4Woj2fhdp54lbG0QHN8h5OEPTXZBB+YxOWmewq8fjV/72Ytq+PaHDrbxI657Q - fQ+lHIV2MLWVpkqmsUbIBEGMSiLSKCaJE1SqMF2BXRognBBt9xDeLsJ1MDwPJ19Q+dmVQBYfGqYsdIOe - bLTX72yqJP68TtVvWc7Y+su/8IkArXn4e3/+jT5cb8dbKL5uM4BOzUfaLoO7LzO48wJLH/uzs8P64EKw - +cojaf3K8bR5Yy7u7E4SNydNq1+Vup9Pow5Rr0ccDEmTmDSANAKVQuxDNIAkhCSGNM6+rzTorzrSGgFI - hAGWZ+BWLLxJC29+mtzyeQqr78SbeRjLmYrisLs7aFy5Nayvf8lvbH+uNFX4wsbre+HkiePMXbzI2NzH - 3+jD+Ha8yePrEgAGgWb/3/51ln7g/1Zu3dw8G+xeezrafuVMXL91TPut4zpqTRLXZDKskUYdhIjRCuIA - Bk0I+pAm2eJGgDABy0GYBZAFMHJgeEjLxjANhGkghIHWBmCgUk0ahKTDGslgnyTsILTG8so400cpHjvL - xMXH8GaKaNmkX1/b7x1sXfG74RfShM9OrI49t39L+QsXJhHC4PxHfuqNPqRvx5s0vq4AYKg1qg+yQMXf - 6h4LNn7/PdHe9ffEu3fe6W/fKvsHt0mCBoIUYYzu6gEkCWgB2hAoUUFYVYxcFatYwi6XcCtlnOoETmUK - q1jByBWRTg7DdjBME2maSCERWoNKSMIBQbdGd/sarTuv0F67zWC/QdyJibspGnCmZ8kvz5NbqmKUJFax - gDe+1HVL4y84xeJndNL/fNzbuP7683dqS0cnedef/sU3+vC+HW/C+LoCgERrmaR40d4fvT+qbX+Pf/MP - 3+ffe2lqeO9Vhp2UMDZQCFSqUIlGKQ+sKkZhAmd8DG9mEm9uFXdqEbc6h12axi6MY+fK2E4O07TA0Ghi - VBKQxj5J5JNGPmkUoMIAHfVJwy5x0CHoNQi7dWK/R5Io0tQmOOzQubfN4eWbdGtNlAWlxUlmLl1g6d0f - oHr0BGbOS4LO7u/3Du/+Qe9w84uD5u718vzxhuVYjM/OE/o+p97/t97ow/12vAni6woAGnu9okjVRTn4 - jU/Ru/yJZO2zonf3Jo0tn05DE3Q1wo8QZhljfJ7iqTOUT16kuHiB/NRRvMoMTj6PMEGrCJVGqCQk9Qeo - QZu03yQetoj9FpHfIQ7axEGHyO+RJhFaCKThIO0cplfELkyQG5unMHuE3MQyRm6CcDCgce8qG3/0a2w/ - 90XqV+8Q15rkSx6zTzzG3Lvex/hDF9EiIQk7nXjYeC0cNH+lW1v7Xcs2dk48cr7z4m//oTIMxft/5D++ - 0Yf87fgaj68LAGjeewXTXaa7t78qDfWpQrX9Ya/cPG+6ddm8epkbv/AH1J6/Q9xLKBxbYvLJb2TumY9R - OXIKp1hEqxidJKhwiO7WiXuHRIM60bBBOGjidw8Jhy2SqE+axiAE0nYxcyWcwjh2cQK3OIlbnMQuTmIX - xrFyZaSVA2mBVqBj0DEaG6SLEAa19Svc/cNfYv9zf0D7tRsMDrsoO6F8eo4L3/sjrDzzDbjVkm5sXQ7r - G5evmYb8GSn15xrb17d6jY1eobKU2Lk8T37fz7D10j9g8ZG/9Eafirfjayy+fgDAWxGd9f94UUjjvy/O - nXpncf5URQgpWrde487/+tNsfeY/Yth5Hv5v/h4zjzwFKiU53CWsbxINdwj6+/jdA8JejcjvkqYRGhCW - g5UrYRcn8MrTOMVJ3NIkTnECuzCGlSuB6YEQCB1D5GetAjQII3toBUqhUoVWKUgD6ZURdok0gfb2LbZe - +D1u/Pov0L58FzoRdkEy+chpjnzkY8w+8kHc6pRq7bwa9+p3X+k3N3458ju/kwaDW06uECgsZdpQrFY4 - /cG/90afjrfjayi+PgDg7kvScOdLfuOzH9Bp72/nJ8+cKMw9KoQwCLstWndfZ/NLf8DwYI+VJ95BrqAZ - HFyle7hFMOwibBPDcbFyRex8Fbc8jVeZwy6MYbpFDDuHtEdVf0MiUJBG6DRBK4UGtBAIJKDRSqHSBIFA - SgvDNBGGSVYjTFFJjEpTpGlhuEWEUyVOBf3DbTY+/2vc++1/T/vVu0TNALviMfnIKRbf/z6OvO97cccm - 435zvX94+wu3Wluv/I7t5n82SdVmcaysTEuotwHg7fjq+LoAgP3L/8HUWpyTRvKthqH+jFtI53IlC4w5 - tDGP0gXaO2vsvfoZtj7ziwgVMHPxcWYffRfF2WXiwQAhTEyviJnPIy0LqRWkCSqJieMQlSSgFdIys8q/ - kKOFnqIFgEQIgRACEGgNWqlR+i+Qholh20hpgIZ0BAJag2GaGE4RvAliP6F3sMna536Fzc/8FrUXX0Z1 - NfmJMmMPL7PyDR9h5X3fg1OajPv19e7mq7+26Xe2frUwVvol2zXvNdbXh9Kweccn/9UbfVrejq+B+LoA - gJ0X/7Wj0vTDdqH8J9xy+YNO/KWqE/w+SIPEfYog/1F8X9PdepndL/8arbV1tB5j5clvYOmxd1FeWELK - lNRvk8Z+ttANIyMDJQlaKyBj/GT/B0MaSMNASIlGZGQgpbN/R2Sg7AsNWpM9MwIC0xoBgUalCTpNsz9E - 2phuCekWGA4CWuu32Hvps2x+5tepvfQiqg+5qRkmHz7F8jd8mOlL78AuTuB39/bbu5dv9Wu3f2/YuPv7 - Xs54vtcT6dEn38PcmQtY3vvf6FP0drxB8ZYHgP3XfoUo7LtK6b/olUqfLE+PrVqD33Dlwc9C0mYQTHHQ - PY/POcziScoz86ikS2/nGgc3rjDsBhRnTjF39iIzJ09i5zx0EpH0eygAYaA1CAFCghASrTQ6SbIlLSXS - tJBSAgKlNErp7HUIhJBIKUCAVukoKwDDMJGGlb1OK1SSkMYRQkoMy8VwSmC4BEFMc+MGey99lvXf+w2a - l6+SdkNK84tMPXKR+Xc/zeSFJ8lNLRMNGtutnSvXt1//rS8Gvf3f/Ma/+odf/u2//y166sgiYPDwd/6T - N/p0vR1/zGG80R/gv3b8Nz/yPRaWN6ul9R2WZz+TK0vHiF8XdJ5HpT6tvQ5bL98mqG+Qy/eYPbNIaWEZ - WVhA5kpI0yEJYgatDr1GkyRJMWwXp1hGGhId30/VNVJK5P0U/36arzVaje77QiLlKCvInsyYhNJASgMp - sucA1P3tg9YZiBjZ1gJAJzEq6kMaYbkepfmjjJ98mOqJk+TnZtAipre1QePqVdrXrzHY3wRCCrMrpeLM - sSPFyWNn3dLMiXvP/9yiV3RCoTu9QSeMPvnhY/zsf7jxRp+yt+OPMd7yGcDOy788IUzrcWF7f8l2gg+W - ijuY/V9HH/4GYazYvm1w+/mUyqRm4bRLbu4ssXWWgAuMnfggXnmVweEBzc012jtrxMMGbtFlbGmJ8uQU - Ti6HTuNR4U4hDONBFoAg2/dzP9sXICVCZlnDV58CKeSDLQNodJqiVIpO0wwgDBPDsBBCoJUiTWJ0mgAa - 6ZQwvDGkV8Jv1zi48QK7X/oMe899kdblyyR+TGGuzNL7PsLCuz7I+OmHiJMhw/ZeJ+ju/8Gwtfm5zv61 - 5/3O1tX8xNmuV6kwe/o4nb1Dzr7/77zRp/Dt+K8Yb/kM4Mf/9DetGAbvdUsTj7t2NGMFryD8V9HRDv2u - oHUo6TQF4wuC6lRMa32PYO86rr6D5/g4jsSrVKkunaa6eIY0Cegd3qN573WCXh9tOFiuh+E4CEOCzu7c - SimEILuz3y8KakjThDRNHmQD0jDgPkRohdYqSwykgZQSYWRgkqZJVmhEI43sdwrDzLKJyCcN2ui4j+nk - qMyfZOz0JSrHj2GO22gVM9hpcvDiS9Quf4mgtYtbqFKaOeY6xanTdmH8YSc/dsT0xnJ+ey8xHfr/4L3/ - Q3Tq/cv8yW8/xc/8ytU3+jS+Hf+V4i0LALrxCzz74x9j/97uaRX732a7nHHsYcGQTQQdUj+gsZPQ3o/Q - KVRnwasI+gMDw1AU3TpJ/Uv4+79H4m8DCXahzPjyCtX5cQQdWjt3qN29RTiMEZaHUypnd3ytkCJL5bX+ - SvpvmGZW3CPrEGQAkX1fSGNUH8ju+mgNUiKl+SArUCpGpQkqTTOy0WhrkLUQNXEwIB62UFEPJ1ehsnSO - mUvvpXhkGbMi0GlCf6vOwQsvcXjli/iNdUqzx6kunckXplZPgHzGML0zhpFXD33H+SQa1iKVNqPvee8x - /ckPn+Xn/+OtN/q0vh3/heMtuwXQ7V8QpNL4nV8++E7U8NNFe/3oxNS+NXcqxStNEDcdbn3m87Q2blEo - x4wvg1OStHcMbBvKVU1jM6VXU5i2oLi4QPn4JXJzH8AeP4ew8gwbm9TvXGP7yl2S2KEyf4y5sxcpz84g - kijr6SuFkJL7GwEhs8WuFag0W9DCMEcL3UApNQKHrGWoR4VDIcAwRxlG/FUgYJhIwwQh0aMsQSmFRGE4 - eazyNMKsEPt9dl77bbY+/5vsfv6P6N+uo8OA3KLD8ge/heMf+VOUVy4Q+l19cPvzyu/u/X4Sd38p6NU/ - 39m7s9Xavd4/+vh36LGVZQzT5NiTP/FGn+K3479AvGUzgP/2L3+XrWOxcHt44X1byYlvvLq7krt3M0Xe - +Iz2/Gtamk321oYiChUTCxF2XqG0RAoLx5WAorWnae9rwh4MDnv0dzaIe6+hog2EtHEri1SWTzN3egXH - hebGXfauXaO7X8OrTuJVqpiug45jdJpimFbW8tMKhMAwLUzTQmtFGmcGIlJKLMfBtGwQkMbxCBT0qG4g - EYaBYRlolRL6Q5IkBgSG7WDaDoZhogWkcUg6aELcx7QtKosXmDz7NOPnzmOUI0L/AH8npP7yTba/+BsM - 23dxqwUxc/K9sjh1fFka7jtjv3cRnbpji+c3pRSJV6kowzT1R58s8qnvusS/+JUrb/Spfjv+/4i3LAD8 - 2Pd/R94f6Ecb0di72mrqfM9YsXb7q7x8dVZs3E0Jdu8q3TqgmBtQnlFCmBKNRb7qYTqSKEjweylpAoaV - /c44SOjv9hjsrBM1v4xQO1iuwCwsUZh7nMnjz+AUZuk322y+8jzdvU0MS+KOT2PlCiTBYHR3l6OiYNb/ - l0KO+AIarRJUmoDIWoGGZaHJmIMqSUbdBoGUJtK0MaxRZyCN0SpBjGoE92XIGkijkGTYhaiL5biUFs4x - ffF9TFx4FFEcEocthtst6q/c5vDl5+gfvkxufFrOnPsGb2L1kUWvMvOk39n7oNap6RZKh3HgB367lgpp - vg0Ab/J4ywGA3v0VPv33/w2f/N6PlYeh/OBBMPHU/mB8IazvGGFzn0Y4zjDNoeNITFg1MTPZozCNGLY1 - QVcwtmzjjRtEscbvK5JIYdgwyrLRShMNE/oHfQZ724T1K8j0NpYrcMrHKEydpDwzR74U0a/vsnPtBt29 - AwRQmp3FsO3srp7EWbNQiIxMBNiOg2FZCAFJFJHEEQKNYToYlp21BEW2HVBKZ4YkSEwrIw9lfIGINI4R - QmCYJqZlj7oSWecgjQbouIudL1CcO8n0+fdSPXEasyqJhgcMNndoX96i9voX6Gw+J3KTY8bY6sX8+PKT - M4ZdeKxX23t60NzLp3G3X5516x97+ig/9+vX+Ut/5iz/w9//d2/06X87/jPjLVcD0PqzULvM519dWVaK - T++Fix9aay+O9davGb3dLVp+ngn1Kqe93+bi/FWOnmiTXxQ8/9wYV18pMjkfc/psn+PHBvT6KfUDGDQ0 - OgKpIA0hCSAOQSVg2pAbyzF2ZIGxE+fxZp/BKJ1HM44/sOnVWhzceIVBaw875zB74iQTK0ewPYc0ikiG - QzCsB61BMWodMmr3qTQFBEIao2JhlimoJEWlKnvOMJCGRAAqiUniCJ0qpJSYjosxQi+VJqh41D4UEsPJ - YxfGSbVk0KpTv/Fldl/4XXb+6DcZbrUwhEVp9Sgz73iChXe/n9LyRTC9uHdwe7e5/fqV+trzf5TEg182 - zdytwvgMU0dWWX3ir7/Rl8Db8Z8Rb7kM4G9+3zdiFIb5VnvqdM0vf7QbFU+0B47s1fZF0KlhyYBp8Tor - 9nMsLnUYm1VgSF6+e4rP3XqUq7ur7O7YBIdt8k7E2ITGq4K0IU4z8Z40QY66d2kCYS8m6jZIemukvWsQ - 3sNwDLyJkxRnHyJXncFycoS9Lo2N2zS31hDSwi6WcUpVVJIQhz4qTbMUXoqscCgztaBK06xGkMRopRHC - wLJthJQkUVZI1FpnhcaRwvA+UKRxhEpjsvZhtqWQpolWSWZY4vdAJ7iFIsXF04wdf5jyiTOYZYegf0jn - 3gatazfp3LpB2N7CdKUxtvpopTJ/dqU4ceQ0qb4Y9usz+UqxM396tfeRi+X0T37rSX7mV6+90ZfC2/F/ - IN5yAPBjn/qokFG63PIrT+8Mp9/bHjiTg85Q9OoNkqBD2W0ybVxh3rnG/EqMWxLU6i6vrJ/kRvM0QX6G - VjTGxk6J2r5J1I8peSHlKuQqoA1QZJwe08rqA/elACpJiPstkv4merAGwSZS9MmNL1OaO0N+fA4hIoLu - Aa2dfXr1OioJsT0HJ+eNhEIjgdBIP6AfGA/eZwimWedAiIwPYJjZa1WaPcjox1kNwBgRh74KQNBI08Sw - bKRhZpyFeEga9RFovPIk1aOXqBw5S2l1BbPgEPbbtG/foXXjMt17N4n7NZycZ5QXj5W96vzJ/NjKWa2N - o/t37owF3Z0kCfdbP/jNl9K/+iMf5n/8V1/k05/+9Bt9Wbwd/xvxlgOAP/k9H5VppB9q+IX37wznz3W6 - qujX9ui2fVQ8ZMK5x5x5ndn8NrMrmsSwuXF3gsubRzjwp6lUY+yCTV9Osd2ZZGu/TOtQQpxSLIQUS+AW - QFgCZGYMKiSYTvZQZEAgwhq6dwXVf400OkAaQ/KVEtWlk5RmVlFxj0FtndbmHcJBgMbEzuWwHAdhGJmU - eMQH0GiEITFtG8MwEWTdAZ0mSCkwHhCD5Fe6DCNRUkYvNrI2oVKoNBMwIQSGYWHaTsYjUCkq6JKGXQSK - XGWW8SMXKR05QX5xDqNgEnV7tO/c4/Dl5+muXSXx++THZihML5fs/ORZpzB5xvbGl2NflfvNrXTm1Gzj - lV/6KfWjf/I9/OmPXeKf//tX3ujL4+34T+ItBQC68+/Z3rNkz5fvakeFb9kPZxe6ncDxD9bp9RQi6TPD - qyy4d5ifaDG5BJ0oz0vXlrjTOkZfTGLKAFsGOI5GFEr0jWnWGjNsbedp7QtsmVIqpBTKGtPJMgGlM2Mf - 2wPTBcvJsgOpUtSwQdR4gaj1ZVJ/E2k4eGOzTByZoTA2SZrYNHc7tHYPiP0+GALLc0e0YJFpCUYphhRi - dPfO2hJpmhBHIWiFYRqZitDITqlKE9IkIo1ThDQxXRfTzqjEaRxnGUGaPtAZSMNCSBOdpsSDFipog4rJ - TyxTXX2IsdMP485WkZ4m7ga0b61z8NIX6GxcQ4V9ilPLlGaOVnNji+ek5T3mFSeW+rWhIaSRQDcI9/91 - 9EMfv8oPfdfD/PSvvP5GXypvxyjeUgDw7H/3cWmnudJ6M/+hblz45mY0Vuw2B2J4sEEYJri6zoJ6jqXx - TeaWQ4oTsNcu89zloxyEcyjXRaoAnSYkCixCHEdjVcu0meNebY61uw6tA/CMmFIpAwIlMgAwPYHlSWxX - YFpgOgJpZu7Cg1qH9uZVovZr6PAWkoTcxGkmjn+AyuJpIOXgxgu0t+4SDnpYhRKG46LTGMMwskKeBqWS - 0cI1MMwsjddpShKHaJXJlC3HGUmJNYr7ogOFHvkOmJaDEJAmEUkY/H9sDQzTRqVJZlY6bCCFJje2zMTp - Zxg/8wTWpINwFHE/oH1zg9qrz9O4/XmE0FQWT4qJ1UtFtzR1LvH9bzTt3LRhlcD613E0rEdp4kY/9J0X - +Hv/8K/wZ7/3Kf7h//x7b/Rl83UdbykA+Mm/+NFiFNhn17vj39jwC491+1L26k2GjX0sMWTc3mRBPM/C - zCHjixotBHd3Jnnu9jnaSZW82WE2eJlCsocWFoEoEeNgJgM8N8Gq5GgaS6zVZ7lx3aNXS/FkwOSspjie - bQukKTBNA8uV2I7ENASpguEA2ofQ2WrT37mNGr6CpIHp5fHK04zNzTK9WiVNIg7vbrJ/6x5hb0BxYhzb - y43ahRGQqQ7v7/dNy84q/aZFEsXEgU8ShQ/Se2lkRcQkClHpqIgos+2EadsPfm8c+BmAjJ67XyNI05TE - 75EODpGGIjc2z8zZ91I9eRFntoQ2h4SdLr3bNfae+xx7r/4GiKEuzawwefQpx/LGzmslnhGCI9JwdBz0 - 65Cmp9//Pek/+th38VP/6M/xT3/xxTf60vm6jbcEAGj9h3z60z/Lj33/t093hvJd24Ppp+r9wsqg2aXX - aDPoB+StOjPuHWbNaywuDKnOSg7rLq+vr/Lq3gUGkclsbof3nrzKpZm7jKe79Oo9mh2D2JkAaWKpITk7 - xMh79PPL3KvPc+NOme5eQE6EzM8rilWB9EyUNjFtC8u10EKTJpo4zCwBg57CbwxJOtcx/D+AdB1pxljF - BapH3s30qWdAWjS319l69SWiQR+nUMCrjiOEIBoOkGbW+nugDUBkoiTDzIqRgY9KQkzLyrgF92nGo+3E - /eKiYdkYloOQBkkUZj93367MtJCmjTAttIa43yLuHSIIyY3NMXH8KcbPPom3MEWs94h7ffyNDvvPvyAa - N74kknhXVxZPi4ljT+fzYysnleKdYb/+hGG7vUFjp3H0iYcTdKK/9/1H9Cc+dJyf+423pch/3PGWAIBn - n/0kn/70z/KD3/3xpa5vfXjPn3qo1suNDQ936Ld6+KGkLNaYt66yVNxmfjHCHjO4eW+SV9ZPsBaexKLH - rHmbJXedqUKf6fGU+fw+Vb3NsNGk05P0VAVhGNhGgiMCjGKRoTfPndoyt+8V2bsTYSUB42MJ5SUTt+SA - sFBakCpNqhQqfeABiiFTpOoTHN4mOHwJFdzEtF2cynEqcycYWzyBVxmjtn6P7cuv4LeaWLk85bkFhFao - OERo8cBsJIlDACzHxbQyYlAw6JOEIdIwcAtFbMdFpylpMmIc6ox3IM1RxmAapHFMFPrEUYRhGpiWk2UL - hoFSKbHfJ/HbSB2QH19m/Pg7mH34G3Bnx4hpErfb9NcOabx6VdSv/yHhYF2MH79kTB55Oj+x+thSNOx+ - Y3tv7TEhiKWkGw2HPa1T/TYA/PHHWwQAPsWzP/R+bh1UznZD93ub0fiJZt82hwcbDDs9VJoymV5myXmd - pdkWUwspyrF4+foCl3eO0xSzuP4mc+oaJxaHlMdzpPYE5ekpFpdynJhvMZXvI6KUtp+jlxaQjoMlY2wZ - IvM5usY0671lbt4psHcvwQ27FKoh+QWJ5VooJQj9GHXfBASwc9nD78cMG13C2jYMXsRMX8JwLJzSAoWp - k4yvnMMrj9PYuMXBrct0tjdxy2MUJqeRlpEV+6Iw6++LzE9QCIFp2ViOB0AchaRxiNDguN6IOfgV70Hg - AXvQchwMwwCdEodD0jhGSiObdGQ7o45CShr5JH4LSUJ+co7qkUeZOvcUzswYqRzQr23QX2vo9tXbHL7+ - OyIabovCzIw5tvJorjJ3YRFlPB70eueCQa2sVLT9A990ZvCX/+yH+Js/8b38P/7Ht2ca/HHEWwIAfvIT - HzaknUxttcbfUfeLH2kH+fFeN2VQ2yYNerhmn1n1Iou5a8yvhhTHNN2hzfM3jnNzf4VI2sxZdzg1cY+T - pzSmbdJsSZxyjsK4g+NI5icVR6YGFKM6cbNFvREwSEywPFxHYdsaLJeenGanP8eNm0X27qWoVpvxakix - moAliCOII41hg1vMACCNM2ZhEsXouA3DddLmK6jhNaTl41WPUJg+R2lmFcuxGbS2Obh9hfbeDqZXxi1X - sfM5kmCISuJMdIQYSZE1hmVj2Q5aKZIwIA78THTkulnBcCQcUkplboUjoZJhWVkdQCWE/oAkDNHoLMNw - XKQ0s4JpMCQetjEMyI9NUT3yENUTD1NYWibRPdGvrYvBvTrt67do3nxVJ+EhbqVsjR95olqdP7uSq8yd - H7brj/rdg3Jhorp78plnB994Yo1PfddFfvp/fe2Nvrze0vGWAIC/8MmPOkmYnt8bjL17dzD+eLenvX6z - Ta/ZQaRdxrx9ZsWrLJQ2mT+qUVKysVvhubULbLRmcEWbMzNrPHSixtS8g7Q84iSHWRhHW3nCIKZ32Gaw - u0dZ7bNQbjA37kMiaHckg1CjhSTnSSxHoMwcbWbYqk9y716J2naCGgRMlmJKJY2VgzABYQpsbyQMkgJh - ZMQioROSQYOkexfVvYHyb2DIBrnxBQrTJ8hPLCGFz7C5yeHdm/RbHRA2XqWKncsQRauv3NXvm48aZiYd - 1lqTRFnWAALTsjAdN9MYpAlpGo9ERwbmfcKQgiQJSaIQnaZIKTBtB9P2slpEHJAEPdKgj2lZ5CcXGDv2 - CNUTF8jNLeok7TE83KNze120b90UvY1bRP4BuYlpe2zlwnhx8sTxfHXp9LDZOLf20i8U06Q3NMr77e97 - 98P6J/769/OPf+YP3ujL7C0ZbwkA+OT3ftwNIt5V8yvv3u1PrXabPXtQ26PbU5i6zbR9kwXnFgsTTaZW - oNnP8dqtOV6tXaQTl5jxtjg7u8GRqVaWm5sGXsXGdl3SMMavH1DfrFHf66FVxMSs5PTFCitLM1RzJfzm - kG57SD9MEAa4OYmbN0msIo1okrW9SbZ2SvTqApOYUiHGK4BbkEjLRAgjW/ymxnYyfYHWkEYJyaBG2rlO - 2r1M6t9GiCFeeYLK/FHyE5Og2vRrm7S2NvF7AWDiFAoZVXi0HdBajViGmUNRJjjKtAZJlFmaSyMDgvuS - 5TRNRzJjPWo5WphWZm6aJglJnImOkFkhMQMQiUoikqCHjn0M06E8f1yPHbtIafU47vQkWiaiv7ujWzfv - 0bz+Mv2dddKoR2l2yShMLU24xdkLTm7smMBeHh5GlaBfG7Y3as0//4NP8WN/9n388Hc/xj/918+/0Zfc - Wybe9ACgd/4ZW83xUjcwvq0Vlt5zMJyo9ut1Y1jbYRAa5NQB8/IVlsqbzM8OKM/CxsEYz18/wp3BSYQt - OVq8w5K3RS5u0K6FCAtKk4LOdov6zX2GjTb5csrYkknoK6LIxC24LM4XOL5oMmUHeCSEAfSGKYMgRZDi - uRqvYBJZFQ6DKe7sTbG759FvazwrolJKKVXByRtIU6KUxrIkjmMgM4YvqYIkzMg5Secqae8yOljDcAzy - EzNMLB/DKRSIoy7t7Xt09vcIBiFaGpk3gGVlrsP3qcJKPTASyboDkjRNSAI/YzDCKPU3skwhjlBpMtoW - 2KNC4SiLGPEIVBIjDTl6PweNII2GJIM6Oh5gOh7VxbNUjpyjsHIUe6yIIhGDvQPRvHqH+pUv6OHhBoKU - 4vQiufHFaa+8cM7JjZ2zvcpsmnQcpf1w/EhlsPnKnfRT33WKn/sPN9/oS+8tEW96AHj2r33Y7vary3v9 - /He1w8KjTb9g9mo1EbT20Qqqep0l8QKLMzWmFhLsPNzcmuGFG8c5jGYpun1Olm4y5+1jqwGNeoqV9xib - LVG7G9DYGGDlFNMrDhNzNr39mNZWQHu3ybC1h0gPmZlIOHYsz9EjFaxU43dj+n5KEKYIrcg5CW7eIvbG - 2O3Pcnt3kt0ti3CoKXgxpbLCK2QL03Sy/rw0BEIKEDqjFytQEYiwi/BvkfSukw520FgUZ1YZXz1FruIR - D5vU1m7QPawRBTGmV8gYguhsapEQKPUVbwHTdpBWVhAMhgPC4YBsu2Bh2U4mTxwNMUlHLUc54hiYto1K - Ux3HEUkUCq3S0Wc2Ru1FSyfhkLjfJAna2G6BysIZxk8/KUpHjiJLUiMionpPNC5fp3HtBd0/uIHlFSjP - HTerC6cnLLf0iDTsp0y7WO4f9EzNMImCWvAD33gh+eE/8Rj/4lde54c/NstP/ZNff6MvxTdlvOkB4Cf+ - 3LfPdIe5x7Z6Ux9oDXNLvW4s+o0GUb9NzhowZdxk3nyJxZU+5WnoDw1eW1/h5Y1TDEKL6dw+F2Zvszjb - wy1o+p0E23UYn6lQXagytpTDMQf4jZidm5obt2CzZlH3XXZrko2NAevrm5iFHqcezvHQ6RWOTI6Tdlv0 - u0M6Q0UqLKTUeIZPrmSic2Ns9le4tTXJ2m2bpBeRs0LKEyleUSJtE2lmvXshwDTAHCkQM4MPTdprk/Tu - kQ6voIJDpLAozp5m8ugJxhfGGLZ2Obx7g9bWLioFtzw2sibToxkGAo0mDkOU0hi2jeW4CMMg8n2SMACl - HugTECLzG0izTIJRjcB2XWHZjtBaEYc+UeBrrZUwTRPL84TpeCAN4sAXcb8uVNAWTr6qqysXmL30DeQW - 5jR5hVYxwUGH1rXbHL7+B6K39xreWEVXFs5RXbxY1ko8qZR+3LDdSSE8PewcDAxLhNd+5x+mSMmP/fB7 - +Cc//8U3+nJ808WbFgC0/ts8+5f/HLUdfbLle+/bGs490uya44P6Ab3WgDgMqLo7zFjXmfPusHwkxS2Z - 3Nss89LGGW61jmMmLY6Ob/Lw8TqWDmkdpAxrCUkrxq8NGXRi6rsBN77c46WXUl68aXN7OMYeExzGJXba - NpsHBlsHJts3e+y/fA+jscvStODJd55mea6M8AfU95t0BgnaKyJJcWVAsSJIcuPshMu8fnuKu7cdVGeA - WwgozibYuZHZJzLrxZsiGzxCBgJKQxqnpP0uqncTNbiMDmoIw8UbP87MqTNMLE4SdHY5vH2dvZt3wMjm - GVie88DK3HIcpBSkccYyNC0HJ1fIpMZhQNjP2qhOLo/luFlXIIlJVTrSKWTMRNvNZe5FWos4GJJEASil - DdMUpuMJ03G1MEzSOCLs7Ol02MD2XDG2eomZC+8ht7goRFGIKGyIqBbq7q11dl/4dXq7VzFdwdjyw7q6 - eLHiuNWLKk6f0jo97uTGmvnKfNcu2MrOW/o7Hp3Qn/zw6bcJRf8Z8aYFgGeffR+EE+L2mvFwJ/A+shvM - Hmt2VG54sE63mxWoJuU1Fp0brIwdMrukCAyHl6/N8ereKQ6SOSZyh5yc2uX4TBcv7hE2fdpNuLlj8UdX - bL74YsTLVxLutAscyjJ+rojtmnimwpYptg22ZyJdj17qstkwuHWlwdblu+jGLVaWHR57+jhHFsYw44jt - u1t0A0isHIbUeEaI58To4jj7yRKv3Flg7YaNvzukWhxQnEpwqyORjjIQpkQa4oGNy32Wfxopkn6fpHsT - NbgG0TZCe7ilI0ycuEh1rorQTbavvML+rTskscStjJMbq5D4A0gTLDurPCZJQhqHWI6DVyghDIMkDPG7 - bbRKsWwbJ1/EGC1mpUbzC5RCCkNbjoPl5oRC4/e7Ihr20WmM6bjigX26NEUahyJoH5IOm8K0TDG28rCe - PPsM1ZOXROr4+MNDwlpM+/omh698ge7OlzFsxeTJdxtTx99RKk0dPxV06h9Owu4x03F7SRD1/U47FEK8 - TSj6z4g3LwD85AcF0Zh3Y6P03k6Y/656OD7ZasfC379H4MeYasBs+iJLhTssLPQZn9F0ghxffH2VGwcr - BCLP0fEdzs/vsjrZZtj1ub0p+PJmmdu9Cn27iPJc8ByEbWCaEluCQabO02nyoLpumCNrb8vCd1zqEayv - 19m5co9o+wanjro88sgCp0+uwHDIwcYejX5ErE0c18HSA2wzRhYr7AYLXN1c4OZli/5+yLjbJT+d4ExK - DGGBNrKRYgYYBkiZTRVMU00cpiT9Lqq7DsEVSLYQuHiVVSorZ5lcncSQffauvcLB3XsMW0OKU7O4xSIq - CUnjjBloWBZJEhMGQ6Q0sVwP03VIohC/18moyNLAyZcwjMycNElirbUSWguhFFoaFrbrCSElcRwSDrqo - JBaGZWE6HobtIqRAxSHxoE3q14Xt5kRl+SE9+9AHqZ58iMTsiyhoEdQa9O/uivrlL4vajd9FWEpUV86a - k0ffkctV5k+EndZ7hq3G0STqS5A7P/Chk9FP/sT38ff/8Y/zt/7O20NQ/3/FmxcAPvExL+iIo/c6U++r - +6VnWgPb7ja6DBt7kAaUrTpz6jkWxzeYPZJie7BTL/KFa2dYr01gy4CHjuxxbqlO0ejz4oshf/i8QV1V - EI6DZyVYhkYKjRQKiUDen+47ugNL8dXfE5nPvyFJpUkPl5qv2D3osXdlE93Y48h8wkOXFjl1ahE9GNLc - b7B/2EHbOWzPwybAsUE5efajBW7uzHLtWo6g5lOQXYozMU5ZgHRIUwlIDFMiDRhNFEOprMef9Duk3Q30 - 8DKkBxiGg1deobRwnMkjs6B7tDZvsXP9FoP2AK8yiVcqYtkGcTBEaDKBURKTjizELMfFtJ0sjfcHRP4Q - 07G1nctjWrZQqSIKAlSaCkCYhqktN4fteAhDkEQBwaA7YioaGLaLYdkIKbVKExEPOyTDhrBzrqjMnxDT - 59+tSyunEHlLBP09hvt1hpv71C+/SvP28yADUZxZtsdXnyznx5aPmVb+kWHn4JEkGjB19OjW2OInog8e - ucGnvvMh/sUvX36jL9mvyXjTAsCPfuK7Kv3AenJ7MP3MwaB6qtceykGjxaA7wJVdJp115ozXWZppMrMs - 6A4trm3M8cLWQzR6DuP2Pk+f3+fodIduLeTVK5pbWyZmwcNxJYZOkfcLZnxl0SME4sHcv8yxR2mdtdf4 - qhmApklqOAyUzeEwZne3zeHtbazBPgvjMRceXmJ1eRJbCxr7LeqNHsr2sBwTz9aYpiCSBWrhHLe3p7l7 - t8CwFpIXQyYnI+yyieFaoLJBI2IEAkJmZqFKadIoIh00SXtb6MEttKpjWhZuaYXi9AqFqQmk6NPZX2Pv - xnWCvo/peORHoqPYHyANmRmOjBSIQgjcfAHTstFJQjjoEQcBhmkJ2/WwHBeVJDpTHirEaACqkJlLsZAG - SRyKOBiKNI4wDFPbXg7TcYWQgjTys4wg7GvHy4vS/DExfvJxXVo9jVFwGbS38Q9qDDY2aN++RnfrJknc - EZXFc9746mPj1blTq45XfuTw9vVL6y/9a6HUoNtvWL0/+a0r/Pxvvj3Y5D+NNx0A6LVf5Nl/cIy1G3MT - /cj85v1g6vG9QWW6X9uX/WaDoS8piD3m7Oss5e6yODukPCNZ3y3z0p1VrnfOoXTKSnmLp843KJldrr3s - c3NL0o5d7JyBITUqVaOB3eIBm05nyTdaZzRbpdSDR1YQyz6jEAJDCAwpEKZJajn0lMF+K2Zn+4Dm9jZu - 2GB5SnLh3BTz0xUsKanvN2h3hoQpeJ6J50kMUzCkwv5gmjubk2xuePTqMQVnSGUswqpk76FSc2TuITIH - Y6FHo8ggDQPS4SFpf4t0sA7xIZabIz++RGlumfzEJIap6exv09hYZ9BuIw2bXHUcy7WRaHSSjnwKM76C - kBLLdpCGKVSaimg4JB3xAWwvJ0zbEVopkcSRSJNIgBCGkfEIDNtGSEGaRDqJMx6BYZhYtovpeKAVaTQk - 9jvoJBCWl6e6eoHxk49SWj2FyFmEgxaDnR3dW7sjems36B/cVUr5lBePu4XJ1an82PJJ08qf1Ik+ksSH - hchvtj7xoUd6f+77n+an/qcf509920X+0b/4zBt9Ob/h8aYDgGd//Luh9Jti7e7Tq+3A+Xg9HHvosF90 - +wdbYthsEiYGVXWXRes1licOmFuIcEqS1+/M8uKdI2yHi5TzQ87NbfPQ0TZpu8eXPj9gu2UTeTlMQyNG - klkxmvTLqNqdceszr74U0EiQ/+k2YDTTT4j7rn7Z15ZN6jq0Q5O9esDOvS0GBwcU9JDjSx4njpSZrOQg - Seg0B3T7EXGqcVwDz9MYlkE3HWO7OcHtzTEOdiyGnRjPHpIrxXgVMBwrc/ZBZLMDDBDG/RoBpL5POtgj - 6d9DDdbRSQM7V6Q4fZSxhQtYhVnSWNPZ36BX3yPsdzFMC9vNYTpZkVAlCSiFJhM1SStjCAopSeOv8hUw - MoC4P9H4K6IjgWnamJY9EiRpkjgkDn3SJBkNPXGQlkOqFEnQJRm2QSu88gQTRx+itHqa3OwiwrVEPOzT - 396hffua6Nx9nUFtC2mYKj+5YOXHl+Zz1cVTTmHiJMpc6Nc3Pcszmyff+d8Pvu/9q/zwdz/MP/93X982 - ZW86APhrP/RhaQXTpd32zKXDYfm7WkFxqdUzxeBgm7DXxpQJE/oKC86rLC33GJtWRBi8eGuFV9ZW6UR5 - lqdaPHpsn5VKl8Z2n+eeC2jEHkbRQ5IJYoSQiFHfTY3yfS0glZJEQRIlxEFEGquvuINiYGSYQJYvfAU0 - JGAgwLaILJd2YrGzN2Dj5g7D2h4lc8iZ41WOLJWYKDvEQUSvHzMIFGmqsExNIZ8iHYeeGuPe4TR3N6rU - dwySKCGXCymXNHY+ywjEaAy5Ydx3MNYkCuIYkmFAMtxFDW6hBlvoqIth5SjPPUR16TxOsUww6NLc2aBX - bxAO/WzAqTUaOCIljOYMqFTBfWGR7SCEJPIHOgkDQAvTtLRpuw+YhWmSmZOiwTQdYZi2EIYhVJqQxAFx - GGRzEoQYZQQ5hGEQD5rEgzo6DSiMzzN+5ALF5dM409PgChJ/yHBnTzSvXtbte6/hN3e15RZ1cfqIW54/ - PWe55UteafK8wBz75EdO2JogcPLJ8NsenVE/8M0n+Ze/feeNvrTfkHjTAcCP/OC3ShnpEwfD6ju3h9NP - t/tWudfq02/W0XGPkttiRrzKQv46i0dirIJgt+7y/J1T3NhfgNjn7NIhj52s4SZ91u6GvHxNMRQudsEZ - AUC2938QAhSSNJUkkcIhYjIXMV4y8DybgQ8kKQUzwhURkoRISZTOCoP3CwZa69HgUMByiB2PDibr6122 - bm3jH9xlugrnzkxxfLlKxTMYtDr0gxQ/FqhU45gJBS/ByOfoqAlu7i9wb61MfctApiG2E5IvK0xXjkxD - jMxm/H4yQ2ZhphJIg4i0v43qXSMd3kDHdQzbpTx3nrGV8xQm5unVGjS3N+keHoLWmK5DZjGe1Qa01pmA - KM5UiHYulykPtSIcDkjCAK01tucJ07JHPocZqzAZ2Zwb0sL2ckjTQqUxUTgkjQKElMKyHWwvj+Xm0EoT - dBtEvRpChRSnV5k4/hjVk49jVopaWykqDMRgZ5/m9dd14+bzIugcaK86Q3XhnKwsnJpNk+QZw/TOWk6x - 2G8OZK++EX72Fz/X/zvPfg9/7a98O3/1Rz/EP/xnXz82ZW8qAPjVn9dY7j0ziO0nDoOx92305062WmFu - WNum3w0RasCEc4956zqL5V0WVyFUNlfuTPLSzgX2BtOUxB6PHN3jwmqb5vaAGzdT1uomiWVhOQKh1Ch1 - ZwQC2YDOJBHoMKE6bHKm0ufdD1u8470nOHJygWB3j0qwz1KhRxpH9GKJj4MWElPoB7Jcke0msgMvBYaU - CNMizefpaJP17S6bV+7SXb/B0qzFhXNTnD09h6Mieo0WnWFEkEqEYWKJgJwb4RYtGsk0Nw8WuXqjRGNb - 4MR93FKIN6YwbWNk+pnpC0wDDJmND2AEBIkfkvT2SLsvo4ZX0WqI6VYoTp1i7uw7MiCo1zm8c4vm9iaW - 42K5HtIwtNapuK8MVColiUItpRS2mxNOrkAaxwT9HmG/hxACp1DUpmULKeWIP5A9lNKYpo2bK2QUZDSR - PyCNA4TWGLYjbC8nTCcHaB35PaLOrhBCUZxe1TPn3yeqJx4VqWegjJQ0GIrosEnz6qvsvPjr+N1D7EJF - T6w+ooqTq3NSOo+pNL1oWu7E0YunWmniJ+Or89GRx/6m+qZTm/zQRx/hp3/prb89eFMBwLd94Fkm5nad - RLofbMeVD6z3Jmfq+x2rv7NGz5fYdJk3XmM5f4/FqQ5Ti1DrF3nh2hLXWqfxRYnl8jaPHKuxMtHlxitd - rt5MaOEhbBPTGFXwpZmZcCJIEo3vK3LC5+hYn2cuhJw/oskBqiux45CTx4YcWUqQOuXGlsFazUK6FpYl - MQVfxRewRpN8xVdsuw0D0zAQlkVoezRTg+3DgDsv3GGwtcnCRMQjjyxy4dwiZhjQrbc4qHVJDDdz8VEh - BS/GyZk09Sw39+d59eo4vX2FlfQpTAd4FbAda1SfMDCsrwABMnM2ThUkw5i0u4fqfA4V3AVCpDVGfnyF - 6ZOPUBibIPT7bF2+QmtvD2mYIlcuY7kuiT9ACIlp2iJJYh1HISpNcb0CTq5AmibC73Xx201hmAZOLo+T - K6DJagBaZ2QirbQwLUdYGXuQNI0J+l3iYJhlEm4Oy8sL080JkIS9BoPamkANKU7OMv/QB6gcu4BZLROn - bZ36Q3R7KOqvv6YPXv0sfmcDp1jV40efkGMLZ6e84uTDwaD9TdK0yjoV7d3rvxElyTDJVYrpR98xx8/9 - xnWeffbZt+xsgzcVAPzoj/5fjeOTn51ZKP3+t0+W9t5fLJfdVtMQN28l9HohhXSdFfNllsZ3mZkPKI3B - Zm2ML1w9xlpnHsuFh5Z3ubDUpKB7vPCFHjfWFUmhgGkbmKO0PxvLLUm0IApS8BOeeHKMD/+JeY4cF+zt - hvzGr0Y8/0JEKyxx8pmnqM5USIYtplcXKU9Ms7/Vp9P2SUgxLTMrlAk54vdLtP5KbeE+h8CQgGETGi5t - abK5P+DOS+v4O3eYyvV48l0nOXtqnrJlUNs65KDWI3FLCNPElik5y8fyTAbmNFd3l3n9xjTttRQn8ZmY - GGKXBaZroFMLYUikKZDGqNUpQMsRj8BXJJ1t0uaXUeF1IER4ixQmlplYOsXEypIOB3U2X/uCaGxsksYp - ldk5hDQI/QE6TYVpmMK0TKIwFEmSCDdfVG6hKAzLxu+2td/rgEqFUyjiliqZ2CiOSJJIZDMPNMIwcbwC - di5PEkcEgx7hoJttGywHw84hR9rpsNcg7Oyjk54uTi4xdfbdjJ99pzDHxkW3t4MOB6hWj/b16xy89nka - m6+I3PQyUyeeNqeOPVWSwnqid7D9PpVGVWnIYNjsN9I4TI88/t0aeBsAvhbi2b/7k2ODw7sX9r74v3wg - Pvy9M6tHflMcO9VnfuUscVRBdLaZ1b/P4myDyUVNAlzfnuG5O6epdV0mCm2ePr3HylgLvznkxZcDNusm - RrmAYWbpfxZZrh6nCpVGeGbMpaef5qGnvoVkJ+H6y02+cGPIljCwFqc5f/EhpA/1rT1WVqtceuQIFx++ - hClsttf3abU6hHGEZZvIBy1FmQlsRhX70QYdtEJIkKZDbLm0MNja7bJ5c4ve3SvMlEIef3KR8+eWqeZd - Du5t02gOGCoD2/NwLHDEENMz6Ysxru2vcvX2ONt3BTnVo1Id4M5qTNdCqGxw6P3W4chaMNMapIo4GBI3 - NklbL4H/HEJEGLlpcpV5MbY0LaZWSoQDn4N7O+zeWNMq1aI4Po6VcxEo0jDAtGwhTZMo8AGF7brkimWk - YeL3OiLodlBRSK5cEU6hKKSUJFGkkyTKKBfZEcKycxiZq5EYdpsMO02tVSpM28UplLBcTwspicOhCNv7 - qKCtS7OrTJ99F7OPfpMWpYLwgyZRv03caONvbrD30u/S3HgVu1yRY8sXzMkjj5ctp3g+CcLHh+2Dk0ol - La80u7vxyr/Vf/b7z/Kp73qYf/6LX36jl8F/0XhTAcDf+NRji+2BeM8fbb3rySvbp+aGdzcYly9y/uwX - OXWswVzxAL13ndmpIVPzkr16jpc3jvLq/hkiP2Clss0zFw4piC4bd0Ou3JPUQwen4GAIjVDqK2O7dSbD - RWssA44enWd+sszO6ze4dXuXnUFKNwrI5QxOnz2C5+Y52Ev4jd/b5tXXtjk6L3j8sSUeeeIchnRp1ofs - 7daJNdiujUQ9eJ/7LCOtGM34y1iGQoKWgtDwaCc2O/UBO7d26d1dZ74acuHcGA9dOkbeFLT2a+wfdhhE - 4BQLWCLGkhGGa9JJx7lbX+DKrTH2t0zySZdixacwlWLYFkJYaCURhhixCrNChdaQJAmx3yVpb5G0XkIP - XsIwulhuGbdyWpfnHxGlmWMgDFFfv83ujcuoRGsnX8KrVkQaBcT+ANO0BGSTkNOMEixypQrSkMTBUPvt - JiqOcPMFvGJJmLYj4tAniUOhVDqagWoJ0/Z05kuIiIMucdBHq1jbjifsfFGYjqeFECThUISdfaGToShU - J5g8+TgTZ96BMTZOlA4YNLa0aveEv7XOwevP0ztcU9I2xNjqw+7EkUcnytNHjyVh9PT6i792Jk1a3dx4 - vrN7+Xr4iQ+f4F/+1lunY/CmAACtf4dnn/1+1l7ZP94NrI9s2Y+eXYsfLr1+Y571myGD9WtU+jcp+ndI - hh1mF1MKVZPLdyZ4ceME68Oj5I02Z2Z3ePxMG7/e49UXA9ZaFr50cRyJHJH99AM2DyOHm5Rw4LO0MMbC - dImDzT1ubba5VYtp+YpUOYgkTznnMDFm88KrW3zh+W1u3KnTb7aYyClOn15gZWkKAwgiRS9I0EbWYhQ6 - /cofKkZav/vDBkfUYsO20abNEJv6ULF72GPv9i7hwT6zxSFnTlY5c2Yez5AMWn32dpqEysB0HTxbYxsK - haQRjrNen+banUnqOwLp+0xUArwxhZE3UcpAKwPTGpGJRjoDTTaQJOp1Ceqb+PXrqGAbwxbCHTup8xPH - KU7Oiny1AMKntnaZw417DPuxcApl8pUKgkRrlYDWo/pKRlk2TBvbywk5siX3ux2hklgbloVbLCEMkyQK - SeIQpTKewH2z08zwVBMFQ6Kgj04TbMcTtlcQhuMJdELi9wj7dQQJueoE48cfp3rskvZmFoUftPSgsUtS - bzBYvyvad67S2bujpe3I8WOP5sozJ2dKU0eOp0P/ofbWzlKS9mQYNBuf+tYnwx/709/AP/03z73ptwZv - CgB49tkfEmDZN26Kx1pB7uOtdGKhGXhm89Bnc3+cOxtL9DbqWINtpmYjFpY1ieHw3JUlXts+QktNsDTe - 4NLyPqfnuuze7vLc8z6N1EV7DpbUCNRXFn+WoyMkhEFEp9GnUplk/sgyC5fGUXm4dXkHNYwZLwqmJ3ss - H22yfKJN3j1krDigkAsxgga6VaPEgIWxmBPHTCpuQDoY0mqlDMNswqhhSIz7Ot/RktMjBqIYDQUVQoMh - SE2LASb77YTt3SYHa5uIfp3ZUsT5M5McWx2n4Dj02gPq9T5BKjEtST4nMA1FpB1qwSRr+1PcXa/SPBSI - OGSsOMQtK8yCgZTWqBiacQhMKxMeJQkMuyntnTZBcwuGd9DRujCMgXCrsxSnFilNTWi3GKDCOq3tDdHe - rxH0Q+3kisIt5LBsgySKSeIEECil0aBt1xGmZQsEhH5fhMM+KIVl2TheHmFkzkVx6KNVmhVPLRfL8TBH - fgRJFBD5fZRKMSwbO1fCsB3SJBaJ3yHxu0gJxelFJk49RvnoRZzxWaKwJ4J2jeHuLoON66K9doPu3j1t - 5cu6NHfUK0wsL+XHFo96ufETpMay3z2wKotTu6/+6k8lf/GHP8if+e7H+Gdv0uEmbwoA+G//1DdZotOZ - u9MYe9eBX/zmRt8r9po9dPs2cQqxOY4drDOe3+bYyZjKmKbRc/n8tRPc2JsjBc6vHPDwao0xs8+tqwO+ - /FqMb+cwPRvjfjo+er+M6ktWB0hSgiBFmi6FgsO5h3JM5HrEW7c4dSLh8acizp/uMlluIaImRSNkPAc5 - FCYQhRH1vUN63TqGMcRTXXLJAN33UUlKJCRRKkm1xDDEgyQA5IPFr3VGNxaj7YEQEuU6DLDYbyZsbxxS - 39zCTQYsTZpcODPGwkwB1zLodga0uwHDQGHbgnwOHCcloMD+YII72xNsbhZoHWpMEVAohXgVsHIG0rCQ - QmaGJDYgIIqg14bYj7QOD0TYvEbYuobyN5GGj1sqUp6dozw5hu2lIuzXdedgl06tSegHGKaZTSUyjUw/ - kU0oyUIIIQwTw7QBRDwciCQI0DrrDNiOm9mRpcnIxTgbkWY5HqblCSkN0iTjEWRdA4VhOti5kpa2g1YJ - Ub9OGnYxTENX54+L6up5cvNHMStjaBkTtg/FYGOXzq0vi/bGXYbturaLY2lp5kixPHtiKVeeOusWxo93 - d/dnQAm7IPqPfuf7g6cnYj7xkfP8/G+8ucaivykA4C9+/7fmAj99eLM/9q7t/tjFdlfZ/WaHQbOOrRvM - 5NdYcV9idXqbxSOKWEvu7Fb44toFtptlcqLOk6f2Ob3QYlD3uXI94tqmAM/Fdk0k9/fhGc8fPSrU6WzU - tuU5pDqmWz/Ev7ONqPdYPTLGY++vsnLc5uC6z40XQ+5ekZhuCT/N8eJrirWaxUHssRc63NlLuHa1S9AT - jBVKrMyVGM8pRNAhjhRhIolTiUIiRsQdMZrgc5+GrEfFScGIR2BbaM+jp232min3rm/T3NrGSzscXy1w - 9tQ4UxUHQyV0O0P6gSJMNKYBeS/Fy8GQIlvtCW5sTrO37dFvaUwnIF+IyZdA2tnkYUmWEaRKE/hoaWXT - kKNBLPr7+7TvvUTYug3xoZAYuJVpUV08QnVuAjun6dX36ezX6dX6qDTVwhDCNCW2YwvTzKYZJVEs0iTN - xp25LtIySZNYRMOBTuNISCFw3Jw2bVeMhpToJI5EEoeZnZqdpf8jWrKO/AFJ5MPIytz2iphOjiT0xaC5 - Q9yvYTsWE0fOUz16AW/+uCCX01ompP227q1t0brxEu3N68T+AKc0SXXpnJefWFqR0n7S9krLcaBKt774 - kun3a4HnTg9+8MMn+Bt/40/wI598N/+vn/nsG710/nfjaxoA9Nav8exPfYD1m25xEMn37/kT79zqTyx2 - 621zWNtnMEhxdINp+xaL9i1WpzrMLsFBK89Ltxd5tXaBfugw627y9JlDFspdbl/xubamORg6WDkLx5Jf - YecwUv7df38NhmniejYpmlqjx0uf26LTL3P6mQ8yNb5I657kc/+hzx+8IHh9r8DEkQKlWYeDocGdmsO1 - HZtGIBkEJqgqiyfeybHHvomFR97J+Mw0RRFSMn1sHRBGgiDShLFGjWy3hGS0K8iykgfipKxEjoFGGBap - 7dK3HLZrITdf36G9foe8bnL+/AxnTowzO+YSdHt02j7D1CBOJYbUFN0QL28QmWXuNea5sT7N3j2bqJfi - OQFeKcUpjOjFhkQpQRAqTBu8PMJ0IBxCbU3T2jigv38NHe8IoQYYwsMtT1FZPMLs8ZPCdKq0D4fUNjZF - v9nM3IhMgRBaGFIIw8wETVEQkESZKYlbKGonl9Nx4BP2e8T+UEjbwckXMU1bACRJhEpirVSCEBLbyWnb - KyKkFGkciHDYESoKtUBgOjlh5QqYTk7EoS/8zqGIuvvCzZeYOHJBT597Bm9ulcjUGhEJ7ffxtzZF49rz - 1G6+QJKkeNV5Nb56Sdq56lGE+Yhp2sctO1fye7UwTf3oiY/+s+DL//b/yY/+mXfzqe98lJ/+9y+90Uvp - fzO+pgHg2R//Pij64t7d8ng3tL6zFlae3OlVi72DXTk43GcYWeT1AYvmFVarOyzN+ZSnBLe2x3nu+ip3 - ukexHM3p6W0eO9kir3u88Pke9/YloZPHce4r/+7PytNfEfaQ7cRHDTsMIVFC0o5jjEqeycky8e4WcW2H - mRMuldUlVGGR4WCImfa4eMokDRU7GwFi0ObU8gzf9p3fygf/9F/g5Hd8An32GeTioxQnTzJm+kw7DeYm - QhwR4w81/UFKEKssG3iQEYCUMpPm3p/+q8AQYMqMwJQ6Dn3bYesg5O71XQ6uvELZHvDQhRkuXVhkpurS - 3juk3fXpRxIMB1MqPDMgX4DILHGrvsyVO5PcveVgDHw8z8eZSrFciU4FQZAKw9Q4Hrg5IYQE30cPO4je - QUJ3a4eweROhbmuDCMOoYNhLVBYfYe7UY9i5Ev1mm+1rNxi02iMFoZsZlsYRpm1r0zJJwlCoNBGGYZEr - V7G9HFEcar/dEFG/i+162s0Xsb280CrNrMqTCJUmAiGE7eSxvQKGZROFPkG/TRIOhUBge3lt54rCsDzS - ONZBe4eovydy5RKTxx7VC499SJjVKSKRkqoA/EAnh7vsfvkzHFz7go7DoSpMrqiJ1YtOoTq3YpjuYxr1 - pGnlja3XfmXglt1EGCpJg1B98lvP8DO/euWNXk7/X+NrGgB+8kc+ijT6br05dmqnm//uRlA8W++7Rv9g - h7C1D0CFNebNV1iZazA1lyBtwWt353j+9ioH/hjTY0MeP7HHqZk2QaPHF74wZLdrIct5DAOEVg+ouqPS - f7bs73vpj3r1oBEaNC45K8ZLNqgdrrF10OSwlXLi2Dzf9k3ncI1JkoFJyWqSpgMSFeO3Io6cvMj7fvAT - 6FPn2XBy7Kcat1hkZnqecFAgGgYUrXUuXCrzyJNHsI0SvVbM4UGTVCtMx8Q05WgO4FdIRGJEJNKj4oEU - GkMKdC5Pz/TYbqXcubzDzqvXGXd7XDxb5emnzzCWNxjU6uwftBmEYHp5DBJc6VMspARmhY3uIi9en2bt - joPZ6ZMv+XjVCJVoLbTEMKTw8hJpCaJEC5WCSiEKoV+LaG/sE7VeRiTXsRwTaRaR9gSl6SUmV09Rnp6j - fVBj68pVuvW6loakODEmtIqFSmLhuC6Gaek0VYT+ACEFxeq4sHMFVKro1PdFMOgKwzC1V6xoy8uTRIFI - 0xitElSaaCGEtqwcTqGM6bgi8gcEgzbRsIthSGG7OZx8CdMpoFPF4HCdsLsjLFMxffJRPXPhfdgzyzoS - CYP+IY5ItarX9P5Lz4mD6y8w7NWorlxUk8eetCZXHpqKh4P3Bd3Wk6ZjG1IafhqHfaROP3Syqn/8L38n - /+QX/y5/69M/90YvrQfxNQ0Af/ETHxZuGCwd9HJP3OtMvKfWc6bbzYBBfZd00CBn95kQ15mzXmPlqE95 - CtpDyUtrR3h16yi+rzg6XeOpM3tUjS47Gz7PvRrTil2cUg6hNTpVD/bV8CDbHhXgxP3SwFc4/LYEldBr - Djlswr1Dk+evJVy7vEXj7nVW58s8/NgRpo/Oky8bSNWhtRlSmjnG6vvfTW16noblUkUzK2BMGljFMQ7a - Q174zAukSYuVFZeLZ1c5d+Y445PzNPa77GwekMjMaMQ0jEySO5oz+CCkeEAwkgIMKUlMl55hsdtPuP7S - LnvX7lLUu1y6NM2T7zzJZN7Eb7XYWNsnwAY3jyEUrhngujGxU2GzO8/z1+fZuG2RNkPmx2IxNa1EriQx - LJNESeJUkaRZ6cSyMtPSwNdEfkrar0Pvi+jhVdK0g7ImMHLTFMenmTtxjvGlo3QO9tm+eYP9O3eE6Tjk - KxWUVlonMUJrbC+H1ppBr4MQErdQxCuWtEoSevUD4XdbQqApjk9rJ5cXaE0c+iKOMh6B1lobpoNXrGYU - 4yRk2G2KaNhDGgaWl8cplIXp5HQaxwxb+yLobGMYmulTTzJ78X26cvQh3fPbDHo1TBWRHNZoXXud9S// - jui3DyjOHWPqxJOML52Z0HH4eBL0H0qi4UwcRAfDVr9TmZ9j9sxJ/TYA/B+MT33vx0QU6fN1v/D+e725 - i/WWLvf2dxm0++gkoOrsM2feYjG/ztGjCjNncnujypc3z3KntYKTNjg/v83jJ2oM6wOu3Ui4uWsSmR5u - 3kY+UOnB/ar7V1h5GpAwkgUrlaKSNAMNLYiUJNEWWDZOJY8vLdYOYm5c2WVvbY2cWWd5VbF61CPuRzjG - GF55md7EFFs5i+f3dthuHhIFezSMF7m3/3kuf+kyzcMhfjskbe1SIGB5boqHHzvN6rEV6ns9djfrNBpd - UgTatEm0hRYGCMFI35MhmMy+J0d/RyoteqbFfifm3vU9ajdv4gx2efTRGR55eJWl2XHaBzV2Ng/ppyaY - Lq5jYYsAy9Jop8R6a57La3OsrZkkQcTU+JDCnMIoQDzUJFHWPTW+ivVse2A6CiFj4s4+4cGrpN3nEeoA - MzenTW9ceOUJJlZPi8LErAj9gO0b1/X+3TWk6eGVirh5V8T+AJUkWI5HFIX4wz4qTYSXL4rS+CRaKe33 - 2vQaNQkCr1jBLZS0EIKg3x3NQVCAFqbtaidXVpbroXSqh506SdBDaK3tfBE7V8K0Pa2TWIf9hg5a68Lx - TDF5/IJcfPRbZGn1ougFPR0M26h+C9lt0b51RW++8LvK7x/gVSfk5LF3OKY7Nj1stM80N3felUT+fGV+ - bm/2zKnBN50wkh/66MNfE2Kjr1kA0Pqf8rO/VBQTJfl0M8h/aGs4s9xohK6/v0ZvAKiUaeM2i7m7rEzU - WFzWDFOX56/N8ureKRrJJNO5PS6t7HN2scP69T6vXklpJDm0ZWEKleWr+qvv9nrUAfgKQ+9BZqD0A6ML - aRgI0wKZ8Wdty8CxDQzbopsKNusBN260aNX6OCJibtxgetwjimIa+TWuB5/ht174aT774r/iuWu/zHb/ - t+g3LpNuDujtW7TbDuUJi939Ds99bo28GXD+ZInHHl/l+JlZClUPpUAPh+TDNmLYJRwM6IWKVBi4Tta+ - Q2tUmg3rME0Lw7ZJDYt2YrDTHLK5fkjtxgYF1eHi2SIPX1plcX6c3kGdw/0WjV6EmcvjuSYWIaYDocyx - 0Znj+uYUN2/nSPshFWfIxKzShglBkHkOaBCWkw0/dXJgeaB1Shz2STu7JI0rJO0vCqV6WnrjuIVpUajO - UJld0qXJcaHTodi98aJobO+IKDJ0vloVds4RcTDAQGjLcjBMU6g0JYki3HwRN1/SaM2g06TfrCEFuIUi - uerkiDk4JIkDVBprIYQ0LUdYbl5Ybo40iRj2WiLotYVOU5xcEStXxLRdoZOIsFtXYXtPWbagOn+E2Yvv - E/nFkyK1bdFv75D2O1jDmujduyl2r3yZ7TuvkmiM0vwprzS1OpWrTJ4eHO69Y/PF5ycMWwR23ml9+GIp - +eGPP8HP/Yerb9g6+5oFgGef/Vb52HShcm0//82NIP+tB/54qdXsS//gHkGoscWAWV5jpbLG0sKA8RnN - Ya/AH72+yo3aEonpcHZhj0urdWYKfV59sc9r11JiJ4e0DKROH/hqZy02NdLtAxoUXyXjzV6VEXMMibjv - kYfOiCwqxZBg2SbKsBkqi3pXcHgQcbg1JOilWEmCp5qE0XWavZeppVcIizvI8gGVpEVuc4i6YrO/ZdFK - LJZWcjhFycHA57kbdV67vkdJ9lieEhxb9JiwQmbzA47PxZw8NcXswhydlqa236fV6qGkwHRMDEOOQEtk - kmAjo/wGWLQjwX5jwO5GndbaLmNWn1MrLg9dWmZyLE/YHXKw16TdizDyeRxH4FoKYUj6aZHt7rS+sTbB - 5lYONQyp5mOmJ5WQNiQphBHC8iBXAq+QcQkyIWSq46AvovYmaesWqnsZlTSFMAzswrgoTuZ1ZdqmOK6J - hnVq63epbx+K0E/IV8Zwco6QhhY6SbQQQkjTJI4i0lQJx8tpx8tjmAZBv0PY72mtUpx8AbdQBgFJFIo4 - GGqttJDC0IZha8vJCdOyRRKHOhi0td9taa0VluNhFyraMG3SMBBBt0bsN7FsQ1eXTovJM09TWj0LrkW3 - uS3iTpvgcF83N+7Q3tkgGg4YXz0jZ049np88cmmuUJ09pqPkdH1zbWHYq0X0J3Z/6Lsv8N/+ze/hz3/i - Xfzjn/nDP9Z19rULAD/4TfleT5681Z74hsNh8clGz5a9ZoewuYckpmQeMqueZ2lqh/mVFNOFewdV/ujG - abaaZQrOkKdOH3B6rg1Dnxdf8rm5rpGFHKYlkYAwTIQhHuylM+OM0UguKUgxSHWml70/TUfIzPJH6Gy4 - 5v3+fBgLfB8cHTKTDzk2HeGJhEZTcffQYLeeEvX7OO0WY8MeU4WUGRsqPTBfkPS/5NHYKNIMbAJTkCpB - PmcyM2lz+daAF16uU9upYfhtFgoRKwsFVo56TK0IVi6ucuzxRzjzxFPMzC2gBiH9RpdWrUe/lzIcpAz9 - hDCGJCtwYJgG0rKITZumr9g66LG3vsOwts+k63NyNc/ZMzNUCh5xEHG432IQpGjDJO9JXAe0FKITV8VW - a0rc2ZwQtbojdJroybFQVKta2B5ggrQgXxQ4rsCyYEQ0RKUQ99uErTuEzdskg7sIVcOwTNxCldJYicJ4 - DrugCfst0Tk4oLXfIApTTMvF8WxhGGidxjwo4GqNNA0sO2MJojVhv0M07KNVKtxcQbi5AtKySUJfx8EA - pRTSMIVlexiWq4UQOo58wkGb2O9pKYSw3axGIKRJEvk67NfQ8QA3l2Py6FldPfEw+cXTJIag227T3u3o - uHYoVGMT/3CbNA6VN7FIafpIpTS9upgvTx13vPJxv7+5iIjD489cav3B//QLyV/6c+/lZ3/1j8/B+GsW - AH7s+75tou1bT9/rzjy92yse6TT6YlBvEQ6GeGaPSXuNefkqK3MdphYF7b7N5c15Xtg6R6cvmcnt856L - h8wWeuyuh7x+I2GnY2DlHUxLYgiBfOCnfZ9hB0hJqiRxnHn6mVIj7otjACQwcgVGiKzYlWjSYUQhHnBh - esD5uSFThYhAmRxGBXrkaMUWhz3w2xqnp1kMYKGuGVuD5JrJ4MAmsU3yY4pKKSIeBJS9lOOrBpNjsDhv - Mj+fY3rWxSs5tEOHejem2++ijYRCAeYmxzh2YpFTl44xNZWj5AYUnBYFL6HgWdhCoYKAYW9AGEQoNKZj - Iz2X2LSpdRWb222276yR9trMluD8yTGOL5cp2CbhMKTd9hmGmT1azhN4Xoo2bBrhJGu1CX1vt0KvZ2KI - VIxVA12tQqGUDUDNLMwlti0wrexYJkAcaZJBk7R3D9W7TerXUHEEoiy8yqyozM1QmsphOQnDdo32wQGd - WoskFSBNYdnWCNQ1Kk2EVkqAEKZlfZWVeUg06JOEgRAIkTkRe0KYBmkSiiTySZIYaZiYmc5ASEOgkkhE - w65OwiFore1cASdfFtJ0RDxoE3b2tE4G5KrjTB6/SGHhFMbYIpE2SP2+SJo14r01+uuvi8b6GmEYKacy - IyaPXirlx+aPeuWpi5ZdWNy9crNanCqQ6uHg488cC3/wW07xL3/rJre+9Hf5Rz/9+18/AKBu/yue/b9/ - gDs3vPlOYH94YzD98HanON7f3xGDZpMghKKxx5x9i6XcOqsLAeUpg9ubFb587wjX26eQ+Bwf3+Kd55qY - YY9XX/K5vS/pKwfbvZ++3xfBf4UEpDTECZDGFKTPUtlnMh+SJoooFUSpHBFxssWfpBAnCpGmHJ0Ledcl - n0cWYzytuLphcrOZpyULlIoOXs4mwKIWGNTaENcEXlszrTVzs4KVY4rl5YiFCZ/pnM+46zM3k7J41OLU - WYdTJzyqBZvYzLHWsvnM811eerVBc7+LkRwSHtzly7/6Ot3DNscvVrn0jMOj7xGcueBz/tFJzj28ysnT - JZaXSoyXKqShQbeTEKYJoLEtE1wH37A5GMD6vRpbN9cxgyaLkxYPX5hlaTqHZ2h6XZ/eIGYYZdbDrpVS - zKUiNXLU/Alu7kyxtldk0JN4Tsp4JaZU0sLKS6RrjWzGBcLQWhpZKUUYCJUkIuo1idu3SQYbKBWiEgm6 - gFeZ1tW5aSbmigIxpN88oLF7yKA9RGkptNYYhsCyTSGFFOnInQidsQCdXAHDsoiGPRH0O8TBEMN2sN2c - MC1TgBZJHIo48rVWiTAtWzu5Ipab1wiIg4EO+m3SeCiEEMLOFbWTryANWww7NfzWLqnfojw1z/Txh5g4 - eUHY41MilUoYYkDSbuj+2h0at14Wre07KGGr/Piynjr+iGva3hnDsC9YljeXBmmxV99OVTrof/LDj8d+ - v8WP/Kmn+Of/5r8OmehrDgCe/Ssfg/HAuH69erIVet+9F06cPOh5jr97j2G7TaRGrr/2NVYnD1lYiLHy - Ji9dn+GFu6vsRrNMlXpcXN7jodUu7f0un//8gIOBReq5GDJL6VMFSZygEjVq9RkoLYkimK9GPHrcZ6nk - Y6Qx9a6gH5mkwhoZg2c/0h9GpGHKXNnlA9+yzEc+eRozTbn+6oAvvAR7AxNRMPEscCTYpkBLQTc22OiY - 7PoGgQnTUwknVxQnV00mS1UMVaU/0HT9mF6gMKRL/dDgN3+nze//YZMXX+mwXY/oJyaJdFhcgJyb8KUv - x7z+/Db7V1+kOnuL+TNdylMFJqfnmVuY4fiFPI+85zzv/IZvY2bqBDoS7K3fo9PtIWwXU4JpSLTlElgu - 9QBuXTlk5+Y6YrDDidUiD1+cZ3Eqh5FGNA/bYhAJwiRrjXpmTCGn0F5RHPpT4trWnLi37op2HeFZic6V - FcUqCCtzKhWGIUwTYVoIw9BggJKQRilxr0bSepnU30GpWKexJwQl4eUrTBxZYHppAhW3dXt/i4P1TaIg - RUgbmVGEQac6G3emCP2+UEph2i75clVI09DBsKeGzZpO/AF2Li9sJ6dNy9boFJVk046TONJCGNorVIST - KwphSIJ+WwS9pk7DoRCGIexcCbc4hpAmQa9Fv3ZXqLjL+OJJFi4+xfS5J4hMT0c6wTJDRL+tB2t39NYL - v0tz8y5KS4ozx+PK/EnP8UonpbQumbZ7wjDzOug1QrfsxoVFM/n4U2f1J7/tIj/7a6+/tQHgJ/7MtxuS - qLp2MPnk3rD00UZQnGx2Bf7BFsmghykSJtRlFr2rHFnpMzGtGKYWX7y+wmsbiwxih5PzLR4/UWO+0GPr - Tp8vPh/SwUN6NmYSUbFjJnMxIk0JI00QCxIMhGGQsyQPn8vzzDsqbO5rnruuudt28LWFbUoMnWDqBEMn - +EFIqmCiXOH4xfdx9OFvx7Y6BNEO7U5Ks6/pDMAaTfdFg0RjW+DkDALlsN1wuLumONjTWNplfPIiTvUR - rm7k+OwrCZ/58oBkYCBik70O+IaLUcwzOe5gYtFuWUyOpywuJ4ytSmqBxRdfthEqQB+22frDOrd+ZZ2b - v3yD3RdvMGyZ5KYvsProWU4/ViWqX6Ox22C/JpC2hetZSJ05I2vDJCrkOBxobl07ZOPKNZ02Nzh/dlw8 - cnGeY8vjRO02jcMWg1iQCEuYpilcEeh8TmEWcuwO5rm6OcuVqzbdg5ScHJIbS3CrYBpm5lcoJYYJhqEx - DCFGNQKRxoiwvU9Quyx0sC6EjIVw5iB2tWF6TB5d0JPLE8LLKdHYWhcH61si8BXCsJXl2joO+lKihZcv - ao0iDgPiMBC2mxPFsQkhTYtw2KN7uI0KA227OZ0rVYU0bRGHvlBphFax1mmsDdPCyZVwi1WEIRl0mtrv - 1kmCvrYcRzv5EnahgjAcEQ3bord3TYukS3V2ntUnPkT15GMMldBhEmuhhjqPLwb3brH+pd+jvnlXJwjG - Vy6oqaOXcuXpIyuR33+vNIyTlp2Lo2Yax5EfSUsnH3/XMf3X/y8f5Z/8/L/n05/+e289APgLP/CtljFQ - pzf7Y+9c700+Vu/KfK/ZZdhqIJIBBbfFjHiZpeJNjh5PsfOCnbrHF+6c4dbBLDLt88ixfR49VoN+n5u3 - Yl67LRkaeVxHMqlbXJrr8u5LkkefPsHY9Bw7WzGtTkisEoquybHVEsdOVrHzLn5qsrkN3bbGVDFLuS6T - ro8WgtjwiIXDsO8je+vk+l+iOHaN5Uc05947h0pzbF5L6PoRKRrXyUZ+60xgj2VobFvQ03k2Dk0uXx7Q - bXSYH4v5xm8+y5lzR0giG4cYxwiZnXSIItg/iLEMgWlbKGkS+BqZpjx5Mca2BVfXbDY2DXZuCfRuSm9f - sb+VsvWaZv1z2+x8/rfx8i8yf26LkxcEhhasXe4xDAWJkJjyK2PPTGmgLYeh47Hb0+L2nYa49/wVZP+A - syc83vGOE+LEkWkxrDdFvd6l2YvByQtDGsJIhhTzKWY+x0G8yOtrU7z4ck4Mtoe4DCnNR3hliWlapGnG - crQdgWWiDUMjDVAi2xrErX2dNK6heq+jDUMId0YQ54XtFkV1vqoXTi1QrNrUN+5wcG+NTq1DrjIunHyO - JBoIAcI0bWHaDmEw1H6vq718kWJ1EjdfFEG/S/tgi3DQw7YdSlNzmFbmUpwk4QOKsRAS2y2Sr0wgpUHo - d8WgsU/iD4RlO7iFMe0Wx7RpeSLoNkRn77aI+/sUxyb08mMf0pXjD6OKVdFuHWihfIpWSO/uHbZfek5v - XX8RbXpMHH+U2RNPGMXxpZWw135XmiTHpJRuEupGHAZhdX4unVz5Fr7lYp0f+uhj/M//7v+8S9HXHAB8 - 8rs/7vixeOfuYOw9d7rTx5qHfWewv8uwF2EwZMrZYMm6yZGxQ5aPQD92efXODC9sX+CgX2Hc2uLJkwec - nu+wdcfnyi3NVsdGWBaupZHEHDZi9lom5955nEtPTDEzHtKqd1m/10EpRaUkmamaVPIec1MOJ48knFvq - cWKszayTkKQmu0GOCAspIVApO1sdrn5xj8PP9jHqBVYevsi5d32QY+efYPfWHlt3txkmAcKU2JZF1sjP - io+uLXByFnHO486OzyuvbFO/e5P5Mnzomy9x/uFVSmMeQb/Gzk6Hw0aK5Vi4ORPL1hzsQbOuWVyOs8d8 - Qm9LMdxWrExrjp2G448ZTF0sYVRcOrWETqtGnNSYPmczNiWwk5CN9Zi9vRSvYGCYBgj5wCHJEBplWPim - Qz0R3Lvb5N4Ld7XR3+b4ksF73n+OIwsVoQdDttb3aXZCZL6StUcJ8JwAmc+LrrnAK2uLvPZ6ntbtvi7I - IVOzMc6EJUzXRMcmQgghTIQ0tDBNtGGCMLNRZ0GzJsLaKyJpvy4wTaQ7qQ13TgvHEU5OkM9L1drZ4c6L - r+v1K3fptQcUxsZxci5CpDr2+9qyTOHlCyLwByL0+8K0LApjEzpfHtNBv02vvoffOtRuvkBxfArDdkWS - RCLy+6g0FjprIWs7V8QrjQnTtnUY9OjWtomG3Wx8WmlMOMUxTNvTYb+jB7V1EbTXqcyuysVLHxQzl95L - mqvo/b0tbTAkxwBd2xZbz39W3H7uD1GmSXnhhJ4+/rhVqMwskHJx2Gk8rtLYsd3cTmPztSiJOxrNWwcA - tP5bvHZ5zhvGxof2/dJ717qT4539QzPY32AQWDi0mTOusVxcY2W2y9Q87DRKfOHKAlcax4ilzYmJbZ44 - 0WAq1+PFL/W5dk/RM1ykZSAMgY/Nds9jt2djpT7jVpsjszFxFLNfS9hrKKJYkXdS8oQYwy79/RoVe8D0 - uGYYm2y2He41bVIEni2wLYPENGlri72u5u7NAbd/dxfRTDm2MslDj11kanqK3Ts7HOw26QxC7LyLbZsI - MTLllGAZAsOzCQ2bW7sh62sNBtubjMkWU/kAkYR0hymNQUo3NOj2BX5H0W5rGh3Y2BYEPc1qNeHipOLE - tCZwJHdLBdbmx6icrrJyapbF5RXCMKXT7VGYEswdL7N0eprebo+D9Q6HPYHCIJczIE0y3YFhYprZlORU - mAwNk1qCuHunIbavrQl1eFecWHb10+88yvGVKWQcs357k9YgJjYdHNcRjpliywizWKCtp3l9c0FcueqJ - /TuhGDMHVCdi7FmphWEKEhOk1KYF9siQRBgaJRRJGJEOGxj+FdLeTdHYWRNf/q1XuPrFTeLA1nMnTotT - Tz4kyuMmQW+fnVvXdbveQWFRqJSENBTRsI9t2ZiWQ5omOgqGaKUoTcwIr1gWSRyI9v4WncNdpLR0vjRB - oTJOEgc6CvqkKhZaJUIIoa1cESdfxrQ9EfQ79Jv7Iui3tZACp1DBKVSFYbnEwZDB4RphZ5vy5IRYuPgM - S098RMWWJ7q9loj7TZy0r83ent740pfYvvIKYRxQWTwpZ0896U0snJw2pP1w7e7Np4bdfdsuuF0hRO9j - zyyr/+U3/8/5EHxNAcCzz77HihrTS2ud0sdqfvHJvV7RHtYORdLcJdY2eXHAvHiJ1aldFhdC8hW4sTPB - H11ZZaMzTamQ8Njxfc4vtjHCPp//owF39ySimCNnplg6JggzSWvJiVnMNxk3hhiJw8A36MWCeh9anYR6 - 3SeJIprtiNdvRLR9QWpZ9JVFbWiy2zYyppklRmQbE2GaDLVEWynV0gAjPET3NpicDTnzjjM8+eGPMTk+ - TdDosLt5SL3eJdIaaZtYlokxcgY2TAmWRTuBuwcDti7XCLY6zE95uLZBEidYVsjCTMBjDyW84/GY86cS - rESRSxTjOcXYUU1wfpnLxz8BT/4FJh/9QWrOJTq5MbyFkLwOyEcKNLiVU0we/yDLRy9QzJVZe3WTRr1N - hMbxbGzHvm+SBIzoxlKQSql7WOKgn7CxWdf7t3ZEergjTh/1xCOX5sTpE4tC+b442K6LRifUqbDIFXPY - IsYyFCJXoBHPcOtgjtdfd/XhRkg+7VKajEVhVmJaNgITtBCGKR7UCaQBUih0MiTy+3T2W/rGy9tc/sJN - fe2517Fzpli5dFLMnnqE2aNHRHkC+o0DsX93k8Z+T6TK0IVqESkVOolB6Wy8u2GIIBhohMArVbHcPGma - 0Kvvi2jQEVIKkR+bwilWhE5iGYc+cThEJUqAxLBcnEIZw3GJ/QF+p07Qbwvbc8mVx3DL40jTIg6H2m/t - osIOuVJeTJ9+h5g88zSyMqkHfk8P63vkdF/rxhaHV6+yc/Mqvf6A8WMPGZNHLuTHFs5OS2Gc8RuNM4NW - YzxJ/N73vf9s85Pf8RB/87/7OJ/4yEX++b/5f1P3n0GWpWl+H/Z7j7/n+rx503tX3nZXezPd0zszO7Oz - MzuLtVgsQGEphkQEIIGgFApQIhAhifwgMUCKoJYSCQgkdgEsCOxiZzC2x7Tvri5vsqrS+8zr/T3+vPpw - qwdgiBSBCO0OlF+qoqI+3bzP/7znfZ7n9/v4/w8D4Dd+sdjoJq+utUe/UO4nF5otKZxamaBdRdNc8som - k8oNlmaajE7FeDHc3Znkw40l6h2dyXyT1y6WmUp3aJw4fHQz4KCpo6YS2HiMmD1OTzpcnnA4lXWRdY9O - xaPnepw0fSptSddTkUIhQnDSjNk8ial0FYbyGqNDCkdVwUFdxYk1NE2gq8pPNVwCQRRA0o6ZmQ+ZXnIZ - GWsQd0oYQmFy+RTLV1/l3AufY2FxgpQh6JTr1Eot6o0+fiQRqophaFj6wOzjxCpHFZd6LyZbSDI+o7O0 - FDNmdZhK91iYDFicCJjMBiTckHE7ZHRSoTS9QGnx58lf+B2unXmFZ8cXSWbncVNjVDULXamRETWirkZU - B9ohhcI4s2fOs3TpMrEv2X+0Q7PdI5Bg2SaCwWixFAKBgiJUIXSNSNFohxonDZf9gxrVrWOhO01WplUu - Xhhjcb4o475HrdyiVOkiNR3TNkjoEZqh4qspWfJGxeZRUTx+ZInmkYvu9xgZjbAKAtXWIVaFiAWqNpgh - 0PTByanTtag10kIxiyIznCGVC2WnVRdH20dCKJLcSF6OLM6THR3HytrCaXWoHpaoHJaIpcRIGJiWJmUc - iSjwhabpgCAMAqkahrCSGWGnMkSBR6dekm67KYWUJLMFTDsFQsHttfGdPrFEKpqOnkhipTJohomMAtxW - Fb/XHvgQUjlpZYYkihCh05FuqxSL2ImTQwVGzr5EfvkZjOEJ2e9V8NtlqTlNgvI2zY1Vdh/el44byMzk - gpobX8zlxuYnEsncYuSHpzq1o1FFp/H8N/6L1q1v/m3+wi9f5O9/63/6VPBvVAD8u7/+9cVK335jrTvx - bKlpFHvlMr1ajcDtkDaqjGtrzJpPWJj3SA4p7JVsPt1Z4n55Ben3ODV2wusXa6hOl7XHPve3oR0amCmD - SAoEEVnDZX4oZHFUJ1JzHLQMbm90WDuKqDsaqqaTsDQ0VaHVU/AiQXFYYXlSkrckq1sKh3UNPaGj6yoK - //K6sEQREElBo6tRa6uUS3D02OHkfoXqvW3UTpmJUcnlF8Y5+/w8y+dnmJgeI20n8B2Xdq1Ls9rF6XtI - wEyYhJZJZGoQ+eTtLjPDAbnUEH13iLurOu/cC7jxxCVsxkyOKMycz9OeeIGg+BZjI1fRtQRBGDCWthhK - DROp42h2BDTwdo/Z+OiQj7+3xdGNQyzf5dJzM5y6uMD47CxRBN2eS98LiaP4p7wE8dRl8HQdWSq6TqgZ - dEJF7Jd7HOyWaOwdkqYrFyd0LlwYYWI0DWFMrdqm3ugTKSqmKWQyIdBMFVdkOO6PsrGXF1sbFs0TBy12 - GRoKMfIKqq0h5MCroOoKVkLQ6cWUKgL0YTl55gWufPHX0bUEu3fu8slPbsvttV10XYiR2THGV+ZkamgY - TTfxei714zKNSo0wCNF0RZjWoG1IHA2mRD6b/hQqqpGQmm4RugOugNttIxADb0EyEwtVELg9oshHCMlT - M5Iw7CQICDxHuq2aDNyeEICZygnDziAUDb9bJ+jWEDIgOzZK8dRFUrPnpZot4vod4n6TuFHFPVyltvGY - k41NQqlEyeEprTh7Np8anpnL5EdPh31n6cEP/sshxRRuQKf721+6Gv3Wl87we9999G92AMjj/wt/49/5 - JR4f2xdqrv3Vrd7EqVKdpHO4RbfVI4ojCtoeM9YG87kj5uYihKlz+8kIN/ZPse/MUrBqXJk55tpKk/Je - h5s3PQ66JrFuYJmCSKh0fY2TpkKzrxKoJoWZInYxT9NNUGprVFuDzUBNGSC3PF+QsgRn5yQTuQjXiXm4 - Z1Dv6STtwTThQBMu4alSTFEFYaxRa+vsH+ps7ugc1lUOTjz21g/Zu3eb44c36JxUUaXD1KTBhfMTnD83 - xfxMkZHhHEk7gZCCoO/htHp4boQfxHR7Hn67g+aGjE3PkJ8/jzd0iY2mxd5Rl6waMDWuMjY/AmPnCNLL - tOIc6/2QA99lOZFgxtDRFR1HD+j6TdTDVW5/WuYPf9Tn5v0TNh7sUDvcZyhnc/bcHON5HTPq0Sof44eS - WDVRFSGVAUJZPIV6PuUQqELRdSLLoOEJdg567G/s0SkdUEzFnJlPcfH0MPmkTuSH1Otd2r1ABLEkYYJt - g2FrdMWw2G+N8Hgjw8G2RqfiY+guyWxIIqegGhqqrmKmhHT9kGYrotdPYqRm5djCadzSkTy4eZNH1zfY - uLvN4dquaFeOgZDizDhjiwvkx6dACHqtDo2Tiui1ujIIQxQFqesamq6BjGUUBIRhKBGK0MyEsNJZVE0T - fr8tnE6TwOljmAlpJVPoyeRAex74hG5fIGM0I4GZzEjNsmVMLP1+B6ddx+/3EKqKlc5j2Dkh45h+bV8E - vQqaKinMLJGdPYcxsgR2Bil81KBBVKvK7u59qhuPRf3oWAZSl5mJZbU4fzanGckzpp1d0hVlVIRK2vP6 - 0amvfqV+Nd6Q//7/7pf4D/7j3+I//U+/929eAPyN/+AtgW+ad4+GX6l5yV8+7A+PVGuB5h+t4zgRUkhG - eMRsaoP5iSbjkzH9yOL9+zPcPZynQ47lsQrPLpZZLHZ4cr/FJ5/6dFR70PsnRheDNd5+qHPU0dirKQRh - zFBG48xKntFCAl0VdPshXSckCGP6fUk2EXN+LsLSYkp1wXbVoB9q2NaA2Rc9Zfb99B1Zgq4wmJdPqShJ - Hcc0aZsmDcPgqK+yseNy96NtHr5/l93b9+geN7CkZGo8zbkL41y6NsvK+UkmJoZJmRYGAhlGdL2Yk1rE - QTUiEDAylebaKzNcmFVZyXmMpPokVYlKkmh0lF4uw0HX46S7Rt+9hxLVafR2OGh+wol7hOe0KNSPaFc6 - 7LRjOlmLGpLdzSP6h1tYrS3G7TZpmji1MvUutH19oBlTFSHlU48CUkiEEAIUBIpQEIYuw4RFzRPsHXbZ - vr+BW60wloEr50Y5szhEUpN4fZ9myxVOIEQYSWEosUglJWbKpKOOslUt8nAtTXlL4jY9DNshlY5J5BSU - jEoQaXhdA6eXxu91hFP5hCcfvcP+4y3GhlXSSSgd1di4tS537j6h26iiCEl+dJipM8sUJiYJA0mzUpf1 - 45IM/EiJohiIpaIgdU2Xmq6LKAoIfBdVN7CSGexMXiLA73el06yJOAyEYaeEaSXRNIM4igh87ynFWArN - sLBSeaFZA66B02ngdhoydHtSNUysdB4zM0QYhLJbP5FO/QDTNBhbuURu8bw0Rmelj4aiBcJSOiKqVmhu - 3BcH967TKJUIFTsamrsQ5sZms6Zpn1ZU9bT0vYm1739Hc7rVqHDO7v315//z6P/0f36F3/jCKf7R21v/ - 5gTA//53vmwGjjbzsDH+1nE/+4VyL2G1a138yh5hFGCqPcaiW8zntpmf80hnJSetFD9+uMJaaRShRDy3 - XOLybA076nL3Tp9bjyIiO4FmaigMTnZCSBI6GIaGLxWebHfZ2WsjApflGYNLp9NkbAPfl1QbAUEoGc3F - nJ8OcRzJ+qFKzdGQioKuwWcLKJ/xuv77WnHxFNUFlq5gaDpSNXH1BH3bwkmq+AY4fY/y1glHTx5T27tD - 7B6QL4SsXCvy3M9d4LUvvsTFK7MszNmMDgdIS+XET3Bnx+PJrT2cuzdJ9ZqM5pMoZgLPEfQaDulRE3NY - pRp2qHY+YKfyh7x98CPePvkejzvv4kZtst2A4c1D8m6bmYmIZy7ClQuChSXIp/rEvTL95gGe00ZoCapt - jWorJpRSoDAAkzwVGPxUaQADhoIElRjFNAlMm3qss7nVYu3mNn7tgKmC5KUX5lmey5HUpGyUm6LV9fGF - QRxJqROQskNhZFPCMcbE6tEoq4+SHD8KhOy72GkfI6+i6jFxEIluS6Pf8vBaNVGrtYSvRowtp1i4kJFL - 57Ik7KQo73vixnfvsr36GMc9EYoSki0Oy+nz58TQ+ASKooiTvUNqxxUCNxzo01REFHhS1w1MK0nouYrv - 9oWUSDszJFP5opRI0W/VaZcOpSIlpp3CTKYRQiH0PREFvgh9lzgMhG7aJDJDwkxlkFEoe42K9LoNEYce - hp2ME5lCbKbzEEvhNMv0K1sylc8wunKB4tkXIDsiWo4vNN2XCcWVercuTu7dYuv6uzRrJZRENh6aO0vC - 1nOx21rp1JovWpnR0XT2cvTsV85GzfLjwJTPBX/miyn++t/8C/9mBMBf+Y2vZrqOdm2tM/rqTid/tlHz - 1X6tjtdtoik98sYRk+IWC8Uj5pYgQOHxUYH3ti5w1LDJGzVev1BiuVinetjn9sOQ9WMV1TbRDRVFys9A - v0gEqiIwDQU7bdELVO6t99jcbeO7LldOpzi1kCWTSWAoEVnLZWo44LAU82BbEAoN3VBQpBxw8xXlp0X/ - 2d95qv+Kn74eSDlYJdaVAcZTl4KcEnB6OuTF5yKeeRPOviKYWJIodKnt7LL/6W2aWwcYqkFxJsnKMxle - eM3kzc9P8cbry5y/MkraVjlZa9IoqYQyR3Z2Ct1Wcbsl8kqNnBmhjc5Q1TPsOJK2u09bhHTtRRYijTOV - I8y1J/TrbQKhMpGOmLQDMjKm34fDlkK5Z5AcHeP8c6cYHhtDxjr7+3XZ63voliaERBBLIQengM/kJkIO - UJ+oQj61ERv4lkVdqDxZa7Bxd5Pe3ipzUxYvvjgvzi8XSYiIo50T2XIiPHSEUIQmfSzdwx5Oi64xJlZL - M9y9Z7Fzz5eJrsPQkEd2IcbzEW5PFWGYJgiEjOMBzj2RMsT82RHlzLOXxfzZs+hWit2dBh+/s8r+gwd4 - 7T2RykuZKowyunCKicUFqSgKx9vbVA5K9DsOVioJRIR+H1030XVTSol0+10C3yc9NCrS+SKaYdCuHotW - +VAQhiRSOZK5IkEQiMDziKJAxqEvZRyjGwnsbAE7P0zo+/QaFXq1EjL0hWknRSI7LMxUToBCt3wg+9U9 - LFsTY6cuMHn1DTw9J7t+KGTsiFwilHbYlHs3brH34KaoVdaE71WlohnStGfN/MSFs1Z65BXiqKhqJpEo - 9YUSRYX5hfhnGgDV63+Xv/qrf4GDviw0XPOLO72RF7Zb+YnOSUnpV07ou5BQm4ybW8yZayyOdxmdEexX - 0lzfmOFW+TxeKJjP7vHa+SpDRof7tz1WdwXVwMCw9AFH7+lUm/jphd2g8a4isQyFVNqg5Wg82Qt48KiG - 7/hcWk7yuWsGZ+cl9VqXB1uwXbHQDBXTGKwL/xQkgkAoGkJoDK4DYuKforwHcNHPZKBCDEi/kaLRcjX2 - T1TW1lWe3IeDVTAiQdbQaexkWP1hj/f+m9usffcDjj68zsmtLbzjJinpsViQXDirc/HNNHOv2QydjUnm - OgjZJXAjyns9nOMes1rEhJ5lOLFASpug2Ciw/DDihc11Zvcfc1JyefcJ/NGHgndv6nxw0+TjewYfrBrc - 3jY4qGiYls3KyggvfPFVLr18DS1WqJY77OzXRCxAM1SIpRTKZx2Rz6iqEikHLvLBdCGAwLMTVEOVjZ0W - G5+u01p/xOkFgxdfmOHaM4tCOD3K+2VZanr4Uhe6lUANHRJ6QDJvy645Jdfr03z0icnJVkg67JNLOSSz - gfRiQwqhoIQxvcMe/WqfbsuR+6uHUsYBn/u1F8QLP3eF0WKB1TuHfPCdWzz48XVC55ihEUUmh4blyPyy - mD1/WkgZU9k/Yu/JLq7jk0inUdQYGfsQRcK0bKEZJr12XYZhiJ3Jkx2ZxEjYNKtHolU+xO934tzwOMns - kIyiMPY8h8B3Bsh3GYNQsHPDJDIFCVL2GmXa5X1k5EszYZMsjGGkckgJ3fIxbu0QTfhy7pkXGb/8MnF6 - VFTbjmw3aowVUNI0qK4+4if/3Q3uXt+X6all5q+9ztyll0xdSy57PfdK/WjrTBD4YXZ8svMzDYD/zb/9 - dWLPYjWcH2vExV/Z6RWf2agkku7htghqZZzYJi2PmdYfsjh0yOy0S3pI4f5Wgfcfz7LZmSOdDLg4dcRz - Kw1kr8377/TZbRiEiSS6NuirC+Wz76McrPw9BWr/9MktBJapYFoa3UhntxyxttkGt03Y67O+HbPftukq - aVRTA0UjQMcLVbxA4IUDHoAbSNyAAeM/VgmkShQLIimIEQhFHYQRIBQVPzZo+glOekk2yhb39xSqLY9U - McXrf+4thi9d5kHJ5r3tLu89arKxGXD30w7vfK/Et//wgO11l/GFSeavzpEt2Oz++DGlR4d4YUi7HVI7 - iTlZ66HurjJ79D6LG/dYub/GxI1NKh9XODiJGbuQZfpinuxYiu2yxl5TI1FMYuZMdEuTXqgKBUjQJ6jv - kpZNnnv+tFhcmBdCWhwe1ilVmqjmwICsqeogaJ8GoED5l16LBn+qSISi4mpJ6lJjr+zw5KNNers7zBQc - Xn11WTx7bUHovkP1uMb+QUNIM4VmmFINXWkZAWbKwk1Ni7XShPjok6So7vWJW23UoE8iq4pk3hAJ6TK/ - JOXZl3Xablcc7RyJzs6q1EKX2VMLXH3tGaZnxjle2xMff+cOH3//ppBhWaRysciODFOYPsvY4mnslEXj - pMT2gyc4XV9qukEibYoo8GToeTKRygpFVYTT6+B7jtAtWwxPzaObCZxOQzaPd2Xo9GR2qCgS6SEhFE20 - G1U8pzcAUMcRmmZgZwuDWQFdp1s9pls9JnR6Uk/YMpEroqeyUkpw2w2lU9oVmuKL6QsXxeiF57GmT1Pv - OtJzWjJruDKbjKSdDukFLXq9Fo2TYzZu3FAevfdx6sn1+0XPiTvD02PezzQA/rf/868L6Rqpubn1izNj - e7+u69p8tTGi7jyqcHzQwDBCRsQaM/oDlmbqTEyGKIbC9bUpPlmfp+ZmmR1p8+LpE5YKLeqHPd5536Ps - mIhMEkUZFJs6eDH9qYZbPH1n/4zmg4xRBOiqgmkNpBSOkmDtSHB7TbBbVui6gy+u4ceYfkAydMmKPjm9 - z5DhMWT2GTJ65PU+Wc0lJTys2EfxAsK2j9cM6Tdjeu2Ifj/CC2JCBIquYZoqiYSGZikcVkMOyj4jYxGn - n1/kyle+QK3h82D1hK1eQEWz6CRSPGkENCOVbMFm6lRIQq1z7/cPqTyxSU+d4dKvPMOpLywiA8nJZput - h236fkQvDKk4Hs0gJjQUkiMGs8tpls9kqR97tKoRmm2hawoaUvRdSTpjMDpqcXjY4tMPt/nk7fsMp2O+ - 9ounOXtmURpakq0nh9TrbSIkhmmiahoyluKnn7UEGcWDz5tBKOu6gtBMfC1BXWrsHnbYuL2Lc7jBeKrH - y59bFhfPTYq8pXG0fczxcUuEuo2macLSpNDxUSxL+olxedifkU+2M2zfb+FUm8LWfAoTeTTVEM2dlpLJ - hmSGNXmwr8qNuxWxf2cNGXRJ5yxGZkbIWg7eya588N62eHT9Ca3qPrkRych8QWRH5ijOzJMdzsna4bE4 - 3NwRjXJT6pZJMpcSUegiw5CBvNSQcRTR7zSlYSXJjUwKw07iOz1RP9wWke8KK5EkWxgFochOsybDwJdI - KYWqSFXXMew0idywUFSNfrNKu3qM22miWwlhpnPCTOVQNQ0IJbEjU5lEnB8dkXp6RHScUNTbJS59eYnL - XzkvsZLc/+gR3/1vvy1ufnBD1GuV/vBkdi9XzP3w1MtnP/6ZBsCf/+XfVjra3Hxw8O5L8cbvvz5qfzh0 - /uI2RmKSXrhAq9kk591iJX2L5WWP7LCk3jX4cGOFuwdz+J7H+ZkKL5+pkAi7bG0EfLoqCFSTZFIh6PTp - tT36Xoyqa+iG9vTJBMgY+ZmYU1GJFJ0AFT+E0IsQno8WeKQ1n7Gsz3zR5cyEw8XTDlcuOzx7zeXqsx5X - rvhcueRx6bzP5Qs+V68GXH024MpVj0uXPC5ddLnyjMelZ0LOXRQsLltMjFlkdBXRdeiX6nSqLfrdPjHg - YtHxTEobFVKJgJc+P8yZa88yN7HI/qM1mvUm0jJI5pLIWONovUnWPmKscIIaOWhGBsWYZvbKWbIZi8bt - 24jAJTs1RnZ6AiVpEYoOE7MxIi35o498jl2N2ZUk+YwCcczmpkvgSeykRojANBXStkY+o9MJY/740wo3 - Vss0D8osjNvi2pVZzl1cwTATVKo9mh1f+GEsTFOTA+RCzFMy74C8JJTB4JRQpKqoQlFVYlWhJzQqPuwd - 1jlcP5Tu3hYz+Yjnr41z/uwkGVvneOdIlut90Q0EVtKUphGj4IlIs+nrI6KhTouThikaZYd80kfxQmpH - CpEfSSMBucmESA1ZgEGz4lPdL9OvH8jMMBRnkiJ226K+W2X9xq5cu7lK5WCPwqguCxMFcuPTYmhqDjub - kZ1GU5Z2S6J6VEPTNIyEgaYL4jAUxAgjYRPHofDcPpqRkHYmj5XO4TtduvUSgdvDtBIyPTQiIxnLfr8r - 3V5bCiGEYVqoqir1RBIrkxcAvtPBadXRDJ10cUTq6Qy+71FZf8zuRz+Umz/6Lse3Hop+7Qh7NODcz2dl - dlayeeeYtev74nitCp4jsjnteOHq0ifFhfEPv/Dbv02bPkIAAIAASURBVLb1Mw2A3/7N31J1M7y6fpJ4 - 8wd3hs7WTiqpGfFjzl4qc+5yj1HTJeeskQ6fsHxKoiY0VneG+HD3PNuNCVKizLWFY64t1qnu97j7WPK4 - mkBIGLNczo4EjBd0Is2m2w3p90OMhEEoBZ1eiBfEBLFCiEYcBGh+nzxdZpJdzo31uDLvcnnB5+xMyPJ4 - yFwxYqIYkTdjjH6M2pRQlYQnkuBIEhxL4rqEukTWJTRi9F5MOo4pJkKmRyKWZjXOncly5dlZrjw/y6Vr - UyydHmWkkMaIQXYcOtU2jyou9W6DlHbE0oUxzj87x3AuhdcNONypYlo6kTAoV8DpehiKy8UXIsxkxOrN - Lo8/LbH9/hbR9h6q76InNKzhUYyUiaW1yRgBQmi0RJ62k6B6HDOWh4Qe8eRxH18qmCmLWCi0OpLj44Bi - TmekYNALBfVuyN5Rm85JlUTUFWcWbJamExQzCv16UzSbLj1/UNiaJhBIIZ4W/r9AmQshP/MbIBCqIFYF - nVij1InF/mFTlLZL+KUKc6Nw8Uyes2cnREITNKstTspten6MaZsYaix0XQgSadE3RqhHI+KkInG6DtmE - K5XQR0Ymiew0WnoerBEZBG2sRIuxGYHQpOx2fALXlZEf4HZdcbJdZvv+rty8tyq6tRORSgtRnBllaGpK - ZAoFoWsSt93gZLdEs9olloowTAPDVGUcDsioiqIShoGMokgqmk4ikxNGIonbbtFv1mXgDLBiiWQaCfQ7 - LdFvNdEMEyudkVZ2iNTIJGZ6CN/py/ruOsd3P6axfk+Wbn/C1rs/of7oPp3DfRoHFRSzx9gZhflLmgxC - V978cVluPOzR7sQim9XUoRF7c/7qyndXXrzwyEz63Z9ZAEj593jnE1VJaL03DoORL33ovzV5d2fGWP+0 - jR0+Hrj+9F1Mbw8pWywsQte3ef/eODeOVmiFWeaGjnhxpczKWIuHtzt8+jDm0E9g6pK5oZCXzgmeuZRn - bmUSL4BSpU+r4yDCkLytkcpYWCqY3RZTapezQ30uTrqcmQiYLUSMpWLyhsSSkqgPnRo0DqBTNQjiAlIZ - QzVnSNgLmKkltMwCenIWPTGFYU5gGeNY+ggmOTTXRDQDZMVBVvsoXZ+U6jJWjFlayHPm/CTnL85y4eIU - i8sj2LkM3ZrD5vV92tuH2FGVC+fyDGc1nFafaqVLt+uSzJm0miqVY4WUFaIEPr1ahw8/LvHRp1Vq7Zj6 - cUyv5KDbHkaihQjbtI8jdC3JG7/1DHNnrxJ05ijYDvg1SmWXelvS7IFtxGQNn7zZ5+xCxOlFyalZWByH - sVxE2uygxlWkWxJps81k0WMi3yVj+sJ3I+H4Kk6kI5UBkFRR/oV38al/dWBg+gzNJmOEphHrBh2RkEcN - n53dKpWdQ9R+g8UxVZxbybG8WMBQhOj3AqoNT/rRQKVuaUjNMmSopyn7BVl1bVwvwKBP2pQkEkOkM0lS - WYWIPsI20XNjdKodUds7pu+E6GmDock02XwCGQTsPT4Q6w92xNaTbdGtl7AMX0wsFsTwVJHMyDBG0iaM - fLrNBo7jEUuBmTDlADQUEfkBURg9Fb4LqWoGZjKNoioycHsycHoIgUgNDaPbKWKhSrffx+t2RNBv0y0d - Ud96QnX1NqU7H1O6+xGdrUeivb9Fv1KVhqqgGwnRDyWpKUVOXzBkOqOJ8rYvrv+4JbY3feEFSjQ0keln - iqlb+Ynhb33p3/6lcjb9ZyPtZ/f8V9TXziVyn+7Ixa6wl8xC1to7uMDOUY/NP5rgQuEml4bvk8t0mJ4D - OwUHRybrRwVKDR3ddlmY8Zko+kSez8GBz8GRQpSMURIGatYkUVSZWbCZS/lEMsJ3IzYedViZSPL81Rw9 - z8Lre9ixQz4OScWCOAQRABH0I+i50OpCqzkg3eYmVabOnmf62a8hs+PUfcl+s02oaZiZDELGqHGIIQMM - QnQZoMYuqttG6dSh24B+G+H00Y+bmNUaplnCSGYZzxSZXsxy6dw0r7+2yNb2eTYelWjsHvPu33/A1Ow2 - uTGLt17LYJs+j9bbtHpNPF+hWZbcfw+uLsLyNByfU/CSgm4sMX1JngjFb5HJTZOaeYajR12axy3q6y7F - kZDZZ8aI/CzHqs2VCxGG1qdWbTKdVyhmItKJgFwiII4SjOY1SS+idxIJTzU46MLm3SaW3hK5FLKYipjL - hCQnYKPssd+xaYcWPVVD1xR0TUUV8b9EYxZIGQ+szKiDz1CAYuhEpk45DKlsdXm8t8rZe5tce/E0Zy6s - sPxzI9zdtMQ7N+s8qbiy0YykYxokLB/LVBF5m1ZvXl7vZKj4GRz9mGtjDfxqi1pLFQ3HkKExhEcezEDk - xl20Rl1mR7Jy6sw8upmiUWqL9TtrcnuzKR5/fJO9B5vy4fs35XNffIbFK5coTk2zcnGExnEk9x9vc7i1 - J/Yfq2JodILC2HCcK2Q/uxMRxLEMPQdVN6Sdy5MaGScKAhqlA9xOk6B8KBSUOOh2Ka+t4tbLKKEvvGZZ - OvUKXrcDQYCiIGNFQQhVmtk0SmyIKAY9G8rhGRifU2iWAx7fdDjc8PBasbBM3csWh7aGpocfbz/cK7Wq - TR/gZxcAR15Sjf3T9Xhisdyz8lG1RjY8Qsv77HSvUT0eonNS4c0rDmcmQhBQaqc47IzS6ymMpZosT/bI - 2x71cshxTdDxVMycIAhVSi2dkptgInDIhUfklB5nRkzmh1Y4fzbHuSXYulvBsQPGlodp73UoPWrRaar4 - QUwoIlp+jBdLNEtg52BiWGXxVYvl108zdfnPUJOnqa3V+f5PfsSTg0Ok6KElbDQzjaaAqcRYWkzSUkjb - CrlxlaGkoGBEFKRD1q0jm4f0T7YIqyfEu4cY6jqprEF+Yp6Xzs5w7dmrHO10WP1knXd//Alz5wKe//I0 - f+bM8zy6F/D2H92gVquRNALcQFKqCfRAcHkGTs3EdP0YI1LIqCaJTIF85gyTZ19jdEnn7ntP+MP//NsY - yiOee22Y2SmNoZTB1fNJZnMu/VJANp2i66fZrsAPb/UxbJfnzuVEparwyZqQB2Uh3AgSdowaBuQMQ5yb - n+DUQlYuXZSMlMvsHVTZqDTEUc+Qbc/GEQq6LjB1gSoGzVkZDcJASkn8VIKqIlGFgtQNwmKeI8elstWV - T/Zvcebjx/Lai+c4PTnG1EsWt7Z87ux5YrOdkI6XEKFUMZQetqkK3xhlo5uWnfoxcm+D+OiA0mZXpsez - TK7ojI8Pk15YkooyRnByD1sNRTYnCDRVqnpaGvYs517oSaft8Om7dR59eJv91e145twdMX9mWoyN23J0 - siCGiyncZih2Hm1w9/4NWZheFguXn4nHFyZJGjpCSplIplF0HafXlnGnLYlBiaUMGlV279+gXzohbHfw - Ow2ifkfK0EVTB0tGQpgoVhJV1yCWMoxCpB/R7fhEQsGaEBTnNIZGVbG74cq1B31Zq8gY0FJJvNyQ/WDh - 4uJjt+tEI8XfAn6Gk4B/9de/NlHpaq+tNkde3GtY062TJv1qhdhpkEu2mE1vsWg/4PRih/EpQbVtcGNn - lo/3ztHvRyzkT/j8pQo5pcPmms/tdUHdM0nnEvR6knrdJQrbmFqXlB5Q2fCQfo6Lr10lXxymtt/leG2X - 2mGNyolke71LsxcwcaVINJxntWRxcyukLSKuvW5y6bLB1LiGEehEbQXcDilDMmTreL5Hef+Q1Tt32Tkp - sddsctBss1uusXFQZnX7mDsbZT5eb/Dukx7vbkZ8fGxxtz/Mtr1Ic/4ZxIUXSF+4QnJkjMiJObq/T/nh - Y7yjdYzIJ52MSA6VGF7sU1jKsnjt11k69zmmR9OoquCk6fKoFPLwEPZKKgaSYkKSNUHEOt2eSb8G9c0y - J3cekE4JCotFOmmLO4c9vv29LZqbNZROH6lESMdFl4KRyQms0bM0zfPcPoTtqsNQ3mSooJPKaeKopVJq - Rij4cqKQF88++wJf/PN/SV742u+QuvIV7PEFMmmNotEgq/XQ5OAupudKwqcqhp+aT5EDQfvgh8/mNRRF - CBUpFE0TUSJFV7XYq4Ti9ge7ol3aZXa8JZ+/bHP5TIq8Hgq33aVS6eHGJigKpuKjJPP0ZJ6dvZg4jJgY - CUQkewIikcnajMzmGZlJkDK6orlZFve+syFuv7slT467FObOc+6Fcc5eEZj0Rdh2aBz1xdF2RezvHIt6 - wyGMFexUkon5KTExPyWTKSsWaiSdfkt4TkgUq1IxddlvNURzf4fW7ro8vP6e3Hj7n8nS9R/ReHid/u66 - 7B3s0auUkFGIblkksllppbNSNW1CqSAHU1YEQSSQCF1V6fVi4RJQWEJOnrWx82lx7+M+dz/qUC1HUk9o - ZEesam409+3nf+GVm4qmdH7vjz6VP5MTgNz8+2AF3F+18g3fvNTxzfFmV8OtneB3WwTCJMchI9oeo4ku - Q1kJusbWUY614xFa5ElnjpkaqjOW7tCvODx+EtD2dFRbRxBjmTF+FLL2qEd/X7I7ajAxnmXytMfIxNs4 - NUm7FKOZAXpSod/zyI6ojM4mWLw4Qq2Xo6MFGMUtxkbqvPhams5OzKffczl40iHsfUJx+Cbn3/hjzn7p - TX77pV/nmVO/wD+5fpp/fv0xm7UOZj6PZtsITeXpdBAyjgnjmCDw2akfsb3f5X3PB9UkkcoyMTzMudnn - uHz2Jc696jPt7WJv3+b43YfUto8w8xHC16i1a2j1B4xdGOPZb/wS5986xa0P3uN3f/c+7z045PZJlyNH - cK0lmcqF7B+HrO/3Set9pC9xXMHSjV1e+socv/k7b7F4PsXv/seCT9Z2uXHQoZjoo+mQyalcbld49vki - v/qFU7xweYSb9w958PABetBgbixmuxDTLrtYYSheefFlfvHP/Tk5cvV50c7kaUgplVOnyZ97Hv1H/4ji - 5tuc7zyhE5usHWl8+tCj2omQqiCV0DF1FWXgZkNKSRRHgylOqcYIIYSUGERIzcBLaKLuW6RkxLTjiHHz - QE6YZflMPhCZkY6c9pH3O/PyuDNO28yipWJ0LUaYSc4+u8TrF8blj7+zLra3HXyzJhKFENELWX9vV+49 - 6FA5gf06Iuf5LDx3KGsbujwstVj7xBOlQykUS/DaG9Ocf3kFkRrnYKfFx+/d4cobL8rlK9fkxbNfJuwd - isPVj/jh7/1T0W8FLJ8/I+24I+PGAU7lCK/rCKQQibQlDduSqmaSGi7IOIYgjAQCwljKOAgHRPqn2joh - BzsoQgqhqrqCEcdGOorH5mNpGX1OnsRy94kbV05iSQTZXKpTnCzsBV74JI7ik4EJm5/NCeBv/JVvgBYr - N3by52pe4td2O0OLRzV093CNfqeLj0pBbjBrr7E8UWF2JgRN54P743y8NUvJG2ZmpMVziyXOT7U52Ozw - 7gcu9cgk0C08T5KO21yc9fnNP7vC618+T35uGpUmpt6guJhHQVLbafPR2wFd5njz3/0Gr//Fl5g4nefe - P39A6cEuc/MKX/21FFcuWjz8boN/+q0O//RewC1H4Umost6A9Qc1avfWGC484uximmdOv4adTNPrdTje - 2sZxXDQr8dQ29i/045qqYVkWiUyGxNAQVi5DrEGtWWHtyRYf3trnu48iPm2PUZu8RvGtVznz81eZmy3i - 7cQ8+XaVR9+8y8GnbxM5H5Ie95g+v8jVC5fIGSYHW7tstgJKPYmd0vA0nbpiskOGHZGiohrslT16jsuF - s3Dl6ixXnn2W/YMGj3YqdBM2HTNDLUxy64nPh+/t8eC9e0xk+zx/ucjS/ApT4yMYaiRdtykip4+Is1x+ - 83PM/Nxr4lM9Ja93JXttX/iGi55QSWjjNA87tI/2uPKCzcufG+P8+Vl0YVM59qnUGnhBgGUnnhqQBRIh - YikG8wQyFoOJSiHFYKpQxgjpBArtvpDZvCr67S4PPj6Uttri0jl47qLGeD6S7aYvGq5Bo6tIv90XM8U+ - F8/E4rk352R2NMONj45kHMek0mnR7xdotDRZb7Xl6Kzk4mWfUxNlce+dY/nP/6ApzbwuJ09ZsjguhIh7 - qLTlhauxHC12cNtVth5X5e2f3BcP3v6euPVP/in3v/02tf0TGbXqMjjYRLRK0sTHTCSlmUpjplLSTKVQ - NIMgimU8KE6paAqarqJpqpASIimFqiiKqgoEyCiORegL4bmCUI9kflbh0mtZRWiqvPdxN7r5QU8e7QZC - U2FoLLs1d372o8J44fYv/6W/2/z9f3bjZxcA/+Ff/oaGGg+vVkZe2++lv3bctnK1Sl/4pW1Cz0NVYorR - A+aST1hZ6DEyGtPxTX78YJHbe1N4sc6VxRovrFQY1js8XnX46HaIbyYJhUKr1uP0mSHe/Pw8p6ZSFFM9 - 0qkj7OwJImHSa58nmcySHfO5t9an5I2RPfUSo0uTJJSAzW8/Zv1WlYM65EezeB2Dd/+oSqkRMHkuyc// - wikuXVxEkUPk0gHFyRrZsSPU1h3Mk1s8c3qYc5cuEiQnqdd6nGzt4IUR6CqapiOEQMaSgUs7RsTx09+E - imom0XN5lEwWT4acHJe4c3+bH6z2+bg+TG/qOaY/9wrPfvkC42MB3eMSn3zrkPf+wWO2f/iYxcuCV39h - mc9/8VVGzBTdY5etnYBW3SOhRqimhZVMkLBN2o5JrR7SPdwjldNZeXGBqbEpNJI8XD/A83yy2QRmOoGr - W+z0BB/fPuHh3X3ypiOXZwXzyxbZbCBkENKt6sysnEI/vSz/SNo8UUyKVoKXLYvn7SSF0Sxr2xu88951 - dp6U0Il57qURXnxhifNnFjHVJPW6y+5RmRCJrquoUQhxLKREDDwCg0GuOI6FEFJYlqDTjuXJcQAiJJ1V - 5dRCllbXFPsHipicNTk7H3FuqC2MxoHoVlqia49yXAvZureLPDxk2JQsnFtSJDb7G23ZbzZwnTYRocgm - JbaQsl2RrG9Iyj3B7KkEk/O2sNMJ0ak7OK1QFIpTTJz9hhi79O8omw9b4vr3PpH3P37E4XZZel4oE2mD - 4nBSjAylSKQTEkOXsRRC0VRhWDrKU1BsFMZEkRSRRCiKIjRNE6qmEUUxMmZAnhrsmSgKQgQetNqRVLMe - I6elWLiSlo2Gwqc/ccXaqi+63UhJ5UScKyZvnXr+3NtTp2d3fu+PPnX/5Xr8Uw+Av/xnv2ZFvfjCWqvw - 2kYr/2ylFlrdch2/VUfBJWs2mIpvs5jbZnklQkvAdiXNj9bOs1EpYIsWr5wpcWm6Tq/a5/6jkAe7KqGd - BE1BcwMWRhTGEyGluxVWv3fE4x+UIPLIjKromQTJ4jBWfhRFa9Nzjlm994D+6vsoj27jPa5yVIlYbcdE - hokaSFJRl9OLAVcvCM5OGlw6N8nnvnyR5ZUQW1RxNwOqm1kazWG0TpMpo8aLZxKsTNqkUjYOCv0Aws8m - EgEvjHH8kJ4f4HkBYRARSUkoY6QQ6KaOkrDw9QTtvs/RQZl793f5eD/kkT5D/vnnufKlazz7wijdoMtH - 93b5/o92qe3uc2nO4YUvneH5L5xhesgjanQ5Xu/SbrkEQYSwdBTLJJIq5UMHLTpibvSAxcvPMrFwERo9 - qpUG+5UGdsIgbVvoukqom7LkSO48qorH9/dF7/hYnF4WLM3o4EQIzZZlAVvDDQ6iLU6OVsVI5GOoFR66 - 3+P+9rfZXr0vdu6GOFWVnOVy8ngPp9zglZdXuPrMErlsnoPjrjw8qGJLV6TVgIQWS0/oBFJBSCkEUv5U - 2yoUEauaaLSEAFMsL2WEoYT0Wy3ZrHSk9PuMj/hiItmUBVGWXu1Y1CoeayeW/PHdY1H1QvHS60vy+S+9 - Is+89qJMD1vkCy4jxS6+F8j17ZiP7sFJDWHqEqcZICMYGrXotCPcIMHY/CxmOk2tdCw//uMfyYO7q7KY - clHMmEATDKUT8UjWkkMZQ5iWjlCEjCI50JLrmkBKfnosFwIURaIoP22bykF7BECEkRRRKNE1LQ4CKVuu - K7JzQkyfNchnBLuPenz846Y42Q8Qqh4VJ7PtZM7+ydKVle8PT420/87vvyf/5Xr8Uw+A3/71X0v2fO31 - rW7+tcfN/FzjqKY7pSNcP8JQ+owY+0xrj1goVplZgkbP4sbGOB8eXKDuJplMHvK5syfM55s8eeBwbxv2 - uyattk5aC3nhXJdXn+8xO9Lm6G6LvfUelX5IuSvpuQH5dAfNSBPps8wuJRmbNOg1Qu7cbPD2jxusHkRs - dVRaisG5yzrnVgIKqoNshRyuRlx/r0/NTbL4whlG0uPo7gSV5hS39Av8MH+R63WDo1KXoaDGuRmNF69O - cHp6BtQEj07adHsOQRShGyrDuSSnpoZ5dWWKN05P88LCBDPDGYpZm5WJPGcmhjgzMcT52RHGxvK0FJX9 - UoPHD/e5s9HliZsnXr7Chc89z7UXVnBbXe7ePuDd63sUJ5tceS7L4pU3mV24wmhhhGRKIiOXTsuj1WxT - 7zgcdjV6PR/NaTG7ErJwdZzTF34RLUpQ2dqgXGvj+CGZlIWlqwhF4EghSh3YPAo52O3Tr3uMFAyZtRUR - URNe8h6l3jvc3/8etze+z3v732LVeVt0d9eFsu7LrR0FT+qMjBn4MmKv1OEn7+xgyJCvvDHLzOQoI1mD - kWSV8WGHdFbhsCJksyOEZQzWCj6bIdA0BU0TslrzCSKd8YmCnJtSmRr1RbvcEf2WI6I4lOW6T+nAEd2t - pjw96vPW66o4ey4hF6cF42ZJTozUmJzoiFwiEgnVE0G3JXb3XEqliIQGl69N8dybZxBGXgR+rET9hqie - eLJZC+k1quJk6zE7D26K1ZtbtBoOuSykkkJmkxrFjE3WNrFMRShCEVIKIZFSVRVURSEIIqI4RtVVFF1D - UVUxoDJDFMcMoEsIycBE5QcSEWsyjCVRIlAWrhpMn0rQrKrc/cTh7vUevbpUkkmrPXVq4vHwVOH9VC59 - L5VNRX/vDz7879Xjn2oAyNp/wifr46lepH/9oJ99db2ezbUP9lSvtEc/NEjQYEJ9wkJ2l8WpLmOTsHWS - 490H09yvLaHogvPjB7x0uk5W6fDBe33ubKtUQxs78Hn2VI9f+7Mus8WA2lrI2o0YknlmXl2moUxxXE0S - Ow1MzSdX0EkWx0llJhi2bTIjY0TpPLu1DqHicW4FPv8WTBdCdj9wqR6H9IF2JyIxrDBxIclINoMQw9xs - 5Hi3ofJBpctqR/Cwb3GvafKkY7LZFKwe9Xm4W2fvuMVQJsnFhXFePz3JytgwWTvLaG6C4fQ4+eQwudQQ - uVQeTdgM2QWWRqaZHBpmOJsmk7UoZG1s26LlRKzvtrh9v8KOm0SbWebl1y5yamEc2enT3dmiXztm4kyW - 6QuXmL/4EgsrGRbnIxYmu0yP58lnCkSuz0HJ5dGRjxqWGM45zF+aZ3blPDMTpzjZO+D44IiuG6AqirAt - Qxi6ilA1eqHK9jHsHEOnL4QZeOTiGkZvm7C3Q1uc0FSP6IdHZE4amLdDwgc23TBFX6p0Wx4zcwlGJi0+ - vFfj7pMqewdVtE6flRGXy1f6jI7HtPuRvLnlUmnHZNIm+mDhSMg4/kwIKpqNjjAsk/mlZYqFMWwzKYI4 - otOPKZ1AqxsIQwmZHYq4fMHgyrO2uHolx5AWs/X+rnjy4T4P39nm1g+O+OSdkrx1p0XgBuQsqeSAyfEh - JuenGZmfJ5nWcKt7BH0fTYswE4NA3dlsUC37CAlJC1K2LvIpSxRSNrY16Hk+vQoaBJeqCgmEfiTjWEpF - 1YRQVBRNlbo+KM3Aj6SM5dOeiHj6Cinod8GLIxLjkpUX03J4OiEf3XHkrY+6bK17khgtndNLcxdm35m/ - uHijslc5+Y2/9vf/P2ryT7cLkIiMfEobX2/aKzXXHHf7oeb3u4ROm0jVUeImSe2A4VyP/DCD3n8rzVZ5 - mG5HMD7qcHreo5AK6NQDNg8j9ssS1Yp54+U+X/xcn7nJiK33VNZuQOFsxMIrOZZfPc/Oic7qzX2O7pUx - N8sMjypYwyPE8SSEOgW5z9VJh0u/VUBTbeyoj3rocfeDiOsfB2QWR1h+Nc+SUkdTurTufMIh27S9KU7E - LBVVpdHsIYpZ+ok8e47G+3c9dH+fgBg7aXJudpjlmQlmx8bIJjK4gUvPq5MzdskbLnm1TzrpoikeXTcA - LYWRHKFPnrSXJJUeo5Ev0plwCLwerVqdo70K79854uPHFX7uyiSvLL7KG2fOIx/8hLDyKetvf5PU1Aa6 - ukTz1gl644Rzsy4vvDVNnDrF3q7FvSc9nmwcsr+xwft/8Ii49V8yMv061545gx79PN/9Tp4f/Ogm9VqH - IIpJJ0yShkBXNHqKQi2QXN+NOam7zB9HjO14YmUilmPTQrSykk5TyN5NleqqTf0kiW+adAKfo3KPzJjF - 514wefPNEd7+oMrf+c4T+XxR55fetMSVz6l0Sqo8fKxwesTG0k18X6AQY2iDAWIZS6IoRlEVEIhO3+Xw - ANmJkL5nIq28CNGEcMqxoXkyZUOr7olbP6qD3hMHJy4P7/vkMrosDgW0GlV6vi/QIjmUQ1iaShNL7OzH - shuXGJtpY1IjrcX0FAVhWaK4MkSlFMj24zopJcRIMRhkUgaXvSlbFwlLkZGQyHBw1ld1VQghiGMpFUUR - SIhiIYVAqspAXCsVOdhfj6WUipBCCGnoGoqAZs0hsgIKoyJO5TQiX2V/y+Vo35N+gMxkjcjOGVXdVG/O - nlnYtVMJ+T9Ukn+6AbCfGDZFeL7kpifLHd0MWi0i1wUhSahd0pTJckQh18fOQLOnctDMcdIrEnkuo4k6 - KxMOWuSzcyxZb6tERsSV+R5f/brHymTE2tuw+zCDPZbhyq9LZi5bqOyh+BHeUJMTYVCu5TnYMlCsTVKj - OsbIedbeO+Zos8yXf2eOpWmD1sMaP/zDY977xOEwhFeeXeGVq88wP7dJff0hd//pHifbx/jJLvLqBInx - URQ9i54rYNg2nuvS7fpoYcz5+TFOzU4wURgGxUCNQ1JsM6Nsk+EJqcYhiVINI+igxz10EaBrGpFq4ekZ - yE0QZ1fws+eppSeo+ikCMYQfTtM83eXTBxvcfLTD/+uHT3jn0RC/cGmcN85+iUW5QrDxLtWPblPe+iHH - N6Dvgn0azmomy8+nmbt2iVefXaZeu8DmnX3c9ipO+QHHjX+Mpi1y8cwb5LKfp1DM8PaPbrO9XyYuZkil - Ehi6iq4KgkjiRRo7bszxYcRkWWH+RBGzh5KlfITjCzaP1QEkZchD010CLcbTIjqdJsf7AS8+N4SlpFG6 - XZZyvsim+1TXVHqlhChqRX77V0+zXnZ4+3v3RbkVSlc3sc0BSh2QdiopwijmyeoGyZU02QmVhBqTGknJ - 0VSe/dWIk8eu2Gt5OE2Hbsuh4SWohDodJSVfWdGYO6PS7sQQapiKI5xaKFEEE5dyMjFxQWqJSYLybTrH - JfqNCMdFhIZGX+p0nQi3FcthXZK0ET0ppK7r2KaJrgs0FUDIkMHrfiyEEEgiOTj6q0J52ucXRLEkCGJk - PIDOoChSImQUKyixOiBcaTHWUMjorIDA4WjNk7vrjqyVQ1RElClkGvmJ7Jbbdzd/+Af/x+YXf/Ov/w+W - 5J9qAFSr9lTP41LNSWRrrYigUSb0I6RukTNbjIgyw8kmhXyIMBR2D2y26kXqcoiEVmMyVWEq26VVCXm4 - CdW+YHkp5Je+5rE4HdJYhzvfFGgTGRZen0VPmRzcPOLokw+JDiW1pobTLxAPTXF0ksKp3mHlOZ8z33iG - 3e7zPPlDiz/8wRFXRnucSeicYLJqORx2Ixb9FMgFMjMzSN0mcbOEU3Eg8skKSKkKQoMISRiERF5EPpNm - YTTHV589y3huiGqzh+9uUgwfcq37gKGTh/TXNtnfdNirQNcDLwA/EoQxmJokb8PYKIzOFMjNn2Nk4TzB - 1Dka6RXq8QhVEnhnF7GHcxwcnXC4dczv//ERH5yd53OXL/CNS2cYTb+LaH4Hd2wXr+bQqCW584MWa598 - DMENxqZmmVlcYcQeQcnPoCVbCGOfONzkaMsmN3SOP/87L1MczfDPv3WLtd1DPD+ikM8MvH5KTEJIdFWR - fqyx7hnisKSy2UDOJn2mixEXzkY8m3EIcOk5Ai+QxDJCuhH5yEGVFlcWNea+lBWy16ZVceWHf+jTDpIM - n82KX3prWi63qlRXXfleI6DUVoWeU1ANVaqqJtJJQb/vc/9eWYyNwrXXR5kdG4s1FNEoxXQtTbQSicHw - sQjwNFX25ISItWE5lUFOzzSxjbrYqvlECDk5XsCezzK9WJAvf2FcWkPLlE/SPP64xEapwUlPotgediag - sl+T5e1ABp2YOIcUmsBSdZFO6CRNTYKQQSSlZIBOVJQBMCmKIxlHsVRVVSq6hioVIUEQx9L3A0kcx4oQ - KKqCRCH0Ypx+TBTEUklIMTyjMHtKE72OJ1fveuxt9em3I8XSlSibS61NLk3fR8rWv/e7kp/8k3/vZxcA - cudv4dWGuFOxJmuufqnjG7l2r0fYquH7CoqaIqXsMpKoM1qIGMpDKA2eHAyzVSniiDSzhWPmim2GrD4f - 7Xk8ehIybkpefTbkpVcCOo9g9R04ccHve3Q2WzTbBv11h60fK6RERJCOOdZ7TAz5KLrG7mYSJzwhvfJN - Xnvjq4yPf52//R/+Lh883sV6LcnMeZurusLJ9Qa7e3s8vLvG7Lm3GJqGc7/4MW37hNITj7IriX0FhCRG - EoYhWhTy3PwEr52dxzTy9Lw2w4kHPKt/j+LWhzz4zgGfPgg5aWjUlSSlEI46ETEDzFg/Voki0GOJFYWk - aDNsfsCZufe4fDXL0ssvMXn5dZqTz6MbaTTynMlauMvjlNp9bjzY4797+zGPlmb55Stv8upvrRD8w3+M - vfsQa8aEwjI7VZtvfusOR390l1TwKaMFg/ERk/EJjWfeyrJ0JUdQbXGyc4tEK8NXvn6ZS6+s8Lv/12/K - W3e2RanWJpUcPIkFSE1IVDXCSiqy71usdnXx8Lgvp0/6vErAyy+qLJ5O0mmPsLMt2Fyr0mx36PUjjMcd - 5ubTpGZTfP8f9uXHH0haqkbf6DOtHcnl+0fMZAXn5kdY36vKkz2XIByseKtCGTwkUUUvMNjcb4nVjVhO - L86JqCU5uHskdLciz59xSA/psrwfc+e+Lm5VJgnSM+K5CxFnTjel3jXl6uMN+r5KsjjJM6+/ztKls8JN - hNz6Z9/mxj/5Ju2WkJGVk3oxLwpjLqbRkceHHrIbCduUhBJ8qcqUbYmMbUrbUBAKxE/XHjVNFYqmCEVR - pIzimMF82GCoQRFS0xSBFCIKQjG4F1BjoahCCEVoWhS3moHsdgKMiVgOTZsMjac5PuqLzSd96lWkFEJJ - ZNXItNXHUyvT94QQrhDif7Q2/1QuAf/G//qLQjq2/kkl/0bZtb++3c4N18pdNTjcoO8KhIgYZ5WFzCbL - U02mJiV1x+btW9PcPJihT4JLcyVeWKkyke3yk3e7PN5y+dzPSV57SZITMY++D/dvwZEKhy0Pp+9z8UoK - Pa9zrxzzYT3iTjuCRMyLL2u8+jmDo5LJ1q5Ds7zB8MQQkyvzRHKU0MjSkxGThRwJzeT2eoNatYYue5y7 - uMjkTB5NjRClDt2awq5+mo0wxa7rE0aCRMJiZWqY87MzTOSH6MsmC4kP+JLxD2h/8yN+8HeO+dbHMY8C - C+t8gTd/dZGFK6NsVgW9KCSVDVlZNkgVEpSjBC3TomqY7MQWd6tw/UGXJz/axL17i3n/PpendRbmpzh2 - dCwjyZWpPPOzE8go5sMfXOfOUUi1sMKVVy+yPGcTnWywfHGe5eevYCSGKbmSO/UmB6HGRkdwc9flwZ0m - 1c0OS+fHiKKI6z/awB725Zlnijz/7MvC0FM8ebRNs90niMEydKEog+t5IRGqgjAMRSYsQYBgpyzZ3o+o - VXVRLJwjlTvHsTvDT/YkP3jSZe8gopDSWJo3+XTD4ZMjSdnKin03oOHEDBWWGB+eYmokze5+k/WdulQS - 1mDSEimiKBJCVTFtWzo9qB86KNUGjScV9h63aHRDKVUYSsa0O7BezbKtXKSrFjH8uhjTjqTtHsnt1Z6Q - UmVsOimXTycxZFl+8u2f8P0/fsiNO12USFIsRmJiIRbZCY1+pIuNu44IaqEophBSRaJrDGVSspCxZNrW - pKqpA3RiLFE1RWqqylNMJYqqChSVmKfNTUUIRUAcxbGQSKGoAlQpFAVDEaLXDUTHd8XQYszUKU1kMzqr - N/t8+n6PUimURsKUxYlsw87a3/6F/8XXP5w8Ne38Z3/72/J/rDb/VALg//CXvpzwncTirfr4l/Y7qc8d - NzS9XaoTVXeJ4hCLJmPRTZYKeywvumSysFvL8N27K6yd5LEMlzfOlzg30cBrO9y43ccXHr/6W5LRZMzD - d+D2x9Bswew0PHMq5sXLIWcuqMxdmmf22ZdodVScUpMzwz4vvWJx5sUsvVaG433Y2mqQTtVYWAhZuvg6 - 01MLGP0ecbvDyUGNvb0mTs9Hk5LF06coZAvIqqR5u8XuruDJ2Gk2hEmp0QHFYDif4dLkMLqaJY57vLX4 - IWfq3+fg9z7i/W93eHtN4YPApJ1NMD5pcXlJYzoPSgyPj/sctF2+/JLNq+d1xrMRotdD9xyWxmE0GZG3 - Y05f0HFkwHe+fcDxjY8o9u7w8rUJ9KEC724HlHsemArm6BDHu2VuffCYXX0Uc/40V0/P01t7THPtLi9+ - +TKL82NQ6VOttegFIbmRYU56OlvVmCFbYicMQjPDzR89Ek9urIsLb8xz7eVLnJ47T+W4Inf2D+k5vkAo - mIb+dLMPFCGErYGtCUBhs2bw8boQ6/e2SNLg5z8/wcsvnmF6cpHDbZdCUXDt5SSG6eK4EXsHhojdkDlb - yqtnLbE4FQlbd8XjhyU2t9tEiQSKpqEhBVJIRUhMLRbNZkijrchMoSDGplPMzgvpOK5weohcYYj93qi4 - U50UncQMkZGk0wtEafOY/YeHotcK0FUFRZdksoGIeiWO7z9G9lsyk9EIQRgZKcbmkKotZKMWy+1bHnE3 - ppADqQlhWqYYyaVFKqELVUWRIONIiiiMUVVVCiHiwAskKELXdYSmCqEoQigIGUviIIZIoigKiqrKKB4M - CUlfyL7nQ9Jj6Zoihyd1qkcKN97r8vBWB7cnyQ6lqjOnJu+lh9I/uvzm1S3N0OTf+s++9bM9Afz7v/mN - oZqjP3+3MfLqZj21Ui+1FadaIXQ76JrPsHHMrLjB6akK80vQD1Xu7I/x481zVNo648kyX3qmzLDW5slt - j3bDZXYu5OUXJbVV+PSPYeii4OJbsDIJVgT76zHf/Sc9Nh44TE+H/PxvhXz1V2Im3B61j7qs/lEVw2mg - J11KoYrn11HCJpOLE0wuLJMbXqJXvQutW1yeCFjKw3DKJDV6GjUw0Y/LtE98toMsN9ITrHng9H3GR4dZ - GJ1gzC4yMepyZuwBz/r/jOaPrvOHf7fPO8cmm3aayEoyY4YsK00SskkUNNHVLo4TU63qPFwXuJ7g6ilY - GnJ5binia28lOTOdJG3YZHIxag68IZ13tz3euXFCsXGdS8UuzzyzQqVrUmvpLE/kMQopqlKyenONrYM+ - /cnzTE6MMZ3wObn7PsPDBi9/7S38pkN5u0y766JqGpZhs73Rxe87LE9Jdncc1h5XCCq3yQ8rXPr8Czz/ - /CtiIjcqtu4/4rDeoNX30E1dqJom4jiWKIhsUopTox7plE5Ppjh0DO5udLj+4TppzeH5ZZPz4xYryzms - EQsr6YuW54oPVx3p9lXOL42LX/vzV8TpRZPD+4/knVsnYu8kIkgkUA1NGIoYrAogRRTHst/zQRGMTeVI - pRLEXiz8Tkdq0iGR0NmqF7hfnsDTUgjDINZsAj2FkrDkzHCbqdE+w0VfmZgxZK44FJv5FWHlhoUw5IAS - nIwZW0jIngMnO4Fo7YVCiaQwk0JolkEuk5RjeRvLUEUkY6JIyjiWEqGgGZoQilACPwIhhNA0IXQN1dCk - YWgyjmICPxIKQqiagqppIkbiubHoNkPhiVBkp4W4+Iot7KTC3U963PyoJ3d3AqkpiHwxubX8zPJPJpan - 7k2fmakrqsLPLADk4bf4m//J7/Obv/obYzXP/OLj9vC19XpitHNwINx6FU+qpPUWk+YWi6l1Ts/2GJ1W - 2DxO8/6TGT49OY0k4MzoIZ+/3EA0O9z8SZ/hRY9zz8Yodag8MpFxjpf+7Cizp1Ns/qTPd67HfHtDZbcV - k1D7TCkVtEaF5pM2mzd83n0Y8+5xhDIuWb4yyquvPcNIrkDgBliJAww7SSL7DMmcim31iZsVHmwG3DkM - yQ3tsZDeYUYPOTYW+Egs8m6lx1HDQeg2KxPDnJ+bZmVungszeyzEP8T57qdc/06V762b3HVTNDAY03o8 - U+xzbTqgaMekbJWhEYtCSmFmKObUKZ/TSxFjaajsBzxaj7l7oJA9leKVX0yTSYTUTwLWNyUbVZP9psrm - aoOovM+p5C5nTg0xOTdNra4SS41ESuXE9dgrNXm8UaafnSI1e5px4ZPwSvjOLmeuzjM6Pc6j29t0ui6K - ZdLzdRwnolvrUG36lJsx9+53cZsHzOQfyanTc+Lsy5/jtS98kdF8XnRKJbFXrnFQd+i6mggjRY4XJa9e - i7FtQa0hiJWE8BSTqi/k4+2quHdri/b2Afl8konlRenXXPYeNthc7WGFHitzJp/7wgWyis7Gu+s8eNKQ - B10pY8tG1VShIp8ix5BCCBlECFVXleGhFIW0ST4hpNpt49a6HJQkD6oj7ISzKIYBxLielFkr4PRkKN54 - FvHqG7ZYuWqz86gtVz9tCFWJRTKjkrBVOtU2ZipmZDEtDndC9h+6JKMIy4RQVUilbFHMJylmTKmpg8u/ - KIqlUBVpWIZQdG0AR30KQYmFQoyCoikYuibiICL0ggFBSVOFomtCVQS+G1KtelLaDsWlgIWLNv2+Ij7+ - YY9Hqy6trhS5gqnkhuy7S1eWv3ntC9d2z1z+X/n/34r/TzwA/upbz/Ef/c0v8tHB+EzDN399u5u/uFOz - Et7BlnCbLTxMshwyYzxmpXDI4qxHMqfw6ZMi7z6eZaM9STHb49rCCRdn2/RKHR7d63LqWsj8PGz8AGL9 - OU597TdZuXqV5qHBt//RHp/sBoTFBF/9osLLZyKMtkdjV2X9kconGwGf1mHV0dhuQruhkI1VkpHEVn1i - DoiFi57MMDR9DcVcZv3eJvuPaugNnxfyHeaLeWrDL/DNbpE/Lofstwf/f2phliuLMyxNZMlke5xWP2R8 - 7yd88A8PefuTiA0sCsMKL56Br7xhsryoUvMkf3g/ZLWVY3HlLI5fpN5WyBc6WDi0j2NOqgqPKxo/XJO4 - RoKZ6TSzwyb1lsY//yQmihXGCxq+sNg5cHjyYJ8zo/ucnirTkCqdKInnp0mkTKQSc1BusnPY5qCnM37h - WbKWgX74mEzSY2jUYHyySKcfsLVbwUqaCNWg0pB0fOiGGoetBI2SS/fwSKTMLZmzDkgLlflRmwvnRlk+ - O0kuZRHUW6TdjljO98Vz5wICP2LnEJquhlRVbEtQ60oO2jF9XYrRSZXFoUBU7x2hOE0+/4sKX3gzx6W5 - NKlWnY0P1vjg/UMe1GNR1xMYloGuKUIIfqooQ0AYDqZtdC1iejrLlauzjGYT9LqCj59Ecr0/Jtz8PIYm - kWGEH0iR9E+YtY+5dlER6WxK7h5a8v6nLQ7X60Tdlmwc1OhWm8wuwcRygm6gy8e3XXHyxKWQkmgWMhSC - oUySQjpBwlAQQhBLpIylUFQN3TTk07FfqemqVFSVWFGRTy/pBFJGnk8chEIoikQoMpYKagyhF4lW35XZ - GZi5YJBJq+yvu/KDt1vycDdAKKo3PlMo50cy76fzmbd/4X/25zp/82/+1/J/qkb/RLsA9mhOQaslI2HO - 7faTiw1Hy/p9T0RuHwIH0FCDMrZxSCHvk0yB4yrsVvPsVHIErs/UnMPypIff9On1QnKTEWlbEjdU6oc5 - Zl99mbNf/HVS0RqV4x02mip+ZpjFczM8d00lUSlx+9M9xs8qXHhjlpXUeaavd/nOd56wdnLMt6/X2dgK - eHlW8OLFmLMzCobcpV3+Dpo1RHpygStf/3MMFb9P9fFjEsUzvCdO8fFOgY8rPTabfeJEiuJIkbHRAikr - hy4DbNZJlG/jPdrizo7Dw7aCko85V3R4eV7j3PksUSBotn02Kh7deszYaYUr8waXskl2Hgg+XIvYKEvS - 2Qx6Umdu2MHqNNm/G5CZzaAlUiyd1djfb5FQPM6cT7N1qPLH97so//e7fO3gkMu/uIc19hqd7gWOmwpG - KkthXqVVqvPe4yOascrXTy3w9TO/jLv3Nim5zc+9NYeiTyJ9j9WDLrVuQCGdRAoQIiI9JDnqqnzzY4eu - vymev3kgp4c+RahZEtksX31jgi98ocDuRpXDTzooJx5qGfwjBcWRhIFOqCCTmhCGYWKaKsOjLr1GhQ9/ - UGVry0WzI15f1skoUC/1xXs/OZb39lxWm4qoa7bEslAVgTIYlB2wBpEDPYGuEIexLB12qB6doIRCGKme - 9JMmu+4Yda0gbUsXahwRRjFRECPDhhBuBUMfko5rcngk0ZNJOTyvoCXTJC2VTCpgeKIvXRFxsufRroTE - nhxcgmoKtq7LnK1j66oIglgo6qDrp6pqrGgqCCGiIJYyjtH0p+RkGKARo1i6XU/IIEQoilR1jQhF+G4g - PBfpeRFG2mN8TjI5g6iVQvn4bsDhXiC9fqzYad3Jj+QfjC+NPTneL3Vc5zj+V6nRP9EAqPWFmiUxixTn - j/qZoUYrUuJ2CxmFqFpMWmuQDY7IqicUhn2ECccNg91WkZqbw4y7zA41mSs6NDdD2p2Y8VOgBdDaTRAl - l/FGT9HKjWB1d1EG41Sk/IBRLWJ8cQFZLCIfabTDClMqPPPGWS68OMOZc0f8P/6r3+P2g1VK/ZhAjzE1 - hcqWjRd7pGYPOHn4+ySMcywsXmNh7i+yuVfh9z5s8v31FutOib5lIXIFhG7iCYVaq8+e5lHMBFxNlFA3 - y2zcabFXi+kKg5RqsFUHfw0qtsPpiZjlScEbSwZbJYfWk8f0pMFYLqAYBcylwLRiiiMh48M2STVN1GrT - flTmh7c7KJNjvPTmPM1mH69WZyY3sPj2YsEf3hD0wjr/y6EPWboY0B0PqDcXiDNFFqeGWE2abO+UuH53 - jV5viv4zc/xc9hWW5D2ixjYvngvJWAX+zt/vsLrp4Bg2tqlg6AqqEiGlTt1R+f4NjXLZEV+8tiPzWYhb - OvWjMSYWNK6udJkVMeVVQXdT4pZiNDeUShwSK7qIpIZtSEwRQzfk0ZOQT3qCsmsIXYfdckhadOj3JdsN - STk08UxLGqZBQlNBSiEHXLHP5IwCBIqqDngCXY/+/rGs3SvjehFre1ma1mkRW8NoMnwqigER9EkoXZk2 - fTTTRlETUosbxFGEqisUJ5IiP5yUmhnRcI44PupzvBELzQ9kIQ0RIIUqMnZCZG1D2qYivShicPIH1dBQ - Bt2KgTQmkiKMQUgQqiI1TRVRHOC5gUBGUjd0VNNAkRB6IfVmINzIk4l5RYwsQW5Eysd3ujx56NJoxSiG - otop1bEz1p3Fy4tPGqWmTNjf+Feq0T/RADjuG2o/YLkfKOeqjmW1mk3ixgl+rKAZKgWjzLhRZTzfo1AA - V+qsHWfZ647hahlG9F2mcw2GLYd7ZY9+HDJ7RqJXoFNOEI3N8SiUVG4/4ufnVSZWpnn5hTS1ygHj6QDR - zJCfGublX5nl0Tc73PmDfZyTH3H5G1/lG//WM0TyiB//s5D68QZCxqzuCVqfdDn7QoLX5wSNyh3K+w+p - 39ll/rVfZez5L2Hu/Rj3yT79Zgc5OY2WyyNdj9D3cVyPXuyDFlBQPHrlgMM9yewQ2AUFP6Fze1dhb8sn - P9Jj2h6MsApFI03EaLOEdzNm3wZ9XGPpaopzhQR6QiOh22SUIvKkSClqcrBWxtW6TIcep8/YJBXoVOs0 - qjEvLKlc33X4wZpD5u82+fov3+SVtxzkwq+w508TKTqdrs9BrUuoCVYPq9TrXcI3VvjixAij+98il17j - 4qkGv/JzCt83NT582MdP6OSyKoocWJMNXaHetrld01G2HJ5Z9sgpIffe2UcDzl2EyQkhrRihuCADQSwV - EX9mUwIsA4hV9hqWdENwY0XEiorwoLobSAUftIhQM9Asg5SuY2gKQkAUxcRxLGI5aKaLQV8Nx0WqAk6f - Ujm94Ak97MnbDxRxa3+YaHREWnYSEXrEqgaKwBAeGb0n8ikhraF5FGFh6X7cqUUCGVK8YElCn+Nyjb4R - inJDcLLpk4tjkckjOxEIRSOVsDANDVUVUkURYRTHUQyGogqhCOIojge/b0EYIwilFFKiKgO1vJBPYWgD - m80AK6cp0g982pGHZggRKEnZ6+pyf7fE/oFLP4RszvIyxVQJEd+7+vln9h5+8CD6V63RP7E7ALnzH3Hj - cMrshuoX9vvpN1cbQ2PN46oeHu/SC3U0xWVc22AxvcWp8Tpz8wPm3zv3p7h+fIo+NmfGDnhuvsJkss3m - 4w7CcFk5LxFVk1p1gsroeW53A25t7rA4O8m5MwlmZzdZWu4wZAnqDwzCis/YUA/npEFlrcHe3V0854DC - tMull5/n3IVLiJ7Hw4cON261UT3ByukRzj83j5VLUik1ufXd6zi9KsUpi4WleZK5EbaP2/S8GD+MkKEk - b1ssjmRZmRpmOR8x5m5TvrlGae2IyWmFM6cNFmZ1RnMhC3mPcxmXXj3kxhPJp0eAJrg2DdmURTs5wt7U - ZSoLr9Cdf5X60Dkq2hSlIAXZMUYWZliYT2ELj7U7u5zsHOO0W+hRxPhQhsXZESIRc9z2ebgpScguZ4ab - FKey5EfGCKJpqt2AptPDERpRGOA5fQ6aMZ0wyfLcIqbXJapusHg2IpmRnOyFNHoK3VDFNBR0dSA/TVgC - N1B5sqmL8hGiWZeiFKhir6eL1S0NpyyQjZhuV4jdvio2PVN0hIlQNGlqgxQIUAlUAwwV0xTCNoS0DBU1 - aSISCamYFrahCUtT0Z5ixQdwkKfKNT4jCwukotJqhNh6IH/p65p45QUhVSLee5DlxtEUyuSc1BM6IvRE - rBqDPQK3KSa0A05NKpx//Q2pJ4bl0WaJ48O6UK2UWLx4gb7TlYe76yLWoVMTHK8GWIoklUEEQpBJJuRY - PiVtSxVP3agyiqSMJFI1NJBShn4odEOXRsKUsVCI5VODUhgR+wFxGKFoGophiBghpB8TuxFd35VxIiI3 - rmOotqzsG+Lmpw6bm57ou8jCaP5oenn8JkJ5++xzp8uVwwr/8Js3f8YnAC1S0qZMb7SyCxXHXHRcaXp9 - l8jt4AudhHRIiEMKdotCATQVyk2b1YMhKk2VZNbl1JxP3g7pNCMCggHUwleQ4TiecYpOcYKDwxb72yc8 - OrnC1eVRJhZOQyPkuBtQsZY4PojYfLCNLgqMLlt0+y3qu0+48w+OOPOVItPLL/HLf+m3mRn9x6z/8F2K - uSLjCy9TtZ5nfGyT6Tji3maLuw+u0++6vPYbv8PXry7jeQF/9MEat3dKyEwGPZskbZtMFtNMZCVmBVrV - mK1DQRgqTGSTnF0o8m+95NAst/j9P4h4tBVjpARfugznl2IyGYMH0WU2Uz/H7As/z/TiGXKpJJEX0KmX - qJ+ssdrYZMs95rmxEYrJcT48esCP7h7hv9fiYtrn1LmQ8StpfuPL41w+leS//d4BH2xGpL8f8JXCTcZO - FdjTppgppmm7Rbz1fWp2AvIZtvZLBJ02evosX8i8weWcjc7bnJs/5rd+xeYffdvn00cxjmGDMoB2KsQk - LTBNjZKXpnSYwNQivBh6gcJx2We4FWCpsWyHmqhLc7AHr8pB4T49vuvw9DJMkZ/RkzRioStiAAOLBZEc - INVADlyvcqB6EoqCQJUx4EcKph4zPhSKU3OKNJWYW48kh+6QDPNj6JoBSGIFKVUVohDRqUrTCKWhJ6TX - 7shmtc7h+okSer4wEipH9ZoMY0eQ0ek2I9yaxNakjAEnEliGTiFtikJKRyhC+GGMEAgUESsDf6SUT5Fw - QhFC0Qc7DEIiiWPp9xwi3xcChKbrsaLrMvRDnI6H0/JkiJQjMwmuvjREvRbw8Y+r8vHDtmjWQsU0FD+d - NLdmTs3csZNW99yzf+1fr0z/pOo/6pvZYcM5+6E3On/cS6T9dg/p9pHE6IqDFddIBocMZzrkh8GNBEft - NLudUbq9gIlCk1MTPazYp3wcYaQkpgWdQ4W+O0ovs0AtXaSnOwSuz0a1zZPDBLnqAqU9eL/q82lhiWYm - w9j4NX5uUeOFkQZDnTv0jh9TPjjh3t/7W+ji/0mhkOXiaIrlX32NdxoX+L36JL1vavzFN0a4NnOaZ7/m - 8uPv7fH26hqjP/wDrnz+8/zlrzyHovnU2y0OTupoaZuMZZA0TBKqiSls+n2DjRM4bkquFBK8kBsBpY9m - arzwUpqFBQ9Turx0qks0nOIH0UWcld/h2rlv8NqQTlKLOfR9XD2kMFbg9PSr1J1nOaye8GFlFUs/4AtT - y7xyuMPO+gZ37+/xD9ZiOHD5K78yzFuvgIHC4Y4OgYl20kWxV/H8HHn9WU6NTdLzfdZKVUodFwopDryQ - //r7D+g/v0Lm6leZrvcZGfqA9EsV6uWIoG7yqGngBTpD6cFqqpASXYlRE4IYgxgwATOO6ce62AgFhKAL - iaVJqSkDd/DTRbfP5AADdehnnnHEwDH8VOkcx7H8qW9wwAwVQgwyY8DKk3ieoOdIMT6icvFiLCeyEfXd - UH78qcpRPIw2PoyqRAqxlFIoMoxjKd02dvdYjCyoWLYurn/3J2LtYUs+uXssT5+VTE+26B0e4xqG9IVJ - 6dDFrfoM56QIAC9WyCUSZJOmtE0FP5aE4SBjVF376dafjIVQdU3GUhCEkhghVV1FRRD2YhHJGGEYUrUM - NEODIKDjBjQ6nogyHmYa0pYULaTsedD0IdQFI8N6aCflxuzy+J2R6WL3X/s5/ScVAK1KbqTtqlcq/cTI - cUPFr50Quz2krpNRO4xwRFE7oTjkYqUFhzWTzcoQlXAYXXEYt0vM5lvER32ODnzSczFZE5wTgSNytFM5 - 1rsOJRS8/DD3jtqcLmW5tHyWfgP21x/w8JPblGUCdXyED+tDrBSzvDn+CqfT58mOl/DcI+qtgO16kaZ1 - iq1ohPdrFXa317GdgKXiLJPDE1yaXuXouRFW4yS/f+OE/eiHfOm3q/zaa8uk9Uv83/6b21QrTY4rFdrz - 00RZA6HYGIaOaSo4wiYggs4O3/pOgzuPe4xdsnnucpLzE0OUNpJs7c0hz3+Zq3MXmBtWuFs+oR5I4mSG - llCpui6VdovJhMJKfoipwpv0200OSts8s7DElWcuIOcOqX24Ted4D/QyqVGP888lmCxGUI2obceYos/8 - mQqG2sWJC8ykEzQqUO52Ebk0iqETunV+tHaEK8f4i2e+yuVMFqv7D3nzzR52WvJf/aMO+80EvUQCS1VR - lJhYxoP3WeKnVSxBSGFrQib1QWnLpxRgKZTBHGz8dDle/ovClzJ++i8MkGmfzbE/dToObg7kUz7OwPco - hZBCESKMIpxeKKcvwzNXFIzQEQd7iCelHK3RIbRUEhH5EqkQoctetSuKUVVcO9eWZ87aGBmdjXslIq/H - xSsm6XxStlzBcbtDekQRqYSQreMI7yRiZArcGImqkLVNmTB1ESKFRA7s8BIhFCEVVZFhEAkhkEbCiCNU - wkhKKSRKJIUkFgJiVdOkbpsouiYECF0MrjZcGcupRcT8WR/iSry33mf1TodOIxJ20uoPTw3vG7b1UFHE - E1VV/5Vu/v/EA0B+S/Kj9g+Lh13r0k4zXdwp9zGqR4Run1izGVLLjGkVxjI+hZxEKjqPD3I8OinSIcdQ - vsNcsc1wwmG76XBw5HD5dEQxpxC2UrTtLPWEyV6lQScEMTLGZk/yaL9GtyCx8MgNp1C8EUItRzyUpuF5 - 3DzssLofkU0lyefOkxs/TzgSUO75tI469PvreKkUQSaNNEN+sqsz9DjFb11b4vLSJseVFv+sNUz9Xpex - /+KHXPmqwheeucT6/gzvPelQO2rg9APQbSJFQzMUTBOCjqRdjamUJXse3GzH9N7vg57m3PQI3niWQF3G - Hp3BlRFblWNuN1xKGMRKSNdQaKoGLTvHe7FEbSu8nhScTuYwx86zWhsmHRR45YUpnp1JUF2vMeSfUL/X - x1RSNPcVntzrgeFzVY35/PMxau+Qo05MwUqRyWYR9S4yhtg0EOMjHJdqvP9pnYnUs7DwPBfVGhNTn3Al - OuTLBwZvXw95dOKTzgiZsp+qzxkw+54SUAcYm8E3YsD4VAalG8dADApSis9YfwgppRSDMeJ/AVCFmM/I - 4YPjtAJPT88/vf+XsYilKuMYEorP8rTKqQVkecMVj3dsqtqYDIwcuqJJEXkiQiFCU7SoI8dTNXn1VJ/x - nCqEqsjFSxNy63GF7bWasjK3LE8/Myufs8ti+9GGvPneDl5jcNnoDczeJEyNoZSpJEwN/ynQUwhBDKAo - SCEIghBVVYSlaapQ1JgYYqQIvEA6jidFHKNbhjDtBGEkpdP1ZNwNZBBFMjEUi4kFQw6PazRrCuUyOK1I - WIFUsrrWmJgeuTs8mT+Qg2bEv/bP/88DYPVul5tyk0vqp2Pj/fTFE2kV29Ukdw9DHC9iuBBh6mUKiSrj - +YiMDY6n8eSwwHYph5QKc+MhixMeauzTbPs0Oj6KkOiqRS8q0kuN0k+l8atd4kiDVIpWP2K33OGwoRCo - GnY+jVYzINIABWHZhLpJK4pohxFHlT56HCIVQaDrxKkCZFSEpiOCiMD1uX0kSa5qvHpmiYvaPl8aOmbz - 8iz3d4f5B9sniHc/4OUXN/hrX32R8+cW+c6NmPUnR2Rdhakxi+yQTSoV4TT7rB6rfLibYPnSPLPLHvc+ - 2GaoUqW+ruGOJDDzFoZpctLvc9Dzud0WlBWbGIN+zqCvm/RVBaHCkKpQiSPGhGTWVjDEKErCxPSOaVFk - qzfDvUMwnCqW0uTTxx7Xn8SkNJ/EhMtbRw5Zu0UhnUPTZyg6CqlSjXYYE0cgVJUoZVPyfH7/7gGd/hD5 - 87/IvBozNtzjrbc8Oo7D4aGP56XomzqmiFAGwk+BkE8FHxKEIlWhSFVVRBiDDCOScR+ViEjT8dD+38z9 - V7ClaXaeiT3f9/vt9z77eJveZ2Vl+erqru6uNgC60ehuuCHBIQcCOQqFODMhXSpGEYoJTXAYCpkJIUSO - KGoI0QwBAmQDbADtXXV5l96ePN6fs7377bd0cQq8G41ANDA8eZNXJzIv1vuvb613vQ+ZWMrWiEIJWolG - K+T4svK45QelrI8DQIw65gtqOe78jWSZ0I8ES4s6fRK5cBKpuMI7twy313Iqrc9gFXJokwFCGKFSkzJV - aKvz0x25OJHS74/ksD1SM1fnmdcW/X4irjkS3YkJrFD2Vwbc+yhTFQcKYzDMkJztUsp7lHK2uLaSUXrc - sSh17OxDa8zHOHpBk2YfP3b08YQ/HUTEw0gcz1WW5+H4vpjBkLA/Uu39mFAnqrCkZPaUowpli5vvjOTR - o4RmX/Bz6EKJo0q9+O6Zp85sfOW3/sG/V73+zAXA4DteUqgffvSnJ7XszH/t9Env8s89w+/p5/nRu9Mc - ba+S5XcpVXYYn8hwPdjv2zxp1tlpByinx+mpPkvjCb12SmdgMJZgxWCNAkw6QZc8LSBNM8ACpTBhTJI4 - ZMUqI63pe4Y0G0GcIEaO90J/1mYaQ5oIKRYYdTxG9iywXUCBqxFLM9wZsLIi/OhmkfLZk8xc7vL5R01s - ajypf4KfbP8U/wfvcPU3bL72zHNMl0/xRx/C1nZEo2zh5jwmxlys/ZR+GBKNWlw/4VPzLY5uCY/WMrrA - xc/kqS16HGYDtnqK25HmYc+nXXDQjkvkuaSORWBSPqlTvuwnXHAVFQ1JZmjaFqFTYNgeo+suMiz0sGZH - 0GtxuJOxNcixOwqoMWB7/ZBH9xsUL9SZzqdsD0YMMkMQeAz7EXGWIspGFQpkTszBwS5vKWG2dpYvz3yS - 86WEhaWf8sLTbY72At58kqpWRzNW1diW5ri3P/5yw/HCT1AYNJkxOJKwVB6KYxu2Q0slqUViHJUqheIY - 1W4pjgd78u84omKOdeDPIsCE435Baa2UGM2gb2S8JnL9uq1OTGcqamVyb9ljtVkTdXpCbFej0pGIgnCU - YsKhmpk94sJch8VJY1b7I3oHXbW1karx+Zr50q8q4WiHw/UNvvsD4eaDhDhFimVUzodOovA9V1XygTiO - RqnjgyQjoC2FZdvH/8xMlOPYorRFkokYY1AW4lrHh4OWVko5tmRakySpUmmqtElNbxRDOZLSpKFUypGN - LNaWI7W1HalItBkbyw8LtfxGHMXvz56c2//3rdefuQBU5U0/UenFP9z90tmtzYe567vvqIvnH/Kf//Ia - Lz11nbded8nudnBVh8q4IVSKzUaOjf4Evdih5h5wotai5o1Yu284GgjBGDgGdOyh3Bp9K0cbRcafDYwy - 0AmDzOFeK2C3k/FR16fryDF3bhQd951KcF2bSq1IKQgIU4MRg61gFKf0ooRwlP67tyVOwv4Q/vBDzfT4 - aX7tiuLp5R8RuzYy9QK79sv8uOmjvvMu555t84lzmr32JOt7AbtpmVJujNmpCtNrLSSImc0Jq/cO2MnV - OP3K0+j1mIO9mMYR2I0+iXPAQDq0ujbddom+yaEzg9EK37U4oWxeszJ+3TNUjyOw6GXCQ0uznnkcWEXa - Tgk/n+NEEBFGHX6wFmInmmsnNLk4ITUj3r8/4mqpx9him7G0xVIpRzZb5/ajLQ5afSTvH4fa+S6UAtZ7 - A/7VB6vkzQTlMy8zVdvj+vVlsiThqDvko9WUUZIXUShPmY9Bn+rjP0JmjApTlGNljFczuXoeNRopeXTD - yMigHA+x04g0zSRG4TgWtqVR6I+zMEVlWYoAlm0f9/4iCjHHg0SlyOKUWsHw7FVblZxI1h4lrLUrNPUE - XlBUilhMmiBODkxEkDU4WT2UxbEeWovy7YwcfY62muLmi2ruXKTUaCj9QV9u3oWDBlTyKM87bv0dCyqB - QzXnKgMSZ8fPnkzAiDpGmmWZSGbwc54o2yb+OAVekgwVZ0qMETdwxcoHoC2G3SE6jCFVSnkipSnN7ElL - ksionbWU9eURnUaqHKy4Uq+uTSyMPRz0RgfD/jD+n10A5ME/R53/DY4a20Fq1KWtwqdPf1t9Sf/kjW/x - zK0/4Zc+/yNenbnNtZeneL23QcFKyRfhsOtzf2eMvXAc7dvMlhsslFvY0ZB7dyIaBqYXbXwrxcQOoc7T - Fod2pkgtG+TYAoqn2egn/LP3j2iPYjY7Ql9s3LzDWDFP2bfIeTZBzme6VmO8VKU1SumGCXGSYpIIlUXY - KmWQphwMYrZt6B0OeP9+lzemPa6NTzI/kedsvMv2wdusz7/GwdwSH7z/21jZR5wPhrwwdo756nNYxefw - mtcZn7rLvH+Ho7DL6ja889BQmXT5a78+w+Rkm/sfbeJbDeJhCR0X8C0H34DqDZHMISsVjndl1RKDwKUV - +LRcm7wyWMbQV5pDozgkpRJAYiK2t1rsrg9xDmKq2YhTJw1OWXH/SUYrER4fxpzspkyblAUV0rcdur6F - 77s4vkfO9YgSQygGymUG3T6PNtf5duEMhcISXz/xKeZOalJzk/XVmOFIca+TqCwDJ28dlywAGpSoJDG0 - +xkT5YyFSaNeetaXdiflrfshO4eCm3qcrytxbU0j0rRHMIwNvqPF0scdhFJ/hhVX6njtJ4hRxBnEqVDM - pyxNC+fmtQy3Uz68KRwwTloew1OgjFFGNFHqiut0mfOP5OxkjzEnpbmvlOvC0lwoaW+H7mGN2yagteHz - 5IHPYS/GtQ3lAEKD0igJXIdK3qEY2KTyMd5BK0H0cRiCVsdqAKIsjXIsdKZwQJk4Je6FohU4+UC5+UCl - qZHhYGTiTkoSGbHzKVNLsHTGVc194c6tSNY3EqKR6EJBkko1f/fEpRN34zCJP/WL//W/d93+7DqAaoA8 - +G/4w3tOLsrUJeM7p3Rtwnq08jKrd20e7EzwmaWbXJt8g7obMzEuBI5iu1HkzmadTligWgo5Mz9kujQi - ao24szEimNZcnQ4InD5ZaNMnTyO1aOqM1P4zAVBgOxxFKUerR5AalGMzUy1ycnaMk7PjeH4AaGwRqp5F - NbBRky79JKHVG1JwfKpBgG97HA0SHh60KRcK7LtHDLdbfLic8i9LLr/5yUtM6rvM3P0haW6J/tKnaVz5 - Og9738L74A2mzj9i4UTIyJ+mu6fpVWvUfJcnu4rv3nZIAo/Tbsy9Dx7jxm2GrTanZiMqeY8dKZGTgIJK - 0dkBtPqwIjAYEk5NsjI+wTcloJ+5XLMznDRhZRizOQzxzIhXgyHV7IB4e427t1rMuCn/ySsZ9ULCgx34 - YU+xN4TKTIRHStFEpN0Djvoh+3GOoJzn+nSFqxNV7qwe8tajHbCHoAxS9Plwr4dzW7OUf4oXF0ImTzd5 - 9XMNBknE9ncHtEcFRjkHDyOa43m40kqMCHGUkdOJmi6keJbF9KTHa5/Kqd5PhfVd8H1bnZhEFsXw1qOM - o6bGLlsf5+Ijf/YXk6UcYzEUoGQUGqI44/Q8cuWcoebGvLMmvH8voJufFKdcUpaJ0QpisdWglzLpd+Xc - dIMTY7HkFBw2hUJNMbEgIt22NCKHw0aRh2sVVrYyFYYN8X0DGloRBK7FVDmglHOxHUWaHed2a8tGaQul - NZKZ4w7IspQRBQYRlNiWVqIzojQTcWw811Vaa7FMIipJ6PYSGcRG8gsZY7O2qtYsHt+J5eHDkIOOgG9T - qrlDz1d3Tl85e6/f7SR/kbL9mQlAtNXGKxs3Uf7E2ih3pj2UKWvQ0FPuFv28wxv9r7L24QwvBX/M5y9v - sDQ5QinFZrPE470Kg0HK/MKIS0spJd+wOspYj2MW3YByySdIR2SWTeTn6CqLnhEy63jA97EHFLSAa6jl - PeZqJS6dnOHk9Di1Qo5Ob8Co26SUNikO9ygPj5gcEwJPiMsG2y1i7DrtZBzcCtl4ntnaIv2FKY6abXb3 - Bny00+czXZ/rhZDzi+uo7g/Y2i3Cc79I86jKR/c2ebGzz8nu9wjiveOzTr2J54WIZTHILM7WhdPVPivL - h0TDEYFOKY0UM/EGrTDDteoEsUNRGgz6u8T9ETJqQdJHTMKNYYn7jqamE3TUp9dv4KcdLtkRF4oWc+Ej - Xi3eYnJhC+WGpLmAPZNjOxIO45hOBIN+iBm0kUFArzskJiAoVSmZNpeqir/xbIF7Eym5rM/t1RZHCZic - R7uxx41Riz+qX8QrX+eVWcXFZ96m1XzMgwcDPtiOaPdcqjlU4CgQLUZZSjmGcsEwN2YoOJF868dCpV5R - F89OSy+y1K17A1XMNaTkh6rgGj7CIop8yUQ4LqM/2/0dP9kwgtYWSinCMCONEy6etdTlsyJhe8iTDYvH - jRrR2LhyCnl0OkK0QwpE/Z6MFQ7Vxckm9VyClSkxSiQUjePazJ2AySzi4OCQ/qGmuW8YdlCJQYYpEmVQ - sSyZLHkEnkUKaOs4sUdZGm3bx3cIUYplKyzXFqOUMtnxf8SkCZImCqW0dhxRjkMSxWJGkThKkRpDaMVq - elpJoeIw7Npqc7XD5nqPMDZSrpZ6tZnaFtp68Nqv/L3N9fu//T958fdXIgCdoVEV25sKVHZ5Z1icOuo7 - djYYIPEAV/cYL0A97VLNJUzPCIUKNPua1XaVzV6NJBoxVWhzbjrExBm7h9BPFcqyCRwHR2lMqkiUYpSk - jBKFsS1QxwAFoghHoFIu8Omzc1xfmKQzFJLukKi5xWLjFvXWHcrhJq7ZxVItbBnhaIPtWhjbJssVmJ6Y - 5sLM04Qzn+SA8zTTcUYLE2zsx7RbHZ7sb1Kf3ObsizM03rrP1oZH4fwnUTMvIuo32Wn9Pt7qQybnBvhW - TJAb4jnCdNFiesbw6gsuV0/7DCIwMbhxSjYM2HrSJ5j9iKmJBVrBFA23STbaY6+xQ9qYg84JGJxAyiVC - JeyMehAeoNNdskJMq+Cxc1TkTPc+z1dWiMdivr/u861/HfDcpYBrp+H8bIOHGwmNbp9mf4QA9VKRK5UJ - xoIxfm/9gJ/s7HCusM8vXSjxpb8+yT/8aJbv3Wmzs75JKxnSyRK+f/eIca/ECfcC8+Ujzl/r8bmNfdrf - TXhnZSChk1O2a6NFMQwFSxsWpgyL04hSWn76QaLieMRrz3Q4OZvn+meM5J2+tJsj7i1rNRzlQSuVGhFH - 5HjxJ6KO14HW8fUcigytlBJKQcql0y4zY6Ke3Enk8X6Ntj+F5RVxtI0YSJUjRqVStBuyVDnk7HhPOXFG - GCksH4Wjjk+UKzkqVUsmZ0J5uDIg6odIIhgHwUKqtmKqYDGWd7G1RWrAdo69+waFtlAYSMWIUjaW7ajs - Y7FCRMWDiCyKRbsOTj5Q2rZk1BqopDNCImW0qygVhaXTilwgrD5KZfmh4XAf5WRIKe9vz5yY+TBfCnZh - YAa90V+obn9mArA9cFScFRYHCVf3B0HxsBmTNvdIM0F7LnV9yJxeZTa/yXg9wbialbUia+1JuqpO0d9n - vnTITK7H/lrEgyeKKPaxtYujLHzXxRgXUZooyQjT48kygMpS7CjhVL3MF585y/T4NCqDYPCYxeYbXG3+ - kOG9VZ486PLGtuYgFEItZJjjEMc0Q2MouE0mKi0unnrMtad/wJVnXsI+9wr79aexpMDNoeLWdh5Hn2Hu - asL09A9pNx5x8MHv4l37NapX/lNWbsa09v8lnyoeUl1wOPuZOo9vtMgDk5dzjC+AVxtQ0S2W70W8/q5m - 6xBOzRh+uRAyPj/ELsbsDz12D1v4o8eMWsuYxm1kIw9FB1wDYYSO2ni6ReX8ODV7AmdPMTo6ohMrvIU5 - AuXQXtvHSgcslS3OzmQcthTtXkh/lGCJkDOGbqPFgyij325y0Iz4hz8SrPYRv/VUyn/5dJXfemqJN48+ - z588OOKdG49o3L7ND3sVitYCX335aRbP5vjEpz9gdXOVjc2+akYuPdumYGWq2xeKfsqpiUgqQUqzr/VR - WhTLccENVdprSBoOKE9nHAwUj3ZtacUW2lNoZUSJUSiNHLuGOA7IPE5NHoRKAl9zdlpxdibDihPe/0Bk - pVXFjE8rx7aELMGIyGAkWBKzVG9a56d6MlvMJD0SiSMRr6LErVjKDWxMDHFmSZpzxSplqpDPVGYnRltC - zlG65jlMFH2CwEFsrQxaUBqOo740x+f+x75GrZWyLKW0JZZSKJNJnCakaaqCchHXd0XJxyG27RFhaJN4 - KfUZ5PS5PEbgnXsDlp+EdPtGFQtaFfJqY2Zp4r3JhcmGUoW/cN3+zARgLwp0M7YXjkLncmfkFLqdLklr - hzDVuLZN2Tpk2m8xU8mo5KA/8ri1PsZGaxzLzbFQGXFivE1R9Xl3PeT+k4wotrGsEpZdxLUtEikimSIN - DVl6/CYjjHEELi1Mcu3MaeZnTqKyDl7vfb5g/wGy9yEffr/FrdWEgeex+PwEg8xlZTNke69LnCQEJYd+ - rBlFilxDERzG5N/cY9b+I64t/JDPfHaRL3z5i3z6pc/z+3cX2eh73F5tcrl2kqfPrfFvbvyUfmGO6olz - ONNfZ2AFPIi+wcRaH7VvszQ1wIsGdJpDPnhbyNUdXrmQZ9TXLDci7rRgI3UovwNXGh3mznq8duE8TiGg - F3Ywax2yZou4CeIC7senpI5gVS1mAuG8P2S+vcNwtUcz8Tj3mQqXnw54baKL3WjQvp3Q3nOJEhfIsImR - LGQYRvQlZWQ0UvBI+xYb+yH/7w8C1g4i/qPaT7ky9R2+Pnear/zCV9n63Nf41oePePtJk5/uxcwvK6on - Jlk4W+cTL+2zszfkhw9jel0Lr2qRGRFfZ8yVElwtarVr00kcBkMtP11L1bMzhmkbbtxT3DtyeBDmSByP - smNjafXxV18hWOrY9KPQCpUk0GlncmYBnrvuMFWKaO1k3HgcsE0Ne6Em2jKQZRhl60E/lpJucmb2UJ0e - H1BxFM1USIzC9W1leRaub1GbcMwg1erug1TdeC9iby2RhaooYyGZKFNwPZX3PbCsj28QFJkgltZYtmUk - yxRGsB0HZdtkgmTZMedYm0wwIlpboj1PiSAmDMURo8RAc5Aov5hRmEC7eS17OymPH0ey20gldW0pjRdi - P++u54rBR8+8+tUW/Hf/YQiAHP5T7j12/Tc38icPwtylUaIKcRhiwjaxlNFk+NkOY4UGk3Uh58FO2+fe - dp29pkfgxJybD1kcjzBJwuZOwvp+ihEL1xnDcs+iaJDhkJiUzISQ+SDHHgCtNSXPx0PR7Rzx0tg7nMv9 - Cbuvf8A7Pz7ih/eFeyOPybNVXrg2weWKw9xyj9//9pAsyfjiywWM7fJgS3jn9oC9no1t5WnYMaNmh+F3 - b/Pg5gqLF7/FV77+K+Rfeo7QfhXPLmPlf8Li45s8Wv4jPpA+kyefZWrh88TeyzTffAN597tIc5PSFGQ1 - 4f0fD9m+pdGpx6mlMl/7RYuTd0PWVkf86G7EN98ZMlGP+PWvOnztmQVmv/AF3lxb5u7jFVq7HUyYYXtg - lS2UX8bT45w/hOeODvGWu+w0Mh5ENv/0tx8wWxH+xiuG3Bw83vNRoyLjyiGnbQqeIU4ycsUCFW+MQlLB - 2j4Ek5GVXB51E5p3DftT1/n55IDX7FXGkn/MUvUi/4tPvMrPvfAKOy0X01thN1KcrnS58NSIT+2lPNru - cu8gpVsoS6GImq8bqrlMdhpK7m9pZfsWnmepx/tKrW4LlrGPkZ+2DZ5DYGn0x0j1P2Pj/dlD93gBaJMp - yOKYmQnh+iXBDCOWVxRrw7rulevi5wJ0MjyO2bd9UaZFyTrkXK0p034oJlKiHIXtKixfC5YGW6OLNu1d - kQcPYna3M0ahkFpg2yhXKzVWcKUYuCQosZRGK00mSkmGWEpIo2O8h5/zlXJdSbWFpEbSMBEJQxFR2IGn - LNeRNE4l7g5w0PiBgxOOqE1njE9r02srtfYok5UnofQ7meU5Xn9spv5wfLJ8v3XY2V8893Ppz6J2fzYd - gCY3FqhTjbRycnvojYfDyDLxAJEUJRFO0iEnO4znOkxNCcqBg0HAk84ERz3FRK3F+dkhE8WMRlPY6kIz - MyhlsNAolUfpFNGQKUFMBnECJmGynOfEZJ16cZaCjllyfsT03ncJb73Fj7494FsPbe6pPH7NxncyVu+u - ko2Dm0AhMKz0fH5yz+KlS5rPX4k57Q/xbKE+luPJE4vhIKG6lPGk3eOdH91m8cYe119a4LmvnESfKePW - xvjky5cY34N3hrvc2H2CpwNeWFziTP08Xu0BBx8+pHqqz2c/49MIY/7gmzH/5PsZ104pPvd0wOeuWXRP - woPljHtrGVE0YuvDx5xtd3lhZpaJgsO1s7O0rxZphQn9DqQdm3LbYr41Yu5hjyeHfb6/lWLP1rn+7Ayv - XuhhNxu89U5Irl6jeqrOF8+OSEYZjX2HkguNTkZaFUId0+z1iIbDY7+E75HqhINByrc2Dd74aZ6auELz - oz9l/91/RJT+AYuf+gwv/8JXCGcuMxwUOGq0yI/vcu25Flc/GLDbTNhvZczPZ3JyMkUMaqepZeVAGzcP - +QCFsSSzAxIjSpSItiws6zgiG3U8OzheKcq/cxeLUkQppJlR1WLMmVmRk9Na1j9M1EcP83Ry02IKFdTx - ryQxmtgoVQl6crpyJOfGhxQlo9tAiS14BQvLs8TxbCzbIothfzvl8b1QZd1UCi6MDASiKFoOpZyrA9+W - 8PjDI5ZtI6KUsrQSgSTJ0EpJYFuiHUv0cWaRpFlGOAyVmwtw8wGWbat4EMqwF6ISLWGG8qvoE+c8WVqy - 2d2MuHt7wOZGQhaJKudVuz5V++DU1cXl5n4nhYOfSen+TASgvWkqR93kqcbIm99su9aoeYSMOohtEzCi - KvvU2GGi2qNUVxwNLJYPy2yGkyRALTjidK2Lm0bcXRMOBg6pFiyi46+AaDIDJhNMenwFihIYRgSlInP1 - MU7Nj3G5ts5T2dt037zDu9/s86drOT4MPUJLc80OuRqEXHYyJgObsOLy+UuKe2VDI+rj2jb1klBeNJhM - Y+UsZl8tkJmMzsEhnVDRUJp3bx3yxuMjvnzrPs99eppTz81RnZvlcnmOiWiR+cJ5doszhChMQeHUAlYb - FhtimGqk/PynFBXf5u//E8W3PojZPMj40gvClQV44aLN6XFhe9ew0Uk4vLHP3GqbYtnialkICxmhMoR9 - GG5Bsi9IP6EpCW0MlmdRKygm/YRzZcNmX/E7DyxMDi72Iy4U21TdFDsQKrU8xXLIaiemLaNjLLlJP563 - Gwg8jLLo7XXY6absRj5TQY5+HPOD799lcaOBSh8z+9I1lEnYufURU9MFxhcv8NKLIzba+3L4pCenZh3O - nbRUs2Gx2VWqFRrGc4JjAUop11WSGpH+MFMmMaItQ5jERElKilDI+5TyPsoYRESMiHT7qbK14fIZxcWT - ogoq4+Ejzc21giRjk8oueKgsVMe2X8MwHMjZUkMuzbZYqGV4Q+Goh3g1jRdosX1blasOXt7h4FDk4b1Y - rd6PlGsMlSrEGhzLlkrgiec6aNvC+rOpv2MpR1tyvKLMxLY/XgMqC3NMMhcbIVOC0krZgYcTBCiTGZ0m - gslodpFYp+TnI6nPeRRqlmy/k7K8mkpzBPmiY5erXj/IuR9ee+XaysrdFVFq8n9+ARD5U2CVD3/gVw9H - 9tV2aM0cdBRh45Bs0Cez85Q4ZELtM+n0qJcyXM/i7naR+zvj9NIxisUWC/Ums4Uuo8aQ2w9S2pGPk9Ok - o4g0i0nTEUYNIdPoLEXiGEc5TMzVOTG7wGx9nNnJLrP2A8ZW7vHBnSP++K5mxbKpTLmcKGteOK2YzQl3 - tobsRAGzJ+tMT9j4+T69+IilCSGX2tzbNtxcF46sEV/5ap4XLnr0VgqsHIQ8aRgajkV3mNF/fcRec4Pn - lxtUJrcx8WPSZIKTLx9y7bmrZNMT5CoZ7YqL5DV3Hhh2/smQv/U3Xb70eYutrYx/9XrMzQ2L86fzVEo+ - vYYmjTSRK1DxyICRHeOGGWlX2Gor1ruGZj+lMBQWSoqlEzYD7dLpCvmDjHo6op52SVOHJnk6rqHTjhje - Tnk/HHJuXvjiKyOC8gjtC8N+Ba1L1HSGbx0PVTEGwhGMUtAFAt+nmOsyPTVgf9xwY6T44IM9hoUOX698 - SLVmaO8MQZ5jcu4sTz9/Up7sG26u7Kp2Q6Q3LLAwU+ZqqNgfJhx2RkRpSrnoiRgbMULZiWWxEHG6LuTr - JRpZlTtbluwcjDhshhTzlvI8C5OKGg5TaqWMZ64qTkxltPcSHm75rA3GlFmsYXs2ZJEY2yVJM7Jei7nJ - Q3Wu1qGo5djK5wr4WpRrKWVr8cu24Fqs3I/Vg4cxh0eZTJcEPw8mRcqeI+MlX2zHVtlxXj/KspQojdYa - k6YiaYbjaLTjkCmtJBORzGClMVoMbuAp2/cFpSTuh6gkJXAds5+lKnFTKtOaQt6SqGPYWBnI9k6kUjCF - sWJzbKa8kiTx/ec+/euNXvsf/YVWfz8zAYAKfKvMclwca43sp3qRnhkMU9Jei3g4JPEK1OhQ9Q6YriSM - FUCM5vFelUe7Y2SJy0I94dzsgLIb8qgRcX8loUceJ6dJIkWSJaTJEOVG2JaNrVNUFOPaBeYXppifmqLk - OBTiR5jDO2zc2OOjlZh7oUOhEnF9yeJTV4oszflsHjj8m7dSRlsel6XES1cKLEy67G002VyLuNHUbB34 - LDcVbWW49ajHbC3H2dkqhfGIIX2qQURxTKOsAm8exqz9sM1LM4d4KbR6ms0bH7B46SwnXjxLNl0mcyLO - XFI0wzIPNqb43psRn35lwK/+aoJbSvkX3xDWNxNGA40ZafZ6LnbO4gufqLJYU3QPBnz0sMfmQYLvOGzH - wl6omC0kTMw4OPMlJvM+g72EN5YbdEQzf7rM5KkiT1cGjDo97q+ErB9ZrHUsZqYME5URSZqxNyygJ0/g - Sg1ae8cPbWMgiWCQ4onH81cW+ezFNnPWmwTWQ6qzGU99YoE3b0V8806TM8sNnr9oCDzo7TUg6cqZp2Z5 - 9oUR776zy5OtVA8S4bNXLC7O5pitKd551Ofu5oDDdkycZVLLaT5xUXGpkjLtRcydK+LWi+x2KvzJGzt8 - 790G/ZEvsfjYlsZSMfVSwlNnbfJWKndvxbLWG1c9f5KcHaDVsQU30Q5KxdTdBmfLbRZzIUnnmCjsFsHJ - WcryLLFtrZSl6I+MPH4UsbuRYAtkCokEHKWoBI4aK/pKuxbG0liOjTkm+ohGYTKjkjgVL3CxjgUAI4Kk - KcngmM7lBjls1yFLDaPeSOkoE3CV9hPKE4bFUzZKNGsPM548GqnWQaw9dFypFB7NnZr7UJBDeJJGo+hn - Vf9/QQFYXdNcGOW7H0wvrPe9U72RKmdRjEnD4y93HGFlB5S9PebGUyplGMUWTxpjrB4VyZIhS/Uh52dT - JDPsNoXNNoRFhe0e35Uk6TEwM3WOfeUOKbatybRFuz+i2R8y6SnG0i72QZcPP0i4u6noikNBFGEo7LZi - CgVwdcrVMy6rHUNr2CLLIrwsRDU0a48120PF7ImAT5/zIMuw213u/ySkO1dD54q88mqJpNEir0O8QPP6 - LcPyQcbMlMVLVyzmS5q3Xt/lzd/dZO57b3Dm+hkWLo+zeDLFHhsnt3uRW6sh+8NdfuOr23z+szk8t8Af - f+eQ9z/qMjZus9ly8QKHQAtnF4RuHf7kvs2bG4bLU8K5WcNnn1ZMjvkYE3DYLbA06XHusuFeB3p9m4N+ - Rnd/QEkNKJsEBw3a4fRkxrWZmPkgodMpsD6YYlDP08ugMQwJjYHMQC9mqlTj6aUKf/v5Hlf89xne+TaH - Bx1MNsbf/IVFisUW//aNLj+9VSZw85wua3Z3RrKzt8ypZ57i9PmaeuXpHDs/jnjvQcT2UYeXz8e8cCZQ - X7pekEsLgbxxf6AebIVqFMaQimjHInFttb3XkaBvyAV99dR0n8FZw7urRhptkUJeq7Gq4vyScHJC6G8b - 9c4Niz1TR9Xrxzki5vjZ2OsblWcg5yaO5MLkUE0Ght4h4IA7ZmH7lniBTaFoqyRW7G5mPLobSfcwkcmi - iDhIYpSq2Y4q+q7yA0cyxxaxLNG2pZTSxxl+IkqO80pQtoN2nOOs/ywjM4YkStCOgx/4aK2ViSKyODbD - gSHJbKUDIxMLyNIZWzUPDTdvx6xsCGGkdKVsmVLeebB0fv6G7dojpb74Myv+v7AANJvG8Tz7tMnUhc1+ - rtzupRD2wLKwXY2tehSzPereAbOzKU6gWG+5rHbqHIzyuFaLpVqbxVrI0VHK+pGmq1xsrbHJAEWYKroj - zdC2IBZ0nGB7FpHA2u4hhVyZS0tFxgMbPdLsbCpKluLKCYdGlufHq8KP7g/49VdCXjkP52d9asWI/mBA - +z2DSQwqMVyaybg8lVKd04zlHQphkWhTs7Le5fXlQ2qXPV57YQ4vyZN2Ohzud3mYT9jNLH6wapg66/DV - ZzwajmLbTXjjoc3eGw1ebvQ480LE5JTivLdHz7/ObvsU//pffpPXXhP++m/NMD49yb/5w0N+emOLYZJw - ugDN9T6desb4rOZTT5cxaZ7udpO5IOJzF2wiq8j6YcBRLGThgJPTiv/l12p0droc3HnI298S7u7Z3Onm - OQp96gX4yic6fOKqoeDl2OwtsBnPEw1CdsMue80OYRhhYZN38/zCUxV+/dKQ+e0/pr/xIatbLR7fUigV - 88zn97h+akgSWtxfHePHcooTX5iUYec9tb29QmP3JMVCgStnZ/jwzo6s7cZs9T1+7/0BP73X4QtP5bl+ - uqx+87Ua765GvHu/rd653cJEmtderMrjnYhbb7XV9uERV5YsuTTrst2Eo16qegO4cBmeuaylrCMeb4m6 - sZpX7bE6TrUkFolSSpFpR/rdUCZyLa5MtdTJ8YRCoOmIwaDxXQvtaBXkbSnVXbYO4Na9hOXlRI0Ghqkp - JALlaEvVcz4F3xOxbbAtlGWDtuTYnSwqixNB5JiI5LmibFtIUlSWok2mlNaiXQflOErSVCSOxLU13cTQ - HMQE0wnVSaVK1UCtPB7y6NFA9rsZ5G1TnSr0PZ8Hpy+fuFsoF8KfafX/RQVgreM4gW2d60X63E7Hc9uN - Q0xnnxQLx1NUdJNp+5DJcpfqGHRSh3vbFbYGkxg7RzV/wEK5QVn1eWclYXlHkTo2jgVKDNqyCGOh3YsJ - fYWbpahRD6Uq+A6MuZqFssV80UJahsFeRsGBL7/kUD3v8+66w91HIaPDESfdhMGh5o9uxvT6sOhm1CQl - 1A57xRru2QKliz7dnCZLfGKKzF2s8dTiCLV2n1HWQa8OmZ51Kc44tCsFugOPOBpwb7vF9+8mTEz7jI/B - cy+XCfOn0IOANh22H7SwCtvE+S7nTj5DOb7M3Z8e0f2j92gf3OWLX/kiF597jv/279/mydoj6mNHFMdc - bj3M2PluyLWrKf/FaxaPH6TkfIe9RoHv33d4uBMT6JBOK4WecOFMGzdK2OnCXuSypXL0/Dw1J+XaxJBP - no1ZmijQGJ4nLl+jWj+DKXk8bG7zZOeQpD2kUqly/fIMXzy/xaXkHf7o92/S2O0zc7JCozNk67DHpq15 - 6ukKrz23RLs5YNjaphNZarcX8WRLmL/X58qVMc5cmOfUTJvbj4cc5rRkrq86WcI/ebPPj+71+MLlonr2 - Qk2eWRyXf/u2jZV36GYFOmmP/WQg93sZspOIkQzXQZWDlN4oljNLllw+A92jSC1veqyHdYZuTTzfE6Ke - MsrDKEvZSVOm3EMuTbSpODFporByCstXYnmW2I6lLM/CuJasb0Vy52YonY4RrSDVKC1QsDWTJZ9CzpVM - H+dFYFkqMwqltIjJJIkSLK3Ez/lgWSSZqDROjUQRKk2VG3jonI9BJB1FImGsAtdDuxCHAxmfTHWxbEvU - ENleSdlYT3QUGimU843xuck7uaL/IE3SoyT+C9n+f7YCIJv/gH/9Yc5VmLNHQ+vcUV87/XYH0ztkpPIU - baFu7TEf9JgpQ2DD2mGej9brNHoVCnmLs/M9Fqo9VDjk/uMR6wcOVt7DchQmAW3ZhElKdzAkndQUA6Hg - x+SNIbA1BddivOgxXfHxmiGtfo9mami3beYHPi9eKfD8CVh/oPjwicPmA4tcTvHMXMqJYgY5n/b80wyv - /ArFMy9TqUyT9ns02xvs9Z6wplqccHt87soM3//RA/77bz+i1zvi4pzNF58t8erFPGcWCnzjzYQbyzH/ - 538x5D/7qnD9vI/xKzT1NVpDl8M3fp+g+ZCgNuTxR/+ao+oyk9c/xWC/yje+82N67bd46bUr/F//0df5 - yXc2+Ok3X6dz+Ig47tNIU370QQNixaAnlMYLTJ0oc+WKhS4O+Levj4jdAmNzebL1Aft7Ke/uW3zUKXAQ - BpRNzCfnhnzuzJDp0KK1e4KjypcoP/U5cnPT3Ly/TOOghXSHMBLGxhUvTSWcyW1RMsuc+5zFMLnGxPgl - SksfMbd8H8eBmjWPZRZZqL2BVreImvd5tJvw5rqHfn9XKvMB165MqktPravby0c0mxloQ6XgUM5VaA4S - /slPh7zxYMD1EwGvXprg8rkS1TGtRHpyfy3BEs1m2yZWNgNxSVXGWCnm/JJmogYffi+TW1s5GZamETdQ - yojCIGGsVWZETRc7cmGyzdnxEDVKaYagfIXOaYVr4RVssSxLuoeGJ/cjVh6FFJVRdg5GGRIoJUXHplLw - xA9cEsdSx2w/W1KDAZRkqDQzxnJc7JxPhoVJMrIsU1kYI1kmbjlAuy6SZpJGsZjIoCxPaSehVE/l1Bmk - UoVHjxO5ezdidydSToIuufbezOL0O9OL9b3PfPXv/8yL/y8kAICyPK/66NA6fzhyT8WROCYOkXhIbOcR - GZKXbSbH+kx8nPq72y5wf7dOp6cZr4dcXYoZLyZ02ylP9hIO+jbOhIX+OFfC8VyiOKXR6tMbFagWLKp5 - mBKXug7wbAdRGkxIwe4SJwPe2jb0dhXP+IpzZwucvZDj1Emb8j1hfzdkPn9EMZfRL5R5r/zXqJ3/Kv/Z - i9epuTnCUcKAMomzSKReYfnggJ3mGt3oCby8xGtjT/Ho7k22lp/w23/cYu4kXH9qjL/7awu8826Db3z3 - iN1mjfmRw7R/l0bLY3twlVMvf44lNYFuv8ub7xzw1pP3mO+NeO2LX+bKl36BP/nH/3e++c3v8LXP3+PZ - n3uNl/+Pv8bmew/5wbff5/UPbrE6iBlgI3YBDiyqK10+cVIoecLVuYBW4vLhJiw8BeN1jb9hQZQylfX4 - wsyQK2XDeOSTDM+zn7/OXWecYrND1O/zkzurPDzqkeVzIILnOUz6mkKhjps7zYlnd1C5q4xP/RwL5zzW - 3zzi/g8OGB0IQW2CM/NFbAMqi2kJrEYZfLChTpwv8dS1KTl7dkJdPn3Eg3cHNEMhzRdxtahawZEksMx6 - P1GrN1LeWt3j0xt7fPpcxli/z7kCPCqVpGMCDjNbdXuGibLw4nlNVYX64Ucp3/wxcqdXxp2ZRAVadBaD - ZalBz6CSobk23uDKXJfJotDfh/5AkS9YWL6F42uqY45KRKvHj1K5/yCRw71UzVcQL4AIRc52pOQd5/Th - 2GjHFW07aG2BMcpkKUiGVlopywbLETEGJMMWozLAoFGuK9qyROJY2VpJKIqjTqqGKqU0A4uncsr1RN56 - 2OfB6ohWoqhWLPJl9qoTpfee/+yze/zv/9V/cAIwVrNG57cHE3P7PduXUV/pNMToDJsQLzmiIDtMVo6h - H8MUNrtFVjt1hsOQmtfl0nSIS8bKoWI/tBmh8dUxrEC0xnFshsOYnb0eBwt5ZioeYyWoJxp/mNLpRIRR - QuC6WEoxygytDFJPYayI5voW33gr5lvvhly65PLJy4pTgcOGM81W8XnOnvsqs1PX6Le6bMZtdjOLvh/Q - chyGNpyo1JgpV+gPz+NXt7k0v8zPvzzFh+8/5h9+c4UPGiPYUDx3SfPcSw5+xaOec3FDl5xtMS37dJPH - dLyLbDqnmWKFv/lrNT556PHPvnmPP/69HsvXn6N8+gr9oMB/9W9+xIk//h/4wtNTfPWXn+fv/Bef5uf/ - xot8cPMx7763zM27Ldb2Yg57mj9uWeRtRU5n9NIRaxt9WisRU05KAeFrMyljrjDjGKZLFezx0zyeeYUn - 5RPsKSFd36Y1jHmwvk87MYjvQTzAdTIqhTHyEyfIzCkOb/wOe3f+LTL6DqNWl8bRkJ22x9nXqsw/W6K0 - HNB7YpMcpPz8s2M88/Q4G8sWdttlb7lLtVLi4vkp6jdWVLsbSZTmsWzEUYKtUbWiS2LgMBH53Y9ivn0j - 5hMzGTPljFcWe+pBW1ht5clSoeRlzBVT1VsNWT1QbPaqqudPiJUvYSmUllRhO5JFEUF0pM5UjzhRHWCL - Os4edEF7WmzXxvYcsQu2areVLK/EsrObyiiGTKOUhbiiqOdcVSt64NjK2LZYjq0EfZxOpJSWJBOTfkzy - cR0yEZWmGSZJRaWpWJallOsopSwxiVEmTPBsWxtf0z2KkMKAYm2oA78s/a7Nk1Wjdw8zSS0rrk7V2rV6 - 4eHB9uHdyfnJ7l9K9f9FBODwID/dD7m633HH9o4yZdr7SBqD41OiR13tUff3mKiHOCXNRsNnpVHnKB1D - 2X2mCgcslrr0GjH3VxX9LEA5DsoIoo8joRzHYjQMaTRbhNY0TtHHTyOKzZAgHDDEBe2QWgWyoI4VVMgp - TXMA+4ea9ZrF423Dm6tDQj9mcTLg7Pkyfuk8VuE5xiamCXOa7zQimmIzdF0i7XBke+zaNoPUMKsMrxUC - FvIBfrlG0qqz9NQEv5WfovHwXYrDRzhHhmLZ4txMjjvvNNg2Ra68coFqecRY7zFrR0Ued2LUYZFrlRaX - 5wP+69+6yg/vNvnmm39MZfYcp648za+8+hrbt2/wp++/ztt//wdcXfT5xDN1Pnu5zM+9uMj+gcPmziEb - u10O24YwAkQRNg2jo4ysZ8hnMGZBKYZq4FFdXKAz/RTr1cusOSXyE+O8ODfNjx9v89HKAT0jx1eVIpAl - OL5NeXIcr39E56Ob3PrddR7f3CO1hd0QjrDRYyXm8jnqVZ8wtnnvgeL125DS5dRJLZ98ZZrZ04reYEAu - DSj6NcaddXZUpgaZEdeycJSFUiIKwdFCwVVqqFyaqc3rjZxMDCJq9gg7jSnYFlZgGCsppseLMlcaw3Id - /G1FmrrEGQQqVUorYuPg211m3SM5P96h7ob0mpAYEbdoYQWWsnwL29FYRku/lcnak1iF7ZSCBSlIYpCc - 1lLJubqc98FxRBwbbVuSCWBELCWSphnGGHKlAO05JJkhjVOyMIE4Vpbvi5MLUFqpLEowUSrK97BsS8Tp - UZoQphY81e8Kjx+MZPnxQPrNVOdsJ6xP1O4tnp162O+OhqPB6M+d9vuXJgAifw8OzvPGTTN1MHSe6oys - aqszwrT3iKMUpQPG9RGz6ojZwoh6wZCIy93tCiuH44gqM1VvsDTRpub0ubE95O6ykOgcXs4+prUZQSuN - a2mGcchRJ6YZKiLlMeZlTLmGcSJ2Rxkbu20erzdZsAvUahNM5Sy2dgY8XI84d2KM05dy/O1xj/52h50H - Ix6VfKxCwES5SELMcr/DdzsjutpD5TwiJXRsi77nUbQN08TERGTaJvXH2XVt/IrN1ZNdNjsFth65vH07 - w7Uyoijiezd7pJ6PdT7PQgkWKhHDQYQpljDBRQ7332d3d4fPXakyM62YnxzxT7/3IR/+dMhkpcC1l17m - 7JVrfPTWu7y+covbf7BC4duG2UnN1bmUhemQ02cScDIGETSaioN1YRA4BLkyVuZCnMMtnSasnOBWYZwH - WY79OGB6fJzUwLc/esT93SadUXQc+6UtSDNAIygyE9FYfsDO62/zk4cHfNCA2PfoKovEsqmGmqOjDt0n - Ozy6FfL2fYt3D2Nm/IgLyb4qFQaiOaS5Xwf3LLmgxplZh910yJM4xtgBYltgMpV9nAJsaSUFT6nMtQgz - m82RzSEuUabI0EyXE05PwdKsp06dPCf1QYWt0bIaPRjI3d2W2GM++AG9rsi41+PSRJMzEyFFLTRbKCuv - 8fIWtm+Ry9uSy1l0eiKra4msrUSi4ozJMhgLUaLJa0sFjo3jORjXRduOUpaG7DhTMkszMVkGIJbngu0g - UQpZhmSpSjNB2za27yFJKiZLMcbQHwhhJlj5hNkF5NSiI1ubwq27CWt7KZmIHiuoUaXs3zjz1OkH7aNO - durC/+ovq/7/fTqAb0L+svO47y5sj9yrw8yqRXGKGnaIMh/tagI5ZCLfYL5mqOSgEznc3amzfljEAc7O - xpyZjrBNwtZewvIOJEWN6yqUyT7OgAdLCZnJGCYZzZEwSBQzBUMx61JONAVniiSFg2afds0C36eWV9i2 - EJKRd0Y8PRtgTxT4/fUu7zxJkDHFxRlFxU3ZGLV4GGY87EX0HI2yhEwZfCflRBDzddfwIgl+erySTCxN - r1ABmcZEM7T8RbatFircYXg0Yucw4faRi/YUd+43mbqaY7Y+zmq3R04yJqdsZqc01ajH3Q8fUZ7wubLo - 80svDLj74AEr32iQnDpD/dQC41MlJhZ/jkouR2N3j/vrj7jzk7vkVJ9qSSjlXFwDapRQMpneQQAAgABJ - REFUGYP5i3nOf/IFSmPPk8ZXoDDHUeZj9o+g02YijGlLwL3NLu/e3oUoBEfAHoF3vN4iFbI4pdNts7a1 - z+rOER3fkE0EpPkSg9Bi0I8ZtPpsbB6ws1Fjr5cR6oCJep4v/MJTfOW1aZz0Q7X64QaPPxxy4fkpCmMl - pqcKFPdHEh4Mxfc9RDmIJEqOLb5kKLRCLFHKU4KxNJF4dAaCpw3nLtpcPpHgW0O2to+U8jO++rVY7NcH - rP+hqMHgNGJ84k5PTc00uDLTlsmCwYkVmYhoR6N9C+VY+EVbeSVHlteMuvcokc2tjMCI1GsQKkXestRY - 4OG6DsaxsVwHbdsCGoXBZIYsTlAg2nUQbR8Hn5oMbTIspTC2C5aDoJA0RYvBsi3VamXST2KcWszYpJJS - 2WXn3aF6+CTUraGYQsnPahP5hpLso6Vz88s7rv3vFff9lycAm/+xG/d700ejmZObPW8hjDJPpRGQHh// - pCm+2WWs1mBmWvACaLZdHjXG2et4uH6Hc5MDFqoJnW7GVgsOQoVbBE9z/AT4M0eaPoZAJqI47MYcdkMW - /YQgHTFhOZycqOKO17A8n6FfhmKV+pjHqdGIsGSIWw3W16ro3DS5RZ/pXJ/e0NBvQjVK6alDmoMug54i - KnocTx808xg+aSK+mkVc0xmxZdNRiiMR1vIW3aTAQE8Q+lWqNYvZSo+7gwErey75nEMxiDjYWKe/eAZ3 - eoos2UGSATlnkjIenb2MP33vCH98hhdeXOAzz8GJwgG/8zvLtONlptwKnp5kkL9Cx36GqQvPUls6y60P - Z1hZWWG4doDfazMpfU5WEqpTUBzL0FmEi0VlrIpb85gMLBaXqiRU6MYxd3d3OF0dcLXic9j0OOjB0SDl - MLVoJwraA7o7XdY3W2R9CPMlFk80qBpD4ga8+XBE2BwwWx4yMZmSX/CYT0os9Ap0HyScv3KK537+Mltv - 7HNjY4eHbw3Q+V3Ov2Rx9qmTbKQ5NsIj1Ytj6WPIWcfEcQEwgvmYGKpElK2V2LZGpQbPybh6VnN2yaJz - EPGjj5YRz+Z/83cUX3pRaByN+ONHs2wcJuTttlosNzhb6+CmqaQpOHmFnVNoV6MdrRxXiyjF2kbMypNI - RQOD46NihWiUFF1bxkseXs5FXBftuaA1aSaCESVZJlmciO3aODkfA6RJShon6DQTrTWu76Fsi+Opf4wj - gu+6xCZmJCNm6ilu7ngGsbYWqe2tEVkmUqgUD6cWJx8r214dDcLu1//WZ+Hv/MP/cASg2/LzvSGXeqFz - crPlecNWDzVsI5bGIyGvmpTNDvV8i7EJwyDTrDXybA0mGaYWFeuIk7U2ZXvEymrGTtcmsSz8j8tPaQv5 - +AQUY9DWMUN956DP2o7P6UBRdoTForDnasI0JYxiTGmS2olTnDs7ySAe8LgV8sbNmJs7ZRbPFbl2foxn - LnbZeriPE4aE7TahG5MOBNXRYGxwy5BlZJbHwHE4VELfVfiWIhHYy4QnSUpsUsYwhL0B/f0OA4kJwpSz - ZSjXIDIxKzshm41ZzhiHelmjTIHImePuky3Wbq7ywfaQxYJwTVskiWEYa3quz9MnPa6dcXnj/cfcePMB - 66MfcuHaVZZOLDCZN4wtldHVIX63zbiTMD+hqBegf7vPj7/9Y8L0NsHYN5ian2Lm5AzjS7MUxmsslG3O - TbbQcx2GL0RsDQusdmusdcZZa7ts7Ies3+jhK5te5NCRGm5hmnpxmzpd3MIAE2ZcnvD45Pk8L1x3mah1 - yOuQxn7MveWWvPPGj8nxQBV3VmV0MFTKy+j0DojSEpdfOI8/Na0sf5k/eXtNdltDnGoR29aoYzyY+pgH - wseUdzLReHbGVDXjwqLFeF64vyG8/TiQ3ZFHzovVZ68O+eXnu9IOd0mGEYHfkpO1HkvlhLhtSBLQgcLy - NbZnkctZAlqaR0YePYzY24xV1QPLRUUGySmV5R1LCjkXL/DRnivatlR2fOmnlDGYJCVLU7xCgJMLiDNR - aZyQhbFkSSqW6+LmAyUiko0isjhFawelHcQakctHauGkiG2Jevww4fHjRBpHmQogK+W9Jwtn5t/PF/zO - Z3/p7/Gd3/vf/qUV/59LAGT1X8PSO9z4UZDvJ/blTmgt7nZsNWoeYQZNUhwCe8Ck3mfKOaJeHOHlFRsN - n3vbYzTDOo6fMV1rMlfuIKMhtx9l7HVsrMDBOp6vopRGrGO/tjGC67lkAvt7DdbGNK3ZcWq+YpKUrNOg - MbDIZzV6586zOLvE1adPsfrkkPX39lnFZibJGB/fZ/P+iKE7opy3KfltTPcR2skThFAeQRJrkoGCXJGt - 2hjfTuvY4wHblqaaZDwchbw/GNJJIi7pDudyPVaaHW591OdmbPHSGc3f/XLC5oHie3cNKw1hpR3zYiJM - F33CjvBoq0vYz2PVZvhMfoNzSzuc8/cY7gn9QcDc6Rq9RHPjxojhrubqeMZLc02y7Iew7TKRq1F3bGqV - EK07iIlJY83+PeGwabNuTbHvlBk1MqofPmA6e5eJ0oD6mE91ukp9rkp9XlGbDanNFJgdm+S1yXlsp0SU - Wtx7UbEZjZH6YySPm/S3FM4wRmUD6mXh689N4ecqZFnG1nKbJ7e2mQw6jJmQF64r3n+wzk+/vyEXvUg5 - cUZPaypmKMNBi1HUU+dPu+JRY2NlXbUPI0ZpEU9rPGWOW4Fj4qdBlEoSzSCEybLw1DmYr4mMmik372Rq - kE2onjUl/88/bcr66g5febalLlVXxT67L91+zEKhr8q2xUFfVJghuZIFjhYnsChXHIapkkdrqTx6GNNp - pGqmhDIOoDVFbamc46BcV2nPE+04CPr4o2QEkyRi0gyUVspxUJaNJDGSpKLSTDJRSmvrOBw0TZXJjCil - CGOlokEmqY6kOpnKqZOuanfgzt1IPV5PZRApJsbsrBjweOnMzLsTsxNtgC/82v/lPwwBwBLgHo+6r5QG - kXW5HVoL3QEq6bfJRl0ip0hRHTKmd5n2Q+o50KJZOSxzb6dOGOWYrLa5sNBjIjegvzfi7nLCUf94+Gfb - oP9dwCfwMTPdc2ziJGV3b4/VMc0RC8wUhXkP5tMRfTOiEyc8PEip13OcPnuC+uwyvntIWQdMFjXjfptu - p0cvSTkxVaQ42MfvjBirTXEin6enNNJ6yF6zA/4cWbjAvjL8f0yVf+nZ2KM+YWefrL/HmNumkk/oqZAz - +R3s6T02+jHVMQunmqPVtDjMYjIiRjG0+oI7DImaXQ6OInqRx0J5js+cO6QqEf1Ng2UHnFqYZOnZeT56 - Z5sndze5fl6YGVOYVGj1DKXJOi9++cvky2X2l9e5/W9/SuPhNsqyuN8rszlzkvp/9Bu89MLLTBYq7D+6 - z9adj7iz/JDe+hrp3QP89w6pSsKknzBTTpkef8TEbI76Qo7qiRJzp6Y4MbuIZQ8Yegcc5ELWq0XCjiLw - Awg1Dx80+N13D1lrhPiJMJEIz5x3ePXni+rk0gy3VgLe/nCTjU4LTCa7DyOVygaBfyBXzhYYdy3m8iNV - shX7kREhw3EFrZWIGBCU1lqZTBH2UxbOIi9eU+RUqB5tKW5ulxm5msV6W40VdsSEbd64mTE10eNKeaTs - WqaqWSq7W8fBvHZeKTuwxPIsbM8Sr2Cr7S2jHjyMZX/HEA4RUwPbUeJpSyZ8V8o5DxxHlOuiHUebY3ah - sTUSZ8c0CjvwBcsmToxKwlhIU2xLKcv3BM/FpJmSOEEZQ+C70kkwR92RWJXIlMbAz3u014Y8eNhlvx1D - 3ovH52pHhVLwaHp+/P5LP/dfDuHv/aUW/59LAKLQUl7783Y3DqaftJwLzb6eScNYSTLEZAmpVlhph5K1 - x9x4xGQdlFZstso82S8TDRPmZkdcmU/xtWGlKay3DAM0Od9FS3bMSjeC8DFFEoVjaUQMrSTicJhwGDrg - KWp2TG37iH4rYaUVMZIcxfOa2ckx5s6UeOWiJisoTp/XXL+osRV0jjIONxOyoz6OHVHPK7q5Kjs5j63W - LnbrDml/Fo5OIKMFksM8iaSozhHS3kQnOwynIw5qOfZ1wFPBFsWJiDuH8I2bed48rHF+xuLEXI+ba4cM - wpDOqMeEpNRLBS6UlghmZpkut8i3D3jrzZBvv5EwQHjh6Yj/5EtdfvXlmM5Fi2Ej490b8K134DCC0/MD - huoBM7Ucra0mj28OKPoWz/78LLMvfI2NE79IFpzmfKHC0wWLw/kZtl99lV6Y0hsN6XbbHOztcbS5w5ON - bd5eW6e3vYX1zj6Vn46YcgfMlTaZrewwXdcsXq4xe22Spb91FmX3GOyv0lg/JHcqZvKZGmubI5aXhzxa - jnlnL2XjX3bkk0+V1ecv5nnhTJ3dLhw1j1RBRTI/lTE7rdTuw4g776TyeC2TUWajw0gSo9VQLHKBoyxt - YYwRUVoEwbUSTs9pLp/WNHcj9XA9x5E9K+3aRWQshzsMVEWeSKHYlJMnq9TGSnTameyuHXLQa3L5AlTH - LaRg4/g2lq1VkirZ2Ul5/ChSZphJ4Bxz/nSmVGBZqpJzTaHgYQc+lucabVvGZAYQlBJMmqC1xssHKNsm - jhOJRyEkCY5tiZ3zlbJt0lGIGcViCXiBp2wnU5k1oFwbUawk0j5y1dqKYXMjk2RodK5ktybmJj6cnqk8 - AYaOm/tLL/4/lwA0e1pPuxMLSZa7cPOgVt8+HKmsu4dlYmwLPBmQSw+o6H3mZmIKNWiNNBvdGtuDCmna - Zabc4vRESL+XsX5o0c18xLLQJmMUp8fXfhZYH0Ml1cdxX44+zofvD1I2tgccVDTTxYTFnGZ2GLAaZWzt - NbhX87i4UOLUM+PUwyob2zYqUCROTDg03NnI+Kff71CyXX7+6Tyfn2wz6QtNlWPPOqSTHtJuPyFtfAQ7 - pePpOBkSjyBu4uSGVCuTFHsl4oYwGgxRE5PUdYnl5YR7j9pcr6ecLMe4lmEQpYzCjPJYkX4csbr8AD8c - wXRAMZxnpqp56ek+G8blIIz4f/3OQ/JEJJliu2ux0hW2IlCWQ/doxNq/eJ/5cpE538VuJcxVFJ2dmKtK - +MS0zZoYbu8v870P79IZ7qClR8WGqmuRd12mPJ/qOZfp8xX2YpeD0TiDUQtr2CEetGl09jGdQ4adFt07 - ip1HFSozi9SWStSWfGbP1DlxvYQJIJMh6bBD2h3Q2I1YW0lVY2tbWoNt6kWtpkuGZMzQbSgaTzK+990+ - 63uwNRDVt5CXzttcvFRU+2GJe9uKla0WaZqQzzmEsUapjIXpjHPzGXUffnBP5OZKjrQyQa7gomxPdvzL - stKe5u0nO+q59i4vL7a5Mm+r2MqkmaDaIyW5TFP0LMpVByewZa8h6uFyIuvLofF1RqkCxgIbRaA0jmNr - x/fEzQfGch1AqSwziiwTkkwkE5RjYwe+ykSJSSJMlCCZActRlrJEo1CZETGZSoymP1RqFBux/JFZOGEx - Na3V6loqt+9E7OwkuIKu+jTGJyrvnHv67NpfSeX/eQWgYG9bhNGJZ2f0pU6mc99vZDzaTtCxpuhmjPlt - Jq19xoMDxsZSEsvi8VaJje4UI1WmlNtlvtxgwuvx4HHEw21NaHsELtStIbYfcTgQ9noWhZxHIXCxlUJp - UJbGzxcYxfDg0R6Xx0uMlTymciNOVGAzrTJWLTHm5zgaFVlYWKA4fMDrN7Z5chvGd0o8c7pEteiT6RGr - LeGnD0JUNODytZDXnl4ivzSPcSvcMY/o7TdQXQsJgRSUEqQiOGWfuZzNqXDA+Pouh62ULF/kc1dzPLc4 - ZP/xiEki1o8yShpUpugMBFM1KDMi6g1obrtkAxfHbPP02TKv/MJVtno9bt9c48aPd7jVzNhPbfY7KeX6 - FC++eJHx6VmKtXG80hhj41MUPJ/W2mN2b73NH/34LW7d/qc89cJbXP3Sr1Ks5ymZW+z33kan60zVwEsU - hMdkXdvSeI6i4ApBPsPKG9IkI4wzoiglGqWE3YzBltBaHbJ+6wiT2ARli3xVEZQVbk7jBYogr8gVbYKC - 5lTRcPopozKEJFFEQyHsGTEqQxzBGVOUI5FzWQZRTL1k1MKCiHFtHs0o9YejSB7uxvQHSnV6RiaqwnNP - WZybS0h6KTeXbe4flGCphuMq7GSIsn3SYp1QW2atva9qcUNVhkYcMmwHWT9Siori6oKWat1haGy1+jhR - jx8l6nDPqMkS+DklmVambNlUPRvbdUR5rti+K2ilxBgUiElTsjhG2/bx3t+yyaJETJziaK1wbFTgIQpM - mqFElGNbxKmWg3Yq/Wwobm3I1HRGOa94Yy2VRxuhaoliup4ztXr+QGHeP3Xh+Y1nX/3bwH/zH44AiPw2 - b/72D7Sycifzue9f+mulvdz1F57lyuQX+MYPzrC9sUnVvEM9t89cMaHoQqPrcXOtxm6rhu96nJwcsDje - xcuGPFmJeLJtoXyLXhRTSTI+faVKqVxmve3yzp0Ddg76VCo58p6NbVkUi3miQcyDx2ssnznDhXNjzNUT - TkrCjd0muztDjExRKCwyvXiWqVNPOPvsAU++3+YP38g4aOV57rzP//prAfu7A54sd/mDjzK+dfeIV94P - Ofv8OX7z3ALvf7LGRwe7PFrbpNMaQCrYORffLzPtFLj0KGa60WV/Y8BBZrErQ7ofPOHadMqrpzI6UZGo - o5mYTqjVDTm7TTwaYVku01OzPGpm7O02mKhq9jtDvNVl1GifSu+IkhPTGkLLKfPa117j6RdfpD49x+ry - KhuPl0lWt9jN3sb3Mgq1HP1czJbrsb3W5GD/Aw7Xd5m7VGZyRij0dgiHTfQ6DEMYDSALQWJQyTFr0UpB - Ikij44jFJOVjbDeMRhbtHhx2RoxSsKzjRF7zMYfachS+q3F9LdoBsQW0Uo6jKJU1xZIiX0I5ecTyNF5Z - YyUZSYTYRUfpDNlcb+E4HfKZyKuLISXL5r0dm0akKOXhhauWqheMbG4YWWmV1ZHU8L0AZWvSzKg4QZne - kdSiJ3zuQoun6pmYniEcCSmaYQ86XSRKtGjLIg5heTk2+5uJ6ETIBJUq8JSlK54ttYKHn/OxfB/tfgz3 - FINGVJpmYtIMNxcoJ+dLaoxEo1AlUYRna7ECH3yfLE5UEkaiklQC38N2bPaaIakzVOPjGV6Qo9/Tsr56 - xP5+pASVlOqV7cn52t1wFG0+86nfCuFv/5UU///fAgB5Bku/Wvjhh9EZBivnC4Pv+8+ee52/+/wKF6e/ - zE8+yrF9I6LiJNSK4Fpw2MxxZ7vOQculmEu4vBAzX02Ihxmr+wk7LdA1RWQUe32LrYHH569U+PyrFS7O - CN9/z3BnJ2V/mJDzLfKBQ6IyDrod1toRByPFzJjhVG7IKWmwvK9Ya0UME4ckmuClxVd44de7ZJU7PPoH - Xd64CdsN4fNPWZydSJn1DdPjwn4jYWe3hfv6A6ZXmpyeGqdez/P0yUm6aY9WO6W542BvaMZbffx+jzut - EXcGwtzlcc6cLnJqsI80En5822b6QpUTlx2q40fki32qFSEbduil80hhGrO7h9VrUSp1GbTh7UPhxuN9 - jjqGam2R57/8LIWlSziey+HuEWvv32aw8RB3uMnJ8T616oh80RAU8qiqJl4cQqRwEvDVHo2DfYaPNY0d - Ra8TIJbgex6BFyB4oFyU7eL6ebQTkGobk9NgacS2SC2H1HJw8gVKEiEbHzJobpBlIb4nBAUfuzjDyp7F - B496tHeaxCbGVVqdPy1cOStM1BWWKPoD8FKlyjVFZUqR2bbaO3T44B1Rw8NU5itDxssZONDpKDqhy0gs - 8YOUubpwbhoZtRLeu4nay8aQyjiW6zNMFAw6jCerjJlNtTi2z0tnMzNfsFm5E6vM9SDvStzP6I9g98iQ - bxmO2vD4YciwnajxEqI9xBhwlBLPspTvu8rL58QOPJTWH7v9jomeYjIElJvzRXueiqKEdBQpkyQY2xPb - ttGWRZaGkn78JHBdSynbBbtvStWQ2flIDQcWG6sWy08iNWgZq2hbg2olf+fkxaUbcZwO/soq/88lAGut - /ESxdKJdOb+0PDgz9njjKf3m1h/xS6t/yvMvNjn3dIXvN5sUTA+vDDGwP8jxpDNOd2BYLLW4OD2k7Cbs - 7gjbPZu+sRi3DX4uJY4y3l8eUi53mC0aTlYzrCs5Ts0qbm1GPNkLaXUj4jjFWJrNwxH3VtrMOVDRcLFg - c2NYZXsYcXPlMcNogShaYvz6FV5+ZYjXWeb/9q9CXr8bEpqA508FnB13uDjTY7oYs9VRrB102Dnsc376 - gNlxl7E89LKYTsvQ2YlI2wkqjhjqlK4BHdhMVjSnxzS27/LWZsLrdxQXSDk9meIdDamdSqnmU5qjHpsH - RyxvbTEeJFw8a3GulLJ7OOSdRxk/2dLUTl7h5V/6ZWoT0+ztHnLjxz/C2X/Axdw+F/0BhXFBB+Bb4GQQ - bsdkBvJ5CCoat2xD6nCwk7J5LwTHo3rmArMvfZGOVDhshviBRaaExihmtx/SSTOswEM7DmhFrGAYxoT9 - EdPTc5yfyXPmgodzYNE8eozjG7wgB6ZEfanE6afH2d7yVZwMZWzKl4VaRxXpsLkODzeFtYZgCUzn4fw0 - nLtYYG5yTO0uKu72e7y1dkgh0GIFDhtDR633fAapxdKccO1MxmQu4+Zd4e17Hl1nDIo1GcUWOdNm1l1X - l7wHlP0OhbpiomzrsqWpuoJvOzLIFWkm0ElCDpuh8rdj2TuAjeVYhYOMyQqkthJXa1OwNK5tIa6DnQvE - 9tzjDGIBkxkkTsgyAcsG1wWlJIsTlGRiWRqxHZWhIclEmWO8udFaDSNIwgxjR2p8ysjJJV82NzJu3QlZ - 3c9Uqi1rouKmeV/fvnD9zM3RYBSpP9uC/YckAO12uT6K5alMMdNTRT0M8vxw9bPcW4av7d/kfO0W1azP - 7FREdVLRDC3WWxX2w0kylVELjjhR7ZKNQu6tGQ5DD3Fsiq4wN26TJor3N1IeLne4mRvQbw+IYmF+osRE - Oce5aZePVoas7WuyzGZltc2HOZtz9Rqnxi3OjYc87edpbNusbWyxhc9y7SQ3Vp7mtQWLX/p1zf5og/Ab - Ax7upViOh2sFDNsxmQjFMR+74JENoWv69Pb6dEewsS+0mwYvFZbmLObOOYxsj2ErIzhKycUhbugR6hKq - aKELPW4/6nDnrsIbKX61ajh1MaLZM6wvH9BaD/n0L87z5c9N42WTrP/xY1a2djh9+QWufuYLzJ6+xvK7 - 7/LgR99gNnvAubERZ2vHpphGqNlueOyuQWNgSJNjk0uSQZCDUh4qnkF6hqwHC3MpJ8/ZXPviSdrVa9w+ - yrG812b34Ihm45AVGmx2enR7GUKK1haxKNJeBI0OC1YdZ3ycF5ZO4to7rG6tYItL1He593CX8WKbp856 - XLmWMTFtq+oU8uBD+MF3FT+4K3RSm/pUAZwx4r4ifXhAYGmu5jJeumCJGMU/W7M57LjKKuSwHIdeYiBN - uXpacf2cQkYxq1u2enhUJTw1JeIWGbW6vLSwwov1J2L3OypS4BVc5UpGXidMTIrpGCE2WmGXVMpQhoOQ - zbVYbW4h3YaRJIbUQrSlJWdZqubbkgs8LN/HCjyUbWOMKAQhM6RRDCgs3xeDJosz0lGEpRRW4COejxEw - o0iRpGJbGu07tHvQGoyE4pDymFaVSkVu3ejL45UBjZFRuZI/nJivbHueuv9zv/LqxvK9tZ994sdfRABE - /jtA8/4PSvWdvvtUo81E67BDafAYyRl27U/zz+5NcVa9zSeqb3H5REq9avHBkxKP9sYJ0yrl8gGL403G - gw67q0NuPsoYpAHKdehHMFbLszRhMVEfktMREg7ZP+izfpQRr4+4fLLMU3NF5ipF7m853F4bcdDscu9J - xsrTZRZnFYuFhOtWzOaeYbMfkVW6RCZjbXCJG70SUTXm879YoFTa4f/xP3ToNkbc0SN2jhS2m+dKPuDT - V/PUfPjGjzKWD0eIVnQsQWqG8bwhv5hncrEIOZvNeyM+vNlF5zSLJzzOnw0oFQ1e3OaN+4atoc1YxUMX - UkwUsv8kRTVTnpkfcemsS2XKpblRIdYVqvM2T33684zNLPDeH38D1l7nun+PF05DHMGHj2GlobEKBS5c - moKeYvlxn+agi60yigWXzsiiewiuMRSsjKqXsrmVsv+dhxzu/zYXPvEyly4+T+zU6LmGvu1ycXqKk+Nj - PDnosHnY4qAzgFwO/Byqqugrj8ORQL5MpktsryuOhrATxry7OkQNW1x8T/GFVy1e9aFkZeqjD1K+/a5D - Olnisy8u8EufPY0qTHDUaErj0Zu4WY/mIGXSZEyYjIlAcyg+fTtPzdX49ghbJ+rSCVsWxw3rTyKW98o0 - 7SmMO6EsraipXV6c2+HZhR5v3HJElOJE2aBHsYqyVHI1RRim2L2UUjEvqXHodDpsbI/Y3U6VgxHlIaFR - khdFzrZUKeeQL/g4+QBlOxijVJZkQmaObb9pJk4uwC/klDFINAxVPIzwfAfb9wXfJY1i4iiCJFWu64jv - BZJ1E0IzYGIswi9oaRxp1lZTtrdiJBLJjwVbsydm3y2W/PX9naOo1+7/Vdf//1QHkAHoB63c5EHfudqL - rPHeIMJqt1BpSs7LUbFT6rZirKwoeZDGNg92qjzZq4JxODETc25uSE6F7O1HPNwQMr+A7Tkc9lKWDxWz - E4pf+0RC1Ohy7+6QhYJGlMOP1w333+6yNBbypWeKvHY1z5m5HD++uU9jGHJvM+HkVMT1uZglZ5/TpRrv - z0/TzDIerK3iBSWirMba7lN8+lyBT3xlkjhr8a3vrfPmnU16CRRzLmU/xb3aY27G4FYMzRWLpG+4vmh4 - +jxMLXrstwIeH/qcKcGZhYBr5yx8K2Vz/YB8ajEapsShg1EW4xXhuVMj/EHK4/cysn3h6jxceV7I25u8 - 96cb3PgONNUiFy9dp90acLD9PYKtP+DVc33OTcLNd+EndzQfHNnEJZdrp0qce6bIiURj5YTvvtnHVoaX - LwcY22f1AO4vj2iHwsC2eNwdcaMx4uGTOzz74X2efe47vPJzX+X6uRe5cfIUURaQRhkXewPeubfCG3ee - MBDIbBvJBTT7I9Z3W3SfHefymTk++XSeP3y9w8pGAjrH0La40VMM73qYQo5ffcZnmOygizGf++TTfPU3 - XuHTP3eWrH+PzVv3eWJCwnAMy12g3TCq1d1FJx3JqxhRGVGscR3NQlVzbgrlGcN7N0WWW2UxY1NqENtM - uQP19Im+LE0pHDsgCWPqZcPpSeDISCcSitO20kawnFSq47Y0OrCxrtXGekq/HUsph1L2MWkspzR5yxLH - cbB9D+15khlFmhx7/XWWIsagLAs38JQX+Go0isiS5BiZbllibBdLadHHfkGVIZIZTZK6KlORuPmQhRMi - QZBy/35P3X0w4PAoUQWtpexaG7NLU2/PnZw6nFr4rb/y4odj+/3/6M//4T//usXIKn3/3vgn11r+1zca - dr3Z6KN7m4SJkIpiKr3LxeJ9ri82mZ8xdFKfP727xEcb06SZzQtnj3jxZIOyGfH+g5DXHxnECygUPALH - Yr854vF6i/ZhFxUlVHxNtydstzRNydMXl4OBcHOlR68fc2nOYbYeEPgeO3shFjHzUxYV38LKlWj7cxzu - dThc2wA7ww0qBN4Cjb0ICUd85qUqc+NFBi2PvdYQRw24PGOgN6C1H7MwW2ZhskDJ1VyaSJnICa2ez0HD - Jhpl5HWPi0vC118rci7o037S5DvvDvnDjyze3C7RyWxmysJTZYXXtugfKOo1mJ+DvKc4egwrHyk2txVZ - ZRZnZprDg2Wmc7f5619oUpGMj95VfPuWw7uHefbsIrWKzaQXkrX20YMGLiPWD4TGwEU5LhfmFdfnI3Kj - JufrIZ88r5j0hZmq4sJFi5YS3r7b4INvvY29+4jPXsmh8z7LfcXqQY9RklHIO0SdLlF/gAQe9PrYwyEn - Jue5cNrj+ecGTE77FIMSOauMMhmGEakpsbh4js98+nlajYiNtSMoj1Ofs5kob3LvD7/FW//8ffXwQ1vF - 0ZiyXUdtrG3IrdVd7rcMI8sFZat+X5geM3zqaSMvnckYNlP+4Ae2LMeLKqsvMOqnajbf41MXYnVizCUd - KNneaKlaEHF6EklHGWhUruao0FjSjz2x/ILqdCK1vNwwO7uRRKFQLiC+p/FsS9VsS5U9R3u5AK9cwisW - RdmWiBElaarJEhBB27ayghzKcYhHoUgS4zq2svxj048kiUgcozKjtLZUKq7qjiz6SY/8WFeuP+Oh0Lz1 - 9oi3b4846MLUZC6t14M3Lj579hu/9Jtf3Pt7/80f/KVe/f2P/fz/7ADiHcdDOJck+sx60yt0OwN01EJZ - BscWPNWlmO1T85qMTxuMCzuHDhv9cRqRT8FtsFhtMZUfsb2VstW0iLDxUdhkWDbonMMoLvKtxx5vrYRM - +DGxsRiIS6gdqjmFRtGLfN5cTbm9ccCvfSLg5RPwp282WduY4WFjmhdPKC75Ic8OIrbzNnstl3u7DUJn - FZ1Os2mm2bQsktF9rl2Y4r/63y3xj//FHDfvPsEv7dDDwrQh125TdjKemRJM5rPTK7OV+rz9cMDWTovX - LtuYNKax0WJvJ2Wla3FgBYSFgECEpaTBK1Pj/Pyv/ByVmtDcXmHvvXsc3u+w3rdxZ/LUT7pMLiY8aiqW - V5qcu7rOC5d2mM2n/Pg+/NHrFrfsEt28Q0DCSWfA07mYc1WLyoTDQBswwp2NlJ1+n0ZbMVtMefFshiQ2 - duDw3NU6GRmry1toB4a2x3fuprz1jTus3nvCL/2dr/Crn/w834jrBE6dmUqBwLZY3jtitz0gGQ0YpRY3 - l5ucnaxz8tlf4ZO/dsSLX7ZJ+me48eE23/nuG3z3hx9xdNDmICvwzBcWyYq7/PNv3uC//z+9y8PfM2Jt - JoRHoMqZOv98gXMvTMth/1Ad3oH90BErsPGVMiZMma0JL1xRys5G3F+H1W5ddQrjuEEe1TiQgh4xN1FR - xXKVVselc7BDMRqocDZFWworp7FcLZI4ytiCifZV2B7Ra/W1kkw8H4kF5RgleUtL0bHI+47Yga+cnK+8 - wFWitKSSHK87kwytwC36SlmaKIolGo3QInj5AHxfMlGkwxiJYqUFFQSekdiRVjsk8/tqvDJUru2ao/2M - lZWRajRTjWMPxqbrq/WJ4r2HN1c2LEv/7IL+f5YC8PDI80Q43wv16Z22bQ/aHdTwkBQb1w2pqEMm9C71 - XJtiUWiMXB7sVtnrj4PjMFnZYaHSwssG3F1O2Diy0b6DpUGyFKMsbH38ZfRtl8S4rAtorY5ZjcenoYho - co4icD2KfkIYh6zvjLi/H1MmY2k94tx4xEQ54ULgcWuqxgMW6IU9VldWOdjY4ZPPXGXp1BWepIv0124y - K/f5zV+eJ/nKGe6vtHh86wa379znzbWYxlBwtEu54nJ2zuaFUwlnqwnNA8XmsMiSsTgzMWC3F7GVaTba - eRxJuVxuc7kY8/ypGqdeeJViUSNJjp+ubPDjTcP+9St85T/9Zb58bZrKG39E9K/eY+XmG5z+lDDuGz56 - Q/j+fYebmYcU4MKEcGnS5sJ4gIwUv/t6xNkLFV54YYLJSYMbdHjOPWSunOHE8O46vPE4Ydd0+Y2/XuDL - nwg4d7LCN/+0xzdfTxjYRdpOxu88GLD3D7/BL67c5td/4z9m1bnGt++OwYyN1hbNwQap6zLUivc39zm9 - avj0yYB8/IRB7wC8mCsvfoqzL3ya5577B2wv32L17rZce7bKL/7qZ/ErbfXdb63y45uP1aevxnL9FZt2 - L8AtjNFrTSBDxJMIxw5IscgEVXQTOTmpODdny/4j1O1Vl14wjeSrAIgMleumVCo1CQo5jpRRnY6tioLE - sUi+qpV4Nq2BTbdviMK+ykYdaR6lsrOfqbyHlIuItlEKlIvGt7XkAleCYg4354NjiYlTTJqislSMEZTr - 4OZzkilN2B+Rhen/l7r/DLItTa8zsefbfu/jTZ707mZe7++tW76qq6qrDRoNNCwJAhhSBEFQFEVpFKMJ - SSNKETMTCg31h6IYozEiieEESIAg2UA3gPZV3dXV5et6lze9zzwnj3fb708/shqkQgTJ4cywwDfiZOSv - zIjMvdb+3u9d71oCVUg0I1E0XRDHREki4igmQUlU1ZSKJghlh1wxZGTcoNFJsbw6ZGvTl1EvFjnH6I2M - Fm8uXJxe7nWGn8qb/19JAHL5H8HJb/C7/8y2gHMtT1lsD1G9fhfp9fC0FGkxJK9UGbN7jKYSHEOwepTi - 4U6Jbj9DMZ1wembAWHaA13N5tOxx0DIw0hq6+mOp7/EXIQSakGhCQQoFP4IwiPA8nyRJkEIQC51KHk6N - JhTshEFfIUiybGz5vP3DDebSBi9eL3FuJsdnUhUaep6PH9Rp9V16eYsHeweEQnJybJR79SkG+x1eGanx - /GSXF86UWZh8ncLCU7g/esRH91fYOqhyNBxQbces7qmYuoKVtlnah6EX4jVjem2J5kYs2F3mUjHXSgF6 - KNEtBQw4Wlpl6a2brDhp0r/6ZZ7+9b/KtflprOYhPj9iZDTh2QsRJ0uT9Koq3/rhNnf3wM7CtfE+L140 - uHQuTX9o8t6DhJvNgNVVjf5IhnPTOnkTNpfr3H+Q0A9MDMvBHFEwOjEf3/LICZUvXSmQGrEg1yPthaRy - Bvmsw5uHXVa+vsx/kv57zDzzPM9MvcS7O6M4/TGunFTY3Npjd7/B/m6X+2MKdw8tTkd71D+6yRu//yHo - v8Pi1QKjc9tMXU6IdSkOVnQ2WhELDkx9RaH+Wkn2arGo1n0GXkQprCKDkKDXEaGboAgpB96x0vL0XMK5 - WUlGicRby3BrNUWYrUgtm4I4QpGRMDVNZlNZmbJNoaoaXiRkz0e6iWC6rMmh1Li1ImW3ExC5IZ1OwsEh - eBIyGsLUQFUV6SgKKVUIVdelsCxhpFNopimlFIRhRBIEyCgSCIHQdYluCBlGUsax1HUV9dgoRMgkkdIP - IU4kEmIhRM9TxTCKUcyhnJx0mRoP5MZawp0HvtypJ0IzFKVUULvZrPnx1ecvrGyv7Sep9C/96SIAFIAV - JRFGaaNlnGsOtTnPD7XI7yODPh4p0gzI6odMll0qZUDAbifLk1qJ/lAwN+lzYSYgZ0Q0ajEbrYR2oOJk - DVRikPKPL1gUIZBA+Em6qjboMml4nDmhENsOWwODB+shShAxkYlRFUkn0JGGyaCb8Hi7xb1ti4UTPhfy - fa5mHfYyaZbtFC2pkaRN9rpdmg873F9eZ7RYZLpynrv6ItW9QyaXtzhVgBemNJ76hUm2XxE82tPZrTbY - O+xTPVLxXRUt0TAUF7Ubs/QkZNyJuFpIsFKSrICCZZO+/BxTL30Gp1xi+713WFvbIhy7zNmrT/ETiyfx - Mdju7lAws2QnRpkiIGyOs74b8eBwlwMPYs3kzoFOLZDcPhxybTZmvpzwxUsmrcjHb+ygFnXywqOgSFYG - sNWXVMYNRssa81mfdNShfqvF76zaBJkRnnthmuXlBik14NS0wY9iye2NAf+P/886v3zU5/O/VEVMfZZ+ - OM3mfkygOmRHQgb7Te6utvkHbxf5tUsVFhdOMLJQ5+YHh9x8sM7spMvFZ0zOvqRIw5iiMdDZfbIictk2 - 6VHJHz7y5NKWwbMXC+KpcZvxSiQUEUk/kCAEsZ9gpWJuXNQ4NR3QbwYs7RqsdQrIsYLQbZPY94mFBqot - NDVFJmOQzlnEipBooFmq6LgKu41EPl4O0YIYPUm4vwv7Hcg6YJqQIKSlqGQ1hbypSMs00RxHGilHKJom - kkQiEin5xJRGMw2pWSaxREZBBGEkLMeSqm2TaLqIXY/E9SRxInRdk4miy84gohe4aClXlkd1kc/ZYn+v - x+qmJ1ohycRItluZyG75Q/fu4vm5w36n/z+b39+/NQF0+1JkD/58Ka1Fp7bb2YlaBwtvgCJDEgXUxMOI - G2TUQyYqHsURGISw3cmy1S3hhR7lVJszoy4yDNk9ErR8nRD9OFVVJshPPmoCiVCIEonrg0HMyxc9Xjkb - c3Iix0Hb4e2Hkp2NLkYS4Og6bVfhoHds76TaCf1Y4dZSwHhuwFi6xnh+hGcmR3kyGCHe7nHQOiTUTSLT - IpQBdhITGA5OsYIqxtjrTbHb2seu7jEu+8wWBD99bYzId2nU++wdhLT74HkK8QCCTkLch6IN5ayC7Yyz - G4+wZMwwc+lzzJw/h2EMGfS7NL2EUmWGiZFZND9h/+hdBkdvMlveITUj6bUV1h/vUKt6nJ+OOJ816GoK - P1rW2GyFjOVdlCBAUQVdz8JzA9LBkK1DSVfGmEnE5RScGg9wCg0mS0WmnBHidsTDlQ7ffa/JzI0Uz35+ - lM884yCGLsPmkM1qxBo6P9pLSH3/iELqfRZfF7w2dY297RlKmQkSkeNeHFE96vPG+03ycYmfvvQiL/0F - lcVXd7h79z6dnXUerfW5s3Egzl9KUyrmWTkYyswAzlcKiFggw1gESPRUmVxxBN3YJE7qhFJAHJExJJdP - ahTshOWliM1Ono45SsouoskE0T3EbizjDEellbpItpIjP9LENDR6Q3iyndB5EshmGwI3EUkk6bnIvc7x - js6IA7qOFAhhCAVLU6VjaliOienYQrNNKRQFGYWo4tiSXioqRspBdWziKJaB64k4jBApB8U0kQiZhDGh - FygyjqVlWxiGJQ9aAW7Sk6NlX6qGIRp1RWxuhFQPA6EmRNlcemN6YfKuEKLaa/eDwP93Pvr/1xPAbkdl - hPS0G8qL+x09X2v6KIM6ChLFsMgyoChrFPQqpbyPaivsNCx2OmU6URHT6DCRbTCZ6lHb9lnakfjCQtM1 - VHm86isRCARSQpIk+GGCpiiM5TXOnSowNZvQdg1QLGYrCgvjbYRIUITkoCnYPjpOss7ldUSisbThkdZj - Ts0lPFPa5NJMhtfDZ+m2Daq7EbGpYKVTTI7kOTNWYDotqNVqbMcJRiYF6QUsYwJXGdKjxVbtEL1fQLgH - YAwYqYRoJMQDiIcaYWjTiy32rDyiskDVHKdpjjI+dQJUEEd7dBsNWonB7MQ8mXyJ/cYeXuMPcHpfRUsi - Bq2Eo4OAldUWfhSwOAvjJ7KITJqZiYijvQC1G7C2FNOJNO4cQdGMGScgGiQcqjrDyhSZ+Uly4zkM08d3 - FFqOTW5U5VR5iD1+SD3us/twg/kJh5G0SjYf85lzGSxh84OHLd5e6zH8Wpf/qPQhV58J6F0tcOhNstMo - cdTs4boe9e6Qr9+yqfYL/MqLI5w/4fMTRZ1aM8/KVpHVtQyR59PaXZFrO0MyEzPMGJfF9bOHciq1K6UW - EHo+XqgRRYIohChQyKQFJyYlC6ORcDsR790RHIZlRHFMhtLAGu4zFq0yUdng+QmNlBqws3kklx7u0x/4 - yFiwWjWkqamSKMYf+OKwf7xCHQvIWJA2QKgCXRU4isBUVaEYhtRTjtBTthSadhw9H8fHVnRCoGgqmmUK - xdCl3x2KOIxBCBJNE4lQpIwiZBSRRLGMEomWaAhMEdPFzvSZmUuIo5iHy758sh7IXjdRC6aS5FPa0vyZ - mY8tyxieufq/+1TB/y8lACn/Y/7W30tzfUqbrvW0S/WeyLTaQ+hViRJQNZui2GNcbTDm9Mk5MW5o8niv - yG6jjBAOkyMHzJXbpJUBH267PN4QJLqOoao/znlHwDGCkSCPzT8MAwxLodEyePuWz+3VNhNjcHYhy5de - STHsxtSqAdtVlcO2SioryNoqSQL7HY1HOyY/ugPjlSoXzsU8MzbBwew8a+1p9hoNklYH37CZXRS8OK/w - 5t0W95cOaXUiSlNjnDm7gL1whU5nwJ2HK7Ra09jC58SETd6M0GOX2PUYhjE9aYBVJLTytIWGnS9wZmKU - KzN5psQevdVVanuHdIVOPDKBa8ZE1beY5j1yco3tm7D6oc7yY4OGnxClBMOeivQdTk9n+LPzHjtrCT/4 - oWCrLgk1yaVpn8lsQMkWtOQc/tQV0jdeojS6SN4sokofz2uzMTxC8apMjnZ4/sYZ7n68xXfeXuOtdxtU - 0i5XZ1Umxkd4/YbDWCXkjTvw9obL7B/V+UryiEsvjTJarBDLk8xVKvSGffbiBntuxLefdKl2Il4djXm5 - PMVEWePpKx6LJ1X2bja4/aNDlrcRBcficjjFuTNFcXbMlJsHq2hRn26vzdANCHyJjBIWTmjcuCQoWiEP - lxI+WrGpZSckmSKy22LC3OTG3C4XplRm52HY2JTry21ufrhCzx1QykM2rcqUZdCMY6q9QA4QwsooIhnG - 6EgpFdBUBVtTyakCW9NQDAs9nUZ3bCSKSOKAJIwQUSyFEFIYukDTiBMpYj9AVYTULAdhGjKWktj1hQwj - qSiK1BRBECoMwlhGiitGyqGYnzHY20148MiVG4eRCFQtnhixe47Jg+kT47dzxcy/c93/vxEBwAO+cuEZ - 43srqbndrn6x7yYZdzDE8Jr4IouOwFHqjNltpoqSrA011+TBbpm9uoOtRJyd8piveMR+yNZBxMaRgiwo - 6LpAyvgTsw+QMjmWGiHQ9eM24LDh8yjxkIHLze2AXFsQpxT+g1dTeK2E31qqUe8p+GikhUCREiSk0gY9 - T+XN9zzGcj6VUoPZiSe8eiFHNVzg23c81vcO2BkeUZ1SyZwu8ZVLgoyn8Pe+2WKv5XE4HNKsHZG2DAZq - TDQziijkiWamiTSd2PUI3CFHvR5Hrsv8WIGcobG3skm70SLv2BQvTFDCZnO3yrDTByfFoe2giH1m3O8w - qW+gNQXv/Uhlcx2k7pNJxeyHCvc3TbyMwth4SMn0sNIaCxdHGXETMnqPxWyfUNfYNac4LP8SlYtf5jPP - Xiaj6wRuTBBLegOPVrtNrb7NXlDHtQLkhQucVXfp3n7A+vYq9ftVMlt9Ti0ofPmlIlPjFv/wm0d8vBLh - pDr8hamPyEyNkHZyzI6X6LoRAzemZ/sMooh3No/YqedZmXqWnxbLnM/exmzcobGe8Hgdse9BSu+TcvYp - lA1UTRP1piHVxMD3NAa+wA0lQoTizAmda6eF9DoB6/ua3HbLtApj6EIX+cEDeXl8Q7501cXOp0WgK7it - I5zMkMtPqZQnx7BFSNGOxUF1iEfIzBmTKIHBIJH1nURGoSSSSFMo0lZUHF3BNjV0xxZmJiVV0xRxnMgk - jCCKkXGCYuioKUfGCCLPF7HvS9MysHMZYtMk9AIi10NGEaqmYlum6PQF9U4fMi7ZYiJt06HdHMr19QGt - YST0VKpbmRlbS2WsJ4Ef7vtu8Glj/08ggObn9YweTex1zYXdtj4bBrEhEh8IiZMILfQw5T7lYouJcYlh - QqNjstocod7TyGX6nB5zGU1HNFuw31doRypZoaAdm74B8tj9BzjOVD42/pCJYOAL1upgKyojeYfGwODd - B4Ir0ypWrNP2j51aDU0DkRBFEiEUCmmF3kDw6ADevGMyPin5XOEWZ0san5+vsFsvUu2EuN06ezuCJzsK - X16UeIsm/3SuSK/pUzuo8b29GugGejbNzGgJ1w852juk7JhUsjaGaRICuiZodYfsugH3thusbe/x3u27 - nBqD2cmIqNtFUVMohTEGRohmrDFl3cZdqVH7wKCxP8HClRHOvqKxfH+Zo/eaVNsQ+j7JIOYHjztU2wqK - HfHsWZWTpRi3brCkTVGdfI3rT/8c0xPniWstHgURe35ML/SJkghTFUxOnURVz3HQ61LMtrm6MM8rn1lg - ZWWNP/xgmQ/eO2D9zpCrlzSungNThbUVm6KhMtzs4SV3sTIOY+kXcKemiPBY3a1S7/QgbbA97NNcG2KP - nkDPpzghYtkLdsSB10ZVkXPlHhem14XowNaGLw8ODFKlFHZOE52hkL0AzBQsjEs5XYh48rHPo90RMchM - S9U0KIkjedJa48xYW0yMGXLnMGKITmVmSlx/PmFmokK/G8qP3u/y/tt1oTm7XD8dM386y0cfefKHb/Sl - iKQ0dBDik95fUVBUFc0ysdKO1G0bVE1GnisJI5CJSABF14VqW4RBROgGJGEkSNlSsS2JUIiTBOJYxnGC - 0HShGzZSCaUf9xkpDGU6G8lqVYq1tVjs70WogRTZnFadmBn9cGKqtP+zv/Zfftq4/5MJwGvkcx2Xi62B - NrNV1/Wg30NPXBTdwEoiUkmTrDygnO1QHodhIthtp9hzx/DRcewms4UeRuzyaDviqKcjVQNVqKji2Pkx - To6tX4WiHntCy+MwEEMFU1MYRjb90EITEikE3tDng9sBthLTiWxUXcGO5B9PD6QEXUoMTaAZJveWFRzh - M5bv8PT1NZ6efcRhdJ2hO82HP1yh1dCpRjmk71EJu8zJDs0wpI8FhSKYBmEYsbG5x+bQQ/ghUlWRpoGq - qWimjqrrhF5AMBiC7+OkLeZOTDExlkeT+xxWa+xHWQaVReacBovGEifkIfc/irj74Rj62Vc49Wdf5fwL - WY5q/y/wfgBySH/gUG+n6Aidx/Ue67t1SFKYF1IIbRyteIGxkUuUUgbVoMV7R208zUCYNh2hU08kTQlu - P2RMi3k+kyVLhlpYwFEzTC0U+Kw+RSlzF9m9j6ZtI4TL2JiOmSgETXj0RGHM8pkvt/D8FlmtwKhjsZ8k - x9tHpTzIDkGnw/srBaYrN3j+c8+Jif3fpfzh18gXEM+ciJisdOWtW01ufyAkuVMijFP4w0Ae9GN8Q2Fx - 0ZAnxgVqmHDzocqd/TJ+dlZMpbqcTa1xptxgYlIhMlOiftiWQtfInj+FaRuy3Vjh4Xs/5K1v7fLx3Vgu - XLRETjis7yVybTOm1pBKMackunVsKy8AQxEYhoGZcjDTKakYx0+YTGIh41giEykVRaBpUhGqlJEPUSx0 - 05BCNwilQAYB0g9QJICQYSwY+ip+7KLbQzkzq1LIKWJlxZcPHnsc1mNSlkLB4aAyVnjv2kuXdvm/f+3T - xv3/PwHI7d+C6UMevGXmqn3tYsdXJg+7UgS9Iwh7xLqDI/uMJDVGqVJJu9i2YP3IYblWphuUsOwhM4UG - 406HYcfl7kpM09UxUhqqiCE5XnU8XnkUqIqKQJAkkljGxLFEVQS6IkARSCEwFAlRwPL6AEWBTmIhUTBV - BVURgCSRCVEMhqZQKWo0mjHvrwjm37NwsodcvvptPjOv06kvsvqkgq+XGPg6sSoZyRtcHU2o1z2W68dr - n8I00XSDzOgImUIRUzUYtId0akeEnSpRv41vOySZDJg5aLZIWTqVtEVKj/GHA+rNAdtJiUapyMvFVeb8 - xyTLMdG+TahN0p2d4YFMEyyHaHqBqbECaq3DvU0fw4l49ZkyExWN+7e6OEOPgx0beyoHRh5VqGz2O6z5 - gvcHIQMiFDPBsyz6ukFfV0l0g1CB9cTHFpBWHLblCBlb5ex0wjRp6usKe3cjjnSBamncfdBjZSsk0Ur8 - XN7glROw394gG/iM5fOkK2VEHCOTGBSF2LZpDiN260MOW45MSSmulaEwDpPhgEffPhDvf3fIQaMkrl+u - UBpPE3gtqmEsjbLC89c1ZoqRbB9FLB2kxU6/hFp05JS2xpnMKienQ8bHHTQEhweSVElhZMyRqcyIWH/Y - 4h//o468/XEbYWuKopVlb+CwtdkVquZw9bohCUPR7vqy1Q6RCKEpCpZlJnY2LaxcRghVlTJOpCoRcSKR - UgjF1CWqShhFRJ4nFRLsXFqQcoilEPHQk4nrIYSUhqkRJhrNdiB7kYuVCxgf19DUhI31AasHgehoSlwZ - z/dKlfTaoDu4rSji6NMG/b+UAH5c92upfMdTL3d8darrJohhk9gfEBpp0qLGiH7ElB1QSkmSWGXlMM+T - /RJhYDBRbnF6ukvOdNncCniyEdIPDUxbRRwbPh8Lf1D4sRJIIo51B9FxWxDL43ZACIGQCboKCJUj3zo+ - KKgaqqqgKXwySpQIjtsARQhUITBtg64HX/+ei5Z4jI/UWTyzwheeTvOwOsmTA5vmVpv+WZ8r50N+o1Ri - /MJ1/mCpzKOjA3JmzFMVmwt6iznrHoViDeupMgPrJPcPF3l/tc+HK6u0Gw2SIEImktxIlplCmozwGQ56 - 7A5UGjpYpTZX8svk9lf46A3JMDxP6dwzuOUi/WBAq9lnNGczNlFCfdgjDF30pMOZrIqZTRjsZvjwYcj9 - GrwykqOi6gRhl532Lg+shGV1BFcYKEIlETqJomEpCl/WI17XE04icaTEkwpdu0g4VGj4TVZaadZ3Swxr - PrZooIge724I1vcVbHXI1a0216sdiqUCE7pK7GYZsWwONejGMVEiMLUU52emOFP2EO1vilL+AScWBe0j - WP7BsZArtlOcf7rC5efSMiV88ejJEYOeJ0ZLCjfOqlINXO4/gXV3WibpAovlJnPGnhhNdWV2LCUVXWfQ - 8MXRkcSsqIzOJYo/WEtWH96Vq3t94WlSXDyX8DNf6rF4Ipb3b0s+fj8ST9YHQiYhUSJJKwoFU5M5S0ez - LaGmHbSUfRxHEEVCJDEcR35KzbYQukbg+wSud+xI59gotoUMEkI/IPKDRAghbccSIlbpHrki1DsUcy6q - mpHdrip39iLRaYeKpqiDUqX4aO7k6CPfDzt80gT/aal/TgACAYleH9iTW039fHdAOfZ91NAlCkMCKVFp - kU/XmCyH5LPghgprRznWq2li32eu6HFuKkaVCbWOZK8PvqmSMrTjN8cnFksIifgkh+54CPD/+zdJju2h - EYCiqAhVRxoKUsrjo9cnP+fYOFggFAU+GSkiIWMr6KrKXhN+eEcwPanzUwWYnkj4yas689PjJGaebn+X - pXeX2X/4Pp+9/jQ//ZefYX2vR39jE56ssvq9XZ60mpy45nP9yzO8eMPl5ad/jv/Av8Fe81n+4OYWf/TW - XVbf+RgnozOR0kgP23QPOzzuptFmFS4tHjHT30QsNTjcyBBMzRDMz9J1UmTyFYrj01SiHfLpJ1iqSqUs - mczFvPnDXSpT08w99zKNTJuD3QaNoxZWqY5eHmMYtOiGBkGkETlFMExIIA2c1gQ/qcf8pBaTSiRCQBPB - g1ihJUwiNYuw0kyUVHKZFp36EY+3ItqugxdL7KTHzmGDx1sNZvJjpEWP6mGVIIqwVJ1erU4pX+bi4hi/ - OFnlVPs2mz94m8jzMNOTZLWS1E8sEo+fFSPniszMuYxbT9i6tSW3Vw5F2vVYmFWYLypsP0J89MCk6Y7L - 6QnBC2OrohI0ZDqlMFJJiXo1kU9ueTJBitL4PprzXfno/Qbvvbkpdlt9CkXk6YVETs92peG4tFpC7G8H - srob4BSktGwFW9FExtRJpwxpphwU3UJKIeMgIglCSRwft5KqJlTDJBEQ+6GIw0ii6SSKdtyLhgEyimQc - xUihKCbHsWCR6JDJB4xNJLLTGojlpYiNdZeol6hFS/UKGev2qUvz97utQfjiF/+zTxvz/3IC6DSElovK - MyTi1GbDKrY6kaYEHRQRoyoJuuxjRVUySo2RSojhwOFAYatX4tBNI2WHyXyX2UJAo56wVRMMYh1FqP9c - /JPITxSAEpRPlID8+GJQ/POxID92RRGfWIUnqIoCQkEK9XgTMYrRRIQmQD3m6eN/YhIhOD45GOkUSweC - 3/x9Dzu3x098ocSzJ/KcPJWlm4xT8CU7D2ze+v09Ju78IaeuvYeIArLxgCjsUZhySS9OMvb0z6KWM+yv - Nti793fwG4JcYZI/f+I8r/zCCX57rkhkZsgUiij1PfzdbbrxgPkT8PyiT/t9j+6tPKTOsaqX2O70CbsB - hakpjPIMameCTDbLnKLQbft8uBZzUFe5Hhn84lmVixMh46qHk7LImJDEEbJ9QNI9hPY6zFwC6xTIBE8k - 1FSTXVOlpSiUtAQ3luwHCQ/6LsPAZ8oQELr0Gw2ibpujfZfuoeBsxefUWELUi+j4ETdXPQpjbfLlNtOW - BWMZNAHdPY/5VMyX5o94yfkYO2zwcfEV9uMCDTNFTeiioRRQUiO8ko04a7XQgxb1vSo7u3U5PR2Li6cg - lXhidceUH+0WGTqOOF9qccp5Qqz3MXI2lazG8m1X3HrgcvZCTFHdE9//+035xg9C8eFtn1I+kRdnkdOO - pPEwUDa9kJUH0OtLadgSqQo0oZLTNWkZGqplYWYyqKZJHCUkcSTl8exfoKhS6DpSCJIwkkkQYhwrBUk0 - gySIZDQYIuIYVVWIhCr7rsCNIoTeozIeMjNjyo01yf2VhM1WgrDNpDLqdDVF3j554dqjg+0n0acN+D+R - ADabipYb6ifdMDmz31WtbreN6jdAUdENhRQt8skhea1OLh3hSY2tepbDfoVEyzCWPmDUOiLpNPno7pDH - OwIjfRwWyrGf2ie6fwUSeXz5l0iOs0AkQuGPiUD8MRlA8smYT9UUkuT4CKaGIUQ+gyhAqBq6YaMoCoqi - omkKmlDQFUk+LWi3LR5tCb76tR3URPJTv1jAMdJs7bWwLAvVydBXU3zjvT1++KTJ69fH0SJY33axS5LT - F2e5+PpPEbQb3P/2V/ngD99nZ6uNmnIYnZ1l9NQCz5w+y8i5y0yMp3C3EqqdLpXJJhdnVBbUEuv3ilT3 - UvjTp1jtxKxt1zh/9hSqbtPoJeSzIxTnxrgwrfDORsT9LfATh/yuyztvLxEM62TMgHNT4+ipgK1hncQP - UJoDREMCMWgaFMtETprDBP4pBuuxxlldpeUHLPUGHPYanNQ9FiwPM+hwuN3i8WrARDrmxUtQzEdsN+HN - +4JGK8FuBiRuQp6EghFz6IaEUpKkbBamDJ5fsHG7p3mvFvCHosBu12fQb9PvHkmjkLB4tiAcvUM62ZHd - 6gpr6/vsHAVcf8WUJxclrQOPJzsVauEIZ8+7nBuvSzvoE6Y1Esvm8CBhczOgP4jF1TMa5bIq33g75uGj - SLbbCQVNonqITh02QkmzJ9nfQfohmGkhURTpqCplRxW2qUthWBjZ9HFir0wQSSKkTI4fQ10XwjRkHCcy - 9HxkEGJl09LIZ4hVVYaDoYh6Q2QUC1XXhKabst6OZHswRKRcmc1D2jI4qg7k+pYnOr6UI2WnNj4z8ti0 - tNXnPv8ftm/94D//U3X8/2MCkPI/5Hf+saVlrfhUy1XONoYYg14fMWwSqjqmKiiIOuNKizHHJ2NBbWjx - aL9Eo5MnZWicmhoyVeygxF0OGzFHfQupGwiF40ujT+rHfv9wfCcYxhCECWEQoqsS29aQKCDV44Rg5fju - oO8maInLmN3nuet5pmcW2e6Nc+/xIavLT8hlTBRDoT7wCRQF29DQhSST0hGKwgdLLaS+zeTchyzMdrC8 - OXw/h5PuceXFHA+/3eBJS+fZsRNkwgHtlS7dhslow0L0txguL7H19l2WVlxWeyoyhFF9j2mvyujaI4qd - fQovv0Cz1WWgwuWzBqNBQO8jl26tTNMeo1qucHS0S7s3pIPGeq1LMPAwZzRK81NcfWaUzX7AwU7EjTOC - ufEIRelhO31KKUlWhuBVselTMCwqdkg56XO0GeG32rBwDibmCLMl7ic2q0NBXgQM+0267V20wQpmVqFR - KpNKjpgUHfYUn8qIwolFAyLJk8OErZYgUmLmvAFKPER6bdwODOMRYk3DKWiEdoZH3TIPlwXvLNW4V2sS - xDGEIdRd5mzJXMFmobxPRt1jd/+Avb2ucH1Fzk2nZS4L996PWN5Lo+kOL83vM585pN9AZhxHeIHGW+/2 - CQOXl57T5eJ8mc7QpOVF8tJTaV50VBk22zJot8WTjb6STiPDCNkfHtvYCA1hCE1mdI2cpWLbJlrKkZrj - SEVXidxIyChCxsetpKprKLpOEIREnn+c9GuZQrUtkjAm8TxCzyeREks3pWk5Mkr6eFGXkZyHogqqhzrr - a76o7nlCC2WStsz12cXJ97MZuwZSdlv/7h1//o0IAO4ITftseunIOl3r66dcLzFDf4geDvCSApoSkFaq - TGQHTJTAMqFWT/H4sEx7aOLYPmN2m6LlkbY0yqMWdlPHPZJYpsRU/3j8j5Qct1MxhFGMoUTkDNAzBl4o - 6A5jVGJMLcY0VRAqXpzQ6fYZzwqeujjFn/vVqzz9wjUa/QV++MMV3nrj+9hiiBdELO0PWdtr0uz2yKRS - WJaOagiOmhlurnj8/X/wkJ/5ouTFFyw67hHZwj7PfGbASlvS/TDgo9UDri5ovPZzY/R6FTxX4bv/3T9l - //EGD+/usBGoNFIOZjbF+FmLhWJA/f4W1RWD1pxNGGqkbJc0KfoPhyzvHtFXZqkWK9waJBzpNp6ls7RX - Z7fpM502KKdGuZEf4fTVMV5oNChk+lx9WmFiSiGOA6KBYNCIufmoS2V0wPgZHW10At8yOTzyGBzcJ9xe - JWmsw8xJGJ8isSwGMmTgt6GzD71tYnY5qmTZCxa4qu7w9MSQMJIcBBrfvm8xVTEJrYRcdkh7ENHt9hh0 - j0jlLXQspkcKJIU0rW6be1tdtg9Ctg6PqHfaSBVIZ0Arg1YWhekKp0ZUxlK70F0TB3suYSCYqKhM5hPR - 76l8/25KHgxNJsYCTmYPyOgtVoSKGinEbki75nJqXpdnTmX44GFaLC2HtGour38+w3PP5xkMHLFy3+Du - h4nc3PLlYBDziWU/KIKUppLSNXRNw0w5WJk0iq4dZ3z4gcQPhYxjpFBAVaVQxPEmYByj6RqYhkiEKmNv - KBI/kFImxFLIIFakCFQZJYGwUkOmp49b1MdLIUvrEe0eouToMm8p67MnJj+aOjHZFkL5tLH+ryCA1k/Z - ZSec/eFaav6gLcqJP0SRPkIkyCRCjbqk1ENG831GRiECDnppNjojDBVBQW+R8faJWj2GGZ3iSJZiTSIP - B8hYIH5sPCSOT/2un5AEEWk8Loz5nD9hMTI7zfIBvHf7EJMehhYxiEyGiU0YQRz0SWXGmTzzAs74NYZR - gcHWOmfLISd/+Xnc7hGeH9IObP7wjQd8++37eN6x2so2DfL5NL2uxtd/0EGyRy4PcyfKZLItuuERLz2t - kE45fOu9HrFnMvVaitmFNN2axu2PWtzbNViWFarqkG4gkEeSJ8t98lMuC+OSuQUFvRihex5Bo8PBvS6d - HZchFsOLE2zEDh8v7RBmclAq0G31MWKBWR6nH2bpiRylmSzXrxuU0uAmAn8YUMx32DwM+Phxwq0nHa7O - CX4qbTKasTmVKnIwm6HTa9Jv7pA8PIS1O1DMHacayRCGPYTfRtEHqNMGaHmCoIHea5PNS8bsEW7dDXnw - kc8vviyZHxNcmoNbqwFH7SHdQciEqlMu5iFjU+0K/CiRO3s18EKwTSjkBZoOQYjiBdLKlpkZTXOu1CTL - Jo3anlhbCdEsgwunbNJGwqMNlZtbGZxxyVNX2jhKn+EgYRA4QjRiUppkelRDV9Pi0bIlv/t2g06jz7lJ - XwzWWvIol2LuUlHYVyVxaMmNnYh6M5bj45/4SQiVgqmKtKFKqero6TRmJo1EiDgIiP0QGUaAlMJQSTg+ - jiZ+IFQhpJVOoRimDKOYsD+USRCgqCq6qhHGiug2PNyoT3bEZ27Oot1KWF1zxUYtkq6mRbPT+XaxZK6N - ThYffe4X/699+JufNtb/ZAKo75dG+568tNXQytu1CIZVdDlA6CopfHJhg7xySKXgkikIGkOV7U6eo6CM - qgdUUjXG7CP8vsu+l0VRFHIpSNnHR/3j8R9EUhAlEhlFzOU9Xpj1OFuKGM1rqHbCyLTgZFpCHLNxGPLt - +wqtSEcYCigKISrtQcje/W0O3/iYr/7db2DmYp79iZNMzI8wMTfBpckRSiMvUR6Z4mvfeouDehNRyGFq - CqQ0WkGOt+908b0Wv/arp5gZTbNyf5ZySeHzLxUpTp/g7Q8P+Ft/92Oenq/x6ouL/OJff4nn2mnefPeA - N77/Phsbe4QyorPnstUeYpdg+pxObsTBbUTU92M+/k4VRUDlSgV71GYkSDO143AYSFyGEMRMlSa4emoO - W8nTHLrkc3PY41uYGy2+/U4XJ2vy4lM2fqAhjZCBLrhfk+gfhCxsH1A+C5+5uIh6cYYASe3xEX7tCHbg - x5NWIhAZgTFtUi4WmVLAWd1m46BP1rE49/w8YS4ixR7lpInajnE0GyEkXhAjVB1d1ZFBwPLmLjcb0Bp6 - AscGJ3V8QYMiiWNBv4cpVXFq6iTX5hUWiisk/ZrcWvGT5ccohWmLE+cydAeuXN9RGWDx9PyQF0/1iOqh - 2D8StBpSko7AAt9TWV7rM2g3xUw2lPkJiakh1pZijvZcnnfbibAVjpoBUZygqByrNFGFreoUDVVmLBXV - MqWWyaCnHJFIIIohiWUcJ1JoKoZpyARB5IdEXiBMx8TIZ5NEUUU0dIkGA5mEIaquYzop0elL2ex0INUn - U4wwDVN0Oz5bO67s9EJFGE6zMjV6Z3Ist/QP/s7X2l/61b/yp673/3Gp739wj8PDzum1uvn5t9Zyl7cO - hgWtswzxEKFppNUeY2KNBeMxF+Z9MnmNx4cFPthcZKMxxWiqyaWRLS6Uj0iSmG6oUchbBInOYVvFj47T - ZBQBvUGAH0RcWMzys6+W+bnX8+ztJ/zuNzv8k7dqYCd84fUKxYxGowPLVZXuMMGPYiQKjq2RMoZYg232 - d9f5+lqTN3aHvHe7ysHyLv2ddYLGJmevnOPGq6/g9mNqBw32Dg4IwxjD0NAdhY6nsFeH2OuQS9ucOXeN - vWWLx++4LE6muXLe4sS8Rn+vQXNzl0q2zpnzk1x/7mkqhTIZJSQvN3lp0eXGIriRoHBqlhNPLTJseGw9 - OGTl0SFtb4iVHfD0WckzNxY4/ewX8AONo50qURwyiGOOhj6hL1HQUDWHk2MDRrJHfO9Wjw+WPPZbKhPj - ac4tZqhkNdQkZHN/wPfue+xu+5xKEk5MTDC6OEvfDvDUAEUmKKpAMwV6XkFMOjjjOc5oKc42AirbDar7 - IUs12NiNGLVcvngxIJuEVBsae4MsbVchZwtuLKTI5TK0OF7RbQuberOFFwSgqIJPRFuAYBiRVzReOl1J - PrNwwOnsO2JY3+DxwyE37wjGZw3OnDd4+EiK9x+aohnYvHKpw7XpOuubIZsH0OrHtJqRbFQDug0fjVBk - UvFxRHwLtuuCyowjb3x2UV7/wpdEaCyKpYehsr85EN7QR3cQlq7LnG5QthWZcmz0XI7USBk95ZAEIYnv - S6KQJEmE0HSh2zaJlCLyA2QQoKdTmKUSURjjd3pE3b5IkgRVN7HtFF4QU+/VRWG0I0bHYxEFlrh/3+eD - j7oMuigZx9y9cHn+O+euL3xUGi1Wn3v9r3/aOP+TCeDX//JfFU6yfF0mwc8dtsz5WrVnNnY2GMYC3dLJ - JXvMaBucyR9wciYh1Ex+uDzGrb152mGJyfQuJ3PbTKW6eMOEJEm4MBuTcUIa/Zi9pqDVV7ANCLw+yIhL - Vy5w48o1ZorzvH+7x7duH7KTQHHyFIsnnkYOJCMplVdfmGN8tMRgqNHv9Qj9ASL2SIIWjV6f5bZOVzi4 - usVqI+HOSp/HHzYID4+YzPi8+hMvUxyrcO/mI3B7ZHQfw9BQTQcPm3tLA45aPc4uhpy7cYHizFne/cbH - PHrvQ/Rwl/lJH8eI+f43G3zttx7w8Rsfcnqyz0+8POTlqw1a9YAf3VbYHKaYuzLGM89maW1ssPzxOpub - XSYvwfwNyf1bO3TXqzw9lvD8s6eZO3ea9c06ja0q7UYbLw5wsQiSESbHdeYmQoqyTr8z4IMV2K8rKIng - wjQsjETk7QDbBlMEyHab9NGAyYFktjjC3GKJymkDe0zHKFtkK1nG9ByLHYMLGy3i+w0+XI7oFwsoEwUO - 6z7tvQ7u0QDppHEmyxSmM4yWNKbzGhMZDdXOEWSnqFuj7LmCvd19fD8A0ziOgI5jQRCg2kVmJsbl5+cR - l3L3UAZvsHqvzeNHmmh7ujx1SqNSEuKr31FZPzJ5/jmVZ6b7xLW++MabiI0DRDotUSIEwfHMqOdBrQ8d - H2GYiIUZTVx75ToXXv95Kud+RTabjli584CDrZr0XE+ajkLRNhixDGxNwUincUZGsAs5oWiaCIeuTAL/ - eDIlBUI3UAyDOAiRvq9ouo6Ry6Kk08RDl6jXIwnCRAqFRNFFEGj0hh6+aLF4OpTj4wnrK6587+OBeLQR - i3TGVMcqzsrMwtjv/uxf+OKjXqfv/ZM/+PjTxvm/ggB+/a+US4Pf/UxFffjzL0zdyS2Wa2JvOEm9mSNs - dCmzzOnCJhemuoyPJtQ9h+88mmOpM0GoqRTDZWaNbU5NBVQqJuVSimJKkrgug1af7apCY6Dh2IIg8Elk - wuT4CGMZB3Xg8+GDXW5vHeEiGB1NMT2hE/k9NrcavPvhDicm8/zcF86QzeVpD2LWd45otT0GgUosdBxd - w9ZVNNvG0232AsGjtRo7j3Y4NeJzcr7AzPmLpIwIO+lwcjpDFEt2qh6hsKnX4dYHVbJWj2eedbj2E69g - js7y8FGdTidiryl5bz3idiNguTNgu36ACA+Zz/rcuyu5u6YxejbPUy/kWZiU3PvWCo/e20OzJCcva8ye - MRlEaTa3ujy485gzJ9O8/Ow8lfwMnquwsXNIO3Bph5J+oOPHJpat89zlFqVUn7UnHqu7LgediHTKJJ81 - Gc0bVMwIW5W0Yo2Dpkt7v07uqE6l2WZ84DMfB8y7EaO7ESMrPfIbbbT+kKobsxEJzMkKly6O8EsvaMRB - yFff89lP8mSKJhdHO2QSDzXUmBjNoGfLNEWJrSDFdiekVq/LMIpBN47NG10fpdXjzMQ4n71cEa9NbTCh - 3qW+u853vx6JR0sKi1cNTs1L4kHId++Y1FyDqYrA6xls7dscDQTlYszihKBQKTK+UOb85RTFMmgiwrFU - LAvMlJC5QpZiqSjKo3ma++s8+fim3N6qy4EXkckYTKQNxlM6mqZh5vNkxisYjo2MY+KhS+KHJIkUUtMQ - hi5RFBm7LsSRdPJZ9GwWiRBhq61EvT4SgWYYCEWn2YpEZ9hGSzU4fUYjl7PkrdshHz8OxE4nCccnSoez - 06X34lh+/ed/7Yv1rZVd+du/98GnjfM/mQB+4889/XRr79Yzfm/nhaliVz8/PeDqbB/TMWh5AnP4mPn8 - DlfOeNiOZLWe41urp9nvZMgZTZ6f3uDaTJNsStBpq1SPVHqBIJEC21TwsBjGOv0A/Ah0XUNTDcpZnbkJ - g41qjaXdJn5k4IcC13WZGoFQRHz9wzofLzWoH/W4Nl/h8uIEhpPlsB2wXRugqhrHmWwaxieGD1JXaYeC - 7fqQlTvrpKKAz700h2VnQdEZz3Qh6THwQ1wvYuApNH2LzeUGByuHLMwanDozzvjiBRApBp0hGX3A518/ - zU/93It0ohytvkSVERubCcNQY/FSlrOnDDLJkHe+dsDaKlQuzqNmpzg4SPFkqcPuXpeBG+M4BUZLRa5d - qVAaydHvqzS2qww6HdKjOVK5aXLpCebGE+YrkrlCwtp+wMYRlCsZwtjgoA7rjYi2VHCKNk7awbJ0dNWn - 3XJZXXO5c9dlfSmAVkDZCSmPRQx18HWFYkHl6pxgNh2wtevy9uOQj7YE1Z5kbWfIB/e67NUD8gWVy2dT - mOkKa7UJGpFNJwqotrsEUoKqCpLo+J5BceRzJyb5/FzMrPZNkXRuid3tId9/X9IKVF77gi10RYg7d4V4 - tJ8ijKCkBWJi+gzXXn6aP/PL00xVYGO5RW50gtlTU4yMpySGg+qkOXWqLFKmxsGOJzTVoTQ2LSfmr8lO - rSWe3Lwptrab+EFMJWcxntIoOMcvBbtcIlWpHC+heT7S94SMIhKkVE0DoakyjhIZu55QhBB2pYxqm0Su - h9/qyNj1EKouLMcRmm6Iar2Hm7RlYWwoR8oqgw7iR+91xcqarwah8GdmR29dvDL/Aztl3b324gV348kO - v/P7H37aOP8TSwt6O9eH7frMoL+ubJGnMim4MK2TcTwuFfq8+70NUvQwNEm1Y7Bay9JyC8jQpyy3uTLW - 4+xsho4scbDXZm+zTi4tWFjIMLNQ4pol6MmQd+75kKgYtsbaRp2ZEZUvvWLw8os6sbT44E6AbXZYKPiM - OA7j6YSfeV5le89F9rfo7PU5uTDKr7ycZ7GQ44e3PB4fhASeSiZrYikSU01QhYKWtfBchbf3BnS++YCj - dpOzV2Z59mKagy2FTKbE3EKeb7w94N5ylyAY8vhI0vhBh73m93jt2QmuXZpmbixktJzCzhvMnVQxbAi7 - PR4/kjypTqEWYs6NBkxOxjBssr8kWT8csuoZBHGW83YRM3ZZqh2wuhdjWzHzdYsbvYCC8gFfOO+RikP6 - wzRvLcXsbm8xXa7QCE/wrdXrXC4avPATeXrJAV/95hH3lltsmzEjWY2VA0GplOIL53KcGLFoNXz+4IcD - hkOf8ZKOp6sMwpihFUHJIjeVJm/oDLc87jzsQUYhP5pm7ITGa6kuI9kG2zWf9arCUksnmw0ojwxAC3DV - FFF2BlUY6MGRFFEs/ljR3miTd3Kcv3yOl07CGfsRsr8q1x63uPURuL7K5IzGdEnI+/cV8f2bKmRHxNMX - bF6Y68pha5PtO7vMF7LkTI+JEYjEkHa1K7s7kq2tNl3XZfYzU4hywvBOU+7sSzm2q8jzA0sM+zHdVguJ - L1KOIvK2Jg1VIUaRZjqNnskiDJ34WMMPcYIUCBQV1dAlKMSeqyiKkKppJMK0RCIR0XCIjCKkEFIKiGOF - RAqCxMdOu0xOJLjDRKyvJSxvRInrJtpIxgiztnL/zKWF23Ece/nyr3za+P7XE0C3vnZWSbpjKl2l0/CJ - CQnjCDvWmLV6rNltskaEgsJmM8fjaglXaigOeFqGj7ZyJHGPhUmXrO7T1KHfTwhDQTGr4uz6yIFLFEoU - VcXUBd0k4sHKIf/k91uczIc8N1fkhWsjhH4X/2iH9vYQRdE5U9GwIoPtQ5+91hHR1oBSJ82EE/HyqQAb - j/VWTNdTiDQTU1PQP7EZ1zWTgabysDOk9t0Vvuz1efZSnlxKZcS2mTIyjI0ssLnfYXPrPi2vT7ufcG+r - Q+ugw96dVU6ctslPxLj9Id2NTYZHDQ7vdRj2bQaVEcbzNjNjA8ZGd1DdIVtrgpV2SFVTmNNaGOGAqO/S - HsQ0PZWiqWLnChhWlr2tLVLcZyFu8bnz13HDEvce11g2HmPoCuXcGINBgpv3ufFymtGxPH//H25z+0mV - u40+zYGNoUPY6jG52Ge0IPmj2yZbh8fAvzgbcnpWoVxK0x9m6HsOJ8Zg0TJZ69k0/ITHay00H0QQktXA - NHVMS6XoRJwZDzg1FlM9EhxYBkd5m2Ys6QahiKPoOEtcVQCb8UKFL5+pcDX3Iyz3jxh0D1hal7x1V1CZ - M7h8xcCKI3YPpFzrWOLypTzPPpOTFwqq/OY3lsT7N6vsbhY4d0KVs1MOzVgTXTcQ+AGFtCttpcejj7Zk - o5Ew6MUyOxoRB/ti//H3xPKdR2xuNqUQUo4UdEZSGpoCvtBEKpOTZiaNUBRBFEkZhsg4JpEcn14U9ViV - msQYpoGeyRCjEA99GfeHiCSRmq6TaLocDBMxcAMiMZCjIzFzM7ayuRnzeM1jq50o0ra9icncgW2I+6cv - zK2EQfinw/HjX0cAw14za8ehpSsgExd/UKVxOOSoprOxEYPwyWSPAyqf7Njc2UrjGhpmTsdXR/l+LcVS - 85BnDjaZsTymihLFNjC0iM3VGoOGIKOpFHIa/UAQx5JsRqXRGfBPv1Xj+nyZL7wwyxcvLVLd3Obrb21y - ZzvCKai89KyNb2kcBhoruwrRloS4xWg6ZCInuDxpMp5KWKo22fdsBoGNYRoYmsBQBZqj0VdsDlyVP7zZ - Yr/e47VrDrPTPqbdJ5d1mUjFnLQlVibEyKk0g0UOti2O1gY82GhSbGsUC2epPW6yenOPRgBRSZBL95kd - E1QKCeM5SXUj5OObMesHMc6YwsvXVGZzLk+WGiRyCMQIAYWRDNn8CNWtLI27A3p7a5y+PMXnzhXYqebZ - PqwT3b3LM5evcyBG6DfO4808YW5R8ld/LcsffrfEP/vODoNhG0tx0TDZ3XHRDclPPl3h5EjCwVaL8+WE - 2ZxG3beptTUGw5CcNWS6ovEXvpDiYKVNdbXFze2Eqmuy62Vo+waWFfH8xSHPnY4oOyneXZ9gwxphmI+p - +x4NNyBSVej20fyIE4sXeOXciHwmvyZK4QeyXb/P4ZpkeQW22nBxxuTEnMH+rsvGnkKomfLUtMFUAQ5r - AYctGPrg9ro82tDobJrk8kKOl1QxOaYzPjojhFDlvTtHNJoNTCMipbVFf/8+3/ntZbGy0pEHzUCUczrl - jC5zpoKqKFJYtrDyOaE79vGb/BPwR7GUUggUoRwn/kaRkHGClslIPZsRQZTg9waEvaEUAnTLxDBNev1I - 1ttd1PRQ5IoJtmXRbvXl9q4rh14scsVsbWp+/G4uY232u4NBGP6pk/3/ywlAtXLbfk8phf1EpAugKhFu - t8XuFmxtg5OCdO5YsqvEHnbcwQiaSDVLoJiETpp1L8PBZoqzqV2uVWqcz7tIb8BWLSY7UubypSwdU/Bo - 06fZ8shlVBTToOWnWA9S3KpC4b19vKMm7WGKMFegn7PYHHZQDJ9UQePefY1GJ8RUFKLZeSZPneLyjZNo - fpfFhw+4v7bBylGXWugw8I9Xg21DIW0ZGIbJTsujtRTghz1e9mIun4tIpXbpKQrNtkLU8BgbM7h2xiCZ - yLI277C3b0JiUhybQSS7tAZ9DvcDeiImFVbJpHvkixqRp7C3q7G57TOVhvmxhEocULIlp05n+Yn+ND+6 - M2R9q07H8xkELmEr4dFNhUc3FV4tDpk9F3HiTIH+aov64RFr+ScE4SwlZxx/PaZe1Hlhoc2fSaeZHh/l - ez9cxffqIGLuL0viIObCWY8r4wmVKMLSbPYaNqtdk81agDccErsJlxWN+amIRHWphrDVs1nuOVQ9CyeM - mc95fOacz1TJoeUtMCw8g5E/h5nWWW00aDS7REGIoViMZfP89OVpXplrkmn/AX7/vjiqSt7/ALmyJsjk - VHFiXJEpVfDGI5W1wzSOU2AyLVGHHe4t10TsDZgugWHF7LWlWK4jT054FDSkdELyxQWmzl0X80+n5Orj - FR699wO0ZB+R7FBrJNIPkOmcQtY2SCm60ATSsCyh53PSyqZRVJWg1ycOfJI4Od5D0zQUVT0+DYSRlIBi - 20J1HOj0iYauDPxACFVFMRRpKbqIE1cGSZfxkUDYaeRhTcq1tSg53A2EI6XImcrOxOzoe9Pzo7Vnv/Cf - ftq4/jcu9Tf+2i/H7e1V2+27p20ttgwlUXwP1nfh4Agq5WNhmaoqjJYVZscizKRPvxfR6GoYaoJlGYT2 - CIfRCJvdDO1GQOIHlHIxszMW5YqFqurU25K9WoymaWiGhqKraJrEG7TY39zgqNPEHklz/epJFmfH6PQS - smbMaDZi5zCkPwyZKaf5+V/4RX7mL/1vGH/tV8hdeJnyzByjqYiCaKGGHXwvZOCrBJ84rtuaimnp+InG - yn5MvRrgyJhLVx3GTths9SW/917CP/x6wOP3WvT29yjaVcr5mGxaIY5dSmMx46csmn1J5HuMZvqcXgyp - jMQc7ifUDmM0JebiPGSVgPfeabG80UMYKV5/+RnOLZ5EiCz5goUaHUFjhZ29Lba7HaZnbDJZh17s0Bok - VHsBhwOfo+EQQUQmN4eiTbJ10CaXjXnmcpq5kQp5w2HQ7nPU9tlrB9x60ufeE5edmsKBmyIwbSbGFWrt - AUvbHloqi2laBD2f1T2fR3WF7SBHX1pk9JhL5S7PTg44WdDoJ+fY117DPP8S2alxYt/l8eo2Wxv7Urox - iycW+dzzF8SrYwdMuG+I1t53ZHOnKdaX4JsfCepS58IVW7x8HvAk/+wHhtgcVsT4iYq4NhsjhkfiyfKB - gADNUFnfR5iKynOnTU5PacKULtWtmnRDBzO/yMiJr8jK1GkqxSYTozXmZltceQoKZQgGKkZgSyvWcEyw - 81lSlYqwi8epQkG3h/R95HHIjFBNQ2iWgYwiSZJI1TDQ8zkhTJOw3ZVRr08SRUhFk1LoMg5VpTPok2gt - Tp+PyKQFq6vwzkcDZW0noJQ3o0rRfu/iU6d+74XXr+/+l//tdz5dr+//IQTw53/plY1aw3eFWTTi3jDj - tYP0cJCo2/uIZgcmR8AyFYaBxdRMnitnLa5OdckrLbqNPs2+jhdqpIwIodv0RJGV3iiNwMZUfHS/TVr2 - mCjroOm0fI32EIII0paGIiWDfki1HXJ/L+beTogR9ZnKKpyaWWB+ooJlKDTbDYgE4+Nnef3nf4H5V17h - PV9h3U4jZmcp5Ccp6zpZf4fJYkJlxGHgSXpujB8nmBpYhkqgqOw3YWUjJq7DVF7jxdcyoCis7MTcrQlu - b0iePIk42unid7uoqsBOZ1DVNMP9OrbbZcyBYkEBXdBoJ5i6pFQSHHTg5p7gwyOdmwcGt9fAjppcOVPi - Kz//KqV0zNHGPRq7N0mCA8ZHJPOjfYSUHLYr7HRUarGAlIMbxbS6PSrFDGYqx6MDm+XdgEa9xekpg0sL - BYrZCr2hxVZNst0R7PRNNgcOS9WY7ZpL1PdJvARNNemEKQxTZWE8Jooiqm3B7pFGKvS5Wujy8oLH2SkH - oc+xbT4td/PXyIyP0PCHvLu0LVaXtwndSEwvnBY/9dw8f+a8j7X3j2hvfAu36/PktuS9D4S42VAZOWHz - hZdSzGUCtjZjfv9mTirFUa5fyTFut0XrsMr6Totc2WZytkjGtsmqEiNyhaYJ+i5iZcPn/u197n34kNqe - L9x2VehyQ7G0felYHZnKIfoDQaOqwcBSDKnjpFRSlRKpSkWotknsByLqD0iiiASEFIoUhi5VVSMJA6Fq - irDzORTHIQxi6dcbJJ4nNU0ThmMSJaqoN3zRC9qkSn0uXtCEiBPx/vtdPl5xlXqo+QsLo9tjY7nvterd - b19+5uzwv/77b3zauP43J4D//re/z0999uyeKqK3yU741Y6ZWn3cy9abiW7oUh0rgWbo9Hwbf6gQdAPU - 0OPMZMjz53y0oE274dHo2SAFKUeiOxZNWeZefZzHyyFea8DVOcHpKUEpKzk47FJrBqCaSKEiVJVEaGhO - GsXO8Ginw72VGl67zXRZcn7RIJvpYuoCSYXx02cIJyb4wNOpBQlm5DOWThN7IStLa0wUh7x4zeHqhUUc - J8fmbpd2zyWRETlHQ7FMWqHByrJLvx5wdlLj1AmdiUmd9S3JYdeiauR4VE/YaIKuGYyM6IyUYtROA9oe - fkcQSQWpKTjp4/2IrQP4zu2EduDws6/P8tyzFyiUZ/jhDzfY2drk5HSb0YqCpimsP9mnWveQZorx0SKW - WqZzlGYvNDnUTBJx7E8forB2UGP9oIbhWHhqic1uiXtPehwd9pgpqlw9m+WFp8e5fnGCmREHM3GRkcfA - j9lvGTT7Bq6v0ur61Gp9tjYG1A9jVC9hzPS5UPS5WILxjI3InaE28UWeGNMsD312Wx1xd2lT3L6/KqNA - 5+y5U/y1X3iKl3Kr8OA3ae3fpn7QY/+J5KNHKh/v67SFwfUzBj/1tEK36sn3b6vc3a2I6amcuHFGCDNu - y267RW/oilIhw9TkGLNzE/ixyu0nbfnxmi+W9kN6oUZ3iKgduKw+uCtW7r7DxvIKT+53+OB9Kb72R/D+ - +yqdhiHH0wZjRR3NtnAqFWmVylLGsYiHHvFxxJxMEKAqKKomQCD9QGimiTVSElLVRDgYiqDV5hPZb2Jb - logixEGtQ2I0KI0PxMSYI49qqnznfZfNvVCVito6fXry3bPnZ95WdX3ll//a3/1Uk37+BxMAwE999pzU - ROQLTb/naeM31fLs0HWHqXDQLamREKpmCaeQEY4hcNseTx706LQCSlnJ8+djLs25xMMmzWZCvWmgqBLT - BM0yaWiTbPujrG37qMM254tdLsxajJSyVHsG9Y6H63lYto1lGugq2E4KX5o83ulx59E+21sHXFzQuTjt - kBIqA8vhsYy4p9cY0SXPaVkmCwG7zcf8wdvf5fHjDcK2xzPnczx3cYLF6VmCUHBw1KXVGSCEJJ0yaIcq - +0cJuysui3M6N65bDNyQZkvSOFLRnTS6ZdKu9vAPqnh7VQ72XBoDgSsUnKJKrqSQSUHtKOTRk5gozPLc - Szf463/jl/nCVya4OHnIxsYOewchzbpFa7VG3GyTG6sg8lkCI2Z83iSfFqiNAYmWItbS9LcPCXsDFNNE - 6cdETZ9uq08qrTO3MMro1CJ9dYwPN0JWtzrE/T5nJkyunRDcOO3z/JWYZy8EXF4YcHp2wOl5l6fPuVw4 - ETJWTCgoknICcxqcKFhUpidx5z/HUu5Z3h2myE5Ocmp+ks3DllhdryJcIX7yiy/xK6/Nc6r2DQZ3v8rW - 45tE/YGo7iLe/kDwcc2ibjtiYlznlUuCG/Mxt+4lvHEnzV4wydyYwcXxHobSEYY1EIViKIOhEN2mIlLW - sXeElhGcmrXFxRNZTkzmhK4KBr4vAiLZc0NZrcZyd1+KrX3E7hE4isXJcoqxlMCxdZRMTlqlCrqdIugP - RDQcQhwTJ4mQiip001QURSWJE5HECartSKNYJIliwm6PeDAgiRMSRUMRhvD9iOagGRcnXDkzLwl9hQf3 - Pd79oCc9V2rFjHq4eHLiay9//qkPNU1rfe279/7U6v7/RAL4gzcf85XPnkRRlMhPLTRA3i6NOG9Z6cy9 - nm/mzJReHq/EetZOBFFMv+vT6cbUGyG9VkQ5FfPqNclsuUfkdTisCjp9A80+PpJJ3WFzOMrjPcHObo9p - x+OFC2O8/Mrz6FaWveqAZrOJ73tYloGmCDQVdEul7eus1xTWtz06tQEFbYChtunIJ6yJH3Cv9iZvrXyT - 9xv/jIc736W5sk53V+do1+aoWqe6e4h0PV55epqXnlnAC3SaLZdWq0NimAww2GrEKEnIaFrjqWuzqHqK - j+70cH2FQGiEiSBrRxRSPgECbIN0xaI4rlAoKTiORbsmqW4mqPooJ86e5Moz8wzW7/PR177L2z/soKaK - XHthjqjfZ+3hPo8e18lnutw459HfbNNYOSJvt3j6pUtce/mz1LVFRHqas5M5Pn9B4/WLCScnQ1RN0u4d - G6dK06CfLqBNXmDoLPL+owEP11x812K8UGC+bDHp9JnLByyWJAsVyXwBptMao6kcxdI0ztwF2Zi8wd3M - dXFTjDHIVbh07iR+lIiP762LBzc3mJ6c4df+4pf53HiN/JPfY/m7Xxfd/TVhqIFYX0LeeqLw0DU58C1S - jskr11SePx2TliHf/cjhna0KYmyUqWKTMW1FGHpP5rMwnrfo9E2qbR1UVShCClNVkDEyDgMMORCaGgpV - E/heIhQpyaURig6KLihkdLFYsTlZtoVGgtQtrHJFsQoFVF0j6g+E9D2EkCRSCqGqQncciRBSxonUTAM9 - nUbYDlFvQNhqyySKjp2nFE1xh9DrD/FpiIWTkZif05TNjUS8d9dX7m4HMpNP+bNT+Ucpx/idp1+6/BhB - /Nt/ikU/fyIBAHztzVV+73vLfPHVS4k/GLj/0f/tq0eN9pOtTHlk0w89UT8anI/7fc0MB6T0BM2QDCPY - O4w5PIjwBiGLkwnPno8ZTfXwhy6bBwIv1lEtHdtS8IwS2+EE9zdDqvsNxqjy3IVxblw/hxspHLV6NBsN - FE3Dsi1UcbzbnSgKB22VjSOF3XoMnTbp7j56d5dmb4uVwRrt2gbRcgPzkaC169AKTEbHVDzpsbRbY3O3 - gRZH/OQLEzx1oUwuYxB3XLx2nzCKeLLnslkVPHN1moWZUUwjRafR4qhaww8Cql2fg77ByYULPP/iNS49 - t0D7aMjqwx6JPo2mj1PMFTl9vsDoqMvR+i0+/v07PPrBEeWCyuxkSEo9YmIUsqNZNnom76/6fOPdDm/f - jri/GrFVDTENlTNTKp9/qciLo/tMrX2DU7Xvc9Wu8dqzF6iMneCgq/Ph3XU+Wt7mIIxI5zJMTExQnD0J - Y6fZUWe4Wyvy4HCCaniFncE51hrzrB6eYK11iu34Mge559gfe5qtkQsimTkvJk6dY2rhBGg6H91f5Z3b - 23Q9hZ//2Vf5cy+XON9/i+p3/qlY+9EPhKEcSd+NWNuAj7dV8XhgiaaRYhioFFIJP/WSYKEcsLsV8Obj - ith0J8XUrMWkU6MQ75ErQjqtI2ONdsdi6DtYloFjK5hqJHd3mnQ7PUYrhhCmJYVlyrNnFE7PKWRNRXrB - sRZpJGMxnbcYSWnEErBTpMfGMFOOVJKYxBuSfLJIJgGhqaimCXEMcYKVzwk9mxFJIglabcJuVwBSN000 - VZfNpkez30LPtJk/oVLMW9y544qP7w/EXicOK2PF9fNnp95NZ+y3TpyZaZw8O8Xf/q++/Wlj+t+OAH5c - 3/rex/yvfv0V2t0H8nM//Z+5l58f33t47/FatxNtVw/DbLstpyxC0rbEcmAYQLufUG/GDHsRjhpx5WTC - +VmPotWj2Q7Yr0OimOiWgW5btLURtvo2y5t14tYeM06Xl24sMDc3Qz80qTc7tNsddF1H1xR0VTn24VdM - moFOrZ3Qq/uUmyHzfsIJL8F6KOnd1jjcSNHsGfgoKJqCaRmk0wYPNnrcfFyn125R0odcGIsYN5ucnUx4 - 5uo4enaWvXaBBw8PkOEhrz3n89T5gBduFHj99bOcPD1JsZBhJKeRc4Y4ZovQGxLGKUJlkvxohcWLBQpl - A5Ek9JoJjarADzUKxZB+e8i9my5d12Nkrshnvvwi+fFTrOzZLO96bHRc9prgttro7RXG7LuoWx/S+Gid - SJ1n27jMH2yn+daDJnfXd9nsD+kkkr7n0ajWOag1CUyToaLRCqARGQSZcbInr2HOXEIZPUdYPkUzPcuB - NU5h/iyV+ZMMrAxKOovupGkOQtZqLmttyTOX5/iLr05wXb1PcvuPWPnmN+Tw8IlQRZ9eT4qlPbi5r7EZ - p2jrKRLFwNYSTo7F4kvPKqhhyFsfxtyszeHZo/Lk+IApu0rRajM6biLR2duTIkpSZDJpaRg6mq4ISSyO - 9tscVQc0egntbiAdM+D5a4LJCjTriag2YukHKuNZmxFHw9EFiWZg5Itkx8bRFIV4OCQJApLkE8svVUXV - dYSiyiROEAJhFouoli2jwVAEnbaIBi4oqjB0Q2qKJmvNLsO4TXliKIpFRQ57inz3vR4rq54iIsKJscKH - N54/+8boRPnJz/76/9v9hS9d4zd/+0efNqb/xxEAwD/+/Q/5e7/5Pf7sz09Rrx6GX/y5v1nb3N9+vLvV - XA+l1vQwR/yQHH4gDA0MA2IJ3X5CuxVBHDGaj7iyGDJbdLGEx+FRRLcPQujYaZvEznIYFlirBezt1clE - TU6Nmly/OI+TztHzJNWjBq7no+sapq5iGAqoCv1YpeXp9HsKZl9lcqAyHigUhEDTE3Ipn3LaI62HTBbg - 9KSCY4VoYgh+B+F10aI+JEMqIzbnzk/z3As3uHDpCkd1E7ffpuDscOqMz7XrDqcXpjg5mmfKAfdwj/ru - Fu1WkyARGJaO4rdJGR0c26d1KGkdHXsZqhkVNSvotDpoZob5K+dIVUYJA4XkqMmoE/LM9RTXr3U5vzBg - MpMwovrQ6rJ3q0p9Tycsv8hy/go/6KX5zp0dnhy2aCkqkW2DZSAlDLyAardPtdZgd7/KYaNJV8DA1Gkl - ktjQMfNZlGwGchmSdIqBlGwdNXm4ssuTvTYbXYmZznJmMsVrsxHPmusUN74vD978BtV7HxO4deIkEvU+ - 3N0RPGiZYpeUCE1bJOiErmCmnHDjdMK1uYj93Zg/es9iLVqQei7LjLXLdPZITFVCMTVu0e8p3H+YMDJW - lPPzWRq1PgiDbGkE3/NFvzek2w2kEobk9ZCUmtBqxGztxbT6AlPV5WzREVlDkEiJnsmQGhkhXS4iw0gE - vT5JHB/380mCappohok8NkkWim4ILZsjQRC22kSDAUkcSxSNJNGE78UctZtCc7ri9DmBqqosr0l+dGtA - vSMZKzvuSDn1nZc+99S3puYXG7/5j96I/30DP/wJ6cA/rnOX/jIAb74lk9WbHzb+1j9574/+n//F/+LB - xr3Hd3t944umr79ohL2ypYXqSBaGIQy9hMerHs1OxIm5iOuTIQsjPmfH+/xwucv9wxGGbg49nSJTqtAb - pnm/W2PznQ2e3V7lMxdbfP7MJOdnzvPm3SK3l3Y5qDawTZWUbWAZOpqqEUQqu6FKoxqy1fBZHPVZnJY8 - f9VgEOrsVGFre0DSd9ETi4vTMJ23WNsKeXyQcHMrJIw1ZqZ0XiiEzBlbzNhDfubFGapVwd7OkFShwaB/ - xMHjR1T3DQ5qLhs7NfzQJ5dTgBhN6VPMuvRbgu1li92DDBKNmZmAUBUcNWNqOx4z02nOny2RHx+j24lZ - vbVF+/CA0YrP6Uqb0yclnZTkaA0aBzbd6BQt6wqD4hk+3trm8f4eA1WDbOETC/AEguNJAbaBjCWNgXts - dqEItKGPctQCP6RoaJRtC13TUSyH2E7RlhDJhIqTYTGlM5b1OaUsM9k4xDpYorV8R25vrRJHEjTwFdio - CrnaVMVeYDBQbRTTxDI1GEpcP2Z2THD5pEI0HLJxoLPRK+PmcsLSwWu1sEZ9xsctaesStxfTamqk044Y - KWnynd0jcmOnuPrKM1QqOVlICR58uC1tzRe2AitLEa3B8WqwlDrljCFKKQ1DSHwJTiqNlUkjJMgwPJ7j - I0mQJFIiVBWhqeCHUtF19HRaSEUVsesR9PoyCSN5LBDS5GAQ0Wy6wmcoK+WYmXFd7u3HLK96yk4rkqFp - DsZmRzZLpfST68+c2pk8+78O4f/0aWP5f3oC+HG99pn/JW9+528Scgu/3dp69w8//Ls3fvozt4b99lf0 - qPF6Kuydy/S7eduSOFlwY2h1I27fj5gYC5meCvnZawHnp1x+8KjLu6tj7LaLBJ6NlbaRI9PsD0r84d42 - 93a3+OLFFtcvjPPnXzvB2dkyb3y0wcrmHs3OkJRjYVsGKUMjVDT6ieDJAA62InokVMZ0FqYmKRZzVFs1 - 1o4aNAKPk1MmiTS4t6+y2xL4icZwEHOU6IxN+exu38EfhGRH5kmZOg4W7qHJ+mqPhz/apjqwaVspDv1R - gjAk3+wzN6JiO4K1ekSrKxkOEjrdJlk7QpIwNmZRLmSIk1kOe5Kv/v5Dzp/rsjg/yeKF01S3Wyw93CT8 - qI2uKZgWNPfADx1mXr3BYOoSm32NUHXIpSvYoxP4ukkQRoRJRJJ8EmcNoKhgZsBWP4lfixFxgqFphGFM - M/Sw1RA7lDiqwqlCiomcyWnbZyKuk2pvMly6TX3zCfW9tgTQHIh1OOwJVmoK265OG1NK0zz22VMVBApC - JKSsmIUJmBuT7K9ErFSz9J1xjLSJJfoEnS6OEVMecdjf9Dg8hEzOxNB8Wo2A9a2WmLV6FPIBc2Vb6r2M - 3L4riCIIEkR3CM0+DAMh87Ym8qaOpQqpCogUAzObRbNsIs8nDnyJPAa+RCBUDSkUkoRji3nTRM+kiWVC - NBgSuS4yjoVqGNLQFNEOPNnq9aRe9CiUpVQUTdZrPhsbffx+pFhZpz46WflwarK4Ua91wsmz/37Ifv+t - CQDgtc//H/74e1d+n//9L/8nt669/vTDVr1zt72x8aWjjbUXc0l/qpAOUjkbIufYMm57P6B6FDE7HTE/ - G/Prr8VcmBry1qMmH2+N0mnlwLZJ2SahdYq14QS/eesRH62s8OWnajxzepHzv3CFb35Q4IMH2+zXGoRR - TMo20VSFXEohsk26Q5V3t302jiJevBhx4XSKC1cvEK81uPN4A1+JyaUEoaagOwKZKEQyJJKw34mZny4T - OT7//ZuPmEx5/Pxg35E9AABheElEQVTTOgfbknYvgRK8/IUSC9fOsVE9w8OHQ/bXH/DZ12xOzEp+96v3 - efzugOVaCstWKCkByuGQ2fMpXn11gjB1ku++3+S3/uEHfOeDfRYzBs/cmGZ2dorx+SkauwmNw5harYVU - YnJTPrmRJ4yPa4xbszxz8RTtwKLlCpoDSXMQ0R34DN2AMIxI4uSThCUFoapouoZtG2Qcg4KjU3Q0Cibk - VJ8CfXJxF6t3QFLbobvxiIPtTdr1NkIFzQYjB/0AsdMVbDQVue9ptBVTxKYlNV3HVI57x0RKBq5EFQkn - JhIWRhNsYh6sqTw5yiOKY1JXEwy/QUpzKWSFsExD3H0wTPYOQ85eUknCPbGylAg31pBRVQb734GRiEyh - LWZPCdbWFLYOEoSABKRlCIqOIXOWThxFQhiatNMp7EwGTdfxu10Z+wGJlIRBhFBVDNsABHH0STSVriF0 - nbjXl5E7RMaxSCSIBJJIJFEUETFgvBzIfE6yfwiPN6TcqSbSEapaNJRasZB5//SlxZ0rr/wN4G982jj+ - n58A/sWyxasA/BczI75Q1a/O3rj+0XDxxBc3P/zwy63G3nOzI3Ehn0m0tCWxDOgPE5bXXWpHAdOTHi8s - OlycC3n7YYc3H45y/6CCF6TRLYOUbeFPPcPH3RpL37nDi4/e57PXRvjzrz7FC1fn+L0fLPFgaZN2p0sm - ncI0DHRFoZQ1cT2NrY7Pzg+2WVw64Fd/4jRfebrChRNX6HTqdDt1zkwMWTkI2azHpNMGfgQf3etSyRe5 - sJhh8FQBXXoMNfjRx0O2DmMWT+qcNHwWJ3s89UKJ556q8NH3WxRKE5gZi1/4aR/TXOEffH1Anwz1KMth - VWfw7SGtzgZ/4a+G/PwXVYJujj96Q+O9VZ97b2wxbm0xm1eZHzcp5hIyeciVoVDpkwreJl//iGKljFOY - QhTGcKMMXpLCjS36no4X6ASJjhTHt9wyAhkliCRCU8BUEywRQr9PWG0Qdvfxuzv0OgfsN0OGfUgSpKYh - UiPgx8h6X7BXE2K3r1ALNYaaSWKaqJouHVURmvJJotsnv6/XixkrJlw/J5guhfRaIY+3LHb6JdT5Mm6t - JpKozdxJKYtFVbY7sL4bE/k+c8VAtOqS2rbJ1NiUXFiYozAyKvPjgVBTdTp9jb1ajb2lnkzlwUkrWKoh - So5BwVFlEAZSaIZ0sjl00xJISPyAOIw5DvA9lp2rpon4JDlKsSyEbhDFiYyGLonnfRIrB1Ekcd1Q9FxX - qrbL1LROKS/kvfsejzZcUXNFMjeedSdG0zuGIW79zF/8Tw/5tb/zaWP43z0B/Lj+j3/z6wD8t3/7r+yi - aP/dwms/+WFz4/Hntpbv/Uo37J6aLYZ2JS1FPiVpD2Dgxqyse1SPQuZmLL5yI8XVE/u89bDDH9yusN0s - ITIZHCtByRUZZD7HN+tr3P7GE76w8i1eurHA//lXnuLNezN8850lVtc3cT2PbCaNkghsXcGupOi6Jo9b - Hv+X37zL8+dK/NLnT/LqxTLNrsW3315maTsgCHRsUxDHCdWWx/3lNpViiq+86rC/HvPGd1u0agFpFeJO - wu132rS3blMqPyIehnQPYoK5r5BOv8Sl575IpKY42HyLt+4NOBio2FmbpbbC0ZsD4niVL3xG589+LsOg - a3B4pNGLdDbVhCM/4P6KT0pGlDQoWQrltKRUgHzeJ5ffI1vYJ5UTWCmwUwLDgqICQhOohooQKjJR8IOE - yI0IegmtfUm9Du4QAg+iWCJUiaoffzCPt3mHPUS9LTjsQM1VaMUaA0WXgWoK6ejoqoKlCFQhhOA40z2R - x6vdQlUQSUA5HXPllIqlStY3YN8r0NdKOLolYtcjbQ64fE4TUSL44LYrNSVmpgJlAY0OtOuIwAZ77Bql - K78qCqWc7K3cp9r7HTr9dxCyD0JKRVFI6YZMGZq0dIUgVlBtBzuXQyiKTPwAGSXHF3/I4yRnQ0NVNWQc - o6gqRjYLpnVsADpwReKHCEWVqiqI/UTUmi69oIdTGspS3hS6oomdvUju1RPhKYqXrRSezC6M3GnUuwfH - O9H/ftf/KAL4F0qSqoRG2n44cfr0zvTpxfcev/vez3+8t/OrM5lBcSIfqhN5Sd+BZl/SGUQ8eDJgd9/j - 5GKKP/tCxLVFl2/dbfNH98p0hmU0xyHnxMSjJ6h5k/zW2hM+2t3k9ftrvPiZ6zz3l5/n6x/M88OPnrCx - voll2zi2jYhj0mqCkVbp6Xk+2PTZ+q1b/OQVncuzBicrGrujNhu1kE4nOQ4pkTr3VgPqbZ/VpYB8EjBm - BFw4KyiNKViTAhSb1pHJm9/0qO/55HTJxegBEycknfYooyOS11+UHLVcuisQ9nSURKcdWvz970RsNmP+ - 0s/6fPaGiWkq/JNvDmj0dPRMmtBM0YgiGkmEHsQYjQizFmFFEY5MyBqSQlpSLkmyGUilj7c0TRt0I0TT - j1fbAeJA4g/A7YI3hCA8viaIEhh6yL4LXVfQ9RDdUKGPyhAVT2hEqok0DDRVCPtYNXsc3YQkSRIpPvH+ - FEKIIJSEUSRTps9UMWGmqFLfieRHSzpdoyKkkScOIzmR91nIRBiRFFtrASubUpyeiDk5DkEk6XjIvh8m - /WFdtA62ROdom2zuDCgZ6YcpSAzM46dUGKpKwTakrgrCRKJohjBSaYxMRiZRROJ5SHl86x9LhG7oUtU0 - EqRMEilUXUF1bKSiEg6GIvY8GYehVDQdTVEJZUxv2CexXFEcVUkUPTmsJXJjs8ewGWo5ND+Xdu6evDB/ - fzDw/73Y9//X1f8kBPAb/9v/hr/9N/8yMjaiX/pr/3Hr7u13Puo0exsNJ/O9w/rRr7ebnc+P9Rp2MRsp - 0yVoDqA7lDS7Ebfu9igXPRYXHP7SKxEvnHH5Zx/0eH+9RHNYwk4LHEfBn7jA4/4E20ub3N2/w8tnl/nF - l57muTMv8K2PF3j7g9scVo/IZDJYho6h6ZQMgRvqHHo6//hHPe4tB7x6Y4SnTqqUcx6e2ydtRYwVoe0q - 1LuCwAOrEDK7oLGhnmQzc4Hi7AIFo05uaoWXZ7vsLLW587DFVm8D9eNNVj7UUUMVzSjzG7/i8BvZhJ39 - No1uQK2hsrRssrvt8ff+mz5f+rzNS+cKtBsJ795rsV2to5lpbNtCMzQEx3n2fixpxzHEIToJ2jBGG0Ro - SYImEwwkGgmakGhC/gvmvMcBFFJAokCMwE0UhrEqQ6mIRDmOWwpRiVUVqWigCISC1BVVqIrC/7e9/46y - 9LruM+FnnzffXDl2VXVOQCNHEmCmRZGyLHnGsi3LHoWxJcvp89iypdGMDQdZsuz5ZGksB1lxlGhKoiST - NDNBEEQGGmh0jlXVVV351o1vfs+ZP26Dlv19mrEtSg2C/ax118Va3es27n3P2eecffb+/RRiZFAtLwND - 14EDs9bGgKBETBhCVhiO7FHccUBTtVNeWUVeXSwRjoyaoBrgmMhIuSpL8Rgf+ULbzFVi2T8OUw3ItZir - 60YuLiOb20httMBzQtFp0xTRFnl/k7S3I2kamgKMo5RUPJexioslWuLc4JSrxq9UcF2XrN8nTxLkpvuM - KYwRcRFlgTFKbGXEcYxWlugsR0eRMcVAGLQotInzgjDMyQlleKQwc3O+6fRsTl9IuHzdAJaaHQuSssup - ex4+dnplcSMTmbjV8/cPjPUH/4gBn/zsK3zsY1/mXe/YT7/VKr7ju/95t5uvXb9yceVFbO98O6+M9Ptm - qIhib7gC1fJAI7CfGFo9zc52hm1y9k8V3LMvZn40ZLcZ0Wwp+lGA5wl2KSByRlgOy1xei9m5epEZP+Rd - 98+w98B+xK9zdXGdVqePKPAcB891sC2LVqjoxoqylTM/EnN8T4YkKb1OTrevcXTBVElzcNhQmSzTmjtE - ccd3M3//9/D4ne8gaNzBtjvDyKxgW7tsr26ytmvRihpMVavsrOe88GKT9fUedp5yaEJx14LLg8c93vPO - gMfeOcqhu6dojEGlorjzxH5mpidRBOg8JopCklTQYmHbFq6jcBwLsW2wHXLLIcYlUh495dMRj5Z4NI3H - jvHYMT5b2hu8TEBTSuxQYrPwiZWHcT3JlGt6hU0rUSKOM9ARdCzjWBa2ZcnAr3mQcBP5vU9Xbu6UuGnF - LhKGGssUvP0e4b4DBXac8NyZgBevT6CH94hbKSNoaccuWZrLrHOD2UrMUIDJDKItxHfh+iqsbVtmeKrM - HffMmDtOTKAklOVLF+WVLz3P6soqqcmlHLhM1kpmuu5hdC65WJSHRyk3hnFcV7IwIotjigK5WeiDE/hY - tg0I9sDoU3DcgdpvuyNFOpAGzzIjzXYu252QzNo183szc3i/o1euZ+a5kyGvXU+kVKu0Du0fP10tux/9 - 9u/9pgvtZrf4+V/70q2ev39gvlpHgK/wvnf/NQBu7N7PmWdejFevvH7x6OMf3Ni8tnhaK/9DGY0/3t9c - P9DwI3+iDpUAWn1DL865vKjZbeUsLOS8+5jmyEzKk6cjnjzTZqU5RuFWCGoeRWOGG1Gdj21scumpDR65 - 9mUevH8/3/2eGe46MMVnnjnPydcvEoYJtWqJUrlMrRFQxBGnrrQJipz6nR7H7n0QtVHlY19YZXv7OpOV - No8dLZhbGGFi+i7cPXeSNaZ5Kelhe6M0Zh8BU8fp5swfuox+vYcTK8YmXE48tJ9D8RCffnKbX/nCKuVn - t5ku9dlbt9k7azG7r8b0rE27k7C+1KffuY6Tl3jbXsXRBmzuZKzvFqy2E3YTF+14KKVwhMFdthJs14Y3 - rNAHG9ubq/NNA5ablukiCstSJBn0ezlTjYz79hv2zVTlxq7F507GbO7GdJKCRt0X2xG0HjhgM7hJR2uN - MUbUVz57YOZuRKHFMpZlqLmawzPCcKng/JncLLYqJJUJAq8kWWFJ0k9pJNc5XrrK22YjMQnm6gaibTgw - BydmYaQGroMMjcDEQpf6zCVz+eRpXvniNa5fXCSOIwmqmHrZpeLYWAqTicJyXPxaXWzXJYsTU9y8DSm0 - MUqJ2I6NstRXjOctP8AOSiYvtORxTB7HGGOwLMuYoqAfxqbV71KdzE1tyDJKbDbW+7K62hOdauMH/tLc - /unn61V/rbndzpM4udVz96vCV20H8F/yz3/sF/nxn/xr/PW/91E+81s/k6T93oozdeiyVu61HC+NMimH - 3XC4ZMNIdeA3mGSGnZYmTATXsVmYtjk0k7Iw1kWymG63oNWxQdm45YDcH2I9Dri0kdO8sUIp2+K+fTWO - HpxhdHKKzVbE1k6HLEnwXMFxbXZDw+ZuTqermdszzPHjcxy+6zh2eQ+dfhnP5FSGqgwtzJOV57muS7yW - JYyVytw/PIlyJuhnOWm6yFDeZDjv0IpiMttjYmqChf13UB5f4NxawauXIl493+X8pZQLl2Kunu+ydTEi - XE/Ioh550SHNQ8JeSruZs7nRZ6MV04oKjOWgLAtbGTAawaCUwlYKx7KwRLCQQb+EgCWCbVnYlsKSwYpt - tMGmYN9oyuGJDE9B2XOYHS9R8mziVNPqpSRpgeNYxrIsEVH/KbAYhJsrvxkoaaGNIkwVJd9wcFbz7rs0 - blHwuWdFLvSmpV+fl8KrUyQJtXiVd4+d530LK8yPDwp5LqzA6s4gJ1H2YXEN4gIeuF+zby4x/eYWX/jt - Szz7+UV2Wx1yZUwQOGa2XmK4ZGPQYpSFU65RGx/HsiyyMBKTZQPBD22wXBvHdxGlMCjEtrArFcTzpEhi - k3V6FL0+ujAolFhAs9M3kW6Zub2xGRkWOh1bnnmhz8XLseU5lowNl59/4JEjHzt8x94rD7zn70X/10ee - udVz96vCH1oAAPg3P/MJnnjiCZ5++QovnV/jkbvm2x/8X//euXYrvNbtZZu77Yws1VWKolL1DL4D2EKW - WySZjcajGgh7xjIOTPUYr4ZkcUa7D53w5mAv1Un8Ea7uCFdX2oRbS8zXNfcfHWdubgbbL7Ox3SbsR2hd - YPkl2pnDyi5sb+3g0ebhYxYP3j/P8Tv2UtIpihjjJ2y4LjdUTDdbYtjsUC12uRFtspVtYwiZSHdQzR2e - Opfx1Mku5y/sMNUIOD5XYnZUoYuQ1d0ua0XAta7DlbWC1XVNmBZUhwuqjYJSBYJ6CW9oCFUfR4IhCmPT - 7/YJoz5Zlg5q2ZWNbVkopTAYbrqmA4PVGQauy2+YUEYpRinNzHDOvrFMfCl4+kzGpdWCWlnYO+kxP+4j - Av24MO1+TmFupgNEUMpCBi8xN3cFIkKWG3o92DNhePsJw7HJlM11w398scKGvQAjs/R7htFihcfGz/At - 92xxfC7l+hbm9CIsrg/k5cRAGEInAuUZU/JzVq/2efazO+alF9rc2IrRLlIpOYyXA6brAb4NYZajvEDK - Qw3K9QamMKSDMl4G+Yqb0vOuY4yIYNlYvo8qBQYRil6fvNcjixJT5IXkqSYMNe24a5xK39x5x0Cv4fS5 - jKdPRbLeppifrrfHR4LP3nH/4Y+9/1vf3vrRH//o11TP//8Tf6gB4L/kuVcuc6SeGZNn6zN3P3TOqQ1f - 2twJo3ZXl4rMDFnG2BXXUKl5+GUfbRw6PQhDw+SwcGA65cBkF1diet2cVqjIMsG1baQ+SUuNcGYlZWX5 - BtJe5Z4DQ9xxYIqh0VGiVA+0AHSK5VjkTomL6zlnLuywcekCCzMh992r8f0mRNskm1uYskscdLnRPsni - 5rOcWn+ak73X6CdrzCY5wdoG4foWbYQ+Od24T3d9GWkvcXC4h1e06fUithOfyCph1ct0LJvNFDa7hn5i - cF3FWN3mwEKNu++d5e475ji0b5bhRgPX9cmTgihKiZL0K9t0pQYb84HVOvCVhXpwGDAG0w3BtzXH92RM - NwxxouTksmPOrmiWtiJRUpjpIZv90yWGKw5pqulGOf24GMhmWUrswY7AfMXWWRR5DnE/5+4DhnffC04c - cuayxZcXJ2gH+41VaWB1N3h48rJ820OL7JnIWN7BfOp5OLsIaYFMDMFQVVBiMzFmMTpisb5l8errcPJM - If3MiFsWPM82expl9o9UKLuWybWWJNcS1BtUh0fE931MnpssjgdHFgbRSymFUpYgFsr3B6u/7VCkGXm7 - Qx7GpsgLMFrCMDebzdiEpsXwZMwdR8sS9kWefakvp5ZiFSm3c8eRmVN7Zkc+86/+2Sde+FP/07v1v/jp - /3ir5+1XjT/SAADwuadO8bkvvsq733Ys+ckf+rfL/+Kzv3Rqa7Nz6eLVVrnT1SVVmMrQkKWGRl2ccglj - hLif09wFnQszo8Lx2ZD9412yJKXdFdqhjWVyPN+HoTmuRzVOL4WsXTzDkLR5x71z7F2Ywa/U2dntEUcR - tjLYXkCYBVxdsehtr2BFZxnZ08R3Q6K1jKpxsA1sa8NSd4UrOxfY7SSM7HQ5vLZK++I6WzsRExPCkXnh - 0JRgm5xOp89Os4PRBUHJZ7cLSTKQJXMcm1w81toOZ1fgxfMx50712Lq2ixs32VMX7jkyyeOP38cD951g - bmYWWzRJ1CNNB6u0WDYKUCKIUoh6Q6bf3NwdiERxIXUvkxOzKWJgeceSG11XEnFFbNtc20zk6o1QSlYh - 82OuHJqriW3bEiaaTj8jzXIUGiUgMrgJyIxFoYXASXnkmOHBQ3D1csoLlyssFguma03gKOFw4wYfuGeb - x++Jef6U5jc+C2dXBk5i+yaFkWGfaqNGfbjOwqzN/AyUh3zTS4TNrVxsB6mXLSaqvplvBIxXXQpjJC00 - lm1RGxmlMjSEpTCmyDDFwKdARGE71uD4YwRsBysIbo4jJO9HZJ2O0UmKGINrCWGUsbbbxa12mZrJZHzI - leXlXD37Yl+2mrntu86NO+5c+PTd9x547vi9e9c/+O0/8TUl+PH/xh95AHiDT33mBX7+I38fpVT/yD13 - XNt/9x1Pnn59eWO9rceyIivZtnGHR3zlBRYIGG3o9TTbO4bAs9g3Cw8d6jJe7tFpxbQ7DlGk8FSKW6mT - lme41C5z7uo2Gxdf545Zj8fvW2ByZoHMWGxs7CAmR7CIC5deaMAS7r1viKm9Q6SlEuHyGnJtlb3aYiqr - MtQaYvZ0zvzFGwxtX2V5q8/JTYcXLjtcvO6w0bS4vGlxadtmuekyOT3BvSfmmJgYBYG1jV10rglcm7Jn - 4Zc8JAjYFZ9Lu8JzZ7q88MVVrjx/AektszDl8dAjd3DvHfMcnhulHijSOGa33SfXBlE3jwSDM/rgDpyB - Gatr50zXM/aPZWy1hTOrtnQLC9+zaJRs8XyHMBNOL4WsbEW4ynBiX4VDc2VJs4J+mNKLMpRlY1kWBuj2 - wVKaYwsFjx4tmCrnPPkCvLA8Sjy0T5LUlqrpyjtPpHLigCVp4sknvphy7lLM8VnYPwIjZccMT08yPL2H - 6tAk7V7ExlbLGCyitqa7nYvvI42qzUglMI3AFc9Woo0WEcHzS9RGR0ypUqFIUimyXIw2xmgNAo5t3bzL - UAPfP89HHMcUaWbyfkje74vOMjFaY3LR3TA2zagl03OaPQsOvZ4yr5yKzUuv9o2jLBkf8i4t7Jv48Ld8 - x3tPR2Ec/cbHXr7Vc/aryi0LAAAf/siT/NzP/A7f+5f/pI66/f75l0+/tnD0wGdvtIKi2Zbh1tZ2yXML - e2w8UJZjIyJorWl3NN2uplKyOb6Q88jhHq50abdydnYDiswQ+BqnOkrXm+RSt8a51y/Tu36Bx45WePDu - /UwvHGRjs8fmdhPxDM2uzXbbomz1mF/wuett8zjDs7R6AbtnrmOfucbw5WXM5XU2r3e5uGsYmfNZOOiz - FTsstX2u7pbYzkrspg7bXY3rCPMzZb7x/ce589gsSQI7zS7bzTbKUjiW4FlQcm0c3yN1A3Yth+VuwflT - O5x/+jTXn/0CcXMZ34opq4Ii7NDebdJLFSkDvQQoMDpHzEBsNc0NU8MF+8YK6p7m8pri9HVbtHLwHAul - DAqNbUHg2SaOE1Zv7NJcbzJe0vzxd8ywd88wifbY6cSEcYptW/R6BXU/5z0PCMdmMqJOxudeK3GuNYU9 - PkeapFRo8/Axx5RsxaXLCa3Njow4sRwYg4oLKEsFw8O4lSHJtadWl3e5ernJ6ro2rVaBJQbPV6YauIyX - Aql4thExZFkuynYkqDco1xri2I7kcWyKLMcYQGSQAsEIosB1sctlY/nBICAkKTqK0EkiOs9NluW0Ozm7 - YSTG7XL0CMxOWubC5VyeOxPJua28mJwe2tm/MPJ8Gie/+fb33bexvrptbgeAPwS+9/v/JFGvz8mnntX7 - Txzr3Li+84JW3ouhbrhbW2G9udmsjwzZMjziidg2RhvSqKDV0iSJUKtYPHgk58RCiMl7tHZhu+lhWQY3 - cFBBg001ycVtmzMvv04pvsHbjpS4//67GZ6aZXF5nbDXJ0lyVlcLsm6b6coO4zMHmDn+LsaOv49goYaM - bFCaKtjE5oVVj/KIy6EFi/0TCjLD9TVN2VeUPIs4E1xXkCJm+9o1nKTPiaN7mByfBPFZ29iiF0Y4joNt - KVxLCGyFZVkkymVTHFb7hq2dhHo9Y2q2ytD8nXTSOovLfbZaHZIsxvM91GCLhAjECSSp5uBoxng1Y7Ol - 2WjmFHkukw0xrm3Y6WjpJ4Nag70jGSemM45P5ASmwMQ5VppJyS6ol3LiVpMozkklIAoLpoc0H3jYomZl - nL1szEs3JmRbZvHqQ2RFblyVsKdeiErb0t1dFyvrUnFzSg7MjMPhAzaNiRGUV6UfKRYXm2ZpuWXCSEte - GLFsJPAcGS75Ml728RyLHEOW59h+ifroGEG5jAB5mshA8Weg9W9ZFmAQx8EqBXjVqijHlSLL0WGEjiMj - RWEUmiIrzPp2LN2sJ/XRiAP7XQLPkRde7vLahVDthqRzc+On7rlr71ON4frJO+87GK6vbnM7APwh8K9/ - +jf5pV/6FK9c2uKZz3/EbK01U23XNw3yfH1ieqlQVZaubI/22r3K+KhNpeZiuw5Fbuj3Clo7GWE7ZjhI - edsdGXunIhQRNzYsdjsWtiu4nkvhN1hX01xY6XH19GlmnCYPHqzzyNsewApKLG/ssr0bsbGZc/2SZvWF - VVqvL5J1+pT9Heb2Fzz8ngPc9bZHmZx/O+cuR7z26hIHZgTHgvXtgsxYpMbCGEOjalP2Fc1uzMtntvjS - C9c5Olfn/Y/sZXR0nCg2LK1sEWc5ohS2EqyblX22bZGKzVbmsnwjJA4j7jrh8/Z3PsADj32ALBa21pvs - tHYpjMb1PBCLKDZIUfDAccMjd1sc2efLntFA9gyXuXNfTUaHPIlzTLsTYYqMA7Nl7j4yyomjY9QbDje6 - GR97rcNTF7pcXYvI0wItLlHh0KjCXXs1bz+ama31lM+95MqS3m/y6vRAsdkglmQSmHUkWsHJthl1UrOn - LsxP20xOQalhm1g1JCpKhDFcvdbkxlpbfAfl2IhlidR8X4ZLPkMlB2UJuTHGIBJUqtRHRo1tWaLzjCLL - jdaD5KTtuaIsS4wxiOuhgrLYpcHqn0UJebcvRRiKyXPQhrwwrLd6GDdkz4KWRt0y29vaPPVsl5WVzC7b - Ek9PNj736DtPfHZkvLH6rj/xo9lbbfLDmyQAvMETTzzBJ79wipfPr/DAsdlCZ3Fv7sQDS1lavK5VcKPT - 0er6cmfeUpkaHbWo1H0Qi24rZWczZHuzT9SPWBjPue9IwdRQSJZmLK5ZxOmgccYJfEJnhJV0hAtX1mjd - uMa+cocH75rnxD130ooVSxsxl5f7XF1KuHqly9VTK1x7ZZXlV1qsvNqkgs8jj5ygNDRHWNSI2uukSYdy - 2aHZs2l2BcsSenFBNyyYHHKIMzh5uceZ5S02N9ocnalyYKZBrVZmt5ey04lBLJRiIIoqYDsWyrHYDS1u - bKasXdygXsl58KE6Dzy0wORkwOr1S+y2EvqJS24UgWuYbuQcGk8JSM3qjYw082V8dIQjB0eZGAtQOmF7 - N2KrlYsWn8P7yzx0t0+715NzS305dV1oxQGpU8Y4JfqpQxwZji/AI3fCwmgh5y9n8oVXha49KlKuoZWH - 5XiiRNPa3DJeusOR4ZBD44aZMdu4ZUtwIBVbEqkR5Q7tTmSuLjXZavZplCDwwHEsRso+wyUPz1EUuiA3 - WmzPo1xrUK3XBK1NHqeYQoNSKNcW23UG9/4GUZ6PVQqMcmwx2mDSlDwKyaKQNE1JEkMYa2nFHamPRBw9 - DGkqvH4xV0+fiSTWdrEwO7Rer/m/+dA773kyKHvRr/7mc2+p5N8bvKkCwO/l5bNLfOs3vx1TFMm3/OCP - b7a3N69E/eRSmqu1nZ1kqLkTjwe+pla5ueWOEnZ2Eza2cjqtDEen3Lkv5+h8ynA5otXJWdtWFMbB9nzs - UpkdM8JSy+LatRXs/gYHh3IeuvcwUzMzbPaElWbEcidmPYHVrmZpM+PspR6XLjTZvrrK9HCZB+7bz575 - WfzAp9fd5dpqSKefMVYXhvycyUrOXftd9k+7jA9bKDRJLyTI28yPaO46WGa0XKDTlBtbCf3UgG1hW4Nd - haUEHIdeprm+3sbxPebnhjh8rEbVa7Nx8RzrmwXbPQ/Ltaj6BXU7odvNzLlFeOGSy7nVgvVOItN7AsZH - BLsIubGZyvVNTTu1SOKQImpSCzIaNReNh6sMtskxlk8/UZgk4933w4NHDNtbqXnmbCAnl4cJSopGkIjo - nCT1JEltfNWSo1MdHt0fM+TpwfG8ZEkqFmHmmFxciZKM5tYuSytdWq3MlAMo+RZV35WJqk/Nd40BkxU5 - 2kBQrlKu1Qn8AJ3lkqepGBDlOGJ53qA92RhQCrtcNm6lbERkoA4UR6aIIsnTlCLPTaeb0+wm5HafmT3G - HD3oydp6Js+/2uPMSopdrmzddWz21cnx+mf8cnrR8yvmw7/z4q2eEn8ovGkDAMDnv3yGzz71KgfKbfI4 - 7P/gj374ei/fPHfx9Mpyp1eEvZCxNEyrnsSUXY3jQDcq2NktaDYzyHLGqxl37kuZHU3w7ZStJvR6gLZx - q2Uyr8FKVOXqao/N1RuMO12O7Slz15378etDtDOLjV6ftoHIL7OrfJZ2C16/sE5zawsr6TDiWlTsHJs+ - gdVnshKzd0QzEWQMeRklH6plYbJhQ2ETJUI/SQjTnDxLcQnxCZGkB7og1YrMOBixsCzwbAEKumlCY2qe - mfljjJV8WlfWeOXzF1ndzokdD88bBI4sFzb7jmz2fXq5x2Y7lWYvYXwyYKRmGadI5dJyxLXNFMuzpdnJ - uLoYoXObmu8wVQNPh/S6Me1sYN4yUc04Mpni65hzF2PaxRD1mRmxbRvf9Jh2N4migjApZG54g4cX2vLw - fI6VGzRKGhM+YeGwtmMkiWOzu9OV5eWebG+n5MVAN6Lk29QDn5GSR9m1MCJkRQHKolIfolSpMtj+5xRF - ASJYnofl+Zg8R2uNuD5OqYTtexitJY9ik3V75FGMKXIEaHUztnt9qiOhmd0Dw3Wfs+cjXjzZpd3Sql4t - XXrwoYOfPnh0z8vf9QMf2Tl6zwdv9VT4Q+NNHQDe4FNfOMmnPv8K737XmF46e77zv//kx8+98sqXT6+s - hjv9sCCMiiHJE98mE8vWmJvJsJ2dnF4nw7cMh2YNdyxkDJdCijRnpyVkscayXLzaMG0ZYrHlcvnKKmln - h/3DcGzfBAtzU4BDL8zY7UaI6yKlEpHjsbjZ4cz5ZVavXids7VCyC4bcmLlhzf6JEuXqGG09zOnFHlut - iHJgsdHWXN+B9b7PlY2M09fabGxFlGyXo3MjjJYEnfTp9XOizKBlUPqMMVBk7J8tcWjaoljb4Mzzizz1 - 7CobmYKqh2MJGEWGjRYX5djie4IjBXW7kKlyYVQUs76ZyLnVjK0+VCsOynLoxi7ruxZrO5qwn9HsC83E - GzgGOwVzQxnjZQNxQbeZMj/h8PBdFRkfHWN8qMKekYSxumZ6OGH/SE+m/Ag3TeiFhm5u0ytsFtcNiysp - /d2ItRsJF5dy0tRQ9hHPEyqey1ApoOo5YltIcbO4yXY96o0RAj8QbfSg6g9QjovleijLQmfZoAeiXDXK - 840BdJqRRxF5v08axybPCtCKdhgTFj0zvz9nbEyxuys8+2rI2csJVd8z443SS3fdf/A37n7oyNW5g+9+ - S7T9/n58TQSAN/iFX/gEf/bb3kWcL5uf+/Ef2/mNL68/9x8//R+v7vZU1G2nXq+XVyhy3xLwHPB8RZzC - xnYBxmZi2OKegykL4yGu9Ol2hW5XMIXG8UtIZZgNPcLltZQr569Rp8PRaY9jRxZoNBrESUHYiyjSdCCG - 6Xn0sFluJqxs9dneDllvZkSZTblcZnhqP+WxA6y1Fd04pyAj0QXdRHPlRs7mboRBMT1/N0fvfx93ve39 - 7JmZpeEY7LRFnoT0c+gnGqM1Y0HB3uoupegSr5+8wHPn1rkSCZHjI7aLJfJGW7CxlBHBUGjwbEPd1thh - T1bX+nJqOTcboYM4gXi2GN+zCEoOsVFsdIWrW8J26pNZJZIUGl7GwfGMhWmPku/R3NGE/UR0GjFS8Rkf - qZhyrcrChHB0MmayoiTtplxd7Mpa27DcFF4+X3DxSsrmxsB5ab0FW92B5kDFFwLPYqTkM14OBmd/DFlR - oGyHoFylXq/jOA55lmF0gVg2dhAYZSkoCjFai7geTq2KURZFkpFHMUUYUsSxyZJE4iSXbt9INw1xyn3u - PKZM2RdOnUvlmTORrHQk37cwujk7U3+yMVz9mO912h/+D2dv9bD/Q0X+4B9xazDGcOXSz/FT/+iXwVae - 1uaP582ND+nm6qN1O5weLmelat1GW4ooFSzbo1bzmZr2GRsVCjE8c87hi2eGOLk4QVeXkMBFeS5ZYcjD - NvX2ee4a3uVDb59gz4GDbJkRPv7URV46fZXmbhPXsfB9n8IalJkWUYTRGt8uGK8YHjw6xZ1H5rHKo9xo - 9rmytETJadPt9njyZBcpPB646zh/5i/9DY489sdoikvc2iK8+gqbL/02l199jrNXVlna1cSFYtgvKFua - ooDVrkPXeNhlD8dS2LzRC3CzEehmQ8/gWDy4JkyijKwwaMs2vmfhOYpByZxCRN1s97vZVSiKPDeE3ZQ7 - 5zO+8UGDK8LVFZsvnvG41oRC5cxVC7Mw6jMzOcxYQ1P3Q3wSertd1te7EmWFaUeYtU0QI/i+kFoimTaY - XOMoTMVTZqjsM1MvMV0NMJaQFIVJ80xK5SpDwyOmMTRslFJEUSQgxvY93ErFUBSi4wgsG7tSxWk0TJ5r - 0m6fotczRdgnj0PyPKXXz1nfzkxmdxmd7vLYA44Jw4Lf+ESXp84kdjN1d9718MEv33N0+jfa3ei3f/wX - n0pEvmanyH8VX1M7gN/LE088wU/+1O/y/GuLPHh8phA4e+ThB07WZud2NjZ67s5Wb6TiFE41QJVKFq5n - UxiLdrug3QFQ3HVAc2JfRN1v0e9ptnZscm2wLYUXBETlPazEVV557QrhxhL7q30ee+go+/cv0OymNNsh - vTDCd2wC38MNfGw/IMVnvW9z8nKT589ep2Ra7BsvcfzIAWanGmituX6jzXB9grvvfTv7H38XK7URfu3i - dc4rBz09y2hjnlHHYrhY5dCMw8hIheu7DlebDtf7Hqnr45U8So6FI2JuDlO52RzwRn8QShADGJQxtoPt - OgSuJY6lBlp4ygIEY7QYPaj5FwxJJhSFYbic8chxwzvuUebi1YgvnHJZ5JAUo0fwJw+Ytj0tV3YDOX2p - I73dTQi32NjocH0jZn3XEGdijFFYjsj0Hlf2HvClUreNaMi6GgX4gZJG4MtQ4ErZt0QphcYIxlCuVKnW - GmI7DrrQkmc5yraxXR/LcxRFIUWWiwoC7HIZy/WgMOgkQUehZGFImiZaEJNkmO1WX7xKyPRsQb1eZmVN - +PKLXVpNY1Ude/PAgcmPv+2dJ55xPXfzwXf8D2+Zpp/fj6/ZAPB7eeHUMs+/tsQHP/BgR+fZazPHjp5W - QXn9ynJrstNJ6hWnsBoNX6q1AJQiSTS9XkE3VJR94b5DBQcnO1ScNhtbimbHRouF7xjsUple5SAXN+DU - 61ewdi9zdFrxx977MPXhcZqdlJ3t7YGvoedhicGxDCVvcOWYYHPqapMLV7fIOi32jufsn9HY7FJyfJQ/ - iTpwgPO1UT7Zcym0wz6lODJSJ+11OX/lKsNDCXcernDv3fsol6ts7yZEcYguMrw3rr9gsNTfVPIZNAoN - JrgMOoTEUiKWUqKUGPhP/UQ3X1/pLxQzEPukKLj3mDEPHcmZ8BN5+TWbV5dGYXS/+JUyPgVuUEGcMmIp - 7pztyaMHO3J81rBnTGjULcbHHdk778m995Z4+6MVc/iQz+Z6xvpKho4NriumWnYYLZWk4jk3+xrMIMNv - 2ZSrNVOp1IwB0VoPPA+CQBzfE8FgshxjjLFKFVF+IAYgy9FpQtoPTRyHJk4yKQpL4lRLN++ZqdmMffss - 6Xa0nDwbyQvnErzAL+ama1eHh0q//l1/86++2txcyt6qmf/fy1siALzBN37Dg6xfuVbsOX5823Wts9MH - Dry800r71zeSg1D4tQoyMl7Bcy2SOCdPNf3Q0OkI43W4c2/GgYk2iojFdaGXDAJBydNQHaPlz3F6KeTa - 5Wt4zQs8fHScdzx6Apwau52IjY01DOC6LkpZOCK4lsL2XDqJ4uL1PucubLC7uc0d+2zmh3x0YbFbsrnI - DkvmCneXHN5TG2ZqOObixkk+8eLnuHRmFdMpuO/4MCcOT7JvdhpthHYnotXqgDHie+6gCta8od5zUxpL - CcIbgcASMBhdAHKzj2DQQzBo97UGOwKlCMOMspfw/keUHJwsZHs1Nc9caHChO4M9OimOayF5KlHuYOmY - PaU1HjuwxYNzfSpaU/UUs1MuC3tcDh0OuOPesvGqFtdWcvPcMyGrKynlClIqOdRLHuMVXwLPphBMWhSi - jeD6ganW6pRKJcnznEJrlOPglEoox0WniTGFRhwXu1QWsR2js8LoJDE6DEl6PUnjRPKsMN0QOnGKcTsc - PAB797hy+VpuXjgby8XNXI+MNa7fcXT6uXLZ+/S3fudf2bh27jnzq7/1/K0e0n/ovKUCwCc++SJ/+s++ - H9t19fd834/E0sjXmmvbp4yyn9vqWMF2x+zRac8ul5DRsTKIIs0MSarpdDVZatg3BXcsJBycaNPtJaxu - CXHqYSkh8IWsNMVGNszZ5T6bi5eoJCu8+5G9HDt6AO0Os7m1y/Z2cyBHbSksGVT4ObaN5Xs0U4/ruzar - 6zlxO6KiOijWCNNX2S2e5Nr6Uzxz7dM8s/FRLlx9kvDaKlvXbLa3PIwJ6Wxvovtt7jk6w6F9M6SFw247 - orXboUyGYwu5cga5AOCNLjm5qe1jMBhtUMrCsqybgUHd/PuGwgiZthAKZkcK8977kICcF04aTu/OsOvO - 4JZ9sZVGFzm9diEVacld02s8ON9lvpbTb2vJscQbdnFqDpVRl+Epl7WNgpdfjNTFcwn9npaggqmUPGmU - fBkOXOM5Ci1ImuVGlGWq1bqUy1VsyyFLM4wZSHtZrgcIOo5BFJYfGMsPjCgLnaUUUUjW75P0+5giN4gy - zU4m/SyiMZYyt8em7Nm8dLLD6+dCqx+ZYmJi+JVHHz3y2Zm50dP3P/5I78JrL/FrH/3acvr97+EtFQAA - PvHpl/nt3/kSDz3coLe7W3zn9/1U54f+8d9YPn1y8aRynEu91B/udNOhuN916zWHas2l0EKWQZIYohjK - Huyf1hybCZms9tnczthtKdLMw/cUdlCi54yz3PW4dqNHb+UqM6WUx+6dY3pmD4UqsXz9Bp1uH7EGk9+2 - BEFj24pcHNa7DhsdodNL8bu7lLrrWL1Ndjo3WG4t0ruxjL7Ywr2s2N10ibU9sCOzNZ0k5uylLYo04x33 - TTPdsKhaffaMRihLs9N3TK5B1EC/72abzEDnk9+bLOQr74OGGk2aGrqhNhNDmnsOablvb8b2RsGnng+4 - wRzSmBBbaSMM1IH63VDG/S0e27fO4eGIskKiTIzxLJyqi1N1cCsORlnmzOlYXnyuJ91mjm0ZMygi8mkE - HoFriSgRYzCF1riuJ0ONhvE8XzTIzdXfOEFpIFCe5aZIMxHbRpXKKNcdfI88M1m/Z+JulyiKB8ZJyma3 - H6PtkL37UqlXFZvb8KUX+lxfL6zhuleMDZc++4733fOxO+8/tDG98D/kXw+TH96CAeANfuVXPsOv/urn - aPa/wMd/+bfy57/wme27H3vPpe1m8noYmWYvsuq9blgzReoMD7v4gY3WQhgNFGKKDMYbhv1TOQcn+7hE - bO9k9Po2hXbwyy65W6dZ1Lm6rVlb20E3Vzg85XHXkSlGp/fQz2DlxjZpOug/t+2B2ox9U1M/1hY7sWK3 - o8l3c0ZaObOpYTYE/7IiOu+wteLRST1ibdHqGup1n8nJgCs3Opxd3OXGZpupep9HjmsOHdB0k4zXLkWE - mcGylTi2MkqpN+b+VyY8NzUF4WYr8eA6gCTVRGEmx/fD207AiJPIxWsWT54bll4wi9toYBWJ5EaRGwtP - 78qRkU0e37fNiEpI+4ZcLCRwcMo29TEXp2Szua15+cWIUydDjNaUS4py4DBa8hn2PbFsZQoMhTYUKDy/ - RL1WF8uyybU2ohSOH4gTBJg8N0WSoLVBfB87CERZllAU6Cg2aa8ncb8vSZqRZkKcKummfaqNmDuPuehC - OHUh5ZnzkXRyOz60b3RpfKTy8Xd/w/1ffPA935o88cS/vtXD94+Mr7oo6JuN4fK7eObzP8YP/pPf4Ie/ - /wNti+xLiTu3pE3nlMna35g2e490ot7+iVFX6g0Pz3Pp93J2dnLCSDHUgLvnUqYaTY5M93nydJ8Lm8NE - aR27HOBVhwi9Kq90N7l6apUHti7wwOE13nHkEAcm7uDZvVM8+9I5NjZ38L2MSrWC77lYKidVQpo7rBc2 - 7ZbLRM9moZuxbxgOOB4bQzZXC4hNTlakRIkhzxS1ks29x8tcvNZi+foy/jGHQwc9s7sJE16FwxMlWe0Z - ElOQ5oXYytxUvhOD/Ke3we3AV0RFRaOMQYtnFcyNIvNjsLGsubJepu+PY9yyKDCCkMVG8iJjrtY1hyZ7 - zNQKVF/T7gpWzcGyLYxSlCqWyZWwuJjI0mJKp6NNpQKOpyg7LlXPIXCV0ZaQFZq80MZxPXzfF8t10QaK - vMAJAmzPQ9k2RRyLLgrEdozluFi2g9EGnaRkYSRpFJNnGZYSwtzQ6iVgJ9Jo5AzXLBaXM3N1KWS3lyvc - 0vbU3OTzCzNDl/r9OEZfu9VD9o+Ut+wO4Pfys7/4WZ544gm+9OJlXjx7gweOzbR//CO/ePbq4sa1bi/d - 3N7qSxSm1TzLKuVAUQoGZ+MwLGh3By3Hw1U4NJMzNxZScSO6nYJeCGlm4boOqlwndEe4ulWwtNKk2L3O - /JBw7+EpxifHESdgs9kjjhOMKbBs+6aAp0FZikxsWoVDsy+EsWaoatg/qzhxyOPAjMtkw1D3+owECQ0/ - ZWEiMwemcvYM5zJS0qa1mfP6iznl0qQ8+vgRgkDR7fZptWOKwuDYg0YjAOQ/3RDwe44AUapEBKZHCt5+ - XLN3tOD5VwpeWRmmFexFBSUGgjtiwrCAqCsnpta4f88uC7UcnRr6mcKquNglx1gli+qwS7treP65Plcu - JhL1C1wfyiVHhoJAar6D71oYJVIUg9qFUqlCtVoV1/PRxhhtDG5QxnJdjNYDRV+tsYJAnFIJy3GN0Zo8 - iog7HeJ+nyzLjG07hKlmpxtSGQ6ZmtbUSra5cDnhhVf6xBFOrexdvuuuvb/z4KNHX/3An/0XrSf+wa/f - 6uH6R8rXRQD4L3n57BINvWNMka8fefgdZ93K8IXla9vx9nZY1Tqv2TZOqWzhOhZaQ69f0O0btLHYOykc - mk6YrLcxWUKrreknAwkqz7ORyhRNM8TZxR7r16/jROvcd3SC44f2UK4N0Y8TdltdikIPylktC1vAUaBs - i05msd4TtnZjHLvgwKzP3MwM9eo4YT+n2QxptXqmWralXnXEUcqcOaPlc0/l8toVI6N7azz+vmGqTkhv - p8u11dAkuRAELsqyBvkA4A2t/8GtAWgD7W5BNdA8dAfmnr0FKsvl08+7nN+ZNGpsDsdWgs4olEOeJlTZ - 5tG969wx1pVAa3Kt0J6NW3FNULcJGg7aslhcynnm6Z5sr2cENviBolbyGC35BK49UHwC0caIKEW1WpNy - qfyGCaGI4+CWyyKiJAsjdJ4jlm2cckUs30dEDHlO1g8JO23iKCIvNCIO/SSnn3fNnrlcJsYtdloWL7ye - cOpSYoZqpWxmrHRyZs/oh7/3f/szS0888eGveauv/1a+LgMAwGefep3PPPka73/nncnP/7NfXP47/+cT - r7Zb8YXLl5qVTietiElLpZKyyuXB3XSW3dQe6Bg8Rzg2L+yf7DNS6tDaLWj3FFFhY0uB5/voxgLXwzJn - r7VpXjvPmNvjnQ8eYHZ6EnECdnZb9MPoK8q+SgYS354jKMtmJ3S4vq1ZupEgUiEojZDYU1xp2ry+kosq - z6HsCVpdh+cvZ/LC9YSmtkxqK3SRUreMSK45t9iRMBcc3x9k/WXQMjvY/H/lH8cY6Hczpho5733QMB4k - cn1F8/TFYbNWzOAPj2KpQnSeEWWW+Kor+4Y2ePveJvPliH5Lk4nCKrtYgS21UVcaY65sNTWvn4p57aWQ - qF9QrYpUAo+Rks9Y2cN1LNEIhdZiEOM4LrV6Hc/zSbNcjGXjBAGOH4DW6CRBRIzj+8YOSkbZDkZrdByR - 9rqE3a5keU6hhX4k9JPYKL/P0YPCcE3JmQsRL1wM1XKXdH5h7NrB/eNfbLf6n3nfN97f+5Ef++itHpZ/ - 5HzdBoA3+A+feIZ/9hN/Bcd1w+n5yWv77zj6+XNn1m6srmfjUT8qK1J3qO4q37PQRkgzTbdnaHVhtG5x - bM5waKKNKz1ubOV0Y4fcWARWilsdJq3s4WLT5cLldZqXX+WOuYDHHjjAyOQsSQ7r6xukNxtZlFIoEWxL - CDwh04obO5ozF9fY3d3mgaN1Du4dYnhsHOxxU2/UOX64JBs7PS4tdTDGw/GqBKUaeyc9PMm5cKFNNxbw - bvYKoMFo+U/TX8hRZBqkyDk4XfDue4x0mykvnLa4GM5LHEyIVxoUOeWpkX63YDLY4d49G9wzFUrdyqXV - 1mjLxi47qMCmOuwSVG1z/kIiJ1+OZGU5HWzvK4p6yWO45FMLXJSlKIyRPM+NpSyCUlnKlaqI7ZBkubFc - D69UwbIU6ByK3CjLRrmeWJ5nRJToPJe01yPpdkmjCCUYjWW22hmJ7jE82jcH9roi2Dx3MuTiUmIlueof - 2Df59EMPHfri0Ej98rv++I++pZt+fj/e8knA/xr+7Hf/cwCee/anM13oTZBfnj9y6HM7253vurzd+pbN - nc2FmUmnPDFeUVFk0w9zkiTnyrKmUlbMT9j8udGQB/Yt8tsv7/Li9TFa6QRBKabkG+ypA2z0p/idzWXO - fPgSj+67zPvefx93fPMJnjm6n88+9SJXl1dx/QDfdXFsC7Qm8BS+F9CNXV5aTTn7Cy/y8OEqj909S2m0 - JsPjDRoNn5mxZbMwAks7NkNl4dBkLDWracKog4PGUorCyKA++Gbn/OAkYDAmJ4qEQgtz08KxfULVyTm/ - pnjtWpmoNoxfKWGZBFEOxrKM5G0ZC9ocHO1Rs3KDVtiBQko2TsnCq1kGV2h1jSxeS7mxkuIpY8QBWynx - LdtYyiLRWuybJ5ICg2PZxvN8DGIybdCWJcrzsV3XmCKjSDOMNohjIbYDaqAAZLLMZFEkaRxRFLlYlm2U - KJ0VsXGrKROTlspyzPJGxuVrMXlfy2zFjas2p+66/9DrrWbvrWHz89/B7QDw/4sB0rnDB65v7Zz+5wn1 - T27r8l/oXt961/pWc//++bIaGfakF1r0w4JWr6AXakaHFHcsWMxPdnjxcshHX2hxrTXJrjtMpRpTLjkk - zgEuheOsLd7g9X/3HO+8e4j3PHiEEwvv5EtndvjYZ1+k2WoTeDalko9tCVoXNAJF7gdEqc+XLoecWr7I - A4djHn9wH1OTw1SNi59obNNnYrrCifvqNDKPG8sFuY5Ea41ozU3nsJuFwgNEoEg1OtccnDEcnMmJWqFZ - 2vBluTcEwzXjuw6S9SXVjjHAcLVr9o602dfoI2lBWCicio1VtvHLFo0RRzKExaWUK5cTs7WRUfGNBIFF - yXOpeo54liLTAx3jm44GYjsOtuuZotBAjuv7uL6Hsm3Jk9joPDeIGCxnEAAQuXklKFkcS5al5GCyTEyc - abSVMjRUMDupTLtT8PqVjCsdjV+rdBf2jizZmNdKZX8pCtPiVg+6W8XtAPB7ePiRv/yV//7Jew5rQXcS - NfSy0tHSyMzoUzrvfPOpy4vvGCq1JvbuKTNcd+hFFp1uytpmQbdnmBy3eMcdhsNTO3zutR6fP9tga2ca - CaqUa4JdqxOnJV4NR1l9eZGTF7/Mex/ew4eOHeDug9/Ep5+5wJeeP0Wz2SHwHWrVsgEttkA1cEwrKUkr - zIikw9b2Wc4+LbhRUz7wdmhMaAJ3m+3nO+bSlubCiqanbaN8Vyw16PIr9E0b4YHR78AdVxe4Kjd7J5WM - 1WDxErLSqZAEo/iWP6gRNIowLMSRiL2jHXNoMmS8bCTcKkyUgVeyENsC26JcsczGruHKlZS19ZwoMZRK - GM+1pOq5VDwb31EkIJnWCGBZDo7jibJd0jwHhIrriWU7Rhfa6EIP5L5sW8S2DSKmyAtTRBFJr0cSxbrI - tbGURSfUdMLUKDtheEgYaQRmcTniynIk3VhTrvsrew9MvzhUCzaKQudav+V7fn5fvu5zAL8f//Hzr/PC - 69d58PhsISbrHn7obUtJkp1Oc2ul29eyvtFfUCZTjapQCjxEFGFc0AsNujCM1BQHZ3IOT4XkUZdWK6fT - 98Gy8HwbnICeGuJGXOPKtVV6G0vsH4q559gsh48fptXP2Wp2CftdUZaN5/mIKFFKCFxDSUKzvdnh5KWu - 3OjkoISaMXRWC15/PeOVa4YLLZuu8lCOg2sJ6qbt7xsVgFpDlCpcW7Mwkcs77yooq4KnXsKcb01KWJ7F - 8T1sSzAIYTejzC73z93grskeE54m7ENqFE7VxS45OBUbv+LI0komzz/Xl42VDDKNX0JqgUcj8Cm5FspS - IGL0wHKQwPcJSmVs1yfVBhyXcr1ubMtC5yk6TREB5XhvrP4UaW7SsC9xr0schaILjaVsOmFBXIQyO9tn - frbAs+Hl1/q8fjayyDQj9fLJhx49+vEjxxfOvf9P/fP+r/7Wc7d6uN0ybgeA/xdeOrPEt/2Pj6OLLPlb - f+//2riytng17EWX01w2O/280e1l4yW3oFpWBIFDkhq6fU2YGHxXmB6BQ1MJ46UeYadLu2PoxQ62a+ME - PsatsJU1WG7CyuISXrbDoXHF3ScOMj4xyU47pdPpEkZ9bNvBcQRLNN1QWOsoVvu2bPYd1nctFtcUFzds - rnY9WStK9JWHZVu49sBQdFD3/0ZFIOS50O9ppkYND95hOD6T0trR5pMvleSGnsUanjSO0mCgEIci7clU - aYO3791krtxHEkNqFOI7uFWH0pCDV7XohPD66ZiXXuiZtF9QDoSSb5vhks9w4GHbCiODnkWjC7GUolKu - 4Hg+A2tfG79UMuVqFWU0RRwPRECUBbaLKGtwlslzyaI+ca9r0jQVRLBth+1ORDPsUK1HOLZhe1fJ06dj - ubqhzeRoNRobKn3+znsP/Pbxew9s/duf//zX7fYfbgeA/yo+88XX+eRnX6FmL5MnYfhD/+TfX8/c1pnL - F1avd7t51Ovnw1ma1zwrp1y2cV2LMNJ0I0gzYaSmmBvNWRjpE6g+UZiw27NIMoXr2DjlGonTYKVXYulG - m531G0yXUo7MVjl0aA7bDUy7n9FutyXLMpTtkhmbDBtlKTQWUW5LM3HY1S6JPRA2cR1nUF8gCr7SGjy4 - 9DdAlhnCXsaRecM77hPKOuHSksUzV8el604bv97AMhlZbogzRcPd4dj4Bo8utGhISq9jEN/GqTrYJZuh - cRcnsLi2lPPqqxEXz8coDLWKohp4MlzyqQcOiGIg9wUYI45tm3KlhrIdcmNw/ICgXBHP80RnGXkcDwoF - LBtluyAKtBadJZKGPeKwL4U2xmCR5tCK+oRFD88v2O3C2WsFJxcT1dVO/+ihyUt7Zoc/5wful6ZmR9Of - /5WnbvXwuqXcDgD/DXz6C6/yqc+9wnvfO66vnTnb/aF/+rtnXn7pqdeuLXaacarJC4YcVfiBZyQIbEAI - I0O7P2jV3zOu2D+dMNPok0ch3W7BbmihjMHzPZzaCC0zxGLT4trVZXR/m0MTHof3TjA9PSlxLnR6Gd1e - hFKDegTXksEKb1vYzuDl2BaOpQaKwgxSbIi8UfKLMcZkWiQvDL6Vcd+hnIcOFawsZbx8uSKL2ZwpgmFc - z0ZhiGND2k/YN7zOA3Nb3Dme4OQF3T7YlcHqb5VsasMuuRFOvhZx7mxsWls5jgPlskUj8Kn5rviOJVpE - CmNEGyNKKTzXp1SugmWb3CB+uYJfKiFAkaYUeWZEWaJs11iuiyhB5xlZ2DNRr0+SpFjKIs0w261EjB3K - xGTBgb1l4kQ4ebrHxlZuu46zedeJhc/fc+/+p3db4dJ3/o2ff0tKff+3cDsA/Hfw8z//Cb7nuz/I0Exm - nvztT+z+6986+dzj73z4ci9z0m6376ZxWi75eCVPiecqshz6kaETCvWKzcKkcHC8T9Xp0euEtGOLMFW4 - qsArl5HKKOvZsLmylrB46SrDTiRH56oc2r9ApVI1nTChE6bEaY6lLJSSQevxTXMRubm6DlSBzH8mFQYG - rY30Y7AEDu4RHjxs2FPPzbMn4cWlIYnq+7CCEjYFRtmSJblYSZO7ptflvpldGXM1uhBSFHZpEAD8qo3y - bLO5U/Dcc32uX4uxjcH3hUrgMhwEBI4zKDoSQRtDURQ4toPvB+L4HliWiGWbSrWO5/uYLBWdpYARZdtG - OQ7KGgikFklC2O0SR6HJswLbsk2UFGy0elIfTjh0QMn+uSqtjpGTp7tCptRI2bt26MDUR977oftPurbV - /c1PvHKrh9It53YA+O/k1z/yFP/sx36ZL59c5i9+z3Ge/cILK3nhfTGzRzfDVJnWbqcmJvcrgTiBNzDx - jBPN1q6mFwnTYw5HZguOTPUo4g7tdko78TEFeI7GK9clDcbkRjokZy6ss3HtKvuHE3PX4XE5fOSQxKlh - tx0TJjf18W3FoJIfMQONLzHGiDHIQOlL0EZuvkO/m1D2NA/fXefYQhXJA774quLsZgNrbI84ji1SZJJq - 12Bihr01eWjPljky3MOERrJCsMqDlT+oO9RGHLqx4fyllBef79PcyqiWhXLJpuYPKv8cy0ILiKXe0CUw - vheIH5QGwiWWjeuXpFypiuvYksWx0Xk62P47LmINbOHyNCUJQ8JejyRJJdeGolBEaUGs++yZzWVqAnN9 - PdPPvN7ntWuJGRmt9fbND73muurDx+7ad214qMrP/eqXbvUwuuXcvgb8A/J7RSP/2p97PDHYH104cd9L - Oo2+8calVz90Y3Pj0b3TTrVe9Wyr4tCNCnpRzrlrBePDNnunHf7iWMpDV27wuy/ucqE5TTcep1TVlByb - vDFKt9Tgy701LvzWaXns8A0ef3Cev/C+A3L26AQf+/xJljd6dPuFBJ5lbEtu3vANEm25MeQF3DTPHdTX - izIWMUOuYc/QuHhOg7UdZKfoENtlfLGNEqHQhn6YSsPtcWiiw/6xlIYPO63C4CjKdQvLs3BLFqWqxeJ6 - ypXLMa1mIXkOYmF8x6bsOjiWIMqgB/JkA3tzpfAcB8dxSM0gV+F4N2W+i8LovDDmpguyKMsIgs5zSaOI - MAxJ0hRttAGh3c9VmCUEpYyJMTGNqjKvnU9YvBFLZMhKw9Xzh47NvWTbqvmub/4xnvztv3Orh86bgtsB - 4KuPsR13JcvTn5+58+Fnd1eX3nPqyoU/3wj6R/ZO2+5oLRBdC2h1U7ZaBa1uweSowz2H4OB0yJOnLvP5 - Mxtc350n8oYo1WzKnpDb02xXJvn46lVe/Y3L5t3HrsnsmPCBwwmv+qk5swqdtEwfF8QSRWE8SanaKUM1 - TaUE2rJIMkMW5uLaqZmu5Dg7l7jetbmyXabFAezhGRRa0Dd3DP0+DXeXw2MdM17OxRELscUYR4GjEEeh - Rej3DdeXMxavJphMm8ADywbPsXBtmwyMYnAg0XogBmpZtijHQWwbCm1s2xHP98UYbbIsRxc5iBr8OUZM - kaPzzGRpQpYkmEIbJQqjoBunpCZmaiI3pZJPlFjq+mpLt7di1TCqqFjW6YNH5170PKcPT97qMfKm4fYR - 4KvI86eWeOHUNb7x/febPI2K4dn9O0r0+dGZmZc6/aK7tp0czNO4VLJzqdcCLMuiH2l2O4NimUrZ5cic - cNdCip216LQjdlouBY5xPYVnISYYZdfZw9nliM31HaZLPe454HDfkYCxckbNDmnYA2OOfbWEIyMp+4cS - Do6lPHLEsH8kx4lTXFdLrW7J6LBnVnc8Xrhcoenuwao0cEyGQVFgQdriwNAmjy7syJibGSkUxraxSg52 - YBPUHLAtNnaMefnlkPNnIpR5Q/DDZbjkU3IdciOCGiQmjdaiROG6HrbrI5ZjxLIIylWpVGuCNiZLE1Nk - qYhSg35/A0Wek6aJRGEoSZKI3JQ0zzXs9hPjlWKzbz7F9wqW11LzpZdDWj1L9kxWd4cbwe/8iW97/DP7 - jh3s/ct/8wnzC7/+5Vs9XN4U3A4Afwh84jMv8cE/9iCWbenv/Rs/HZUm1fra0sbrhTHPbe0Uzk6rmC3S - vht4RoYaPogiTgy9qKAooFaC43tS9o72cXSHZjuXnY4tYrs4tsKxlIT2GE0ZZzsKcJVhohTLZC2johKs - POfY/hpHDwxRrQZEaUG7l+L7HgabMM1xS9AYtpgY9WQrqsm5nTEJnTGU42PpRMLUkqLQsqe+yaP7tnls - Xw87yel0QXwXr+pQGXGY3utiLMWZ86m8/mrMxkpKKYBKyaLi+dR8F9+xKERQSsRWSigKbMsmKJXBdowW - he36UipXCIISRZ6RJ4kUeWFEKcSyMFqTpRlRFJk4jiTPMjBikgy6USFp0WN8LOPoIdf0IotXL+byyrVE - adfbufPI1Knxseon//z3fvDM5L5v0U888U9v9RB503D7CPCHxF//wZ8DYHKqgYikf+sf/vrK8y/83Oa/ - /Ps/cbUWeJ9rFnx7stu9u9Zv14aHA6pll3YvpxMZuv0cx4RMVgr+5EMxR1YTXrjW5+XVMVq9OkEtMKXA - RpthltKq7K5ucnZzhYOlFUYrmr17fBFfiAqN4ykjShFHhlbLGNszGKVE6Zykn7F8vTCr7TqhPQy2hxKD - UbYp8gLX9JmrtKhZfa6twY1VuLGdY/kRI2M5e/cayiMBnT5cvRqZza2UtIDUgGVZVFwHRymMGVQhys3s - vzYMnJAd1xhRIILrumLbjimKwugsg6JAiaABnRdoXZBmCUmaSJ4XRmuDwdCLCrPbT/FKGUMNQ61sy7WV - iKvLoSRRrir18vrMwuSz++dHr2+sNfX8yKlbPTTeVNwOAH/IfOhP/DAAxmzzMz/xA6mjinPzdz+wsrG0 - fD5P7D8WZc439JP+4XolLQ8NBWTaptWG1W2NKhKGqjl3TOcsjKXsu9rnxaUhzjdHJPFr+CUXx7VMJxvj - dFhiNWywL97gQGPbeP0OQSnGH6kyNFoj0z4Xl7viWBFzs4bxYYdMu5xdcmRxd8iEUsXBYEmBsX1xrNC4 - cZus2eRKr8dlCqJkoNlXTnL6iWJrFy5fT+j0c86cj6TTz41XFmxb4Vg2wUA+iBwQpcAYtDZoBGNZxihL - jChjiYXvB8a2bfI8kzzLjDHa2LZFboQky8mylDSOSZMEXWhBFEWhifKcJI/NaC2nWhVp98QsXs/NjdWU - hmuroZK1PjJSe+6eR+6/sXDn37jVw+FNx+0A8EeEyCif/fg/5C/+f36O/33/nq6Y9Km8dPCqznZeK/Kt - D6S93qNJGh8cargyXLeIY4+NzYzt6ymzScHsRM43nog4PNXj+WsdTm1MsJkMGe0HOI6Nses08zphOMZ6 - /zrz3nWOTPYYKSlMo4q2Sqy3BlV9lqsZqisS7dKTMTpmVLQVIOSYoiATF890pZKvm6TVYdcpEN9GyKlX - YN+cx8jUfhI1x0uvrHLl4gpJr8D3DLWqouw5VDwH11Zfufe3lKALjS40tu2gbAd9U1/Qsm3jeR6WEkmS - xGR5BlqjLJvCGLIsI0lSkiQhiVMsAVAkmZBrjeVmMjZSGN8Vc20l4fxKKluxZAf31JszE9VLRZade/j9 - f7cNP3irh8Gbjts5gD9CfulXvwDAF5+/zDMnl3nbvfOdH/93v3t2ceP61V4/2dzZ7kme6aop8oqjUmyV - kRcFzY5mp5WhdcForWDfeEZJeiaLI7bbhiRXKMvGdWxSKdMshulkARqh5kfkUR9dGDO9f0HmD45TrRpa - uyGXl+FyZ4KWGcHYAZatBmWCaUQ9XWZCL0rFihkZtpmeKYOAsl1mFibZf+ww47N7uHhpg9WlTRNISskz - lAP1RtUfnjMwGUEJtqXQWqMN+H6A7XqiEZRtEwQlqZQrgBnIeaUZhTZSAGlekKQpWZoO3rOBQUiaG7qh - MXEeix/0Zf+e3Niq4PWLqZxaTNRuonpHDk+/evzIzBc2N1svfehPvSt74omfutVD4E3H7QBwC3nmlcuM - +qvoIt/Yd+9jZ73a6NnV1d242ezXpYjKFpkraDqJZVZ3ba6simy1LbQW6k6El+3S29wijnMyHLAE21HY - ti1dM8pmMsJK0+L6UpcsLOT4vQ9x970LTIxEvH66zZMva9b0PLk3bGzPI8fDZDHVZJkZ6zp7yi1Ghwwz - 0w57pgMy7dBLfOKsTLcZsrG0yKXzV02/26VWMjiu4DgWDd8ncAZSaqiBA5HIYAdgjBg/KIuyXZJCi+v6 - UiqVxXE9siwnDkOKoqAw2iS5liTNSNLUxEkqeZ6LGIM2hijVNLsZhj6NWpfJkZxut5AXT+esb2nbsezd - g/unPvW2tx/7crlSuvHwu7/v67rp5/fj9hHgFvNXf/AXAPjFf/d3e3/pr//U8y+++uuXXvz4b35h+exr - 39Pf3X487LfHYu0qywtM4DkmyguurqaDO/Ki4I7JlNn4GmvJrtyI95gwG0U5gQlcjVEVruV3c7lbYTVc - Y2YlY34mZtQPUMall0BYqRgjZZzCkCYplXSHSXOVudouc2MwXEccvyBLE8rlshkqoL+5zMWllDDWptky - YllgOxjXtSg5LoFjY1lCpg2ONbAezLOCojCIsgXLRosaePpZNpZtEyc5aRJLnKQogUJDlOakeUaeZWRZ - ihhjXGugTZAXGUmWUPFiUw5S0+4hyzdgcVUbG6+YHim3PMyrj7zjzosnX7z0dSf2+V/L7R3Am4Tf/t2n - +c1f/SG8UiXau3965ch99z777NMX+2vr8Ykizf3RGtYdhyriWlrWN0JptjJxyyU5fGySgwfG2DPmUE3X - UdE2cZoRZRa5uJQ8CyOjJIyj83WK1lnSjWucOd81V7dctFNCZT2ccE3GrXX2VtY4UN/mwJ6C4WFY24AX - TmmeeiUlzmB02GZ0wjfVIQdjGWntahOHBseDkutS8TzKro1SQiGCZVkIQpZlmMF1H8r1Bt2JYkmlUsHz - ApI0IQwjE8eJyQpDnBeEcWKSNCNLM8mzDKMHWYMkhSjJSXUkQ/WI0aGUnZbm/HUjF7bQjdHG5pGD4y+5 - tvqdt73zxNLajab5yH946VY/4jclt3cAb0LGZ6aSfrd3/Y6H7v/05Pz80MtPn/zA+QtbR/o7oe34vjhO - YGxP4fpl6mN7OHjssFTro9y12jXXLlzg0oUzXN68zmq/TjsapW4Zym7E8lJGvB5zo9ajFwtj9ZSN1uty - x4LD4yc808184lxT90tiWdqs7hieORfR7uaMDQtF0mdnM6F+wBNzs6vYEnCsQUm0Y1n4lo02hlzrQeZf - hFwb4qzAcR1cxzWZBoXBtW3RRkmS5YRRTJIkFHmBNoXJtCbLcsnzfHA1WBhRYtAawliZKNUoK6YUpMZz - jNluIWvbiNZiPN+9vO/g7PONWrB7q5/lmx35g3/Ebb7aLC19mH435JknT7rNze0hW+WPvfDSpQ89/fTZ - D84OOyMn9tUlyzKSHER5xvVc/KCMVx6lXi9RK4POWqzc2OTUhW2GvJz5iYBIjdCOC9K4yd69EzTqNRYX - t01gmtTcnjx7pjA7fYeD+8pUK54YrQjDxJTshJFKTj+CRENQ1ew0c1av5xSRNpYoXN9mOPCp+x4FBttS - eK4NImRFQRjn+EGFcrVq8kKLbdtUyxX8ctWIskzU71JkqaANUZbrJM+NzgspigIweJZtwNBLUrO8FUmc - 99k33Tf7pzN8z/CFl+DcoljKcbK5ubFf+a7ves/PHjw4ffaxb/7R7q1+nm9mbu8A3oTMz38bAP/q//je - 9Af+wa9uvPjlH/tkv5BzpVrl+eWzi9/66tnd9+osYajhmpk5G03B6lqL1dXrOLZibq7B0WN7mJ6dI8tg - 8doGz762S7lamJKvqfmRzI1Nc+DwKPtmq3zpeeEjT++aMCxktJpjoozCHjK4I5Qbozj0SYptKtWCiqXp - JoXZ2dVsbmkqPtTKgmc72JbCMMj0GxFEFFlRkKQajaIQRaYHDkCWBcqyTV5osjSXOE6NyXMtQJYVFEWB - 0dpkaWayJJMQVLMXs7TdM60oM8PVgoqvpZ8Yc2EVc2kbSWw3PrpneH2k7r9erQSvL+ydiG/1s3yzczsH - 8Cbm4596iZ/7l38JUxTp9/yVv7dzx4HkyvLS7gUs67pf8cbFdsb6kRHbdaVRcxiq5FKpGsQy5HGP5uYO - K9ebbOxEdOMMkVQocskS6LdCrl/Z5OzpDVlb7yGWYshXNHwIfGFkfEgmphtStlMxWUqcGSw7Q1RGGBp2 - dzS9thbLBt+zqbgejmW90XL4FevxOMlIc41tu1iOD2pQ1mtbtnG9gLzQxElKniZoYwYGJWHMbqundna7 - KtGF2GVnp9QofdKu+C8bi7zXS0pRmFVyjVnfRS9uwI0WjuP7u/efmHvx4P6JL9xx94GzrmuZf/mzn7vV - j/FNze0A8Cbndz7xMr/2kWf44Hvq5vKl9eiv/2+/vjIzt3W+tdu5oo3p5YWe6PeScr8TKsfSNIYqMjw6 - RJZG7O40abe66Kyg7AsTox71oQrKa5h+L2F9bVturPQojMjYeJ3JYWG4pnE9C+WWKbRF0t2h127T7eWU - SgWijFm5kUunpcXC4LmKkudQ9byBxLgxWJaNKDVoJ05TCgNBUEYGTr9gMJbtYDu+aG1MkaYmjRLp9yK1 - 2+6r3TB0EnTXrXgnvYr3H/yK98sTC2O/NTU3/CVBn/T8oO0HrtfpJEPNpi6nsZiJ8eHmwvzYc/v3Tfzy - vr0TLy0urfe++Tt/+lY/vjc9t3MAX2O0dn+dH/iLP86/+fcvyY/8rfccWl7ceH9zJ/nGfjd+MOn2hhr1 - skxOj5hCp0Rhh7DbZXcrosjh4JFRJufnjVWeZndzic2ly+xs9qQfO5TqdfPQ2w6wZ6ZMZ2uDK1d3WVnr - 47mDvkCKjPFJRVoYXjkVE/U0tZIY33Wo+C4116UwUACB6yIixFlOlGZYlk2jPmQ0iqwopBQEpuSXsWxP - wjAkDHvKmEJyXfRTrVeiPHtNPOvkwv6p03P7p07/3X/00cU/+dh+Dhye4bmnTvKt3/FN+y6eufrQ4uXr - 74n6+R5BhRNTQ6/MLYw/Mzc//sL69UvdJ37mZxG591Y/rjc9t3MAX2M0hv40rz7/T9nZ/BUThumFf/Ob - Zy782A9+6PXNteaHVpY339lvhwcWr23UKxWXIHCNX6qAXZCkBVYwZGb3zrJn3xzXzvdJuzfoRzmJKbBU - JpY/aoL6OK4YkkSTZIaVzZjANcxN2BjR7OwW9LuGPAcj4NoWjrIotKZAMKIwCHmhidIcrcG2B/f+ea4l - Twu0g8pyrdIiIcqS9Ugni0ZY9Kvu6sRw5fLQaO2L//hffe7ctz5+mMZQhZ/7P76Db/+Od+GNfRd/+39+ - Lzvbnat/+k+/Z+X6ytaraZYPF1pn9Ub5wlOfe7Xd6UY88TOv8IXf/Nu3+lF9TXB7B/A1zr/7ie9kdXGV - 0lBQT6P0gxdeX/7A6uLGo46Y6VJg+15gm+3trgmjjGMn9so9d0+xMO1x5tQqp8+skxpjUILreTI+Nm08 - 2yJsb4pfCkycOzz/0hXKfp/77wzYamZcXUzZXB8k+qoVZYZKAYFto41GlKCUjW3bZHlBnKa4jofrBYjl - SJ4XSud54fpByw38puVbN0p177nGeOXJsZnG0y999kyvXCtRqvocu3seY+Av/e1f+//7vX/q7w8SpYXW - DJyE4H/5x795qx/H1xy3A8BbhH/4A9+ALjSz8zOHt9Z2vuH0S+e/qdfu3O150gijRGV5xvRkgIehsxWb - rY6NCnw5ftSlH+dsNjEPPXQY13J48nMXuHplgySOGB1VzM+5TIy5XF1KWF5JUIN2X+O6NjXXxVGKTGtc - x8JxbLQR4iQjS3OplCvYjmvaUZoaRdsrOctDY9WXRifqX9qzMP70h77loY2f/elPZZZt8SP/6vP88r/8 - bv7c9//srf45v264HQDeYvzM//cvSF7g10fqd7/y5dc+cO7khW8T9B7Xs700Q7a3Q7Y2emZ0tMS+hRqz - kz6XFzu8crops9M1c+zIOHvnR7ixusG1qys4jqZaUViW4vyllLWNnHoVU/FtfMfFswZ55ExD4Np4tk2c - 5fTDREdRlovjZkG13K5P1K5U6qWPHDk8+xvdrtVK4u1iZs+ofvBtR8zjH/zxW/2zfd1yOwfw1sNUh2pR - qVJ68fhde6/O7hl++tUXL317c7vzrYgOylVXlF2S6eHCjJd3MbGCPENUwcmlFm0jjE81OHp4ntmpEc5f - XmS7uUuR5URRgQI0gChsscTc9Bl3lCKLM8IsNv0810GttLHv0OyZodH6s/VG9UWtzXmUbM7tmwz/3Pf/ - rPmbf/7RW/073YbbO4C3JL/wb76PWqPG44/tkxefveBdubgxde3SysNr1zf+4m6r93C303dGqkYNl7Up - skjC1BBmtjHKplwu0ag12N3N2N7p4Hk98jyj08UkoRGtwfUUNc+jbNsmTlLiOKMowCl7qtwob4xNjnyq - Plz9ZJplz45NDnX27p+Ojh2bT9/2wR/RP/2jf4bv+zu/+p+pKd/m1nH7KbyFeepTP8TK0iZ/5n/+Gfm1 - n/3+yotfOrW32+l8IImSP7+z0drX3O74UZqbakWZiVFHKiXb9PqweKMQUQWNakGjZsxuW3N1scC2jKkG - MjD4yIwUmQHPptKobEzNjL7qePZTSVY8PzE9snTgyPzWz/7kh7vv/sAjTE2PUqkE3HPPAa5dW+dPfe+/ - vdU/zW1ucjsAvMX59H/433jnBx7h+/7HH+ZnP/oK/+QH3j++trJzot/P/2SnE75/c217No4jVymjA09J - oRXdPqZchlrFUBQ5u7sFW5sFBrAtRGmR4UY5Gx+vLYtj/65XKz29/9DM8sEje5b+p7/289vvOjpq3vfB - R4ijhH/405+51T/Bbf4fuB0Avk5YX/1FJqan+eG//A+4cvYq9z72wJHmVvPtO5vNb7p8aeO+1evbM/US - jI04enjIwwsU/bjg4lJMc6dA5QPnDs93e8PD9VMjI5Xnx8crz87vnXjxh//Fp5e+84N3mqN37mN+7xR7 - 5id42wf+wa3+yrf5r+B2APg65H/9/vfgOA5j0+NBq9m+/9ypxffeWN587+5W845GKa2dOOSY2pBtNrvw - xZcTbqwXUlYUE5P1pdn5kef3H5z+6J337H/u0x/54src/mke+8BDdHZ7fMf3/8yt/mq3+W/kdgD4OuYf - /cCHSNOcb/rjD049/dS5hz/y71/8kO5vvW3vWLTfC7B3IjEvXygkSm1man738NHZX/rmP/WOX5nbO3ny - y0++Evd7ET/yrz57q7/Gbf4A3A4At+Gjv/iXCcb2K5NH+z7/0Y+/5/yrZ759p5UdbYXUOqm0h+rBxp3z - 9XPjY7Vf+pv/4C99ds/R9yYiB7/urbXfCtwOALcB4N/+xPdSrtfIeq16c6dzx6svXfjmfi+6e2p6+NXJ - qZHPD402nrnw4qnOd/8v386JR08g8g23+n/5Nl8FbgeA2/xn/ML/+b0ShpHauLHjpklqiZAFgZs3hur6 - r/7wr9xe9d9i/N+4oMJgd0uTSwAAAABJRU5ErkJggg== - - \ No newline at end of file diff --git a/GUI/SPRGenerator.Designer.cs b/GUI/SPRGenerator.Designer.cs new file mode 100644 index 0000000..2b861b4 --- /dev/null +++ b/GUI/SPRGenerator.Designer.cs @@ -0,0 +1,145 @@ +namespace Grimoire.GUI +{ + partial class SPRGenerator + { + /// + /// 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.typeGrpBx = new System.Windows.Forms.GroupBox(); + this.equipBtn = new System.Windows.Forms.RadioButton(); + this.itemBtn = new System.Windows.Forms.RadioButton(); + this.skillBtn = new System.Windows.Forms.RadioButton(); + this.prgBar = new System.Windows.Forms.ProgressBar(); + this.genBtn = new System.Windows.Forms.Button(); + this.statusLb = new System.Windows.Forms.Label(); + this.typeGrpBx.SuspendLayout(); + this.SuspendLayout(); + // + // typeGrpBx + // + this.typeGrpBx.Controls.Add(this.skillBtn); + this.typeGrpBx.Controls.Add(this.itemBtn); + this.typeGrpBx.Controls.Add(this.equipBtn); + this.typeGrpBx.Location = new System.Drawing.Point(12, 12); + this.typeGrpBx.Name = "typeGrpBx"; + this.typeGrpBx.Size = new System.Drawing.Size(188, 66); + this.typeGrpBx.TabIndex = 0; + this.typeGrpBx.TabStop = false; + this.typeGrpBx.Text = "Type"; + // + // equipBtn + // + this.equipBtn.AutoSize = true; + this.equipBtn.Location = new System.Drawing.Point(19, 29); + this.equipBtn.Name = "equipBtn"; + this.equipBtn.Size = new System.Drawing.Size(52, 17); + this.equipBtn.TabIndex = 0; + this.equipBtn.TabStop = true; + this.equipBtn.Text = "Equip"; + this.equipBtn.UseVisualStyleBackColor = true; + // + // itemBtn + // + this.itemBtn.AutoSize = true; + this.itemBtn.Location = new System.Drawing.Point(77, 29); + this.itemBtn.Name = "itemBtn"; + this.itemBtn.Size = new System.Drawing.Size(45, 17); + this.itemBtn.TabIndex = 1; + this.itemBtn.TabStop = true; + this.itemBtn.Text = "Item"; + this.itemBtn.UseVisualStyleBackColor = true; + // + // skillBtn + // + this.skillBtn.AutoSize = true; + this.skillBtn.Location = new System.Drawing.Point(128, 29); + this.skillBtn.Name = "skillBtn"; + this.skillBtn.Size = new System.Drawing.Size(44, 17); + this.skillBtn.TabIndex = 2; + this.skillBtn.TabStop = true; + this.skillBtn.Text = "Skill"; + this.skillBtn.UseVisualStyleBackColor = true; + // + // prgBar + // + this.prgBar.Location = new System.Drawing.Point(12, 103); + this.prgBar.Name = "prgBar"; + this.prgBar.Size = new System.Drawing.Size(279, 23); + this.prgBar.TabIndex = 1; + // + // genBtn + // + this.genBtn.Location = new System.Drawing.Point(206, 17); + this.genBtn.Name = "genBtn"; + this.genBtn.Size = new System.Drawing.Size(85, 61); + this.genBtn.TabIndex = 2; + this.genBtn.Text = "Generate"; + this.genBtn.UseVisualStyleBackColor = true; + this.genBtn.Click += new System.EventHandler(this.genBtn_Click); + // + // statusLb + // + this.statusLb.AutoSize = true; + this.statusLb.Location = new System.Drawing.Point(12, 86); + this.statusLb.Name = "statusLb"; + this.statusLb.Size = new System.Drawing.Size(0, 13); + this.statusLb.TabIndex = 3; + // + // SPRGenerator + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(303, 140); + this.Controls.Add(this.statusLb); + this.Controls.Add(this.genBtn); + this.Controls.Add(this.prgBar); + this.Controls.Add(this.typeGrpBx); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "SPRGenerator"; + this.ShowInTaskbar = false; + this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "SPR Generator"; + this.typeGrpBx.ResumeLayout(false); + this.typeGrpBx.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.GroupBox typeGrpBx; + private System.Windows.Forms.RadioButton skillBtn; + private System.Windows.Forms.RadioButton itemBtn; + private System.Windows.Forms.RadioButton equipBtn; + private System.Windows.Forms.ProgressBar prgBar; + private System.Windows.Forms.Button genBtn; + private System.Windows.Forms.Label statusLb; + } +} \ No newline at end of file diff --git a/GUI/SPRGenerator.cs b/GUI/SPRGenerator.cs new file mode 100644 index 0000000..e2ac3c9 --- /dev/null +++ b/GUI/SPRGenerator.cs @@ -0,0 +1,258 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Data.SqlClient; +using System.Data.Common; +using System.IO; +using System.Windows.Forms; +using Grimoire.Structures; +using Grimoire.Configuration; +using Grimoire.DB; + +namespace Grimoire.GUI +{ + public partial class SPRGenerator : Form + { + string sprName = "01_equip.spr"; + string[] tableName = new string[] { "ItemResource" }; + string sqlQuery = "SELECT icon_file_name FROM dbo."; + string condition = " WHERE wear_type >= 0"; + Size defSize = new Size(34, 34); + bool ignoreSize = false; + + List sprEntries = new List(); + + List ignored = new List(); + + ConfigMan configMgr = Main.Instance.ConfigMan; + + public SPRGenerator() + { + InitializeComponent(); + } + + private void genBtn_Click(object sender, EventArgs e) + { + if (itemBtn.Checked) + { + sprName = "02_item.spr"; + condition = " WHERE wear_type < 0"; + } + else if (skillBtn.Checked) + { + sprName = "03_skill.spr"; + tableName = new string[] + { + "SkillResource", + "StateResource" + }; + condition = string.Empty; + defSize = new Size(20, 20); + ignoreSize = true; + } + + if (!ignoreSize) + ignoreSize = configMgr["IgnoreSize", "SPR"]; + + statusLb.ResetText(); + + loadEntries(); + } + + async void loadEntries() + { + DBHelper dbHelper = new DBHelper(configMgr); + string sqlCmd = null; + + foreach (string table in tableName) + { + statusLb.Text = $"Loading icons from dbo.{table}..."; + + sqlCmd = $"{sqlQuery}{table}{condition}"; + + if (!await dbHelper.OpenConnection()) + MessageBox.Show("Failed to connect to the Database!", "SQL Error", MessageBoxButtons.OK, MessageBoxIcon.Error); //TODO: review me? + + int rowCount = await dbHelper.Execute($"SELECT COUNT(icon_file_name) FROM dbo.{table}", DB.Enums.DbCmdType.Scalar); + DbDataReader dbRdr = await dbHelper.Execute(sqlCmd, DB.Enums.DbCmdType.Reader); + + if (dbRdr == null || !dbRdr.HasRows || rowCount <= 0) + MessageBox.Show($"Failed to load icons from {table}!", "Load Exception", MessageBoxButtons.OK, MessageBoxIcon.Error); + + prgBar.Maximum = rowCount; + + int idx = 0; + + while (dbRdr.Read()) + { + string name = dbRdr.GetString(0); + + if (string.IsNullOrEmpty(name)) + MessageBox.Show($"icon_file_name cannot be blank!", "Load Warning!", MessageBoxButtons.OK, MessageBoxIcon.Warning); + else + { + if (sprEntries.FindIndex(s => s.Name == name) == -1) + sprEntries.Add(new SprInfo(name)); + } + + if ((idx * 100 / rowCount) != ((idx - 1) * 100 / rowCount)) + prgBar.Value = idx; + + idx++; + } + + dbHelper.CloseConnection(); + + statusLb.Text = $"{sprEntries.Count} icons loaded!"; + + resetProgress(); + } + + compareEntries(); + } + + async void compareEntries() + { + string dumpDir = configMgr.GetDirectory("DumpDirectory", "Grim"); + + if (string.IsNullOrEmpty(dumpDir)) + { + MessageBox.Show("Dump Directory cannot be empty! Please fill it in properly in the settings menu and try again!", "Invalid Dump Directory", MessageBoxButtons.OK, MessageBoxIcon.Error); + + statusLb.ResetText(); + + resetProgress(); + + return; + } + + string jpgDir = $"{dumpDir}\\jpg\\"; + int total = sprEntries.Count; + int prg = 0; + + bool showWarnings = configMgr["ShowWarnings", "SPR"]; + + statusLb.Text = "Validating icon entries..."; + + prgBar.Maximum = total; + + for (int i = sprEntries.Count - 1; i >= 0; i--) + { + SprInfo sprInfo = sprEntries[i]; + + string filename = $"{jpgDir}{sprInfo.Frames[0]}"; + + if (File.Exists(filename)) + { + await Task.Run(() => { + using (Bitmap bmp = new Bitmap(filename)) + { + if (bmp != null) + { + Size size = bmp.Size; + + sprInfo.SetSize(bmp.Size); + + if (size != defSize) + { + if (!ignoreSize && showWarnings) + { + ignored.Add(sprInfo.Name); + sprEntries.Remove(sprInfo); + + MessageBox.Show($"Image size is invalid! {filename}\n\nImage Size: {size.Height},{size.Width}\nExpected Size: {defSize.Height},{defSize.Width}\n\nEntry has been removed!", "Invalid Image Size", MessageBoxButtons.OK, MessageBoxIcon.Warning); + } + } + } + else + { + MessageBox.Show($"Failed to load image {filename}", "Image Load Failed", MessageBoxButtons.OK, MessageBoxIcon.Error); + ignored.Add(sprInfo.Name); + sprEntries.Remove(sprInfo); + } + } + }); + } + else + { + ignored.Add(sprInfo.Name); + + if (showWarnings) + MessageBox.Show($"No matching image for {sprInfo.Name} located in the dump directory!\n\nEntry has been removed!", "Missing Image Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); + + sprEntries.Remove(sprInfo); + } + + prg = total - i; + + if ((prg * 100 / total) != ((prg - 1) * 100 / total)) + prgBar.Value = prg; + + total = sprEntries.Count; + prgBar.Maximum = total; + } + + statusLb.Text = $"{sprEntries.Count} icons verified!"; + + resetProgress(); + + save(); + } + + async void save() + { + string buildDir = configMgr.GetDirectory("BuildDirectory", "Grim"); + string sprPath = $"{buildDir}\\{sprName}"; + + statusLb.Text = $"Writing {sprName} to disk"; + + prgBar.Maximum = sprEntries.Count; + + using (StreamWriter sw = new StreamWriter(sprPath, false)) + { + for (int i = 0; i < sprEntries.Count; i++) + { + SprInfo sprInfo = sprEntries[i]; + + await Task.Run(() => { + sw.WriteLine(sprInfo.Name); + sw.WriteLine(sprInfo.FrameCount); + sw.WriteLine(sprInfo.Frames[0]); + sw.WriteLine($"{sprInfo.Height},{sprInfo.Width}"); + sw.WriteLine(sprInfo.Unused); + }); + + if ((i * 100 / sprEntries.Count) != ((i - 1) * 100 / sprEntries.Count)) + prgBar.Value = i; + } + } + + resetProgress(); + + System.Threading.Thread.Sleep(1000); + + statusLb.Text = $"{sprEntries.Count} icons written to {sprName} successfully!"; + + showIgnored(); + + statusLb.Text = string.Empty; + } + + void showIgnored() + { + using (MessageListBox msgListBox = new MessageListBox("Ignored Icons", "The following icons could not be verified and were ignored", ignored)) + msgListBox.ShowDialog(this); + } + + void resetProgress() + { + prgBar.Maximum = 100; + prgBar.Value = 0; + } + } +} diff --git a/GUI/SPRGenerator.resx b/GUI/SPRGenerator.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/GUI/SPRGenerator.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/GUI/XOREditor.Designer.cs b/GUI/XOREditor.Designer.cs new file mode 100644 index 0000000..d9c06b1 --- /dev/null +++ b/GUI/XOREditor.Designer.cs @@ -0,0 +1,275 @@ +namespace Grimoire.GUI +{ + partial class XOREditor + { + /// + /// 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.hexBox = new Be.Windows.Forms.HexBox(); + this.unKeyLb = new System.Windows.Forms.Label(); + this.menuStrip1 = new System.Windows.Forms.MenuStrip(); + this.ts_file = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_file_load = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_file_save = new System.Windows.Forms.ToolStripMenuItem(); + this.unKey_txtBox = new System.Windows.Forms.RichTextBox(); + this.ts_file_load_key = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_file_load_config = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_reset = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_file_load_def = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_def = new System.Windows.Forms.ToolStripMenuItem(); + this.resEncKeyLbl = new System.Windows.Forms.Label(); + this.ts_file_save_key = new System.Windows.Forms.ToolStripMenuItem(); + this.ts_file_save_config = new System.Windows.Forms.ToolStripMenuItem(); + this.hex_cms = new System.Windows.Forms.ContextMenuStrip(this.components); + this.hex_cms_clear = new System.Windows.Forms.ToolStripMenuItem(); + this.unkey_cms = new System.Windows.Forms.ContextMenuStrip(this.components); + this.unkey_cms_copy = new System.Windows.Forms.ToolStripMenuItem(); + this.hex_cms_copy = new System.Windows.Forms.ToolStripMenuItem(); + this.menuStrip1.SuspendLayout(); + this.hex_cms.SuspendLayout(); + this.unkey_cms.SuspendLayout(); + this.SuspendLayout(); + // + // hexBox + // + this.hexBox.ColumnInfoVisible = true; + this.hexBox.ContextMenuStrip = this.hex_cms; + this.hexBox.Font = new System.Drawing.Font("Segoe UI", 9F); + this.hexBox.LineInfoVisible = true; + this.hexBox.Location = new System.Drawing.Point(12, 45); + this.hexBox.Name = "hexBox"; + this.hexBox.SelectionBackColor = System.Drawing.Color.LightSteelBlue; + this.hexBox.ShadowSelectionColor = System.Drawing.Color.FromArgb(((int)(((byte)(100)))), ((int)(((byte)(60)))), ((int)(((byte)(188)))), ((int)(((byte)(255))))); + this.hexBox.Size = new System.Drawing.Size(641, 295); + this.hexBox.StringViewVisible = true; + this.hexBox.TabIndex = 0; + this.hexBox.UseFixedBytesPerLine = true; + this.hexBox.VScrollBarVisible = true; + // + // unKeyLb + // + this.unKeyLb.AutoSize = true; + this.unKeyLb.Location = new System.Drawing.Point(12, 343); + this.unKeyLb.Name = "unKeyLb"; + this.unKeyLb.Size = new System.Drawing.Size(123, 13); + this.unKeyLb.TabIndex = 2; + this.unKeyLb.Text = "unResourceEncodeKey:"; + // + // menuStrip1 + // + this.menuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.ts_file, + this.ts_reset, + this.ts_def}); + this.menuStrip1.Location = new System.Drawing.Point(0, 0); + this.menuStrip1.Name = "menuStrip1"; + this.menuStrip1.Size = new System.Drawing.Size(665, 24); + this.menuStrip1.TabIndex = 4; + this.menuStrip1.Text = "menuStrip1"; + // + // ts_file + // + this.ts_file.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.ts_file_load, + this.ts_file_save}); + this.ts_file.Name = "ts_file"; + this.ts_file.Size = new System.Drawing.Size(37, 20); + this.ts_file.Text = "File"; + // + // ts_file_load + // + this.ts_file_load.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.ts_file_load_key, + this.ts_file_load_config, + this.ts_file_load_def}); + this.ts_file_load.Name = "ts_file_load"; + this.ts_file_load.Size = new System.Drawing.Size(180, 22); + this.ts_file_load.Text = "Load"; + // + // ts_file_save + // + this.ts_file_save.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.ts_file_save_key, + this.ts_file_save_config}); + this.ts_file_save.Name = "ts_file_save"; + this.ts_file_save.Size = new System.Drawing.Size(180, 22); + this.ts_file_save.Text = "Save"; + // + // unKey_txtBox + // + this.unKey_txtBox.ContextMenuStrip = this.unkey_cms; + this.unKey_txtBox.Location = new System.Drawing.Point(12, 359); + this.unKey_txtBox.Name = "unKey_txtBox"; + this.unKey_txtBox.ReadOnly = true; + this.unKey_txtBox.Size = new System.Drawing.Size(641, 229); + this.unKey_txtBox.TabIndex = 5; + this.unKey_txtBox.Text = ""; + // + // ts_file_load_key + // + this.ts_file_load_key.Name = "ts_file_load_key"; + this.ts_file_load_key.Size = new System.Drawing.Size(180, 22); + this.ts_file_load_key.Text = "Key File"; + this.ts_file_load_key.Click += new System.EventHandler(this.ts_file_load_key_Click); + // + // ts_file_load_config + // + this.ts_file_load_config.Name = "ts_file_load_config"; + this.ts_file_load_config.Size = new System.Drawing.Size(180, 22); + this.ts_file_load_config.Text = "Config.json"; + this.ts_file_load_config.Click += new System.EventHandler(this.ts_file_load_config_Click); + // + // ts_reset + // + this.ts_reset.Name = "ts_reset"; + this.ts_reset.Size = new System.Drawing.Size(47, 20); + this.ts_reset.Text = "Reset"; + this.ts_reset.Click += new System.EventHandler(this.ts_reset_Click); + // + // ts_file_load_def + // + this.ts_file_load_def.Name = "ts_file_load_def"; + this.ts_file_load_def.Size = new System.Drawing.Size(180, 22); + this.ts_file_load_def.Text = "Default"; + this.ts_file_load_def.Click += new System.EventHandler(this.ts_file_load_def_Click); + // + // ts_def + // + this.ts_def.Name = "ts_def"; + this.ts_def.Size = new System.Drawing.Size(57, 20); + this.ts_def.Text = "Default"; + this.ts_def.Click += new System.EventHandler(this.ts_def_Click); + // + // resEncKeyLbl + // + this.resEncKeyLbl.AutoSize = true; + this.resEncKeyLbl.Location = new System.Drawing.Point(12, 29); + this.resEncKeyLbl.Name = "resEncKeyLbl"; + this.resEncKeyLbl.Size = new System.Drawing.Size(121, 13); + this.resEncKeyLbl.TabIndex = 6; + this.resEncKeyLbl.Text = "szResourceEncodeKey:"; + // + // ts_file_save_key + // + this.ts_file_save_key.Name = "ts_file_save_key"; + this.ts_file_save_key.Size = new System.Drawing.Size(180, 22); + this.ts_file_save_key.Text = "Key File"; + this.ts_file_save_key.Click += new System.EventHandler(this.ts_file_save_key_Click); + // + // ts_file_save_config + // + this.ts_file_save_config.Name = "ts_file_save_config"; + this.ts_file_save_config.Size = new System.Drawing.Size(180, 22); + this.ts_file_save_config.Text = "Config.json"; + this.ts_file_save_config.Click += new System.EventHandler(this.ts_file_save_config_Click); + // + // hex_cms + // + this.hex_cms.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.hex_cms_clear, + this.hex_cms_copy}); + this.hex_cms.Name = "hex_cms"; + this.hex_cms.Size = new System.Drawing.Size(181, 70); + // + // hex_cms_clear + // + this.hex_cms_clear.Name = "hex_cms_clear"; + this.hex_cms_clear.Size = new System.Drawing.Size(180, 22); + this.hex_cms_clear.Text = "Clear"; + this.hex_cms_clear.Click += new System.EventHandler(this.hex_cms_clear_Click); + // + // unkey_cms + // + this.unkey_cms.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.unkey_cms_copy}); + this.unkey_cms.Name = "unkey_cms"; + this.unkey_cms.Size = new System.Drawing.Size(103, 26); + // + // unkey_cms_copy + // + this.unkey_cms_copy.Name = "unkey_cms_copy"; + this.unkey_cms_copy.Size = new System.Drawing.Size(102, 22); + this.unkey_cms_copy.Text = "Copy"; + this.unkey_cms_copy.Click += new System.EventHandler(this.unkey_cms_copy_Click); + // + // hex_cms_copy + // + this.hex_cms_copy.Name = "hex_cms_copy"; + this.hex_cms_copy.Size = new System.Drawing.Size(180, 22); + this.hex_cms_copy.Text = "Copy"; + this.hex_cms_copy.Click += new System.EventHandler(this.hex_cms_copy_Click); + // + // XOREditor + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(665, 600); + this.Controls.Add(this.resEncKeyLbl); + this.Controls.Add(this.unKey_txtBox); + this.Controls.Add(this.unKeyLb); + this.Controls.Add(this.hexBox); + this.Controls.Add(this.menuStrip1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MainMenuStrip = this.menuStrip1; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "XOREditor"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "XOR Key Editor"; + this.menuStrip1.ResumeLayout(false); + this.menuStrip1.PerformLayout(); + this.hex_cms.ResumeLayout(false); + this.unkey_cms.ResumeLayout(false); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private Be.Windows.Forms.HexBox hexBox; + private System.Windows.Forms.Label unKeyLb; + private System.Windows.Forms.MenuStrip menuStrip1; + private System.Windows.Forms.ToolStripMenuItem ts_file; + private System.Windows.Forms.ToolStripMenuItem ts_file_load; + private System.Windows.Forms.ToolStripMenuItem ts_file_save; + private System.Windows.Forms.RichTextBox unKey_txtBox; + private System.Windows.Forms.ToolStripMenuItem ts_file_load_key; + private System.Windows.Forms.ToolStripMenuItem ts_file_load_config; + private System.Windows.Forms.ToolStripMenuItem ts_reset; + private System.Windows.Forms.ToolStripMenuItem ts_file_load_def; + private System.Windows.Forms.ToolStripMenuItem ts_def; + private System.Windows.Forms.Label resEncKeyLbl; + private System.Windows.Forms.ToolStripMenuItem ts_file_save_key; + private System.Windows.Forms.ToolStripMenuItem ts_file_save_config; + private System.Windows.Forms.ContextMenuStrip hex_cms; + private System.Windows.Forms.ToolStripMenuItem hex_cms_clear; + private System.Windows.Forms.ContextMenuStrip unkey_cms; + private System.Windows.Forms.ToolStripMenuItem unkey_cms_copy; + private System.Windows.Forms.ToolStripMenuItem hex_cms_copy; + } +} \ No newline at end of file diff --git a/GUI/XOREditor.cs b/GUI/XOREditor.cs new file mode 100644 index 0000000..e737a75 --- /dev/null +++ b/GUI/XOREditor.cs @@ -0,0 +1,242 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.IO; +using System.Windows.Forms; +using Be.Windows.Forms; + +namespace Grimoire.GUI +{ + public partial class XOREditor : Form + { + byte[] defXORKey = new byte[] + { + 0x77, 0xe8, 0x5e, 0xec, 0xb7, 0x4e, 0xc1, 0x87, 0x4f, 0xe6, 0xf5, 0x3c, 0x1f, 0xb3, 0x15, 0x43, + 0x6a, 0x49, 0x30, 0xa6, 0xbf, 0x53, 0xa8, 0x35, 0x5b, 0xe5, 0x9e, 0x0e, 0x41, 0xec, 0x22, 0xb8, + 0xd4, 0x80, 0xa4, 0x8c, 0xce, 0x65, 0x13, 0x1d, 0x4b, 0x08, 0x5a, 0x6a, 0xbb, 0x6f, 0xad, 0x25, + 0xb8, 0xdd, 0xcc, 0x77, 0x30, 0x74, 0xac, 0x8c, 0x5a, 0x4a, 0x9a, 0x9b, 0x36, 0xbc, 0x53, 0x0a, + 0x3c, 0xf8, 0x96, 0x0b, 0x5d, 0xaa, 0x28, 0xa9, 0xb2, 0x82, 0x13, 0x6e, 0xf1, 0xc1, 0x93, 0xa9, + 0x9e, 0x5f, 0x20, 0xcf, 0xd4, 0xcc, 0x5b, 0x2e, 0x16, 0xf5, 0xc9, 0x4c, 0xb2, 0x1c, 0x57, 0xee, + 0x14, 0xed, 0xf9, 0x72, 0x97, 0x22, 0x1b, 0x4a, 0xa4, 0x2e, 0xb8, 0x96, 0xef, 0x4b, 0x3f, 0x8e, + 0xab, 0x60, 0x5d, 0x7f, 0x2c, 0xb8, 0xad, 0x43, 0xad, 0x76, 0x8f, 0x5f, 0x92, 0xe6, 0x4e, 0xa7, + 0xd4, 0x47, 0x19, 0x6b, 0x69, 0x34, 0xb5, 0x0e, 0x62, 0x6d, 0xa4, 0x52, 0xb9, 0xe3, 0xe0, 0x64, + 0x43, 0x3d, 0xe3, 0x70, 0xf5, 0x90, 0xb3, 0xa2, 0x06, 0x42, 0x02, 0x98, 0x29, 0x50, 0x3f, 0xfd, + 0x97, 0x58, 0x68, 0x01, 0x8c, 0x1e, 0x0f, 0xef, 0x8b, 0xb3, 0x41, 0x44, 0x96, 0x21, 0xa8, 0xda, + 0x5e, 0x8b, 0x4a, 0x53, 0x1b, 0xfd, 0xf5, 0x21, 0x3f, 0xf7, 0xba, 0x68, 0x47, 0xf9, 0x65, 0xdf, + 0x52, 0xce, 0xe0, 0xde, 0xec, 0xef, 0xcd, 0x77, 0xa2, 0x0e, 0xbc, 0x38, 0x2f, 0x64, 0x12, 0x8d, + 0xf0, 0x5c, 0xe0, 0x0b, 0x59, 0xd6, 0x2d, 0x99, 0xcd, 0xe7, 0x01, 0x15, 0xe0, 0x67, 0xf4, 0x32, + 0x35, 0xd4, 0x11, 0x21, 0xc3, 0xde, 0x98, 0x65, 0xed, 0x54, 0x9d, 0x1c, 0xb9, 0xb0, 0xaa, 0xa9, + 0x0c, 0x8a, 0xb4, 0x66, 0x60, 0xe1, 0xff, 0x2e, 0xc8, 0x00, 0x43, 0xa9, 0x67, 0x37, 0xdb, 0x9c + }; + + byte[] xorKey = null; + + DynamicByteProvider provider = null; + + public XOREditor() + { + InitializeComponent(); + } + + private void ts_file_load_key_Click(object sender, EventArgs e) + { + using (OpenFileDialog ofDlg = new OpenFileDialog()) + { + if (ofDlg.ShowDialog(this) == DialogResult.OK) + xorKey = File.ReadAllBytes(ofDlg.FileName); + } + + if (xorKey != null && xorKey.Length > 0) + { + provider = new DynamicByteProvider(xorKey); + + if (provider != null) + set_provider(); + } + } + + private void ts_file_load_def_Click(object sender, EventArgs e) + { + clear_provider(); + + xorKey = defXORKey; + + if (xorKey != null && xorKey.Length > 0) + { + provider = new DynamicByteProvider(defXORKey); + + if (provider != null) + set_provider(); + } + } + + private void ts_file_load_config_Click(object sender, EventArgs e) + { + xorKey = Main.Instance.ConfigMan.GetByteArray("ModifiedXORKey"); + + if (xorKey != null && xorKey.Length > 0) + { + provider = new DynamicByteProvider(xorKey); + + if (provider != null) + set_provider(); + } + else + MessageBox.Show("No XOR key has been defined in the Config.json! Please load from key file or default.", "Nothing Loaded", MessageBoxButtons.OK, MessageBoxIcon.Warning); + } + + private void ts_reset_Click(object sender, EventArgs e) + { + clear_provider(); + + provider = new DynamicByteProvider(xorKey); + + if (provider != null) + set_provider(); + } + + private void ts_def_Click(object sender, EventArgs e) => ts_file_load_def_Click(this, null); + + private void ts_file_save_config_Click(object sender, EventArgs e) + { + if (provider != null && provider.Length > 0) + Main.Instance.ConfigMan.UpdateByteArray("ModifiedXORKey", provider.Bytes.ToArray()); + } + + private void ts_file_save_key_Click(object sender, EventArgs e) + { + string keyPath = $"{Directory.GetCurrentDirectory()}\\grimoire_xor_key"; + + if (provider != null && provider.Length > 0) + { + if (File.Exists(keyPath)) + File.Delete(keyPath); + + using (FileStream fs = File.Create(keyPath)) + { + byte[] buffer = provider.Bytes.ToArray(); + + fs.Write(buffer, 0, buffer.Length); + } + } + } + + private void Provider_Changed(object sender, EventArgs e) => generate_unKey(); + + void clear_provider() + { + if (provider != null) + { + provider.Bytes.Clear(); + provider = null; + hexBox.ByteProvider = null; + unKey_txtBox.Clear(); + } + } + + void set_provider() + { + provider.Changed += Provider_Changed; + + hexBox.ByteProvider = provider; + hexBox.Refresh(); + + generate_unKey(); + } + + void generate_unKey() + { + int colCount = 0; + string colStr = null; + int byteCount = 0; //3 per round + string uintStr = null; + string outStr = null; + + for (int i = 0; i < provider.Length; i++) + { + byte b = provider.Bytes[i]; + + string byteStr = b.ToString("X2").ToLower(); + char[] byteArray = byteStr.ToCharArray(); + Array.Reverse(byteArray); + + uintStr += new string(byteArray); + byteCount++; + + if (byteCount == 4) + { + byteCount = 0; + + char[] uintArray = uintStr.ToCharArray(); + Array.Reverse(uintArray); + + colStr = string.Format("0x{0}, ", new string(uintArray)); + + if (colCount++ == 3) + { + colCount = 0; + colStr += "\n"; + outStr += colStr; + colStr = null; + } + else + outStr += colStr; + + + uintStr = null; + } + } + + outStr = outStr.Remove(outStr.Length - 3, 1); + + unKey_txtBox.Text = outStr; + } + + private void hex_cms_clear_Click(object sender, EventArgs e) + { + if (provider != null) + clear_provider(); + } + + private void unkey_cms_copy_Click(object sender, EventArgs e) + { + if (!string.IsNullOrEmpty(unKey_txtBox.Text)) + Clipboard.SetText(unKey_txtBox.Text); + } + + private void hex_cms_copy_Click(object sender, EventArgs e) + { + string byteStr = null; + string outStr = null; + string curRowStr = null; + int curCol = 0; + + for (int i = 0; i <= provider.Length; i++) + { + if (i == provider.Length) + { + outStr = outStr.Remove(outStr.Length - 2, 1); + break; + } + + byteStr = $"0x{provider.Bytes[i].ToString("x2")}"; + curRowStr += string.Format("{0},", byteStr); + curCol++; + + if (curCol == 16) + { + outStr += string.Format("{0}\n", curRowStr); + curRowStr = null; + curCol = 0; + } + } + + Clipboard.SetText(outStr); + } + } +} diff --git a/GUI/XOREditor.resx b/GUI/XOREditor.resx new file mode 100644 index 0000000..27b5dfe --- /dev/null +++ b/GUI/XOREditor.resx @@ -0,0 +1,129 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 132, 17 + + + 17, 17 + + + 229, 17 + + \ No newline at end of file diff --git a/Grimoire.csproj b/Grimoire.csproj index 5540c56..693131a 100644 --- a/Grimoire.csproj +++ b/Grimoire.csproj @@ -46,11 +46,17 @@ bin\x64\Release\ - - packages\Microsoft.Data.SqlClient.1.1.2\lib\net46\Microsoft.Data.SqlClient.dll + + packages\Be.Windows.Forms.HexBox.1.6.1\lib\net40\Be.Windows.Forms.HexBox.dll - - packages\Microsoft.Identity.Client.4.12.0\lib\net45\Microsoft.Identity.Client.dll + + packages\Microsoft.Data.SqlClient.2.0.0\lib\net46\Microsoft.Data.SqlClient.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.Data.Tools.Sql.BatchParser.dll + + + packages\Microsoft.Identity.Client.4.14.0\lib\net45\Microsoft.Identity.Client.dll packages\Microsoft.IdentityModel.JsonWebTokens.6.5.1\lib\net461\Microsoft.IdentityModel.JsonWebTokens.dll @@ -75,12 +81,44 @@ False ..\3rd Party\Microsoft.SqlServer.BatchParserClient.dll + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.ConnectionInfo.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.Dmf.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.Dmf.Common.dll + ..\3rd Party\Microsoft.SqlServer.Management.Common.dll - - False - ..\3rd Party\Microsoft.SqlServer.SqlClrProvider.dll + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.Management.RegisteredServers.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.Management.Sdk.Sfc.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.PolicyEnum.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.RegSvrEnum.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.ServiceBrokerEnum.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.Smo.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.SmoExtended.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.SqlClrProvider.dll + + + packages\Microsoft.SqlServer.SqlManagementObjects.161.46041.41\lib\net461\Microsoft.SqlServer.SqlEnum.dll packages\MoonSharp.2.0.0.0\lib\net40-client\MoonSharp.Interpreter.dll @@ -141,6 +179,8 @@ + + Form @@ -154,6 +194,12 @@ DataRebuild.cs + + Form + + + DumpUpdater.cs + Form @@ -196,12 +242,24 @@ Setup.cs + + Form + + + SPRGenerator.cs + Form StructureEditor.cs + + Form + + + XOREditor.cs + @@ -209,6 +267,7 @@ + @@ -241,7 +300,6 @@ - Form @@ -290,6 +348,9 @@ LogViewer.cs + + DumpUpdater.cs + Main.cs @@ -303,9 +364,15 @@ Setup.cs + + SPRGenerator.cs + StructureEditor.cs + + XOREditor.cs + ResXFileCodeGenerator Resources.Designer.cs @@ -367,16 +434,16 @@ - - - - This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. - - - + + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + \ No newline at end of file diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs index 1f92f70..f5aa872 100644 --- a/Properties/AssemblyInfo.cs +++ b/Properties/AssemblyInfo.cs @@ -32,5 +32,5 @@ // 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("0.4.9.1")] -[assembly: AssemblyFileVersion("0.4.9.1")] +[assembly: AssemblyVersion("0.4.10.1")] +[assembly: AssemblyFileVersion("0.4.10.1")] diff --git a/Structures/Settings.cs b/Structures/Settings.cs index 2cec03f..3cd46bb 100644 --- a/Structures/Settings.cs +++ b/Structures/Settings.cs @@ -40,11 +40,14 @@ public Tabs.Style DefaultStyle [Description("The password used to connect to the world database. Leave blank if Trusted Connection is true"), Category("Database"), DisplayName("Arcadia Password")] public string WorldPass { get => configMan["WorldPass"]; set => configMan["WorldPass"] = value; } + [Description("Determines if the target table of the save operation will be backed up before inserting the .rdb data by creating a script (.sql) of the tables data in the /scripts/ folder"), Category("Database"), DisplayName("Backup Table")] + public bool BackupTable { get => configMan["Backup", "DB"]; set => configMan["Backup", "DB"] = value; } + [Description("Determines if the target table of any SQL save operation will be dropped and recreated or truncated before inserting the .rdb data"), Category("Database"), DisplayName("Drop Table")] public bool DropTable { get => configMan["DropOnExport"]; set => configMan["DropOnExport"] = value; } - [Description("Determines if the target table of the save operation will be backed up before inserting the .rdb data by creating a script (.sql) of the tables data in the /scripts/ folder"), Category("Database"), DisplayName("Backup Table")] - public bool BackupTable { get => configMan["Backup", "DB"]; set => configMan["Backup", "DB"] = value; } + [Description("Directory where sql related scripts will be stored."), Category("Database"), DisplayName("Scripts Directory")] + public string ScriptsDirectory { get => configMan["ScriptsDirectory", "DB"]; set => configMan["ScriptsDirectory", "DB"] = value; } [Description("Determines the period of time (in seconds) a SQL Connection attempt will last before timing out (expiring)."), Category("Database"), DisplayName("Connection Timeout")] public int ConnTimeout { get => (int)configMan["Timeout", "DB"]; set => configMan["Timeout", "DB"] = value; } @@ -52,6 +55,11 @@ public Tabs.Style DefaultStyle [Description("If defined, this is where any exported/built files will be placed. If not defined Grimoire will use/create the 'Output' folder."), Category("Data/RDB Utility"), DisplayName("Build Directory"), EditorAttribute(typeof(FolderNameEditor), typeof(UITypeEditor))] public string BuildDirectory { get => configMan["BuildDirectory", "Grim"]; set => configMan["BuildDirectory", "Grim"] = value; } + // SPR / Dump utilities + + [Description("Directory where a previously generated data dump is located"), DisplayName("Dump Directory"), Category("SPR Generator / Dump Updater"), EditorAttribute(typeof(FolderNameEditor), typeof(UITypeEditor))] + public string DumpDirectory { get => configMan["DumpDirectory", "Grim"]; set => configMan["DumpDirectory", "Grim"] = value; } + // data [Description("The default directory displayed when opening local files in the Data Utility"), Category("Data Utility"), DisplayName("Default Directory"), EditorAttribute(typeof(FolderNameEditor), typeof(UITypeEditor))] public string DataLoadDirectory { get => configMan["LoadDirectory", "Data"]; set => configMan["LoadDirectory", "Data"] = value; } @@ -59,29 +67,12 @@ public Tabs.Style DefaultStyle [Description("Determines if Grimoire will use a modified xor encryption key to load/alter client data files"), Category("Data Utility"), DisplayNameAttribute("Use Modified XOR Key")] public bool UseModifiedXOR { get => configMan["UseModifiedXOR"]; set => configMan["UseModifiedXOR"] = value; } - [Description("If UseModifiedXORKey is true, this key will be used in Data.xxx importing and Data.000 Load/Save operations"), Category("Data Utility"), DisplayName("Modified XOR Key")] - public byte[] ModifiedXORKey - { - get - { - int[] nKeyArray = configMan["ModifiedXORKey"].ToArray(); - byte[] bKeyArray = new byte[nKeyArray.Length]; - - for (int i = 0; i < nKeyArray.Length; i++) - bKeyArray[i] = (byte)nKeyArray[i]; - - return bKeyArray; - } - set - { - int[] nKeyArray = new int[value.Length]; - - for (int i = 0; i < value.Length; i++) - nKeyArray[i] = (int)value[i]; - - configMan["ModifiedXORKey"] = nKeyArray; - } - } + //[Description("If UseModifiedXORKey is true, this key will be used in Data.xxx importing and Data.000 Load/Save operations"), Category("Data Utility"), DisplayName("Modified XOR Key")] + //public byte[] ModifiedXORKey //Because JSON must store the key as int array, we must convert it + //{ + // get => configMan.GetByteArray("ModifiedXORKey"); + // set => configMan.UpdateByteArray("ModifiedXORKey", value); + //} [Description("Determines if files like data.000-008 will be backed up before any changes are made to them. (RECOMMENDED)"), Category("Data Utility"), DisplayName("Backups")] public bool Backups @@ -155,6 +146,24 @@ public bool UseASCII [Description("Determines if the flag selections are reset when changing flag lists!"), DisplayName("Clear on List Changed"), Category("Flag Editor")] public bool ClearOnChange { get => configMan["ClearOnChange", "Flag"]; set => configMan["ClearOnChange", "Flag"] = value; } + // Dump Updater + + [Description("Determines if existing files (in the dump) will be overwritten (without warning) by files being copied into it."), DisplayName("Overwrite Existing Files"), Category("Dump Updater")] + public bool OverwriteExisting { get => configMan["OverwriteExisting", "DumpUpdater"]; set => configMan["OverwriteExisting", "DumpUpdater"] = value; } + + // Spr Generator + + [Description("Determines if images whose size does not match the expected size will be processed"), DisplayName("Ignore Invalid Size"), Category("SPR Generator")] + public bool IgnoreSize { get => configMan["IgnoreSize", "SPR"]; set => configMan["IgnoreSize", "SPR"] = value; } + + [Description("Determines if a warning will be shown to the caller during generating"), DisplayName("Show Warnings"), Category("SPR Generator")] + public bool ShowWarnings { get => configMan["ShowWarnings", "SPR"]; set => configMan["ShowWarnings", "SPR"] = value; } + + [Description("Determines if unverified/ignored spr icons will be listed at the end of generating"), DisplayName("Show Ignored"), Category("SPR Generator")] + public bool ShowIgnored { get => configMan["ShowIgnored", "SPR"]; set => configMan["ShowIgnored", "SPR"] = value; } + + // locale + [Description("Determines the displayed language of Grimoire"), DisplayName("Locale"), Category("Language")] public string Locale { get => configMan["Locale", "Localization"]; set => configMan["Locale", "Localization"] = value; } diff --git a/Structures/SprInfo.cs b/Structures/SprInfo.cs new file mode 100644 index 0000000..0ed4cd9 --- /dev/null +++ b/Structures/SprInfo.cs @@ -0,0 +1,53 @@ +using System.Drawing; + +namespace Grimoire.Structures +{ + public class SprInfo + { + public SprInfo(string name) + { + Name = name; + FrameCount = 1; + Frames = new string[1] { $"{name}.jpg" }; + size = new Size(0, 0); + } + + public string Name; + public int FrameCount; + public string[] Frames; + + Size size; + + public int Height + { + get + { + if (size != null) + return size.Height; + + return 0; + } + } + + public int Width + { + get + { + if (size != null) + return size.Width; + + return 0; + } + } + + public int Unused => 0; + + public void SetSize(int height, int width) + { + size.Height = height; + size.Width = width; + } + + public void SetSize(Size size) => this.size = size; + } +} diff --git a/Tabs/Manager.cs b/Tabs/Manager.cs index 6ad0543..689bd3d 100644 --- a/Tabs/Manager.cs +++ b/Tabs/Manager.cs @@ -263,6 +263,10 @@ public void Clear() DataTab.Clear(); DataCore.Clear(); break; + + case Style.HASHER: + HashTab.Clear(); + break; } lManager.Enter(Sender.MANAGER, Level.NOTICE,"Tab: {0} contents have been cleared.", Page.Text); diff --git a/Tabs/Styles/Data.cs b/Tabs/Styles/Data.cs index cd77b95..3dcf079 100644 --- a/Tabs/Styles/Data.cs +++ b/Tabs/Styles/Data.cs @@ -105,19 +105,6 @@ private bool tab_disabled #region Constructors - public Data() - { - InitializeComponent(); - - lManager = Logs.Manager.Instance; - tManager = Tabs.Manager.Instance; - configMan = GUI.Main.Instance.ConfigMan; - - initializeCore(); - gridUtils = new Utilities.Grid(); - localize(); - } - public Data(string key) { InitializeComponent(); @@ -169,6 +156,12 @@ public async void TS_File_New_Click(object sender, EventArgs e) string buildDirectory = configMan.GetDirectory("BuildDirectory", "Grim"); + if (!await check_locations(dumpDirectory).ConfigureAwait(true)) + { + lManager.Enter(Sender.DATA, Level.ERROR, "There are unresolved issues with your dump structure! Please verify that files are in their proper extension folder (e.g. .nfe in /nfe/ folder!)"); + return; + } + lManager.Enter(Sender.DATA, Level.NOTICE, "Building new client to:\n\t-{0}", buildDirectory); tab_disabled = true; @@ -180,15 +173,7 @@ await Task.Run(() => { core.BuildDataFiles(dumpDirectory, buildDirectory); }); - } - catch (Exception ex) - { - MessageBox.Show(ex.Message, "Build Exception", MessageBoxButtons.OK, MessageBoxIcon.Error); - lManager.Enter(Sender.DATA, Level.ERROR, ex); - return; - } - finally - { + string msg = "Client build completed!"; MessageBox.Show(msg, "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); lManager.Enter(Sender.DATA, Level.NOTICE, msg); @@ -200,6 +185,12 @@ await Task.Run(() => core.Backups = true; } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Build Exception", MessageBoxButtons.OK, MessageBoxIcon.Error); + lManager.Enter(Sender.DATA, Level.ERROR, ex); + return; + } ts_status.Text = string.Empty; @@ -601,6 +592,63 @@ await Task.Run(() => { extStatus.ResetText(); } + async Task check_locations(string dir) + { + string[] extDirs = Directory.GetDirectories(dir); + + ts_progress.Maximum = extDirs.Length; + + for (int extIdx = 0; extIdx < extDirs.Length; extIdx++) + { + string extDir = extDirs[extIdx]; + + //check if dir is 2 characters long (e.g. .db/.fx) + int extOffset = 0; + extOffset = (extDir[extDir.Length - 3] == '\\') ? 2 : 3; + + string dirExt = extDir.Substring(extDir.Length - extOffset); + + ts_status.Text = $"Checking directory: {extDirs[extIdx]}..."; + + string[] dirFiles = Directory.GetFiles(extDirs[extIdx]); + + for (int dirFileIdx = 0; dirFileIdx < dirFiles.Length; dirFileIdx++) + { + string name = Path.GetFileName(dirFiles[dirFileIdx]); + + extOffset = (name[name.Length - 3] == '.') ? 2 : 3; + string ext = name.Substring(name.Length - extOffset); + + if (ext != dirExt) + { + if (MessageBox.Show($"File: {name} does not belong to the directory: /{dirExt}/\n\nWould you like to move it", "Directory Mistmatch Found", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) + { + string destName = $"{dir}//{ext}//{name}"; + string sourceName = $"{extDir}//{name}"; + + if (File.Exists(destName)) + if (MessageBox.Show($"A file with the same name already exists in the destination folder!\n\nWould you like to delete it?", "Duplicate File Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.Yes) + File.Delete(destName); + else + return false; + + File.Move(sourceName, destName); + } + else + return false; + } + } + + ts_progress.Value = extIdx; + } + + ts_status.Text = ""; + ts_progress.Maximum = 100; + ts_progress.Value = 0; + + return true; + } + private async void insert_files(string[] filePaths) { using (GUI.MessageListBox msgbox = new GUI.MessageListBox("Review Files", "You are about to import the following files!\r\n\r\nAre you sure you want to do that?", filePaths)) @@ -612,25 +660,30 @@ private async void insert_files(string[] filePaths) try { - foreach (string filePath in filePaths) + tab_disabled = true; + + if (filePaths.Length == 1) { - tab_disabled = true; - string msg = string.Format("Importing: {0}...", Path.GetFileName(filePath)); + string path = filePaths[0]; + string msg = $"Importing: {Path.GetFileName(path)}"; ts_status.Text = msg; lManager.Enter(Sender.DATA, Level.NOTICE, msg); - await Task.Run(() => { core.ImportFileEntry(filePath); }); + await Task.Run(() => { core.ImportFileEntry(path); }); } + else if (filePaths.Length > 1) + await Task.Run(() => { core.ImportFileEntries(filePaths); }); + + core.Save(); } catch (Exception ex) { + Core_CurrentProgressReset(null, new CurrentResetArgs(false)); MessageBox.Show(ex.Message, "Import Exception", MessageBoxButtons.OK, MessageBoxIcon.Error); lManager.Enter(Sender.DATA, Level.ERROR, ex); } finally { - core.Save(); - tab_disabled = false; ts_status.Text = string.Empty; } diff --git a/Tabs/Styles/Hasher.cs b/Tabs/Styles/Hasher.cs index 9b67157..0476f60 100644 --- a/Tabs/Styles/Hasher.cs +++ b/Tabs/Styles/Hasher.cs @@ -215,6 +215,7 @@ private string HandleAscii(string filename) string convertedName = StringCipher.IsEncoded(filename) ? StringCipher.Decode(filename) : filename; string fileWithoutExt = Path.GetFileNameWithoutExtension(convertedName); string ext = Path.GetExtension(convertedName); + if (optAppend_ascii_rBtn.Checked) if (!convertedName.Contains("(ascii)")) return $"{fileWithoutExt}(ascii){ext}"; @@ -226,6 +227,8 @@ private string HandleAscii(string filename) return convertedName; } + internal void Clear() => fileGrid.Rows.Clear(); + private void localize() { xMan.Localize(this, Localization.Enums.SenderType.Tab); diff --git a/Tabs/Styles/RDB.Designer.cs b/Tabs/Styles/RDB.Designer.cs index 404fd8b..86c4429 100644 --- a/Tabs/Styles/RDB.Designer.cs +++ b/Tabs/Styles/RDB.Designer.cs @@ -49,12 +49,13 @@ private void InitializeComponent() this.ts_struct_list = new System.Windows.Forms.ToolStripComboBox(); this.ts_struct_status = new System.Windows.Forms.ToolStripLabel(); this.toolStripSeparator3 = new System.Windows.Forms.ToolStripSeparator(); - this.ts_prog = new System.Windows.Forms.ToolStripProgressBar(); this.ts_save_enc = new System.Windows.Forms.ToolStripButton(); this.ts_save_w_ascii = new System.Windows.Forms.ToolStripButton(); this.toolStripSeparator4 = new System.Windows.Forms.ToolStripSeparator(); this.grid_cs = new System.Windows.Forms.ContextMenuStrip(this.components); this.grid_cs_open_flag_editor = new System.Windows.Forms.ToolStripMenuItem(); + this.statusLb = new System.Windows.Forms.Label(); + this.ts_prog = new System.Windows.Forms.ProgressBar(); ((System.ComponentModel.ISupportInitialize)(this.grid)).BeginInit(); this.ts.SuspendLayout(); this.grid_cs.SuspendLayout(); @@ -73,7 +74,7 @@ private void InitializeComponent() this.grid.MultiSelect = false; this.grid.Name = "grid"; this.grid.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.CellSelect; - this.grid.Size = new System.Drawing.Size(780, 428); + this.grid.Size = new System.Drawing.Size(780, 390); this.grid.TabIndex = 17; this.grid.VirtualMode = true; this.grid.CellMouseClick += new System.Windows.Forms.DataGridViewCellMouseEventHandler(this.grid_CellMouseClick); @@ -93,7 +94,6 @@ private void InitializeComponent() this.ts_struct_list, this.ts_struct_status, this.toolStripSeparator3, - this.ts_prog, this.ts_save_enc, this.ts_save_w_ascii, this.toolStripSeparator4}); @@ -232,12 +232,6 @@ private void InitializeComponent() this.toolStripSeparator3.Name = "toolStripSeparator3"; this.toolStripSeparator3.Size = new System.Drawing.Size(6, 25); // - // ts_prog - // - this.ts_prog.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right; - this.ts_prog.Name = "ts_prog"; - this.ts_prog.Size = new System.Drawing.Size(75, 22); - // // ts_save_enc // this.ts_save_enc.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Text; @@ -277,10 +271,29 @@ private void InitializeComponent() this.grid_cs_open_flag_editor.Text = "Open w/ Flag Editor"; this.grid_cs_open_flag_editor.Click += new System.EventHandler(this.grid_cs_open_flag_editor_Click); // + // statusLb + // + this.statusLb.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left))); + this.statusLb.AutoSize = true; + this.statusLb.Location = new System.Drawing.Point(3, 430); + this.statusLb.Name = "statusLb"; + this.statusLb.Size = new System.Drawing.Size(0, 13); + this.statusLb.TabIndex = 26; + // + // ts_prog + // + this.ts_prog.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.ts_prog.Location = new System.Drawing.Point(677, 422); + this.ts_prog.Name = "ts_prog"; + this.ts_prog.Size = new System.Drawing.Size(100, 23); + this.ts_prog.TabIndex = 27; + // // rdbTab // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.ts_prog); + this.Controls.Add(this.statusLb); this.Controls.Add(this.ts); this.Controls.Add(this.grid); this.Name = "rdbTab"; @@ -310,7 +323,6 @@ private void InitializeComponent() private System.Windows.Forms.ToolStripComboBox ts_struct_list; private System.Windows.Forms.ToolStripLabel ts_struct_status; private System.Windows.Forms.ToolStripSeparator toolStripSeparator3; - private System.Windows.Forms.ToolStripProgressBar ts_prog; private System.Windows.Forms.ToolStripComboBox ts_enc_list; private System.Windows.Forms.DataGridView grid; private System.Windows.Forms.ToolStripButton ts_save_enc; @@ -321,5 +333,7 @@ private void InitializeComponent() private System.Windows.Forms.ToolStripMenuItem ts_save_file_sql; private System.Windows.Forms.ContextMenuStrip grid_cs; private System.Windows.Forms.ToolStripMenuItem grid_cs_open_flag_editor; + private System.Windows.Forms.Label statusLb; + private System.Windows.Forms.ProgressBar ts_prog; } } diff --git a/Tabs/Styles/RDB.cs b/Tabs/Styles/RDB.cs index 2cb9cd3..3f79838 100644 --- a/Tabs/Styles/RDB.cs +++ b/Tabs/Styles/RDB.cs @@ -16,7 +16,6 @@ namespace Grimoire.Tabs.Styles { - //TODO: Correct encoding public partial class rdbTab : UserControl { #region Properties @@ -33,6 +32,7 @@ public partial class rdbTab : UserControl readonly Tabs.Utilities.Grid gridUtil; readonly Stopwatch actionSW = new Stopwatch(); XmlManager xMan = XmlManager.Instance; + DBHelper db = null; bool structLoaded { get { return (ts_struct_list.SelectedIndex != -1); } } readonly string buildDir = string.Empty; @@ -60,7 +60,10 @@ public int ProgressVal set => Invoke(new MethodInvoker(delegate { ts_prog.Value = value; })); } - public string Status { get => ts_struct_status.Text; set => ts_struct_status.Text = value; } + public string Status + { + set => Invoke(new MethodInvoker(delegate { statusLb.Text = value; })); + } public bool UseASCII { @@ -93,12 +96,49 @@ private void rdbTab_Load(object sender, EventArgs e) loadEncodings(); loadStructs(); setChecks(); + configureDB(); + core.ProgressMaxChanged += (o, x) => { ProgressMax = x.Maximum; }; core.ProgressValueChanged += (o, x) => { ProgressVal = x.Value; }; core.MessageOccured += (o, x) => { + Status = x.Message; lManager.Enter(Sender.RDB, Level.WARNING, x.Message); }; + + } + + private void configureDB() + { + DbConType sqlEngine = (DbConType)configMan["Engine", "DB"]; + db = new DBHelper(configMan, sqlEngine); + + db.ProgressMaxSet += (o, x) => + { + ProgressMax = x.Maximum; + + if (x.Message != null) + Status = x.Message; + }; + + db.ProgressValueSet += (o, x) => + { + ProgressVal = x.Value; + + if (x.Message != null) + Status = x.Message; + }; + + db.ProgressReset += (o, x) => + { + ProgressMax = 100; + ProgressVal = 0; + statusLb.ResetText(); + }; + + db.Message += (o, x) => Status = x.Message; + + db.Error += (o, x) => MessageBox.Show(x.Message, "SQL Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } private void setChecks() @@ -185,9 +225,7 @@ private async void ts_load_sql_Click(object sender, EventArgs e) } } - DbConType sqlEngine = (DbConType)configMan["Engine", "DB"]; - DBHelper dbHelper = new DBHelper(configMan, sqlEngine); - Row[] table_data = await dbHelper.ReadTable(tablename); + Row[] table_data = await db.ReadTable(tablename); if (table_data.Length == 0) { @@ -229,7 +267,8 @@ private async void ts_save_sql_Click(object sender, EventArgs e) case DialogResult.Yes: using (GUI.InputBox input = new GUI.InputBox("Enter desired table name", false)) { - if (input.ShowDialog(this) != DialogResult.OK) { return; } + if (input.ShowDialog(this) != DialogResult.OK) + return; lManager.Enter(Sender.RDB, Level.WARNING, "User opted to provide Table name for save operation.\n\t- Table name provided: {0}", input.Value); tablename = input.Value; @@ -239,9 +278,9 @@ private async void ts_save_sql_Click(object sender, EventArgs e) } } - DbConType sqlEngine = (DbConType)configMan["Engine", "DB"]; - DBHelper dbHelper = new DBHelper(configMan, sqlEngine); - await dbHelper.WriteTable(tablename, tManager.RDBCore.Rows); + + + await db.WriteTable(tablename, tManager.RDBCore.Rows); lManager.Enter(Sender.RDB, Level.NOTICE, "{0} rows were saved to table: {1} from tab: {2}", tManager.RDBCore.RowCount, tablename, tManager.Text); diff --git a/packages.config b/packages.config index 13e1d25..54c40cb 100644 --- a/packages.config +++ b/packages.config @@ -1,13 +1,15 @@  - - - + + + + +