diff --git a/ChanSort.Api/ChanSort.Api.csproj b/ChanSort.Api/ChanSort.Api.csproj index c68f484..e564e4b 100644 --- a/ChanSort.Api/ChanSort.Api.csproj +++ b/ChanSort.Api/ChanSort.Api.csproj @@ -83,6 +83,7 @@ Resources.resx + diff --git a/ChanSort.Api/Model/LookupData.cs b/ChanSort.Api/Model/LookupData.cs index 1594e63..c6fc7d0 100644 --- a/ChanSort.Api/Model/LookupData.cs +++ b/ChanSort.Api/Model/LookupData.cs @@ -206,10 +206,24 @@ namespace ChanSort.Api } #endregion - #region GetDvbtChannel() - public object GetDvbtChannel(decimal freq) + #region GetDvbtTransponder() + public int GetDvbtTransponder(decimal freq) { - return ((int) (freq - 106)/8); + return (int)(freq - 106)/8; + } + #endregion + + #region GetDvbtFrequencyForTransponder() + public decimal GetDvbtFrequenyForTransponder(int transponder) + { + return transponder * 8 + 106; + } + #endregion + + #region GetDvbtFrequencyForChannel() + public decimal GetDvbtFrequenyForChannel(int channel) + { + return channel * 8 + 306; } #endregion } diff --git a/ChanSort.Api/Utils/BrowserHelper.cs b/ChanSort.Api/Utils/BrowserHelper.cs new file mode 100644 index 0000000..95e3ee3 --- /dev/null +++ b/ChanSort.Api/Utils/BrowserHelper.cs @@ -0,0 +1,43 @@ +using System.IO; + +namespace ChanSort +{ + public static class BrowserHelper + { + public static void OpenUrl(string url) + { + OpenHtml(@" + + + + +"); + } + + public static void OpenMail(string url) + { + OpenHtml(@" + + + + +"); + } + + public static void OpenHtml(string html) + { + try + { + string fileName = Path.GetTempFileName() + ".html"; + File.WriteAllText(fileName, html); + System.Diagnostics.Process.Start(fileName); + } + catch + { + } + } + } +} diff --git a/ChanSort.Api/Utils/MappingPool.cs b/ChanSort.Api/Utils/MappingPool.cs index e0653ca..41a5ee8 100644 --- a/ChanSort.Api/Utils/MappingPool.cs +++ b/ChanSort.Api/Utils/MappingPool.cs @@ -6,7 +6,7 @@ namespace ChanSort.Api public class MappingPool where T : DataMapping { private const string ERR_unknownACTChannelDataLength = "Configuration doesn't contain a {0} data mapping for length {1}"; - private readonly Dictionary mappings = new Dictionary(); + private readonly Dictionary mappings = new Dictionary(); private readonly string caption; public MappingPool(string caption) @@ -14,19 +14,30 @@ namespace ChanSort.Api this.caption = caption; } - public void AddMapping(int dataLength, T mapping) + public void AddMapping(int dataLength, T mapping) { - mappings[dataLength] = mapping; + this.AddMapping(dataLength.ToString(), mapping); + } + + public void AddMapping(string id, T mapping) + { + this.mappings.Add(id, mapping); } public T GetMapping(int dataLength, bool throwException = true) { - if (dataLength == 0) + return this.GetMapping(dataLength.ToString(), throwException); + } + + public T GetMapping(string id, bool throwException = true) + { + if (id == "0" || string.IsNullOrEmpty(id)) return null; T mapping; - if (!mappings.TryGetValue(dataLength, out mapping) && throwException) - throw new FileLoadException(string.Format(ERR_unknownACTChannelDataLength, this.caption, dataLength)); + if (!mappings.TryGetValue(id, out mapping) && throwException) + throw new FileLoadException(string.Format(ERR_unknownACTChannelDataLength, this.caption, id)); + return mapping; } } diff --git a/ChanSort.Loader.Panasonic/DbChannel.cs b/ChanSort.Loader.Panasonic/DbChannel.cs index 69e5bd3..9e09310 100644 --- a/ChanSort.Loader.Panasonic/DbChannel.cs +++ b/ChanSort.Loader.Panasonic/DbChannel.cs @@ -102,7 +102,7 @@ namespace ChanSort.Loader.Panasonic { freq /= 1000; this.FreqInMhz = freq; - this.ChannelOrTransponder = LookupData.Instance.GetDvbtChannel(freq).ToString(); + this.ChannelOrTransponder = LookupData.Instance.GetDvbtTransponder(freq).ToString(); this.Satellite = (this.SignalSource & SignalSource.Antenna) != 0 ? "DVB-T" : "DVB-C"; } diff --git a/ChanSort.Loader.ScmFile/DigitalChannel.cs b/ChanSort.Loader.ScmFile/DigitalChannel.cs index 1cf1885..4be9300 100644 --- a/ChanSort.Loader.ScmFile/DigitalChannel.cs +++ b/ChanSort.Loader.ScmFile/DigitalChannel.cs @@ -19,9 +19,9 @@ namespace ChanSort.Loader.Samsung int transp = data.GetByte(_ChannelOrTransponder); decimal freq = transpFreq.TryGet(transp); if (freq == 0) - freq = transp*8 + 106; + freq = transp*8 + 106; // (106 = DVB-C; DVB-T=306?) - this.ChannelOrTransponder = LookupData.Instance.GetDvbtChannel(freq).ToString(); + this.ChannelOrTransponder = LookupData.Instance.GetDvbtTransponder(freq).ToString(); this.FreqInMhz = freq; } } diff --git a/ChanSort.Loader.TllFile/ChanSort.Loader.LG.csproj b/ChanSort.Loader.TllFile/ChanSort.Loader.LG.csproj index 82329f4..7dcfc05 100644 --- a/ChanSort.Loader.TllFile/ChanSort.Loader.LG.csproj +++ b/ChanSort.Loader.TllFile/ChanSort.Loader.LG.csproj @@ -73,6 +73,12 @@ + + Form + + + PresetProgramNrDialog.cs + True @@ -110,6 +116,12 @@ + + PresetProgramNrDialog.cs + + + PresetProgramNrDialog.cs + ResXFileCodeGenerator diff --git a/ChanSort.Loader.TllFile/ChanSort.Loader.LG.ini b/ChanSort.Loader.TllFile/ChanSort.Loader.LG.ini index 65da27a..49db60b 100644 --- a/ChanSort.Loader.TllFile/ChanSort.Loader.LG.ini +++ b/ChanSort.Loader.TllFile/ChanSort.Loader.LG.ini @@ -146,7 +146,7 @@ offAudioPid2 = 170 [ACTChannelDataMapping:164] - ; DM and LH series + ; DM and LH series (except LH3000) reorderChannelData = 1 lenName = 40 offChannelTransponder = 9, 112 @@ -174,6 +174,34 @@ offServiceType = 115 offAudioPid2 = 158 +[ACTChannelDataMapping:LH3000] + ; LH3000 + reorderChannelData = 1 + lenName = 40 + offChannelTransponder = 9, 108 + offProgramNr = 10 + offFavorites = 18 + offPcrPid = 20, 152 + offAudioPid = 22 + offVideoPid = 24 + offName = 28, 112 + offNameLength = 68,111 + offServiceId = 70,158 + offOriginalNetworkId = 86 + offTransportStreamId = 88 + offFrequencyLong = 96 + offFavorites2 = 109 + offDeleted = 109 + maskDeleted = 0x42 + offLock = + maskLock = + offSkip = + maskSkip = + offHide = + maskHide = + offServiceType = 160 + offAudioPid2 = 154 + [DvbsBlock:687880] ; everything before LM series (but including LM611S and LM340S) satCount = 64 diff --git a/ChanSort.Loader.TllFile/DtvChannel.cs b/ChanSort.Loader.TllFile/DtvChannel.cs index f617118..f3dd394 100644 --- a/ChanSort.Loader.TllFile/DtvChannel.cs +++ b/ChanSort.Loader.TllFile/DtvChannel.cs @@ -17,8 +17,13 @@ namespace ChanSort.Loader.LG this.InitCommonData(slot, SignalSource.DvbCT, data); this.InitDvbData(data); - this.ChannelOrTransponder = data.GetByte(_ChannelOrTransponder).ToString("d2"); - this.FreqInMhz = (decimal)data.GetDword(_FrequencyLong) / 1000; + int channel = data.GetByte(_ChannelOrTransponder); + this.ChannelOrTransponder = channel.ToString("d2"); +// ReSharper disable PossibleLossOfFraction + this.FreqInMhz = (data.GetDword(_FrequencyLong)+10) / 1000; +// ReSharper restore PossibleLossOfFraction + if (this.FreqInMhz == 0) + this.FreqInMhz = LookupData.Instance.GetDvbtFrequenyForChannel(channel); } } } diff --git a/ChanSort.Loader.TllFile/PresetProgramNrDialog.Designer.cs b/ChanSort.Loader.TllFile/PresetProgramNrDialog.Designer.cs new file mode 100644 index 0000000..0dad15f --- /dev/null +++ b/ChanSort.Loader.TllFile/PresetProgramNrDialog.Designer.cs @@ -0,0 +1,124 @@ +namespace ChanSort.Loader.LG +{ + partial class PresetProgramNrDialog + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(PresetProgramNrDialog)); + this.labelControl1 = new DevExpress.XtraEditors.LabelControl(); + this.labelControl3 = new DevExpress.XtraEditors.LabelControl(); + this.labelControl4 = new DevExpress.XtraEditors.LabelControl(); + this.labelControl5 = new DevExpress.XtraEditors.LabelControl(); + this.labelControl6 = new DevExpress.XtraEditors.LabelControl(); + this.labelControl7 = new DevExpress.XtraEditors.LabelControl(); + this.linkDetails = new System.Windows.Forms.LinkLabel(); + this.btnOk = new DevExpress.XtraEditors.SimpleButton(); + this.SuspendLayout(); + // + // labelControl1 + // + resources.ApplyResources(this.labelControl1, "labelControl1"); + this.labelControl1.Appearance.TextOptions.WordWrap = DevExpress.Utils.WordWrap.Wrap; + this.labelControl1.Name = "labelControl1"; + // + // labelControl3 + // + resources.ApplyResources(this.labelControl3, "labelControl3"); + this.labelControl3.Appearance.Font = ((System.Drawing.Font)(resources.GetObject("labelControl3.Appearance.Font"))); + this.labelControl3.Appearance.TextOptions.WordWrap = DevExpress.Utils.WordWrap.Wrap; + this.labelControl3.Name = "labelControl3"; + // + // labelControl4 + // + resources.ApplyResources(this.labelControl4, "labelControl4"); + this.labelControl4.Appearance.TextOptions.WordWrap = DevExpress.Utils.WordWrap.Wrap; + this.labelControl4.Name = "labelControl4"; + // + // labelControl5 + // + resources.ApplyResources(this.labelControl5, "labelControl5"); + this.labelControl5.Appearance.TextOptions.WordWrap = DevExpress.Utils.WordWrap.Wrap; + this.labelControl5.Name = "labelControl5"; + // + // labelControl6 + // + resources.ApplyResources(this.labelControl6, "labelControl6"); + this.labelControl6.Appearance.TextOptions.WordWrap = DevExpress.Utils.WordWrap.Wrap; + this.labelControl6.Name = "labelControl6"; + // + // labelControl7 + // + resources.ApplyResources(this.labelControl7, "labelControl7"); + this.labelControl7.Appearance.TextOptions.WordWrap = DevExpress.Utils.WordWrap.Wrap; + this.labelControl7.Name = "labelControl7"; + // + // linkDetails + // + resources.ApplyResources(this.linkDetails, "linkDetails"); + this.linkDetails.Name = "linkDetails"; + this.linkDetails.TabStop = true; + this.linkDetails.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkDetails_LinkClicked); + // + // btnOk + // + this.btnOk.DialogResult = System.Windows.Forms.DialogResult.OK; + resources.ApplyResources(this.btnOk, "btnOk"); + this.btnOk.Name = "btnOk"; + // + // PresetProgramNrDialog + // + this.AcceptButton = this.btnOk; + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.btnOk; + this.ControlBox = false; + this.Controls.Add(this.btnOk); + this.Controls.Add(this.linkDetails); + this.Controls.Add(this.labelControl7); + this.Controls.Add(this.labelControl6); + this.Controls.Add(this.labelControl5); + this.Controls.Add(this.labelControl4); + this.Controls.Add(this.labelControl3); + this.Controls.Add(this.labelControl1); + this.Name = "PresetProgramNrDialog"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private DevExpress.XtraEditors.LabelControl labelControl1; + private DevExpress.XtraEditors.LabelControl labelControl3; + private DevExpress.XtraEditors.LabelControl labelControl4; + private DevExpress.XtraEditors.LabelControl labelControl5; + private DevExpress.XtraEditors.LabelControl labelControl6; + private DevExpress.XtraEditors.LabelControl labelControl7; + private System.Windows.Forms.LinkLabel linkDetails; + private DevExpress.XtraEditors.SimpleButton btnOk; + } +} \ No newline at end of file diff --git a/ChanSort.Loader.TllFile/PresetProgramNrDialog.cs b/ChanSort.Loader.TllFile/PresetProgramNrDialog.cs new file mode 100644 index 0000000..e1a5f0a --- /dev/null +++ b/ChanSort.Loader.TllFile/PresetProgramNrDialog.cs @@ -0,0 +1,23 @@ +using System.Windows.Forms; +using DevExpress.XtraEditors; + +namespace ChanSort.Loader.LG +{ + public partial class PresetProgramNrDialog : XtraForm + { + public PresetProgramNrDialog() + { + InitializeComponent(); + } + + private void linkDetails_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) + { + try + { + BrowserHelper.OpenUrl( + "http://sourceforge.net/p/chansort/wiki/Channels%20disappear%20or%20change%20program%20numbers%20randomly/"); + } + catch { } + } + } +} diff --git a/ChanSort.Loader.TllFile/PresetProgramNrDialog.de.resx b/ChanSort.Loader.TllFile/PresetProgramNrDialog.de.resx new file mode 100644 index 0000000..9e06372 --- /dev/null +++ b/ChanSort.Loader.TllFile/PresetProgramNrDialog.de.resx @@ -0,0 +1,148 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Diese Datei enthält vordefinierte Programmnummern für Satellitenkanäle. + + + Aufgrund von Fehlern in der LG Firmware 2009-2013 ist diese Liste instabil! + + + Um Probleme mit der bearbeiteten Senderliste zu vermeiden, erwägen Sie bitte eine dieser Optionen: + + + - Sauberen Kanalsuchlauf ausführen (ohne vordefinierte Länder-/Satelliten-/Providerlisten) + + + - Hotel-Modus aktivieren (muss bereits vor dem Export der Senderliste vom TV auf USB erfolgen) + + + - ChanSort's "TV-Datei bereinigen" Option aktivieren (nicht unterstützt bei 2013 LA-Serie) + + + + 214, 13 + + + Details hierzu gibt es auf der ChanSort Wiki + + + Wichtiger Hinweis + + \ No newline at end of file diff --git a/ChanSort.Loader.TllFile/PresetProgramNrDialog.resx b/ChanSort.Loader.TllFile/PresetProgramNrDialog.resx new file mode 100644 index 0000000..1b12515 --- /dev/null +++ b/ChanSort.Loader.TllFile/PresetProgramNrDialog.resx @@ -0,0 +1,379 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + Top, Left, Right + + + + Vertical + + + + 12, 12 + + + 560, 13 + + + + 0 + + + This file contains satellite channels with preset program numbers. + + + labelControl1 + + + DevExpress.XtraEditors.LabelControl, DevExpress.XtraEditors.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + + $this + + + 7 + + + Top, Left, Right + + + Tahoma, 8.25pt, style=Bold + + + Vertical + + + 12, 41 + + + 559, 13 + + + 2 + + + Because of errors in LG's 2009-2013 firmware this list is unstable! + + + labelControl3 + + + DevExpress.XtraEditors.LabelControl, DevExpress.XtraEditors.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + + $this + + + 6 + + + Top, Left, Right + + + Vertical + + + 13, 70 + + + 559, 13 + + + 3 + + + To prevent problems with your edited channel list please consider one of these options: + + + labelControl4 + + + DevExpress.XtraEditors.LabelControl, DevExpress.XtraEditors.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + + $this + + + 5 + + + Top, Left, Right + + + Vertical + + + 31, 87 + + + 541, 13 + + + 4 + + + - Run a clean channel search (without predefined country / satellite / provider lists) + + + labelControl5 + + + DevExpress.XtraEditors.LabelControl, DevExpress.XtraEditors.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + + $this + + + 4 + + + Top, Left, Right + + + Vertical + + + 31, 122 + + + 541, 13 + + + 5 + + + - Enable Hotel-Mode (must be done before exporting the channel list from your TV) + + + labelControl6 + + + DevExpress.XtraEditors.LabelControl, DevExpress.XtraEditors.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + + $this + + + 3 + + + Top, Left, Right + + + Vertical + + + 31, 104 + + + 541, 13 + + + 6 + + + - Enable ChanSort's "Cleanup TV Data File" option (not supported for LA-series) + + + labelControl7 + + + DevExpress.XtraEditors.LabelControl, DevExpress.XtraEditors.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + + $this + + + 2 + + + True + + + 13, 156 + + + 165, 13 + + + 7 + + + See the ChanSort Wiki for details + + + linkDetails + + + System.Windows.Forms.LinkLabel, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + $this + + + 1 + + + 254, 202 + + + 75, 23 + + + 8 + + + Ok + + + btnOk + + + DevExpress.XtraEditors.SimpleButton, DevExpress.XtraEditors.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + + $this + + + 0 + + + True + + + 6, 13 + + + 584, 237 + + + CenterScreen + + + Important Notice + + + PresetProgramNrDialog + + + DevExpress.XtraEditors.XtraForm, DevExpress.Utils.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + \ No newline at end of file diff --git a/ChanSort.Loader.TllFile/Properties/licenses.licx b/ChanSort.Loader.TllFile/Properties/licenses.licx index e69de29..ff18d72 100644 --- a/ChanSort.Loader.TllFile/Properties/licenses.licx +++ b/ChanSort.Loader.TllFile/Properties/licenses.licx @@ -0,0 +1 @@ +DevExpress.XtraEditors.LabelControl, DevExpress.XtraEditors.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a diff --git a/ChanSort.Loader.TllFile/SatChannel.cs b/ChanSort.Loader.TllFile/SatChannel.cs index 3156e67..9d4109e 100644 --- a/ChanSort.Loader.TllFile/SatChannel.cs +++ b/ChanSort.Loader.TllFile/SatChannel.cs @@ -6,8 +6,10 @@ namespace ChanSort.Loader.LG { private const string _SatConfigIndex = "offSatelliteNr"; private const string _TransponderIndex = "offTransponderIndex"; + private const string _ProgramNrPreset = "offProgramNrPreset"; public bool InUse { get; private set; } + public int ProgramNrPreset { get; private set; } public SatChannel(int order, int slot, DataMapping data, DataRoot dataRoot) : base(data) { @@ -18,6 +20,7 @@ namespace ChanSort.Loader.LG this.InitCommonData(slot, SignalSource.DvbS, data); this.InitDvbData(data); + this.ProgramNrPreset = data.GetWord(_ProgramNrPreset); int transponderIndex = data.GetWord(_TransponderIndex); Transponder transponder = dataRoot.Transponder.TryGet(transponderIndex); Satellite sat = transponder.Satellite; @@ -36,10 +39,11 @@ namespace ChanSort.Loader.LG public override void UpdateRawData() { base.UpdateRawData(); - -// bool deleted = this.NewProgramNr == 0; -// if (deleted) - // mapping.SetWord(_SatConfigIndex, 0xFFFF); +#if false + bool deleted = this.NewProgramNr == -1; + if (deleted) + mapping.SetWord(_SatConfigIndex, 0xFFFF); +#endif } } } diff --git a/ChanSort.Loader.TllFile/TllFileSerializer.cs b/ChanSort.Loader.TllFile/TllFileSerializer.cs index 0df9948..1484dbd 100644 --- a/ChanSort.Loader.TllFile/TllFileSerializer.cs +++ b/ChanSort.Loader.TllFile/TllFileSerializer.cs @@ -10,6 +10,7 @@ using System.Reflection; using System.Text; using System.Windows.Forms; using ChanSort.Api; +using DevExpress.XtraEditors; namespace ChanSort.Loader.LG { @@ -63,6 +64,7 @@ namespace ChanSort.Loader.LG private int deletedChannelsHard; private int deletedChannelsSoft; private int dvbsChannelsAtPr0; + private int presetChannels; private bool removeDeletedActChannels = false; @@ -101,9 +103,9 @@ namespace ChanSort.Loader.LG foreach (var section in ini.Sections) { int idx = section.Name.IndexOf(":"); - int recordLength = idx < 0 ? 0 : int.Parse(section.Name.Substring(idx + 1)); + string recordLength = idx < 0 ? "" : section.Name.Substring(idx + 1); if (section.Name.StartsWith("DvbsBlock")) - this.satConfigs.Add(recordLength, new DvbsDataLayout(section)); + this.satConfigs.Add(int.Parse(recordLength), new DvbsDataLayout(section)); else if (section.Name.StartsWith("ACTChannelDataMapping")) actMappings.AddMapping(recordLength, new DataMapping(section)); else if (section.Name.StartsWith("SatChannelDataMapping")) @@ -138,9 +140,7 @@ namespace ChanSort.Loader.LG this.ReadDvbCtChannels(ref off); this.ReadDvbSBlock(ref off); this.ReadSettingsBlock(ref off); - - if (this.EraseDuplicateChannels) - this.CleanUpChannelData(); + this.CleanUpChannelData(); #if STORE_DVBS_CHANNELS_IN_DATABASE this.StoreToDatabase(); @@ -245,7 +245,10 @@ namespace ChanSort.Loader.LG if (channelCount == 0) return; recordSize = GetActChannelRecordSize(off, blockSize, channelCount); - var actMapping = this.actMappings.GetMapping(recordSize); + var key = (Path.GetFileNameWithoutExtension(this.FileName) ?? "").ToUpper().StartsWith("XXLH3000") + ? "LH3000" + : recordSize.ToString(); + var actMapping = this.actMappings.GetMapping(key); this.reorderPhysically = actMapping.Settings.GetInt("reorderChannelData") != 0; for (int i = 0; i < channelCount; i++) @@ -454,6 +457,9 @@ namespace ChanSort.Loader.LG ++this.duplicateChannels; } this.DataRoot.AddChannel(list, ci); + + if (ci.ProgramNrPreset != 0) + ++this.presetChannels; } if (!this.nextChannelIndex.TryGetValue(index, out index) || index == -1) @@ -560,6 +566,18 @@ namespace ChanSort.Loader.LG #region CleanUpChannelData() public override string CleanUpChannelData() { + if (this.satConfig == null) + return ""; + + if (!this.EraseDuplicateChannels || this.satConfig.dvbsChannelLength >= 92 /* LA series */) + { + if (this.presetChannels > 0) + { + new PresetProgramNrDialog().ShowDialog(); + } + return ""; + } + this.ResetChannelInformationInTransponderData(); byte[] sortedChannels = new byte[this.satConfig.dvbsMaxChannelCount*this.satConfig.dvbsChannelLength]; @@ -755,7 +773,8 @@ namespace ChanSort.Loader.LG file.Write(fileContent, this.dvbsBlockOffset, this.dvbsBlockSize + 4); // rest (including settings) - file.Write(fileContent, this.settingsBlockOffset, fileContent.Length - this.settingsBlockOffset); + if (this.settingsBlockOffset != 0) + file.Write(fileContent, this.settingsBlockOffset, fileContent.Length - this.settingsBlockOffset); } } #endregion @@ -890,6 +909,7 @@ namespace ChanSort.Loader.LG sb.Append("Channel records erased (duplicates): ").Append(this.duplicateChannels).AppendLine(); sb.Append("Channel records with Pr# 0: ").Append(dvbsChannelsAtPr0).AppendLine(); sb.Append("Channel records with duplicate Pr#: ").Append(numberOfDupePrNr).AppendLine(); + sb.Append("Channel records with preset Pr#: ").Append(this.presetChannels).AppendLine(); } else sb.AppendLine("not present"); diff --git a/ChanSort/ActionBox.Designer.cs b/ChanSort/ActionBox.Designer.cs new file mode 100644 index 0000000..bd08e1b --- /dev/null +++ b/ChanSort/ActionBox.Designer.cs @@ -0,0 +1,76 @@ +namespace ChanSort.Ui +{ + partial class ActionBoxDialog + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ActionBoxDialog)); + this.lblMessage = new DevExpress.XtraEditors.LabelControl(); + this.imageCollection1 = new DevExpress.Utils.ImageCollection(this.components); + ((System.ComponentModel.ISupportInitialize)(this.imageCollection1)).BeginInit(); + this.SuspendLayout(); + // + // lblMessage + // + resources.ApplyResources(this.lblMessage, "lblMessage"); + this.lblMessage.Appearance.Font = ((System.Drawing.Font)(resources.GetObject("lblMessage.Appearance.Font"))); + this.lblMessage.Name = "lblMessage"; + // + // imageCollection1 + // + resources.ApplyResources(this.imageCollection1, "imageCollection1"); + this.imageCollection1.ImageStream = ((DevExpress.Utils.ImageCollectionStreamer)(resources.GetObject("imageCollection1.ImageStream"))); + this.imageCollection1.Images.SetKeyName(0, "0000.png"); + this.imageCollection1.Images.SetKeyName(1, "0001.png"); + this.imageCollection1.Images.SetKeyName(2, "0002.png"); + this.imageCollection1.Images.SetKeyName(3, "0003.png"); + this.imageCollection1.Images.SetKeyName(4, "0004.png"); + this.imageCollection1.Images.SetKeyName(5, "0005.png"); + this.imageCollection1.Images.SetKeyName(6, "0006.png"); + this.imageCollection1.Images.SetKeyName(7, "0007.png"); + // + // ActionBoxDialog + // + resources.ApplyResources(this, "$this"); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ControlBox = false; + this.Controls.Add(this.lblMessage); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "ActionBoxDialog"; + ((System.ComponentModel.ISupportInitialize)(this.imageCollection1)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private DevExpress.XtraEditors.LabelControl lblMessage; + private DevExpress.Utils.ImageCollection imageCollection1; + } +} \ No newline at end of file diff --git a/ChanSort/ActionBox.cs b/ChanSort/ActionBox.cs new file mode 100644 index 0000000..843e887 --- /dev/null +++ b/ChanSort/ActionBox.cs @@ -0,0 +1,94 @@ +using System; +using System.Drawing; +using System.Windows.Forms; +using DevExpress.Utils; +using DevExpress.XtraEditors; + +namespace ChanSort.Ui +{ + + public partial class ActionBoxDialog : XtraForm + { + private const int ButtonSpacing = 10; + private const int ButtonHeight = 50; + + public ActionBoxDialog(string message) + { + InitializeComponent(); + this.lblMessage.Text = message; + } + + public Image EmptyList { get { return this.imageCollection1.Images[0]; } } + public Image FullList { get { return this.imageCollection1.Images[1]; } } + public Image CopyList { get { return this.imageCollection1.Images[2]; } } + public Image Delete { get { return this.imageCollection1.Images[3]; } } + public Image Cancel { get { return this.imageCollection1.Images[4]; } } + public Image Save { get { return this.imageCollection1.Images[5]; } } + public Image Overwrite { get { return this.imageCollection1.Images[6]; } } + public Image Discard { get { return this.imageCollection1.Images[7]; } } + + #region AddAction() + public void AddAction(string text, DialogResult result, Image image = null, bool isDefault = false) + { + int width = this.ClientSize.Width-20; + var button = new SimpleButton(); + button.Text = text; + button.Appearance.TextOptions.HAlignment = HorzAlignment.Near; + button.Image = image; + button.Width = width; + button.Left = 10; + button.Height = ButtonHeight; + button.Anchor = AnchorStyles.Left | AnchorStyles.Top | AnchorStyles.Right; + button.Tag = result; + button.Click += button_Click; + + this.Controls.Add(button); + + if (isDefault) + this.AcceptButton = button; + + button.DialogResult = result; + if (result == DialogResult.Cancel) + { + this.CancelButton = button; + this.ControlBox = true; + this.SelectedAction = result; + } + } + #endregion + + #region SelectedAction + /// + /// Returns the action selected by the user + /// + public DialogResult SelectedAction { get; protected set; } + #endregion + + #region OnCreateControl() + protected override void OnCreateControl() + { + base.OnCreateControl(); + int top = this.lblMessage.Bottom + 20; + foreach (Control c in this.Controls) + { + var button = c as SimpleButton; + if (button != null) + { + button.Top = top; + top += button.Height + ButtonSpacing; + } + } + this.ClientSize = new Size(this.ClientSize.Width, top + 10); + this.ActiveControl = this.lblMessage; + } + #endregion + + #region button_Click + void button_Click(object sender, EventArgs e) + { + this.SelectedAction = (DialogResult)((Control)sender).Tag; + this.DialogResult = this.SelectedAction; + } + #endregion + } +} diff --git a/ChanSort/ActionBox.de.resx b/ChanSort/ActionBox.de.resx new file mode 100644 index 0000000..150c989 --- /dev/null +++ b/ChanSort/ActionBox.de.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Wie möchten Sie fortfahren? + + + Aktion wählen... + + \ No newline at end of file diff --git a/ChanSort/ActionBox.resx b/ChanSort/ActionBox.resx new file mode 100644 index 0000000..7cd780f --- /dev/null +++ b/ChanSort/ActionBox.resx @@ -0,0 +1,470 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + Top, Left, Right + + + + Tahoma, 9pt + + + + Vertical + + + 15, 11 + + + 527, 14 + + + + 1 + + + How would you like to continue? + + + lblMessage + + + DevExpress.XtraEditors.LabelControl, DevExpress.XtraEditors.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + + $this + + + 0 + + + 17, 17 + + + 32, 32 + + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFpEZXZFeHByZXNzLlV0aWxzLnYxMi4yLCBWZXJzaW9uPTEyLjIu + OC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI4OGQxNzU0ZDcwMGU0OWEMAwAAAFFT + eXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRv + a2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAAChEZXZFeHByZXNzLlV0aWxzLkltYWdlQ29sbGVjdGlvblN0 + cmVhbWVyAgAAAAlJbWFnZVNpemUERGF0YQQHE1N5c3RlbS5EcmF3aW5nLlNpemUDAAAAAgIAAAAF/P// + /xNTeXN0ZW0uRHJhd2luZy5TaXplAgAAAAV3aWR0aAZoZWlnaHQAAAgIAwAAACAAAAAgAAAACQUAAAAP + BQAAANo+AAACtgQAAIlQTkcNChoKAAAADUlIRFIAAAAgAAAAIAgGAAAAc3p69AAAAARnQU1BAADX+28z + GAEAAAAgY0hSTQAAbJsAAHJvAAD2rgAAhYMAAG73AADoQQAAMXQAABdsobYtmwAAAAlwSFlzAAALEQAA + CxEBf2RfkQAABCxJREFUWEfFlclLW1EUxl0UQSp0IRQKpd0Vuikthf4J3Rah4uymXblxJSIixgFnJSoO + iCgOqAtBpURUnFBRiVIHVERRcWhVNInGxFQUT893yw1vSF4cIr3wZbj3cc/vfuec+0KI6L9KN1FbW2vt + 6Oiwtbe369TW1ibU0tIi1NzcfFxXV/ezurr6m3af20o3wYFci4uLND8/r9Lc3JyQ1Wql6elpmpycpNHR + URoYGKCmpibq6+szr6yshGr3CyTdBE6KgLOzszoh+MzMjACYmJigkZERAcCOkcViwfoPhgrX7mkk3QQs + XlhY8J5YKQkCiKmpKa8DnZ2d1N3dTTs7OzQ2NmbhtTDtvv6km4ADvlIgJUEAARcGBwepq6tLuGCz2Whp + aQnOtGv39SfdBACWl5cJEL4EdwACCLgwPDwsTt/a2koul4t2d3cFJDtj0u7tS7oJVPfq6qo4iT8BBBBw + AWno7e0l7ghyu93Chc3NTbHG7nzX7q+VboI3sq2trRFc8CdAwAm4gDRwBwgADEAcHBwQDsFrVz09PV/l + 3r6km+CWsq+vrxO3lF9JCLiAjhgaGhIpwLi5uSGn00l7e3viGV67ZNAvcn+tdBONjY12WAgX/AmnAwhS + IV2QDsgBiMPDQ/Ec14mba+MzT+vi6SYaGhrsW1tbBBeMBBAJgaJDK8IFiFtZ/EdtoE1RqJym05OTk0/a + eKo/UH19vR39DBeMtLGxIUCUToyPj4t6QEvW1NRQSUkJ5efnU2FhIZWVlQFuc39/P0IZTxUc4rvdgVaC + C4EkQWTXKDujv79f3A9IDWAqKyvJbDZTQUFBtTKeKjjEDztQxXAhkLa3t4UAAjeUIChOXNUAwT0BGKSE + 9z9SxlMFh6qqqk6Pjo5EFd9GcEvCwBU4grSgTeVtCRDUAV5g7MSZMp4qOFRRUXF6fHxMnKs7SQkDR+AG + agMvMNyYCI5ixf7KeKrgEBfLKW4ztNBdhdQBRtYQOkV2CYoU6QkIUFxcfMaD4MJdhdRBgIEjSAtqQ15c + +F1eXm6cAm6ZM1wi3LP3loSBG0gJ6gJuAIgdNgbgvnXireZwOO4tpBAggEBaZEoAVFpa6lTGUwWH8vLy + nBcXF4Q0PEQSBG4AAikBEF9OxgDZ2dnOy8tL8W5/iJBGCSLdwP+ioiJjgKysrPPr62vxWn2oJIwEgbMM + cK6MpwoOZWZmnuOVioeDISXM1dUVrmJjgIyMDDxAHo8naJIwGFzkxgDp6eku/ibUQTCEU8vfGLm5udjf + G08VHEpLSxMAqINgC+PWAKiDYAsjJyfHGCA1NfWfV4802IE//OWNF2IymZ4kJiY+ZT2Pi4t7HRsb+ysl + JcXzWEpKSvodHx//MjIyMiIqKioshD9CWc944VV0dPRbhnjP+vgYiomJ+cAHfMex3iQkJLxITk4O/wuP + oQEZbqZmUwAAAABJRU5ErkJggu0EAACJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIBgAAAHN6evQAAAAE + Z0FNQQAA1/tvMxgBAAAAIGNIUk0AAGybAABybwAA9q4AAIWDAABu9wAA6EEAADF0AAAXbKG2LZsAAAAJ + cEhZcwAACxAAAAsQAa0jvXUAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAABD1J + REFUWEfFlUlLXFEQhV0EIUTIQggEQrILZBMSAvkJ2QYh4uwmWblxJSIijjgrzvOsOIOK8ywqKipxQEUU + FYdERdvWttU0ipU6F17zJp/aUXLh66bva6pOnVt1nxMR/Vc0G7m5uZM1NTWm6upqDVVVVYKKigpBeXn5 + QV5e3s/s7Ozv6jh3RbPBiaxzc3M0MzOjYHp6WjA5OUnj4+M0OjpKg4OD1N3dTaWlpdTR0ZG2uLjorI53 + G5oNVIqEU1NTGpB8YmJCCBgZGaGBgQEhgB2j9vZ2PG9lUS7qmEZoNmDx7OysvWI5khCIGBsbsztQW1tL + TU1NtLm5SUNDQ+387Kk67k1oNuCA3hFISEIgAi709PRQY2OjcMFkMtH8/DycqVbHvQnNBgQsLCwQRGRl + ZVFERIQh3LSi+srKSrJarbS1tSVEsjMR6th6aDbQ3UtLS6KSm5Acggs4hpaWFuKJoLOzM+HC2tqaeMbu + /FDHV6PZ4ECm5eVlggtlZWXEI6YL3MnMzBS0trYKAVgQsbu7SyiCj+iyubn5mxRbD80Gj9TRysoK8UiJ + ruem0oCq+/v7qbe3lzo7O6mvr08cAdb19TVZLBba3t4WbvEzG/fMVym+Gs1GSUnJESyECzk5Obrnrqa+ + vt7ugLQgYm9vTxTCYs+4N77wtiafZqOoqOhofX2d4IIREIjg6Ac0HUYRLgAeZfEbvYExhVt8UR0fHh5+ + VudT/AAFBQVHmGe4gA7Xq1gNEmA0h4eHkUiMJNxLSkqi2NhYio+Pp5SUFIhb29nZcZXnUyQHfLebMUpw + 4TYgcnV1VTQczls+GV1dXeJ+wNFATEZGBqWlpVFcXFy2PJ8iOeA/m9HFcIHF6FZ8X+rq6oQYHAnH35fn + UyQHPFbH+/v7oovvAtyC2I2NDeEKHEFv4DqXbku8M3BMeIGxEyfyfIrkID09/fjg4ID4rCg/P1+3ovvS + 0NAgkqNZEV+eT5EccLMc4zbDCN0XHB2ESz2ESZGmBE2KPrlVQGJi4gkvgguFhYW6FTkCbkuMb2pqqvER + 8Mic4BLhmXUYiEcfwQ30B/oCbqBP2GFjATy3FrzVzGYz8aWkW40jYKIgKDk52SLPp0gOYmJiLOfn54Rj + +BdQAHoJbqA3MDFwhS8nYwGRkZEWm80m3u3FxcW61ThCW1ubEJaQkGAsIDw8/PTq6kq8Vv8VFAEkR+As + CziV51MkB2FhYad4peLP/GbUrcYRcCldXl7iKjYWEBoaij/QxcXFg4FiABY3ubGAkJAQK38T+uAhHcAo + YkVHRyO+PZ8iOQgODhYC0AcPDdadBaAPHhqsqKgoYwFBQUE2/n60xQ784S97Pic+nyd+fn7PmBfe3t5v + vLy8fgUGBl48Fv7+/r99fHxeubm5ubq7uz914g9n5jk/eO3h4fGORXxgPj0Gnp6eH7nA95zrra+v78uA + gACXvwrYNK14tLKNAAAAAElFTkSuQmCCnggAAIlQTkcNChoKAAAADUlIRFIAAAAgAAAAIAgGAAAAc3p6 + 9AAAAARnQU1BAADX+28zGAEAAAAgY0hSTQAAbJsAAHJvAAD2rgAAhYMAAG73AADoQQAAMXQAABdsobYt + mwAAAAlwSFlzAAALEAAACxABrSO9dQAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKh + AAAH7klEQVRYR61VCVSU1xWeDjMQT22W40m1ilo1JkqIS6vWQ0xqUptjksbUGCsCsWn1aF0KSCSIsmtE + FimL7DuyCVRARPZFIIKgbEcWQcQBVLZZmBlEFv367nOwDiFVUu853/nnX9673/2+++4IphKBgYGVCQkJ + 0vj4eC3ExMRIo6Oj+4KCgqr9/f13aj5/8cGSqevq6lBTU6OFsrIyFBUVIScnB5GRkbh48aJ3Q0ODrmbZ + iwuqlhJWVVVpobS0FIWFhZwAUwiZmZmorKzMYKSma5a+mIiNjZXW1tbi6tWrWrh8+fITBRITE5GamgqJ + RILi4uJM9m6aZvnkMRVf6flkFlRUVHAVcnNzkZKSwlWQSqWor68nZeJ5oh8Ltulz+0oErl+/Dvr+9OnT + cHJy0gIrhld/5swZqNVqdHR0cIXYHk6adD8M2pQSPo+vzIKRxsZGXtnToPWkAhFOT08HUw6Dg4Nchba2 + Nv6OqbNLk1I7puJrXFwcmpubQSpERUWBWcNBavj5+XFkZGRwAhRE4t69eyDSrKDRtLS0LzVp/xtT8ZWR + RUtLC9gRoy6nJuMoKChAXl4esrKykJ+fzy2gePToEZRKJTo7O7lS7N0wU/dzTerHMRVfCSQpqRAQEPCD + bwlJSUnwjDgO5ZCCk6AgEt3d3Zw4IzvIeuMjTXqBgLr9eX2NjIpEfVMtaq5fQ1NzI1eDQIRocyqi7EoJ + kqqCsd5rAYKi/blqZCHtQXaSWqyhFf39/Ws4Abax9H/56ubjCsvIPfh9wDswjHoNy1OnwyjvFXxSOhsm + 3xvAvPgD2Kb9BdY+u+HgZI/E4nBIVK34+7kNOJxkxq0jtTw8PHDixAmcPHkSp06dIjXburq6ZgjYEZNN + 5mtefi5s4y2xLHwWlp9/Ce+WifFRvQhftIlg3CGGaacYJh26+EryCr65bYRDNzfAsnojYm+6o05VhBRJ + AIyz9JFbdBHZ2dm8j0hFIuPr6wtvb2+4urr6CyIiImQTfbVztMN7Lisw11+Mt9NE+M0lHXzAkn/WKsYX + 7WJsuS3Gl+y6XSLG13d1sad3Glzl6+AvN0Wq2hEl90NwVZ2MA3UrYXt2k1aPJCcn8xlDJ83Hx0chCAsL + k926deuJn+StWeznmO0lwsIwHSyKE2JplhArGIlVZSKsIZSKsJZd110R4cMaET5pEmObRBeH+wwRrDTB + 2UFL5A+6IujOfjh1GqC17XGfUI9QYpoz1GecQEhIiIzmNqlAHb/FdSPm+OphboAIs72F0PcVYl6IEAuj + hVh8RoglCTp4O0kHy88xZTJEWJ0jxrsluvhDtS7+dEMPe7vegGv/xwhR7EC8zAq76hbANsJYSwWaFVSs + l5fXgIDNejmNTFKBsDJwPma56TAIMdNdiFmeDF4M/xJyVQyDXsdbIS9jQYQOFsfoYGmiCMvTxVidJ8a6 + cl1sqNeDSdt8WHStxXd3N+Fg84dwbTfis4AKbW1t5Wq0t7dTMw4ISIa+vj6wjkRwcDB2On+FOR4vYfbJ + n0H/FFOAqbDCcy5MXbbA4Ts7PuOlMimcg+zwvscyzAsUY16oDhZEifBmsgjLssRYdUkPf6yciW11S7C7 + zgjbvp8Ja++vnyjAiub5PD09lQLGQkEzmwbFODxKnDHfTwyDwFcRUOKJrjud/Lmbmxvu37+PgYEBDoVC + gcirflga93MsZEosOivGohQxFqeKsSRDF8uzf4H1ufrYWPhrOF/7FL29vXw0kxo9PT10NJUCd3d3ttcA + SIXQ0FDO0NHJER97vQdzF9ZEGtbjGB4e5iqEh4drvnXA+9Fz8M55MQwZDJgdS9MYAYa32G+D1GkwTH0V + RrEzYOG8l6+5cOECL4AVpBSwwTBAo5JNpmfi+PHjGBsb438y46i8XYA16XpYy5pxbZ4ufpejh9VZbG7k + vIzPyl7HgfpVCGi2RPbtUNzqvcETy+VyriQjoBKw6aSkiughO5Ja1U6Evb09/4OhxWx+8GdbQlbCKJM1 + X85r+HPJL7GrfDFsCtbj23Bj2Hsc5GpO3IdG/OjoKA0ilYBVpXza18lAXhMcHR0w9nAMKrWKQ6GSwTx3 + E9wq9uJCWwha+2vQI7+HHlk3pANS/s3Q0JAWKBeBghWvEjg7Oysn+kqgZPaO9rBzOIrDDjawtj+Ef367 + H7d6bqKhox4nTh/DgSN7sf/IP/iVsPfIbuw8/Ff87bAZdtvuhJWdJY46HGF7aatAR5Hi2LFjagF7qZro + q1LFekLeB0l3O5o6GlDbdg1VLRXYY7ML1e1VqGy9jPIbpShpLER+fRYyq9OQVpmE5PJ4xJVFIeZSGL9m + 12ZwsjKVFMMjw7x/xvGEAPNVNdFXqt7O8XHlh+yt8I3dQRyys4K59QG+mUIt5+gb6MXN7haUt5Qhq+Y8 + zlWeRcqVBCRXxOPfVxJx4Voqfyfpa4d6SI2HDx/yHiJQuLi4qAVHjx5V0c1ErwikhnpQzb2kq42NDV84 + HiOjI1AMytHRL8GNu01ouccmXG8buqTsnCu6IVfLoBpS4cHIA558YjAFHghsbW3VdEN9MK7Aj8HMzAwW + FhZaMDc357A8aAkrK6bS4/sh9u6Z2LFjx10Bq4oTeNqfnwoK7utUYpzAuDf/Dyi4r1MJa2vrYb7yBQX3 + 9Rlhamqqv3nz5hlbt26dJti+ffudyfz5qeC+TggTE5PfEoyNjVeyfMvYN2+yfvrVvn37pv8HvCkwgKFr + n78AAAAASUVORK5CYILCCAAAiVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABGdBTUEA + AK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAhUSURBVFhHxZd5UFXX + HcfPu+fc+/aVRXFBcUPpaJ1aQp3WsUnTGcwk2ulMmphM0rFqa5OOU6ORRbbHosADHjuoaNS0aU3dWmuK + mjiTxYUCyqKDdNxwyWiJ1hJXeO/9+j1PaJE8jGln0j8+HObey/l+f7/z+51zYET0f4XVTI1lZWPHiLqZ + M0saU5Ovd7+z7d7hJYu618eML6oIj7BUhYezXM5ZlUFj6YrC3ApnBYKzQpWzUpCvCrYBYzXIEgrz4p0H + 3xXodHgvWLlBj1FlRTrd1Bq7rXRXQkLX0YUv3N8WNeJWpeDHmHdU1OTf/eCpg+e3bCbfx4fIv38v9W3f + SueSfk1/jJ/V5rXZ5rox4X9jwCsEK+J8dK3ZXL1n1reudya/SV2efHp/wYK+Spv1k0Kuy2INaam3exoO + E508ToEDeymw420KbK0i2lBEfetWU8u8ub5yq2VTCRePZaBUvoN4HmNKhaZWvzdz5p2Lb6ygf5R66eir + r/g3TYjZU2axxJRbzKwIQbHzmzcE7jfCwOEPKLDrt+TbWk2+ijzy5awkf/JiouXP041nvk3vOk1nUplu + bOYjDLhBMdfJdP9se9TI6x3zn6UbSauo/ZWXqS5q5Emv0TCj2OlgNRHhLGhArzJWFROzcPfTT526XJJP + 9O5mok0l5MtfTX1Ji6l32Y+o94XvUuCZqXQ3PpL2OfU9GTo+dx1qwjPEQBVI5zrHRqO+4UjsZPp0/nPU + 9ZPn6U9x0+56BE/JZNCCeJnL9bCB2imTWfnIEazQal30lzmzr15Zvogo8zUKIPL7C+fQvcQ4upUwknpm + OOnzKVY6ZFd78zn/aT4Ey/oN1GJEBlbsMBvunJowji7OTqDWJ+Jpa5jzXDpjkR5NZbk6acAZwkDsFFY9 + LpoVwV2RzarUupxpB+Im3rzx3BMUmP9Nuj17LF3/houuTrLSp9FGuhalp0NW4StQ+WslEF6rCtNGldd/ + ZFSpw2mjznFj6OPoMVSqqfVlmmpxox6KH8eAXJvyMCc+srMqo15Zb1DrjkQ7ez+b5qLPJtnp0mgjnY/U + 6Ey4Rl1OleqNvA8G1m1V+aUmjdNJg0ZtJiMdtJgCqI/CbClo1LNs9lUMuJysGmy0WYLV7NGxmW8ZRNOJ + cANdhvhZF6K0CTpl4XTKoNCHmkLHhY5aOBCcdqvCVyyUZXnohjxF978ZKEd6vZiomCtsvcqX7THyWx1m + Th0mTq16hU5AvBXizYqO/soY7eTK3TyVL5Ddkd9voOYrG8AS1Ia52Cb7AwOlmKgMmajVBMsUwlau8cNH + INyi6qipX7gZHMDv2ZpIycJ3OSBbe9CSayGQheofMFAD8YqwMFYbGcHK/mMgltXEjGcliLzM5WAlVgur + NBuDLeZFhXswYS5I08TojYJfaIBYs05HjToWNNAIjuPZFpV3Z2hibAb+ZoC0/jETBIvRYpXdxsodDlaJ + LBfrsRHJDOQ77CwH6ZKky/RBvAgU4w8LghGJxO2C32oJij8QbZLiMHIC698ms4KaqNKLthTsmGnDkIpN + TJKBLTpXr2dujCxT7vEQGyATgmuBNOCBgUJN/GKPUPpaId7UH/VxjNuFcmeL4NeaUQ+nURtnUJwNdpWy + hahMVUIbGMwaGJEjy8B6IXX/ZsCA3OmKVLHiz1zxt/anWiKN7IShYpUn4r1WrYnT7XYR7JJro/VU79J8 + KYr4YTJMYPxSHhIfMJAHkIFV+xTF3wJRGbWkDeIHVCWAQlsuvyt4sMaGUoPa3IkNqmeSif4Za6FNdu3S + G0wwaeLL+IIBCQws3avo/Cf6o26EcCvW+qiqkEfjf5DfSANyG84ByUilFyauTDETxdupa6qF3KqoSZJr + jnPjUTwkjEqX4/d2cKVXRi4rvUlB2tF2bVjr9Zo4l45vZLsNNpCGYlrJhKnaqnXenG4lmmWn/SMMvSkK + T0iDyKNgbkw0CLFFKN0yctlqzXKXQ4X/DZvPTj3vRVvFD0QvxwED6TAg0/kmE5HbHPq/35tho5txVqo2 + qcdggmVAaDhkiwWRk+J0+6hBthZSfhxRt6K1OlHhn5gFQShHRi+/GzAga2AgA7Kg1gTh8fURhvu+6XZq + wvmB+8OPMyGUNQwst3+SXMFfque6QDtSLqNuMyJyq6AOh0rletGyBiKDNxlJNnZJNyaRAhmIVF5W5KTZ + nL/ePMpIn8fa6Ddm9Zx8noPnocAPhWVh396g1zrarSZqM+BkQ8rlodOFk2+3Rb2bKkScjFKmejAyhVlS + FMir2sDvaUxeVsR7V2Is1B5lpjyuLMmEjjsELB17NC4NMftjov1np02kjjAzdTo1uhihUXOEnrJUsQ4G + WCjWwMDQNR0AO55jl0270T3OSluMomUtnhXKq9wQ2Fq4KNDU/JPznqbLiXPpwvTxdCHaRt3jjXR4hD5Q + aFBHFBtVVhIC+Twdk4QiFSDFS9sjTXTUZfC7FTHajXbNHgIrtZhYpdO+r+v1JdS99CW6+uwcuvadSXR7 + Rhg1jjMH6mz6mLfsehaKzcANoSwEEYoM3KLrDOLY6TAT1WjcI69w8pQdDFuHYvKYjHWXM5LpVm4S3fzl + i9Tz4pNE8+LoyESHv9SsRlVaNRaKKpsWzEKWvK5DcCj96z75oFnr/dAozr5vEGwoLBXndQpjCU2/+jnR + js10N28l+Va/Sv4lifT7UY6rubhmF+pxKA1DPtoRHTQseaBEFYVva2InYEMJGlgNKsZHN19/ZwPR3m1E + NdnUPv/7hBSuSnpgMCTJIB0dhIspjvDhka3uhVhpCNgaTCLBhFHVkyY0HV38sv+DxCfvF1lM3keJSx7X + gHxfDrGKEHzhv9Wvm5APvz6I/QuZzBFpeiSaDwAAAABJRU5ErkJggn0KAACJUE5HDQoaCgAAAA1JSERS + AAAAIAAAACAIBgAAAHN6evQAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAABJ0QAA + SdEBBfyrlQAAABl0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuN6eEncwAAAntSURBVFhHnZcJVNT1 + FsevgGyiqBiEmqmkT5+5ZAj4emVohhxEEBQQDQSUNRwVlEWNdQQVFBWxMHu5lTyzl2K2aZkppLYIirLM + DDPDpj4BCZSZAfl2/38GyaOVdc+5Z+Z/zpzf53u33/8O/Y6ZmxK9Zk0UM5QonX3j33Tp00QJFkSefOaQ + 7qP/2IxtiCSLiNTbiLo+IsLJv+CfCd6H8LkB4QtDwpdGhBN9CXvZo4yoaYwBZTNjcDfqUbOcRlS4h8Ff + W1vj8sKFKI+NRWViIirj41ERF4eKNWtQHhOD8lWrcF0iwbXoaFyLjERZaCiuhgTj6tJAXH1jMa74LUCp + lztK5rqgxMUZPzpMRtFTFig0J3j0pSvGRGP0zAdmNJXoaAFH8MOcOaj/8EM0HD6M+oMHUff++6h5912o + 334bqtxcKHNyUJ2VBUVmJuTp6ZAlJ0G2YR1kiXGQrY1BVYwEVSujUBUdhqqIEFSGBqAyxB8VAQtweepY + fDeA4GVMZcy06kazDSIKzCW6f/HVV3Hz2DHcOHoUDQUFqD90CHX79qF2717UvPMOVLt2PSRAIU2HIjUZ + iqT1UKyPhyIhBoq1EihWR0EuCYP8zRDIIwIhX+4PWbAPZAFeKJ0yEqcHE543op16PBnOJSo91b8/6vbv + F+E3jhx5KAO1+gzI9BlQZmdBuTkTyo3pUKYlQZm8DsoNcVAmxkAeJ0FlbBSUq8KgXBECZVQAqsP8Ub3M + B9VBXpAvckXJUCOsG0AtzOY+JZqQRKT9ycNDhIrOJXgQ/XvvQZ2fj+/5+fsThajK2QZV9haoNmdAlZEG + VXoSVCnroE6KQ/W6GHyWvQknd+ZAtjoU6pXBUEcHQB3hD3WoD1QhXlAtnYcK++E4aUOwMqAl1J9HJJ9r + L0tNFTNQd+BA96cQuQDfswcXPjiE5qYm6HQ6FBceRxVD1JulqMlIQY10A2pSE6BKWosvcraIv7vb1oZP + t2dBvioItSveQG3UItSGL0Tt8vmoDXZHtcskXBtBGN2XMoWZCDhgYoIaBgm17nHhWc11v8CRC4f2mCDi + /P8+hmxTGmozklArXQ91ajy+2pH90O/aWEThVi6TZAkaov3QELkADWGeaFg2F7Xe0yEfTZhiSnmCgMAC + W1uod+8W6yw6f1fl5aGYs9Hc1Kg/std0Wi3OflQA+UaOPj0Bp3K3obm5F95jba2tOLYlncvgi5tR3rgZ + 7oGby91wY/ErUI0lTDWl3aKA/44YAeX27VDt2CG6kv08l6Cp8VF4j2lZxJnDh0T4ncfAe6yVRXySmcxl + mI/bke64HeaK/wfOQN0/CS+a6QUUDBsmjlZ1drbocvazLOCXlhb9MY83QUTLnTv6p8dbe3s7jm3nnony + QFOUG5rDXdAU9DJuTibY99MLOGRuDkVGxkMuy8zAmXf3/Cngj0yAH9+5BbWS+WhZ6Y6WFa5oeXM2Wpb9 + C42OhGkWegH7eQoq+LoVJkFwObsiLYVvumR8/XYe7txp1h/55CbAC3OzUB/jhdY189Aa64a21S5oWzkL + bWEOaJnBAgb8RkBpQACqNmwQXf7WBvF2Ey6Y6pRErnMO1/nJRWgYfmJXFhrivNGW4IG78XNxL24O2te+ + hvZYZ7RHTsVdF4LDwN8I+NHNTXzhVMbznc73uiJhDWTRoagK9kO5jyv2BfqiRqXSI37fhM7PlwSh3m8c + 2pZNxr0oB2hiZ0CbOJt9FnQJztBKpkLjaQzHwX16BZybMAEXpjuhaPwYnLe1wrn+BijmF8fFQYQLQwip + jpOgfkIBW4O9oHyFxCjb3fpA49EXmgUW0AQOgzZyArRvToJmsTUch/TtFfA5+1f8Hv/amHDWjHDegsED + CcVWTw7vMUFEzjIv1LkyeCGDF1lBE2ALTdAIaJaNhjZ0DLRhY+FoY9Yr4AteJE7xAnHGhLPRj8EcfRFH + n+Lw1+A9JooI90GdL4MFaPg4MXIh/dpV06Bd7QBHW4teAV8K0fPm0hP9OY7+78J7TBQRtRj1yydCG+MI + bdzL3AczoV3P/fCWCxyHD+wVcIpXqG84+u94aznL0SfbT/xTuACoq63RPz3ehJswZ8VSHkdn6FLdoZPO + hy5zIXSbfOE4wqpbwAFO/2lO/7em3dEXWRLSJoxCeVmZ/phHTWy2IG9kvz7pD6ejsfE2ciIXoTGFwVlL + oMsJgm7ncuhyw+A0yqZbwMHfNF9Rf+58Tv8l7vyNEx8vQoBnL/WGnG+zRmfCdrfHi2jkd4lQgkapD3Q7 + QqDbHYWOPavQ8d4adLwfBye7YaKAgIOc/jPmRmL6hea7xCvTz08RLtsSMieziGu9IkR4oDeq7Em8ze6+ + TvhlriF2eNo/JOIBfOMi6HaFd4P3JaDjg2R0fLQJHUcy4ThmRJ64kOxlAcV2w1E02ATfc/p/4NG7bE24 + OpRQ9gxhywujUMEiBHhWgDcqphCaXyK0ziTccyVovMzwi78Ndvr+WxTRDfdnuB/DI9CxNxYdh5JEaOdn + 76Cz+BNoT+Rh3DNPZ4orWaohac8Ps0KpsxN+GN4fP7KAEl6ZyobxO+JZQiUvD9n2o5Dp545rEwi3HQh3 + Xia0zeaLxt0AGt+BPOPPojXieex8YzZyIvzQlLaA6xzK8BiGc9RHt6Dz2w9xv/ISOi99ivIPtsF6kOUS + QYChhyGVnjXvg9KZTrjuMQtljmNx5RljXBvOcBYgtyNU8wJxfRzhJkff6KRPP990wpWqWfwUtMufg3al + PVrjndGUNI+bbSk68iXoOLABHZ/m4X7JaXRVl6BLeUUUkBsf9WAppUF9KHCvKa/lwwei3HMWZL5zUO3v + CoXLFCjsbaAYawD1Pwj1HP2tqYSm6Vx3bj4x/d5m4i2njRgPbex06JLm8Ihx6vNXovP4DtxnWFfFxW54 + bTnuXy/CrXOFmDZx/IO1XDCjaYZ09CSP4E+jB6Nq/kwoA+aiJsQD9eFeuBnphVtBs3Db1x5NC8ajxXsk + 2nyHQ7OEwXyliuB0z+5mO5yOzlP/QefFQty/fFoEdsl/QpfqKn8vRnvJGYQt8n74j4neLKcbUeERS+q6 + bGuI6xOGQPbSaKhdJ6N+oRNuLZ2JpvA5aFk9D22JXmhP4Rpn8nhtDejt8v3r0FEgRccn29D5eT46vzmI + zqKPcf/iCXReOI4bZz7Gcl/PK6Ymxo/8NesxY1sDkizrR+qDQ6jrAjdh+SjugecIKq5/3fPcAy9yD/AE + tMziHnAzwD0fS9zjBmyPnoL2+BnQpHlAszUQWi6BhpuvuWAzft6TjixJcNML48dkMYMn/8/N3KwPvTbU + iGKe7Uvp7NKRxiQdJbgJSUebspuT1K4fu4WB1G6AkdTO0kRqN8hMamfVT2o3ZIDUznqg1M5msHSkjVXC + IAvz3/l7TvQr893zMDR/cVoAAAAASUVORK5CYIIqBwAAiVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYA + AABzenr0AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgA + AHUwAADqYAAAOpgAABdwnLpRPAAABqhJREFUWEftl3tQlFUYxrdpuljN1DjT1IhNTZk1JdY0NV0sU8QL + CYooaAQoKCyS3BdQrnGxkKtFiOEFAUUCZaF0YdlluQSCUIaxu18LEqmIAQKCLLcFn97zsQbFWk5bM/3R + O/Pb/Xb3nOd9vnf3nPes4D8VCx3iH3zqnfjFD5nu3nDvC1H/GPcviLK7Z8Fuu0dfjbWZbxa3UCDAXfqU + 08LW9u4FFmlxSzfna/3iKiZCPq36xxFGyMdft8vseOG9z1fps07Fgwt2PfaGbZZSXNmFfyu0o0DkFyrM + M9+XqE87Ffc9GfTUcpfcC+3dY+i/wRjFxMRNjI/fhM4Ixkmjf3AM3X0jpAdIqq/iabPUdH3aaTEvcK65 + Sy6nbB1Ea/sArnRpodPdxMjYxN9knGdMN4GOriG0XOpHV+8wTsgu4Rnz1P36rFMxiwwsc87las734RzX + g5aL/RgloaGRcaNgGi2XBtCg6obm534c+eqn2xsw25LLlZzphKK+A42aHgyPjmNwSGcUTON8cy/kdVdQ + r7yGfXnNmL/idgYcj3P58naIFRdxprET2uFxXKffgzEwjdrzXSiQt0FGJpKyOTy/ar8BA88FzFnilKM6 + VNiGjMJmfvANrQ69/aNGwTTK6jpwWNyM/NKfEXOgCc9bGDAw+6VgkyVOx9TJORokH1WisPzib79eY2Aa + RaSVlK3EwYJmBKd8jxcNGZj7RrDJux8cU0cdUCEi7RxyJK18CTt7ho2CaRwvbkXEvnOIz1TCJ74BpqvT + DRt42/6oOiD5e/jE1eHgSQ16B0ZxtXvIKNjXcEis4TXDUs9BGF0HUyuDBmJMFpEB4e56OIdX4bMcFa5d + H0F7p9YomEYKaTmHfwPP2Do4hlTjZauDMw08axZj8tamo2obURXWesuw5/B59A2M0YY0ZBR9VMU9GT/A + xlcO+12VsPRS4BXr2xh4kwys2F6Gd7acQtDeBtoRb0B5oc8omAbTWuxyGiu3S7FMWIrXbA79uQEzVwlW + upfwlVgzHa87ZNocpsG0zLZJYO5WAvM7MWDuVsxPeJdcL9k6ydKtEt4YY5lrMQ8bx7j1mn22lOYt1c9Z + QvOZxmTyYiwX3oGBlR4KrCDHqzyksPRkdyHHOt8y2PiVYYO/ArYiBewCynk2Bk7Crtn77PP1NI6vHFXC + ckcpLEiHVYAlZyxzu50BWgVsGa7zq+KF7ERlsPQohsX201j9oQRWOyRY61UMa2Kdd8kMrL0YxXAMLsfm + 0Eo47KrA+0FkMIAZK4O1jxxWXnJYfCjH64YMsGVIzUjtFFaLbZE1WONRhM2ifIQkyhCeLEdokhzBCaWE + zCAhhG/0KawR5sE3vh6en9Rie0wN3KKq4RJRRcuvkl8FG0QVeNPWgAG2Fa9yzVN7fNIA34QGrHYvQFlN + C3+Suck//nUMakewxj2PT8aq4ETPjiEVVJUKuJMZ95gzcAqtxtsbMwwbsBLmqwM/bUR4WiPsfL6GtEpD + y0gLv7hq5EkaeSPD1OOnc6vv07kD7b/08wYc6E5ZcidmgnChjU2UWA9RUj2ZqMNi+8yZBmY9G2yyfodY + HZWuREKmCk5BEpwu56BuG8C2iHJknKjnj1gD1Fz+CGs4QyMTaLvch/U7TsB7z1l+672Ff8JZfET9JZz6 + gX/CtzBzzNynTzsVzMAmv0J1YrYGafkauIaVoEimRlNLL4SRZODkd3ySHtrbf8f1UdpuR8mEDpq2Hmzy + Ock3M5aMNSB2HbmfGtGRH2hHbEJISiOWO2Wn6dNOCzLwgahInZbfiqzTrfCMlkEsVeFbdRecQxXUUNR0 + tzp00rmOZ1rH+4VgZpQt3XAUiamdq5CU1YRkasE81N5Tv+SQcpxDdHoTVjgfnfkVCOb6mjjv+lqTeeoi + ChSX4B9bhhMlKlymhpKaq4K09goGh6kCA7op+sd4rhED2glwP/XAeWcRnfsu4DAdatjBJqOwBUeKJjkk + bkFCFoeVzlkGTsUPez9i55V/Nru4AyW11xB74Du6m0JEpdYgbG8VdsYrEJpcOcXeadcEG+MVI4XHR6U0 + vwtFlVeJDp7Cig7kydpxvOQKdh9UYtHGA2H6rL+PRTb77R18T1Z5Rkt/9IqScg7+BZy9dx63JaCAc2EE + irmtwWJOGDKJe2ghD7veFiTmXAj/j6VcSKKcC9gj50SxMs7n41KOaXlESjnXUEmTpVtO3kLrlPn6lIbC + 8gHBHL8nBCaBc2ebRvzGLEPM06N/zcax/xeC2Z4zYZqPejxOCe6ezPN/sBAIfgUj9zzexZoZ2wAAAABJ + RU5ErkJgggEHAACJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIBgAAAHN6evQAAAABc1JHQgCuzhzpAAAA + BGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwgAADsIBFShKgAAAAAd0SU1FB9gCDwcbCcW/Em8AAAAadEVY + dFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAABl1JREFUWEftlnlMVFcUxl3S1q6JdoliE6tp + Gtu01TR1BVvbamVxAYbZZFELyDLMxr4O28CALDMMyCKIDPsiIlBEccAuakSLS9sYpSo1ad27YFHTGt7X + 8968Yq0DDrF/+iW/vDdn3j3n3HvPefdNeKzHehTNe3/hzHkLFroTQlt4e8Gid/mhjyaxVPjROvd1O0Se + nkN6owFB8mAEyAKtEhgSBOPWfOwwVSAmPp751MmxQygWmERSkQPvbnwSSTzeidfE/JmWqYUmOQml27dB + rpKNSnhUKJqaG7G/uwvmni6Um8pQ21CF5NTE3yWSdU/xbm2Xp7e0bXtFCUOzaFhov2zfp87Oww7Ll8N+ + DFY6OcNx9Wos+3jFmTWua7KTUhKYqJiwP4VCtxd4t7ZJJBXa6zK1TERU2KBQ4v4Sbx6XvLylHTtMpYxI + ItTzJtvls9Hry8rqHYxI7KHhTeMSbd+KzOx0JixC9RtN4EXebJvE64XOhvxcGqy+IpAInuPNNsvJyWnS + Jt8NfeUVpbR9HpG82TYJhcJJvv6bTtQ11tDSeSh587hE47wKi/OZEGXwjxKJ6xTebJuo7aQVldsZdahy + gJIZd+XSmCmBwZsHuNlLBD682bro4clU4RuIcqKS52pEZBho77/9l80a1SKpRyNdu4gSgut1kVgQUddQ + w2wO9DvBbgUXyJoo+BOeXtI9+QV5TEtrMzh2205VjQnGAgOKtxWhoNAIlVo+TDOOoa75tax8GyOWeqzk + Q1kXLXVSQ1M909TUiMoqk00072pCa3sLauurERUTDpk8kEOuDIY+LwcBQf7Y27WHoQ7q5MNYl4fY7eVc + Q86t7u5u3L59G8PDw2PCMAwuXryI3t4jONt/BlXVJoQogkYSYAmSBUCXocXWwnxqXcHY54BkvVB59NhR + nDp1CkNDQ7h5cxB//HGTu7916xYlxXIbd+7c4bh79y4OHz7M/X/jlxvI1WdxQdkkWNgV2OTrg68Ofgmp + p3iY6mEWH8q6vDd4tvX19eHSpZ9x7lw/Llz4gWY4QL9/wtWrl3Ht2hVcv34VN25cxy8UcHBwEAcO9KC/ + /yyOn+hDaloSFPTuZ1GqQyCjJIqKC5GVnYnE5AS2gDfzoR7Ua84636XrM+64q0rhHVsFgaoEHuoSyFIq + cfz4UZw+/R3Onj1NiZ3B+fP9GBg4Rwyg/fM27OnswKHDBxETFwlVqBzqMAU0ifHQG3JRV18Lv4DP6D4b + tAKjv3opgRpTzwUU7OkfoWz/OYgTmmGqqUdHRys6O9vR1dUBs3kfvvjCTMt/iALUoKauCt/0HQVVOugV + y6FNS+VOPYNBj/BINfKMuWwClXy4B0UJlOa2fA9Zce8I6rJjSKo4AsegYrgp78edVkigLsWGiAI6jsu4 + LYiOjUBkdBhtQQgSkzTY3bYLxcVF3Mrk5T8kgdkuGYkp1cfgbzwIP+PX8MuzEF7WC13DSWQ0nYKOpZHl + JEcGocgzY1OEHmY661NSNVwS6nAl5Ao5qO8RFx+LuIRo5Bqyxt6C2S46V1nOPmZjzgH4ZPVweHN0W9hy + Dy8OM7wyzUio6MVK32xU11ZyPc8GY1GFKaFQyhEbH00FGI90nRZ0FoxRhKsypjkqq+766w9AnLaP2GtB + a0E0QqeF1E4Iic36HnwSXA7tli3YVlqEhMRYaJLiuKAs9OGBzKx0hIYrH96Gc92yWgJyzXBLbLegaYcr + R9s9EtqwboRWzuaVSvbANBQWFdBnlmaEFG0i15oGKsC16/2HqM7UfCjrmr1a996KENOwu6YVztHN9xPV + DCeOnfeI3AlHQkDPL/UtgTohE2m6VC6oNj2Z7lMoeA5thworA7dizuqM7XyoUTVxjku6YYWimnGJ3oVV + 5HxVZPN/YO08US08u+Ea346FPlvhH2FJgq0HfV42vRcUcPbTYr7UeNluefjYW0B6evKU56e/+nFM4XzP + or8W+1cw9kHVsA+qgQNdHbirBdZmoRYOwXVYJquHA/Gm0Ii31iZjqbsaDu5yLJGmM6+7pPZOneu8nPy/ + wsbgIlnRROJZYgbxxpPTZi2Zscg/buaHoUV2y9T5dvYhW2YsDU4bhXQ7e5nuH2aw1w9URjsHRc7zsxY7 + kb/5rE/e9zPEqGI/FNgMpxFstuyAR2U6wfqaSrCfYexEbRb78P/BGJow4W/6Fe13GcY+rQAAAABJRU5E + rkJggg8LAACJUE5HDQoaCgAAAA1JSERSAAAAIAAAACAIBgAAAHN6evQAAAABc1JHQgCuzhzpAAAABGdB + TUEAALGPC/xhBQAAAAZiS0dEAP8A/wD/oL2nkwAAAAl2cEFnAAAAIAAAACAAh/qcnQAAAC56VFh0Y3Jl + YXRlLWRhdGUAAHjaMzIwsNA1sNQ1sggxNLMysbQyNdI2sLAyMAAAQukFKFHT8DkAAAAuelRYdG1vZGlm + eS1kYXRlAAB42jMyMLDQNbDQNTIIMTSzMja0MjDSNrCwMjAAAEHTBRHNZzlkAAAKHklEQVRYR6VWCVSU + 5Rr+EbNMvd4Wy25aaqfSNDVzySU1xdulBDTTkhRc0CDjgKXI0RRxR0HAC7hgCGKouCJIgCKIDiLDMgzL + MAOzDwyzwLDMBojPff9xKDLxds99znn4hv//z/s87/t97/d9TG8Y7eLHDB45pe84J/cXZy7xeWf+Nxtn + Oq/a4rrQ6ydPt2+DvlvkE+y/yGfXRjfv4I2u3+70+3zddp9/rd660mllwOdzvvafNn2xz6j3nZYPfmHk + xD5vTHG2R30KXnh3FnPkyn1msovX3z/1DJj7ld++QK/t0Wf9DiYWBkZdle2My2rc90ue6VByQUf45eIH + R1J4Xf++xntoY0pJV+Rl7oOw8/kd+xNzjEEn0vWbIi6IvXfHcb4JiExw9d7lN3/FpmlTXdYMIKPMc6++ + Y1e1Y86yDczwCXMdPlu71XX9zuN522MzjQev8BGZpUD0bT2Oc1pw8n4b4otM+KXUjGS+BVcqrEgTtCNL + 1I4ccQfuSDtRIO8EV0lUdOC+1ILb1c1IKVThWGopAqNSDO4BkWn/9AyY4Rt2kZm9xNuuTljgsZmZvXTD + OP+QRPnRzBqE5RgQmtuKw8TIvFZEc1pxoqANp7hGnCkxIrnMRAbMZMCCLKEVObXtuCslUXkHilWdKKt/ + gAr1A1RpumysaOjCPYkZkVd5WLk1pniGm9dr89397eoE57XbmOlua+f+GHrGGJcjwZE8A8KeYCCeDPxS + YrIZuEoGrpOBGyIrcsXt4Mg6KPNOlNZ1otwuLtR2oZpYru7EnRojTmQIsGHfKe3Uz1aOn7e8h4F55Gbc + xy4Tl/nuUW8OTUTY2VzEZlUj/q4aCfcNSOC24XSxibI34RzPjIs0BSmVFqRXW383IG2nCrSDSyySW1Eo + NSO/phXZ5TpcuSfD6cwynLicB+/tkbUjJs59a6rzN3Z1wvjZLszLoyYO8/kpnB8enwL/vbHYsOsYNh2M + R/DRiwhLzMTxKxwKwsP52wJczhcj5b4caUVKpJfUIYNXjxtlDbhVrsHtKi041TrkCzS4W6FCTqkEmQVV + uH6nDJmcMmzYEX6XGfjqS2++N8WuTnh52FvsMGjjriMZdZomCKX1SM0pQkxSBnbHnMeWQ/H4MSQOgWEJ + CI4+h9BTKTiefANJ6flIzeMht0SEomoVqhV6yHVtqGsyQ0mjRG1ArUoPqboJumYTZHU6rNtyIIm0nu0/ + cDCr+QiOz/Rjh74r/YJjxQo1Ojq7YGizQq03QqZuhkCmRalQhYIKGThlYtzliZHPl6KwSonSGjUqpDoI + VSSmboVUY4RCb0KzqQNGSydM1gcwt3ehvfMh+EIZviAHpOXAODiwmr8DAPO5h/82Ll+E9o4uNLVaUE8G + 6igYSxVRyVJngoIo11JGRKnGBAmJilk2PKJCb0ar+ZF4N61kIKeA/3Dul+u9C0nrTwi5LmWmu3i6/3qb + 22G1GbCSsBEqnZFEKajWSKJUERJis7SJklitnTVqliaqgpnMWtFm+V2cpaXjIS78mmecMG+p8+pdiXbV + HljsG8KMnuny8enLWQaTtRNNNAWsgW5xGbE3YXGDBTKdGbV6LbiaMlQ2VcFgbYWRhFkjRpb0O+ZMSv0b + Ez6ZwHbdnzDDdQ3z6pjp74bGJktbjFabAbbsvYmzwiJWnJ5lqzMQKdmC08oQBIlWIETsg+LmXDRZm2Bs + b0crrYVGmtLgyHj+86+Nfv39WQvtqj0wavwMhhkwdEhgyPGChsY2MtBuM8CWvTfxGrUF+Q0FWMv/CK5F + b2AdfyZS1QmIkW3FDf158Fvz0WKxosX8AEpNM3yDIjJIapC96/6IAYNfYof+tEiTa5Xa3wx0Z99TXEis + rqf/ta0IrfWHG4kvKhqB/TU+EBnkuNYQh0xdEiQmAQyWNpuBCnEd3H2DjpFGX8e+z7Baf4TDo7bos2R9 + 4KGiSslvBrqz75m5kMRraLFJaH3kaNMRJPSwVeFOQx6ETVKUG3hQmMQooWngNKWTCTPyioVwXuG3he22 + XlFHL+ct8/4+i8N72Gg30F36nuKSxiZkqC8jQhxIc78ZPD0f9xqKUEkbT1WdCQ0tdC4YcnGuPgKX1DFQ + mVS4epPbMX2h5/LtSSV2tSdg/cGLzKQFX7kkpd0261rbqe8pS3v23eJs6cXU++eVx7C4eCSV/k1ES4JQ + Te/LlEZUqIyoN3SgsqUMCaoDuKCOgsqoQWxylmEMddkiX3Yf6gULPAKYkR86TTqSkNKgNlhsG0/P7Flx + QR0ZaWjBPpGPbd5XlU3BacVhVOhkKFdaUEkVULXqoDUZkK27hEJDNtTNZuw9ek78yjtT3/5ooadd7QmY + MMeNGTR87PAd4fEVcm2bbUfrNtC98KrIgECjQ6BgqW3xHZUGoaZRA662DBw1FyKdAVnaC7ilu2pbjHxD + sW2L/mHvUQ7Tf8hLI8ZNs6s9AUNHjqG//f62YUfEzWq53magZ/kFdgPV9WZcU12wtV28cj82Vy2GJ+9D + 7BatBbcxH6Hi77G31guxip2QNutQUqPBqk37kyn4c/ZuezL69nuWHZ5x9935M7dK8QcD3eWvJLLzXEkn + 3MW6WOwQulMl3rRxl2i1LfNgkQcipT+Co8uFvLEdt0pq4ea15SDF7mPvtt7BtonzSv9tN+gMl+stvRho + o/mmqdE1I0ERhmUl7+Lr0jE4LN4EQSPdExoSUaVX0D5BCWituHSrhD2EfGqe1oLdCLkuY2a4rFpxPuNe + p7xHBQR1rGgrePIWlEibUSRpBlfSgiJFHVJlqciQ36QLqQwV9J2kSU8L1YyqehOEGgtOXMoxfeC07LM1 + e87YVZ6CJRvDmLGzF809ejajRULtVi5vxj2RHrmVGtzkq+nmo0YW3YAy7cziqZFdpsVNInsryqMbUYGo + kQwawFe22UwcOHml4a3JCz5wWrHJrvIUzFq8jnl97MzRu6PPyu6Q6JUCOS5wpH+JFzkyuqopkMpVII2r + tBm9J9Qh4FBc+eDhY4eNn+1qV3kK3v5wDvP8KyNf+S4o6n5ithAns4iZ1Y9IF9Wn8Wf6NiFbhNO3amw8 + k1OLS3dFWB1wMJ1CDxrypEPocTzbf4BtmOXisXvL4STLsTQejv8qQFRaJSKvVSA8pRzhV1nyH2M5Iugd + +90x+j7uBhm/XkoX21Mtk52+9KWYjg4OfdjYfwkOjv2ee3vU+OkHFnr4VfjtOdG25+frXRHJHERdLUbU + NR6iUvmITi23k37Ts2h6x36z52Ral29wTPOnX/sUDx89aRvTx3GYPe7/BEfiUAfHvvMHDxn2w6j3p8VO + nrcow+lLryK3VT8Il/lsk9Hxqlz+fZByqfdWqaunv2DeF2sKJ811uT7ivckxA18c6uvQx/FjisHuPH89 + 9SeANTKQ+A/ie8TpxAVUI1e6Tn9ho0MfF3rmRGT32dHEocTnif+XcG9gtzI2cN/HyD77L9vc42CY/wBc + QuHh/jKt5QAAAABJRU5ErkJgggs= + + + + True + + + 6, 13 + + + 558, 126 + + + CenterParent + + + Choose an action... + + + imageCollection1 + + + DevExpress.Utils.ImageCollection, DevExpress.Utils.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + + ActionBoxDialog + + + DevExpress.XtraEditors.XtraForm, DevExpress.Utils.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a + + \ No newline at end of file diff --git a/ChanSort/ChanSort.csproj b/ChanSort/ChanSort.csproj index c0be3ca..6e1040d 100644 --- a/ChanSort/ChanSort.csproj +++ b/ChanSort/ChanSort.csproj @@ -85,6 +85,12 @@ + + Form + + + ActionBox.cs + Component @@ -136,6 +142,12 @@ AboutForm.cs Designer + + ActionBox.cs + + + ActionBox.cs + CharsetForm.cs diff --git a/ChanSort/GlobalImageCollection.cs b/ChanSort/GlobalImageCollection.cs index c4be357..382cdee 100644 --- a/ChanSort/GlobalImageCollection.cs +++ b/ChanSort/GlobalImageCollection.cs @@ -89,7 +89,6 @@ namespace ChanSort.Ui #endregion - public SharedImageCollection ImageCollection { get { return sharedImageCollection1; } } public Images Images { get { return sharedImageCollection1.ImageSource.Images; } } } #endregion @@ -99,7 +98,6 @@ namespace ChanSort.Ui public class GlobalImageCollection : SharedImageCollection { protected static GlobalImageCollectionHolder holder = new GlobalImageCollectionHolder(); - public static SharedImageCollection Instance { get { return holder.ImageCollection; } } public static Images Images { get { return holder.Images; } } public GlobalImageCollection() { } diff --git a/ChanSort/GlobalImageCollection.resx b/ChanSort/GlobalImageCollection.resx index 829fc82..33b6079 100644 --- a/ChanSort/GlobalImageCollection.resx +++ b/ChanSort/GlobalImageCollection.resx @@ -129,7 +129,7 @@ a2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAAChEZXZFeHByZXNzLlV0aWxzLkltYWdlQ29sbGVjdGlvblN0 cmVhbWVyAgAAAAlJbWFnZVNpemUERGF0YQQHE1N5c3RlbS5EcmF3aW5nLlNpemUDAAAAAgIAAAAF/P// /xNTeXN0ZW0uRHJhd2luZy5TaXplAgAAAAV3aWR0aAZoZWlnaHQAAAgIAwAAABAAAAAQAAAACQUAAAAP - BQAAAJNLAAACDgMAAIlQTkcNChoKAAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/YQAAAARnQU1BAACxjwv8 + BQAAALhZAAACDgMAAIlQTkcNChoKAAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/YQAAAARnQU1BAACxjwv8 YQUAAAAJcEhZcwAACukAAArpAf11ztMAAAAqdEVYdENyZWF0aW9uIFRpbWUATWkgMSBNcnogMjAwNiAx NToxMDo1MSArMDEwMP/NqUUAAAAHdElNRQfWAwEODCaDia/cAAACZ0lEQVQ4T82S7UsTUBSH75eCCAx6 oTAqg7BMRKjoQ6S9Oa1I10gzU8PUZmYpKEamy8gCX8iS2YxqiRmREMrUltEoLdSMps458wXUEiW0UToN @@ -175,288 +175,348 @@ LWGoBTfR1IKbTKnJ0YY/RD8m2K0yQXAS8N/E77iZG6hJD2saLLNBxvuLjiC/p64LG/Ci5+otsDXAWiMu VzhdQfQtnVvcDYKV8Kt4pFPCHd4IPsA4XxDMGbIvsSyUzsP7CVaka9vWp3QG76kEzmeCK2wyR1uXezoP H4ZddoO0xxeQU3fQ6xJW5ZBdCaXk4yZGOSTYzj02ld21khZ1wixPMCLHNBQYSZzuj986jSIDJTtI0dHB - NOi7Gl1zRVNfcL1UOFclqrJAUeTI8xMK0oH+xWTZF9s+A36qvos7AAAAAElFTkSuQmCC8gEAAIlQTkcN - ChoKAAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAA - CXBIWXMAAA68AAAOvAGVvHJJAAABh0lEQVQ4T62SIY+EMBCF+Qknz648WVmLRFZikUgkFlm5shZZWYlF - IldiK5HIuffaJbCby4nLTfKSDdv3zcxri3+pEHY55D00bjJCzkW536NYCw2rDFDfP6TroPYhT3sGTJPg - sPxaO1TVk9R1SHrai4JdCbB2yyd/KJq3bRdtJlGqEWP8CeC4BAxDzKff6jCvcRdVBayxAjCeAOcyoOvW - 7LjU1fxYN/kqfcrAVO4CQFAEtAjmWu/m+RHlsxylaRaprgAmTQD/OOon87RE+dAjApwBuJ8Aa9cECCFD - DA8g7RQYdubY7HyYDb6XpT0BvF+avRfcP29jR6BbCpWBcWeud5grE14BfBzJ7PgWdnTvXmSaTuq2z2ZM - VFYegOEEsMNhZmea8FmULmXB/syg6YZshDTW0bq/ADCeA+AYmwCa294ixE0iguzwW9EIKe1eAW27PPeO - ckNgN1WKD7OEaZZpXmReeG0mGQ9pnabMxQ5Nw4B8emF8JLxnXhXDyhpS1yxMqNoT8Pcqim88sz2Gvhgj - 5QAAAABJRU5ErkJggrEBAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAABc1JHQgCu - zhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxySQAAAUZJREFUOE+dUqGygzAQ5DOw - SCQSi6ysxFZW9hcqkchYJDISGxmJjEUikft2mbQ8pq8t83bmBnJ3m8vdbXIEIAbvEY/HIaIwzTPODhhD - OHbJNE0w1uPW0+yIK+3ECy78CjHtFQrawaPqJlTDgnIAShILuyDvZxQ0Y+l4d4l1JDOpNB61cbh0DufO - I+tmZCYgbQOyZlxbipQNM51V6/gCh2VZ1iqC+s76BVk7om4tvH/ThqYc/hhSx5ZqM8CPB/qPvzvoZR+J - n/Bvoqo2vUPPiUfXE4qpnXjcoGraf9MP3MK4buP3TBTXQEsOWnnRvSHQWXLSVcck6kB7l5BaCupOO3G1 - qaHAWCBS9lCFG6ctYiajiFazQMo1SgN3wwMRKa9Qf7lEIwXyJQXFU7YeVxK/rvEB6SGndEOYVkE9RBXD - 36Hkj3rfIUl+AJCNcVaotQnCAAAAAElFTkSuQmCCRAEAAIlQTkcNChoKAAAADUlIRFIAAAAQAAAAEAgG - AAAAH/P/YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAA68AAAOvAGVvHJJAAAA - 2UlEQVQ4T8WSIRKDMBBFc51KZC0yMjIWGRkZi0RWYiMrkVyBI9RWVlZu9yeEBqahFe30z7zJkt2/WSDi - 6zqciIS9R5Kkf8YlNWc2onCLGuK6p+FSMOfsCuNyURg/ad5LOOdWKCVJ1hUtp4c1Vxp9htMrTq0ho7lB - 3RO5cWPOjIkrm3K61GA1diYkUXTLTHm8TFASkijaGlO8TFASkn0rqXPqJci9bTB2FTXqGNE1GyJ4Ru6j - Bvhl1lry3tM0TQHs/b4B1KgqXhgpSWtNxvCHY7CH1wgX6c8S4gEtwUamb8vaXgAAAABJRU5ErkJggoIM - AACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAAEZ0FNQQAAsY58+1GTAAAAIGNIUk0A - AIcPAACMDwAA/VIAAIFAAAB9eQAA6YsAADzlAAAZzHM8hXcAAAo5aUNDUFBob3Rvc2hvcCBJQ0MgcHJv - ZmlsZQAASMedlndUVNcWh8+9d3qhzTACUobeu8AA0nuTXkVhmBlgKAMOMzSxIaICEUVEmiJIUMSA0VAk - VkSxEBRUsAckCCgxGEVULG9G1ouurLz38vL746xv7bP3ufvsvc9aFwCSpy+XlwZLAZDKE/CDPJzpEZFR - dOwAgAEeYIApAExWRrpfsHsIEMnLzYWeIXICXwQB8HpYvAJw09AzgE4H/5+kWel8geiYABGbszkZLBEX - iDglS5Auts+KmBqXLGYYJWa+KEERy4k5YZENPvsssqOY2ak8tojFOaezU9li7hXxtkwhR8SIr4gLM7mc - LBHfErFGijCVK+I34thUDjMDABRJbBdwWIkiNhExiR8S5CLi5QDgSAlfcdxXLOBkC8SXcklLz+FzExIF - dB2WLt3U2ppB9+RkpXAEAsMAJiuZyWfTXdJS05m8HAAW7/xZMuLa0kVFtjS1trQ0NDMy/apQ/3Xzb0rc - 20V6Gfi5ZxCt/4vtr/zSGgBgzIlqs/OLLa4KgM4tAMjd+2LTOACApKhvHde/ug9NPC+JAkG6jbFxVlaW - EZfDMhIX9A/9T4e/oa++ZyQ+7o/y0F058UxhioAurhsrLSVNyKdnpDNZHLrhn4f4Hwf+dR4GQZx4Dp/D - E0WEiaaMy0sQtZvH5gq4aTw6l/efmvgPw/6kxbkWidL4EVBjjIDUdSpAfu0HKAoRINH7xV3/o2+++DAg - fnnhKpOLc//vN/1nwaXiJYOb8DnOJSiEzhLyMxf3xM8SoAEBSAIqkAfKQB3oAENgBqyALXAEbsAb+IMQ - EAlWAxZIBKmAD7JAHtgECkEx2An2gGpQBxpBM2gFx0EnOAXOg0vgGrgBboP7YBRMgGdgFrwGCxAEYSEy - RIHkIRVIE9KHzCAGZA+5Qb5QEBQJxUIJEA8SQnnQZqgYKoOqoXqoGfoeOgmdh65Ag9BdaAyahn6H3sEI - TIKpsBKsBRvDDNgJ9oFD4FVwArwGzoUL4B1wJdwAH4U74PPwNfg2PAo/g+cQgBARGqKKGCIMxAXxR6KQ - eISPrEeKkAqkAWlFupE+5CYyiswgb1EYFAVFRxmibFGeqFAUC7UGtR5VgqpGHUZ1oHpRN1FjqFnURzQZ - rYjWR9ugvdAR6AR0FroQXYFuQrejL6JvoyfQrzEYDA2jjbHCeGIiMUmYtZgSzD5MG+YcZhAzjpnDYrHy - WH2sHdYfy8QKsIXYKuxR7FnsEHYC+wZHxKngzHDuuCgcD5ePq8AdwZ3BDeEmcQt4Kbwm3gbvj2fjc/Cl - +EZ8N/46fgK/QJAmaBPsCCGEJMImQiWhlXCR8IDwkkgkqhGtiYFELnEjsZJ4jHiZOEZ8S5Ih6ZFcSNEk - IWkH6RDpHOku6SWZTNYiO5KjyALyDnIz+QL5EfmNBEXCSMJLgi2xQaJGokNiSOK5JF5SU9JJcrVkrmSF - 5AnJ65IzUngpLSkXKabUeqkaqZNSI1Jz0hRpU2l/6VTpEukj0lekp2SwMloybjJsmQKZgzIXZMYpCEWd - 4kJhUTZTGikXKRNUDFWb6kVNohZTv6MOUGdlZWSXyYbJZsvWyJ6WHaUhNC2aFy2FVko7ThumvVuitMRp - CWfJ9iWtS4aWzMstlXOU48gVybXJ3ZZ7J0+Xd5NPlt8l3yn/UAGloKcQqJClsF/hosLMUupS26WspUVL - jy+9pwgr6ikGKa5VPKjYrzinpKzkoZSuVKV0QWlGmabsqJykXK58RnlahaJir8JVKVc5q/KULkt3oqfQ - K+m99FlVRVVPVaFqveqA6oKatlqoWr5am9pDdYI6Qz1evVy9R31WQ0XDTyNPo0XjniZek6GZqLlXs09z - XktbK1xrq1an1pS2nLaXdq52i/YDHbKOg84anQadW7oYXYZusu4+3Rt6sJ6FXqJejd51fVjfUp+rv09/ - 0ABtYG3AM2gwGDEkGToZZhq2GI4Z0Yx8jfKNOo2eG2sYRxnvMu4z/mhiYZJi0mhy31TG1Ns037Tb9Hcz - PTOWWY3ZLXOyubv5BvMu8xfL9Jdxlu1fdseCYuFnsdWix+KDpZUl37LVctpKwyrWqtZqhEFlBDBKGJet - 0dbO1husT1m/tbG0Edgct/nN1tA22faI7dRy7eWc5Y3Lx+3U7Jh29Xaj9nT7WPsD9qMOqg5MhwaHx47q - jmzHJsdJJ12nJKejTs+dTZz5zu3O8y42Lutczrkirh6uRa4DbjJuoW7Vbo/c1dwT3FvcZz0sPNZ6nPNE - e/p47vIc8VLyYnk1e816W3mv8+71IfkE+1T7PPbV8+X7dvvBft5+u/0erNBcwVvR6Q/8vfx3+z8M0A5Y - E/BjICYwILAm8EmQaVBeUF8wJTgm+Ejw6xDnkNKQ+6E6ocLQnjDJsOiw5rD5cNfwsvDRCOOIdRHXIhUi - uZFdUdiosKimqLmVbiv3rJyItogujB5epb0qe9WV1QqrU1afjpGMYcaciEXHhsceiX3P9Gc2MOfivOJq - 42ZZLqy9rGdsR3Y5e5pjxynjTMbbxZfFTyXYJexOmE50SKxInOG6cKu5L5I8k+qS5pP9kw8lf0oJT2lL - xaXGpp7kyfCSeb1pymnZaYPp+umF6aNrbNbsWTPL9+E3ZUAZqzK6BFTRz1S/UEe4RTiWaZ9Zk/kmKyzr - RLZ0Ni+7P0cvZ3vOZK577rdrUWtZa3vyVPM25Y2tc1pXvx5aH7e+Z4P6hoINExs9Nh7eRNiUvOmnfJP8 - svxXm8M3dxcoFWwsGN/isaWlUKKQXziy1XZr3TbUNu62ge3m26u2fyxiF10tNimuKH5fwiq5+o3pN5Xf - fNoRv2Og1LJ0/07MTt7O4V0Ouw6XSZfllo3v9tvdUU4vLyp/tSdmz5WKZRV1ewl7hXtHK30ru6o0qnZW - va9OrL5d41zTVqtYu712fh9739B+x/2tdUp1xXXvDnAP3Kn3qO9o0GqoOIg5mHnwSWNYY9+3jG+bmxSa - ips+HOIdGj0cdLi32aq5+YjikdIWuEXYMn00+uiN71y/62o1bK1vo7UVHwPHhMeefh/7/fBxn+M9Jxgn - Wn/Q/KG2ndJe1AF15HTMdiZ2jnZFdg2e9D7Z023b3f6j0Y+HTqmeqjkte7r0DOFMwZlPZ3PPzp1LPzdz - PuH8eE9Mz/0LERdu9Qb2Dlz0uXj5kvulC31OfWcv210+dcXmysmrjKud1yyvdfRb9Lf/ZPFT+4DlQMd1 - q+tdN6xvdA8uHzwz5DB0/qbrzUu3vG5du73i9uBw6PCdkeiR0TvsO1N3U+6+uJd5b+H+xgfoB0UPpR5W - PFJ81PCz7s9to5ajp8dcx/ofBz++P84af/ZLxi/vJwqekJ9UTKpMNk+ZTZ2adp++8XTl04ln6c8WZgp/ - lf619rnO8x9+c/ytfzZiduIF/8Wn30teyr889GrZq565gLlHr1NfL8wXvZF/c/gt423fu/B3kwtZ77Hv - Kz/ofuj+6PPxwafUT5/+BQOY8/y6xOjTAAAACXBIWXMAAAsMAAALDAE/QCLIAAABs0lEQVQ4T51TOUsD - URjMT/FXWFhYpLCwEAQL7dIELFQQhDRWHogYRdAgrAbj1SgoghI0SBBE8cAQTJAouW9jEhLPiDLuPHeX - PFPpwLDvzTfzse/tt6bfsNvtFpVelfhFahbN1gi12KTSpygKAoEAKpUKdHBNjTV66NViP9DCZbfbLQKx - 0gdWr8oY9eQFuaZG0EOv1ETd+PSw67KE7rU4bHsZjBzmBPu3U0JjjdCa+PSwha9GLJ8X0eWK4iLxIvb1 - cJwURI0eQjuOhQ28PF+kWEOnMyzoPHvE0V0Vw/tpTHiyiDzWREiv08sMs2wgLmnxtIAO5b6BPa4wbjKv - ooGu0csMs6IBYdtNon0hJLFvM4Z89efydvwlQ6eXkBoMbcfRNncr8fn9C0/vn5jyZCSdXsJowNdxHGdh - ng0atG6E4Us+Y3ArKukkvfVHEJd4//CG1ukbiQObEbTPBxt0eusv0fiMs0dptEz6Bcf2E0JbOskZGkkP - YXxGbRaMQZrxpNA8fg3ztB+963fiyT3JGiENEqFupFEO5V5hP0jCuhIS5JoaoYXlUSa0Jv/7meqhFv/w - O5tM33TDo46olI1sAAAAAElFTkSuQmCCOwQAAIlQTkcNChoKAAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/ - YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAA68AAAOvAGVvHJJAAAAGnRFWHRT - b2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAOqSURBVDhPFZNrTNV1HId/B40Iikxb0tpKa5Wt - ViyDViihYmTDYc4XYd5Bk2ygI2AggTCRxBTkMkUxCBwDAj1BgBDXMy6Hm9xUEvJwZyXI4XDg3P7nnKd/ - L75vPntefL7P9hGYR4W0gDDaEDq0YtG2LGYtiJLeKTJ7hyjue0R+x98sSHb6BjVEFZVxKL+GnEYVZquk - EMZlq5CWLcKE5KABLrd1E5Z/m7AiJUdKUwktqCGie5jPfrlLQHQuPT0jTMtc2JVuDCaEWMKusNm0Cp0c - hpQXENjyK1HtTdwcG6JSf5fsxxlsq4tgRbqK5+L72ZlYRNPQX+T8psZoNAqxaNe9v2Axklx1G39VCHt6 - I8l99BCNzU6vbZGwgQS8S3/kw6yruMVmsCb2KFsjo9HpzbssNr2TMJpsfu0Tj/G5foYtHV8RPXSN/jkj - XZPNNGnHSL03Q7wqjz5tCHPm7XQueJJaf5D88hSsjAUJk1kiuX4a14Q0fCrPo1z4F+VwFTE133C2u4q8 - fjUa3QmWcWfO4obJ7IbFtE5ucBJsw/+bX+Kd8Hac45oJ7RwnQd3Gzjun2K5Owa96kOMNt2iYSiKzP4B1 - kS8SnuOO1fI6duNG7Ho1Yhwtr5xux7N0htjBf3jvQhJOeecQN8pxuqLh2WwNz6fX4HJhG44/vMuqoFXk - tK1l3ujGkpSAWJAbvH2xgcP9sP78COLEHzjGVOKQdBLHtO9wTSyVs2ZE5Nc4HvTE8/uVPNCuZ9b2Kuqh - WPkFG+yr1eNfNi8DrawIHsA5uBGHmAAU8S/zzLFAnA8/YOW3WbifCmXwyQYM0hpZ6Kfo7RrEDGb21szy - ZsifCI8SFFurcPGvQHFoH+KIF86Bp3H5pICoklC6tH5MSG/R3OdBX+9ZZLM3xJ3RebxzZnD9spCnP8jG - wSNdvss47j6Ow55gxKYk1nrGMb0Yjs7sRX7ZAULCI7FIeliaEuJ66yRvnFERc0uN77GrvOafyUublKze - lckLnyewenMaH++4TG7xURJjfYkOP4BkAIPVoDBYJxUit2WADbEF3LdDw72H+IVm4L2/Hp+QWnz21vPF - /haSs7KZMm2hZ9CLxqbfZfs4G7AIg31GiM7hiaAdiVVczK2lTtXFucJCUgrquFRcQY48pGulN1F1XJLF - bWZe+oi4pDgWefLUsnVeIesTwmg27K4cmfRTVldToaxAdX8EnRX0MmazjCMtjdLSWkTEzxuJ+ckX85K8 - WYNFIRmtwmBF/AcoZsuMve9BDQAAAABJRU5ErkJggrEBAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAI - BgAAAB/z/2EAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxySQAA - ABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAABIElEQVQ4T53SoU4DQRDG8RFnW9GE - EFxDkxOIOgSGUHEkCARPgKCCN0BcQjXuXgKBO0xdqw6BAIVEoQgKWTf8Z9klA+FKyya/7O7czJfL5URV - hVXgDXaxfc/q4dnksIG2Ym3GwZ0YdoF5CoghAzTuXmEczqkYLiIdnOGrOdT/CmCVeMcCT1g9gLULG9yK - hWOsFbCPV/SwgQb3qTkOLA3IcA272esfxPPdSgGp+F+/FtchkmuDm3DJdYwqnkvYkolIH+o8Ivxsnym5 - TjFECEAXL8jsucdghhMs0E0BR7hCCjhF+XPYY7jGKFxoznALjZ7Rcc0DcPwWUPmAS5wjvUGB2jW3B9C4 - jZkV2f1HtNAiNi8NqDG0IrsP6OEB9tFaAmT0AZdE/lIKPmnzAAAAAElFTkSuQmCCBAIAAIlQTkcNChoK - AAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAACXBI - WXMAAA68AAAOvAGVvHJJAAABmUlEQVQ4T7WSIZDkIBBFI0eOPDty5cjYSGQkFomMxEYikVhkZGQsMhIZ - i0Qi/3Vzmd2Z2927qqu6rvpFVcJ/TX/o/kvFdca2zFi9Qa0V5+evK+cDS7Dv8lailIBaPHKymNQAO09w - 1sDRWkp5BbKp1gUgVTIGN7XVuxkpGhgtYNQdJRJ4vUFL8RnAZpabJfZIwOyou8ERFY0hoGSPYH5gt92f - AAHWSJiJpEdMLCWatBzg9K0BpOhfAcGfAJq5ZouSNFK4vmt3F1LXzKyhv/8OmFtgNdN6aNR9RF0vsGGF - 9Stmt8DYgGn2UMZBTvYVwGHxzDUpMgvUSIEt12Z+rkLXmXPBqGcIZT4gnq6nHgTZB9TtjbpfkUPXOnP5 - JZ7akI7SzFtMGEb1C8L3WxJd3WkuS4fDd+3YXI/ObI4pQ8ipmQcxou8p0PY4dpq9mS+te6LQNM3M5ucT - OMpl3VJbWf3bDZ01BKAH8kj5IQ7sufMWj2Zeth3Lun8A+Glao9oDUeMAMdzbD06bzY9uX6kBvitOmzf8 - Tef2f62u+wlSbAABOMbXPAAAAABJRU5ErkJggrkAAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAA - AB/z/2EAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxySQAAAE5J - REFUOE/VjVsKACAIBPf+h+tKReCCkPmgPmpACGNGvEMDOkdWNXTAi7gHoshuv2BFUqJGRzjyleeaXI5Y - UjpiySSMeDI5DkzCiDy/ABifwFoLoTstugAAAABJRU5ErkJggtoAAACJUE5HDQoaCgAAAA1JSERSAAAA - EAAAABAIBgAAAB/z/2EAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwB - lbxySQAAAG9JREFUOE+1kYEKwCAIRP14/3ub4oUuE1fswSGceW5FjsvqCulDEWbWhtWKPOABZhWQn8F2 - qPEVE++BLKAM7QQc0wr9ZbNHF8glQ+oa7e1+sPti4VAVsEoTPwxBZk2g4Su0/Qvp0JeAgQxBZp1AdAOK - rlhF1QdZ1QAAAABJRU5ErkJggr0BAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAAB - c1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxySQAAAVJJREFUOE+VUiuU - wkAMrDyJrEUikVhkJfLsSeRJ7MmTyNrKysq1lStXro2MXDlMQoH7FB7kveGVTWaSnU31KIoM0LAASsF0 - 9HwUjShxiyIHaG5fEwBDhzf+tPwK0HHFIeR5EZXA7g1HHxxFvqDpcF/AOloHlZGFR8jAe+uRh90VOq6Z - oxB9KZqNcRZUiSTUNIsF7FrSB8COPr6DQo5vlLxnzY5iG3KW9KZHJX3tCaiRXgCbSFihUk3ILmKdP5+G - DKvzBJdr5H7J8d8BE3KxCT+/p/9GljSRL2EGmggS3c+7uziTu/kXSQNNjBuKbO/CJ53bTHvK2NoE64dw - AZ1ZKnvXZALxhmIYf5+ZgHk20W5RiiJ1VrQgacHCGvG4ROwbP9dQe8525p+BFi7Q1iyuMZIoiWvMsJx1 - jF3jV8zMq6R5D3LYQ/J4Jf4NlYwUuAfXfFWdAADPK6qKc5p7AAAAAElFTkSuQmCCWwEAAIlQTkcNChoK - AAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAACXBI - WXMAAA68AAAOvAGVvHJJAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAADKSURB - VDhPpZK9DsIgEIBpa6ObURdN3HzRPmUnpg506sTCBN6dd80VSQyV5OPgfr40DSbG2KSUSvTAAWgVeD8D - J743BrYOD4w04hlriNR0bs2bYRjSXmB1JNizeK79V9CTIIRQDQseJPDeV8OCOwmWZamGBZ+fOM/zBufc - Vy5nI5imqZqN4BfWWiLPkwA2eXkSNR02juNI8NAF88ATY/5US1xFwgLMrc9ZBGiUcyn2OKwEa12aJKGH - JIr8WPgCQwW+3DjmQs0LULVk3hduNfOAMxUNAAAAAElFTkSuQmCCxQAAAIlQTkcNChoKAAAADUlIRFIA - AAAQAAAAEAgGAAAAH/P/YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAA68AAAO - vAGVvHJJAAAAWklEQVQ4T2OgGfCK6vmPjqFShAFI8fv37zEw0YbADIDZjMyHKsENcCkm2pCBNQAkSSyG - akEFIAmQLYQwQQOqq6txYqIMIIQHuQuIxVAtqACbQlwYqoVSwMAAAGu3W43ADBe1AAAAAElFTkSuQmCC - AwIAAIlQTkcNChoKAAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAA - sY8L/GEFAAAACXBIWXMAAA68AAAOvAGVvHJJAAABmElEQVQ4T22SK7cCMQyEVyKRWCQSiUUikVgkkr+A - RCKxSGTl2srKytqVK1fmzhe6l+ecA93mMZkkbV5hQl+Klfvd8vls+Xi0fDpZud3cDmroN4Zh8MCixLTb - WVyvLa5W/7+03ToZcTXlCU++XLxiq8RwOFgUWWpbS1LDvZ3PLS0WljabdxJklevVsoJw8itK/ERJyVoI - ZjNL+73bnIDeqBxWkqxkpEPSp/wMEvjucn4QTKf+7Q76JvEuBVRxEvoWUa/7J4kPdjKxpNN9if4YUghu - gJl7u1w60SdJF6MVqaAdt1Mx6EL1EU4CAT3rfCWh5U72VircFrUe2LIG5yUEHJBESOhZ/pGE0wm0FdCw - 26hLHHuq4NuHJl/W0LJOklm3tzBuoidIBkiQV/MdI0mWv0gyiZ3mkuVCsRPwx8vz9TD5XyRUZnW6Fv2C - 4t4e09D33q9LVQVkIhcyl62HRmWS6b2THdT0RxUn4b2/SO15UKrW6Y5sKn8lj3CrULTnqAFRiVUFnYEW - 9U6QDWrKb3hEBQlj0ogaVtE0f/hlWz5JHN5BAAAAAElFTkSuQmCCAQYAAIlQTkcNChoKAAAADUlIRFIA - AAAQAAAAEAgGAAAAH/P/YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAAGXRFWHRTb2Z0d2Fy - ZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyJpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tl - dCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1s - bnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuMC1jMDYxIDY0LjE0 - MDk0OSwgMjAxMC8xMi8wNy0xMDo1NzowMSAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRw - Oi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiBy - ZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4 - bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9u - cy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRv - YmUgUGhvdG9zaG9wIENTNS4xIFdpbmRvd3MiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6NjQ1QTVE - QzE1NTY1MTFFMTlEMzlGQkM3NTZEQTg5QjAiIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6NjQ1QTVE - QzI1NTY1MTFFMTlEMzlGQkM3NTZEQTg5QjAiPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFu - Y2VJRD0ieG1wLmlpZDo2NDVBNURCRjU1NjUxMUUxOUQzOUZCQzc1NkRBODlCMCIgc3RSZWY6ZG9jdW1l - bnRJRD0ieG1wLmRpZDo2NDVBNURDMDU1NjUxMUUxOUQzOUZCQzc1NkRBODlCMCIvPiA8L3JkZjpEZXNj - cmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/PqSWWTYAAAJY - SURBVDhPbVJLaxNhFP2gexdCacxrEpIWUbJI2qSPpKn4iNZYGsGkWqFPRaGFaA1qYjOmaqFkEVQIFXWn - G+vOhVatxsdGdKOif8K1aNNqj/dMJ7EWLxzunMc9k8CozeN2u8uapv10Op1wOBzgJqduRuoDwHyS8Xg8 - MYaTySTy+TyKxWId5NTpM2ee/C0Q8bjH04zzFy4id0nH6PhpHB0cqYOcOn3maiX1AqvdjTMZHacms0gk - R5E4Mo744RPoTZw0dr/wRGrM8JljnndGgdPlLff2D2N5sQGP0gpX9yrMCLCk8HtR9nOFwh6FazGF24MK - 1acNYJ53RoHF1rL8eL4TeKFwr1xG5eM3TGemsCoF35/IwTOFpaUF6PpN3J+/BbxUYN5ia142Chq3tQAf - FNZey9tWKshOzCAzuA+/3ir8qCisiH5u+Biyk1eA1VdYeyO59wqNlma55y+wevDw7jjW3onxSfBF8FXw - 2eTc5NSFM7dwZwwt2/3rBXaHC7NzNxAIxdDafhBtHXHBIUGf8D7zmVrc8JmbnbsOm11bL9A0V1XXCziw - P45I1y5EI7sR7f4PRKfPnK5f5sdVNQrka3uQSqUwdXYKHcF2hDu70B0OCyIbEDZ0+swxzzujQEY+MCdy - uRxGhkYQ8AcQbAsiFAwhFBLIJqdOnznmeVcrUFarddrr9RpmOp1GT7QHvh0++HYKZJNTp89cU1PTBO/q - BTJbKbJ5YGAAhUIBpVKpDnLq9M3jLTzaWMCh2Cr/bcHlclUZroGcOn0zZ8zmgto4BX4BwzWQU/9nAKg/ - yGOuHJCHKfQAAAAASUVORK5CYILHAQAAiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAA - AXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADrwAAA68AZW8ckkAAAFcSURBVDhPpVIt - k8MgFOzfqaw8GxkZGRsZiYxFIiOxyEgkFomMxCKRkXv70nTm2ml7c9ed4WMS9uM9OAlAbNuGnAtCTHBL - gLELFh9R64b90DuUUuFD5EgIaUVYMyzJanYYpxm5lNci4i7kEFdUpigbkLkmOvu1QFuPtp/2hAflHhJb - ohYSyN0Ht1g5hbzBpYJRW0SWdlDuIWTPn0L6KZA5RQosqWJyEd0wPRdQeubBsscWYqWAlHFNUPcE2iV8 - deq5gHUejs2TmoUkzrJGqvi1wsbCZnoolnFQ7hHZPGmU1CskGbL3N/dlRadmDOOLBEyMQRmYJWKhowzH - usXZ+IxBOzSM7+bhuYCg1op+NDxs2bCwu0rsns5NN2LWLWrW70XkniMfkebjkXtveoWJ7iklNJcz4nz+ - XeQRUp6shS+x7dr/idzwkchjEm8uUEPz9xQCabgxBiJ2fPoEp9M3PYCuJ83FFLAAAAAASUVORK5CYILR - AgAAiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0 - U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJjSURBVDhPlVP9S1phGL1/6gzXbMsiolE/hBWI - +ENtOvsySwuD5leaOsNyS0VcqDms6Z1au3X7IhFELA2U0/s+w0D6ZV04cO/Le85znuc8V6hUZFxf/0Wx - eIxkMga7fQPT01OYnJyEVquFyWSCzWZDPB7DyckviGIOslzG3d0FGFcQzs4K8Hrd0Ov1MBqNcLvdiEQi - iMViODo6wuXlJZrNJur1OhOJw2q1siLryGSSuLo6hbC+bsXKygp2d3fh8XiYmJfew+EwUqkUzs/PcX9/ - j3a7jVqthnK5jM3NTczNzSKR+A6BW+WXQ6EQnE4nIRAIkItsNsuqXOHx8REPDw/kJpfLkTuNRoPV1SUI - Ozse6tPn8xEcDgdcLheJptNpSJKERqOBarWKfD6PaDRKrU5NaTA//xk0A5vNgpmZGSwsLMBisZAgb4u7 - 4U4ymQwRFxcXMT4+zvCRyH6/GzwFoVQ6ZoOxYnl5mWbAiVzAYDCQGBfl7yMjI1Cr37NCBuzvf6PkSIBD - kkRsbKyy/qLgT6fToRSCwSDMZjPGxsYwPKxmgp/YnT3Wmvgvxq4AB49lbc2Mg4MfNPlSqcSc2TE6OoqB - gXesBSMj77Nk/hD5hQCHLJewtGRiFvdQKBQwMTGBvr437OwL24MILi6Kz2SOHnIX4XCAEhFFEQqFAoOD - A2yI4Z7KXfR8dHF4GGe74MfNzQ2USiWGhj6wnfj5gszx4oAjmz2kraxUKlCpVDT5VwnwPecCrVaLfiqV - 6u3rBG5vJWxt2aHT6dDfr2SbN8u2MvH/Ahynp7+xvf2VNi4U8j3n3gtZeALAUv0zVsZhhAAAAABJRU5E - rkJggmABAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAABc1JHQgCuzhzpAAAABGdB - TUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxySQAAAPVJREFUOE/FkiFzxCAUhPMzzlaePImNRCKx - yMjI2MiTlbWVSCQWiURikUjklscknXYmySXqdiYiJN++ZaF7i6QR4JahlIJl6bxmO0EYBmF7PPV8zSCm - CGk5pOPNYFk+J1QpLyB9hQOj12sGKlTQM6jIEWO8BhtvGjgkgVlP16OPRWLMEkMW+3DOefMjQQSTScpp - 22CNRz/9LYdaXyePZtifrp3GtMScIH8vyFAEVOJQmf8z3lSIoSWgJDTxy39Cxh4y9HDeHcOrUkqtbYLo - yLh/oHePc/AqH1yDmL3X5wN75R7qWe/7Xd8gvw+O7ZVoOy+L67ruB5WO0+O4CdrNAAAAAElFTkSuQmCC - 6gEAAIlQTkcNChoKAAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAA - sY8L/GEFAAABlElEQVQ4T2NABv7VpyQ8CvZ/tUpYLAYVwgb+Q2lM4Fl0cJVr9vb/VhHTS6FC2ABuA9xy - d95zTlv/0Di45yVUCBvAboB7wQEnoO3fbWLnahgHdP63ipwRAJVCB9gNAGo+7ZS67pZZ2KRpJkHdX8zD - Jh+ESqEDTAOAmplds7Z/BNISIL5l1ExfY/+O/+ZR07TAClABpgEuWduOmYdO/GEZPjnFKmwGl7F/53uQ - Acb+7RehSpAB7kAkEmA3YGpE/tqpoZk7p0cXzZ0aVbBrorvvxR5jzRSoNDLAbsBkz8BtIHp2ZIr4VE+f - F7V6qvfAEpgAuwHT3dzAqW9mUPzMOn3V/w366mFgCQRoBGJvIAYZ4ArEXUCMCuZEZDtPcvf9X6evtgoq - hAyMgRikGYadgBgVTI0uetBlovmi1VxHHMSf4uioDZZAgC1ADNJ8DMxDBjPCs3v77e3+dxhppIL4kzxt - RbuMNZaCJREA5gpU26e4+2p3GGt+KddR+lqrpza72VBtRaWuyqtqXZW5UCXIoBpKUwMwMAAA1uqHbWt/ - 5s0AAAAASUVORK5CYILoAAAAiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IA - rs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADrwAAA68AZW8ckkAAAB9SURBVDhPvY5RDsAgCEO5 - 1g6/szEb7EBUTPaxl9QZSjvl5RZtZ1RmN2/MYe2zCL1EDOf7WEIvwUUP/F0AdgUjRQHIBTOHgjPHAi6s - ng/KghiMd+CzUR2G8P1csAr7DLhnClRhmwP3TYEqbB5ZhB0vocYwoLch/VkvLZaJyAO1fLRJwmwK3AAA - AABJRU5ErkJggkUBAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAABc1JHQgCuzhzp - AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxySQAAANpJREFUOE/VUCESgzAQjOwT+EJl - JRYZGYmNRCJjkcjIWGQlEovkCbGVlZXXy5HQQBN0uzM7d5O53dsL+x9cNQBrXysD+PDpc5B3FLrBI8W4 - 1jOMNiOOeQoXF4cofoB/2xn0PYfR3MCYEjjn9Bi2U40Rogd2nYCnvQA8GFU7F2CXAioDoCag3kvXTzuy - 7ziJwSKDyVRQbDLDXgixTxFjM/DiAc8wiifZNvW3UWyg8S8mXcKC/5GiajMGbrMTp0SOs0ZxU6XPUKqm - 2Kebc2IHKSXd5uLl6Ed/Eoy9AcV8Gi8V4zpDAAAAAElFTkSuQmCCOAEAAIlQTkcNChoKAAAADUlIRFIA - AAAQAAAAEAgGAAAAH/P/YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAA68AAAO - vAGVvHJJAAAAzUlEQVQ4T6WQIRKDMBBFOUKvUMk1egQkFhkZGYuMRNZGIiNrK5GRsStXIrfZFGgEUAg7 - 8yeZzLw3P1vsjUdPD3MjCOf0dHxm+Ok1VfZ+TrLAoEm6hiya45If3EVY+YZaEGRHQ/Wr3JekMIPKiwi3 - IElhQ/343JZsw4I6VNRiuIdsSsygoyANwxrlUj9N77r1r9A0URDgRWDL/wtMhwUMc+18wTgv74JAYv1d - XI6A60us8gVcX0AQYKZAQn1NwKCZclrg4B2hOQ6GFUFRfAC3eSsPJ8swNwAAAABJRU5ErkJggkABAACJ + NOi7Gl1zRVNfcL1UOFclqrJAUeTI8xMK0oH+xWTZF9s+A36qvos7AAAAAElFTkSuQmCCDQIAAIlQTkcN + ChoKAAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/YQAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsEAAA7B + AbiRa+0AAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAYlJREFUOE+tkiGPhDAQ + hbl/cPLsypPIWiSyEotEVmKRlSuxyMpKLBKJxFYikXPvtUtgN5sTl5vkJRu275uZ12b/Ut7vcsg5aNhk + gPo+yP0exFqoW6WD2nYRY6BmkYc9AcZRcFh+rR0qq1Gqykc97FnGrgRYu6WTb4rmbdtF6VHyvBat3Qng + uAR0XUinX+owr2GXvPRYYwVgOAF9nwDGrMlxqat5WTf5LlzMQJf9BYCgCGgQzLVezdMS5KsYpK5nKa8A + Jk0A/zjqnXmcg3yqAQFOANxPgLVrBHifIJoHkHYMDDtzbHY+zBrfi8KeAN4vzc4J7p+3sSPQLYbKwLgz + 1zvMpfbPAD6OaO75FnZ0N0/StZGqaZMZExWlA6A7AexwmNmZJnyWXBUyY39mUJsuGSGFdZRqLwCM1wNw + jE0AzU1rEeImAUEa/M5phHLVPwOaZn7sHeSGwG55Ic5P4sdJxmmWaea16Wg8pFScMhU6fNQ1A3LxhfGR + 8J55VQwrqYtdkzBh3pyAv1eW/QDDmDyIp69ltgAAAABJRU5ErkJggp8CAACJUE5HDQoaCgAAAA1JSERS + AAAAEAAAABAIBgAAAB/z/2EAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwgAA + DsIBFShKgAAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAACDklEQVQ4T2MgFrgX + H0xgZGZlgnJJA1ohy/hdq67/dM7fkwgVwg8cUzcJBdeey3Uvv7jcufziNufKS3vtK279d62+/tYkYpYM + VBl2EFBxItC97Mpby/xr/01yr/03yr3+3zD/xn+jwpv/TUpu/7ctObcBqAy7V/xKj/ta5V7+o5d6/p9m + 3LEHWonHr+pmXPxkWHjrv0nZ3f/mVff/29Y/+O9QfCgaqgUBzGPXClhknH6uHbFlrpJ9lTZQiA2ImVX9 + Z6ibV937b13/8L9t06P/lhUXjxkkrnEDa0IGjunb/LV8JnsAmSjOsyi/nGhdf/+PecmZTZrh8xyAQiwQ + GUzACKVRgFHWfndl7x59IJMZIkIkcCw+pupScSIIyiUeuJUeN/NuurnGt+fxH9eqo3VQYTiInvrANKzz + bBqUiwCeJcct3Kuu7HdtuPvfrfXR/4AJz/8bxy5yhkozuNWfV0xb9b4/e9OXd8bhPSpQYQQwTdxhZ1d+ + 869T/f3/7u2P//sBDQie9vJn8MyXt8MXvX+UuuXXv8xdf/8Fdh7NACrHGl4MlnmnJ4MMcGx+9N+589l/ + r8lv/gfN//Q/es2P/8kbvn7y7wBrxh2YKt5TeI0Lr961qnv436ry4mHnpmtbvLpurPRpP1um6lEjC1SC + 3WZkoJu8z8Wi6s4feecGdSCXsAZsQDdhGyjX4UwwCMDAAADxRdlk7n1DlQAAAABJRU5ErkJggkQBAACJ UE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xh - BQAAAAlwSFlzAAAOvAAADrwBlbxySQAAANVJREFUOE+lkqsSwyAQRfMJ/YXKfkJtZCUSGxmJjI1EIrHI - yMjaykgkFrmycsvSbNrMdDIJvTNXwTk8Zqtf8fGBtTst9XHCeWlfCLKgcw10KO+X44IeFHbQ4vC0ZQKd - BU25oE+nK5DlAjr9T4HMAlcqIFiBQAemTNAmuI07BW7Sq8HJggRT7Sz47uDNWhggoBjTQnov/f4bvmET - bqiCRBvTQAWNQ3RZENP+Gf2EJXRlAqnS17lium7DHJaYmMb3KMxhiQ7dAovxvA/msGQsgTks2Yar6gWi - aB5TNw92LAAAAABJRU5ErkJggvkDAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAAE - Z0FNQQAAsY8L/GEFAAAACXBIWXMAAA6/AAAOvwE4BVMkAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQg - djMuNS4xMDD0cqEAAAN1SURBVDhPbZNrUJRlGIa/JXGL06KyoZZCA3kgtXIcKmYKRyVTbARJ2sXlGCuC - KCwU6bIsISgeQDJJA4IhYHEBUSIJGJihIkhEflAzkD+IoS11OMTADOeBq4/PGc2Zftzvv+t63vd55xaA - x/lzeOC38o4yjLUniSqPILj4Qw6XhmO8oae6vQrLQwuzs7NW/2WkY35+3qrrjy4yGlI405zKuZY0MpoN - pDYmoa9PIL4mmsiyEFIq9HTf6/56ZmZG9pSgs+8OafV6vmzLxtCQSMyNMKKuB6OtOsRHFWoizGoizUGo - i/2JztfS0d3B9PR0jiQYGh98JrPpFLltWSTVHePI9RAJjKwMIkKEw8oD0ZQFoCrx42Dx++y77ENy0Unu - P7gv8iiFyttm0hsN6OviOVylkcBQEWrubWBhYYGzjekEFPmyv2A3vnm78Ml9B2+DF00/NzE3NycT0m8Z - Od2cIk2OMKsIvRYoXtWP73/9ThKk1iSzTwR3X9nOzstv4/35m2w1bOZ0fjpjY2OCEFUSLk5PIKT8INoK - DZd+ukBWcyZ3+zslQfkvZaTXG0mqSeCN86+zNXMLrxjXE2zQMDIyIhPUVwLQiVs+VHqAWLNWgv4vf//z - Fx6p69iY9jLuKa7sOfYeQ0NDMkGV+wFHKsM5ULiXwKv+1N25RW17Lf0P+iWwo+c2N1tvUtRUyNqPX2DN - idWs1Cnx0+1neHhYELRfhaP5JpC9V3fgfeEttnziwbpYN0wtZZIgPCcU5wglSq0TzglKnBKXo9A6EJMR - zejoqCBkVZ1nz8VdbL/khVf2Nrade5VNn23gWrvpkSAvlJVJz7MiQQTjHLCLtcVRraCwspDx8XFB+PHu - D7xr3IGnuKDXzmzC49R63JJd8EnbSXCmho2JG1gWr8D+uB02R59Drl2Kp9aTzq7OR984NTVlKKguaNms - 88DN4IKL/kVWJznjdHwZDlH22MXYYhMrgjFyrLXWuIe5k1eax+DgoNSJxR4IA5YB4cQXn8pcI9egjFvB - cp0jDnH22Mba8OxROUujrVkSuoRVqlUYLhro/b1XJj7vSRcWMzExIZi+NVn56nx5KcQVxyAFcpUchUqB - q9oV/3j/hyXmktq+vr7HRXpKsJjJyUmh516PzFxrluUU5dhk5Gaszc7PlpmqTUJrW6tgsVikGz9hEP4F - FdR7LL8mfOEAAAAASUVORK5CYIK1AwAAiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAA - AXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADrwAAA68AZW8ckkAAAAHdElNRQfaCxkL - Kg/WMYK1AAAAB3RFWHRBdXRob3IAqa7MSAAAAAx0RVh0RGVzY3JpcHRpb24AEwkhIwAAAAp0RVh0Q29w - eXJpZ2h0AKwPzDoAAAAOdEVYdENyZWF0aW9uIHRpbWUANfcPCQAAAAl0RVh0U29mdHdhcmUAXXD/OgAA - AAt0RVh0RGlzY2xhaW1lcgC3wLSPAAAACHRFWHRXYXJuaW5nAMAb5ocAAAAHdEVYdFNvdXJjZQD1/4Pr - AAAACHRFWHRDb21tZW50APbMlr8AAAAGdEVYdFRpdGxlAKju0icAAAJjSURBVDhPjZLdS5NhGMZ3HP0D - HXTYYX9AUIHQgXmw1Iz5MZ2bTXRT1zZN2lf66vyIzSxbZc4p+JGhEXM2EsXSCk1admAGUWggeZAZnShF - +ut5NhamEzq43pfnua/ruu/nvm8V8F9wKD4uOgbJv9RNpq5aXCXu9xFTwe1to6L5CaHIOwrKnNx/MCyu - E7F95FTQ2nuY+whGqxIXL76di/9lJSkFe5FTcZenSwmDpFhWorF0pxbsRrC3n6zyAJEYDE8sxU0kXIGX - aGv6UouS6OgMxcXNPQv0PgN/BJTBDRzBVfSeCDXu1tRCiaR49DXYbixQqkyRrvORYbiOuvQmJludoB3Q - xKT4zsALcs9nUZSbjT4vG1PhOYz5anpDXYKW4B4oDo4t4zSehF+LsDUJP2dh8zE7GyFclhJezU4L+h6D - 3WXnFJj4NK7A11r4Xs/OWhUsZ0DsOG86juKtdyUMvL5bVDaMYLsWxS06K7ttdA7RaNOLrMJp4yqKx4RG - a6TNo4MFNTw8TIOIT46PopJiuSRyzlLcN4Mgl7M6PygyN7K54hLnivj8bWYzv9fCYp7HWO86jc9bh6qw - uod8a5AW/22qar0ExXMzCq7gqiqGH362P2swFakprXRxz62FbyLDSBqtNXomoo9QZRVa/q6nNPEOfOGs - oR1jSQkr0x54f4rt2Bm2VobZWRfLEE4n7Eijpd6Z6IH8SEgTWYk98AGtvZvoWJi8nExikQvibYdE2UdE - 5hNMNaVTZzXwfGbqXwONoZqiy/2YlRGa/IF4sDPQjrVMh71cR625GGdlMW7xtNGh5B6g+gOoVtefNoYj - bQAAAABJRU5ErkJggmADAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAABc1JHQgCu - zhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxySQAAABp0RVh0U29mdHdhcmUAUGFp - bnQuTkVUIHYzLjUuMTAw9HKhAAACz0lEQVQ4T3WPW0hTcRzHfbDEpERzK0wxY6ZZmYpR4LW84PUU3sjw - slnelqKlVggZGQ5xRqUUuswUdWW6tNQinWLq8LaZt9Qm/R6jwIfz6Nu3/9nWQyw/8OX8OHy/n53ZeBd3 - i85Ufay6pNQOSZ9NUFHL1I5cNY0i1RQKTZk0PfObJ3eyGieIU2r7hf6JYrXIRkBS2quoVM8isHYUHg/G - 4VYzBa/6efg3LiNYtYnAplX4NCzA/eE0PGvG4V87hsI2HY6X9TWYBJ5FXcqGKUL54DpKNEu40fsVt96t - ovL9Bu4OGVE+sMHerUDauYirbfNIU80ir0MPSbFaaRIck3cplZME6QeCbIhQ+IlwbZCQqSGkqI1IaP+G - iy0rCGnSI+jRLHwV00htnoF3Sc9jk8A1/maUtN3Aj60RmqYJjTpC3QShYpiQpzEirXMNUc1LCG5cgF+d - DqVqPcIUn/kj8eXRJgHDThQm5VJeGPj7Y4Qc9uuFbJzdT0h/bQTXsY5olSDQI69rESEKLX8oQsYJO/Pc - jEmSrDLwVVpCEfsb+UyU1fcDqd2biGtdRa56BaH1X3hxRK7V+C92YiZJajHwFaMEOZPkDhCu9GxB+vY7 - gp/MbztGFuw6/guT5HBJ7EtKRggF7CukTJKmHMFAdNivtexErORw0EcGjI14HfSxbKxgkmyuskePjN4t - lL7SYSYhBCSLA50VmyNLwCIX+lN11MnJsrHiQFnXHJLfGKG+Uw2SxoKCXNhYZI5w5yZiROJ829K3wiGv - Yw6pPUZ0yMtAif4gon+TGIBhiUu9pW+FQ+pzHZ/Ra4RCfg8UexoUcxIU5WuOcMf5QyMRVVv6VtiKw2VJ - UU9n+POKCRiC3H5TejgoLcwcds+fk2zHONp7Wfr/xe7wheuce37ry0xn+8vaQI/F5Ug/CBHuAtH+WNbZ - Y67uji3LPpa9LK4spywRbja2sfkDNmCxwsesQzEAAAAASUVORK5CYILXAQAAiVBORw0KGgoAAAANSUhE - UgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsIA - AA7CARUoSoAAAAAHdElNRQfWAxoOERLaSefrAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4x - MDD0cqEAAAEzSURBVDhPYxg8YNbs6RcaGhr+E4N7+7tWQ7UhAEiCWABSC9WGADADPnx4jxeDQH8kEwzH - QLWjGnD8+DGsGCQH0vju1bH/59cWgtlQ7cS5AKTh/evj/y+tyfq/sDn0D04DsNmOrHlJeziYD8TGUO34 - XQBS/PbZ0f/nV2X+X9AchqkZBHC5AKz56ZH/J+an/F/QArG5syEL5nRGKI3dBe/fv/tfEG35/9Dqrv+L - W0PBmp/fOQWLRpBmVAP+/fuLohmkwcdJ7X92uBmYfebgeqD4e5gBrBCdUAAS/PXrJ9yAd+/eghSBNW5e - Oe3/oUOH/p8+fer/o0ePYAZwgDXCAEgQGfz79+//9+/f/798+RKs6enTp/9fvXqF7AI2iE4o6OnrXAyS - IAZ393YsBmpB+J98wMAAAEBy/BniHbchAAAAAElFTkSuQmCCCw== + BQAAAAlwSFlzAAAOvAAADrwBlbxySQAAANlJREFUOE/FkiESgzAQRXOdSmQtMjIyFhkZGYtEVmIjK5Fc + gSPUVlZWbvcnhAamoRXt9M+8yZLdv1kg4us6nIiEvUeSpH/GJTVnNqJwixriuqfhUjDn7ArjclEYP2ne + SzjnViglSdYVLaeHNVcafYbTK06tIaO5Qd0TuXFjzoyJK5tyutRgNXYmJFF0y0x5vExQEpIo2hpTvExQ + EpJ9K6lz6iXIvW0wdhU16hjRNRsieEbuowb4ZdZa8t7TNE0B7P2+AdSoKl4YKUlrTcbwh2Owh9cIF+nP + EuIBLcFGpm/L2l4AAAAASUVORK5CYIKCDAAAiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9h + AAAABGdBTUEAALGOfPtRkwAAACBjSFJNAACHDwAAjA8AAP1SAACBQAAAfXkAAOmLAAA85QAAGcxzPIV3 + AAAKOWlDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAEjHnZZ3VFTXFofPvXd6oc0wAlKG3rvAANJ7k15F + YZgZYCgDDjM0sSGiAhFFRJoiSFDEgNFQJFZEsRAUVLAHJAgoMRhFVCxvRtaLrqy89/Ly++Osb+2z97n7 + 7L3PWhcAkqcvl5cGSwGQyhPwgzyc6RGRUXTsAIABHmCAKQBMVka6X7B7CBDJy82FniFyAl8EAfB6WLwC + cNPQM4BOB/+fpFnpfIHomAARm7M5GSwRF4g4JUuQLrbPipgalyxmGCVmvihBEcuJOWGRDT77LLKjmNmp + PLaIxTmns1PZYu4V8bZMIUfEiK+ICzO5nCwR3xKxRoowlSviN+LYVA4zAwAUSWwXcFiJIjYRMYkfEuQi + 4uUA4EgJX3HcVyzgZAvEl3JJS8/hcxMSBXQdli7d1NqaQffkZKVwBALDACYrmcln013SUtOZvBwAFu/8 + WTLi2tJFRbY0tba0NDQzMv2qUP91829K3NtFehn4uWcQrf+L7a/80hoAYMyJarPziy2uCoDOLQDI3fti + 0zgAgKSobx3Xv7oPTTwviQJBuo2xcVZWlhGXwzISF/QP/U+Hv6GvvmckPu6P8tBdOfFMYYqALq4bKy0l + TcinZ6QzWRy64Z+H+B8H/nUeBkGceA6fwxNFhImmjMtLELWbx+YKuGk8Opf3n5r4D8P+pMW5FonS+BFQ + Y4yA1HUqQH7tBygKESDR+8Vd/6NvvvgwIH554SqTi3P/7zf9Z8Gl4iWDm/A5ziUohM4S8jMX98TPEqAB + AUgCKpAHykAd6ABDYAasgC1wBG7AG/iDEBAJVgMWSASpgA+yQB7YBApBMdgJ9oBqUAcaQTNoBcdBJzgF + zoNL4Bq4AW6D+2AUTIBnYBa8BgsQBGEhMkSB5CEVSBPSh8wgBmQPuUG+UBAUCcVCCRAPEkJ50GaoGCqD + qqF6qBn6HjoJnYeuQIPQXWgMmoZ+h97BCEyCqbASrAUbwwzYCfaBQ+BVcAK8Bs6FC+AdcCXcAB+FO+Dz + 8DX4NjwKP4PnEIAQERqiihgiDMQF8UeikHiEj6xHipAKpAFpRbqRPuQmMorMIG9RGBQFRUcZomxRnqhQ + FAu1BrUeVYKqRh1GdaB6UTdRY6hZ1Ec0Ga2I1kfboL3QEegEdBa6EF2BbkK3oy+ib6Mn0K8xGAwNo42x + wnhiIjFJmLWYEsw+TBvmHGYQM46Zw2Kx8lh9rB3WH8vECrCF2CrsUexZ7BB2AvsGR8Sp4Mxw7rgoHA+X + j6vAHcGdwQ3hJnELeCm8Jt4G749n43PwpfhGfDf+On4Cv0CQJmgT7AghhCTCJkIloZVwkfCA8JJIJKoR + rYmBRC5xI7GSeIx4mThGfEuSIemRXEjRJCFpB+kQ6RzpLuklmUzWIjuSo8gC8g5yM/kC+RH5jQRFwkjC + S4ItsUGiRqJDYkjiuSReUlPSSXK1ZK5kheQJyeuSM1J4KS0pFymm1HqpGqmTUiNSc9IUaVNpf+lU6RLp + I9JXpKdksDJaMm4ybJkCmYMyF2TGKQhFneJCYVE2UxopFykTVAxVm+pFTaIWU7+jDlBnZWVkl8mGyWbL + 1sielh2lITQtmhcthVZKO04bpr1borTEaQlnyfYlrUuGlszLLZVzlOPIFcm1yd2WeydPl3eTT5bfJd8p + /1ABpaCnEKiQpbBf4aLCzFLqUtulrKVFS48vvacIK+opBimuVTyo2K84p6Ss5KGUrlSldEFpRpmm7Kic + pFyufEZ5WoWiYq/CVSlXOavylC5Ld6Kn0CvpvfRZVUVVT1Whar3qgOqCmrZaqFq+WpvaQ3WCOkM9Xr1c + vUd9VkNFw08jT6NF454mXpOhmai5V7NPc15LWytca6tWp9aUtpy2l3audov2Ax2yjoPOGp0GnVu6GF2G + brLuPt0berCehV6iXo3edX1Y31Kfq79Pf9AAbWBtwDNoMBgxJBk6GWYathiOGdGMfI3yjTqNnhtrGEcZ + 7zLuM/5oYmGSYtJoct9UxtTbNN+02/R3Mz0zllmN2S1zsrm7+QbzLvMXy/SXcZbtX3bHgmLhZ7HVosfi + g6WVJd+y1XLaSsMq1qrWaoRBZQQwShiXrdHWztYbrE9Zv7WxtBHYHLf5zdbQNtn2iO3Ucu3lnOWNy8ft + 1OyYdvV2o/Z0+1j7A/ajDqoOTIcGh8eO6o5sxybHSSddpySno07PnU2c+c7tzvMuNi7rXM65Iq4erkWu + A24ybqFu1W6P3NXcE9xb3Gc9LDzWepzzRHv6eO7yHPFS8mJ5NXvNelt5r/Pu9SH5BPtU+zz21fPl+3b7 + wX7efrv9HqzQXMFb0ekP/L38d/s/DNAOWBPwYyAmMCCwJvBJkGlQXlBfMCU4JvhI8OsQ55DSkPuhOqHC + 0J4wybDosOaw+XDX8LLw0QjjiHUR1yIVIrmRXVHYqLCopqi5lW4r96yciLaILoweXqW9KnvVldUKq1NW + n46RjGHGnIhFx4bHHol9z/RnNjDn4rziauNmWS6svaxnbEd2OXuaY8cp40zG28WXxU8l2CXsTphOdEis + SJzhunCruS+SPJPqkuaT/ZMPJX9KCU9pS8Wlxqae5Mnwknm9acpp2WmD6frphemja2zW7Fkzy/fhN2VA + GasyugRU0c9Uv1BHuEU4lmmfWZP5Jiss60S2dDYvuz9HL2d7zmSue+63a1FrWWt78lTzNuWNrXNaV78e + Wh+3vmeD+oaCDRMbPTYe3kTYlLzpp3yT/LL8V5vDN3cXKBVsLBjf4rGlpVCikF84stV2a9021DbutoHt + 5turtn8sYhddLTYprih+X8IqufqN6TeV33zaEb9joNSydP9OzE7ezuFdDrsOl0mX5ZaN7/bb3VFOLy8q + f7UnZs+VimUVdXsJe4V7Ryt9K7uqNKp2Vr2vTqy+XeNc01arWLu9dn4fe9/Qfsf9rXVKdcV17w5wD9yp + 96jvaNBqqDiIOZh58EljWGPft4xvm5sUmoqbPhziHRo9HHS4t9mqufmI4pHSFrhF2DJ9NProje9cv+tq + NWytb6O1FR8Dx4THnn4f+/3wcZ/jPScYJ1p/0Pyhtp3SXtQBdeR0zHYmdo52RXYNnvQ+2dNt293+o9GP + h06pnqo5LXu69AzhTMGZT2dzz86dSz83cz7h/HhPTM/9CxEXbvUG9g5c9Ll4+ZL7pQt9Tn1nL9tdPnXF + 5srJq4yrndcsr3X0W/S3/2TxU/uA5UDHdavrXTesb3QPLh88M+QwdP6m681Lt7xuXbu94vbgcOjwnZHo + kdE77DtTd1PuvriXeW/h/sYH6AdFD6UeVjxSfNTws+7PbaOWo6fHXMf6Hwc/vj/OGn/2S8Yv7ycKnpCf + VEyqTDZPmU2dmnafvvF05dOJZ+nPFmYKf5X+tfa5zvMffnP8rX82YnbiBf/Fp99LXsq/PPRq2aueuYC5 + R69TXy/MF72Rf3P4LeNt37vwd5MLWe+x7ys/6H7o/ujz8cGn1E+f/gUDmPP8usTo0wAAAAlwSFlzAAAL + DAAACwwBP0AiyAAAAbNJREFUOE+dUzlLA1EYzE/xV1hYWKSwsBAEC+3SBCxUEIQ0Vh6IGEXQIKwG49Uo + KIISNEgQRPHAEEyQKLlvYxISz4gy7jx3lzxT6cCw780387Hv7bem37Db7RaVXpX4RWoWzdYItdik0qco + CgKBACqVCnRwTY01eujVYj/QwmW32y0CsdIHVq/KGPXkBbmmRtBDr9RE3fj0sOuyhO61OGx7GYwc5gT7 + t1NCY43Qmvj0sIWvRiyfF9HliuIi8SL29XCcFESNHkI7joUNvDxfpFhDpzMs6Dx7xNFdFcP7aUx4sog8 + 1kRIr9PLDLNsIC5p8bSADuW+gT2uMG4yr6KBrtHLDLOiAWHbTaJ9ISSxbzOGfPXn8nb8JUOnl5AaDG3H + 0TZ3K/H5/QtP75+Y8mQknV7CaMDXcRxnYZ4NGrRuhOFLPmNwKyrpJL31RxCXeP/whtbpG4kDmxG0zwcb + dHrrL9H4jLNHabRM+gXH9hNCWzrJGRpJD2F8Rm0WjEGa8aTQPH4N87Qfvet34sk9yRohDRKhbqRRDuVe + YT9IwroSEuSaGqGF5VEmtCb/+5nqoRb/8DubTN90w6OOqJSNbAAAAABJRU5ErkJggjsEAACJUE5HDQoa + CgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAAlw + SFlzAAAOvAAADrwBlbxySQAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAADqklE + QVQ4TxWTa0zVdRyHfweNCIpMW9LaSmuVrVYsg1YooWJkw2HOF2HeQZNsoCNgIIEwkcQU5DJFMQgcAwI9 + QYAQ1zMuh5vcVBLycGclyOFw4Nz+55ynfy++bz57Xny+z/YRmEeFtIAw2hA6tGLRtixmLYiS3ikye4co + 7ntEfsffLEh2+gY1RBWVcSi/hpxGFWarpBDGZauQli3ChOSgAS63dROWf5uwIiVHSlMJLaghonuYz365 + S0B0Lj09I0zLXNiVbgwmhFjCrrDZtAqdHIaUFxDY8itR7U3cHBuiUn+X7McZbKuLYEW6iufi+9mZWETT + 0F/k/KbGaDQKsWjXvb9gMZJcdRt/VQh7eiPJffQQjc1Or22RsIEEvEt/5MOsq7jFZrAm9ihbI6PR6c27 + LDa9kzCabH7tE4/xuX6GLR1fET10jf45I12TzTRpx0i9N0O8Ko8+bQhz5u10LniSWn+Q/PIUrIwFCZNZ + Irl+GteENHwqz6Nc+BflcBUxNd9wtruKvH41Gt0JlnFnzuKGyeyGxbRObnASbMP/m1/infB2nOOaCe0c + J0Hdxs47p9iuTsGvepDjDbdomEoisz+AdZEvEp7jjtXyOnbjRux6NWIcLa+cbsezdIbYwX9470ISTnnn + EDfKcbqi4dlsDc+n1+ByYRuOP7zLqqBV5LStZd7oxpKUgFiQG7x9sYHD/bD+/AjixB84xlTikHQSx7Tv + cE0slbNmROTXOB70xPP7lTzQrmfW9irqoVj5BRvsq9XjXzYvA62sCB7AObgRh5gAFPEv88yxQJwPP2Dl + t1m4nwpl8MkGDNIaWein6O0axAxm9tbM8mbInwiPEhRbq3Dxr0BxaB/iiBfOgadx+aSAqJJQurR+TEhv + 0dznQV/vWWSzN8Sd0Xm8c2Zw/bKQpz/IxsEjXb7LOO4+jsOeYMSmJNZ6xjG9GI7O7EV+2QFCwiOxSHpY + mhLieuskb5xREXNLje+xq7zmn8lLm5Ss3pXJC58nsHpzGh/vuExu8VESY32JDj+AZACD1aAwWCcVIrdl + gA2xBdy3Q8O9h/iFZuC9vx6fkFp89tbzxf4WkrOymTJtoWfQi8am32X7OBuwCIN9RojO4YmgHYlVXMyt + pU7VxbnCQlIK6rhUXEGOPKRrpTdRdVySxW1mXvqIuKQ4Fnny1LJ1XiHrE8JoNuyuHJn0U1ZXU6GsQHV/ + BJ0V9DJms4wjLY3S0lpExM8bifnJF/OSvFmDRSEZrcJgRfwHKGbLjL3vQQ0AAAAASUVORK5CYIKxAQAA + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADrwAAA68AZW8ckkAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRy + oQAAASBJREFUOE+d0qFOA0EQxvERZ1vRhBBcQ5MTiDoEhlBxJAgET4CggjdAXEI17l4CgTtMXasOgQCF + RKEIClk3/GfZJQPhSssmv+zu3MyXy+VEVYVV4A12sX3P6uHZ5LCBtmJtxsGdGHaBeQqIIQM07l5hHM6p + GC4iHZzhqznU/wpglXjHAk9YPYC1CxvcioVjrBWwj1f0sIEG96k5DiwNyHANu9nrH8Tz3UoBqfhfvxbX + IZJrg5twyXWMKp5L2JKJSB/qPCL8bJ8puU4xRAhAFy/I7LnHYIYTLNBNAUe4Qgo4Rflz2GO4xihcaM5w + C42e0XHNA3D8FlD5gEucI71Bgdo1twfQuI2ZFdn9R7TQIjYvDagxtCK7D+jhAfbRWgJk9AGXRP5SCj5p + 8wAAAABJRU5ErkJgggQCAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAABc1JHQgCu + zhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxySQAAAZlJREFUOE+1kiGQ5CAQRSNH + jjw7cuXI2EhkJBaJjMRGIpFYZGRkLDISGYtEIv91c5ndmdvdu6qruq76RVXCf01/6P5LxXXGtsxYvUGt + FefnryvnA0uw7/JWopSAWjxyspjUADtPcNbA0VpKeQWyqdYFIFUyBje11bsZKRoYLWDUHSUSeL1BS/EZ + wGaWmyX2SMDsqLvBERWNIaBkj2B+YLfdnwAB1kiYiaRHTCwlmrQc4PStAaToXwHBnwCauWaLkjRSuL5r + dxdS18ysob//DphbYDXTemjUfURdL7BhhfUrZrfA2IBp9lDGQU72FcBh8cw1KTIL1EiBLddmfq5C15lz + wahnCGU+IJ6upx4E2QfU7Y26X5FD1zpz+SWe2pCO0sxbTBhG9QvC91sSXd1pLkuHw3ft2FyPzmyOKUPI + qZkHMaLvKdD2OHaavZkvrXui0DTNzObnEzjKZd1SW1n92w2dNQSgB/JI+SEO7LnzFo9mXrYdy7p/APhp + WqPaA1HjADHc2w9Om82Pbl+pAb4rTps3/E3n9n+trvsJUmwAATjG1zwAAAAASUVORK5CYILhAgAAiVBO + Rw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUA + AAAJcEhZcwAADsIAAA7CARUoSoAAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAA + AlBJREFUOE9jAIFvZ09Kfdy8zuj1yhVsYAEC4F58PMuzpFjjkzZWygxvNq5IeNFc8u1lU9H/132N947l + p7lB1WGAu7HRfG86GxvvFKQ/WmRuONudi0OR4WBxVvfT2ry/b6e2/383qeX/h5aS/7fiA/sdJKVYofrA + 4GlmfPibquwXh6ODrycJCVkDhRghMkDQ6eFqc7Yw/cS7tvL/b4ri/78MsPx/z0b9QIu2Ju+d2CjBB84G + qx/Za/xfpKO6RIaRSQCqDR0wMs+zMEy46mr84pmJxP/bSqz/T2sInT6jL/3wsBTL7xZhvkqgImaIWjzA + h19AeL007/xTMkz/D0ky/N8vxfw/T5AvASiFcDI+8Lggn/Gci1n7cVXe/yfV+P6fVGD7v09DfBpUGj+4 + GxPDfM3DfPEpTYH/561U/zZLiVVcMFa4fl2D7/82TalIqDLc4Gag4+JzOkL/LxpK/u+Rl2oACjEWioqI + XDJTvnhZX/xtl7K8BEQlFnAn3LPhorn8/wv6Yv8XyouuBQqxQGQYGBrlpKWvmik+PqYlthAqhAouRfpb + 33HR/XvBQOL/Lg3xF6YcXGJQKTiYpy5vdk9L6MdMBQl9qBACPInyOnLDWef/RSOp/+2SohlQYQywX028 + 6riaJKordqlr8DxLCvp728Po/zkjuf+qLGxSUCkMIMPJyXJCVem0GhsbN1SIgcGGX4DrTUbEr/sBVv8P + GCq+4mJk5IBKYQUrNNRcSwUFLaBcCNjlaF59zs38W4ucZBpUiBDATFTAfAxK48SlNjhgYAAAGkDLSg+k + y2kAAAAASUVORK5CYILaAAAAiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IA + rs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADrwAAA68AZW8ckkAAABvSURBVDhPtZGBCsAgCET9 + eP97m+KFLhNX7MEhnHluRY7L6grpQxFm1obVijzgAWYVkJ/BdqjxFRPvgSygDO0EHNMK/WWzRxfIJUPq + Gu3tfrD7YuFQFbBKEz8MQWZNoOErtP0L6dCXgIEMQWadQHQDiq5YRdUHWdUAAAAASUVORK5CYILJAgAA + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAJzSURBVDhPtZJdSFNhGMffcza7EKWorrsQEjK7sZuKRKJMKrzoMkIqmRVFJqhB9oFiZJKiVBKV + kShqwnQRtZVYLlFJVpq5/MiPbdqmZttZzdp23rP9e5ynQozwph/8Oc95nuf/vM97OOy/UZwuih5jmkky + 7Xt+65BGo6ZXztSN6DPcMwAuDcJZFZOjpleGXqdZ6+3IcSMcwoK+duVLrdna9Wr531RmxAiuBwm1is+G + MJciUuYdcNYkNlbrYkW1bSlPdJotw4VRZ+1VcfVzrUcng+5XCAXtCHHboiiWPZ348iLL6bgd3/SxaFVe + 2ylNUsTcX7r9vGS+gOC4CcqMBYqnD4rvHZQAifcuaiGeJ0lUm30D2dYKb2cxrBU7i1jDfu2usbojijzU + Am43gs+0gXvaoXwzk4n0nbQQU47PUm3SCHnEgAl9dqjloHZ3ZIv6VE2urUEXlgfvgdvqwF0PoXzWQ3E3 + L2pODz7dBO6oI3M17C15aEyLyo+Yf1GzTVvmepQB+UMh+Pg18KlyKNMVEXFnOW1XimCfDs7arbifJFaq + tj9kxTPRcnHdUKB7D4L9e+mkVPCJFPCxJBq6AYEuEX4Tw9sCYTQ3gf39x+ovEDr8RoZANyMTo+uQHKRR + hmAvg/8lg7VIeK22L8d6WRjxP6NmC5nGGN2dISTR8xMNtNLgDoahEmFKbV/OcLHg+/GUBvQwzA/QuncY + LHcZfCM0gN4D7Qyj5QI/sYkJqmUpw1dE2dsswFoqeA3p7PrNZLaxbAeLMxxgV9+XCG7psUADxPBx+l6q + ZSnmzNUnDSns2KVEFqumfnNuM4vWJ7PD5sw1p9UUwdhPMtmihmnOUQAAAAAASUVORK5CYIJbAQAAiVBO + Rw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUA + AAAJcEhZcwAADrwAAA68AZW8ckkAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAA + AMpJREFUOE+lkr0OwiAQgGlro5tRF03cfNE+ZSemDnTqxMIE3p13zRVJDJXk4+B+vjQNJsbYpJRK9MAB + aBV4PwMnvjcGtg4PjDTiGWuI1HRuzZthGNJeYHUk2LN4rv1X0JMghFANCx4k8N5Xw4I7CZZlqYYFn584 + z/MG59xXLmcjmKapmo3gF9ZaIs+TADZ5eRI1HTaO40jw0AXzwBNj/lRLXEXCAsytz1kEaJRzKfY4rARr + XZokoYckivxY+AJDBb7cOOZCzQtQtWTeF24184AzFQ0AAAAASUVORK5CYILUAgAAiVBORw0KGgoAAAAN + SUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6JQAAgIMAAPn/AACA + 6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsSAAALEgHS3X78AAACSklEQVQ4T6WS2UuUURjG + /XO6iJC8qGyBlAhJKcqFTBy11CStXFIsk9yaCzNsnUozG9d0CMkZdxtGs9wzZ1xDIjHIJjXGXGqc79d3 + vmD0U/CiLp4D5+F9fud9X44H8F/aYowOWKI/T1qZtPbyoaedrtaXNBqKqS3JD9xcK6S62PrMsVMj/SzP + TeByjCAt9CDZW5kbK+NZ4VWK8lOObqwXUl3Gh7pYstuYHmniVmYceakaspPOMNOdy2xfJrnJoXLZNoDB + ThPSj16yEkNJjfbfI7wrZ/28yh/fRJpIJz32uGxtA+gwloG9iZRI0em6X/FIizSWRKLGV+ULKUenUe9p + rntKy4sHNFQWUq8voE6fj6FIS01xHlW6bMof3kB/9zqlhdeEPFWAtlodi9PNMG9RJH034/rWxtrXZpxf + TLhmW9z+zHAN93IS5NgGQGPVnb/hsWRc1gScgzGsdoez1BHEylt5ceMpuGyXcL4/z8dXgWRcOKkG1Otv + w5yFteF4fg+cY+VdGN0VfmhCdvK6JsodXu3VMG7wJy0mQA0Q80r2dn71RbHcdZpF8wnCg3YQFbFf1gF3 + eKkzmNFKX5Ii1pesHIZirTLv8psQHO0BLDT4KrDNYUebP9ZSby6G+agB1bocnDNGHK3HmDce5qflFNX3 + A4kM30eR9og7vGDyYejJbuJDD6kBFbospvv1DJfsxfb8IJ9aIplqDFMWJmYWbYuXRdiUt4u4YO8tAK+C + jFi0aRpFufL3zbocomxbLEzMLNoWL4uwLPU/+Hfh8QdZjOdNufbSGQAAAABJRU5ErkJggm0GAACJUE5H + DQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAAEZ0FNQQAA2Ov1HBSqAAAAIGNIUk0AAIcLAACM + HAAA+V0AAIUwAAB7cQAA66AAAD/EAAAh8aVSo6gAAAMQaUNDUFBob3Rvc2hvcCBJQ0MgcHJvZmlsZQAA + OMuNlE1IFGEYx/+7jQixBpGZCMXQwSRUJg1SAnPXrzZlW8ZVU4TYnX13d3J2dpqZXVMkQoiOWcfoYkl0 + kOgUHjp0ykOEkGkXCTpaBJHgJWR7ZmY/ZkmxF2b2N8/H//mYZYCq11FNU7w8kFZNXRwI8DfGJ/jqT6hC + DXygE5UMzR8OD9lMsag8HmB307oD6y37+A87NToVJBnqALVJhy9aHHP4qsXTpmYST1ospaJxYo24WY+I + PcRPiY8lXRxzcZwZEs3ZTZyRNJ10vLXEHTkpaWkuEwtqXFaJtyx73JDSFEPzen9bu3DaNAeBrtPAkQ9l + 24QBLL8ATjWWbU31wMkxYKW9bNsR7f146taMRHubszVfgHr6ms/vNALVj4G9R/n8n2f5/N5zqkF9vFOk + rJ4r7tjzEXD6Le58RSzSQezMZJ8OYJH2OHYUGLwPPPkGnHsFnHgDhGuASCe891C8THbHrtOT0WZ0OZky + +TZBuMT76dUyPqhKrc18VFF422XwOjOYnmPxVqSVrFSod5wuH1NHhumX5vPeZUZfgT3z8Wgv7RKtxN/j + rLfPeo/ELxNyf9BaIF1bCb1/xGHPedkMRhz2jqpKaKjA9WosdL2gyWlmQCzqG7nhvqL9VvRamLiBWJzK + DFoxdZTbPZuKjDnsUWZTPaECf9azolX3LMUsaYr9n6fevO8xDgUMMlS6q+AhYgABtECDjgwS5JEpQiYr + s2N0YgNT+0YqCLuYJ/825WzbObeRpWwraxSBEOabSwq88EX4KWwIi8KS8GOhIdtU9szrN2Vp7eEv0rUq + F3UL3kJPjr5Edf3kVZAka7o0k+Hq1NVdQl1oKCtZNdiD0K5rSuaq1IKYrTRlV8rZPoPufle1g7ZHsatz + b+vLtTa4lcl13+pcxa4y/0zFSlNVPpfj3PmMO8Nd4IJcB9cJnrvCdXNdXC89XeaGShkjpCJj2lYyEKUs + FTPk1SremRML59tin9oBpjJdlnjrGxrWMwlZYa7P3CHu/zrAX7hwDd/Ec6rXAAAACXBIWXMAAAsQAAAL + EAGtI711AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAKhSURBVDhPhZNdSFNh + HMbfUijF7Uw0P3Om0/zCTGerCA2VWoZakpWUSalRdFM0DaGL6MpuugiEurGLboQ+IJqm6NTc/NjmNGhT + 0dMidbqRTtxubFA+ve/ZYS4keuAH7/n/n995z80h/0p3kjSkT87F9cmlcR/pWRz/P4YULn+24ljn4q1q + j6ulHq7mOiw0VXpmzxR2sp1Y2xntfgn5rEppXWks/7V+9xzWb6vhDoLNlhvUv6aUya3060QrKBalXONs + KMPq9SIsNp2Go+MpXEM9Auy8dFMt7Jw3SmE5nKgRNX/6D0jT7efzfc7LBbA3X4XHuQKfzxfg58Y6Vh/W + g+2dl2inKs+nS+HSRZ0Q85HE9oWqDPC1Kqw5luD1erf54cKKpgYLFWmYu1YkdFjXpIxvF3X6+Udjeb40 + BvyLNrjd7gBrjkV8v1MOvjQW1holHDNWocOXxMCiiuFFnZDxHJnPmheJ+V4tHA6HwPLXeczVlcGqjMSE + Ohf85IQwZ50vtMscUSdEnyXbnMyNxHSPFna7Hd+mrbDWloDNRktyYBsbEeaMGdphc+aIOiG6g5zNmC3D + 1LM2TNObpi6eBHv+VJwNy6AONpstAOsYc2RgjqgT8iFV+mQ0SwbjWRXM1cUYzZSh/0QmDN1amM3mABMm + E8bLC8G6zBF1Ql4lSBJ0GZx3hIoGSu/xDPS/e4vh4WEBvV4PA8V4v1HY09u9zBF1f14nSa4MpHFbQwoO + I5XFMHY8x/jggB96HrtwCmynU3Bbb2hX1P7KnsfR4ZquZOmmTk6LScFIwWZdcunmo+jwZtrd61e2s4si + oRxShIbcexAVNvYyPmLjfaLkN6MjLsLTEhVmSg0NYXIBhROdHWG/bRglmqLYTV9IyWNnyj5KOCXo1ybk + D9uSslHkXI87AAAAAElFTkSuQmCCAQYAAIlQTkcNChoKAAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/YQAA + AAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5 + ccllPAAAAyJpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0i + VzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0 + YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuMC1jMDYxIDY0LjE0MDk0OSwgMjAxMC8xMi8wNy0x + MDo1NzowMSAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5 + LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6 + eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFk + b2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEu + MC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENTNS4x + IFdpbmRvd3MiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6NjQ1QTVEQzE1NTY1MTFFMTlEMzlGQkM3 + NTZEQTg5QjAiIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6NjQ1QTVEQzI1NTY1MTFFMTlEMzlGQkM3 + NTZEQTg5QjAiPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlpZDo2NDVB + NURCRjU1NjUxMUUxOUQzOUZCQzc1NkRBODlCMCIgc3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRpZDo2NDVB + NURDMDU1NjUxMUUxOUQzOUZCQzc1NkRBODlCMCIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRG + PiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/PqSWWTYAAAJYSURBVDhPbVJLaxNhFP2gexdC + acxrEpIWUbJI2qSPpKn4iNZYGsGkWqFPRaGFaA1qYjOmaqFkEVQIFXWnG+vOhVatxsdGdKOif8K1aNNq + j/dMJ7EWLxzunMc9k8CozeN2u8uapv10Op1wOBzgJqduRuoDwHyS8Xg8MYaTySTy+TyKxWId5NTpM2ee + /C0Q8bjH04zzFy4id0nH6PhpHB0cqYOcOn3maiX1AqvdjTMZHacms0gkR5E4Mo744RPoTZw0dr/wRGrM + 8JljnndGgdPlLff2D2N5sQGP0gpX9yrMCLCk8HtR9nOFwh6FazGF24MK1acNYJ53RoHF1rL8eL4TeKFw + r1xG5eM3TGemsCoF35/IwTOFpaUF6PpN3J+/BbxUYN5ia142Chq3tQAfFNZey9tWKshOzCAzuA+/3ir8 + qCisiH5u+Biyk1eA1VdYeyO59wqNlma55y+wevDw7jjW3onxSfBF8FXw2eTc5NSFM7dwZwwt2/3rBXaH + C7NzNxAIxdDafhBtHXHBIUGf8D7zmVrc8JmbnbsOm11bL9A0V1XXCziwP45I1y5EI7sR7f4PRKfPnK5f + 5sdVNQrka3uQSqUwdXYKHcF2hDu70B0OCyIbEDZ0+swxzzujQEY+MCdyuRxGhkYQ8AcQbAsiFAwhFBLI + JqdOnznmeVcrUFarddrr9RpmOp1GT7QHvh0++HYKZJNTp89cU1PTBO/qBTJbKbJ5YGAAhUIBpVKpDnLq + 9M3jLTzaWMCh2Cr/bcHlclUZroGcOn0zZ8zmgto4BX4BwzWQU/9nAKg/yGOuHJCHKfQAAAAASUVORK5C + YILkAgAAiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1B + AACxjwv8YQUAAAAJcEhZcwAACxEAAAsRAX9kX5EAAAAHdElNRQfUBxgPMwsKE6x8AAAAGnRFWHRTb2Z0 + d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAJASURBVDhPlZHdT1JhHMf7A7roonu9KKGtP8ALLrtg + q4tq6si2xg1rubZe9IKSFLZmulpjzsKNQjYCX5AxmjKGB0RxyUsQgoAEgXiAAwECA4mJ7tfDw+mCYS0+ + 29nzcn7fz/N27g96vZmtN6xbTZvb9S2bCwjLl4KRsHxA8910yd9Z1qwKV4wW2HR6wOENgtMXBFcghFti + 3VrQaHQsurQduXyBrdUTYPf6IRiLQySRhEB0H1z+EOyEIri/algj5+aUF+hIK1LZvHXD4cGF6cNDKJbL + uB9LURAmExBNpSD4IwoSifQxHWnl06K2bvP4IRQ/gFyphAQViJBJLEvlckDl87hVqhaX6UgrKrUOn/vb + Xhi8aMuhOAnZYhF/eSQsoB01WoVygaAjrbydlmW/7u6BwxfA4WQ2C5lCAQfL1SpUazUoVSogFE3M0JFW + 7g+NizfsbnAHv8NuJAbxdAYLSkdHUDs+hpPTU7DZncDjDZ/9Ev39/IsC0XvSg47QeIX9dLp5mWjVxuoH + iQS8fiMFPn/mBh1pB0kuPXn+zqkz2SBCZfClkT+z8FlvgYlXUkqlMvzSL82HXVMMp3nsCpOOtYNE7Htc + 0eTDYbGcwxkdQeOrAoHk/KxgiOPTPoUSMQDuyS5K/egfkrNQPGD2BpYGyicZNZJwYEvYRc1ymZ1JxIMM + llvR15SY7oCR3029vMXoTPLieg9r++PtpsQ8CDLeZYr+9f+MXOthrU3fLO+sjMPUs7E6Pd0ZSNI7yr0r + 5HJFfb8Bf/2gi4hp+/UAAAAASUVORK5CYILRAgAAiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf + 8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJj + SURBVDhPlVP9S1phGL1/6gzXbMsiolE/hBWI+ENtOvsySwuD5leaOsNyS0VcqDms6Z1au3X7IhFELA2U + 0/s+w0D6ZV04cO/Le85znuc8V6hUZFxf/0WxeIxkMga7fQPT01OYnJyEVquFyWSCzWZDPB7DyckviGIO + slzG3d0FGFcQzs4K8Hrd0Ov1MBqNcLvdiEQiiMViODo6wuXlJZrNJur1OhOJw2q1siLryGSSuLo6hbC+ + bsXKygp2d3fh8XiYmJfew+EwUqkUzs/PcX9/j3a7jVqthnK5jM3NTczNzSKR+A6BW+WXQ6EQnE4nIRAI + kItsNsuqXOHx8REPDw/kJpfLkTuNRoPV1SUIOzse6tPn8xEcDgdcLheJptNpSJKERqOBarWKfD6PaDRK + rU5NaTA//xk0A5vNgpmZGSwsLMBisZAgb4u74U4ymQwRFxcXMT4+zvCRyH6/GzwFoVQ6ZoOxYnl5mWbA + iVzAYDCQGBfl7yMjI1Cr37NCBuzvf6PkSIBDkkRsbKyy/qLgT6fToRSCwSDMZjPGxsYwPKxmgp/YnT3W + mvgvxq4AB49lbc2Mg4MfNPlSqcSc2TE6OoqBgXesBSMj77Nk/hD5hQCHLJewtGRiFvdQKBQwMTGBvr43 + 7OwL24MILi6Kz2SOHnIX4XCAEhFFEQqFAoODA2yI4Z7KXfR8dHF4GGe74MfNzQ2USiWGhj6wnfj5gszx + 4oAjmz2kraxUKlCpVDT5VwnwPecCrVaLfiqV6u3rBG5vJWxt2aHT6dDfr2SbN8u2MvH/Ahynp7+xvf2V + Ni4U8j3n3gtZeALAUv0zVsZhhAAAAABJRU5ErkJggvkCAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAI + BgAAAB/z/2EAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAAAAlwSFlz + AAALEQAACxEBf2RfkQAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAACWUlEQVQ4 + T5WQ30tTYRjHj3SR1EVoXkiZEzNG4F0YeBGV3QX5BxghRIUIW6BEqVRgWgilLJF+kAmRsHJjarkUS6em + W0lW4rQl46x55na2s7Nf7nh2zuzbOWfnIgkrP/DlfZ/v833eFx5iOzAMkx+NRsvVcnvEorGzGxvCT06g + IQripM/nK1Fb/4ZlI6eEdBK9X47AMLMbdm8r0ul0yu/3H1UjW+N2u4tFUUyYFiphsOeh05GPjukcjLmb + sJZYG1NjBOHxeHatUFQFSZI5qiWTxXH8xwnyDtqm8tA+U6CobSoX3ogDq6uBR0qK9Hi0/HqKouMuCOti + PEDTZbIfpJkmKjqHZlsu2t4XKWq27cVS0IogHZqUItmE07mo4ZI8NeS6jqujuTDOX0SKE+KLi0uV/Dov + 3psuwy3bQbRMlODm2H6MLLeADUdcVVVVe+RPiDATfTG+3IVrowVSQIvGt4UwftVDTG1g6FurVBcp/o13 + h9BpPw0uwXN9fX2lyrCMn6L7h50dqBs8gAarVlH9q0J0Oy7hyuviTV6AJTE7O1urjmYwGo2lLBOLPHfU + Q/dSg3qzFJZUp56y9JJvnTdg5Qclb31HZvI3TGZzORuKx57Y9Kh5poGuV7tJDaZyxCNrQs/TnsPqyJ8M + Dgwekx5Jdo3U4vxjDWq6tYqqH+6Dk/yAuU+fb6vRrbH0W06EQwnuruUCzhmKUH2/BO0DNQisBr3ZEmrs + 75hM5gqGjvEGy2XoHhyHP+CH9c3wGbX9f5gtlpPL38kFn5cOjY/bGiUrK9PZHvK2d2auW0EQvwCWUIP6 + O4nZEQAAAABJRU5ErkJgguoBAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAABc1JH + QgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAZRJREFUOE9jQAb+1ackPAr2f7VKWCwGFcIG/kNpTOBZdHCV + a/b2/1YR00uhQtgAbgPccnfec05b/9A4uOclVAgbwG6Ae8EBJ6Dt321i52oYB3T+t4qcEQCVQgfYDQBq + Pu2Uuu6WWdikaSZB3V/MwyYfhEqhA0wDgJqZXbO2fwTSEiC+ZdRMX2P/jv/mUdO0wApQAaYBLlnbjpmH + TvxhGT45xSpsBpexf+d7kAHG/u0XoUqQAe5AJBJgN2BqRP7aqaGZO6dHF82dGlWwa6K778UeY80UqDQy + wG7AZM/AbSB6dmSK+FRPnxe1eqr3wBKYALsB093cwKlvZlD8zDp91f8N+uphYAkEaARibyAGGeAKxF1A + jArmRGQ7T3L3/V+nr7YKKoQMjIEYpBmGnYAYFUyNLnrQZaL5otVcRxzEn+LoqA2WQIAtQAzSfAzMQwYz + wrN7++3t/ncYaaSC+JM8bUW7jDWWgiURAOYKVNunuPtqdxhrfinXUfpaq6c2u9lQbUWlrsqral2VuVAl + yKAaSlMDMDAAANbqh21rf+bNAAAAAElFTkSuQmCCoQEAAIlQTkcNChoKAAAADUlIRFIAAAAQAAAAEAgG + AAAAH/P/YQAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsEAAA7BAbiRa+0AAAAadEVYdFNvZnR3YXJl + AFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAR1JREFUOE+Nk01qAkEQhZ+DhCxzAhFcZ+MqYCC4ysKNIATi + xgQUTFYuZ+lFPIcQRuZIHkFfdVXNdDPjxAcfU91V9ew/EXTCnlywIiCfROZSaa6hE/KkWZgRmSuwQ4mn + UNdhcMGCPJO1FX0QmVeTTAst11BdqF8p+rZYKNHTQss15IWOFC2jcUEDNblpoAfYZlDgi99/DER+kG6w + CXEeHaCow6DEo0Vd6lzBPrlGXc3d76Bu9i1MLZZtPIS5d3IOOeDNviZv0gaNx9U4D+N2TN74a4mJjR20 + mkTbO3LCX+CA+IOqDV5CLuWV9AmlRYoYxc2akxuKVzEn0fXKH2ZUJWvUQN6CX7HnhmFUSR5LgUPyqyT7 + y36swrUlOw1dwBWCXtPmlcApvQAAAABJRU5ErkJggkUBAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAI + BgAAAB/z/2EAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxySQAA + ANpJREFUOE/VUCESgzAQjOwT+EJlJRYZGYmNRCJjkcjIWGQlEovkCbGVlZXXy5HQQBN0uzM7d5O53dsL + +x9cNQBrXysD+PDpc5B3FLrBI8W41jOMNiOOeQoXF4cofoB/2xn0PYfR3MCYEjjn9Bi2U40Rogd2nYCn + vQA8GFU7F2CXAioDoCag3kvXTzuy7ziJwSKDyVRQbDLDXgixTxFjM/DiAc8wiifZNvW3UWyg8S8mXcKC + /5GiajMGbrMTp0SOs0ZxU6XPUKqm2Kebc2IHKSXd5uLl6Ed/Eoy9AcV8Gi8V4zpDAAAAAElFTkSuQmCC + OAEAAIlQTkcNChoKAAAADUlIRFIAAAAQAAAAEAgGAAAAH/P/YQAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAA + sY8L/GEFAAAACXBIWXMAAA68AAAOvAGVvHJJAAAAzUlEQVQ4T6WQIRKDMBBFOUKvUMk1egQkFhkZGYuM + RNZGIiNrK5GRsStXIrfZFGgEUAg78yeZzLw3P1vsjUdPD3MjCOf0dHxm+Ok1VfZ+TrLAoEm6hiya45If + 3EVY+YZaEGRHQ/Wr3JekMIPKiwi3IElhQ/343JZsw4I6VNRiuIdsSsygoyANwxrlUj9N77r1r9A0URDg + RWDL/wtMhwUMc+18wTgv74JAYv1dXI6A60us8gVcX0AQYKZAQn1NwKCZclrg4B2hOQ6GFUFRfAC3eSsP + J8swNwAAAABJRU5ErkJggkABAACJUE5HDQoaCgAAAA1JSERSAAAAEAAAABAIBgAAAB/z/2EAAAABc1JH + QgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxySQAAANVJREFUOE+lkqsSwyAQ + RfMJ/YXKfkJtZCUSGxmJjI1EIrHIyMjaykgkFrmycsvSbNrMdDIJvTNXwTk8Zqtf8fGBtTst9XHCeWlf + CLKgcw10KO+X44IeFHbQ4vC0ZQKdBU25oE+nK5DlAjr9T4HMAlcqIFiBQAemTNAmuI07BW7Sq8HJggRT + 7Sz47uDNWhggoBjTQnov/f4bvmETbqiCRBvTQAWNQ3RZENP+Gf2EJXRlAqnS17lium7DHJaYmMb3KMxh + iQ7dAovxvA/msGQsgTks2Yar6gWiaB5TNw92LAAAAABJRU5ErkJggvkDAACJUE5HDQoaCgAAAA1JSERS + AAAAEAAAABAIBgAAAB/z/2EAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAA7BAAAOwQG4kWvtAAAAGnRF + WHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAN1SURBVDhPbZNrUJRlGIa/JXGL06KyoZZC + A3kgtXIcKmYKRyVTbARJ2sXlGCuCKCwU6bIsISgeQDJJA4IhYHEBUSIJGJihIkhEflAzkD+IoS11OMTA + DOeBq4/PGc2Zftzvv+t63vd55xaAx/lzeOC38o4yjLUniSqPILj4Qw6XhmO8oae6vQrLQwuzs7NW/2Wk + Y35+3qrrjy4yGlI405zKuZY0MpoNpDYmoa9PIL4mmsiyEFIq9HTf6/56ZmZG9pSgs+8OafV6vmzLxtCQ + SMyNMKKuB6OtOsRHFWoizGoizUGoi/2JztfS0d3B9PR0jiQYGh98JrPpFLltWSTVHePI9RAJjKwMIkKE + w8oD0ZQFoCrx42Dx++y77ENy0UnuP7gv8iiFyttm0hsN6OviOVylkcBQEWrubWBhYYGzjekEFPmyv2A3 + vnm78Ml9B2+DF00/NzE3NycT0m8ZOd2cIk2OMKsIvRYoXtWP73/9ThKk1iSzTwR3X9nOzstv4/35m2w1 + bOZ0fjpjY2OCEFUSLk5PIKT8INoKDZd+ukBWcyZ3+zslQfkvZaTXG0mqSeCN86+zNXMLrxjXE2zQMDIy + IhPUVwLQiVs+VHqAWLNWgv4vf//zFx6p69iY9jLuKa7sOfYeQ0NDMkGV+wFHKsM5ULiXwKv+1N25RW17 + Lf0P+iWwo+c2N1tvUtRUyNqPX2DNidWs1Cnx0+1neHhYELRfhaP5JpC9V3fgfeEttnziwbpYN0wtZZIg + PCcU5wglSq0TzglKnBKXo9A6EJMRzejoqCBkVZ1nz8VdbL/khVf2Nrade5VNn23gWrvpkSAvlJVJz7Mi + QQTjHLCLtcVRraCwspDx8XFB+PHuD7xr3IGnuKDXzmzC49R63JJd8EnbSXCmho2JG1gWr8D+uB02R59D + rl2Kp9aTzq7OR984NTVlKKguaNms88DN4IKL/kVWJznjdHwZDlH22MXYYhMrgjFyrLXWuIe5k1eax+Dg + oNSJxR4IA5YB4cQXn8pcI9egjFvBcp0jDnH22Mba8OxROUujrVkSuoRVqlUYLhro/b1XJj7vSRcWMzEx + IZi+NVn56nx5KcQVxyAFcpUchUqBq9oV/3j/hyXmktq+vr7HRXpKsJjJyUmh516PzFxrluUU5dhk5Gas + zc7PlpmqTUJrW6tgsVikGz9hEP4FFdR7LL8mfOEAAAAASUVORK5CYIK1AwAAiVBORw0KGgoAAAANSUhE + UgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADrwA + AA68AZW8ckkAAAAHdElNRQfaCxkLKg/WMYK1AAAAB3RFWHRBdXRob3IAqa7MSAAAAAx0RVh0RGVzY3Jp + cHRpb24AEwkhIwAAAAp0RVh0Q29weXJpZ2h0AKwPzDoAAAAOdEVYdENyZWF0aW9uIHRpbWUANfcPCQAA + AAl0RVh0U29mdHdhcmUAXXD/OgAAAAt0RVh0RGlzY2xhaW1lcgC3wLSPAAAACHRFWHRXYXJuaW5nAMAb + 5ocAAAAHdEVYdFNvdXJjZQD1/4PrAAAACHRFWHRDb21tZW50APbMlr8AAAAGdEVYdFRpdGxlAKju0icA + AAJjSURBVDhPjZLdS5NhGMZ3HP0DHXTYYX9AUIHQgXmw1Iz5MZ2bTXRT1zZN2lf66vyIzSxbZc4p+JGh + EXM2EsXSCk1admAGUWggeZAZnShF+ut5NhamEzq43pfnua/ruu/nvm8V8F9wKD4uOgbJv9RNpq5aXCXu + 9xFTwe1to6L5CaHIOwrKnNx/MCyuE7F95FTQ2nuY+whGqxIXL76di/9lJSkFe5FTcZenSwmDpFhWorF0 + pxbsRrC3n6zyAJEYDE8sxU0kXIGXaGv6UouS6OgMxcXNPQv0PgN/BJTBDRzBVfSeCDXu1tRCiaR49DXY + bixQqkyRrvORYbiOuvQmJludoB3QxKT4zsALcs9nUZSbjT4vG1PhOYz5anpDXYKW4B4oDo4t4zSehF+L + sDUJP2dh8zE7GyFclhJezU4L+h6D3WXnFJj4NK7A11r4Xs/OWhUsZ0DsOG86juKtdyUMvL5bVDaMYLsW + xS06K7ttdA7RaNOLrMJp4yqKx4RGa6TNo4MFNTw8TIOIT46PopJiuSRyzlLcN4Mgl7M6PygyN7K54hLn + ivj8bWYzv9fCYp7HWO86jc9bh6qwuod8a5AW/22qar0ExXMzCq7gqiqGH362P2swFakprXRxz62FbyLD + SBqtNXomoo9QZRVa/q6nNPEOfOGsoR1jSQkr0x54f4rt2Bm2VobZWRfLEE4n7Eijpd6Z6IH8SEgTWYk9 + 8AGtvZvoWJi8nExikQvibYdE2UdE5hNMNaVTZzXwfGbqXwONoZqiy/2YlRGa/IF4sDPQjrVMh71cR625 + GGdlMW7xtNGh5B6g+gOoVtefNoYjbQAAAABJRU5ErkJggmADAACJUE5HDQoaCgAAAA1JSERSAAAAEAAA + ABAIBgAAAB/z/2EAAAABc1JHQgCuzhzpAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOvAAADrwBlbxy + SQAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAACz0lEQVQ4T3WPW0hTcRzHfbDE + pERzK0wxY6ZZmYpR4LW84PUU3sjwslnelqKlVggZGQ5xRqUUuswUdWW6tNQinWLq8LaZt9Qm/R6jwIfz + 6Nu3/9nWQyw/8OX8OHy/n53ZeBd3i85Ufay6pNQOSZ9NUFHL1I5cNY0i1RQKTZk0PfObJ3eyGieIU2r7 + hf6JYrXIRkBS2quoVM8isHYUHg/G4VYzBa/6efg3LiNYtYnAplX4NCzA/eE0PGvG4V87hsI2HY6X9TWY + BJ5FXcqGKUL54DpKNEu40fsVt96tovL9Bu4OGVE+sMHerUDauYirbfNIU80ir0MPSbFaaRIck3cplZME + 6QeCbIhQ+IlwbZCQqSGkqI1IaP+Giy0rCGnSI+jRLHwV00htnoF3Sc9jk8A1/maUtN3Aj60RmqYJjTpC + 3QShYpiQpzEirXMNUc1LCG5cgF+dDqVqPcIUn/kj8eXRJgHDThQm5VJeGPj7Y4Qc9uuFbJzdT0h/bQTX + sY5olSDQI69rESEKLX8oQsYJO/PcjEmSrDLwVVpCEfsb+UyU1fcDqd2biGtdRa56BaH1X3hxRK7V+C92 + YiZJajHwFaMEOZPkDhCu9GxB+vY7gp/MbztGFuw6/guT5HBJ7EtKRggF7CukTJKmHMFAdNivtexErORw + 0EcGjI14HfSxbKxgkmyuskePjN4tlL7SYSYhBCSLA50VmyNLwCIX+lN11MnJsrHiQFnXHJLfGKG+Uw2S + xoKCXNhYZI5w5yZiROJ829K3wiGvYw6pPUZ0yMtAif4gon+TGIBhiUu9pW+FQ+pzHZ/Ra4RCfg8UexoU + cxIU5WuOcMf5QyMRVVv6VtiKw2VJUU9n+POKCRiC3H5TejgoLcwcds+fk2zHONp7Wfr/xe7wheuce37r + y0xn+8vaQI/F5Ug/CBHuAtH+WNbZY67uji3LPpa9LK4spywRbja2sfkDNmCxwsesQzEAAAAASUVORK5C + YILXAQAAiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1B + AACxjwv8YQUAAAAJcEhZcwAADsIAAA7CARUoSoAAAAAHdElNRQfWAxoOERLaSefrAAAAGnRFWHRTb2Z0 + d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAEzSURBVDhPYxg8YNbs6RcaGhr+E4N7+7tWQ7UhAEiC + WABSC9WGADADPnx4jxeDQH8kEwzHQLWjGnD8+DGsGCQH0vju1bH/59cWgtlQ7cS5AKTh/evj/y+tyfq/ + sDn0D04DsNmOrHlJeziYD8TGUO34XQBS/PbZ0f/nV2X+X9AchqkZBHC5AKz56ZH/J+an/F/QArG5syEL + 5nRGKI3dBe/fv/tfEG35/9Dqrv+LW0PBmp/fOQWLRpBmVAP+/fuLohmkwcdJ7X92uBmYfebgeqD4e5gB + rBCdUAAS/PXrJ9yAd+/eghSBNW5eOe3/oUOH/p8+fer/o0ePYAZwgDXCAEgQGfz79+//9+/f/798+RKs + 6enTp/9fvXqF7AI2iE4o6OnrXAySIAZ393YsBmpB+J98wMAAAEBy/BniHbchAAAAAElFTkSuQmCCCw== - 04/21/2013 20:54:27 + 05/03/2013 15:22:32 diff --git a/ChanSort/MainForm.Designer.cs b/ChanSort/MainForm.Designer.cs index d690225..10418bc 100644 --- a/ChanSort/MainForm.Designer.cs +++ b/ChanSort/MainForm.Designer.cs @@ -133,7 +133,6 @@ this.miCharsetForm = new DevExpress.XtraBars.BarButtonItem(); this.miIsoCharSets = new DevExpress.XtraBars.BarListItem(); this.miShowWarningsAfterLoad = new DevExpress.XtraBars.BarCheckItem(); - this.miAutoLoadRefList = new DevExpress.XtraBars.BarCheckItem(); this.miEraseDuplicateChannels = new DevExpress.XtraBars.BarCheckItem(); this.mnuHelp = new DevExpress.XtraBars.BarSubItem(); this.miWiki = new DevExpress.XtraBars.BarButtonItem(); @@ -157,7 +156,6 @@ this.rbInsertAfter = new DevExpress.XtraEditors.CheckEdit(); this.rbInsertBefore = new DevExpress.XtraEditors.CheckEdit(); this.cbCloseGap = new DevExpress.XtraEditors.CheckEdit(); - this.cbAppendUnsortedChannels = new DevExpress.XtraEditors.CheckEdit(); this.tabChannelList = new DevExpress.XtraTab.XtraTabControl(); this.pageEmpty = new DevExpress.XtraTab.XtraTabPage(); this.mnuContext = new DevExpress.XtraBars.PopupMenu(this.components); @@ -188,7 +186,6 @@ ((System.ComponentModel.ISupportInitialize)(this.rbInsertAfter.Properties)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this.rbInsertBefore.Properties)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this.cbCloseGap.Properties)).BeginInit(); - ((System.ComponentModel.ISupportInitialize)(this.cbAppendUnsortedChannels.Properties)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this.tabChannelList)).BeginInit(); this.tabChannelList.SuspendLayout(); ((System.ComponentModel.ISupportInitialize)(this.mnuContext)).BeginInit(); @@ -835,7 +832,6 @@ this.miWiki, this.miEraseDuplicateChannels, this.miShowWarningsAfterLoad, - this.miAutoLoadRefList, this.miCleanupChannels}); this.barManager1.MaxItemId = 57; // @@ -1168,7 +1164,6 @@ new DevExpress.XtraBars.LinkPersistInfo(DevExpress.XtraBars.BarLinkUserDefines.PaintStyle, this.barSubItem1, DevExpress.XtraBars.BarItemPaintStyle.CaptionGlyph), new DevExpress.XtraBars.LinkPersistInfo(DevExpress.XtraBars.BarLinkUserDefines.PaintStyle, this.mnuCharset, DevExpress.XtraBars.BarItemPaintStyle.CaptionGlyph), new DevExpress.XtraBars.LinkPersistInfo(this.miShowWarningsAfterLoad), - new DevExpress.XtraBars.LinkPersistInfo(this.miAutoLoadRefList), new DevExpress.XtraBars.LinkPersistInfo(this.miEraseDuplicateChannels)}); this.mnuOptions.Name = "mnuOptions"; // @@ -1242,13 +1237,6 @@ this.miShowWarningsAfterLoad.Id = 54; this.miShowWarningsAfterLoad.Name = "miShowWarningsAfterLoad"; // - // miAutoLoadRefList - // - resources.ApplyResources(this.miAutoLoadRefList, "miAutoLoadRefList"); - this.miAutoLoadRefList.Checked = true; - this.miAutoLoadRefList.Id = 55; - this.miAutoLoadRefList.Name = "miAutoLoadRefList"; - // // miEraseDuplicateChannels // resources.ApplyResources(this.miEraseDuplicateChannels, "miEraseDuplicateChannels"); @@ -1379,7 +1367,6 @@ this.grpTopPanel.Controls.Add(this.rbInsertAfter); this.grpTopPanel.Controls.Add(this.rbInsertBefore); this.grpTopPanel.Controls.Add(this.cbCloseGap); - this.grpTopPanel.Controls.Add(this.cbAppendUnsortedChannels); this.grpTopPanel.Controls.Add(this.labelControl2); this.grpTopPanel.Controls.Add(this.picDonate); this.grpTopPanel.Controls.Add(this.tabChannelList); @@ -1431,13 +1418,6 @@ this.cbCloseGap.Name = "cbCloseGap"; this.cbCloseGap.Properties.Caption = resources.GetString("cbCloseGap.Properties.Caption"); // - // cbAppendUnsortedChannels - // - resources.ApplyResources(this.cbAppendUnsortedChannels, "cbAppendUnsortedChannels"); - this.cbAppendUnsortedChannels.MenuManager = this.barManager1; - this.cbAppendUnsortedChannels.Name = "cbAppendUnsortedChannels"; - this.cbAppendUnsortedChannels.Properties.Caption = resources.GetString("cbAppendUnsortedChannels.Properties.Caption"); - // // tabChannelList // resources.ApplyResources(this.tabChannelList, "tabChannelList"); @@ -1521,7 +1501,6 @@ ((System.ComponentModel.ISupportInitialize)(this.rbInsertAfter.Properties)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this.rbInsertBefore.Properties)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this.cbCloseGap.Properties)).EndInit(); - ((System.ComponentModel.ISupportInitialize)(this.cbAppendUnsortedChannels.Properties)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this.tabChannelList)).EndInit(); this.tabChannelList.ResumeLayout(false); ((System.ComponentModel.ISupportInitialize)(this.mnuContext)).EndInit(); @@ -1642,7 +1621,6 @@ private DevExpress.XtraTab.XtraTabControl tabChannelList; private DevExpress.XtraTab.XtraTabPage pageEmpty; private DevExpress.XtraEditors.CheckEdit cbCloseGap; - private DevExpress.XtraEditors.CheckEdit cbAppendUnsortedChannels; private DevExpress.XtraEditors.CheckEdit rbInsertSwap; private DevExpress.XtraEditors.CheckEdit rbInsertAfter; private DevExpress.XtraEditors.CheckEdit rbInsertBefore; @@ -1660,7 +1638,6 @@ private DevExpress.XtraBars.BarButtonItem miRenameChannel; private DevExpress.XtraBars.BarCheckItem miEraseDuplicateChannels; private DevExpress.XtraBars.BarCheckItem miShowWarningsAfterLoad; - private DevExpress.XtraBars.BarCheckItem miAutoLoadRefList; private DevExpress.XtraBars.BarButtonItem miCleanupChannels; private DevExpress.XtraSplashScreen.SplashScreenManager splashScreenManager1; } diff --git a/ChanSort/MainForm.cs b/ChanSort/MainForm.cs index a1b24c3..4d03ebf 100644 --- a/ChanSort/MainForm.cs +++ b/ChanSort/MainForm.cs @@ -72,7 +72,6 @@ namespace ChanSort.Ui if (this.curEditMode == EditMode.InsertAfter) this.rbInsertAfter.Checked = true; else if (this.curEditMode == EditMode.InsertBefore) this.rbInsertBefore.Checked = true; else this.rbInsertSwap.Checked = true; - this.cbAppendUnsortedChannels.Checked = true; this.ActiveControl = this.gridRight; } #endregion @@ -208,8 +207,7 @@ namespace ChanSort.Ui this.currentTvSerializer.DefaultEncoding = this.defaultEncoding; this.miEraseChannelData.Enabled = newSerializer.Features.EraseChannelData; if (!this.LoadTvDataFile()) - return; - this.LoadCsvFile(); + return; this.editor = new Editor(); this.editor.DataRoot = this.dataRoot; @@ -227,6 +225,8 @@ namespace ChanSort.Ui if (this.dataRoot.Warnings.Length > 0 && this.miShowWarningsAfterLoad.Checked) this.BeginInvoke((Action)this.ShowFileInformation); + + this.BeginInvoke((Action)this.InitInitialChannelOrder); } catch (Exception ex) { @@ -249,7 +249,9 @@ namespace ChanSort.Ui } } } + #endregion + #region FillChannelListCombo() private void FillChannelListCombo() { this.tabChannelList.TabPages.Clear(); @@ -340,35 +342,45 @@ namespace ChanSort.Ui if (this.dataRoot == null || !this.dataRoot.NeedsSaving) return true; - switch (XtraMessageBox.Show(this, - Resources.MainForm_PromptSaveAndContinue_Message, - Resources.MainForm_PromptSaveAndContinue_Caption, - MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question, - MessageBoxDefaultButton.Button3)) + using (ActionBoxDialog dlg = new ActionBoxDialog(Resources.MainForm_PromptSaveAndContinue_Question)) { - case DialogResult.Yes: this.SaveFiles(); break; - case DialogResult.No: break; - case DialogResult.Cancel: return false; + dlg.AddAction(Resources.MainForm_PromptSaveAndContinue_Save, DialogResult.Yes, dlg.Save); + dlg.AddAction(Resources.MainForm_PromptSaveAndContinue_Discard, DialogResult.No, dlg.Discard); + dlg.AddAction(Resources.MainForm_Cancel, DialogResult.Cancel, dlg.Cancel); + switch (dlg.ShowDialog(this)) + { + case DialogResult.Yes: this.SaveFiles(); break; + case DialogResult.No: break; + case DialogResult.Cancel: return false; + } } return true; } #endregion - #region LoadCsvFile() - private void LoadCsvFile() + #region InitInitialChannelOrder() + private void InitInitialChannelOrder() { - if (File.Exists(this.currentCsvFile) && this.miAutoLoadRefList.Checked) + DialogResult res; + string msg = Resources.MainForm_InitInitialChannelOrder_Question; + using (ActionBoxDialog dlg = new ActionBoxDialog(msg)) { - var csvSerializer = new CsvFileSerializer(this.currentCsvFile, this.dataRoot); - csvSerializer.Load(); + dlg.AddAction(Resources.MainForm_InitInitialChannelOrder_EmptyList, DialogResult.Cancel, dlg.EmptyList); + dlg.AddAction(Resources.MainForm_InitInitialChannelOrder_CurrentList, DialogResult.No, dlg.FullList, true); + dlg.AddAction(Resources.MainForm_InitInitialChannelOrder_ReferenceList, DialogResult.Yes, dlg.CopyList); + res = dlg.ShowDialog(this); } - else + + if (res == DialogResult.Yes) + this.BeginInvoke((Action)this.ShowOpenReferenceFileDialog); + else if (res == DialogResult.No) { foreach (var list in this.dataRoot.ChannelLists) { foreach (var channel in list.Channels) channel.NewProgramNr = channel.OldProgramNr; } + this.RefreshGrid(this.gviewLeft); } } #endregion @@ -379,7 +391,17 @@ namespace ChanSort.Ui using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Title = Resources.MainForm_ShowOpenReferenceFileDialog_Title; - dlg.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyComputer); + + var refList = this.currentTvFile + ".csv"; + if (File.Exists(refList)) + { + dlg.InitialDirectory = Path.GetDirectoryName(refList); + dlg.FileName = Path.GetFileName(refList); + } + else + { + dlg.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyComputer); + } dlg.AddExtension = true; dlg.Filter = Resources.MainForm_ShowOpenReferenceFileDialog_Filter; dlg.FilterIndex = 3; @@ -471,15 +493,16 @@ namespace ChanSort.Ui { this.gviewRight.PostEditor(); this.gviewLeft.PostEditor(); + try { - this.gviewRight.BeginDataUpdate(); - this.gviewLeft.BeginDataUpdate(); - this.editor.AutoNumberingForUnassignedChannels( - this.cbAppendUnsortedChannels.Checked ? UnsortedChannelMode.AppendInOrder : UnsortedChannelMode.MarkDeleted); + if (!this.PromptHandlingOfUnsortedChannels()) + return; + this.SaveReferenceFile(); this.SaveTvDataFile(); this.dataRoot.NeedsSaving = false; + this.RefreshGrid(this.gviewLeft, this.gviewRight); } catch (IOException ex) { @@ -489,15 +512,47 @@ namespace ChanSort.Ui Resources.MainForm_SaveFiles_ErrorTitle, MessageBoxButtons.OK, MessageBoxIcon.Error); } - finally - { - this.gviewRight.EndDataUpdate(); - this.gviewLeft.EndDataUpdate(); - } } #endregion + #region PromptHandlingOfUnsortedChannels() + private bool PromptHandlingOfUnsortedChannels() + { + bool hasUnsorted = false; + foreach (var list in this.dataRoot.ChannelLists) + { + foreach (var channel in list.Channels) + { + if (channel.NewProgramNr < 0) + { + hasUnsorted = true; + break; + } + } + } + if (!hasUnsorted) + return true; + + var msg = Resources.MainForm_PromptHandlingOfUnsortedChannels_Question; + DialogResult res; + using (var dlg = new ActionBoxDialog(msg)) + { + dlg.AddAction(Resources.MainForm_PromptHandlingOfUnsortedChannels_Append, DialogResult.Yes, dlg.FullList); + dlg.AddAction(Resources.MainForm_PromptHandlingOfUnsortedChannels_Delete, DialogResult.No, dlg.Delete); + dlg.AddAction(Resources.MainForm_Cancel, DialogResult.Cancel, dlg.Cancel); + res = dlg.ShowDialog(this); + } + + if (res == DialogResult.Cancel) + return false; + + this.editor.AutoNumberingForUnassignedChannels( + res == DialogResult.Yes ? UnsortedChannelMode.AppendInOrder : UnsortedChannelMode.MarkDeleted); + return true; + } + #endregion + #region SaveReferenceFile() private void SaveReferenceFile() @@ -747,8 +802,6 @@ namespace ChanSort.Ui this.miEraseDuplicateChannels.Checked = Settings.Default.EraseDuplicateChannels; this.miShowWarningsAfterLoad.Checked = Settings.Default.ShowWarningsAfterLoading; - this.miAutoLoadRefList.Checked = Settings.Default.AutoLoadRefList; - this.cbAppendUnsortedChannels.Checked = Settings.Default.AutoAppendUnsortedChannels; this.cbCloseGap.Checked = Settings.Default.CloseGaps; this.ClearLeftFilter(); } @@ -814,8 +867,6 @@ namespace ChanSort.Ui SaveInputGridLayout(this.currentChannelList.SignalSource); Settings.Default.EraseDuplicateChannels = this.miEraseDuplicateChannels.Checked; Settings.Default.ShowWarningsAfterLoading = this.miShowWarningsAfterLoad.Checked; - Settings.Default.AutoLoadRefList = this.miAutoLoadRefList.Checked; - Settings.Default.AutoAppendUnsortedChannels = this.cbAppendUnsortedChannels.Checked; Settings.Default.CloseGaps = this.cbCloseGap.Checked; Settings.Default.Save(); } diff --git a/ChanSort/MainForm.resx b/ChanSort/MainForm.resx index d8ad422..b751067 100644 --- a/ChanSort/MainForm.resx +++ b/ChanSort/MainForm.resx @@ -395,9 +395,6 @@ Show warnings after loading file - - Load reference list automatically - Cleanup TV data file after loading @@ -636,7 +633,7 @@ True - 311, 25 + 263, 6 Close gap when moving/deleting a channel @@ -662,33 +659,6 @@ 3 - - True - - - 311, 4 - - - Auto-append unsorted channels when saving file - - - 322, 19 - - - 6 - - - cbAppendUnsortedChannels - - - DevExpress.XtraEditors.CheckEdit, DevExpress.XtraEditors.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a - - - grpTopPanel - - - 4 - 7, 8 @@ -711,7 +681,7 @@ grpTopPanel - 5 + 4 Top, Right @@ -738,7 +708,7 @@ grpTopPanel - 6 + 5 Bottom, Left @@ -780,7 +750,7 @@ grpTopPanel - 7 + 6 Vertical @@ -810,7 +780,7 @@ grpTopPanel - 8 + 7 169, 24 @@ -840,7 +810,7 @@ grpTopPanel - 9 + 8 Top @@ -1349,12 +1319,6 @@ DevExpress.XtraBars.BarCheckItem, DevExpress.XtraBars.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a - - miAutoLoadRefList - - - DevExpress.XtraBars.BarCheckItem, DevExpress.XtraBars.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a - miEraseDuplicateChannels @@ -1434,7 +1398,7 @@ DevExpress.XtraEditors.XtraForm, DevExpress.Utils.v12.2, Version=12.2.8.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a - 04/29/2013 00:24:15 + 05/03/2013 17:24:18 16, 16 diff --git a/ChanSort/Properties/Resources.Designer.cs b/ChanSort/Properties/Resources.Designer.cs index df78028..3381552 100644 --- a/ChanSort/Properties/Resources.Designer.cs +++ b/ChanSort/Properties/Resources.Designer.cs @@ -87,6 +87,15 @@ namespace ChanSort.Ui.Properties { } } + /// + /// Looks up a localized string similar to Cancel. + /// + internal static string MainForm_Cancel { + get { + return ResourceManager.GetString("MainForm_Cancel", resourceCulture); + } + } + /// /// Looks up a localized string similar to Supported Files|{0}|All Files (*.*)|*. /// @@ -105,6 +114,42 @@ namespace ChanSort.Ui.Properties { } } + /// + /// Looks up a localized string similar to Modify current list: Start with current list and modify it as needed. + /// + internal static string MainForm_InitInitialChannelOrder_CurrentList { + get { + return ResourceManager.GetString("MainForm_InitInitialChannelOrder_CurrentList", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Create new list: Start with an empty list and add channels in desired order. + /// + internal static string MainForm_InitInitialChannelOrder_EmptyList { + get { + return ResourceManager.GetString("MainForm_InitInitialChannelOrder_EmptyList", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to How would you like to edit your channel list?. + /// + internal static string MainForm_InitInitialChannelOrder_Question { + get { + return ResourceManager.GetString("MainForm_InitInitialChannelOrder_Question", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Copy channel list: Order the channels the same way as in a reference list. + /// + internal static string MainForm_InitInitialChannelOrder_ReferenceList { + get { + return ResourceManager.GetString("MainForm_InitInitialChannelOrder_ReferenceList", resourceCulture); + } + } + /// /// Looks up a localized string similar to The input file contains multiple records that use the same ///program number. It is possible that the TV will not accept @@ -212,20 +257,56 @@ namespace ChanSort.Ui.Properties { } /// - /// Looks up a localized string similar to Data modified. + /// Looks up a localized string similar to Append unsorted channels the end of the list. /// - internal static string MainForm_PromptSaveAndContinue_Caption { + internal static string MainForm_PromptHandlingOfUnsortedChannels_Append { get { - return ResourceManager.GetString("MainForm_PromptSaveAndContinue_Caption", resourceCulture); + return ResourceManager.GetString("MainForm_PromptHandlingOfUnsortedChannels_Append", resourceCulture); } } /// - /// Looks up a localized string similar to Do you want to save the changes?. + /// Looks up a localized string similar to Delete unsorted channels from the list. /// - internal static string MainForm_PromptSaveAndContinue_Message { + internal static string MainForm_PromptHandlingOfUnsortedChannels_Delete { get { - return ResourceManager.GetString("MainForm_PromptSaveAndContinue_Message", resourceCulture); + return ResourceManager.GetString("MainForm_PromptHandlingOfUnsortedChannels_Delete", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to What should happen to unsorted channels?. + /// + internal static string MainForm_PromptHandlingOfUnsortedChannels_Question { + get { + return ResourceManager.GetString("MainForm_PromptHandlingOfUnsortedChannels_Question", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Discard changes. + /// + internal static string MainForm_PromptSaveAndContinue_Discard { + get { + return ResourceManager.GetString("MainForm_PromptSaveAndContinue_Discard", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Do you want so save your changes?. + /// + internal static string MainForm_PromptSaveAndContinue_Question { + get { + return ResourceManager.GetString("MainForm_PromptSaveAndContinue_Question", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Save changes. + /// + internal static string MainForm_PromptSaveAndContinue_Save { + get { + return ResourceManager.GetString("MainForm_PromptSaveAndContinue_Save", resourceCulture); } } diff --git a/ChanSort/Properties/Resources.de.resx b/ChanSort/Properties/Resources.de.resx index 364b033..f67f919 100644 --- a/ChanSort/Properties/Resources.de.resx +++ b/ChanSort/Properties/Resources.de.resx @@ -142,11 +142,14 @@ Die sortierte TLL-Datei wurde erfolgreich erstellt. - + Möchten Sie die Änderungen Speichern? - - Daten verändert + + Änderungen speichern + + + Änderungen verwerfen Es konnte kein Modul zum Lesen/Schreiben von {0}-Dateien gefunden werden. @@ -234,4 +237,28 @@ Möchten Sie die Downloadseite öffnen? Neue Version + + Wie möchten Sie die Senderliste bearbeiten? + + + Neu zusammenstellen: Mit leerer Liste beginnen und Sender in gewünschter Reihenfolge hinzufügen + + + Bestehende Liste bearbeiten: Derzeitige Senderreihenfolge übernehmen und anschließend bearbeiten + + + Reihenfolge kopieren: Senderreihenfolge und Favoriten aus einer Referenzdatei übernehmen + + + Was soll mit den unsortierten Sendern geschehen? + + + Sender am Ende der Liste anhängen + + + Sender löschen + + + Abbrechen + \ No newline at end of file diff --git a/ChanSort/Properties/Resources.resx b/ChanSort/Properties/Resources.resx index fb6692d..5a3e7f7 100644 --- a/ChanSort/Properties/Resources.resx +++ b/ChanSort/Properties/Resources.resx @@ -142,11 +142,14 @@ Sorted TV data file was created successfully. - - Do you want to save the changes? + + Do you want so save your changes? - - Data modified + + Save changes + + + Discard changes No plugin found to read/write {0} files. @@ -233,4 +236,28 @@ Do you want to open the download website? New Version + + How would you like to edit your channel list? + + + Create new list: Start with an empty list and add channels in desired order + + + Modify current list: Start with current list and modify it as needed + + + Copy channel list: Order the channels the same way as in a reference list + + + What should happen to unsorted channels? + + + Append unsorted channels the end of the list + + + Delete unsorted channels from the list + + + Cancel + \ No newline at end of file diff --git a/readme.txt b/readme.txt index 608f1ec..f4d44de 100644 --- a/readme.txt +++ b/readme.txt @@ -1,10 +1,12 @@ -Version v2013-04-29a ====================================================== +Version v2013-05-03 ======================================================= Changes: +- Added Assistants for loading and saving files - Added support for LG's 2013 LA-series DVB-S channel lists. Due to a lack of test files containing analog or DVB-C/T channels, these lists are not supported yet. If you have a TLL file with such channels please send it to horst@beham.biz. +- Added support for LG's LH3000 model - Improved clean-up of LG channel lists. This should solve problems with program numbers changing randomly or inability to change them at all. - Fixed: Program number and channel name can be edited again by directly @@ -109,11 +111,12 @@ OTHER DEALINGS IN THE SOFTWARE. Change log ================================================================ -2013-04-29a (inofficial alpha) +2013-05-03 - Added support for LG's 2013 LA-series DVB-S channel lists. Due to a lack of test files containing analog or DVB-C/T channels, these lists are not supported yet. If you have a TLL file with such channels please send it to horst@beham.biz. +- Added support for LG's LH3000 Model - Improved clean-up of LG channel lists. This should solve problems with program numbers changing randomly or inability to change them at all. - Fixed: Program number and channel name can be edited again by directly