From 4baf596bb765174257a43d5645094ff6ef4a47df Mon Sep 17 00:00:00 2001 From: Aaron Cuevas Lopez <1830303+aacuevas@users.noreply.github.com> Date: Thu, 2 Oct 2025 17:39:38 +0200 Subject: [PATCH] Added NET8 compatible ONIX Hub updater Requires clroni compiled with net8 support --- hub-tools/CSHubUpdater/.gitignore | 5 + hub-tools/CSHubUpdater/CSHubUpdater.sln | 31 + .../CSHubUpdater/CSHubUpdater.csproj | 17 + .../CSHubUpdater/CSHubUpdater.csproj.user | 11 + .../CSHubUpdater/CSHubUpdater/HubBitFile.cs | 134 ++ .../CSHubUpdater/HubConnection.cs | 305 +++ .../CSHubUpdater/HubFixedVoltage.cs | 18 + .../CSHubUpdater/CSHubUpdater/HubHS64.cs | 46 + .../CSHubUpdater/HubIDAttribute.cs | 14 + .../CSHubUpdater/CSHubUpdater/HubRHS2116.cs | 42 + .../CSHubUpdater/CSHubUpdater/IHubBitFile.cs | 11 + .../CSHubUpdater/IHubConnection.cs | 16 + .../CSHubUpdater/CSHubUpdater/Program.cs | 17 + .../CSHubUpdater/UpdateHub.Designer.cs | 318 +++ .../CSHubUpdater/CSHubUpdater/UpdateHub.cs | 95 + .../CSHubUpdater/CSHubUpdater/UpdateHub.resx | 120 ++ .../CSHubUpdater/UpdaterApp.Designer.cs | 211 ++ .../CSHubUpdater/CSHubUpdater/UpdaterApp.cs | 149 ++ .../CSHubUpdater/CSHubUpdater/UpdaterApp.resx | 1775 +++++++++++++++++ .../CSHubUpdater/oe-logo-only-color_a.ico | Bin 0 -> 98966 bytes 20 files changed, 3335 insertions(+) create mode 100644 hub-tools/CSHubUpdater/.gitignore create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater.sln create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/CSHubUpdater.csproj create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/CSHubUpdater.csproj.user create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/HubBitFile.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/HubConnection.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/HubFixedVoltage.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/HubHS64.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/HubIDAttribute.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/HubRHS2116.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/IHubBitFile.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/IHubConnection.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/Program.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.Designer.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.resx create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.Designer.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.cs create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.resx create mode 100644 hub-tools/CSHubUpdater/CSHubUpdater/oe-logo-only-color_a.ico diff --git a/hub-tools/CSHubUpdater/.gitignore b/hub-tools/CSHubUpdater/.gitignore new file mode 100644 index 0000000..43c6270 --- /dev/null +++ b/hub-tools/CSHubUpdater/.gitignore @@ -0,0 +1,5 @@ +!*.cs +!*.csproj +!*.csproj.user +!*.resx +!*.ico \ No newline at end of file diff --git a/hub-tools/CSHubUpdater/CSHubUpdater.sln b/hub-tools/CSHubUpdater/CSHubUpdater.sln new file mode 100644 index 0000000..a26f44e --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.13.36105.23 d17.13 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CSHubUpdater", "CSHubUpdater\CSHubUpdater.csproj", "{1181DC7D-0413-4F95-8ED8-2631F1848FCF}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {1181DC7D-0413-4F95-8ED8-2631F1848FCF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1181DC7D-0413-4F95-8ED8-2631F1848FCF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1181DC7D-0413-4F95-8ED8-2631F1848FCF}.Debug|x64.ActiveCfg = Debug|x64 + {1181DC7D-0413-4F95-8ED8-2631F1848FCF}.Debug|x64.Build.0 = Debug|x64 + {1181DC7D-0413-4F95-8ED8-2631F1848FCF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1181DC7D-0413-4F95-8ED8-2631F1848FCF}.Release|Any CPU.Build.0 = Release|Any CPU + {1181DC7D-0413-4F95-8ED8-2631F1848FCF}.Release|x64.ActiveCfg = Release|x64 + {1181DC7D-0413-4F95-8ED8-2631F1848FCF}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {A1C3689F-BCDD-4EAF-A981-470D338D0778} + EndGlobalSection +EndGlobal diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/CSHubUpdater.csproj b/hub-tools/CSHubUpdater/CSHubUpdater/CSHubUpdater.csproj new file mode 100644 index 0000000..c515e26 --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/CSHubUpdater.csproj @@ -0,0 +1,17 @@ + + + + WinExe + net8.0-windows + enable + true + enable + true + AnyCPU;x64 + + + + + + + \ No newline at end of file diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/CSHubUpdater.csproj.user b/hub-tools/CSHubUpdater/CSHubUpdater/CSHubUpdater.csproj.user new file mode 100644 index 0000000..c4cdafe --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/CSHubUpdater.csproj.user @@ -0,0 +1,11 @@ + + + + + Form + + + Form + + + \ No newline at end of file diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/HubBitFile.cs b/hub-tools/CSHubUpdater/CSHubUpdater/HubBitFile.cs new file mode 100644 index 0000000..6bfe7ca --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/HubBitFile.cs @@ -0,0 +1,134 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Security.Policy; +using System.Text; +using System.Threading.Tasks; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.IO.Compression; +using System.Threading; +using System.Runtime.CompilerServices; + +namespace CSHubUpdater +{ + internal class HubBitFile : IHubBitFile + { + const string HeaderSignature = "ONIXHUBX"; + const ushort HeaderVersion = 1; + private static readonly int HeaderSize = Unsafe.SizeOf(); + + const int MaxFileSize = 5 * 1024 * 1024; // Anything beyond this size will result in an error + + public ushort HubId => header.HardwareID; + public ushort HwRevision => header.HardwareRev; + public ushort FwVer => header.FwVersion; + public ReadOnlyMemory Data { get; } + + readonly BitFileHeader header; + + private HubBitFile(BitFileHeader header, byte[] data) + { + this.header = header; + Data = data; + } + + public static async Task CreateAsync(FileInfo info, CancellationToken cancellationToken) + { + if (info == null || !info.Exists) + { + throw new FileNotFoundException("Selected file does not exist"); + } + if (info.Length > MaxFileSize) + { + throw new ArgumentException("File size is greater than supported"); + } + + await using var stream = info.OpenRead(); + byte[] headerBuffer = new byte[HeaderSize]; + await stream.ReadExactlyAsync(headerBuffer, cancellationToken); + var header = MemoryMarshal.Read(headerBuffer); + ValidateHeader(header, stream.Length); + + int dataLength = (int)header.Length; + int paddedSize = (dataLength + 3) & ~3; + byte[] dataBuffer = new byte[paddedSize]; + Array.Fill(dataBuffer, (byte)0xFF); + await stream.ReadExactlyAsync(dataBuffer.AsMemory(0, dataLength), cancellationToken); + byte[] computedHash = SHA1.HashData(new ReadOnlySpan(dataBuffer, 0, dataLength)); + if (!header.Sha1HashSpan.SequenceEqual(computedHash)) + { + throw new InvalidDataException("Hashes do not match. Possible file corruption"); + } + + cancellationToken.ThrowIfCancellationRequested(); + return new HubBitFile(header, dataBuffer); + } + + static void ValidateHeader(BitFileHeader header, long streamLength) + { + if (!header.SignatureSpan.SequenceEqual(System.Text.Encoding.ASCII.GetBytes(HeaderSignature))) + { + throw new InvalidDataException("Invalid firmware file (Invalid header)."); + } + + if (header.Version != HeaderVersion) + { + throw new InvalidDataException($"Unextpected file version. Expected {HeaderVersion} but reported {header.Version}."); + } + + if ((ulong)streamLength < (header.Length + (ulong)HeaderSize)) + { + throw new InvalidDataException("File size is smaller than reported."); + } + } + + + + [StructLayout(LayoutKind.Explicit, Size = 64, Pack = 1)] + unsafe struct BitFileHeader + { + [FieldOffset(0)] + public fixed byte Signature[8]; + [FieldOffset(8)] + public ushort Version; + [FieldOffset(10)] + public ushort HardwareID; + [FieldOffset(12)] + public ushort HardwareRev; + [FieldOffset(14)] + public ushort FwVersion; + [FieldOffset(16)] + public ulong Length; + [FieldOffset(24)] + public fixed byte Sha1Hash[20]; + [FieldOffset(44)] + public fixed byte Reserved[20]; + + public ReadOnlySpan SignatureSpan + { + get + { + fixed (byte* ptr = Signature) + { + return new ReadOnlySpan(ptr, 8); + } + } + } + public ReadOnlySpan Sha1HashSpan + { + get + { + fixed (byte* ptr = Sha1Hash) + { + return new Span(ptr, 20); + } + } + + } + } + + + } +} diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/HubConnection.cs b/hub-tools/CSHubUpdater/CSHubUpdater/HubConnection.cs new file mode 100644 index 0000000..453fb7f --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/HubConnection.cs @@ -0,0 +1,305 @@ +using oni; +using System; +using System.CodeDom; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics.Eventing.Reader; +using System.Linq; +using System.Linq.Expressions; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security.Policy; +using System.Text; +using System.Threading.Tasks; + + +namespace CSHubUpdater +{ + internal abstract class HubConnection(string driver, int index, int portIndex) : IDisposable, IHubConnection, INotifyPropertyChanged + { + readonly oni.Context context = new(driver, index); + readonly uint hubDeviceAddr = (((uint)portIndex + 1) << 8) + 254; + readonly uint controlDeviceAddr = (uint)portIndex + 1; + public ushort HubId { get; private set; } + public ushort HwRevision { get; private set; } + public double Voltage { get; private set; } + public bool SafeFirmware { get; private set; } + public ushort SafeFwVersion { get; private set; } + public ushort FwVersion { get; private set; } + + const int MaxWriteWords = 16; + const int TimeoutMs = 2000; + + public event PropertyChangedEventHandler? PropertyChanged; + + void OnPropertyChanged([CallerMemberName] string? propertyName =null) + { + PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); + } + + Task Init() + { + return Task.Run(async () => + { + ResetHardware(); + context.Refresh(); + + double? voltage = await PowerHub(); + if (!voltage.HasValue) + { + SetVoltage(0); + throw new IOException("Unable to open hub"); + } + Voltage = voltage.Value; + + //just to be sure + context.Refresh(); + FillInfo(); + + }); + } + + void FillInfo() + { + var hwid = context.ReadRegister(hubDeviceAddr, (uint)HubRegisterAddress.HWID); + HubId = (ushort)hwid; + OnPropertyChanged(nameof(HubId)); + HwRevision = (ushort)context.ReadRegister(hubDeviceAddr, (uint)HubRegisterAddress.HWREV); + OnPropertyChanged(nameof(HwRevision)); + SafeFirmware = (hwid & 0x10000) != 0; + OnPropertyChanged(nameof(SafeFirmware)); + SafeFwVersion = (ushort)context.ReadRegister(hubDeviceAddr, (uint)HubRegisterAddress.SAFEVER); + OnPropertyChanged(nameof(SafeFwVersion)); + FwVersion = (ushort)context.ReadRegister(hubDeviceAddr, (uint)HubRegisterAddress.FWVER); + OnPropertyChanged(nameof(FwVersion)); + } + + public async Task RestartHeadstage() + { + SetVoltage(3.3); + await Task.Delay(100); + SetVoltage(0); + await Task.Delay(1000); + SetVoltage(Voltage); + await Task.Delay(500); + FillInfo(); + } + + + protected abstract Task PowerHub(); + + protected bool CheckLinkState() + { + var linkstate = (LinkState)context.ReadRegister(controlDeviceAddr, (uint)ControlRegisterAddress.LINKSTATE); + return (linkstate & LinkState.Lock) == LinkState.Lock; + } + + protected void SetVoltage(double voltage) + { + if (voltage < 0 || voltage > 10) + { + throw new ArgumentException("Hub voltage must be between 0 and 10"); + } + uint param = (uint)(voltage * 10); + context.WriteRegister(controlDeviceAddr, (uint)ControlRegisterAddress.PWR, param); + } + + public void Dispose() + { + ResetHardware(); + context.Dispose(); + } + + // NB: In v2.0 of onix, this happens automatically on reset. + // But we add it here as a safety so the software can be used in earlier versions + void ResetHardware() + { + SetVoltage(0); + context.SetCustomOption((int)ONIXOption.PORTFUNC, 0); + } + + public Task UpdateFirmware(IHubBitFile file, IProgress progress) + { + return Task.Factory.StartNew(() => + { + using var cancellation = new CancellationTokenSource(); + progress.Report(0); + var data = MemoryMarshal.Cast(file.Data.Span); + WriteProgrammer(ProgrammingStatus.DISABLE); + if (ReadProgrammer().HasFlag(ProgrammingStatus.BUSY)) + { + throw new IOException("Programmer in busy state. Try again in a few seconds or reboot the device"); + } + bool isCrossLink = CheckCrossLinkAndSetSize(file.Data.Length); + WriteProgrammer(ProgrammingStatus.ENABLE); + ProgrammingStatus status; + if (WaitProgrammer(cancellation, TimeoutMs).HasFlag(ProgrammingStatus.ERROR)) + { + throw new IOException("Error while clearing flash."); + } + + int written = 0; + while (written < data.Length) + { + int toWrite = Math.Min(data.Length - written, MaxWriteWords); + for (int i = 0; i < toWrite; i++) + { + WriteProgrammerData(data[written++]); + } + WaitProgrammer(cancellation, TimeoutMs, isCrossLink); + progress.Report(written); + + } + + WriteProgrammer(ProgrammingStatus.DISABLE); + WaitBusy(cancellation, TimeoutMs); + + + + }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default); + + } + + ProgrammingStatus WaitProgrammer(CancellationTokenSource cancellationToken, int msTimeout, bool crossLinkCheck = false) + { + cancellationToken.TryReset(); + cancellationToken.CancelAfter(msTimeout); + var token = cancellationToken.Token; + ProgrammingStatus status; + ProgrammingStatus test = ProgrammingStatus.WAIT_DATA; + if (crossLinkCheck) test |= ProgrammingStatus.DONE; + while (((status = ReadProgrammer()) & test) == 0) + { + token.ThrowIfCancellationRequested(); + } + return status; + } + void WaitBusy(CancellationTokenSource cancellationToken, int msTimeout) + { + cancellationToken.TryReset(); + cancellationToken.CancelAfter(msTimeout); + var token = cancellationToken.Token; + ProgrammingStatus test = ProgrammingStatus.BUSY; + while ((ReadProgrammer() & test) != 0) + { + token.ThrowIfCancellationRequested(); + } + } + + void WriteProgrammer(ProgrammingStatus val) + { + context.WriteRegister(hubDeviceAddr, (uint)HubRegisterAddress.PROGRAM, (uint)val); + } + + ProgrammingStatus ReadProgrammer() + { + return (ProgrammingStatus)context.ReadRegister(hubDeviceAddr, (uint)HubRegisterAddress.PROGRAM); + } + + void WriteProgrammerData(uint val) + { + context.WriteRegister(hubDeviceAddr, (uint)HubRegisterAddress.PROGRAM_DATA, val); + } + + bool CheckCrossLinkAndSetSize(int len) + { + try + { + context.WriteRegister(hubDeviceAddr, (uint)HubRegisterAddress.PROGRAM_SIZE, (uint)len); + } + catch (Exception) + { + //NB: If there is an error here it just means this is not a crosslink device + return false; + } + return true; + } + + public static async Task CreateFromHubInfoAsync(string driver, int index, int portIndex, uint hubId) + { + var assembly = Assembly.GetExecutingAssembly(); ; + var deviceType = assembly.GetTypes().FirstOrDefault(t => + { + var attr = t.GetCustomAttribute(); + if (attr == null) return false; + if (attr.ID != hubId) return false; + return t.IsClass && !t.IsAbstract && typeof(HubConnection).IsAssignableFrom(t); + }) ?? throw new ArgumentException($"Hub ID not supported {hubId}"); + + var hub = Activator.CreateInstance(deviceType, [driver, index, portIndex]) as HubConnection + ?? throw new ArgumentException($"Unknown error initializating hub id {hubId}"); + try + { + await hub.Init(); + if (hub.HubId != hubId) + { + + throw new ArgumentException($"Invalid Hub detected. Expected {hubId}, Reported {hub.HubId}"); + } + } + catch (Exception) + { + hub.Dispose(); + throw; + } + return hub; + + } + + public static async Task CreateFromVoltageAsync(string driver, int index, int portIndex, double voltage) + { + HubConnection hub = new HubFixedVoltage(driver, index, portIndex, voltage); + try + { + await hub.Init(); + } + catch (Exception) + { + hub.Dispose(); + throw; + } + return hub; + } + + public enum ControlRegisterAddress : uint + { + PWR = 0x03, + LINKSTATE = 0x05 + } + + [Flags] + public enum LinkState : uint + { + None = 0, + Pass = 1, + Lock = 2 + } + + public enum HubRegisterAddress : uint + { + HWID = 0x00, + HWREV = 0x01, + FWVER = 0x02, + SAFEVER = 0x03, + CLOCK = 0x04, + REBOOT = 0x10, + PROGRAM = 0x20, + PROGRAM_DATA = 0x21, + PROGRAM_SIZE = 0x22 // only for Crosslink devices + } + + [Flags] + public enum ProgrammingStatus : uint + { + DISABLE = 0x00, + ENABLE = 0x01, + BUSY = 0x02, + WAIT_DATA = 0x04, + ERROR = 0x08, + FULL = 0x10, + DONE = 0x10000 + } + + } +} diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/HubFixedVoltage.cs b/hub-tools/CSHubUpdater/CSHubUpdater/HubFixedVoltage.cs new file mode 100644 index 0000000..31cff3d --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/HubFixedVoltage.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace CSHubUpdater +{ + internal class HubFixedVoltage(string driver, int index, int portIndex, double voltage) : HubConnection(driver, index, portIndex) + { + protected override async Task PowerHub() + { + SetVoltage(voltage); + await Task.Delay(500); + return CheckLinkState() ? voltage : null; + } + } +} diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/HubHS64.cs b/hub-tools/CSHubUpdater/CSHubUpdater/HubHS64.cs new file mode 100644 index 0000000..da5be6b --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/HubHS64.cs @@ -0,0 +1,46 @@ +using oni; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace CSHubUpdater +{ + [HubID(2)] + internal class HubHS64(string driver, int index, int portIndex) : HubConnection(driver, index, portIndex) + { + protected override async Task PowerHub() + { + + const double MinVoltage = 3.3; + const double MaxVoltage = 6.0; + const double VoltageOffset = 3.4; + const double VoltageIncrement = 0.2; + + await Task.Delay(1000); + double voltage = MaxVoltage; + for (; voltage >= MinVoltage; voltage -= VoltageIncrement) + { + SetVoltage(voltage); + await Task.Delay(200); + if (!CheckLinkState()) + { + if (voltage == MaxVoltage) + { + return null; + } + else break; + } + + } + SetVoltage(MinVoltage); + SetVoltage(0); + await Task.Delay(1000); + voltage += VoltageOffset; + SetVoltage(voltage); + await Task.Delay(200); + return CheckLinkState() ? voltage : null; + } + } +} diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/HubIDAttribute.cs b/hub-tools/CSHubUpdater/CSHubUpdater/HubIDAttribute.cs new file mode 100644 index 0000000..f6ca62d --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/HubIDAttribute.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace CSHubUpdater +{ + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)] + internal class HubIDAttribute(int DevID) : Attribute + { + public int ID { get; private set; } = DevID; + } +} diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/HubRHS2116.cs b/hub-tools/CSHubUpdater/CSHubUpdater/HubRHS2116.cs new file mode 100644 index 0000000..82d0e40 --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/HubRHS2116.cs @@ -0,0 +1,42 @@ +using oni; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace CSHubUpdater +{ + [HubID(4)] + internal class HubRHS2116(string driver, int index, int portIndex) : HubConnection(driver, index, portIndex) + { + protected override async Task PowerHub() + { + const double MinVoltage = 3.3; + const double MaxVoltage = 4.4; + const double VoltageOffset = 2.0; + const double VoltageIncrement = 0.2; + + double voltage = MinVoltage; + for (; voltage <= MaxVoltage; voltage += VoltageIncrement) + { + await SetPortVoltage(voltage); + if (CheckLinkState()) + { + voltage += VoltageOffset; + await SetPortVoltage(voltage); + return CheckLinkState() ? voltage : null; + } + } + return null; + } + + async Task SetPortVoltage(double voltage) + { + SetVoltage(0.0); + await Task.Delay(500); + SetVoltage(voltage); + await Task.Delay(500); + } + } +} diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/IHubBitFile.cs b/hub-tools/CSHubUpdater/CSHubUpdater/IHubBitFile.cs new file mode 100644 index 0000000..9342541 --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/IHubBitFile.cs @@ -0,0 +1,11 @@ + +namespace CSHubUpdater +{ + public interface IHubBitFile + { + ReadOnlyMemory Data { get; } + ushort FwVer { get; } + ushort HubId { get; } + ushort HwRevision { get; } + } +} \ No newline at end of file diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/IHubConnection.cs b/hub-tools/CSHubUpdater/CSHubUpdater/IHubConnection.cs new file mode 100644 index 0000000..1de2546 --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/IHubConnection.cs @@ -0,0 +1,16 @@ + +namespace CSHubUpdater +{ + public interface IHubConnection + { + ushort FwVersion { get; } + ushort HubId { get; } + ushort HwRevision { get; } + double Voltage { get; } + bool SafeFirmware { get; } + ushort SafeFwVersion { get; } + void Dispose(); + Task RestartHeadstage(); + Task UpdateFirmware(IHubBitFile file, IProgress progress); + } +} \ No newline at end of file diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/Program.cs b/hub-tools/CSHubUpdater/CSHubUpdater/Program.cs new file mode 100644 index 0000000..5d5b256 --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/Program.cs @@ -0,0 +1,17 @@ +namespace CSHubUpdater +{ + internal static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + // To customize application configuration such as set high DPI settings or default font, + // see https://aka.ms/applicationconfiguration. + ApplicationConfiguration.Initialize(); + Application.Run(new UpdaterApp()); + } + } +} \ No newline at end of file diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.Designer.cs b/hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.Designer.cs new file mode 100644 index 0000000..1cbfe65 --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.Designer.cs @@ -0,0 +1,318 @@ +namespace CSHubUpdater +{ + partial class UpdateHub + { + /// + /// 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() + { + groupBox1 = new GroupBox(); + fFwVerTextBox = new TextBox(); + fHwRevTextBox = new TextBox(); + fHubNameTextBox = new TextBox(); + label4 = new Label(); + label3 = new Label(); + label2 = new Label(); + groupBox2 = new GroupBox(); + hSafeFwVer = new TextBox(); + label8 = new Label(); + hMode = new TextBox(); + label7 = new Label(); + hFwVerTextBox = new TextBox(); + hHwRevTextBox = new TextBox(); + hHubNameTextBox = new TextBox(); + label1 = new Label(); + label5 = new Label(); + label6 = new Label(); + progressUpdate = new ProgressBar(); + programButton = new Button(); + cancelButton = new Button(); + groupBox1.SuspendLayout(); + groupBox2.SuspendLayout(); + SuspendLayout(); + // + // groupBox1 + // + groupBox1.Controls.Add(fFwVerTextBox); + groupBox1.Controls.Add(fHwRevTextBox); + groupBox1.Controls.Add(fHubNameTextBox); + groupBox1.Controls.Add(label4); + groupBox1.Controls.Add(label3); + groupBox1.Controls.Add(label2); + groupBox1.Location = new Point(12, 13); + groupBox1.Margin = new Padding(3, 4, 3, 4); + groupBox1.Name = "groupBox1"; + groupBox1.Padding = new Padding(3, 4, 3, 4); + groupBox1.Size = new Size(339, 206); + groupBox1.TabIndex = 4; + groupBox1.TabStop = false; + groupBox1.Text = "File:"; + // + // fFwVerTextBox + // + fFwVerTextBox.Location = new Point(121, 136); + fFwVerTextBox.Margin = new Padding(3, 4, 3, 4); + fFwVerTextBox.Name = "fFwVerTextBox"; + fFwVerTextBox.ReadOnly = true; + fFwVerTextBox.Size = new Size(180, 31); + fFwVerTextBox.TabIndex = 6; + fFwVerTextBox.TabStop = false; + // + // fHwRevTextBox + // + fHwRevTextBox.Location = new Point(121, 85); + fHwRevTextBox.Margin = new Padding(3, 4, 3, 4); + fHwRevTextBox.Name = "fHwRevTextBox"; + fHwRevTextBox.ReadOnly = true; + fHwRevTextBox.Size = new Size(180, 31); + fHwRevTextBox.TabIndex = 5; + fHwRevTextBox.TabStop = false; + // + // fHubNameTextBox + // + fHubNameTextBox.Location = new Point(121, 39); + fHubNameTextBox.Margin = new Padding(3, 4, 3, 4); + fHubNameTextBox.Name = "fHubNameTextBox"; + fHubNameTextBox.ReadOnly = true; + fHubNameTextBox.Size = new Size(180, 31); + fHubNameTextBox.TabIndex = 4; + fHubNameTextBox.TabStop = false; + // + // label4 + // + label4.AutoSize = true; + label4.Location = new Point(8, 141); + label4.Name = "label4"; + label4.Size = new Size(105, 25); + label4.TabIndex = 2; + label4.Text = "FW Version:"; + // + // label3 + // + label3.AutoSize = true; + label3.Location = new Point(7, 90); + label3.Name = "label3"; + label3.Size = new Size(112, 25); + label3.TabIndex = 1; + label3.Text = "HW revision:"; + // + // label2 + // + label2.AutoSize = true; + label2.Location = new Point(16, 43); + label2.Name = "label2"; + label2.Size = new Size(102, 25); + label2.TabIndex = 0; + label2.Text = "Hub Name:"; + // + // groupBox2 + // + groupBox2.Controls.Add(hSafeFwVer); + groupBox2.Controls.Add(label8); + groupBox2.Controls.Add(hMode); + groupBox2.Controls.Add(label7); + groupBox2.Controls.Add(hFwVerTextBox); + groupBox2.Controls.Add(hHwRevTextBox); + groupBox2.Controls.Add(hHubNameTextBox); + groupBox2.Controls.Add(label1); + groupBox2.Controls.Add(label5); + groupBox2.Controls.Add(label6); + groupBox2.Location = new Point(371, 13); + groupBox2.Margin = new Padding(3, 4, 3, 4); + groupBox2.Name = "groupBox2"; + groupBox2.Padding = new Padding(3, 4, 3, 4); + groupBox2.Size = new Size(346, 287); + groupBox2.TabIndex = 7; + groupBox2.TabStop = false; + groupBox2.Text = "Device:"; + // + // hSafeFwVer + // + hSafeFwVer.Location = new Point(137, 240); + hSafeFwVer.Margin = new Padding(3, 4, 3, 4); + hSafeFwVer.Name = "hSafeFwVer"; + hSafeFwVer.ReadOnly = true; + hSafeFwVer.Size = new Size(180, 31); + hSafeFwVer.TabIndex = 10; + hSafeFwVer.TabStop = false; + // + // label8 + // + label8.AutoSize = true; + label8.Location = new Point(9, 243); + label8.Name = "label8"; + label8.Size = new Size(126, 25); + label8.TabIndex = 9; + label8.Text = "Backup fw ver:"; + // + // hMode + // + hMode.Location = new Point(137, 189); + hMode.Margin = new Padding(3, 4, 3, 4); + hMode.Name = "hMode"; + hMode.ReadOnly = true; + hMode.Size = new Size(180, 31); + hMode.TabIndex = 8; + hMode.TabStop = false; + // + // label7 + // + label7.AutoSize = true; + label7.Location = new Point(66, 192); + label7.Name = "label7"; + label7.Size = new Size(63, 25); + label7.TabIndex = 7; + label7.Text = "Mode:"; + // + // hFwVerTextBox + // + hFwVerTextBox.Location = new Point(137, 136); + hFwVerTextBox.Margin = new Padding(3, 4, 3, 4); + hFwVerTextBox.Name = "hFwVerTextBox"; + hFwVerTextBox.ReadOnly = true; + hFwVerTextBox.Size = new Size(180, 31); + hFwVerTextBox.TabIndex = 6; + hFwVerTextBox.TabStop = false; + // + // hHwRevTextBox + // + hHwRevTextBox.Location = new Point(137, 85); + hHwRevTextBox.Margin = new Padding(3, 4, 3, 4); + hHwRevTextBox.Name = "hHwRevTextBox"; + hHwRevTextBox.ReadOnly = true; + hHwRevTextBox.Size = new Size(180, 31); + hHwRevTextBox.TabIndex = 5; + hHwRevTextBox.TabStop = false; + // + // hHubNameTextBox + // + hHubNameTextBox.Location = new Point(137, 39); + hHubNameTextBox.Margin = new Padding(3, 4, 3, 4); + hHubNameTextBox.Name = "hHubNameTextBox"; + hHubNameTextBox.ReadOnly = true; + hHubNameTextBox.Size = new Size(180, 31); + hHubNameTextBox.TabIndex = 4; + hHubNameTextBox.TabStop = false; + // + // label1 + // + label1.AutoSize = true; + label1.Location = new Point(24, 142); + label1.Name = "label1"; + label1.Size = new Size(105, 25); + label1.TabIndex = 2; + label1.Text = "FW Version:"; + // + // label5 + // + label5.AutoSize = true; + label5.Location = new Point(23, 91); + label5.Name = "label5"; + label5.Size = new Size(112, 25); + label5.TabIndex = 1; + label5.Text = "HW revision:"; + // + // label6 + // + label6.AutoSize = true; + label6.Location = new Point(32, 44); + label6.Name = "label6"; + label6.Size = new Size(102, 25); + label6.TabIndex = 0; + label6.Text = "Hub Name:"; + // + // progressUpdate + // + progressUpdate.Location = new Point(12, 307); + progressUpdate.Name = "progressUpdate"; + progressUpdate.Size = new Size(705, 34); + progressUpdate.TabIndex = 8; + // + // programButton + // + programButton.Location = new Point(12, 247); + programButton.Name = "programButton"; + programButton.Size = new Size(112, 34); + programButton.TabIndex = 9; + programButton.Text = "Program"; + programButton.UseVisualStyleBackColor = true; + programButton.Click += programButton_Click; + // + // cancelButton + // + cancelButton.Location = new Point(239, 247); + cancelButton.Name = "cancelButton"; + cancelButton.Size = new Size(112, 34); + cancelButton.TabIndex = 10; + cancelButton.Text = "Cancel"; + cancelButton.UseVisualStyleBackColor = true; + cancelButton.Click += cancelButton_Click; + // + // UpdateHub + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(734, 356); + ControlBox = false; + Controls.Add(cancelButton); + Controls.Add(programButton); + Controls.Add(progressUpdate); + Controls.Add(groupBox2); + Controls.Add(groupBox1); + MaximizeBox = false; + Name = "UpdateHub"; + Text = "Update ready"; + groupBox1.ResumeLayout(false); + groupBox1.PerformLayout(); + groupBox2.ResumeLayout(false); + groupBox2.PerformLayout(); + ResumeLayout(false); + } + + #endregion + + private GroupBox groupBox1; + private TextBox fFwVerTextBox; + private TextBox fHwRevTextBox; + private TextBox fHubNameTextBox; + private Label label4; + private Label label3; + private Label label2; + private GroupBox groupBox2; + private TextBox hFwVerTextBox; + private TextBox hHwRevTextBox; + private TextBox hHubNameTextBox; + private Label label1; + private Label label5; + private Label label6; + private ProgressBar progressUpdate; + private Button programButton; + private Button cancelButton; + private TextBox hMode; + private Label label7; + private TextBox hSafeFwVer; + private Label label8; + } +} \ No newline at end of file diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.cs b/hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.cs new file mode 100644 index 0000000..86067d8 --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.cs @@ -0,0 +1,95 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace CSHubUpdater +{ + public partial class UpdateHub : Form + { + readonly IHubConnection hub; + readonly IHubBitFile bitfile; + bool isUpdating = false; + + public UpdateHub(IHubConnection connection, IHubBitFile file) + { + InitializeComponent(); + hub = connection; + bitfile = file; + + fHubNameTextBox.Text = file.HubId.ToString(); + fFwVerTextBox.Text = file.FwVer.ToString(); + fHwRevTextBox.Text = file.HwRevision.ToString(); + + hHubNameTextBox.DataBindings.Add("Text", hub, nameof(IHubConnection.HubId)); + hHwRevTextBox.DataBindings.Add("Text", hub, nameof(IHubConnection.HwRevision)); + hFwVerTextBox.DataBindings.Add("Text", hub, nameof(IHubConnection.FwVersion)); + hSafeFwVer.DataBindings.Add("Text",hub,nameof(IHubConnection.SafeFwVersion)); + Binding modeBinding = new("Text", hub, nameof(IHubConnection.SafeFirmware)); + modeBinding.Format += (sender, e) => + { + if (e.DesiredType != typeof(string)) return; + e.Value = ((bool)e.Value) ? "Backup" : "Normal"; + }; + hMode.DataBindings.Add(modeBinding); + bitfile = file; + + + } + + private async void programButton_Click(object sender, EventArgs e) + { + isUpdating = true; + cancelButton.Enabled = false; + programButton.Enabled = true; + progressUpdate.Value = 0; + // NB: Last 10% will be resetting the headstage + int maxValue = (int)((bitfile.Data.Length / 4) / 0.9); + Progress progress = new(value => + { + progressUpdate.Value = value; + }); + try + { + await hub.UpdateFirmware(bitfile, progress); + await hub.RestartHeadstage(); + progressUpdate.Value = maxValue; + if (hub.HubId != bitfile.HubId || hub.HwRevision != bitfile.HwRevision) + { + // NB: This should never happen, it it happens, something VERY wrong has happened + throw new IOException($"Programmed IDs do not match. Reported hub id: {hub.HubId} hw rev: {hub.HwRevision}. " + + $"Expected hub id {bitfile.HubId} hw rev: {bitfile.HwRevision}"); + } + } + catch (Exception ex) + { + isUpdating = false; + Close(); + MessageBox.Show(ex.Message, "Failure while updating", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + cancelButton.Enabled = true; + isUpdating = false; + if (hub.SafeFirmware) + { + MessageBox.Show("Hub booted into backup firmware. This implies a failed update. " + + "Please try again or contact support", "Update failed", MessageBoxButtons.OK, MessageBoxIcon.Warning); + programButton.Enabled = true; + } + else + { + MessageBox.Show("Hub update successful", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information); + cancelButton.Text = "Close"; + } + } + + private void cancelButton_Click(object sender, EventArgs e) + { + Close(); + } + } +} diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.resx b/hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/UpdateHub.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.Designer.cs b/hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.Designer.cs new file mode 100644 index 0000000..0c7536c --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.Designer.cs @@ -0,0 +1,211 @@ +namespace CSHubUpdater +{ + partial class UpdaterApp + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + #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(UpdaterApp)); + searchFileButton = new Button(); + label1 = new Label(); + fileNameTextBox = new TextBox(); + groupBox1 = new GroupBox(); + fwVerTextBox = new TextBox(); + hwRevTextBox = new TextBox(); + hubNameTextBox = new TextBox(); + label4 = new Label(); + label3 = new Label(); + label2 = new Label(); + portComboBox = new ComboBox(); + label5 = new Label(); + programButton = new Button(); + groupBox1.SuspendLayout(); + SuspendLayout(); + // + // searchFileButton + // + searchFileButton.Location = new Point(514, 48); + searchFileButton.Margin = new Padding(3, 4, 3, 4); + searchFileButton.Name = "searchFileButton"; + searchFileButton.Size = new Size(47, 45); + searchFileButton.TabIndex = 1; + searchFileButton.Text = "..."; + searchFileButton.UseVisualStyleBackColor = true; + searchFileButton.Click += searchFileButton_Click; + // + // label1 + // + label1.AutoSize = true; + label1.Location = new Point(13, 58); + label1.Name = "label1"; + label1.Size = new Size(119, 25); + label1.TabIndex = 1; + label1.Text = "Firmware File:"; + // + // fileNameTextBox + // + fileNameTextBox.Location = new Point(139, 54); + fileNameTextBox.Margin = new Padding(3, 4, 3, 4); + fileNameTextBox.Name = "fileNameTextBox"; + fileNameTextBox.Size = new Size(368, 31); + fileNameTextBox.TabIndex = 0; + // + // groupBox1 + // + groupBox1.Controls.Add(fwVerTextBox); + groupBox1.Controls.Add(hwRevTextBox); + groupBox1.Controls.Add(hubNameTextBox); + groupBox1.Controls.Add(label4); + groupBox1.Controls.Add(label3); + groupBox1.Controls.Add(label2); + groupBox1.Location = new Point(18, 120); + groupBox1.Margin = new Padding(3, 4, 3, 4); + groupBox1.Name = "groupBox1"; + groupBox1.Padding = new Padding(3, 4, 3, 4); + groupBox1.Size = new Size(339, 205); + groupBox1.TabIndex = 3; + groupBox1.TabStop = false; + groupBox1.Text = "Target:"; + // + // fwVerTextBox + // + fwVerTextBox.Location = new Point(121, 136); + fwVerTextBox.Margin = new Padding(3, 4, 3, 4); + fwVerTextBox.Name = "fwVerTextBox"; + fwVerTextBox.ReadOnly = true; + fwVerTextBox.Size = new Size(180, 31); + fwVerTextBox.TabIndex = 6; + fwVerTextBox.TabStop = false; + // + // hwRevTextBox + // + hwRevTextBox.Location = new Point(121, 85); + hwRevTextBox.Margin = new Padding(3, 4, 3, 4); + hwRevTextBox.Name = "hwRevTextBox"; + hwRevTextBox.ReadOnly = true; + hwRevTextBox.Size = new Size(180, 31); + hwRevTextBox.TabIndex = 5; + hwRevTextBox.TabStop = false; + // + // hubNameTextBox + // + hubNameTextBox.Location = new Point(121, 39); + hubNameTextBox.Margin = new Padding(3, 4, 3, 4); + hubNameTextBox.Name = "hubNameTextBox"; + hubNameTextBox.ReadOnly = true; + hubNameTextBox.Size = new Size(180, 31); + hubNameTextBox.TabIndex = 4; + hubNameTextBox.TabStop = false; + // + // label4 + // + label4.AutoSize = true; + label4.Location = new Point(8, 140); + label4.Name = "label4"; + label4.Size = new Size(105, 25); + label4.TabIndex = 2; + label4.Text = "FW Version:"; + // + // label3 + // + label3.AutoSize = true; + label3.Location = new Point(7, 89); + label3.Name = "label3"; + label3.Size = new Size(112, 25); + label3.TabIndex = 1; + label3.Text = "HW revision:"; + // + // label2 + // + label2.AutoSize = true; + label2.Location = new Point(16, 42); + label2.Name = "label2"; + label2.Size = new Size(102, 25); + label2.TabIndex = 0; + label2.Text = "Hub Name:"; + // + // portComboBox + // + portComboBox.DropDownStyle = ComboBoxStyle.DropDownList; + portComboBox.FormattingEnabled = true; + portComboBox.Items.AddRange(new object[] { "A", "B" }); + portComboBox.Location = new Point(428, 149); + portComboBox.Margin = new Padding(3, 4, 3, 4); + portComboBox.Name = "portComboBox"; + portComboBox.Size = new Size(134, 33); + portComboBox.TabIndex = 2; + // + // label5 + // + label5.AutoSize = true; + label5.Location = new Point(374, 152); + label5.Name = "label5"; + label5.Size = new Size(48, 25); + label5.TabIndex = 5; + label5.Text = "Port:"; + // + // programButton + // + programButton.Enabled = false; + programButton.Location = new Point(379, 209); + programButton.Margin = new Padding(3, 4, 3, 4); + programButton.Name = "programButton"; + programButton.Size = new Size(183, 58); + programButton.TabIndex = 3; + programButton.Text = "program"; + programButton.UseVisualStyleBackColor = true; + programButton.Click += programButton_Click; + // + // UpdaterApp + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(626, 340); + Controls.Add(programButton); + Controls.Add(label5); + Controls.Add(portComboBox); + Controls.Add(groupBox1); + Controls.Add(fileNameTextBox); + Controls.Add(label1); + Controls.Add(searchFileButton); + FormBorderStyle = FormBorderStyle.Fixed3D; + Icon = (Icon)resources.GetObject("$this.Icon"); + Margin = new Padding(3, 4, 3, 4); + MaximizeBox = false; + Name = "UpdaterApp"; + Text = "ONIX Hub Updater"; + Load += UpdaterApp_Load; + groupBox1.ResumeLayout(false); + groupBox1.PerformLayout(); + ResumeLayout(false); + PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button searchFileButton; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox fileNameTextBox; + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.TextBox fwVerTextBox; + private System.Windows.Forms.TextBox hwRevTextBox; + private System.Windows.Forms.TextBox hubNameTextBox; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.ComboBox portComboBox; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.Button programButton; + } +} \ No newline at end of file diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.cs b/hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.cs new file mode 100644 index 0000000..eb6adff --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.cs @@ -0,0 +1,149 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace CSHubUpdater +{ + public partial class UpdaterApp : Form + { + + IHubBitFile bitFile; + CancellationTokenSource loadCancellationToken; + readonly SemaphoreSlim loadSemaphore = new(1,1); + + public UpdaterApp() + { + InitializeComponent(); + } + + void UpdaterApp_Load(object sender, EventArgs e) + { + portComboBox.SelectedIndex = 0; + } + + async void searchFileButton_Click(object sender, EventArgs e) + { + string initialPath; + string writtenPath; + try + { + writtenPath = Path.GetDirectoryName(fileNameTextBox.Text); + } + catch (ArgumentException) + { + writtenPath = null; + } + if (!string.IsNullOrEmpty(writtenPath) && Directory.Exists(writtenPath)) + { + initialPath = writtenPath; + } + else + { + initialPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal); + } + + using OpenFileDialog dialog = new(); + + + dialog.InitialDirectory = initialPath; + dialog.Filter = "All Files (*.*)|*.*|ONIX hub firmware files (*.onix)|*.onix"; + dialog.FilterIndex = 2; + dialog.RestoreDirectory = true; + if (dialog.ShowDialog() == DialogResult.OK) + { + fileNameTextBox.Text = dialog.FileName; + await LoadBitFile(); + } + + } + + async Task LoadBitFile() + { + bitFile = null; + programButton.Enabled = false; + try + { + var file = new FileInfo(fileNameTextBox.Text); + + Task localTask; + //Protected zone + await loadSemaphore.WaitAsync(); + try + { + loadCancellationToken?.Cancel(); + loadCancellationToken?.Dispose(); + loadCancellationToken = new CancellationTokenSource(); + + localTask = HubBitFile.CreateAsync(file, loadCancellationToken.Token); + } + finally + { + loadSemaphore.Release(); + } + bitFile = await localTask; + hubNameTextBox.Text = bitFile.HubId.ToString(); + hwRevTextBox.Text = bitFile.HwRevision.ToString(); + fwVerTextBox.Text = bitFile.FwVer.ToString(); + programButton.Enabled = true; + + } + catch (TaskCanceledException) + { } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Failure to open firmware file", MessageBoxButtons.OK, MessageBoxIcon.Error); + hubNameTextBox.Text = string.Empty; + hwRevTextBox.Text = string.Empty; + fwVerTextBox.Text = string.Empty; + } + + + } + + private async void programButton_Click(object sender, EventArgs e) + { + Enabled = false; + try + { + using var hub = await HubConnection.CreateFromHubInfoAsync("riffa", 0, portComboBox.SelectedIndex, bitFile.HubId); + if (hub.HwRevision != bitFile.HwRevision) + { + throw new ArgumentException($"Hardware recision mismatch. File expected {bitFile.HwRevision} Hardware reported {hub.HwRevision}"); + } + UpdateHub updater = new(hub, bitFile); + updater.ShowDialog(); + + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Failure to open hardware", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + finally + { + Enabled = true; + } + } + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing) + { + components?.Dispose(); + loadCancellationToken?.Dispose(); + } + base.Dispose(disposing); + } + } +} diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.resx b/hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.resx new file mode 100644 index 0000000..b9d468e --- /dev/null +++ b/hub-tools/CSHubUpdater/CSHubUpdater/UpdaterApp.resx @@ -0,0 +1,1775 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAA4AEBAQAAEABAAoAQAA5gAAABAQAAABAAgAaAUAAA4CAAAQEAAAAQAgAGgEAAB2BwAAICAQAAEA + BADoAgAA3gsAACAgAAABAAgAqAgAAMYOAAAgIAAAAQAgAKgQAABuFwAAMDAQAAEABABoBgAAFigAADAw + AAABAAgAqA4AAH4uAAAwMAAAAQAYAKgcAAAmPQAAMDAAAAEAIACoJQAAzlkAAEBAAAABABgAKDIAAHZ/ + AABAQAAAAQAgAChCAACesQAAAAAAAAEAGABpMQAAxvMAAAAAAAABACAAZ10AAC8lAQAoAAAAEAAAACAA + AAABAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACAgAAAgICAAACAgADAwMAA//8AAAD/ + /wAAAP8A/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUiAAAAAAAFU5YAAA + AAVVADYgAAAFVQAGYlAAVTUAVTUjMAM1VVVTIDOABVAAAAYDRHAAVQAAYzhlAAAFUAY4AFcAAABVA0AA + NwAAAAUDAAZAAAAAAAAAA0AAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAA//8AAP/xAAD/wQAA/jEAAPjh + AADDAAAAgBEAAJ+hAADPAwAA5jMAAPJzAAD45wAA/+cAAP/vAAD/7wAA//8AACgAAAAQAAAAIAAAAAEA + CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI5YzAEWaLgCFpi8AJLioAL2exQA9QTAAO12VANK0 + LwAws5AAzarWAGZsPgA+Z9UAdLRpACbQ+wDdtS8Ak41jAEBr6QDAtkIA37YvAKmdbgA/auoAR27gANKu + MgA8zeMAu5vDAMiq0ABLXUwATaKmAHpvfACWlJUAqqmpALe2tgDGr2QAxKAqAHt6RQA+XowAHJXwALW0 + tACysbEAtLOzALe1swCrjzcAsp5eAK2ecQCQgU8ALk93AA09OADctDEAzqw0AN61LgDbrikA3bMsAMWs + XgC/gxAA1qYjALazrQCMYSEAnGUNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg5 + OgAAAAAAAAAAAAAAICA1NjcAAAAAAAAAACAgIAAAMjM0AAAAAAAAICAgAAAAExMwMQAAACYnKCAAACAp + KissLS4vAB0eHyAgICAgISIAIyQlAAAZGgAAAAAAABMAFRscDgAAAAoKAAAAABMUFRYXGAAAAAAACgoA + AA8QEQAAEg4AAAAAAAAKCgALDAAAAA0OAAAAAAAAAAUGBwAAAAgJAAAAAAAAAAAAAAAAAAADBAAAAAAA + AAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAP//AAD/8QAA/8EAAP4x + AAD44QAAwwAAAIARAACfoQAAzwMAAOYzAADycwAA+OcAAP/nAAD/7wAA/+8AAP//AAAoAAAAEAAAACAA + AAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBiHh6PWw0RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC3trYBt7a2RLazra2MYSH7nGUNjgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAALe2thG3trZvt7a217e2tufFrF7xv4MQ/9amI9YAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAt7a2Mre2tpu3trbzt7a2wre2tljctjlZ3rUu99uuKf7dsyz437YvIgAAAAAAAAAAAAAAALe2 + tgi3trZdt7a2xre2tvG3traWt7a2LQAAAADfti8d37Yv7N+2L5PctDHizqw0w7aeLGwAAAAAt7a2IrW0 + tIiysbHqtLOz9re2trK3trZut7a2eLe2tpC3tbOoq4833LKeXv2tnnHykIFP/y5Pd/8NPTiacV91dnpv + fPyWlJX/qqmp+7e2tuq3trbSt7a2ure2tqK3traKxq9k0MSgKtayrZ9De3pFwz5ejP4clfD/JMn6PYly + jiK7m8PbyKrQtb+ywgwAAAAAAAAAAAAAAAAAAAAA37YvOd+2L/K2o15BP2rqqktdTP9Noqa5JtD71SbQ + +wEAAAAAzarWGM2q1tDNqtavzarWCQAAAAAAAAAA37YvD9+2L92pnW6pP2rq3kdu4LzSrjL+PM3j2ybQ + +24AAAAAAAAAAAAAAADNqtYQzarWw82q1r7NqtYOAAAAAN21L6OTjWP+QGvp9D9q6nDbtDM4wLZC/ibQ + +/Qm0PsRAAAAAAAAAAAAAAAAAAAAAM2q1grNqta0zarWy7idS3BmbD7/PmfV2j9q6jMAAAAA37YvaHS0 + af8m0PufAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWBr2exaU9QTD/O12VpD9q6g4AAAAAAAAAANK0 + L5kws5D/JtD7OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3bXYDPkM8PQAAAAAAAAAAAAAAAAAA + AACFpi/LJLiozwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADYtS8GRZou9iS8t2gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAASaA9KCOWM/MlyOEOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFKrYQEynEAdAAAAAAAAAAAAAAAAAAAAAP/5AAD/wQAA/wEAAPwAAADgQAAAgAAAAAAA + AAAPAAAAhgEAAMIBAADgIwAA8GMAAPnnAAD/xwAA/8cAAP/PAAAoAAAAIAAAAEAAAAABAAQAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAgIAAgICAAICAAAAA//8AAP8AAP//AACAAIAAwMDAAAAA + gAAAAP8A/wD/AP8AAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAACT5AAAAAAAAAAAAAAAAACZNEQAAAAAAAAAAAAAAACZOTTXMAAAAAAAAAAAAAmZmZl9RzAAAA + AAAAAAAAk5mQAHRzfQAAAAAAAAAJmZmQAAfZc3MAAAAAAAAJOZmQAABHN9d0cAAAAACTmZkAAAAAcwdz + CUAAAACZmZkAAAAABzeTQzAQAACZk5mZOZk5mURJlEM6oAMzMzmTmZmZmZNDkJQ7tVADgzmZmZmQAAAH + QAAxglMAAzmQAAAAAAAAc3ALMDJVAAAJmQAAAAAABzcAszSZUAAAAJnAAAAAAANws1MzM1AAAAAJmQAA + AAB3M1OwR1VQAAAAAJnAAAAHOTs7AHOVAAAAAAAJmQAAc0O1AANzVQAAAAAAAJnAAEQ7MAAHclAAAAAA + AAAJmQQysAAABJKQAAAAAAAAAJkxowAAAAdFUAAAAAAAAAADgDAAAAAJFQAAAAAAAAAAABAAAAAABCUA + AAAAAAAAAAAAAAAAAHIwAAAAAAAAAAAAAAAAAAA2IAAAAAAAAAAAAAAAAAAAQVAAAAAAAAAAAAAAAAAA + ABMAAAAAAAAAAAAAAAAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////// + //////+H///+B///+AP//8AD//8HA//4HgP/4HwB/wP8ifwP+AHwAAABgAABAYAH5wOH/8YD4/+MB/H/ + kAf4/wEH/H4DD/48Dg//HB4f/4h+H//A/h//4f4///f+P////H////x////8f////P////z///////// + //8oAAAAIAAAAEAAAAABAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGULgAmmTwAIpQuACGX + NwBNnC4AIZQvACW/wACPqC8AJLmsANS0LwAxly4AI6+JAD5CNwB1oy4AIqNhACbQ+wCchaAALDMkAC02 + KQA8X6cAwbEvACOZPgAmz/cAzarWAMmn0QBmWUwAM0MoADhQRQA+aN0A37YvAFKdLgAlyN8Ano0tAEFS + KwA6V3AAP2rpAJ+qLwAkvLcAxqYuAFliLAA8X6QAP2rqANm1LwA1tJAA2bIvAIF8OAA/Z9AAfLVpAKyb + VgBDbOUAxbZAACbQ+gDCqFEAPszgAEFr5gCrlzoAf8OZADpUWgCAei0AzLE5AIhxjgCkiKsAt5e/AMKn + yQA6WX8AN0wrAEFXUAAsuPcAaVZtAHZpeQCbmZoAsK+vALe2tgBWaGgAPE8rADpt6QAcpPMAdGJ3AIB2 + ggCKiYkAhoWFAIWEhACTkpIAqKenALa1tQCynl4AsI8lALSSJgCxp4oAwLKGAKqRKwBIVSwAPWXVABlb + 5AAUg+0AJMf5ALOysgCrqqoArq2tALazrwCkizoAoIIiAKSMPgC2tLEAoYQpAJl9IgBZZocAIkmpAAY3 + aAALRk0Au5goALaVJwC4pGMAp44+AKKEIgCsnnMAgIqoABAyJAAGLB4A3LMuANayOgC0mSoAmIsqAN60 + LQDftS8A3rQuANOgHwDarSgA2aomANK0VADetS8AyY0RAMyTFgCwlUEAtYMTALJqBQDNlRcAs62dAJdy + HAB9RAEAo2kMAKSQawB6QgEAgUoFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAASY6PkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASUmKi4yNAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAASUlJaIaHiIkeAAAAAAAAAAAAAAAAAAAAAAAAAABJSUlJSUmCg4SFfx4AAAAA + AAAAAAAAAAAAAAAAAABJSUlJSQAAAB58f4CBHgAAAAAAAAAAAAAAAAAAAElJSUlJSQAAAAAeHnx9Hn4e + AAAAAAAAAAAAAAAAAElJSUlJSQAAAAAAHh4eHh4eHh4eAAAAAAAAAAAASUlJSUlJAAAAAAAAAAAeHgAe + eHkAensAAAAAAAAASUlJSUlJAAAAAAAAAAAAb3BxSXJzdHV2dwAAAAAAVWFIYmNVSUlJSUlJSUlJZGVm + Z2hoaWprbG1uAABOT1BRUlNUVUlJSUlJSUlJSUlWV1hZAFpbXF1eX2AAAEVFRkdISUlJSUlJSQAAAAAA + AB4eAAAASkscTE0QAAAAPT4/QAAAAAAAAAAAAAAAAAAeHh4AACpBQkNEEBAAAAAAABgYGAAAAAAAAAAA + AAAAHh4eAAAqKjo7PBAQAAAAAAAAABgYGAAAAAAAAAAAAAAeHgAqKio3OB45EBAAAAAAAAAAABgYGAAA + AAAAAAAAHh41KioqKgAeHjYQEAAAAAAAAAAAABgYGAAAAAAAAB4eMTIqKioAAB4zNBAAAAAAAAAAAAAA + ABgYGAAAAAAeLS4vKioAAAAeHjAQEAAAAAAAAAAAAAAAABgYGAAAACcoKSoqAAAAAB4rLBAAAAAAAAAA + AAAAAAAAABgYGAAhIiMkAAAAAAAAHiUmEAAAAAAAAAAAAAAAAAAAABgZGhscHQAAAAAAAAAeHyAQAAAA + AAAAAAAAAAAAAAAAABESExQAAAAAAAAAABUWFwAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAADg8Q + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoLDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + CAEJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAMEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////// + /4f///4H///4A///wAP//wcD//geA//gfAH/A/yJ/A/4AfAAAAGAAAEBgAfnA4f/xgPj/4wH8f+QB/j/ + AQf8fgMP/jwOD/8cHh//iH4f/8D+H//h/j//9/4////8f////H////x////8/////P///////////ygA + AAAgAAAAQAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqqXDIxaEWuPWw1DAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3trYBt7a2Kre2tpCkkGvvekIB/4FKBfHInSsKAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3trYFt7a2U7e2tru3trb8s62d/5dyHP99RAH/o2kM/9+2 + Lz4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3trYct7a2fre2tuK3trb/t7a2/7a0sf+wlUH/tYMT/7Jq + Bf/NlRf/37YviAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tgK3trZBt7a2qbe2tvi3trb/t7a2/7e2tve3tran0rRUx961 + L//JjRH/zJMW/9OgH//fti/SAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2thC3trZst7a207e2tv63trb/t7a2/7e2tt+3trZ7t7a2Gt+2 + L0vfti/93rQt/9OgH//arSj/2aom/9+2L/7fti8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tjC3traXt7a28Le2tv+3trb/t7a2/Le2trm3trZPt7a2BQAA + AADfti8Z37Yv59+2L//etC3j37Uv/9+2L/vetC7l37Yv/9+2L2kAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAt7a2CLe2tlm3trbDt7a2/be2tv+3trb/t7a27Le2to63trYnAAAAAAAA + AAAAAAAA37YvA9+2L7bfti//37Yv59+2L4Dfti//37Yv1t+2L5jfti//37YvswAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAt7a2Ibe2toW3trbmt7a2/7e2tv+3trb+t7a2ybe2tmK3trYMAAAAAAAA + AAAAAAAAAAAAAAAAAADfti9x37Yv/9+2L/zfti9L37YvmNyzLv/Wsjq1yrFddrSZKv+YiyryuKAtDAAA + AAAAAAAAAAAAAAAAAAC3trYDt7a2R7e2trC3trb6t7a2/7e2tv+3trb1t7a2oLe2tje3trYCt7a2Are2 + tga3trYUt7a2LLe2tkS3trZcsaR7e7uYKPe2lSf/uKRj9re2ttWnjj73ooQi/6yec/+Aiqj/EDIk/wYs + Hv8iSj1OAAAAAAAAAAC3trYUt7a2cra1tdmzsrL/sK+v/6uqqv+ura3/trW13Le2tpi3trabt7a2s7e2 + tsu3trbht7a29re2tv+3trb/t7a2/7azr/+kizr/oIIi/6SMPv+2tLH/trSx/6GEKf+ZfSL/WWaH/yJJ + qf8GN2j/C0ZN+B1dYCKLeo4HdGJ3n4B2gvOKiYn/hoWF/4WEhP+TkpL/qKen/7a1tf+3trb/t7a2/7e2 + tv+3trb/t7a2/7e2tv+3trb/t7a2/re2tvy3trbwsp5e/LCPJf+0kib0saeKkbe2tnjAsoaDqpEr/0hV + LP89ZdX/GVvk/xSD7f8kx/mvAAAAAI18kDFpVm3/aVZt/3Zpef+bmZr/sK+v/7e2tv23trbwt7a24be2 + tsq3trayt7a2mbe2toK3trZpt7a2Ube2tjm3trYit7a2DN+2L1Tfti/+37Yv/9+2L2YAAAAAP2rqA1Zo + aIk8Tyv/OFBF/zpt6f0cpPP/JtD7/ybQ+0cAAAAAo5OlAohxjoikiKv/t5e//8Knydy7tLw2t7a2Fbe2 + tgm3trYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfti8f37Yv69+2L//fti+t37YvAj9q + 6hU/auqyOll//zdMK/9BV1DYLLj3qCbQ+/8m0PvdJtD7AwAAAAAAAAAAAAAAAM2q1nHNqtb8zarW/82q + 1sLNqtYRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvA9+2L8Dfti//37Yv4d+2 + LxQ/aupCP2rq5D9q6v86VFr/gHot/8yxOYIm0PviJtD7/ybQ+3cAAAAAAAAAAAAAAAAAAAAAAAAAAM2q + 1mDNqtb6zarW/82q1s3NqtYYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfti9737Yv/9+2 + L/zVsTtFP2rqgD9q6vo/aur/QWvm76uXOv3fti//f8OZnSbQ+/8m0Pv3JtD7GQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAM2q1lDNqtb1zarW/82q1trNqtYiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvO9+2 + L/nfti//wqhRoj9q6sA/aur/P2rq/z9q6r+YlIJB37Yv/9+2L/0+zODTJtD7/ybQ+6gAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1kLNqtbxzarW/82q1uLNqtYsAAAAAAAAAAAAAAAAAAAAAN+2 + Lw/fti/c37Yv/6ybVvtDbOXwP2rq/z9q6vw/auqBP2rqBd+2L1Xfti//xbZA/CbQ+vwm0Pv/JtD7QgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1jTNqtbozarW/82q1uvNqtY5AAAAAAAA + AADfti8B37YvpNmyL/+BfDj/P2fQ/z9q6v8/aurjP2rqQgAAAAAAAAAA37Yvh9+2L/98tWn/JtD7/ybQ + +9cm0PsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1inNqtbfzarW/82q + 1vLNqtZFAAAAAN+2L17Gpi7+WWIs/zxfpP8/aur/P2rqtD9q6hYAAAAAAAAAAAAAAADfti+42bUv/zW0 + kP8m0Pv/JtD7cgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q + 1h7NqtbVzarW/82q1vjPqaBzno0t8UFSK/86V3D/P2rp+D9q6nI/auoDAAAAAAAAAAAAAAAA37YvAd+2 + L+efqi//JLy3/ybQ+/Qm0PsVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAM2q1hfNqtbJyafR/2ZZTP8zQyj/OFBF/z5o3do/auo2AAAAAAAAAAAAAAAAAAAAAAAA + AADfti8d37Yv/FKdLv8lyN//JtD7owAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1g6chaC9LDMk/y02Kf48X6emP2rqDwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAN+2L0zBsS//I5k+/ybP9/4m0Ps8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHdtdgw+QjePP0VDZj9q6gEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA37YvfnWjLv8io2H/JtD70ibQ+wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUtC+vMZcu/yOvif8m0PtsAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvAo+oL90hlC7/JLms8ibQ+xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXtS8VTZwu/CGUL/8lv8CcAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGOiNkcilC7/IZc3/iXI + 4DcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANZ5DWyGU + Lv8mmTzQJtD7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABSq2EDLJk5UUCjTyIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////// + /8f///4D///4A///4AP//wAD//wAAf/wBAH/gDgB/gD4APAAAADAAAAAAAAAAQAAAgEAf4ABwf8AA+D/ + AAPwfgAH+DwAB/wYBgf+CA4P/wAcD/+AfB//wPwf/+H8H////D////g////4f///+H////h////4//// + //8oAAAAMAAAAGAAAAABAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAgIAAgIAAAAD/ + AAAA//8AwMDAAICAgAD//wAAgACAAIAAAAD/AP8AAAD/AP///wD/AAAAAACAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAGOjAAAAAAAAAAAAAAAAAAAAAAAAAAAGZn46MAAAAAAAAAAAAAAAAAAAAA + AAAAZmZzM+YAAAAAAAAAAAAAAAAAAAAAAAZmZ2Yz44cAAAAAAAAAAAAAAAAAAAAABmZ2ZmeHM+iAAAAA + AAAAAAAAAAAAAAAGZ2ZmYHjo44hwAAAAAAAAAAAAAAAAAGZ2ZmZgAIeDaOYwAAAAAAAAAAAAAAAAZmZm + ZgAACDho6HiAAAAAAAAAAAAAAAZnZnZmAAAAaHjoeDh+AAAAAAAAAAAABmZmZmYAAAAAjoeHhweIAAAA + AAAAAABmdmdmYAAAAAADh4CDiAiHAAAAAAAAAGZmZmZgAAAAAACGgwCGhwNzcAAAAAAAZmdmZgAAAAAA + AAh+h2Y+NmcBEAAAAAZ2ZmZnAAAABmZmZnOHNmczd38JAAAABmZmdnZmZmZ2ZmdmZmMzZmc3N8LxIAB3 + d3d3dmZ2Z2ZmdmZnY+M2ZmeDLFzFAAd5d3d2Z2ZmZmZmZmZgY3hwAANwfHVVAAeXmWZmZmZmAAAAAAAA + aIMAAAGRfFVgAAB3ZmAAAAAAAAAAAAAI6HAADHKhxlxQAAAGZmYAAAAAAAAAAACDaAAAxiA3BXVQAAAA + ZrZgAAAAAAAAAABoOADFfHN4BVUAAAAABmZmAAAAAAAAAAjoYAx3x3OHZXUAAAAAAGa2YAAAAAAAAIeD + AMV8UGg2VVAAAAAAAAZttgAAAAAAAIeGfHfHAI5nV1AAAAAAAABmbWAAAAAACDh3x1xwAIeFVQAAAAAA + AAAAZr0AAAAAh4d8V8AACHh1dQAAAAAAAAAABmZgAAAHg3fHfAAAB4NlVQAAAAAAAAAAAGa20AAINyfF + wAAACId1UAAAAAAAAAAAAAZmZgCHonxwAAAACHNXUAAAAAAAAAAAAABmtmcxkscAAAAACDdVAAAAAAAA + AAAAAAAGZnMHJwAAAAAAh2FWAAAAAAAAAAAAAAAAZpApIAAAAAAAgzJVAAAAAAAAAAAAAAAABwGiAAAA + AAAANhdQAAAAAAAAAAAAAAAAABkAAAAAAAAAgxVQAAAAAAAAAAAAAAAAAAAAAAAAAAAAYXUAAAAAAAAA + AAAAAAAAAAAAAAAAAAAIMkUAAAAAAAAAAAAAAAAAAAAAAAAAAAAGMXUAAAAAAAAAAAAAAAAAAAAAAAAA + AAADQiAAAAAAAAAAAAAAAAAAAAAAAAAAAAADI1AAAAAAAAAAAAAAAAAAAAAAAAAAAAABJAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAjEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /////wAA////////AAD//////58AAP/////+HwAA//////APAAD/////wA8AAP////4ADwAA////+AAH + AAD////gEAcAAP///wBwBwAA///8A+AHAAD//+APwAMAAP//gD/AIwAA//wB/4QjAAD/8Af/DCEAAP/A + P/4AAQAA/gD+AAABAAD4AAAAAAEAAMAAAAAAAwAAgAAAEHgDAACAAP/w+AcAAMH//+HgBwAA4P//w8CH + AADwf//DAI8AAPg//4YADwAA/B//DBAfAAD+D/8AMB8AAP8H/gBwPwAA/8P8AeA/AAD/4fgD4D8AAP/w + eAfgfwAA//gwH+B/AAD//AA/4P8AAP/+AP/A/wAA//8B/8D/AAD//4P/wf8AAP//z//B/wAA/////8P/ + AAD/////g/8AAP////+D/wAA/////4f/AAD/////h/8AAP////+P/wAA/////w//AAD/////j/8AAP// + /////wAA////////AAD///////8AACgAAAAwAAAAYAAAAAEACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAIZQuAC2cQQA4nT8AI5xHACSVLgAhlzgAUp0uACGULwAlwMQAlqkvACS4qADXtS8AMZcuACOs + gQAm0PsA37YvAHmkLgAioVoAJtD6AMCwLwAmlS4AJs71AD1BNwA7QDQAVJ0uACXF1wCJd4sALDMkAC44 + LwA8YbUAoqsvACS6rwDNqtYAq5CwAC81KAAvOyYAOFJRAD9p4gDYtS8AN5guACOviQCbfXkAQEMmADZL + KwA3TCsAOll/AD9q6QB9pC4AIqNgAMypzQDHpS8AaGssADhMKwA3TC0APGGyAD9q6gDGsi8AJptCACbN + 8gDbtC8AkoYtADtPKwA4T0AAPmfWAFieMAAlx9wAu58uAFBbLAA5VWIAP2roAKWsLwAlvLcA0q4vAHFx + LQA8XZUA2bUvAD61jwDetS8Am4w1AEVpxACCtmkAwKZJAEpv3QDItj0AJ9D5ANKwPgBAaukA3rYvAELM + 3ACFw5IAP2rmAHV3SADUry8A2bc2ADpWaABTXiwAvaAuADtbjQA9UCsAioEvAIBqhQCKcpAAoISnAK+R + tgC7ocEAPWGxADhNLQA+ZtMAKcP5AHdlewBpVm0AeWp8AKGeoAC0s7MAt7a2ADlOLQA9YrkANHLrAB+y + 9gB2ZHoAcmV0AIKBgQCDgoIAh4aGAJqZmQCura0AyrFhANCpLADUrS0A2bEuANy0LgCymS4ATVorADtc + kgA+auoAElznABiU8QAlzfsAeWh8AIh+iQCRkJAAjYyMAImIiACGhYUAhYSEAISDgwCmpaUAtbS0ALe1 + tACnkU0AoYMiAKKEIgCkhSMArqB3AMCjRQC4mCkAXmEoADdSaQA9ZuIAJl/kAAlV5AARdusAIsH4ALGw + sACpqKgApKOjALKxsQC0sKUAoocxAKCCIgChhSsAtK+hAKubaACfgSIAbWU3ADJQpwAqTKoACECpAAY5 + bQAJQ1YAGXyMALCniwCggiMApY5DALa0sQCvpYYAoYUqAJudpgBEXqoAFD1/AAYsHgAMNCkAxaMyAMmk + KgDDnykAvZooAL6pZgC0rpwApockAKOFIwCigyIAsqqUAK6vtQBSX1oAEjgoANuyLgDXry0AzrFQAMak + NQCMgSgAaG4mAJ+RKwDftS8A37UuANuvKgDarSgA3bIsAN60LQDKjxMA1aQiANSiIADctjoAyY0RAM+Z + GgDNlRcAz5gZALi2sgDBpUgA1a4tAM6XGADDgQkAvnsIAMmOEgCzrp8Ao4csAKh/GQCtbwcArGADAMOC + CwCvo4AAnHocAINPBACARgEAnFwDANmrKAC3trUAp5NWAH9JAwB6QgEArnwXALWyqgCFVRgAilYLAI9b + DQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA+/z5+QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc3P29/j5 + +foAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHNzc3Pw8fLz9PUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHNzc3Nzc+rr7O3u79oAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABzc3Nzc3Nz4+Tl5ufo6RAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc3Nz + c3Nzc3MA3hAQ3+Dh4hAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc3Nzc3Nzc3NzAAAAEBDa29rc + 3dUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHNzc3Nzc3NzAAAAAAAQEBDX2BDZ2BAQAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAHNzc3Nzc3NzcwAAAAAAABAQEBDVEBAQ1hAQEAAAAAAAAAAAAAAAAAAAAAAAAABz + c3Nzc3Nzc3MAAAAAAAAAABAQEBAQEBAQABAQEAAAAAAAAAAAAAAAAAAAAABzc3Nzc3Nzc3MAAAAAAAAA + AAAAEBAQEAAQEBAQABAQEAAAAAAAAAAAAAAAAAAAc3Nzc3Nzc3NzAAAAAAAAAAAAAAAQEBAQAAAQzs/Q + ANHS09QAAAAAAAAAAAAAAHNzc3Nzc3NzAAAAAAAAAAAAAAAAAMHCw8TFc8bHyMnKy8y/v80AAAAAAAAA + AHNzc3Nzc3NzcwAAAAAAAABzc3Nzc3Nztreqqri5c7qqqru8vb6/v8AAAAAAAABzc3KkfqWmk6dzc3Nz + c3Nzc3Nzc3Nzc3Ooqaqqq6xzc62qrq+wsbKztLUAAACLjI2Oj5CRko2TlHNzc3Nzc3Nzc3Nzc3Nzc5WW + l5iZmnNzc5ucnZ6foKGiowAAAHhvb3l6e3x9fnNzc3Nzc3Nzc3Nzc3Nzc3NzAH+AgYKDAAAAAISFLYaH + iImKDwAAAG5vb29wcXJzc3Nzc3NzcwAAAAAAAAAAAAAAABAQEBAAAAAAAHQtLXV2dw8PAAAAAABlZmdo + aQAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEAAAAAA4ai0ta2xtDw8PAAAAAAAAISEhISEAAAAAAAAAAAAA + AAAAAAAAAAAQEBAQAAAAADg4Yi1jZAAPDw8PAAAAAAAAACEhISEhAAAAAAAAAAAAAAAAAAAAAAAQEBAQ + AAA4ODg4X2BhEAAPDw8AAAAAAAAAAAAhISEhIQAAAAAAAAAAAAAAAAAAABAQEBAAADg4ODhbXF0QXg8P + Dw8AAAAAAAAAAAAAISEhISEAAAAAAAAAAAAAAAAAEBAQEAAAODg4ODgAWBAQWg8PDwAAAAAAAAAAAAAA + ACEhISEhAAAAAAAAAAAAAAAAEBAQVlc4ODg4OAAAEBBYWQ8PDwAAAAAAAAAAAAAAAAAhISEhIQAAAAAA + AAAAAAAQEBBSUzg4ODg4AAAAEBBUVQ8PAAAAAAAAAAAAAAAAAAAAACEhISEAAAAAAAAAABAQTk9QODg4 + OAAAAAAQEBBRDw8PAAAAAAAAAAAAAAAAAAAAAAAhISEhAAAAAAAAEBBJSks4ODg4AAAAAAAQEExNDw8P + AAAAAAAAAAAAAAAAAAAAAAAAISEhISEAAAAAEENERUY4ODgAAAAAAAAQEEdIDw8AAAAAAAAAAAAAAAAA + AAAAAAAAACEhISEhAAA8PT4/QDg4AAAAAAAAAAAQEEFCDw8AAAAAAAAAAAAAAAAAAAAAAAAAAAAhISEh + MjM0NTY3ODgAAAAAAAAAAAAQOTo7DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAISEhKissLS4vAAAAAAAA + AAAAABAQMDEPDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEiIxwkJSYAAAAAAAAAAAAAABAnKCkPDwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbHBwdHgAAAAAAAAAAAAAAABAfASAPAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAFxgAAAAAAAAAAAAAAAAAABAZARoPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAABQVBhYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAEBEBEhMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA0BDg8AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgEBCwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwEICQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAABQEGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAADAQEEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQECAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////AAD///////8AAP//////nwAA//////4f + AAD/////8A8AAP/////ADwAA/////gAPAAD////4AAcAAP///+AQBwAA////AHAHAAD///wD4AcAAP// + 4A/AAwAA//+AP8AjAAD//AH/hCMAAP/wB/8MIQAA/8A//gABAAD+AP4AAAEAAPgAAAAAAQAAwAAAAAAD + AACAAAAQeAMAAIAA//D4BwAAwf//4eAHAADg///DwIcAAPB//8MAjwAA+D//hgAPAAD8H/8MEB8AAP4P + /wAwHwAA/wf+AHA/AAD/w/wB4D8AAP/h+APgPwAA//B4B+B/AAD/+DAf4H8AAP/8AD/g/wAA//4A/8D/ + AAD//wH/wP8AAP//g//B/wAA///P/8H/AAD/////w/8AAP////+D/wAA/////4P/AAD/////h/8AAP// + //+H/wAA/////4//AAD/////D/8AAP////+P/wAA////////AAD///////8AAP///////wAAKAAAADAA + AABgAAAAAQAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIpWC49bDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALWyqoVVGHpCAXpCAQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2 + tre2tre2taeTVn9JA3pCAXpCAa58FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAALe2tre2tre2tre2tq+jgJx6HINPBIBGAZxcA9mrKAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tre2tre2tre2tre2tre2trOun6OHLKh/Ga1v + B6xgA8OCC960LQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tre2tre2tre2 + tre2tre2tre2tri2ssGlSNWuLc6XGMOBCb57CMmOEt+2L9+2LwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAALe2tre2tre2tre2tre2tre2tre2tre2tgAAANy2Ot+2L9+2L8mNEc+ZGs2VF8+YGd+2L9+2 + LwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tre2tre2tre2tre2tre2tre2tre2tre2tgAAAAAAAAAAAN+2 + L9+2L960LcqPE960LdWkItSiIN+2L9+2LwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tre2tre2tre2tre2tre2tre2 + tre2tgAAAAAAAAAAAAAAAAAAAN+2L9+2L9+2L9uvKtqtKN+2L92yLNqsKN+2L9+2LwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tre2 + tre2tre2tre2tre2tre2tre2tre2tgAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L9+2L9+2L9+1L9+2L9+2 + L9+2L9+1Lt+2L9+2L9+2LwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAALe2tre2tre2tre2tre2tre2tre2tre2tre2tgAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAN+2L9+2L9+2L9+2L9+2L9+2L9+2L9+2LwAAAN+2L9+2L9+2LwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tre2tre2tre2tre2tre2tre2tre2tre2tgAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L9+2L9+2LwAAAN+2L9+2L9+2L9+2LwAAAN+2L9+2 + L9+2LwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tre2tre2tre2tre2 + tre2tre2tre2tre2tgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L9+2L9+2LwAA + AAAAAN+2L9uyLtevLc6xUAAAAMakNYyBKGhuJp+RKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAALe2tre2tre2tre2tre2tre2tre2tre2tgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAMWjMsmkKsOfKb2aKL6pZre2trSunKaHJKOFI6KDIrKqlK6vtVJfWgctHgYsHhI4KAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAALe2tre2tre2tre2tre2tre2tre2tre2tre2tgAAAAAAAAAAAAAAAAAA + AAAAAAAAALe2tre2tre2tre2tre2tre2tre2trCni6CCI6CCIqCCIqWOQ7a0sbe2tq+lhqCCIqCCIqGF + KpudpkReqhQ9fwYsHgYsHgw0KQAAAAAAAAAAAAAAAAAAAAAAALe2tre2trSzs7GwsK6tramoqKSjo6al + pbKxsbe2tre2tre2tre2tre2tre2tre2tre2tre2tre2tre2tre2tre2tre2tre2trSwpaKHMaCCIqCC + IqGFK7Svobe2tre2tqubaKCCIp+BIm1lNzJQpypMqghAqQY5bQlDVhl8jAAAAAAAAAAAAHlofIh+iZGQ + kI2MjImIiIaFhYWEhISDg5GQkKalpbW0tLe2tre2tre2tre2tre2tre2tre2tre2tre2tre2tre2tre2 + tre2tre2tre2tre1tKeRTaGDIqKEIqSFI66gd7e2tre2tre2tsCjRbiYKV5hKDdSaT1m4iZf5AlV5BF2 + 6yLB+AAAAAAAAAAAAHZkemlWbWlWbXJldIKBgYOCgoeGhpqZma6trbe2tre2tre2tre2tre2tre2tre2 + tre2tre2tre2tre2tre2tre2tre2tre2tre2tre2tgAAAMqxYdCpLNStLdmxLty0LgAAAAAAAAAAAAAA + ALKZLk1aKzdMKztckj5q6hJc5xiU8SXN+ybQ+wAAAAAAAAAAAHdle2lWbWlWbWlWbXlqfKGeoLSzs7e2 + tre2tre2tre2tre2tre2tre2tre2tgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2 + L9+2L9+2L9+2LwAAAAAAAAAAAAAAAAAAADlOLTdMKzdMKz1iuTRy6x+y9ibQ+ybQ+wAAAAAAAAAAAAAA + AAAAAIBqhYpykKCEp6+RtruhwQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L9+2L9+2LwAAAAAAAAAAAAAAAD9q6j1hsTdMKzdMKzhNLT5m + 0ynD+SbQ+ybQ+ybQ+wAAAAAAAAAAAAAAAAAAAAAAAM2q1s2q1s2q1s2q1s2q1gAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L9+2L9+2LwAAAAAAAAAA + AAAAAD9q6j9q6jtbjTdMKz1QK4qBLwAAACbQ+ybQ+ybQ+ybQ+wAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q + 1s2q1s2q1s2q1s2q1gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAN+2L9+2L9+2L9+2LwAAAAAAAD9q6j9q6j9q6j9q6jpWaFNeLL2gLt+2LwAAACbQ+ybQ+ybQ+wAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1s2q1s2q1s2q1s2q1gAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L9+2L9+2LwAAAAAAAD9q6j9q6j9q6j9q6j9q5nV3 + SNSvL9+2L9m3NibQ+ybQ+ybQ+ybQ+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1s2q1s2q + 1s2q1s2q1gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L9+2L9+2LwAA + AAAAAD9q6j9q6j9q6j9q6j9q6gAAAN62L9+2L9+2L4XDkibQ+ybQ+ybQ+wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAM2q1s2q1s2q1s2q1s2q1gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAN+2L9+2L9+2L9KwPkBq6T9q6j9q6j9q6j9q6j9q6gAAAAAAAN+2L9+2L962L0LM3CbQ + +ybQ+ybQ+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1s2q1s2q1s2q1s2q + 1gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L9+2L8CmSUpv3T9q6j9q6j9q6j9q6j9q + 6gAAAAAAAAAAAN+2L9+2L8i2PSfQ+SbQ+ybQ+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAM2q1s2q1s2q1s2q1gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L961 + L5uMNUVpxD9q6j9q6j9q6j9q6gAAAAAAAAAAAAAAAN+2L9+2L9+2L4K2aSbQ+ybQ+ybQ+wAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1s2q1s2q1s2q1gAAAAAA + AAAAAAAAAAAAAAAAAN+2L9+2L9KuL3FxLTxdlT9q6j9q6j9q6j9q6gAAAAAAAAAAAAAAAAAAAN+2L9+2 + L9m1Lz61jybQ+ybQ+ybQ+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAM2q1s2q1s2q1s2q1s2q1gAAAAAAAAAAAAAAAN+2L7ufLlBbLDlVYj9q6D9q6j9q6j9q + 6gAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L6WsLyW8tybQ+ybQ+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1s2q1s2q1s2q1s2q1gAAAAAAANu0 + L5KGLTtPKzhPQD5n1j9q6j9q6gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L1ieMCXH3CbQ+ybQ + +wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAM2q1s2q1s2q1s2q1sypzcelL2hrLDhMKzdMLTxhsj9q6j9q6gAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAN+2L8ayLyabQibN8ibQ+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1s2q1s2q1pt9eUBDJjZLKzdMKzpZfz9q6QAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L9+2L32kLiKjYCbQ+ybQ+wAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q + 1quQsC81KCwzJC87JjhSUT9p4gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L9i1LzeY + LiOviSbQ+ybQ+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIl3iywzJCwzJC44LzxhtQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAN+2L6KrLyGULiS6rybQ+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD1BNztANAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L1SdLiGULiXF1ybQ+wAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAMCwLyaVLiGXOCbO9QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L3mkLiGULiKhWibQ+gAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANe1LzGXLiGULiOs + gSbQ+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAJapLyGULiGULiS4qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFKdLiGULiGULyXAxAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ACSVLiGULiGXOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAADidPyGULiGULiOcRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGULiGULi2cQQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////wAA//////// + AAD//////58AAP/////+HwAA//////APAAD/////wA8AAP////4ADwAA////+AAHAAD////gEAcAAP// + /wBwBwAA///8A+AHAAD//+APwAMAAP//gD/AIwAA//wB/4QjAAD/8Af/DCEAAP/AP/4AAQAA/gD+AAAB + AAD4AAAAAAEAAMAAAAAAAwAAgAAAEHgDAACAAP/w+AcAAMH//+HgBwAA4P//w8CHAADwf//DAI8AAPg/ + /4YADwAA/B//DBAfAAD+D/8AMB8AAP8H/gBwPwAA/8P8AeA/AAD/4fgD4D8AAP/weAfgfwAA//gwH+B/ + AAD//AA/4P8AAP/+AP/A/wAA//8B/8D/AAD//4P/wf8AAP//z//B/wAA/////8P/AAD/////g/8AAP// + //+D/wAA/////4f/AAD/////h/8AAP////+P/wAA/////w//AAD/////j/8AAP///////wAA//////// + AAD///////8AACgAAAAwAAAAYAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3trYDnHtFUIpW + C7mPWw2RmmkUBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2Gbe2 + tnO1sqrbhVUY/npCAf96QgH/lGERagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2A7e2 + tje3traft7a28be2tf+nk1b/f0kD/3pCAf96QgH/rnwXqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2 + tgy3trZht7a2yLe2tv63trb/t7a2/6+jgP+cehz/g08E/4BGAf+cXAP/2aso5d+2LwoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2 + tgG3trYpt7a2jbe2tuq3trb/t7a2/7e2tv+3trb/s66f/6OHLP+ofxn/rW8H/6xgA//Dggv/3rQt/t+2 + LzsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAC3trYGt7a2ULe2tri3trb4t7a2/7e2tv+3trb/t7a2/7e2tv+4trLvwaVI/tWuLf/Olxj/w4EJ/757 + CP/JjhL/37Yv/9+2L4UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAt7a2G7e2tnu3trbdt7a2/7e2tv+3trb/t7a2/7e2tv+3trb+t7a2x7e2tWHctjqS37Yv/9+2 + L//JjRH/z5ka/82VF//PmBn/37Yv/9+2L88AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAt7a2Bbe2tj+3tralt7a29be2tv+3trb/t7a2/7e2tv+3trb/t7a277e2tp63trY3t7a2A9+2 + L0Tfti/637Yv/960Lf/KjxP/3rQt/9WkIv/UoiD/37Yv/9+2L/zfti8eAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAALe2thC3trZnt7a2zLe2tv23trb/t7a2/7e2tv+3trb/t7a2/re2ttm3trZzt7a2GAAA + AAAAAAAA37YvF9+2L9/fti//37Yv/9uvKv3arSj/37Yv/92yLP/arCj837Yv/9+2L//fti9mAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAALe2tgG3trYvt7a2k7e2tu+3trb/t7a2/7e2tv+3trb/t7a2/7e2tvi3trawt7a2SLe2 + tgMAAAAAAAAAAAAAAADfti8B37Yvrt+2L//fti//37Yv/t+1L8Lfti//37Yv/9+2L/bftS7I37Yv/9+2 + L//fti+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC3trYLt7a2VLe2tsC3trb6t7a2/7e2tv+3trb/t7a2/7e2tv+3trbit7a2hbe2 + tiO3trYBAAAAAAAAAAAAAAAAAAAAAAAAAADfti9p37Yv/t+2L//fti//37Yvq9+2L5Hfti//37Yv/9+2 + L87fti9237Yv/9+2L//fti/t37YvDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAt7a2HLe2toK3trbgt7a2/7e2tv+3trb/t7a2/7e2tv+3trb9t7a2xLe2 + tlm3trYMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2Lyzfti/x37Yv/9+2L//fti/h37YvFd+2 + L8Dfti//37Yv/9+2L57fti8w37Yv/N+2L//fti//37YvRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAt7a2BLe2tkW3tratt7a2+re2tv+3trb/t7a2/7e2tv+3trb/t7a27re2 + tpa3trYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvDN+2L87fti//37Yv/9+2 + L/nfti9E37YvCt+2L+fbsi7/168t/86xUI64trFNxqQ18IyBKP9obib/n5ErkQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2thW3trZvt7a21Le2tv23trb/t7a2/7e2tv+3trb/t7a2/be2 + ttG3trZst7a2EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3trYFt7a2Dre2thW3trYoxaMymsmk + Kv/Dnyn/vZoo/76pZuu3tra7tK6c1KaHJP2jhSP/ooMi/7KqlP+ur7X/Ul9a/wctHv8GLB7/Ejgo4muZ + ogYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3trYyt7a2mre2tu+3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tvm3traqt7a2Q7e2tgO3trYIt7a2ILe2tji3trZPt7a2aLe2toC3traXt7a2sLe2tsm3trbat7a27Le2 + tvqwp4v/oIIj/6CCIv+ggiL/pY5D/7a0sf+3trb/r6WG/6CCIv+ggiL/oYUq/5udpv9EXqr/FD1//wYs + Hv8GLB7/DDQp7WSTmw0AAAAAAAAAAAAAAAC3trYNt7a2XLe2tsa3trb+tLOz/7GwsP+ura3/qaio/6Sj + o/+mpaX/srGx9Le2tsC3tra/t7a21be2tu+3trb+t7a2/re2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tv+3trb/t7a2/7Swpf+ihzH/oIIi/6CCIv+hhSv/tK+h/7e2tv+3trb/q5to/6CCIv+fgSL/bWU3/zJQ + p/8qTKr/CECp/wY5bf8JQ1b/GXyMigAAAAAAAAAAkoKVGXlofJOIfonkkZCQ/42MjP+JiIj/hoWF/4WE + hP+Eg4P/kZCQ/6alpf+1tLT/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tv+3trb/t7a2/7e2tv+3trb/t7W0/6eRTf+hgyL/ooQi/6SFI/6uoHfgt7a2xLe2tq63traWwKNF4riY + Kf9eYSj/N1Jp/z1m4v8mX+T/CVXk/xF26/8iwfj5JtD7JgAAAAAAAAAAdmR6sWlWbf9pVm3/cmV0/4KB + gf+DgoL/h4aG/5qZmf+ura3/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tv+3trb5t7a25be2ts23tra3t7a2n7e2toe3trZvyrFhudCpLP/UrS3/2bEu/9y0LqTfti8CAAAAAAAA + AAAAAAAAspku501aK/83TCv/O1yS/z5q6v8SXOf/GJTx/yXN+/8m0Pu4JtD7AgAAAAAAAAAAd2V7xmlW + bf9pVm3/aVZt/3lqfP+hnqD/tLOz/7e2tv+3trb+t7a287e2tua3trbYt7a2wLe2tqm3traQt7a2eLe2 + tmG3trZIt7a2Mbe2thi3trYGt7a2A7e2tgEAAAAAAAAAAAAAAADfti8z37Yv99+2L//fti//37Yv2d+2 + LxEAAAAAAAAAAD9q6gdBZbx+OU4t/jdMK/83TCv/PWK5/zRy6/ofsvb/JtD7/ybQ+/8m0PtPAAAAAAAA + AAAAAAAAhHGHNYBqheGKcpD/oISn/6+Rtv+7ocH1u7S8Zre2tjq3trYjt7a2Fbe2tgu3trYCAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2Lw/fti/T37Yv/9+2 + L//fti/537YvOgAAAAAAAAAAP2rqHj9q6rg9YbH/N0wr/zdMK/84TS3/PmbTrinD+b4m0Pv/JtD7/ybQ + ++Mm0PsGAAAAAAAAAAAAAAAAAAAAAM2q1iHNqtbWzarW/82q1v/Nqtb/zarW0M2q1hsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2 + L5rfti//37Yv/9+2L//fti98AAAAAAAAAAA/aupKP2rq5j9q6v87W43/N0wr/z1QK/+KgS/dOMXhIibQ + +/Mm0Pv/JtD7/ybQ+4IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNqtYZzarWyM2q1v/Nqtb/zarW/82q + 1tzNqtYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA37YvV9+2L/zfti//37Yv/9+2L7vfti8GP2rqCT9q6os/aur7P2rq/z9q6v86Vmj/U14s/72g + Lv/fti+vJtD7dybQ+/8m0Pv/JtD79ibQ+yMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWEc2q + 1r7Nqtb/zarW/82q1v/NqtbjzarWMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADfti8g37Yv69+2L//fti//37Yv6d+2LyE/auojP2rqxj9q6v8/aur/P2rq/z9q + 5v51d0j+1K8v/9+2L//ZtzaCJtD72ybQ+/8m0Pv/JtD7swAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAM2q1gnNqtauzarW/82q1v/Nqtb/zarW7M2q1j0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2Lwbfti+937Yv/9+2L//fti/+3rUxVD9q6lk/aurtP2rq/z9q + 6v8/aur/P2rq71t3yHbeti/737Yv/9+2L/+Fw5KWJtD7/ibQ+/8m0Pv/JtD7TAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNqtYHzarWnM2q1v/Nqtb/zarW/82q1vHNqtZOAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L37fti//37Yv/9+2L//SsD6lQGrpmz9q + 6vw/aur/P2rq/z9q6v8/aurLP2rqKd+2L0Pfti//37Yv/962L/pCzNzLJtD7/ybQ+/8m0PvaJtD7BwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWBM2q1o7Nqtb+zarW/82q + 1v/Nqtb0zarWWwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvO9+2L/ffti//37Yv/8Cm + SfVKb93eP2rq/z9q6v8/aur/P2rq/T9q6pI/auoMAAAAAN+2L3Pfti//37Yv/8i2Pfgn0Pn5JtD7/ybQ + +/8m0Pt9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q + 1gHNqtZ9zarW/M2q1v/Nqtb/zarW+82q1mvNqtYBAAAAAAAAAAAAAAAAAAAAAAAAAADfti8S37Yv29+2 + L//etS//m4w1/0VpxP8/aur/P2rq/z9q6v8/aurrP2rqUQAAAAAAAAAAAAAAAN+2L6Xfti//37Yv/4K2 + af8m0Pv/JtD7/ybQ+/cm0PsdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADNqtYBzarWas2q1vvNqtb/zarW/82q1vzNqtZ8zarWAwAAAAAAAAAAAAAAAN+2 + LwLfti+j37Yv/9KuL/9xcS3/PF2V/z9q6v8/aur/P2rq/z9q6r8/auoiAAAAAAAAAAAAAAAA37YvAd+2 + L9Xfti//2bUv/z61j/8m0Pv/JtD7/ybQ+6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1lzNqtb4zarW/82q1v/Nqtb+zarWjs2q + 1gIAAAAAAAAAAN+2L1/fti/9u58u/1BbLP85VWL/P2ro/z9q6v8/aur8P2rqgz9q6ggAAAAAAAAAAAAA + AAAAAAAA37YvFd+2L/Hfti//pawv/yW8t/8m0Pv/JtD7/ibQ+0cAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNqtZKzarW8M2q + 1v/Nqtb/zarW/82q1p/NqtYI37YvJtu0L/GShi3/O08r/zhPQP8+Z9b/P2rq/z9q6uI/aupEAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA37YvOd+2L//fti//WJ4w/yXH3P8m0Pv/JtD71ibQ+wcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAzarWPs2q1urNqtb/zarW/82q1v/Mqc2wx6UvxmhrLP84TCv/N0wt/zxhsv8/aur+P2rqtD9q + 6hoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yva9+2L//Gsi//JptC/ybN8v8m0Pv/JtD7dQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1jPNqtbkzarW/82q1v+bfXn/QEMm/zZLK/83TCv/Oll//z9q + 6fg/aup1P2rqBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yvm9+2L/99pC7/IqNg/ybQ + +/8m0Pv1JtD7GQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNqtYmzarW2KuQsP8vNSj/LDMk/y87 + Jv84UlH/P2ni2j9q6jgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yvzti1 + L/83mC7/I6+J/ybQ+/8m0PumAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWHIl3 + i9EsMyT/LDMk/y44L/08YbWnP2rqEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADfti8H37Yv9qKrL/8hlC7/JLqv/ybQ+/0m0PtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAHdtdhs9QTfBO0A07kJKUnI/auoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADfti8x37Yv/lSdLv8hlC7/JcXX/ybQ+9Um0PsDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEfIQCe3V6BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfti9iwLAv/yaVLv8hlzj/Js71/ybQ+3AAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfti+TeaQu/yGULv8ioVr/JtD68CbQ + +xgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2LwHXtS/DMZcu/yGU + Lv8jrIH/JtD7oQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2 + LwyWqS/qIZQu/yGULv8kuKj/JtD7OgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAANW0LydSnS7/IZQu/yGUL/8lwMTOJtD7AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIClL1kklS7/IZQu/yGXOP8lx9xqAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADidP5QhlC7/IZQu/yOcR/Am0PsUAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADefRX8hlC7/IZQu/y2c + QaEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFKr + YQgxnD9zLZo6fFeuZhQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////8AAP///////wAA//////4PAAD/////+A8AAP// + ///ADwAA/////wAHAAD////4AAcAAP///+AABwAA////gAAHAAD///wAAAMAAP//8ADAAwAA//+AA4AD + AAD//gAPgAEAAP/4AH8AAQAA/8AD/gABAAD/AA/gAAAAAPwAAAAAAAAA4AAAAAABAACAAAAAAAEAAIAA + AAA4AQAAgAAA4GADAACAB//AwAMAAMB//8GABwAA4D//gAAHAADwH/8AAA8AAPgP/gAADwAA/Af+AAAP + AAD+A/wAIB8AAP8A+ADgHwAA/4BwAcA/AAD/4DADwD8AAP/wAA/APwAA//gAH8B/AAD//AA/wH8AAP/+ + AP/A/wAA//8B/4D/AAD//4P/gP8AAP//z/+B/wAA/////4H/AAD/////A/8AAP////8D/wAA/////wP/ + AAD/////B/8AAP////8H/wAA/////w//AAD/////D/8AAP///////wAA////////AAAoAAAAQAAAAIAA + AAABABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjV0YiVQKi1YLAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2n4Ve + ekIBekIBekIBh1IIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2 + t7a2t7a2squWjWEUekIBekIBekIBiVQJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAt7a2t7a2t7a2t7a2trOupIs9i14LekIBekIBekIBpG8PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7W1qZddn4EhjF0HfEUBhUgBnloDz5kb37YvAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2r6SCoIMkoX8eomwIqGMErF8Cv3wI1qUj + 37YvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2tK+grpAzw58pzp0gw4IJ + unQGuXMGw4IJ268q37YvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2uLaz0LBH + 3bQv37Yv0Joaw4IJyY0SxIMKxocN3rQu37Yv37YvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2 + t7a2AAAAAAAA37Yv37Yv37UvypATx4kO3LAryY4Ry5AT37Yv37Yv37YvAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2 + t7a2t7a2AAAAAAAAAAAAAAAA37Yv37Yv37Yv3rQtxogO2Kgl37Yv0Zwc0Joa37Yv37Yv37YvAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2 + t7a2t7a2t7a2t7a2AAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv27Aq0Jsb37Yv37Yv2asn1aMh37Yv + 37Yv37YvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2 + t7a2t7a2t7a2t7a2t7a2AAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv37Yv264p3rQu37Yv + 37Yv3rUu268q37Yv37Yv37Yv37YvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2 + t7a2t7a2t7a2t7a2t7a2t7a2t7a2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv + 37Yv37Yv37Yv37Yv37Yv37Yv37Yv37Yv37Yv37Yv37YvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2 + t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv + 37Yv37Yv37Yv37YvAAAA37Yv37Yv37Yv37Yv37YvAAAA37Yv37Yv37Yv37YvAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2 + t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA37Yv37Yv37Yv37Yv37Yv37YvAAAA37Yv37Yv37Yv37Yv37YvAAAA37Yv37Yv37Yv37Yv37Yv + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv37Yv37YvAAAAAAAA37Yv37Yv37Yv37YvAAAAAAAA37Yv + 37Yv37Yv37Yv37YvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv37YvAAAAAAAAAAAA3rUv2rIu1q8t + 0qwuAAAAAAAAv6hesJMnYWclOlIjdXcnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA168t1a4t0KosyqUqxKAqw61ot7a2t7a2 + r51kp4gjpYYjo4Ujo4gvtbGpt7a2l5iXLEAjBiweBiweBy0eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2AAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2t7WzqZNLpIUjoIIioIIioIIi + ppBKtrSwt7a2t7a2qJNToIIioIIioIIipIw+tbS1gIywMlCkCjAzBiweBiweBiweHkc/AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2AAAAAAAA + AAAAAAAAAAAAAAAAt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2rqF6oIIi + oIIioIIioIIioocvtK+it7a2t7a2t7W0o4k2oIIioIIioIIino5aXXGsLUynHkamBjRgBiweBiweBi0g + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2t7a2t7a2tLOzsrGxrq2tq6qqp6amoqGhnJubnp2dq6qq + tLOzt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2 + t7a2sqyYoYUroIIioIIioIIioIIjr6WFt7a2t7a2t7a2tLCkoYUqoIIioIIigm8hPE5uLUynLk6rD0Os + BkGrBzt4CEBgF4SdAAAAAAAAAAAAAAAAAAAAg3SGkImRmZeYlZSUkI+Pi4qKiYiIh4aGhYSEg4KChIOD + j46OpKOjs7Kyt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2 + t7a2t7a2t7a2t7a2trOtpY1CoIIioIIioIIioIIiqZZct7a1t7a2t7a2t7a2t6uHuZcouZgoeXEoN0gn + OV2zPGbgMWPiClXiCVXkDmzqILf3Js/7AAAAAAAAAAAAAAAAcmB2aVZtaVZtcmV0goCBg4KCg4KCg4KC + g4KChoWFmJeXrKurtrW1t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2 + t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2uKNitpUnvJkowp4pyKMqyqUsAAAAAAAAAAAAAAAAAAAAAAAA + zasvamwsOEwrN042PmfYP2rqH17oCVjmFIXuJMf6JtD7AAAAAAAAAAAAAAAAAAAAaVZtaVZtaVZtaVZt + cGJzgX+Bg4KCjIuLoJ+fs7Kyt7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2 + t7a2t7a2t7a2t7a2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv37YvAAAAAAAAAAAA + AAAAAAAAAAAAlIczSlgrN0wrN0wrOFFOP2nkO2nqD2DoHKT0Js/7JtD7JtD7AAAAAAAAAAAAAAAAAAAA + a1hvaVZtaVZtaVZta1hvfWyApqKltbS0t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2t7a2AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv37Yv + AAAAAAAAAAAAAAAAAAAAAAAAP2rqOVFIN0wrN0wrN0wrOlduP2rqLnrsIbz4JtD7JtD7JtD7AAAAAAAA + AAAAAAAAAAAAAAAAfmqBcV12dF95hm+Mmn+hpomts5q5u7K9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv + 37Yv37Yv37Yv37YvAAAAAAAAAAAAAAAAAAAAP2rqP2nhN0wuN0wrN0wrN0wrO1yQPm/rJ8n6JtD7JtD7 + JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAwqHLyafSzarWzarWzarWzarWzarWAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA37Yv37Yv37Yv37Yv37YvAAAAAAAAAAAAAAAAAAAAP2rqP2rqPWTBN0wrN0wrN0wrRFQrAAAA + AAAAJtD7JtD7JtD7JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarWzarW + zarWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv37YvAAAAAAAAAAAAAAAAP2rqP2rqP2rqP2rqPF2ZN0wr + N0wrZGgsy6ovAAAAJtD7JtD7JtD7JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + zarWzarWzarWzarWzarWzarWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv37Yv37YvAAAAAAAAAAAAP2rqP2rqP2rq + P2rqP2rqOlh3PVArjIIt2bIv37YvAAAAJtD7JtD7JtD7JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarWzarWzarWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv37Yv37YvAAAAAAAAAAAA + P2rqP2rqP2rqP2rqP2rqP2nmTV9Wspou3rUv37Yv37YvAAAAJtD7JtD7JtD7JtD7AAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarWzarWzarWAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yv37Yv + AAAAAAAAP2rqP2rqP2rqP2rqP2rqP2rqP2rqS2/Zzaw237Yv37Yv37Yv3LYyJtD7JtD7JtD7JtD7JtD7 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarWzarW + zarWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv + 37Yv37Yv37YvAAAAAAAAP2rqP2rqP2rqP2rqP2rqP2rqP2rqAAAAAAAA37Yv37Yv37Yv37Yvi8KLJtD7 + JtD7JtD7JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + zarWzarWzarWzarWzarWzarWzarWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA37Yv37Yv37Yv37Yv37Yv2bM2AAAAP2rqP2rqP2rqP2rqP2rqP2rqP2rqAAAAAAAAAAAA37Yv37Yv + 37Yv3rYwRsvWJtD7JtD7JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarWzarWzarWzarWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yvza0/VHTRP2rqP2rqP2rqP2rqP2rqP2rqP2rqAAAAAAAA + AAAA37Yv37Yv37Yv37Yvy7Y9KM/4JtD7JtD7JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarWzarWzarWzarWAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37Yvs5szUm+2P2rqP2rqP2rqP2rqP2rqP2rq + AAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv37YvibZlJtD7JtD7JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarWzarW + zarWzarWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv2bIvjIEtP12JP2rpP2rqP2rq + P2rqP2rqP2rqAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv17UvRbaPJtD7JtD7JtD7JtD7AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + zarWzarWzarWzarWzarWzarWzarWAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37YvyKcuZWksOVNX + P2nkP2rqP2rqP2rqP2rqP2rqAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37YvrK0vJry2JtD7JtD7 + JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarWzarWzarWzarWAAAAAAAAAAAAAAAAAAAAAAAA37Yv3rUv + rJYuSVcrOE45PmXLP2rqP2rqP2rqP2rqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv37Yv + YKE0JcbYJtD7JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarWzarWzarWzarWAAAAAAAAAAAA + AAAA37Yv2LIvg3wtOE0rN0wuPF+iP2rqP2rqP2rqP2rqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + 37Yv37Yv37YvxrIvK51FJszuJtD7JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarW + zarWzarWAAAAAAAA37YvwaMuXmQsN0wrN0wrOlh0P2roP2rqP2rqP2rqAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAA37Yv37Yv37Yvg6YvIqNgJtD7JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAzarWzarWzarWzarWzarWzarV0ahRoY8tRlUrN0wrN0wrOFFJPmfaP2rqP2rqAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37Yv3bYvO5kuI66HJtD7JtD7JtD7AAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAzarWzarWzarWzarWv5mlZlQrNkYpN0wrN0wrN00uPWO/P2rqP2rqAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv37YvqawvIZQuJLquJtD7JtD7AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWzarWvJ3ESEU7LDMkLDQkNEUpN0wsO1yP + P2rqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv3bYvXJ4uIZQu + JcXXJtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWhXOGLDMkLDMk + LDMkLjkmOVRfP2niAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv + 37YvxbEvKJUuIZlAJsztJtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAe2x8LDMkLDMkLDMkLzs3PWO/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA37Yv37YvgaUvIZQuIqFcJs/3JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAOz80LDMkMzgrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yv1LQvPZkuIZQuI6x/JtD7JtD7AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvoqsvIpQuIZQuJLioJtD7AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3rYvV54uIZQuIZQuJcPP + JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwrEv + KZUuIZQuIZUxJs70JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA37Yve6QuIZQuIZQuIp9SJtD6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA17UvM5cuIZQuIZQuI6p6JtD7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnaovIZQuIZQuIZQuJLWgAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAV54uIZQuIZQuIZUwJcDDAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ5UuIZQu + IZQuIZc5JcXXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAARZ46IZQuIZQuIZQuIpxIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAM5xAIZQuIZQuIZQuJ6BTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOaBHIZQuIZQuIpQvAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOJ9GI5UwAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA/////////////////////////////////////////H/////////wP/// + /////4A////////+AD////////gAH///////wAAf//////8AAB//////+AAAD//////gAYAP/////4AP + AA/////8AD4AD/////AB/AAH////gAf8AAf///4AP/ggh///+AD/8CCD///AA//gYYP//wAf/+Dhg//4 + AH//wAAD/+AD//gAAAH/AA/AAAAAA/wAAAAAAAAD4AAAAAAAAAPAAAAAAA/AB8AAAAP8H4AHwAAP//g/ + AA/AP///8D4AD+A////wfAYP+B///+DwBB/8D///wOAEH/4H//+BwAQ//wP//4MAAD//gf//BgMAP//A + f/4EBwB//+A//gAOAH//8B/8AD4A///4D/gAfgD///wH8AD+Af///gPwA/4B////AeAH/AH////AwA/8 + A////+AAP/wD////8AB//Af////4Af/8B/////wD//gH/////gf/+A//////H//4D/////////gf//// + ////+B/////////4H/////////A/////////8D/////////wf/////////B/////////8H/////////g + /////////+D/////////4f/////////z//////////////////////////////////8oAAAAQAAAAIAA + AAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKpUACs4ckEMObMAgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyqpcwjV0YpYlU + CvSLVgvSmWcTMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2Dre2 + tli3trbBn4Ve/HpCAf96QgH/ekIB/4dSCM3FnzkGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2 + tgK3trYlt7a2g7e2tt63trb9squW/41hFP96QgH/ekIB/3pCAf+JVAn4yZ0oIwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAt7a2Bre2tkW3trast7a28re2tv+3trb/trOu/6SLPf+LXgv/ekIB/3pCAf96QgH/pG8P/9+2 + L1QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC3trYVt7a2b7e2ttW3trb+t7a2/7e2tv+3trb/t7W1/6mXXf+fgSH/jF0H/3xF + Af+FSAH/nloD/8+ZG//fti+iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAt7a2BLe2tjm3trabt7a277e2tv+3trb/t7a2/7e2tv+3trb/t7a2/6+k + gv+ggyT/oX8e/6JsCP+oYwT/rF8C/798CP/WpSP/37Yv4N+2LwoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3trYSt7a2Xre2tsO3trb4t7a2/7e2tv+3trb/t7a2/7e2 + tv+3trb/t7a2/7SvoP+ukDP/w58p/86dIP/Dggn/unQG/7lzBv/Dggn/268q/9+2L/vfti88AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2Are2tiS3traJt7a24re2tv+3trb/t7a2/7e2 + tv+3trb/t7a2/7e2tv+3trb/t7a2+Li2s7TQsEfr3bQv/9+2L//Qmhr/w4IJ/8mNEv/Egwr/xocN/960 + Lv/fti//37YvgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3trYHt7a2T7e2trO3trb6t7a2/7e2 + tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trbgt7a2g7m2sSLfti9937Yv/9+2L//ftS//ypAT/8eJ + Dv/csCv/yY4R/8uQE//fti//37Yv/9+2L8wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tiG3trZ2t7a22be2 + tv23trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a297e2try3trZat7a2DAAAAADfti8/37Yv9t+2 + L//fti//3rQt/8aIDv/YqCX/37Yv/9GcHP/Qmhr/37Yv/9+2L//fti/637YvHAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3trYHt7a2Obe2 + tqS3trbtt7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv63trbqt7a2lre2tjO3trYEAAAAAAAA + AADfti8W37Yv1d+2L//fti//37Yv/9uwKv/Qmxv/37Yv/9+2L//Zqyf/1aMh/9+2L//fti//37Yv/9+2 + L2MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2 + tgy3trZlt7a2xre2tv23trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2ttK3trZqt7a2FgAA + AAAAAAAAAAAAAAAAAADfti8C37Yvo9+2L//fti//37Yv/9+2L//brin23rQu/9+2L//fti//3rUu/duv + KvDfti//37Yv/9+2L//fti+p37YvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAC3trYBt7a2L7e2to+3trbut7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trbyt7a2pre2 + tkC3trYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvYt+2L/zfti//37Yv/9+2L//fti/p37YvrN+2 + L//fti//37Yv/9+2L/Dfti+m37Yv/9+2L//fti//37Yv6d+2Lw8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAALe2tg63trZSt7a2u7e2tva3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/re2 + ttq3trZ8t7a2ILe2tgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvKN+2L+/fti//37Yv/9+2 + L//fti/837YvYN+2L7Xfti//37Yv/9+2L//fti/G37YvV9+2L/7fti//37Yv/9+2L//fti9DAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC3trYCt7a2H7e2tn63trbZt7a2/re2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tv+3trb3t7a2ure2tlO3trYNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvDN+2 + L8Lfti//37Yv/9+2L//fti//37Yvod+2LxHfti/b37Yv/9+2L//fti//37YvlN+2Lxbfti/037Yv/9+2 + L//fti//37YvjQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tgK3trZBt7a2pre2tvS3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tv+3trb/t7a2/7e2tuy3traPt7a2Lre2tgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAN+2L4Xfti//37Yv/9+2L//fti//37Yv3d+2LxDfti8i37Yv9d+2L//fti//37Yv/9+2 + L2QAAAAA37Yvv9+2L//fti//37Yv/9+2L9Dfti8HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2Fre2tmy3trbUt7a2/re2tv+3trb/t7a2/7e2 + tv+3trb/t7a2/7e2tv+3trb9t7a2xbe2tmO3trYNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L0rfti/337Yv/9+2L//fti//37Yv9N+2Lz4AAAAA37YvS961 + L//asi7/1q8t/9KsLv3Esndyt7a2X7+oXrqwkyf/YWcl/zpSI/91dyf4sp0sKwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe2tgS3trY0t7a2lre2tum3trb/t7a2/7e2 + tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tu23traht7a2O7e2tgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2CMasViTXry3f1a4t/9CqLP/KpSr/xKAq/8Ot + aNu3traft7a2tq+dZN+niCP/pYYj/6OFI/+jiC//tbGp/7e2tv+XmJf/LEAj/wYsHv8GLB7/By0e/yhO + On8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2Dbe2tli3tra/t7a2+Le2 + tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb8t7a22re2tnW3trYeAAAAAAAAAAAAAAAAAAAAALe2 + tgK3trYFt7a2Cbe2tg23trYbt7a2Nbe2tky3trZlt7a2fLe2tpS3tratt7a2xLe1s9Spk0vspIUj/6CC + Iv+ggiL/oIIi/6aQSv+2tLD/t7a2/7e2tv+ok1P/oIIi/6CCIv+ggiL/pIw+/7W0tf+AjLD/MlCk/wow + M/8GLB7/Biwe/wYsHv8eRz+4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3trYjt7a2hLe2 + tuG3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tvu3trawt7a2Ure2tiC3trYvt7a2Rbe2 + tlq3trZ0t7a2i7e2tqK3tra6t7a2zbe2tuO3trb2t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tv+uoXr/oIIi/6CCIv+ggiL/oIIi/6KHL/+0r6L/t7a2/7e2tv+3tbT/o4k2/6CCIv+ggiL/oIIi/56O + Wv9dcaz/LUyn/x5Gpv8GNGD/Biwe/wYsHv8GLSD/G0xIcgAAAAAAAAAAAAAAAAAAAAAAAAAAt7a2Cbe2 + tkm3travt7a297e2tv+0s7P/srGx/66trf+rqqr/p6am/6Khof+cm5v/np2d/6uqqv60s7Pht7a25Le2 + tvW3trb4t7a2+7e2tv23trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tv+3trb/t7a2/7e2tv+yrJj/oYUr/6CCIv+ggiL/oIIi/6CCI/+vpYX/t7a2/7e2tv+3trb/tLCk/6GF + Kv+ggiL/oIIi/4JvIf88Tm7/LUyn/y5Oq/8PQ6z/BkGr/wc7eP8IQGD/F4Sd4ym42xYAAAAAAAAAAAAA + AACTg5Ygg3SGgJCJkdOZl5j7lZSU/5CPj/+Lior/iYiI/4eGhv+FhIT/g4KC/4SDg/+Pjo7/pKOj/7Oy + sv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+2s63/pY1C/6CCIv+ggiL/oIIi/6CCIv+pllz6t7a18be2 + tui3trbgt7a2zberh825lyj/uZgo/3lxKP83SCf/OV2z/zxm4P8xY+L/ClXi/wlV5P8ObOr/ILf3/ybP + +5EAAAAAAAAAAAAAAACLeo4acmB23mlWbf9pVm3/cmV0/4KAgf+DgoL/g4KC/4OCgv+DgoL/hoWF/5iX + l/+sq6v/trW1/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tv+3trb/t7a2/7e2tv+3trb/t7a2/re2tvy3trb6t7a2+Le2tuy3trbWuKNi9baVJ/+8mSj/wp4p/8ij + Kv/KpSzUtaqGN7e2tiO3trYTt7a2BAAAAADfti90zasv/2psLP84TCv/N042/z5n2P8/aur/H17o/wlY + 5v8Uhe7/JMf6/ybQ+/wm0PsvAAAAAAAAAAAAAAAAjHqPcWlWbf9pVm3/aVZt/2lWbf9wYnP/gX+B/4OC + gv+Mi4v/oJ+f/7Oysv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2tv+3trb/t7a2/7e2 + tv+3trb9t7a27Le2tta3trbDt7a2rre2tpa3trZ+t7a2Zre2tk+3trY4t7a2I7e2tg4AAAAA37YvTt+2 + L/zfti//37Yv/9+2L//fti/y37YvNwAAAAAAAAAAAAAAAAAAAAAAAAAAlIczp0pYK/83TCv/N0wr/zhR + Tv8/aeT/O2nq/w9g6P8cpPT/Js/7/ybQ+/8m0Pu9JtD7BAAAAAAAAAAAAAAAAI59kVVrWG/+aVZt/2lW + bf9pVm3/a1hv/31sgP+moqX/tbS0/7e2tv+3trb/t7a2/7e2tve3trbot7a227e2ts63tra3t7a2obe2 + toe3trZvt7a2Wbe2tkG3trYmt7a2Ebe2tgy3trYHt7a2AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA37YvH9+2L+Pfti//37Yv/9+2L//fti/+37YvcN+2LwEAAAAAAAAAAAAAAAA/auoMP2rqgzlR + SPs3TCv/N0wr/zdMK/86V27/P2rq/y567PchvPj/JtD7/ybQ+/8m0Pv+JtD7WQAAAAAAAAAAAAAAAAAA + AACjk6UJfmqBoHFddvx0X3n/hm+M/5p/of+mia3/s5q5/ruyvZu3trZht7a2Sre2tjG3trYit7a2F7e2 + tg23trYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA37YvCN+2L7Lfti//37Yv/9+2L//fti//37Yvst+2LwcAAAAAAAAAAAAA + AAA/auonP2rqvD9p4f43TC7/N0wr/zdMK/83TCv/O1yQ+D5v65YnyfrTJtD7/ybQ+/8m0Pv/JtD76CbQ + +wsAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1gPCocuAyafS/c2q1v/Nqtb/zarW/82q1v/NqtbXzarWKwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L3Lfti/937Yv/9+2L//fti//37Yv5t+2 + LxwAAAAAAAAAAD9q6gE/aupSP2rq5z9q6v89ZMH/N0wr/zdMK/83TCv/RFQr/2Nxbmonzfs8JtD7+ybQ + +/8m0Pv/JtD7/ybQ+40AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1m7Nqtb4zarW/82q + 1v/Nqtb/zarW/82q1ubNqtY2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2Lznfti/z37Yv/9+2 + L//fti//37Yv+N+2L00AAAAAAAAAAD9q6g4/auqSP2rq/z9q6v8/aur/PF2Z/zdMK/83TCv/ZGgs/8uq + L/7fti8SJtD7oCbQ+/8m0Pv/JtD7/ybQ+/Qm0PstAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADNqtYCzarWXc2q1vTNqtb/zarW/82q1v/Nqtb/zarW682q1kMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2 + Lw3fti/W37Yv/9+2L//fti//37Yv/9+2L43fti8CAAAAAD9q6i8/aurKP2rq/j9q6v8/aur/P2rq/zpY + d/89UCv/jIIt/9myL//fti/cQMzeHibQ++sm0Pv/JtD7/ybQ+/8m0Pu6JtD7AQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1gHNqtZNzarW8s2q1v/Nqtb/zarW/82q1v/NqtbwzarWUM2q + 1gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAN+2LwTfti+Y37Yv/9+2L//fti//37Yv/9+2L8nfti8PP2rqBD9q6mI/aursP2rq/z9q + 6v8/aur/P2rq/z9p5v9NX1b/spou/961L//fti//37YvrifQ+m8m0Pv/JtD7/ybQ+/8m0Pv+JtD7VgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1kDNqtbtzarW/82q + 1v/Nqtb/zarW/82q1vfNqtZeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfti9V37Yv+9+2L//fti//37Yv/9+2L/Lfti8sP2rqET9q + 6p4/aur+P2rq/z9q6v8/aur/P2rq/z9q6v9Lb9m+zaw299+2L//fti//37Yv/9y2MoEm0PvUJtD7/ybQ + +/8m0Pv/JtD73ybQ+xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAzarWNM2q1t7Nqtb/zarW/82q1v/Nqtb/zarW/M2q1nHNqtYCAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfti8m37Yv6N+2L//fti//37Yv/9+2 + L/3fti9oQGrpOj9q6tU/aur/P2rq/z9q6v8/aur/P2rq/z9q6vI/aupv0rA+Mt+2L//fti//37Yv/9+2 + L/6LwouOJtD7/SbQ+/8m0Pv/JtD7/ybQ+4UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNqtYtzarW1c2q1v/Nqtb/zarW/82q1v/Nqtb6zarWg82q + 1gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfti8J37Yvvd+2 + L//fti//37Yv/9+2L//ZszawRGzkdD9q6vM/aur/P2rq/z9q6v8/aur/P2rq/z9q6tQ/auo5P2rqAd+2 + L2Lfti//37Yv/9+2L//etjD3RsvWxCbQ+/8m0Pv/JtD7/ybQ+/km0PsjAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1iDNqtbQzarW/82q + 1v/Nqtb/zarW/82q1vzNqtaRzarWBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA37Yve9+2L/3fti//37Yv/9+2L//NrT/wVHTRxT9q6v4/aur/P2rq/z9q6v8/aur/P2rq/D9q + 6qI/auoVAAAAAAAAAADfti+R37Yv/9+2L//fti//y7Y99yjP+PQm0Pv/JtD7/ybQ+/8m0Pu1JtD7AwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAzarWFs2q1sXNqtb/zarW/82q1v/Nqtb/zarW/s2q1qPNqtYHAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA37YvOt+2L/rfti//37Yv/9+2L/+zmzP/Um+2/T9q6v8/aur/P2rq/z9q + 6v8/aur/P2rq8j9q6mM/auoDAAAAAAAAAAAAAAAA37Yvwd+2L//fti//37Yv/4m2Zfsm0Pv/JtD7/ybQ + +/8m0Pv9JtD7UwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNqtYQzarWss2q1v/Nqtb/zarW/82q1v/Nqtb/zarWrs2q + 1hIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvFt+2L9jfti//37Yv/9myL/+MgS3/P12J/z9q + 6f8/aur/P2rq/z9q6v8/aur/P2rqyz9q6ioAAAAAAAAAAAAAAAAAAAAA37YvE9+2L+Tfti//37Yv/9e1 + L/9Fto//JtD7/ybQ+/8m0Pv/JtD73ibQ+wcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1g3NqtakzarW/s2q + 1v/Nqtb/zarW/82q1v/Nqta6zarWGAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvBN+2L6Hfti//37Yv/8in + Lv9laSz/OVNX/z9p5P8/aur/P2rq/z9q6v8/aur5P2rqkz9q6hEAAAAAAAAAAAAAAAAAAAAAAAAAAN+2 + Lyzfti/537Yv/9+2L/+srS//Jry2/ybQ+/8m0Pv/JtD7/ybQ+38AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAzarWCM2q1pjNqtb9zarW/82q1v/Nqtb/zarW/82q1srNqtYYAAAAAAAAAAAAAAAAAAAAAN+2 + L2Hfti/73rUv/6yWLv9JVyv/OE45/z5ly/8/aur/P2rq/z9q6v8/aurrP2rqVj9q6gMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADfti9X37Yv/9+2L//fti//YKE0/yXG2P8m0Pv/JtD7/ybQ+/Im0PsnAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNqtYEzarWhc2q1vzNqtb/zarW/82q1v/Nqtb/zarW2s2q + 1iIAAAAAAAAAAN+2Lyrfti/v2LIv/4N8Lf84TSv/N0wu/zxfov8/aur/P2rq/z9q6v8/aurBP2rqIwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37Yvid+2L//fti//xrIv/yudRf8mzO7/JtD7/ybQ + +/8m0PuxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2q1gPNqtZ0zarW+c2q + 1v/Nqtb/zarW/82q1v/NqtbhzarWMt+2Lwrfti/FwaMu/15kLP83TCv/N0wr/zpYdP8/auj/P2rq/z9q + 6vc/auqFP2rqCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L7nfti//37Yv/4Om + L/8io2D/JtD7/ybQ+/8m0Pv9JtD7SgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAzarWAs2q1mXNqtb3zarW/82q1v/Nqtb/zarW/82q1eTRqFGroY8t/0ZVK/83TCv/N0wr/zhR + Sf8+Z9r/P2rq/z9q6uE/aupKP2rqAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2 + Lwbfti/n37Yv/922L/87mS7/I66H/ybQ+/8m0Pv/JtD71SbQ+wwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWW82q1vPNqtb/zarW/82q1v+/maX/ZlQr/zZG + Kf83TCv/N0wr/zdNLv89Y7//P2rq/j9q6rU/auofAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADfti8n37Yv9d+2L/+prC//IZQu/yS6rv8m0Pv/JtD7/ybQ+3oAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNqtZIzarW7M2q + 1v+8ncT/SEU7/ywzJP8sNCT/NEUp/zdMLP87XI//P2rq9T9q6nc/auoFAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvT9+2L/7dti//XJ4u/yGULv8lxdf/JtD7/ybQ + +/cm0PsbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAM2q1jnNqtbmhXOG/ywzJP8sMyT/LDMk/y45Jv85VF//P2ni2T9q6js/auoBAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L4Lfti//xbEv/yiV + Lv8hmUD/Jszt/ybQ+/8m0PuoJtD7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzarWLntsfOAsMyT/LDMk/ywzJP8vOzf8PWO/qD9q + 6hcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2 + LwHfti+v37Yv/4GlL/8hlC7/IqFc/ybP9/8m0Pv7JtD7RgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3bXYwOz805Swz + JP8zOCv9Qk5idz9q6gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADfti8D37Yv39S0L/89mS7/IZQu/yOsf/8m0Pv/JtD72CbQ+wUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAIN8gwl4cnZPg3yCJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvFt+2L/+iqy//IpQu/yGULv8kuKj/JtD7/ybQ + +3QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2L0Teti//V54u/yGU + Lv8hlC7/JcPP/ybQ++wm0PsgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADfti94wrEv/ymVLv8hlC7/IZUx/ybO9P8m0PukJtD7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA37Yvp3ukLv8hlC7/IZQu/yKfUv8m0Pr+JtD7PwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA37YvCNe1L9Ezly7/IZQu/yGULv8jqnr/JtD7zibQ + +wkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+2Lxmdqi/0IZQu/yGU + Lv8hlC7/JLWg/ybQ+20AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADUtC87V54u/yGULv8hlC7/IZUw/yXAw/Qm0PsRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAk6kvbyeVLv8hlC7/IZQu/yGXOf8lxdegAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWeOqshlC7/IZQu/yGULv8inEj6Js/4PQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAznEDQIZQu/yGU + Lv8hlC7/J6BT0CbQ+wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAOaBHnCGULv8hlC7/IpQv/zmhTHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAFKrYQ44n0aRI5UwtT2hS35suH0JAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////////////////////////////8f/// + //////g/////////wB////////4AH///////+AAf///////gAB///////wAAD//////8AAAP/////+AA + AA//////gAAAD/////4AAgAH////8AAMAAf////AAHgAA////gAB+AAD///4AAfwAAP//8AAP+AAA/// + AAD/4ACB//wAB//AQAH/4AAf/wAAAf+AAPAAAAAB/gAAAAAAAAHwAAAAAAAAAcAAAAAAAAADgAAAAAAA + gAOAAAAACA+AA4AAAA/wDgAHgAB//+AcAAfAH///4DAAD/AP///AYAAP8Af//4BAAA/4Af//AAAAH/4B + //8AAAAf/wB//gAAAD//gD/8AAAAP//AH/wABgA//+AP+AAOAH//8AfwADwAf//4A+AAfAD///wB4AD8 + AP///gDAA/wB////AAAH/AH///+AAA/4Af///+AAP/gD////8AB/+AP////4AP/4A/////wD//AH//// + /gf/8Af/////H//wD/////////AP////////8A/////////wH////////+Af////////4D/////////g + P////////+B/////////4H/////////gf////////+D/////////4P////////////////////////// + ////////iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAgAElEQVR42u29eZRk133f97n3 + bbV19To9K2YADDAABrsAgYsIQhRNygSphZJNndhiZFG2adOREx2dJMfSsSImIn0sKUpkRfQRHZ1IpkxZ + NBcllEGJMSlCYkhQIIhlsGOAGcz0LD29d+1vub/88bp7umd6qa6uXqrqfs9pDKan3qt6r97ve7/f3/3d + 3wULCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLC4uOgLK3wKLT + 8S8e+6hcKF9iqjbD+dIYAFppsm6WG4qHGc4M8W8/+Mf2WV8F2t4Ci07H67NnmaxNU4kqS78TEWITM1uf + 41LlMh/8o3eLvVNWAVh0ET702R+WWlznzflz649yC2rgrpGT/Luf/Jx95i0BWHQ6fuqz75Op+hRTtWkS + SZp40BU5L0efX+CrP/uEfe6tBbDoZEzXp6lE1aaCH0AQwiSkkTT4+f/7p60dsARg0an4n7/638lUfWqF + 528GkYmITcx8WLI30RKARadirHyxZfdaCss8M37K3kRLABadilpcR6R1FS9YB2AJwKJj0YjDLZ/jN/7s + EcsClgAsehVxPMW/e+wesQRgYdFhyHqZLZ9jLkxnBCwBWFh0GHw3j1Jbm8qfjxLiJLYEYB8ni05D5J1E + tljDdr4u1AxEz5wQSwAWFh2EP/jALyuji6BatwIToVBN7L107S2w6ESIsw9QENdbOr6aQN3Q8yRgFYBF + ZyL3VvBu3NIp5iLhpbJQ+l7v2gBLABYdCSd7H9rbv6VzNAxMhdLTK+IsAVh0JryD4AyDO9LyKUID0xGI + 9G4y0BKARUfCOPsw3jHIPtDyOaoGxupCL6cBLAFYdCSeffQmpbwjqNzbWz5HORberAnJwtjfiyrAzgJY + dHAiYACUvzAdGINsrrCnZuBSA0wPVwJYArDo4Kd331UiMKVNE0A5TlVA3MMEYC2ARUfbAADV9yj4x1s+ + z5s1YTKUnrQBlgAsOh+Z28AdbvnwmUio9Ggm0BKARecjuAOcoZYPn2ikdsASgIVFRz7FBcichMK7Wjr8 + jZpwJbyq/HvJBlgCsOgKKGdfy3mA6VUsQK+QgCUAi47GYiIQZxjlH6eVZqFTIT2bA7DTgBbdAe8gOEVw + R8HMg6ltygJMhL05F2gVgEUX+QAXlb0vXSOwCYQGqnG6OtASgIVFJz/OwV3gDG7qqGihL8Bc3Ht5AEsA + Fl2lACg8ktqBTWIuFt6o9t6OAZYALLqJAdJ1Ad4xCG7f1JGVBC41rg//blcBlgAsui8P4B0E/6ZNHVZN + 4HIj7Q1gFYCFRQdhaSpwEf5xVOb+TZ1jaqE9mFktR9DFKsBOA1p04VO9D4II3IOQzIBs3Di0HKfNQXSP + 9QezCsCiC21AJl0i7N8IOtfUIaGB+TidEeil/gCWACy6lgRU/uGmewbGArUkzQWs1h+gW22AJQCLLiWA + ALL3gTOS/n+TOF+T6+oBrAKwsNjjuC4RqHRqA9x9myoMuhwK5R5qEWQJwKJbJUCaC/CPprmAJvF6RZiJ + Vv+3brQBlgAsupsGsvej8m9r+vVnajC7jgXoNhKwBGDR3XCGwN0PupiWCm+AyRCqibUAFhadnweANPCd + kYUOwt6G5xhvCBWbBLSw6C4VoIo/1lTj0PGGMB2t3yOwm2yAJQCLHkgEBOnaAF3Y0AYIUElSEugF2FLg + PYZP/sonZGJmGpRCKQhcn3/1v35S2TuzlWHOB//YVQLYYAORapKuDTia7f7bbh+sPYBf//i/lj/6iy8S + xiFxsvrQU8z18baTD/K7v/c79jtbB/c+dmZNeS6zn4Xa99KfdfBgv+Itg4qPHHHWfZ1336sd/11YC7DL + +PDP/AP52lN/TRg3MGbtzpT1sMFL517lgz/x42LvWoujnX8c/Js3fF3DwFyPWABLALuIf/GLvySzpXle + v3CWOIkxYtZ8bRiHnLtygdnSLB/6kfdaEmgF/lGUfwOo9WcD6gsLgzZCNyQDLQHsEr78qS/K//udv+L0 + +TObOu789CSXpq/wL3/8B+RbH3mnJYJrsOpU4CLcg+Adh+Dkwo7Cq2MmSvcLtArAYlvwpd/6E3n9/FnC + JCSRzTekn40MT8zUGAsTnvpHlgQ2BaeIytwNem0CKMXCpTqWACzajxc/95QkScLEzASJWV/2r4WaMZyt + RlyMDROJcOljj1gSaPqJz0NwYmGFoFozB1BOhFoCGxUFdroNsASww8EPUI3qPHf+JRLT4nY0AmKEz8/G + /FUloWaE8Y89IlcsETShAAYh/4507wDlr/kyI/BiufvrASwB7HDwXxPHW8J8bHihnvCfSjG1BSFhSaBJ + ZO5Yd5VgQtoirNLl6wIsAexS8LcDocBELDxdFyYSoSqWBGCDROAi/OPgHVpXZU2EaZegjdDJNsASwC4G + /1arSJRWzAqcahierCe8GV3NJ1yxlmD9e5d7ELXO3gFC2h2o3OTCoE4lAUsAuxD8g/l+7jx8G452Wnx6 + 0+BXjkIttLH9s3LCN6sJY5FZYS0sCaz15A+Aewj8W1ddH2CAyUioG2sBLNo88vdl89x84Bie46HV5r8C + pRTK06CuaojLsfB6JDzXMNflFiwJrHYTXXD6FzYQWf07mGiwlFuxBGDRNs8/2DfIfcfvIufncFQLKsBR + 6Ky7wkM0BF4ODV8sJ6u2te41S9BUHsAZSncTXqUy0Ai8XhXmNzEL0Ik2wBJAmwO/mYSf6zjkMll+7Pve + w71H79jcF+Y7OIGDk3GW5P8iSgmci4T/MB/zXGP1ocvmBpZ/EaOQfyfovjXLgycj4Vy9e2+XXQ68G+oT + hVKKE4ePM5fEXIwSLl56GcSsvTmdAuVotK9RvrNC/i/3rUbg2YZhQCuOuMKQYxcPrmsDlAv+DenOIPGV + 615SjmE6hKMZawEstiD7V8NtN9zCHbc8yO13/BDK8WEdO6CUQnsanXXRwfq24em64ZXQMBat/ZGsCliG + 4HZwD6z6T/MxTIXN36pOswFWAexC4C/HnSP7uGlwiBflFyhdeJbqpVPI3LnrZL/2NU7Bb3ru8PFawrMN + w6cP+PhK4an1SWD0U4/3rFRQhfeCJEj9uev+bSIUzta699qtAtjF4AfwtKbgurxtdIQjB46jDt2PGroF + gmIq+z2NDpwF2d/8eRsCs0b4ds0wHtvBfl04/ekWYu7oqhZgKtzc6TpJBVgFsNvPngJHKX5wX5EKxznt + joJJwIRIWEpH/8BJp/02gURSEvhGNaFPK45467PHohroSSWgC+kaAfcgxBMsL9IuJzAddS+B2gzRLo38 + q+G5UoNn5xt88UoZ3SdoNQfP/UeolSButHzed+Y0b8lqHs03x/fdRALrtQhbOWxfhPAN5MrH4Zol2ocy + ii8/uPmxshNahlkFsEeCH+Bg4CL9iq8aTVz0MN4gqEeRseeR6TGYv9LSed+IBDA8lBH6tCLY4LHsSTXg + FK92DjY1kKu6PzZpLqDoKoIuM82WAPYQ9vkORd+hoAOqxTxh4MHAEMak04NSm4c4XJgqbJ6HxiKhYuBi + LBx1wXdUU9LvyscekZ4hAV1YsAID6f1dRgAJwmQIgabrCMBagF0e9a/FyQ89oFaVrtVZzGvfQl5+HJm7 + vGlL4Co45il+pujyQEaT05v76juVCJq2AAuQmc9A7SlYNiMw5MEv3+Jwsk8x6m/uNux1G2BnAfYITn7o + AbUY/LBKKaufQ91wD+qu96JvexhVGIZNLCZKBK7E6VqBZxqbL3DvlboBlbnzutmAWOByQ2gk3Xe9lgD2 + 0Oh/LVaQgOujho6gjt6DOnofjByDTB+4fnMjG1Ay8GoovNQQapJWDnY7CTS1JmAF0R4Fdwh0dgV5jodp + t2BLADb4t032NzVC9e1DHbsf593/DH37D6L23byp93quYfhaNeGpesJ8C0tdu34tgTOSLhHO3Lv0q0jg + hZIw18KmoXu9JsASwBqBvxPBf63sb3oEUxq8DOq2h9H3fQD9fT8O2SLo5nK6s0b4QilhLBJCae0yu5kE + lHcQtYwAEoELdaHeYnuwvUwClgA6UcYqBdpBDR5GHbgVdexe1OhxKI6CF2x4voZJlw6/HhoubaFKsFNI + YNM2wBlKdxBSHqAxAnMxVE2qBqwFsCP/jsr+dR/ibD/q4B3oR/4h+u4fRvUfWHWl4HIYUj/7/5QTHitv + zdh2pSVwD0DmrpQIdICQ9gacDWG2yxjAEsAu+P3NBn9TsjXbjz7+EPqH/in6+NtQQ0c2POZiLDzbMDxW + aS0f0NWWQLmQewu4+5d+NRUJ4w0sAVjsQSnruJAbRI3ciLrhbtSB29IEoXbWVAR1gYlEeKpmmErStQOW + BJaFRnAb6P6l38zHMBN1Vx6g5wlgL8v+lgevO96FuvdR9P0fADdYt15gOhG+Xk04Expm2tADv2tIQGlU + 9n5w9129V5EwEXbX8696Pfg7NfA3rHBLYjARMnMROf1t5PwpZOrNNV9+i694KOPw94sOWa3a8mDsperB + zVYEAiAxMv8lqPw11J/n3qLi/qLm529sfdzca5WB2gZ/d4z6q1oCL5sWDx2+E3XTg6iRGyHIr/ryyzGc + iQwvhKZtme69pAY2PROwkAdQ7gHwjy1ZAJsEtMG/J4K/6QfaDVDH7kff9/6UBPJDq76sbIQzkfC1iqEu + 7bs9HT9L4B1C+bcBMBvB1Bb3CtxruQBtg7/LRv614GfR9/0I+l0fRT/8ESgMgbOyE+6VWPjLasITNcPZ + qL11rx1LAt6NkHsQ3H3MJj5XGuluQd2yZaC2wd+5wb85WavAC9JS4v3H0zLi0ZshP7j0CkO63+CT9YRX + wnQJcc+TgHJAZSC4HdFFIoHpqHsKgrQN/s4e+TftbXP9qH03oe99P+rQHai+fde95Fs1w/MNQ8kI7b5p + HWkJlI/K3AO6n0TS5iBbEUh7yQZoG/ztC/zdkv2bJgGlIcijH/op9Hv+OfrtH4ZluYGqgb+uJfzKZEi4 + TXeuo0hAZ6HvveDtp5IIT80Z5ruk0aprg7+HoRQqyMOh29FRFZk4i1x6GcIqdSNMIjxTN9zgKQ65attI + oCOajagAvCPEcpSJcMxaABv8uyf726ICFuFnUaPHUSceRh27P1UC2qWBZiaBp+qGi7HQDb0wWr5HKFA+ + uIeIvWNMhmmfwK1gr9gAZQO/swP/WrRU8LIIE0PUIHnyCzD+GjL+GgDvzTs8mne4N7P948V2q4Et3Z/w + LF7jeYbn/zc+cZvDvcWtf9TdLgzSNvi7J/i3NsqRZrzdAH3LW1G3P4K6/RHwMrwea75aTWiIbPv0157O + DbjDJO4h5kwfCU5XxIu2wW+xPCeA46IOnEAduRt17AHo28clL89ToWYiFmrS2bd4SwSp+zDuCFW1j5rx + uiIPoGzwd8fI31apuwwy9SZy5knUG3/DWytjvL/g8Lbszo1+22EJtnRvkhkof51fGP4zHspf4NZ8Z9sA + bYO/+4J/yyPd8hGibx/q+NvgbT/Nqwfv4/lghOcbO9cdc89ZAp2D7H1MJoUtlwVbC2CDf++TgJ9LW48d + uYupg3fyRvEoLwbD1IUdmxnYUySgPHAPMZP0MR37lgBs8PdKfkCj730/37v7J/jCrT/C+YUeeb2nBDTo + LK/Ft3IuPtKWM+7mlKC2wd/dwd8uK7AIU9xP6Yb7+NR9H+GVoVt29FraVUbcjnsyrk4yru5s27XtFglo + G/zdP/K3lQS8DFF2kJf2382pkZOc6Tuy49ezF9RARR+mpG6wFsAGfw+SgFIkuUE+e/tP8GsPfGxXrme3 + FxVFzhFK+mZLADsZ+Db49x4u5Pcz+qnH1W7V8+8mCYzFI/xF6TZqxutYG2C7AvdQ8Lc7HwCQqKs1Ab1G + AlXJ8YGHv6ziDl5T1xEEYEf+vY3lhTW7SQI7TQRVKQAQ07nTgcoGfm8Gf7sqBTdSGLsxOjdDQu26foXh + c6Mf5Sb3XFs++05XBepeD/7dbORhSaXzLYGgOfHgf2nb87PTeYCezgHYwN+Z0Xg3bMFGJNDufEg7R+6d + JIE9RwA7uTV3LwfmdiQE11MBu0UC3byNedcRgE32WRLYSTWwXddvCcAGvyWBdUhgL1qCXrUBei8Evg3+ + 3iIBawmsAthx2ODfe9htNfDJ3/43ouMGbHH3g70y+9FxBGBH/u5XAXsVVz72iNw88zrF2TFUHILZe32P + d8IGqG4OfBv8e2c0a5ZgdlKin47h8briS2/5GPWhG1D9B9pyfe0O3O0sDlLdGvw28C0JbIQLsfBcKPxu + cDO14ZtQB29HHX+o5bDYLhLYTgKwi4Es9mRuYCfeJ6NgRAv60ivIhReQsVPI7GWozad7JPQAdmyUtLLf + qoDN5hq2WwnUBOYS4Z+Oh8wubHigDt6BOv4W1M0PogojW7q2TlABqpuC3wZ+95HAdhKBAWKBn7nUYCqR + tM9/kEflh6BvH/qBH0MV90NuoGsJwFoAi561BBrwFRR0+icAjQoyewm5/Apy/hQycQbmr1gLYEd+qwJ2 + UwVspxL4lYmI16N0E9TrAuTwnajDJ9EP/uSmr6unLYANfksC20EC20EEfzgX80zD8Ex9lT7nXgYV5NIZ + ghMPw/7jqEyxa2xAR1sAG/zWErQD/Y4it9YZozpSnUUuv5rOEpw/hcxfgSTa8aDdjsKgthPATtb2W+wM + dmOtwE6SQL+GrF7ndMYgpUnMC1/DPPWnyMWXkHrZ5gCs7LdWYC8QzFYtwenQ8BeVhM+Xko3DRet0u7Qj + 96AOnkDf9jB4GVB63WvZq1ZA2+C36HVLMOgoCrqZU0i6ZqBeQqbOIhdfRN74G6Q0AVGtI++dtsFv0clW + YDkJtEoEw44iv9lImLmAnHsO89xXYPp8x1oC1QnBbwO/N+xAuwimFUvwjWrCF0sJzzfM5hYHKwXaRY0c + Q514GH3LW3n2J+9TPWEBbLLPYi+SSitqIKsUI04LbyYCSYSUp5A3n2b/i3++7UHbTjJpiQBe+JPvygt/ + 8l0REUS2lwPs6G+xE8jo1Aq0jMoMcu4Z+sae42f/2Yc7ZmDc9BW/+Lmn5OLERZLkasY0m8lRyBXI+IEN + fDti78lcw0a24GwkvBwafnMqYiutQUZcxXtyDv94wF01ObnXrMCmNjX79K9+Sr725DeI44jlA7/nevi+ + Tz6Tw/cCfM8nF2RQSqFU+hl9z8fRDgK4joPWGlc7CIKjHVzHRWu7NKGT8OyjN6ntIIF7HzsjO92hKFBQ + 1IqtXkzFCDURGiJc+dgjsludkNuuAD79v/xbKZdKjI2dJ06SFdJfKYXWmkI2Ty6TI5fN0Z8vLgW6Uppc + kMV13SXCcF0Hz0l3VXVdl8AL8HwP0cK9f/ctdvS3SqDtSmA9FTCVCJdj4Z+Ph5gtvs+jBYd/1O8ysMxS + LCeCvaQCmjr44//Nr8jczCxR1Fz5o1IqJYJMlkyQoT9fXD8R4WqcwGPw+Ahu1sPx1xcmjz76PksQlgC2 + hQjec75OvMWreUfW4Sf7HO7J6BVJtkUS6CgC+O1/+Vty/s3zRGGIMc1zo+u4OI6D6zgEfkDGy+B7Ppkg + g6P1kjVwfBe/L0NuX4GgP4t2NUpv/Xu3JGFJoBUi+K8uNigZobIFGXBfoPnBvMMHCg7XTiyobELhb43j + DClUsMcJ4Hf+p/9datUa59/c2s6nWmvymRwZP0Mul8N3PRzt4DgOmYE8mYEchUNFtLMzOQBLDp1DAtud + C7iWBH5+vMHlGCaT1i/lhK/5/ozmIwPuddNsyjF4t00RHI/Q/YLO6V0lgXUP/B9/9helWqm2/abnMjny + uRyDQ4McvudGgnwG5XRGTFry6G4l8BtTES+Hhjei1i/jqKe4w9f84pCHd92nFiQJcfdfwT1UI/fWvl0l + gDXN9uf/z8/J0995altueKIT6jpi3q0hly+QzWXJF/IUCgUcx1myB3sRjz32FbGEsX6gdtpGGYve/MrH + HpH9ruJCrNjKZiEVw6rNRRbHXKU94gmXZE4wczMEd+Vwhj10ZudnwdYkgKgRoto9LacU2tGowIFAEeuE + UqVMlEQkCxszuK6L67p4nrcwg9DZ8XMtYVgF0bqy2G47MPqpx9X/8ZG/JRKHEEYgrSUC6iJMJetQiNJI + 3UVqLmGtgu5zkEhwR/2UBDYZdtEzJ6RVFbDmQX/wm78vp199jbnZubbdYO1o/GKG3EgBJ7ieexzHIQgC + stkso6Oj+L6P53n26e9A4ujEfMAi3v2zf0cuz01CuLUVfl+5IUNmjU8scQWJSpjKOZSncEZ9cm/rwz8a + oFpUAq2QwLrzbe2s8nWzHl7WJztSQHurX6Axhnq9ThiGVKtVPM/D8zwGBwfJZrMEQdCzBLBZ67HbpLEd + VmDxfNtNBHNv/TAOCvPEZ5HSFNTnWzrP66HhgKtWLTFWTnZhVPSRJCa5ElL5+izxbTncQz7+TQHK09ve + t3tNAkhH3jZ8f0rh+A5ePsDLeji+sw7hpGsLjDHEcUwYhrhuOp0YhiFBEOD7/tLvbOVga6Rhbcj6+O5H + f0zd+8VToo59H0y9CbOXkJkLmz7PRCL0acWws7oNQLkoJ4PEVSSKSaZjorEGEhmUAvewj/I1ytu+r2vd + M//SP/wfpDRf2tobOJrMYI7MQBY307qc11rjOA5DQ0MUi0Wy2Sy+79undY/bj06cFVj+uWXseeTii5jv + fnHT5/jogMs9geZksMZAZSJM/QrSmEKS+tWYCTROv0P+3YO4wy662Pwyxc3aAHcjfshms9RqrXmhoJjB + KwQE/dktF/cYYxARJicnmZ6exnVdCoUChUKBbDZLLpezkbqH7IdB8YFH/7a6o3SOS4nHpLgoL1gacpwN + qkP3CtSBE6jhG1CjxzEvfR25/Fq6dVgTOBcJR711R0eUP4iEK/NsEhqSKaH859O4hwOCE1mCE9ltaeG7 + LgEU+4uEYUgYNjBmc0t/vbyPl/Pxsn7bCnxEhCRJln6UUiRJQr1ep16vEwTBUt6g02cPOh0a4bHHviKn + 6nWycYNaBUropbySqVZW2ETlOEt99ZTjpL33Fr5DpTTK9Va8fscWDLk+aBdGbkQdvR8yfcjYC1Cd3bAz + cMmkMwLr2WO0D04ApgFm4XwCkgimlJCMh4QalKtwBl2cAQfaWDOz4Zl+/9c/LS+deoEoijCmOQJQWlE4 + 2I+X81fN9rf9YdMa13UZGhqiUCjQ19eH4zg2CvcInp9t8LXxKq+XQ1Z9hBwH7WeWglwFGZTronT6HSrX + w8nmr3pnrdO/K7WzbcqiBjJ3CfPk55HLr26oBO4ONI/mHf52Yf1n0VQvIOE8Eq9tt4NbMvgncgS3Zzec + JdiMDWjqhV/6/c/LU088SbVaJYrW3jVVOxq/L4PfF+AXMzs+Ci8mBZVS9Pf3k8/nl36sItg9hEaoJcJv + vDRFOTJrLLZR1z+NSqV5aAVq6R9lSRnkHUW/p/j5E0P4y7f3oj2JzlVJQAzEEWbsVNoe/KWvQ9RYtWbA + AT7c7/Iz/esPghKVkGgeU10n0agVOqvReYe+Hx1CF5x1y4ibJYGmhucP/tzfUZ/4b39VPN/D830qlSpx + EmOSBAFECShwsz5uxsPNuLsScMsXK9VqNeI4XrIHnpf2LMhkMkskYbEzcJUi58DJYsC5asRYdbVBRK6f + dFqUz7L6fFQoipIoXp1vcCjrciDjNJ23aIYgkvJcqkIWq1NVakuUF6AGD6OUwiQRjJ1CqnMQriybT0h3 + IJ5JhMF1ZLtyfDABKGeBSFb56EaQhsEYof5MBfeghzvq4e7fWiK8aX3+y7/9qwrgc7/3x/Lm2XPU6zXC + MEQQRIM44C8k+/ZCbNVqtaXkZblcplAokM/n8TzP2oOdzgco0Epx72BALMKFatyOCWZCI4RGeL0cknfU + CgLYCOsRRF1gMlb81sQM2g9QrreQl3BRjoNyXNTAAcgPoAvDmMoUKomQsHZd8FaNML0BAaAD0BEoFyRc + WynEgsRC7bulNCm4UD24lVqBLYfqtTcyjmOSJCEMw6VRuVKpLCXxjDE0Go2llmJhGJIkCXEc78jD6DjO + ki0YGRlZqimw2Bm8PB9yaq7B4+PtXWT20HCWB4YC7uxvT7FYwwifeH6KSmxorJH7UlqjXB+lDDI/jlx4 + ATX2DMRh2g1LK96ac3l73uVdOY2nNa5WZNzrpbskDaQxialPgAmbfJgV3mGf7Pf34d8YoK6ZbmzGBmw5 + Q7dcSj322Fdk0YcvVu2JyIoAExHiOF6aUTDGLE3xASRJsqLxiIgskQlAFEUsb0aaJiebr9lerDZcfJ/F + mYNsNksmk7FksM0YCRxOFgOema5TT2TN4NosLlQjtIKb8h6+o3C3KEM10O9pYln7M4oIJDGCgJtDhm9C + wgbMj6c/UcQUhjMm5oRJbYRW4Oo0t6EVZBydpjkkgSTAbYBaeD9Xp69ZFA+uUqwoojVCMhvTeL5CMhkR + nMyhC86mCofamqJ/9NH3qeUksJTB3EQJbxRFNBqNFYphUcqLCPV6fQVhLJLGdV/MKv+/+PcoioiiiGq1 + ShAEBEFAkiRorfF9f6mXoc0TtB8DvkPe1YxkHCYbCY2wPQQwXo8px4aZ0RwDvsZ1t/bdKaDf15TidQYX + ESRZUK5OAP2HkShGRCPlOWjMMyuG84liXDmrDOCKPm/h90rQeAShwklAEAJH4WpwVfqBMloQ0r6Fiz/x + TIIq13GuxPQNeWQOgFdwcJskgW19wlspINlqEjCO4yUCWSwnXk4QpVJphbKI43hJQbiuSxAE9Pf309/f + bxcjbSPGqjFfH6/yN1Pt21LLUXBzwefdB3LctUUrEIvw1UsVnp8LOVeJNnlwiEQ1zPf+lIFGiX1xhZ8b + aG6sNfUpiKtIsrZFmjFwxcCEgYsCoaTXfoOveOCeLLffnuGt7yw2ZQO2dZL+Wnuw3Q+VUgrXvToDISJk + MpkVKiCfz68gjOVqYjkRLBJEGJf39pMAABEkSURBVIZLiUNrD9qHQV9za59HaAzPzDTaMwBIqgReK4W4 + SnF7sfUMuUYx6DtkWqlgdVyUyqJv/QFqsxeZmL0INLeWQDkBIjGsQgCTCYwn8GyUJirrAlXALIzkM7Fw + 4ZWQb00avj2e8EP3b1xt6e7UF75oD7abABY7FLeCRbWwSASL+YrFvgSWANqHvKs5nHWJDLw0HxIbIdni + 0yHAfGQ4X4kJtOKWgoejWp+V6vccvFYIQGlwfNToLURuBqMckrCCDmuoOFx/ma320h9WNiWpShr8r8fw + /Bo5whlgbDwmM51wZirm4FCWv/7srfLw33tN7YoF2GsWod2qpluvcSdRS4TPnJnjfDVmJkzadt5B3+Gj + twwwHDhkWyidFWC6kfBnF8s8OVXf0mdxlfALA/PkXnuS4PzLSLS+4pG4gqmNg4mXSODxOpyOUgJoFvv7 + HfYN5HnsP0/uTQLo9CDZzmW1vUIcicAb5ZC/HK/y0nxI1KZZgUArTvYHPDKa41jebWkkD43wp2Mlnpis + E27hczkK/skNASONGforU4TP/BWmPIuEqxOLJA0knEOiOSJjaAB/UIJZkyqBpu+BpzgwVOCR+2/h137z + O2pXLUAzgdRpD/3i590OIljtnN1IClrB0bzH4ZzLdJisUSW4eUSSFgjd2udT9DSjmc3bN18rMlqTcdSW + CACg7GYYyh/CHRrGTIwRXxnDlGaQamkVK+uAk0WieRoCUwsJv832KW1EQrWecGFilj2tAKwqsPdwvB5z + thLxmTPzbT3vrX0+J/p83nco39Lxfzle5anpOmc3OxNwjQL44YN5TvYH3JhPZ5WiN04Rn3+N8IUnVjcg + IiTls5wLI06F8ESDlvYsdLTCdzWvfK+mOooAei1X0Ov3OzLCTGj48sUyb5RC5iLTlvNmHMWBjMv7DuW5 + Me+RdzeXIH56ps5LcyHfmmx9ulIBdw0E/MC+7NL0pNSrmFqZZPwc0cvfJZm6jDRWZv5N9TKn6nW+UWlw + KWmtP5ciTY7/9Afey6/9qy+rPWkBmgkmaw92l7y2+/57WtHnae4o+syGCbVEtiy7AeqJMB0mvDIfMuw7 + BFqllXhNIu9q+v2t97OYCRMay6Y5VCaH4wUox0XKsyg/Q3LlPKZehYUO2bH2qRMzZ1qfJhXS2SzPXd0C + uZ32UHYqEXS6KtiJ2Y+so3j7SJaLtbSqb6LenlmBcmz49mSNmwupAujbJAEMeFub/hVgqpGS2kp97qCL + Q/j3vhMzdYnG099ALr6BNFK1UdUZKiqmIpUt34PFtvsdaQFsrqC38MnP/Wd5ta54suYQNRpIkqTLYU2M + xDEShZs+pwKOFTzuKPq8/1Ch6ePmI8PlWsy/eXVmS9ekgPcfLvD2kSzFa7tii4BJMPUK0ennSC6dIXrj + eZ6tx7xULfF0aQpka2R47vlw784C9Jo9WCQuSwKr45c+9H4FcPe//6a4QT6t1BRBTAImQRZXji5WcS4b + 3SSOrlZ+iknJY+HvUzFcrBvGqhEHMm5TViDQipy7dQsgC3akHJvrCUApcFx0vh/3wDGU44IIc2fOUG1E + aduwpLUchOtoAs8BQrqSAKw96F6c+q/fse7eApIsKILF+XQRkloFMQYkQZIEaTSWFuxUopDLofDcbIP+ + UacpKxA4qqVCotVQTQxzkeFQdu3XOPuPogf24Rw4xuzklyhXGyhdXugavPnH23M1w8UsUOlOC2DtQXdj + w7bi15bVLvx96b/CisBRgKfgux+4VTX7zMxEwqfHQqZKFaph69OBd/b73F4MeNf+9TtYJyKEieHXnz7H + 5KWzxBdfRN58fKEJ6eZmR4YPHOCeH3gnf/jxP1I9RwCWCHqEBFrEZhqKvuMPvyFzkblaqSgmVRpJDCjE + mFRpLOsNaMLwKvmI4XhWc3Pe5UcPr5+DqCXCTJjwuy9PMjs3hcyNI2e/AaXLSPkKNDk7ootFCvsOcvcP + /ih//Auf6F0CsERgSWCrJHDt+8tCLmIxYy9JjGnUr/YHAJLy/FVFkkQcdAxHA/j7N66/Sm8uMrxZifjj + N+cpLdRDyLlvIhefQy6eQuLmEoLe0aPo4cO89pnH9/ZaAEsGlgw6kQTa/X6Lz+QzFfh2SXG61CBeGO2T + WhnqM0htEvOdTyPVKtSvTwyqjI+z7xDBQ+/HO/l3UX0H170+t1cfJrv+wGIvk/vD/+kpcYIEtaAg3CiE + 5AAS1yDrYCpzSGUWKhcX9L4GN4sevAHdfwDn4HHwN57utA+RVQRWBTSpArZbAWzmvUxlCilPIlPPLUSy + g8oOoEfvQeVGmn4vSwCWDCwJNBkse4kA2vVelgAsGVgSaDJgdiood5JotA3x7gwk24lod2zCbpJXK7AK + oIcCq9tUQTeqgHZeUzOEZQnA2gNLArsQoHuFAKwF6FF7YC2CtStWAVhF0BWqoBNVwG4pDEsAlgy6kgh2 + kgS2iwB2Wv5bC7DNgdSJwWStQWcT1mZhFYANrK5RBDulArZLpu+0/LcEYAmh6whhJ0igmwjAWgAbSNYi + 7AGy2o3gtwrABlZXElknqgBLABaWDDqACLYjYHcj+28tgA2kbSGubrcIe6mOvx2wBLCHScASQY+gTXeq + lcVK1gJYe9DVqma7Ruw4SlCAs4Vdg8QItUpIJuej29B63BKAJQJLBDtEAtVSul9fri9o+RwmEcqzVfL9 + WZw2bD7SCgFYC2DzBF1vD9q1jn85wnpEWI+v7kLUigIQIY4MYnaPy60CsKqgZ8isnUpgfqpK1EhbgPfv + y+O2YAWiRszlszPsO9JPJu/vCsm5Nmy6TxXYLdK2H67nEIcJ5dkaub4ApdSmZHwUJjRqEVE93lUFYC1A + lxKBrTTcXivgeBqlFfVKSFiPiaPN7d6bRMnSccYIskscYC2AtQc9Zw/aYQXECJX5OhdPT+F6msJAlpEj + /WinuTF1fqpKdb7O/FSV0aOD5PsDvKA1Qb4VYrMEYMmgJ8lgyyQgUC3VuXB6CgUEWY/CUJb+kUJTU3pT + F+cpz9ZoVCOGDxXJFQOyhWDHCcBagB7OFVji2pp2VkqhHY1I6umr8w2SOJX0G6mHOEqIw9Q2JLHBxGa3 + LsPCKoLeVARbVQH1SsjE2ByNSrgU9PuO9JMtBGQKq2f1RYSwFjN5YY7KXB2AwmCWXF/AwGhh059hq3kN + SwAWPU0GWyGBsB4zO1GmNFUlWRjBg6xHYTC75tSgGKE0XWN2sky9HAKQyfvkigEjh/t3nACsBbDoGnuw + 0+SltMLzHZS6esvCRkyjGqXBLaspgPQ1Jrn6j0lslgjEWgALqwh2mMxaVQFJbKiVG0ycn1sqCgJwXI3r + Oxy9fRSl1XXHXHx9irAekURmiUhyxQyHbxm2FsDCksFukEErJGCMEDfihYC+SgBKpf9ZrPBbrPITEeIw + 4c0XxhFZOfefLfgcvHk4rS9QascIwFoAi00FkZ1BYEWgO+5CwKqVMl+MUJ1v0KhFS/LeJGbNwh8RSOJk + U0uD21HYZBWAhVUEW7QC51+eoF4NVy3pLQ7nKI7kyfUFNGoR9UrI+NmZ614XZD2GDxfJ9QVNFxNZArCw + hNBmMmiFBC6fmaZWCYmW2YBFuJ7G9V2OnBihPFujOt9gfqp63eu8wKV/JE9xJNfUwqJ2lTVbC2CxYz67 + E4jrYFImZ0KQ5rPyru/grrEQKEnSPEF1vkG9Eq3IFaywAEaIwnjH1wRYBWBh1cAyfLPq8T1vhIs6j3Ka + q82fm6hQma9TnqmtGWWF/ixhIyYOE0xyPbloRxPkPPYfG8TPbPy+7VIAlgAsLCEsH4mBl0sRL5dj/qqR + x+nrR+f7cDK5NY8pz9SozteZnaisfeIwxoQJkhic/uz1gagUSituuG0fQc7bkeC3FsDC2oNVRsTRQHMi + 75CPKqi5KaKJi0RT4ySlWUz9ev/ueHrDxJ1pxJh6iKmFSGK4Vuun04JCkpgN1xK0E7YhiMWukMBeVgTD + vkPR1RQvlJmulKkbMPkyTmEAJ1dA+5mFyX5AKRzXQW/QDMSEMaYeQZwgUQKeg7pm1aAYwSQmJQjt7Mi1 + WgtgYe3BGlZgupHwF5cqfG+mTn2xdFcp0Bq3fwgnX8QdGEH7PqWZOpfemF7jZEJ4fgqJDRiD8l3c4T50 + /vrlv6PHBskWfIKstyMWwCoAiz2jDPYSESgg72pu6fNJRPjOVH0pmDEGUy0jUYipVtC5PKYOHiERHtdX + BclC8AsISGwwtRAU6NxKEojDJC0RzloLYGGJYFeRcRRH8y4KeHqmQSyCkTSoTb0G9RoJc+hGEZO4OEYT + Cwh6QSk4C4QhsDzznxikHmGUQmf9q3aCtFVYEic7MvpbArCwuYINcCDjUnA19w9mOF0KmQqvD05Tnsc0 + YtR8A1MxiJ9DZYtQHEEigzSun/s3tRAVJ5icj/Jd1EISMWrExOHOhaUlAAtLBhsg0IqHhjNUE0M1EWqr + zeMrheNpMCHSqEAcQr2EiRUSKSTxUNoFdTVZKIkhmangDOVR2gOliKNkR5cG22lAi44kg52EqxU3FjwO + ZV1GAmfNpIHjaMBAnJKAlKeR0jQyPw1hFYlqEDfAJEvWwNRCpBEj8dX2YElsVl0UtB0bnFgFYGEVwQZQ + Cyrg7SNZDmZd/uCNuetHUr24L4BiRfQ2aphSDcwkOB7i+JAfBi8HToBCk8xWkTDB3de3RADGmKYXBW31 + 2iwsOh47QQaRESYbCV+9XOGV+ZD56KpUX1wCPH5uZknCS5RgKnVMtZFyglKpBXA80G76p1+ATAGdzeEO + 96NzPrmBDCNH+gmy3lJvgO0Y/a0CsOg6ZbCdROBpRdHT3F70uVJPaCRCY6FqTylQTlrOq5RK9wyMk6Wp + v6sskaQWQKmUBFLmQEyMcUF5A5jYJw4T/IyH2uYh2hKAhSWCTSDvat4ynOVCNSY2woXaygy/6zqIEZJY + MFGcVvWtBhFIIqjNQm0WcTzich8qeytJzqNRjRZ2HlaWACws9lqu4B37coxmXL50vkRoZGmQdzxNkmiS + 2CD1eOX8/3owMdTnSc6dJmrsJ+w7gZg8bHNFsJ0FsOgpMmgXhgKHw1mXmwoe/rKafsfVaK2WKgab3j5c + BEyMVEqY0hzR7Bxitn860CYBLXoO7VIEpdhwphzxhfMlphrpNF5lvk69HFKdrxOPz9FKhw9d6MM7cJCb + 3/MWvHxm2xKA1gJYWEWwBULIO2lC8PuHM5wuRZwuhbieg0aQesSmOnwudwPVCuH5c0jywLbfC2sBLCwh + tGgRtAJfK27MexzNueRdnRKAUukMQKs6QwSJQqJShbBU2dZrtwrAwoKtzR7c2ucTG3ilFFJPNFqlK/5a + xsIKwtrULFE9tDkAC4u9ni8ox4aJesLvnZ7l0sU5Zs7NkJTrW3rv4+97hNP//Q9va4xaBWBh0QZlEGjF + UOBwos9Hsh6zeuvu2tPbX+lscwAWFm3IE3ha0e9p7uj3OZTz0nUBWxy7/R2ITmsBLCzabA++OTbPF16d + 5vQzY601+NQa5TmYr3x82+PTKgALiy2ogtWUweFiwLtuHEhX87VQzO/lMgwcPbQj12AJwMKizUQwmvN5 + 6FAf+ZyP522yllcp3ExA36HRHfns1gJYWGyTPfjzC2WeeGGc7740nrYCb2b0H+xHeS6N//iLyhKAhUWH + 4z2/9hm5PB/x4gvnkehq559r4WYD8odGCTI+47/zczsWl5YALCy2GR/8/a/Kl7/8JDoxKJEVBYJKK0xs + cHNZBk4c49Inf2pHY9ISgIXFDuLt/9f/JxfOXQHSDUFzxRxBsY/v/YO32li0sLCwsLCwsLCwsLCwsLCw + sLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsNgQ/z+IbUvJi4sDAwAAAABJRU5ErkJggolQTkcN + ChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAIABJREFUeNrsvXl4XVd97/1ZeziTZlmS50F2Ijty + HClR5pAoCQQSMV+K09JLKS0trWhvS8vtvYXbCVre0uHecktd+pT7lra8lGumlkEOCQQMIWQykeLEju3Y + smN50NE8nGlP6/1jrSPLtiRLOufYUry/z6PHg6R9ztl7re/6jd8fhAgRIkSIECFChAgRIkSIECFChAgR + IkSIECFChAgRIkSIECFChAgRIkSIECFChAgRIkSIECFChAgRYllAhLcgxHLH73d98G9PTZ7ZNJQZWXdy + oi8CCEMYRtyKe+sr1w6tiNUeubZmyy7g8O/c+6eT4R0LCSDEMsenf/jHZT/ue+rajJfZHrdivzPpplam + 3XTDcHbEVgtbEDEjsiZWPZ6w4ycFxn+sKV/1k9pYzbFPPPiZg+EdVLDCWxBimaIW5DuB//ry8OH4hd+U + SHJ+TpxN9VcZwqiKW/HtdfEVXcBjQEgAoQUQYjnj4S8+tG8oO7RpKDNc40tfXHqhCxJ2IlcRKf/pGzbe + +yng8d+7/88nQgsgRIhlhI8/+tsrgWt/1PeTtSk3XTGfzZ+3CBzfieb83JqTE30PAs8CVz0BGOGSCrHM + sB5481B2qCLlpuyF/KIbuHiBt2rcmXjHuDNRGd7KkABCLDP0TZ7e1Dd5+mdARBfz+xPOZLS7f/+q9by4 + we1uqgsJIESIZYSMlzUyXrZMSrno+JVEUh5tuPWx8Q3bQwIIEWIZIec5ds5z4hQYwDaNyG3jnnXd1X4/ + wyBgiOWGomSuPG/onoms0RdaACFCLCPE7ZgXt2MpQBZynTHHieX83Dq3u+kOt7vJDgkgRIhlgIhVlotY + ZWNCiIIIYNz1I57vNQA3AyEBhAixHODazSOu3bxfIrxCrnMyK8kEbATeBcRDAggRYhlgQGw9PSC2PhoY + lS4itvjrOJK0TzXQDNS73U3lV+P9DIOAIZYV+kTbCPCiNOslCPCyi7pO2odsQDTtUx812GwK0sBV1ykY + WgAhlhvGgMMkbnewNxV2IVdycFLiSt4JtIUuQIgQSx8eMGnGW4cMe2WqkAvlAhhyJALuBbaGBBAixBJH + T0dj0NPR6GGvHsZcMYm1+GpeJ4BhF6RkDbDe7W5aGxJAiBDLAIFZfySwNw4SX7zlng6gLyvxIQFcAzzg + djcZIQGECLH0cVTY6wZE4s5FX2DSk5zISHxVUbAFeBtXmUZGSAAhlitOYlaPYG8AEQOx8IRWJoAzOQgU + AdQA24DE1VQZGKYBQyxXHMKqvwUAsxqCCZALqw2a9JQV4CkCqNVfq4ABYDS0AEKEWLp4GTgLICo6ILJl + 0Rc6kZEMOlOVxe8HWkMXIESIpY0UkAUcYlvBWrHoC424kpQ/9c9bgNUhAYQIsYTR09GYBTJAhuh1YNYu + +loDOeUOTCOAdSEBhAix9NEPvIBRDrFmKL9vURc5lpEkz7kAlcCtbnfTz4UEECLE0sY4cAxAmPWLjgMM + n+8CCGAjcHtIACFCLG2M5QkAcwUisoXFpPGHHKYTAMAG4ParoSgoJIAQyxkDwAuAxF4NsevBagBjYe39 + xzKSAec8fZGVwHbghte6cnBIACGWMyaAvqljX1iIeCuYC8sIOAGkPdUdOA02cB+wJiSAECGWJlKoWoAA + kGBA9HowaxZ0ETdQ+gBj3kV743Zg1WvZFQgJIMSyRU9H40RPR2MfKhjoICwobwd74Wn8MU9yLC2nK42a + wJuAJqA8JIAQIZYuXgXGQKi+AHsjRLctzJTw4UzuPBdAcK5L8IaQAEKEWLo4SX7Qp7AQ9mqINC7oAmkf + zuZAnq81bKNmEW4PCSBEiKWLZ4EzU/+KbEHEblzQBYa0PFhw8bduBd4eEkCIEEsXSSA99S+rHqKbwVrN + fJWDJz0lDmJcXEZQB2xxu5u2vBaVg0MCCPHaIwARUy3CkU1gJOZ1ASeAcU9lBILz3YAYTMmHV4YEECLE + 0sNRYOS8/xExRNndzFcz0JOQ8VUswLt45lACNUBkXUgAIUIsPRwChs8ngCjEW8GsU3+fJ05m5IX1AHkr + 4F5gg9vdlAgJIESIJYSejsYMqi9g8BwBGMoNsOoXVBh01pFMXmwCmEA9qipwdUgAIUIsPfRrSyDPACoW + ENmgYgHz9SVSkhH3ov/O1wRs07GAkABChFjaBKB3bvxGRNkd875IbwZGZ5cWfDPwnpAAQoRYephgei3A + lPFeC9ZKMCrnpRw86EDan3XyeC2wzu1uWuN2N0VDAggRYulgbEYCMCpVINCqRxX2XcKMyElSs1sA5UAD + qj8gERJAiBBLB6OongBmsgJE5dvnJRzan5MMu+dpBF6IFcDPozQDlj3CuQBLCH/xJ5+6PpCyeWBkaCWA + ECKI2hG3qqLyQE1Vdd+v/NavHg/v0qwYAU7M+B0RVb0BRrlyA+aYHyCBlK9IoHzm3RFHTRKuc7ubInbr + YSckgBCFbHoBmP/6yFfxfO8m4F1BELQiBAIZBEEwGQTBl3NO7qkPffA3T91yw03eL37o/TK8c+ejp6Nx + uKWrV+o9fH5BrxGByMZ5EQCoYqAhV7IhPqO8WAK4UccDIkBIACEKwluB9wkh3vkvj3xFeL47089cX5mo + 8O5ovnnk2Mnjv/v5v/unH/3ih94fWgMXw0dJhK3TpnreB1CbP94KBJD56ZwXOZWVPD8ecGOlOdePPagu + zNdDAgixKHziY5/4wP5jB+9Kjgze4Hg5EQTBrD+bdXLGwVcPl1cNxH+ur/fF9cnO9n8G+ht27fXCO3ke + AZzSp/NFDr+IbEH6o5ckgFwAY+4lX+sGVOoxJIAQC8M3d33NBhJPHn3uXaMT49cdPXV846V+x/Ec49Xk + qfj62ro32bFI7aGEfKbawkl2to837NqbC+/qlAt/GjXp92JENiD8JFLYIGff4VndGHQJNAEn3e6mCODa + rYeXpVsWZgGuDG4D/tdjT//w3ldO9m5cyC+eHB40zgwnb310xH9kwucjKOHKEAoB8BIXNgZNHXerwd4C + 0eY524RHXDUv8BKoR6kF3QmUhRZAiHnhwO597z7U98rdJwZO3eP4TsSX/oKvMeoG4qmRjLGjPN4RNc3N + yc72bcAXgPGGXXudq5wAXgUmZ/0JsxIR24F0T4CfnfFHJjzJmey85gtUA3cDB+d8zdACCHFg977Ygd37 + 1gJv8H3/roGRgS1+4BmBDBZ8rUwQcDztitNecP2AL+/24W0SdgBrkp3tsav4NvsoebDZN6NRBtEm3SEo + Zo0BTPqSjA/+3IZAJSolmFiuysEhAVw+bAP+DHg47WZveuHkQfzAX9yVJMhA8pVRjx+m/JWZQN4H/Avw + EWBbsrNdXI03uKej0e/paHwWNTBkFgugBspep2YHiMjspoSEA5OqHmAONKDkwtahWoZDFyDEeae+qRfG + zwJ3AK+f7i8WGjUa9wJeyvp8eQIerrDrEgZvBlqAv0l2tr/YsGvvoav01g9pS2D9rD8Ru04ZDLlDs5oS + fVnJigjUX3rc2K2oeoCnQwIIMX3zV+gNeR+qeKSoijKOhAFP8nxWcn9CxuqF2JQQbELlwiuSne0R7Z8G + Dbv2BlfR7Z9ACYTMTgCRLeAPz0oASBhwlErQPLADNaAkJIAQ584Y4Hrg06ho8UWR4kLtdGEIRiWM5QKe + zfpsjxpcFzEAOoHjqPbYnwUywNWUKhyb0w0AROJmCCaQk9+fbf9zMiOZrJjXU3ojajjJ/xfGAMKT3ziw + e18F8JvA/wCuRdWPT6GmrIrta7diGuYid77a/MIUCC1j+61JnyfSPn1ukHctVqNGW30d+GCys/36q+gx + 9AO9c6/8arDWQOTaGduEA2DQlWSDeTlqK4DNbnfTTW53kx0SwNW7+SNADUo/7k5UtVjiwvtcES9j86qN + 2KaNIRb+CIQQCNsAce50OutJjrqSF3JTBBAFqrR/ei/wpmRn+3XJzvbKq+BRDKEKgua4iRaYVXqAyMzP + YCAHmfk5ThFUXcBN+u8hAVylqERF+z8B3MMs+nE1FTW0brmeRCSBKRZhBZgCI26d50PkJLzsBHxt0r9Q + 1joBvBP4A+BhYMNV8BxOA0cufR9r1TRhcfGhHUg4mpaMu/N+zTXAWy609pY6RLhni3Lym6jS0E7gAWAT + Sn3CmNm/lEgp+fbTj/H8iRd57vgL82fsiIkRMTDL7fMsgDybmwJ+vtLixpjBDVHjQqt2FDgMdAN/Cgy+ + FsuIW7p680Q8d1BOeiAdZN8HwB+asTz4VzYYdDQYbIhdcqv4QFYT/zG79fBoaAFcHZs/gRKHeBdwC7BR + m9/G7KwrMIRB09otbF63jTVrt4NhXrShL/L7LQMjYiAiM/9sALgSenIBvY5k+PwqFgPVJHOtdgseBm5I + dravfA0+liwqEzAJeHO6AUYCIutnVQ6e9GB4frWVJirQu41lpBwcEkDhqNab6iOoVN+8C0K2rr+G6665 + mW3X3Y8wIzCHOyCEwLANjLiFEZ3bbXg+G3DICehzZwxgrUClJv8QFb2+5rX2QHo6Gh1U5mOI+fTrR7eB + tWrGb417MOQsqGLjFqAxJICr4/R/nd5I/6b9/wUHgLbX1fMLO1pYec+HKWt6E6Jqw4xmv5mwsKqiCGt+ + j2xvxudTwy6pQDIDD5j6/X4M+Fyys/2Tyc72Na9BK2A/Kj03tx9c/kZEbOYkyYAjOZ5ZEAG8Dbh5udyk + sA5gcRu/HlgFvBdVC1672HiKbRiUC8EdDXUc8LdwRFhgRpCpJDjjyuyPmjrqP//r5iSMBpKfZAK2RQzW + 2WKm+E9cf457gOFkZ/uLwE91bGC5Fw4FKJHQ7KWN9yo1QsxqAC95kQswtLD2qhUo5eBrgVeWeptwSACL + wyq98X+10AuZAkwhuLe+khRbeMVqgMCHwEE6EyrolyeABcCXigR+kPapMMRMBDDdhbkLlcbai8qhj7LM + pa60739auwKXsIPLVQzAWg3eANOLtCd9GHYXtIergLWoIrBjqODgkoUZ7uUFn/4/B/wa8NFiXrfGNokZ + glrb4mV7Fea2m7Gbb8bInEAQKFJYICRw0pM4SDJScm3EuNTJdQNK8Tb9X2/ZxF8+e6Jv2TL0z/+2gQrK + 3cx8SrBFBGGvhvQPzyOAMQ+ygeA9axZEwBYqEPi1T3x2aEkTQGgBzH/j16HSezuB60rxGqujFrJKyEcD + Y9CrtCsCuyaG6ED2vYgc7oPx5KKue8yVQMCtMUmFIYiKOQ+EGEqncEOys30j8C3Aadi1111mjyxvAcwv + zWlWnlMODjIgzxlAXqBiAZWWIDo/HqgFtgM1bnfTmN16OBMSwPLe/GWoxpI7UJHzUgyFkPUR06mMmE65 + Ee1NV5Y1OlE7SnWt0gqUEpkZB88BKVlIL2GfK0kFcNqTbLAgYorZwgkGKoV5nz41VwPPAwPJzvaJZaY/ + 6OsYQJqZlIJncgOMcjVQVMrzCMBHMuhA1GC+BFClv1YC7rzckCuEMAswP/wh8Bngf1O6iTDjwFdM6Bxt + qHnYiUW+iRCTRBIYrW/BvO+DGLfuRNSuB2vh1aYTgeR/j7jszwVk5lfffi2qVuAx4Pf1ibZs0NPR6PV0 + NJ5EpQJT8/7FsvsvGiYqpRoYMs++gOnYieoUDF2AZXrybwTeANxP6UpoPX1K/AXwglDtu4PA9/T3fwmA + SAKx/gawoojBXuSJ55Hp0XnHBnwJSU/1CpgC7ozPO/yzAiWBvSXZ2f5Z4HDDrr0nltFjHEIFNsvn88Mi + th3pnjz/AUk4m5NsSSw40XM7qvIyJIBluPlXoKq63qJ9/lIIPwYoAcuzwL8D/Tt2tg0BtHT1Pq9/5p1A + GVYkImrXgR2FRBUyNQxJH5y0cgsu5V8AEwEcdiQxIbkxBlExLxOwTJ9i21HtxVaysz0HJAHZsGuvXAYE + kGQ2peALEdkAVi0YcRUL0OTZ7yi14AXiOmC1291UbrceXpKagaELMDs6gf8GvIPSqb5Ootp1fwE42Kw3 + vzZhDwKPoqS+pmbeiYp6xMYbMV//IYxt9yLqNy/oBV/IBXwv7bMv6zO+MJPW0K7Ap4A/RxUSLYfW18PA + gXn/tFmnWoRjLVP/5Up4aUIytvAIyGqglSWs3BxaAOef+jFUaewHUC20a0to9jsojcBngd7mnW1yFoL4 + N1TdQQLVcQbCADuG2Ho3YuU1yNXbCA4+Drk0BJdepaOB5KsTPtWGIBGBiFiQabsRVTvwj8DXk53tzzbs + 2ntkCT/WJGpYyLwh7NUQa0Gmn5qyAE5lJVn/0rHEGdCEyqp8MySApbvxBSoFdg2qlvvNlE7oMaMX5VFU + gO1k8862sVl+1kHp3PegCnU0AQgQJqJmLcTKIVaGGDqBHOuH1BC4c2e+coFqHT7qBFQYBhvtBS3qSpTU + WQ2qYMhMdrZngYGGXXuzS/DxDuuYyvxh1kJks2oTlj6BDBjzIB0oa2Bht4vVQIvb3RQFPLv18JKqCwhd + gHP3oRz4DVR9/DWUTuX1VeBLqO7B7uadbbMuzp6OxqCnozFvBfzTjD8Ur0Ksvg6j/QMYO96EqFo1d1eh + DjxkA/jGpE/X5KIqfoW+Xx8A/gr4ZebS37uyOIMSCF3AsbgKYtcrIjCiSJQ24KgDo+6CQx6rUAVWq1mC + A0SuegLQZv9m4G9RvfylMvtTwCsoYY5/AiZnMftnW8TP6Pc4Y3WeiFdhbLkV4/5fx9hyB6L20sVvpz1J + Ty6gK7XgeMB01ALvB/402dn+O8nO9vJkZ/tSqjAdWbAFAKpVOHEbWOe6pYdcSf/i1BNsVErwmpAAlpDZ + f2D3vipUa+z9qHr4VSU6+VP6FHoMeA443ryzbd4hpZ6OxnzU/bvagpi42Gy1IFGDqNuEWL8DsWqrChDO + oTOQlTDgS/ZlAoZ81TuwSDdyA0pj4H5UyrAx2dlevRSec09Ho4sqBhpiLm2AmbZGdCsYVVP/M+7BiLuo + myRQ4+BWhQSwtOIfjcCvowp9Gildkc8Z4Puo/oFXm3e25RaxkEd7Ohq/gQoaHp9ztV13H6KlA+PGt4AV + VSQwm4PsSx5P+/Q6ASN+QRm9TcCbgM+hWmKbltCzzgIvspCCIGEg4jeCVX/uXrmSgcW1SAnUTIj1IQEs + jdN/Jaqb759RAb+GEgag/h3VNfhxYKJ5Z1uhQaBP668J7c7PvOIqV6p04ds+hrHjQcSKuWeQ/tuExzcn + fdKBLGRgSX4Wwu8Bf5XsbP/9JWIJpIGX9Z/z37NmHUSvVfEA1JyAU9lFE0AFcIvb3fTgUjsFr7bNX4uK + 9N+GKneNUJquyDOoHPS3gQPNO9v6i3jdl7Q78Aa9sJjRJTAtFQtYu11ZAkIgJwYgd/FBeNaDXjfgJUfQ + EjWJiEUvdIGqgc+fvCeTne0v6w2YukKFQy6qMWhh57ewENYqZGQjZF9k3FtUEHD6YbtOu5yPhARwhfx+ + 7a++A3g3pVVwPQg83ryz7XNF9mmzLV29h1F9CS2zEsDUE44iNt6IWL2VQAg4+jRyBgKYDCS9LnwvFbA1 + Yiy0NmAmrEQFVdehOgp3ca4x53LD0bGThZ/f9hqEvxXJtxl1YaiwnsgtM8ZvQhfgsmz+7cDPaZP83Zfc + OIvHBPB/gT8G/meJXmME+DHwr8Dj8/qNSByj9a0Y930Q4+5fgvJaMM8v5Et6ku+nfZ7KBBx3iyYI1KRd + oMeBX0h2trdcIRfgxYW5AHkC2ASJm8GqZ9SPkMxJJr1LTg2eDY3A7W5303q3uymxFPaFdZVs/utQc9zv + 0yeTRWkk0fOm7r8Dx5p3tpWkDbSno1ECbktX7w+1C7MD1bRjzGmd21FERT0IgbHtXuSpl5DjSUiNgA4o + OBKezfpITOpNKCv8iDBRNQNRVF/FmmRn+2pUUNRr2LX3chTG5F2AhSfxhAkiBtFtyNzLuHKQYRcaDKXm + tIh7kUBlTJ5ZFCGFBLAo3KTN0f9U4tfpBh5p3tn2pcvxoXo6Gh9v6eqNAx2o8txLb9dEFSJegahaRSC1 + zoAmgDyezATEhKAlapAwRDGY0tRf79IWwTXAU6iqSP8y3CcHON3S1bu4LL6IIGI3IN0z+HKQAUdSYwti + iyPHiD6MjrPQAqWQABZ88m9FtWT+fYn9/Ungt4AfoYp9LieeRLUMfxlVKnzpOgZhQLQM49aHkZNDyKNP + E/R8G1LDyl4O4EcZn0NOwN+ujM6lILQY7EDp5bUCu5Od7d9q2LX3xct0r15AFS4trEffiEPFGyHbTcp9 + hX1jAauiBhXWom5MAngf8ASwL4wBlG7z36VPxndT2nltL6A6+p4DBhdQ3VcsZFDNLo+isgMLONkEIlqG + WLMNo/k+xKY2iJaBEGQDGPQl3dmA017RP5JAVVzeD/xysrP9rmRne8NluFf5YSGLeMdRsNfhWRsYcGDx + yYApNeZr3e6m6670PrFegxvf1P7m6/QCe2OJXkqiCku6gW8172x74Up83p6OxiyQbenqfUyf/jewkDbd + SBzRsEVt/ESNigl4DrnAJ+cH7MsGmMJgpSWKnStt0KbwDlSVYzbZ2T4BZEuYKpxgUVF4ASIC1ho8uZFB + pw8vKIgAoqjy8+2obFFIAEVEG6qX/13MUwVmEcjpk/edwNHmnW1X3Jfr6Wj8WktXr4Pq0nvrQq07UbUK + UVGHcc0d+M9+FfqPIPuP8OUJj7HAxAZaYkU3GGOo8thPakvtKeCjyc72VIlESF/RG29xOze2A0cIjow/ + QarwyMVd+hl9JXQBinf6v1Vv/Ds0y5YCWVQK7q9RhT4jS+kWAJ8HBliMEKUwwYpiXHM7Yls7Yls72DGO + egaPpn1yUuKXzsHZoC2CPwDuKJFLMKCtjUUelyvwrTWMBRX4hdtDq7UbsN7tbopdqQVjvQY2vaF9/GpU + vfXtlKYOPS/F+ypq6uxXm3e2nV5it6MP1fl2HFV3vrDApxCqenBVE8SrIFaJTB7jjDPBpJNiwJNUm1Au + SjJUegVKSbdGfwaZ7Gz3gLEipgoHUE1BizwuKwisOtKinkzQjytzC9UGmI5qHQfZrOMSV0RL4bVgASRQ + ab7PoqKrt5XodVztP34A+EzzzraDS+1G9HQ0Oj0djeOoWvzvFnItUbUSY8utmA/8BtnmNzBYuZrPjnrs + z5V0YpilN8UngS8A/4W8CEpx7s8BlK4hhZCAqHiQ484KjqcLNodqUK3U667Umlm2FoA++eP6Bt6Fqu8v + leDCKZQ+/ndRhT4TS/32oAptyimw9kFU1MOWO2BlE4dfeoSNzhkqckNcHy352VGH6qGvS3a2PwN8FcgU + YWZhWltIa1mMpqGRgHgrg/4PGHJVM0mBh9etQL3b3RSzWw9fdivAWMabP4GKeN+nCWANxRep9PWCeR6V + 498DDDXvbMsu5fvT09E4iJqM+7h+/4sf6BFJIGrWItZdz9Dq7Ryr3CAPRFcEWYnvl7auP4FS1X2Ddu1u + BmqTne2F+ssOqqFqcUFGYYO1hhG/wh32IoUGKm3tqq3RLkFoAcwTMZRk999rH6pUdf2T+rT47yjhzvRy + uUE9HY37Wrp6DwK/ok+7uoIuKAyMljfz06Hr3WODR70bD/xLsMokVmGUfA1t1c/47cCHUPUWhZjxKVTw + 9joWpf9ggBHniHPtwCpvWEDv6gIP4HLgRh2fOBsSwNwnv4kSx/w51EjrLZSuwq8P+Amqi+3ElQrSFIgc + 8D9QlYJvogiCJ0HlSnsiXsGuiNX386d+KG8efSVC6YUuLO3efQzoTna2Pwp8aZEipHlptoKmH/eLZvrF + JNBbjM/3Ov2svhMSwOybP6ZP+tcD7dokLEWe30UJeTylzf5ngUzzzrZgGRJAoN9/i7YCbi34inZMuFbU + PLhyh70/N9i/ws9mGyf6ctqMLVWHm9Br9TpUejcAXk12tr8KnGrYtXchKc8sqjGooMxCylgbnRDrA1S6 + NVqgO70euMbtbqoEUpdTOXg5WQB1QDPwd3qhlWooxbje/H8OvNy8sy3FMoXuGuxv6er9Fir/fWtxtqMw + /UTN+i9u+08Hnlh3+0v/5wcfnUCNFb8copeb9Vcrqojm81xCIu0CZIBjhVp0rrluxYQxnJd4X01h5ear + UZJqm7V7ctlczSUfBNTinVuB30T115eXkLie0gvqt1B19RleGziEEiT9BgscknEJ3HWqbOXr/+CW3372 + RMWaP0al7ya5DB1+2v37APDlZGf7/XqU+XzjOodYbBBwuo/o1Q1+Z2LrI5nALkZWaBXwn1H1EKELoDd/ + GWoQxdv06bWZ0sh3Odrn/yHw4+adbSd4DUGrCA1pEqhHdcQVI3ZS7gtz9VMrW29emRn8yftf/uqTZV5m + DXAnSnehqoQfK6ZfowalM9CT7Gx/QRO3N0e60APGUKncHAVUjKZlwnkud8OpO8teTYNbVeB+ygcDK9zu + JstuPXxZRrEvdQugHpXq+5heVKUK+KW1v//F5p1t3+C1iRSquGY/aqJPsbAC+PB/bHpD4o9u+a0fAx/W + RHrqMnwmS7uDH0ZlO3bqf1tzkKHf09GY1nGegk7utCx3fug+OOQRSVFgUBEV32rTrm70ci2KJUsAB3bv + ezfwJ8AX9c0plc//Ax1X+G0W2k67vKyAQMc3/hYlg14s5JWAP/TCiq2/rl/jI6gCrT/m8vVK3IJKE34F + eF+ys/1SNTqvFEpSPlZiWK7ZPBpUPYsa31YomVWgMgKtV60LoFV7V6E62m7U5mopkNMn1ePAc80720Z5 + jaOnozFo6eo9rX3gp1FR9coiHSTXSMTwA2/5fAtw6LFv/WKvJtfVqLbXFm3mihJ9vIhez9tQ6k+1yc72 + bwInG3btnemkHyyCJRSVGKtHgqoXG9W/7yjCfdyBKlT68dUaA1ip/f2fpbTjp7PauvhR8862o1wl6Olo + HG7p6n0FJU1dXyQCABXF9lAp2jMNu/aeBfYmO9uTmszXo3L5ooQfz0ClO9+iD49+7frMRABntRtQEAEA + a7tz13/xpshMY8fiAAAgAElEQVT+YlVFtjHL+LdSQCylxXlg976fQQX8Sr35v4SSqv4SEFwBFZ8rjpau + Xgv4S1RdxY4iXtpDNWU92dPReDzZ2S5QAbsK7X7s0JbH5YCrrZAnUDLqkw279nr689+Gkof/7wW+RmDh + 3/TUmo41qNTxdQWuXQnsBf4IeKbU/QHGEtn46w/s3vdOVC//jSXa/B4qrfd1VKNMd/PONv9q3PzaEvCA + 76EyA1mKV9dvofszWrp6Yw+85fOgAmTjKLn03foZZCl9utBG9evcixKJ2Z7sbK/R30sWKT5heJh1Pc52 + F6XPWGgwUKAyG20lPgSXBgEc2L3P1ubju/Tpf30JXkZqn38E+Jo2+18ixPdRHY7jRd6M92p/uBIQDbv2 + +g279mYbdu39GipI93Xtf2eZY7xZEV2Tu4AP6k21MtnZbk+LARSD+Oqfyt3ka789V4Tr5Qkg9ponAFRE + +s9QlWSlKiWdQI3k7mje2faFpdjLf4WsgBSqueaDKKGTYuEaVO/BR7kgiKsVgL8APAR8hsujiRdBKQ79 + H1Rb8Yce+9YvRjTxjReBBJq+knqrqd3KfgovINug98OaUg8QuWIEcGD3vjUHdu97L+eaekqBvNn/GVTQ + 61S47S/CJCqF9QTFTYPWa1egpaWrd90FJCBRga4u/WyeRnXDXQ6s1tbmLz185Ju3G17uNMhCrZ+GlExU + 6bX2chHXWStqmtBrhwAO7N5n6FTfNm3yt1BE1ZfpwRlUBPikNvufbd7ZNhju94usgExPR2Mvqgz6QBF8 + 2DyqUEVcNwObWrp6jQtIYBA1Hec/tOl8DBWVDyitzkANKtf+js0jR1srR/smhedIgoI4oM6RdpXdejin + SbRYUnE3aBemZLAu8+bPF438tT75N5fw5VJ6cf0v4IVl2s13OfEFbb42oSLZxZql8DF97RdbunrHdINS + ngSyqJz37yY7229C6Tl+ktI2e+Vx54bT3f6Dx3q8r9/WaWVr1yOqVhXi8uStpy/p935PEd7jwzpO8u1l + bwEc2L0vqk39P9QPulSDINKo/v2Pap/vOFdmIu1yQ0Yv4r/X5FksxFFVeh+5BKn0orIS/w1VoFVycYw4 + 0lhj+DYvfFvI/d9BHn16sUtltXZ50K7Ncb0GC113tcAGt7up2e1uMpYtAeiTf70299+sgxyl6OXP6VPs + Wc2azzTvbBu9WlN9C3QFPG26/kAv3mJVRlrajH0QWNfS1TujelPDrr0jwFHgm6g8eA8qVeeW6jPHBKLO + kIZx5pAalNq3Hzl6FjLjECyoF6caqGrp6o3cfPo74/o+Hi4SeTZoi6wke9W6DJvf0Gb/b6BGdV1bwpc7 + oQNLfwKMh2b/gklgAjjU0tX7GVSU/l1FunSd/voVVN3B92YhgTwJfSLZ2b4ZpQq8U5+wRUfCEKy3DEwB + cuhV5NCriOFTiC23ITbfjCift4paQpPAGm0BHEFVmbYXwZXaiKqk7KIQbccrQQAHdu+r1x/gI6i85poS + vVRG+5L/D/BTVGQ7PPUXj0emmba3UbwW7IcBv6Wr93hPR+Olyq/PaHekB1VT8B59IhbtJIwKqDUFMQG2 + UPP+5PCrkJtEnnwBo+3tiMqVkJiXXmeFdnHPolKq+ZbjigJJYL2+RqXb3eTbrYedZUEAB3bvq0AV9dyE + KgypojSFDUP61HgSpeF3onlnmxfu4YIsgVMtXb0vanfgRgqXvMpjEyqyfVdLV+8JINBdijNZAxngULKz + 3UcFwtboQ6SSItWLGEBEQLkBE4Ee+JlLId0cpIaRJ/dDQxpRsxYqLxmyiuv3aNith1NAyu1uOonqTagv + xFDRXxtQGZKBJU8A2uffgmoJfQelU+1Fn/jfbd7Z9hfh1i0qulFdg+9Hpc6KRd53o7oDv6Ettzkr5xp2 + 7X0l2dl+AiXJ/neaBLYW84OuNg3SQUAq0EZj4EHOI3j2K4i12xFrmzFuvqQ3VK7X/PTsxWP689YX4W2+ + HhUcXdoEcGD3vjrUpJN/1KxVqkqmcR0s+ju9WEMUF472Of+7JvF3Fum65ZpMPqJdjSfm8TueNqc/hiqO + eQj4hWKR0paIYEKKGcegy+RRGDtDMHIK0XQ3rNyCiM3YQFmLqnmYTgC7teV7exHe5ru1W/HkkiWAA7v3 + NaKEO3foPyOURsJrAJVq2QO81LyzrT/cr0V3A6T215/VJ9v1FCeAa+qvu4ETLV29R3s6Gs9cwgqQqF6F + fHehpX3jTfqQKWgiVJUpSMzWF+tmkb4DZw+rWICThpXXIspqwLQvNNXXcX6H7XHtng4UwQrYCKxzu5sa + 7NbDySVJAPqhvhV4YwlPflD143ubd7b9fbhVS04EB1u6ep/UJ1wxMzj3oKr/+lABv3mhYdfeXqA32dl+ + BlVJ+nDBBGBA3JijMz4IkBODyJe+Byf3Y7S+BdbfoEjgHMo0IU0F/OzWw4Nud9NxVHlwoQSwQpPddRQy + 4bgUBHBg974mHdz5a30jSqVpNgZ8WpuOB8LtednwQx1reT1KsKVYKk1vA25o6erdD4zo5qT54jlUuu3z + wN9oclpU3fx6S1AznxCn58DoaYInv4BYdwNidRPG1rvBjoEw8pJelS1dvUM9HY3ZaYfVV/XhWCiagZ/R + rm9RYBRh81+LStO8TbNUUVM103AYFZX+AXCseWfbWLgvL5sVkEFlW/boU7tYqagKzuW5FzQht2HX3hyq + d+A4qtfjUVQ/w4JRYwrKjflo40gIfMhOIIeOI08fQB57BjkxAG5G6HVfy/lB79OaPB0Kb7leCbS53U0V + bndTUUq1i2EB3ISq8vrZEq/DZ4BvNO9s+364Ja8IJPCvqIKXrRSnV8BGBck+iOqgO7RAEvBQAcJ/SHa2 + vw6Vf19wwG2FKShb6JE1cgo5OUwwdhYjVo5csRFhx0Gl/ZLa78duPdzndjcNojIecQqLia3VJLBCk1/B + RLzok/rA7n03HNi976PAZ7VZUiq4wK+h5Ku+Fu7DK2YFSOAF4P8FPl7ES1uooPEvtHT1/loB13kSNTjm + TtQ8xwWRSZ0p2BE1FqaR52aQQ6/if+fTBI9+mmD/dyAzdisXt7d7qIaoQ0W4XyZqgEhRZNWMRW7++1Gp + mDdon78U9QQ5YJ8+dZ4BzjTvbPPDrXhFSSBAlVv/VC/m8SK6otuBe1q6eje2dPUueP6DHgTioJqKvgP8 + G6qKcF6uYlwI6hZzNksJvoucHEKeeJ6VBx5p2dj9tS0XjDGXqJbnYukEtKGUsy+vC3Bg9z4BWFLKN+qg + xp0AQpREW3QSJRTxb807254Pt9+SIYG+lq7eSdSAkbj2d4uxALbpw6QJ1dGZWSQJnE12tj+G6mxcp99f + +aVM75ihXIFFIzWCTI1Q4U+0VFrmfqAy2dnu6PcUaAvljfrvhcTIhHa7u9zuJsNuPVxQv4tYIAG0Ar99 + euD0233fnyqQjscSlCfKiUWKEvx39MN/E6qs92y47ZYWtLhHJUrK7R0Ur8fDRQXNfgv4Xk9H42ShF0x2 + tt+HSjl+eC5r9bgredkJ+Ksht6BIXZ0leCBhTvxqtTWMSlGe0BLpuN1N/wU12r4YhUH/BHzZbj28p6QW + gO7miz7T2/3eJw48fWsulbnV89yEnFY0ZVs2kUiEsliCiB0lYkdIRGMIIaasg4gdwTRMJGCZJoZhYBkm + EolpmFimhWEYWW1ePo6K7k6E221JQmqS/hEqkPcrRbquiYqiv0H/vRgxnyPaB7dQ3agbmWEAZ1RApSEK + 7iBLBZKMlNGclLVRIT4MdCc7259v2LX3O3pNP18kAtioLYHSEcD3vvaYeeDUkdjEyPh6V/g7J9OTN/ed + Olnl+T5yGgMIITAMg/J4GYlYgkQ8QVVZ5dRGF8IgEY1jWdYUYViWia0rqSzLImpHsSO2Jw15Mmd6e4ej + E14gZKKra09Mm035L4FKp+SJOgBkR8dDYQPQ5XMDJJBr6erdp83Zn0UVfhVa9ZlvHb8T8Fq6eh8BsrM1 + DM3TLehLdrYPoaLm+WKcGBekqyNCFQQVikwAjiSSCYhETR5GFe/UJDvb9/mjA0Nmlbcfga9fuxDXaQ1w + g9vdZAKB3Xp4UdwlLkEAG48cPPy6/jP9/zI2Mmq47vy0GYQQighicWLRGFVlcw+fMSwDM2pTs6UOK247 + ZsTKoCLOeX24E/oB5oNOJ1CyzhM6VjDS0fHQ0XBrXhF3YCXw6ygV22uKeOkjKHmwrp6OxqJVviU725uB + X2WWUdwPnMziFWgGvC5u8q4KkxtiRp5hAm0t/WPZvaPPRZoy30HpI5QV+HEGUWpLg3br4UW5S3NaACeO + Hn9XLpt7cGJ8Qvj+/D0jKSU5J4fne6SzaVKZFDE7RsSOEIvGMA1jyjUwIxaRihiJ+nKseATDMvITX7dO + Mzc36NiAMy1A6HKuuMLp6tozrgktp4liZBqBHOKc/nxafy9PJhNAqqPjoZFwOy8KY9pUb9Gn98oiXbde + b9JXW7p69/d0NBarC+4UKiU3ojfPfdoaEKDSgROBJFVAaG0ykJzw5PRxSwIV5PxA+umKNxkV6YNmrbhB + RAsmgCgqGP9jvSeKQwCP7n7EACoOvfTybbls7rZcNrtgU8XzPTzfIwdkclnKYi6xSAwpJBHLxjRMTNPE + SkSIVMSI1SYwTCNvBhosXjMwox9u/zQ34af671LfqH7OSV4NA+NdXXvyC8zTJCKnfeWmuR8ZzleudTo6 + HnKv1t2vS15faOnqfV5v2roimLdoMrlNE8s4RWqDbdi1dwx4LtnZburDYCWqjDgOROpM8KQgVUA0IC1h + wJPTb4DQr1ONI3bkjto/juIGRpXESBTkd5ioDsSXURWaRbMAEsADfa+e3JROpQseHhkEARPpSSbSkzAK + iViCskSCmtoaGjbWEC2LIcyipRLjnBNnyOPmBZ5o+fZiFyWQeZBzfev7OT9NdRQlPX614x9Q/RmfYx5p + t3ku7nLUSK+NqNr/oqFh196nk53tLwFfRvUSXA9s2WApbYDBAlIBWSkZ9CW+hAsqjKPSF9Hc/sq3+ckk + 1poMidsLksqIAm9H9Wo8WzQCGB8fLwPeZllWSSS8fMMna7iMWxnk2VPEE3HKyssoLy/HNM1S1RXMF2Wc + G5YptUWwY5oLMaGtibwVkO3q2pOZZinkdIxCoJRsTl1gNRyeRiYDwGRHx0OvhWzHqI7b/E9UVmBdka67 + Bri9pav3g8D/7eloLOYY94y2Bj+u3YG7V1riPac8IQpRlEsFzKgtkDcGhGHjDVj4Y5JgbITo9QnMFTZG + bMHWQN5Svt7tbjpqtx7uLgoBuI4TQbJVGEZZUZeIEBimgYiaEBV4hs9EahLXd/H1YAbLsrAsC9u2dQbh + spOBxeK73XLaOnh12gLLE4CnSWGdJgahF99EV9eevIahMy2uITgnhCEv+P70eIbf0fHQFa+Q7OlozLV0 + 9fajUrhv1Kd3dREunUD1/j8AfL+lq9fp6WhMF8kK8PWz+Wmysz0L5GLR+K3Sc+pw3Brk4gIBWSkZ8ueg + EGEgsxYyY+FkUhgVJtKVWA0RRQLz5wGhrd1GHWMoDgHk0jkLWImURW3rNQxBpCJKoq4cM6pe2vc9UimP + VCrF0NAQ0WiUeDxOQ0MDkUgE27ZZRojqr5pF/v4ZTQpj0wjk6WnkcgYlOplvNT2kfza9FD58T0fjGPBE + S1fvo9p9ureIVsC7UINeBMWpqb+QDA4AB/7wk5+oSB7peSvu4AM4ixvxlwpUPcBc9CGsBNL18UeHSP94 + HLMhQuKOCiIbooiFWwI79EHxpWLFACSoMueiHatxGzseIV5XjmEbs8YKstksjuOQTqexbRvbtqmpqSEe + jxONRnmNow7VHTe9xmHHBRaGN80CyAFuV9eeQJPFsCYQQy+IMU0YQm/IY5o8HB3b6OvoeKgU5PFFVIpq + mw4MFksV6veAf2/p6v0LYHL6lKEiYvfY7e/dbCIeCJ76InJiCLKLa3k46gSsssSMJcbC1O0ORgTpe/hJ + h9Tjo3hbE1hrIkQaowjbmG8odRsg3e6m1cCI3Xo4WxABWLbtCDgGsoxClX2EwIyY2GVR7LiNGZl9LUgp + kVISBAGe5+E4DpZlYZomjuMQjUaJRCJT/2cYxmuNAGwuHolVtQB/dkyTgNQbPMW56Lmvg5VZTQYZ4KyO + X4hpxOBwrtIvNe13/WmWidRWhzNLAdYpIK8q/BaKNwRmC0ql+HWo2QJOsR/Axz/6B/0t/3FwSPjeuNh4 + UyVDJ2D0DHJk4X08A76kwhCsMGd2AxAWwowhvTTS9fCHPdy+HNINEAKstRFExEDYl2SBhCba7doNKIwA + VtSvyALfkVI26FNp8fvfECrNVx3Hii3MnPd9H9/3SSaTGIaBaZrU1tZSWVlJPB4nEokQYgr57Mdiu8TO + oNKnA9M28ZG8W6sJoecCMhlkhvxzT0djpqWr9wXgU3qzlhfxM7ahxoc9WQoCUDQcG8HmhHHru3fIvheV + 8MdzC69KPutJGkzJbMe4EAbCroDAQfqKR92TObyki/tqjrLX12CtsBD2vAyock22Z/RzKcgFGAX+AcTd + 8Xh8eyazOF8oWhnDLo8SrYojjMKCeUEQIKVkcHCQ4eFhLMuivLyc8vJy4vE4iUQipIAC3WBN9o2cK7d2 + 9N+DaUSQDz45ANr9CDRZ5Iup0gGHxhzE2d0TscNnfNsdlFajsKNTe8EsW3R2uV5bRe9t6ep9uqej8dkS + 3ItxTYA7xKomxIr1iIYtBAcfR549okaHzQOvupINc515wkREapDO+R3L0gnwhySTjwxjrY0SbYoTbYpf + KjhYqeMk32ABY95nJICH3vPmABj989/9swOO42xynNz2IJDn1f9fkkTLItiJCHY8ki/wKRhSyimrwPd9 + hBD4vk82myWbzRKNRqfiBlc4lbgckVfrnb5kF5IFik1zGXIGcjKGHLrRzq6Me7lEJgUTGFNxpSCdOs9N + FKapzGJQfzcM0M9QCANh2efepxBxYdmvB7ItXb3Hejoah4p8LybIC29aETAsqNuE2HAjxCqQfS9BehT8 + ueu/JgKVEZjLPcaIgBmFIAeBO+VgSV8STPj4/Q6OAcISmDUWZrUJM9fMmKjS5s1ud9MRu/XwyUUTQB4t + ba1Pne47VTY+Orrddd15BwWFIYhVJ7ATkalof7ERBAHpdJp0Oq06Cy2L2tpaysvLqaiowDTNcEtfXqyd + 6T93xAJENsfpVJrhSYdgpjVkmhiR2NQmF9EYwrIQhnqGwrIx42XnfGfDwDStdyDEGKpAqNgEkB/wqQN1 + BqJ8BaLpbuTKawiyk8izOcjMTQBjgcSZM5MoEIaKA+A7yOD860lP4g24eAMuMu0TaUpglMVnK5rLpwS3 + a+tlXgQw5zG554vftl3XXet73i/ue+rZ96fT6Q2uO3vTnWEaRCpiRCqiRCpjl/0UzgcFhRBUVVVRVlY2 + 9RVaBFcOTiDJ+JK/PDjEpBvM0mwjLl6N+XocAWLqm3LKMigzhVtli+xvNtW+GDHIRQRpHaA8Nm0DD+rg + 5Rm93sdRbbmTs9VPtHT1bkYp8H7zYjM0AM8l6NuPPH0QefBxcHPMVDNgAu+tsnhf1dyHoHQnkO44QXqO + QKMhMOIGRplJxdtqMcrN2cqIu4G9duvh3y7YAnjoPW9293zx28O2bX8/nojbdsS+3o5Ebkyl0is937MD + 3xcSkEKCACsewYrZWDHrimy4IDj3EDKZDJ7nTbkHtq00C2Kx2BRJhLg8sIQgYUJzZZRX0y596ZkOEXlx + 5Uze5JQzF9U4UtgTUtiHx3Ob18Qtd1XMdKfFCfLFVSkdwMwXVOXVhHM6fiH0iZkv1BrrlcfLeoNo7SOZ + hLJC8tWpQrklwo4iatYihCDwXejbj0yPqaEh0+ADGQkjvqRmjlJ3YUYgiIIwNZHM8GkDicwFBIEk253C + Wm1jNdhYKy8KhK8C1rvdTVXApN162F80AWgSGAf2fu9rj52cHJ+4LZfLVZ44/mplNpuxHMeREimkgZAm + RHSwbynsrUwmQz54OTk5SXl5OWVlZdi2HboHlxmGAEMIWmqieFJyKu0VZXSzE0icQHJ00llZZgpWxaae + 60LnA/xkWsDz+GqyE3aQc781nsOIRBGWreMSFsI0EaaFqF4FZdUY5SsIUkMI30U6mYs2bzqQDF+CADCi + YLggLJCzJzakJ5GeJPPchAoK6urBCyynVajKyVodtPUX7QLMha6uPatQBQgPo1IztwB4nofv+ziOM3Uq + p1KpqSBeEATkcjny7cWO4+D7Pp53efQ8TNOccgvq6uqmagpCXB68PO6wfyzH3v7i1h/duiJOW22U7VXF + KRbLBZI/e3GIlBeQC+QssS4DYUUQIkCO9yNPvYTo6wbPUWpYhuD2hMWdZRb3JQxsw8AyBDHrYtNd+jlk + bpAgOwDBPLObpsBeGyF+SwWRTVFEdOq6p4CvAH9jtx4+XpAFcIlI6VFUL/hTmnVeZxjGemBNNBqtzm/6 + 6RtMSonneVMZhSAIplJ8oHL/04VHpJRTZAKggpHnMhKu655n+s/HTchms1Ovk88cxONxYrFYSAYlRl3U + pLkySvdwlqwvZ91cC8WptIshoLHMJmIKrALNUAOosg08Oft7lFKC7yGRYCWQKxqRTg7G+9WX6zJEQG/g + 0RQoN8IQYBkqtmEIiJmGCnNIH/woVg6Efj3LUD+TNx4sITiviDaQ+KMeuRdT+IMu0eYERrmJsEWlPpAv + mcVZNAF0dDyUrzQ72dW1J4pKA2UNw2g1DMPV1kUEsKPR+acCXNcll8udZzHkTXkpJdls9jzCyJPGRQ9m + hr/n/+26Lq7rkk6niUajRKNRfN/HMAwikciUlmEYJyg+qiMmZZZBXcxkMOeTc4pDAP1Zj0kvYKQhQXXE + wLIKe3YCqIoYTHhzHC5SThXwYEahai3S9ZDSQE6OQW6cURlw0hf0C3OGA1xQkS/yERIDm6gjMH2QSKKm + wDLAEuoNxQyJRJwnVOGN+IjJLGbSo6LWJrYK7HIzYdnieqDa7W6K2K2HnaK7AJdwD2zgzahZcreghB0u + SxDQ87wpAsmXE08niImJifMsC8/zpiwIy7KIRqNUVVVRVVW1HJuRlg360h6P96d5ZihTtGuaAjaXR3j9 + qgTXF+gKeFLy6JkUL445vJpaoN6L5yDdDMFP/53q3AT1Xopfrp7fGRhkh8BLI/3ZXaSRAJIBDARwWoIj + 1WdfHxG03RBn27YYt99TCfCnwPft1sOPl8IFmPMWoFR4zqBmtm1FKbtsQc13j1KC+YFCCCzrXAZCSkks + FjvPCigrKzuPMKZbE9OJQBNExnGcQdu2T5um6ZqmKXRwxdAEvBFVOGOFW3phqIkYXFth4wQB3SO54hwA + UlkCRyYcLCHYVrn4UnEDQU3EJLaYClbTQog4xrV3kRk9zcDoaeY7E0SYUaT0YAYCGPSh34ceF7JSfaU5 + J1U14klOHXJ4cjDgJ/0+999YefP6hsgQqkX78hFAR8dDEtUT/2pX1x5rGhm0aregHtXAUK7JQBSLAPIK + xYuKKmtrIU8EUkrP87y0YRiDQoicaZo+qujE1RHWCe36RKa5PKZ+JjbnquvQf1r6T23UEbtaCaDMMlgb + t3ADODju4AVKQacQSGDcDTiZ8ogagmvKbUyx+KxUlW1iL4YAhAFmBNFwDa4VIxAmvpPCcDIIz5m7zdaw + 1ReC6RmFtFSb/6gHL85i0I8Aff0esWGf3iGP1bXxpoxjHHts9wfKgPQDOz8nL4sLMIdrYKK03u5CyXS9 + EzUJJr4M1uyk3vyfQinfvNTR8dCo/lwCVZ++gXNiIg0oXYDV+fWESk9V6M+bQFVtXdXWQ8aX/GvvGCfT + HiNO8XRNaiImH7ymmhVRk/gi5OYkMJzz+dbpSZ4dyhb0Xiwh+XD1OIkjzxI9+TLSndvikV6KINMPgTdF + Anuz8IqrCGC+WFllUl9d9uSH3/eOjwNPPLDzc6nL5QLMaqXpwGF+tvsPNAFci0ol3qUtgqWImN7Uv44q + JBns6trzBEoH7xCq8uz4NFsvqq2AmH6Klo7KmtOsgYppRNwwjRwESgSjdtq1yjhXbhtBqe3ULncCiRiC + +1Ym+H5/mkkvwC1SViDtBXznTIr2hgQby6wFn+QCqLAN4qYgYgicAt6XRJCuaCCx/U5im7bidP+QYHIU + 6cxCLMJCWOVIdww3kOSA/Q6MLlCgaDQdEIvJpr3P7P99lMLylSUA7Rq4KNGKfuBwV9eeXlTp5pjeGNV6 + I6ydZjIvBVicm2TroirKEii113ptFYyhJMYXXJuu6yoqOZe62YDqzpOaFMpRcmJ5V6NWf9/SP1M1zW60 + 9c/Y+t/RaS5Jfo59+VK4qYaADWU2axMWw44/S5XgwuFKydFJh2srIlTaBg0xc1HkFDMMYmZhBAAwacWo + LVuDVbuCYKAPL9lHMDGCTE/M4MqaYMaR7jg5CUM64Ocu8C3kXEk669ecGhi9bTZ3c0nlubq69lRqs/g2 + 4Dc4p5Cz1OGi+tN/DDzX0fHQ16/AvbtjmvVUjaoIy2sDrNMWRr4Ht1xbXEsG/VmP4ymXf+0dL+p1r62I + 0FQR4aE1i5O3/H5/mn3DWY6nFq/8bgp40+oymquibCpTWSX32H68k0dwXnpqZgdESvzJ47zquOx34Kkc + i5pZaBqCiCo82nrop5nDV9oFuBRSKCWZE8Be1KSZa4EHURmENUuUACyUUs01wDu7uvb8miaDF1FlpkMd + HQ85JX4PL04LLprTrACmWQPWBe5I/r3HtcVha+tgk/6//Kmxaloso1JbaA3FfPO1EROB4MbaGMcmHMbc + oCjXPZl2cQPJhjKLTWU2ZdbCAsTVEYM1casgAggknEx7bCg7l1K21mzBqFmJuXID7svP4Q+dRebS585l + IRBmgnGRpdfLsdi7EQSSnBvwn9/yxvdt+cDaH7y/87OPLVkC0N1ZE/rrtB7Wkfepr9ULM11Lb+EAAB0W + SURBVG8aJ5bQ+xd6Y1TqjZJPD65B9Wgf0Z+lHzXGzC/BvVuUtLgOzMa0yxWZ5n7EplkUDdM2fH7cdu00 + sslP3RXTLJD8s4lfQEbRaS7JFGxDUGEbXFcZYdTxyfiyYLMbIOtLhh2fQ+MOKyImUUOoSrx5oswyqIoU + nrEecXxy09IcIpbAtKMI00JOjiIiMfzkSYJsGrRCtmdEyOIxFiw+TSpR6XDbMq/xA//QUrcALlzUfUAf + 8GRX155avUh/GWjXp235Enzbhian+/QXwBOowQ3fAJ5hiaj4TiPdFGpewXRrYr4EEkfVeZRN29Q3TXM3 + 1qGyIfk5fCs1SV7k2sVNwZ11cU5nVFXfQLY4PDnpBfxkMMPmcmUBVCyQAKrtwsJQEhjKKVI73z43MSpr + ibTcQzB0htzzP0CePobMqeKotBEjJTxSMlXwPfADv9Z1nYplRQAXYEwv1E+iJrnUAm9CZQ62oBqTlira + UJNnfgZVOn0QNSzy28BER8dDOZYvsqjJScY0a6iH8+sfzGnuhzEtIJknzJunuSarr6kp2xTEyxsnM2a7 + m8vZ0vcFgUQGHtLzkO7CvKlAKkvgu/1pTmU83rxm/udGhWVQHy08Dp31JZNewLgbUHmBKrawbMz6tcTu + eQfuKy/gn+nFPfYiJ4IISWnrNuHCyDCd9XZXVlQ/vWwJQJ9UPlqqSZvUcVRKbiNKwGGzPmnq9CJbKkHO + vGBnPsNRoU/MapQy72mUjlumo+OhzHLa/TqzcyGBzdvC0S5IMG09VldErCMRaW0yiFpWtOwmKWUVUiID + HwIfme8czVdxBuc2h/Tcc5WfMkD6/lThzZAHp7MBfWmXVTFrXq5A1BAkrMJdADmNBC4kAIQA08Ioq8Ja + tRFhWiAlY729pHOukg3zF7csLNMgaptMpFJHo9HY2Zl812WPrq49FdoKeI8Oxt2iN9ly0A1/CVUX8Wng + dEfHQ/2EoKWrtwHoAD7GLGPHpa8tgnw+XUr8TAoZBCB9pO8jc7mphh3pOtRbkrZKg7sbElTMc2MP5Xz+ + aP9gwZ/pzvo4N9bEuO4SJcoylyGYGOGLe77O8f4+To+cRbojLGZcWTxqUV+VANj6xOODSz4LsGg3T/ut + f6xP2irgbZoI7uZc/nwpYpsmr7cDZ7Q18DlUOvGVq5gDBlGTbm4A7mGGtKUwtW5g5FztmFleNXXinpMS + kueZJk8JeFn4H7qJ8VP3KjnBABX0zGvq5V2T9UC1YRi161dUNw1NpBJpx110d9iY43M2412SAIJIDKd6 + Jce2dTBYdRxOH4ATe7UI6cLyAYmauvSWu+7pF8Jwnnj8X3hNEoA2Qz3A6+rak5/P9xNUBuElVPHOak0E + W5bY28/7yDHOFei8E9jR1bXnpA7OHUWlEievlt3f09EYoFR/f6jvz7X63hgXmc8z/HsutneBAay2Z6j2 + rmPyiTqcnInMF3qdmUYA1UAiK8wVfnn1O0S0cmskkHVT7kUQgK+UxGQQKEtjmjZg4DjnyEcG5KSYu71Y + wwlgxJU4VpygsgEhJeT6YeIscjIJ88yOGJWVuGVVZ53qjXskxoyRxNdcHbqOFeRn6j2tXYS7gTtQQyq2 + LOG3n08lrtefYQj4KvAtlGTVVUMA0/Bd/efb9QldLLfuwRHszN/QuBsY14STd8kudEdqqWedAQ1RPShH + 6lhEPmIvfY8glz2nDwAwOT4Vf5C+S0YGTLjzIQDJYM4nMExEeR2ivA7pjyBPC0gPqljIfE6W6mpylbWn + D2z9wFeAFHyC12QMYAGxAoGqJbhFm5QP64Bh2RJ+2/nRMiOo4qjvAD0dHQ/95CqKB9RpK+6fNTkWCyeB + fcD75xo73tLVWwb/f3tnGiTXVd3x39t6m00aSSNZFpImsmzLNrQN2LENOAbi2GoIIRizFCkSPhDyIZWN + qlSlkkqKKlJQJCGpLJVAUpAQSJm1Aqm8BpNEYBvLBi9qgbFsD2pLo9E+mpme6e1tNx/Obc1ImrFmpntG + Lfn+q55KlqWe+/q9+79n+Z9zeACpA7mtjZ93Bhj5BAduZ1bP0q+f8Rodv1L7qmzdO23dNTLd3BYlygWI + 6zPQmEDVT5M88VlUrQaNCwODViaFs2Ez6dvehnfDAzNW31XfKhWGP7BgkPCVRACFwm7l+8UziG7/JFK8 + swup0rsRyVF324ihFkm3qgezwK2+X7wLKUQ6rN2EhnaFrkRUtRv0CFJSfkOHPneN/k7fkPfLz5UKwwcX + csuRYq9207U5YM0fcX3m9yhPb6TZZHYUW1rHPTjs9t822Ze520nHYv4DbhhAvAkV1SHrkFSnUNVJqOru + 57YNbhZ77auwBzbhXLUDUr1HaQ04MQRwlgSmEE3BAeB7WkN/yxy/b5BZ6azVRVZSWvvBO5Hc+ylER/Aj + fT+nfL8YAfECAzsv53hAHTic98vf18/lOjpTJNZKyd4BNPN++VCpMDyffR3r2EC7KdqMPvFzf8PwdKkw + fL6g4cW8X7ZJM0Aa1+lZ4Ca33kRSHUfNnEaN79fHhIOVXYM99Bqs3NlxnkeYO+DkZU4XA3ERNiJR+Q8h + asOhLrQIFsJXkXTiD4GHC4XdyZX4jPJ++Z1ItqeTvRQq+vv7e6C00NjxvF/+MvCeNn/WKf0Zz5UKwyfm + +RnX6njHpzpwXx8H9pQKw6veEuxyRUWb058H9iDS453AnUjJ79ouXvvrEEHUXcDdvl8cAUa0uxNcQVbB + c8A/AJ/Qp2knmjZmtWvxIeD3WTjhfhwpVNvWxs9qWTBHkNqQ87Gd2cKrdvECUDYuwOLdg7o28475fvFJ + /SBeo83vYR2A6mO2oKWb8HP6Asl0PK2vBjDp+8UqMvU5usxjBUcAH/gIEkjb0IHP9PTz7QE25P3ydKkw + PJ+a8bTetO0QgKM3+UJ65K0dIIAEyXaOatIyBLAMMqjqE3QE+IbvF6/SzP1+RLv+2i5e/vX6er+2akrI + zLi/1iZo9XJ9LqXCcBWo5v3yn2pT+tc79NGD+voTZCbgQ/P8nXEuElRbBFwk8LzQfPQ365hEO6jr9/aM + jp8YAugAJhC14T8h6ZtNwNv1abud2Wq3boKlYxg3ICKo64ARLTD6IbCvUNg9cZk+j6eRcuutzFZddgK7 + gYm8Xz5SKgz/dB7/fawDBNCyNub6/i0xWCesmmn9fGcWsxiDxVkEDW1On/b9YmqOGzCmzaydSFqph+7S + FXiasNZrF+Fa7cf2Aq6WHk9pggsKhd3h5fA8SoXh43m/3KqqvJPOtY/bod2+l/J++XkgmRMUnNBuQDuw + keBydp7nNITI2NsNPNcQQVPNEMDKkEGAKPP+BUATQgG4BxEZ3drFyx/W193anz2ozd3/QjQFpy6jR/Gk + ftE/iARoO9U+7l7t5n1Dm9Ot/P9R/R21A0dbj+f36FuLZJ460eNiEhGNTRsCWB2ESNOPZ/VLuAPpU7BL + +3MZuqe56fkv3U3alH4HUNbBz+8Bo7ohS7d/77H229+j76ETSGmX7s+RgqRH9J+/pC2pTmBb3i9fXyoM + H9D/3YtkIto9/RuaAEZYhG7BEEBnLAKlTcPTehDKqP7yx7TZuFW/UEPMV9By6ZDSVx8S2W516kkBh3y/ + eEi7C5NI45Kucg+0fj/J++W9Os5xI52p9bD1d/Am4Cd5v1wuFYaPlArDtbxfnkQCq+22pGvFkVoE0Oqs + 1O6wmHHgeKkwvKi6EUMAnSeDSJvW39IXvl8sALfrE6oTD3ml0Ook/FZtPp5Bcu5PAs9oIujGeMDBvF/e + o9/nP+zQx9pI/cFbtAvwOf3nEZJb39GmuT6EBGZbWKOtxXZdgAPMU9BkCODS4mG9ib6ApOd2aRdhN7PN + MrsNPZqoPooECad8v/hdfR8/7sJeBXuReoG3aGtmQ4c+9x7g2rxffkzHAOp6k21qc7NepWMx5P3yddqC + 6YR1WEIyJIYAusgqmEFSMid9v1jTZtqkPmVbEfpdzNYgdANsfW1E8uOBPgmHgJ2+X9ynLZ0zhcLu0S6w + Aqp5v3wcqY/YrU/UTnyXA/qkfitSmhxoImi3zfvaOSS1RbuJnYgTHdMuqCGALiWDo/oF2uv7xa8gQbhb + gd+ls5HsTsLT1xv1FegT9xFtEYx2yTobSMPYTZpQO0WmvcCH9XPbj2QC2i0MasUAQFLI13VoraM6bmMI + 4DJABanm2wd8Sb8E1yPdg2+gs7XvnSaEO5D6g6bvFz8FfFubnv8HnFiFQSjzWQEq75crwL8jUfC/6NBH + p/Tz+ACio3ia9tWUVzPb63AX7Zc41/V7NLaUtRkCuLTWgNKnaQBUdYfcGaQYZYc2DXdqX3Gwi9yD1nzC + FLPCpzuQdOIO4DnfL7ZM0cOrmT0oFYaTvF9+SccvnkHET52wqjy9UROVqGct22rXXHeA3I3fHLkOUZK2 + m15sIoVSlYWqGQ0BdD8hHEdUhft8v7hOb6j7EclxTxcRwPlkkOFcAdTD+jTao+9nVdOHpcLwWN4vB3od + fR10q24Askqpb1pYnfDXM8AtKLZhtU0ADeDHLEL8c/7DM+hS6BZmtrYIhjQR3KNPold38dJbJ1CsTdIS + EkB7ENETNFZ6AXm/bOuYyscQZd81HfroGJiKwji0wHU8Z9k1ICpRk/Vq8N+ZXOqttmNtanNdI/o+j12s + AMhYAJeXixBrMmjFC8a1a3A9ohzbpC2FdBcRujXn/RrUhJXVpu4RLTDaC1R01eVKkVAVGdLqdZAAbKAn + aEQzgJ1rY2yYUnhREG1VWS/d5qOrIVmlM4hOwVgAV7hl0KfjAu/VJJBHlIatFuPdPBDlWe0e/KOOEZzS + L228El2M8n55G1Is9Hkds+jIOz95aqYCFgPrc/2WtbyPjKMkmDpdPdo/mNvoppxsG8s5BTxTKgzfu1ym + Nrh8ySCFyFLvQwp87kNyypfDsz2KpKw+Czy6UuKivF/eBLwP+G061Ba+Ml4jbMphO7ChB3cZlkDYjDj+ + 0gQbtgyQ6WlLD/YQ0vrrk0v9h8YFuPwRISmgJ/WGelRbBduRNOJtXbz2ASRK/0GkjdmYtg72A8cKhd2V + Dv2cKSQ9eYe2jobb/UDXc4iCmJnJOrm+NJZl4SxhhmAYxDTrIWEjQrU/Bv0ES8j9GwK4suIECZICanUv + wveLLyJBwlalX0abvzntInSLddBKIW5EothnkLkHDtCjexXMAGE7E5R1UGx/3i8/jSgEt7XrJjmejWVb + NKoBQSPCdu0lEUAcxgSNiCiMSRKFUhcOOVoCjrPMMmXjAlzZ7oGlX/bbkfr2d9P9g1Dmntr7gK8ATxUK + u5/ogCvQi2RRPo+o+5YdwVOJolppcHRkHNez6V2TZf2WAWxncSRQGa9RqzSojNcY2rqWnoE0XnrZ5/Fv + lArD/2YIwGA+EuhBIvFrdWwgj6jZXq/JoVvJIEQi26PMNi75EdLpdj9QW2pz07xfdnUM4N3A7yCp1WUy + ANSmG4yNjGMB6axH72CWgfW92M7Ft9X40Qozk3WatZB1m/vJ9afJ9qaX8x2VgD8rFYZ94wIYzOciVJF0 + 2CiwXyv0Dmm3YVJbBGv05dI9GQQPKZbZoN2Dm/UaNyEpz0O603G9UNi9KPFLqTAc6YKhbwPvZHZQx7KO + TsuysB2bJEoIg5hapUnvmixYDrZtvaz1EIUxUSAzSOIoIYmWlQCJkazK1LJjGWaLvOII4SlkHt4X9SCU + 64B3Ab+sN1c3DkLJIOWzc2fcfRkJfLY6GC02HjAFPJX3y19DSod/abmLsmyLVMalWQ1kQ0/FzEzUyfam + yfTOH9VXSonvH8TEetNHYUwYxMtZQlPf+wlDAAbLwYQ2p48jPQG3IF117tMbbn0Xr/1upBjp/b5fPIDo + /p9BJkI3F1F/8KA+OVtdnZccD7Adm3TOI6iHZ0d2V8ZrJInCTTvzpwYVNGshcTx74kdBTBQuiwBi7QKc + MQRgsBxroFWINKlbhQ8h9eSejhe0hlT0I5r6bsJGfYFU1g1qwsohfRcmkch4oEfGn28JHMr75Z8AjzM7 + FHZJ7o9lW3gph7lCoKAZ0ayFNGYC7Q6cbwHI30ni2fBFHCVnrYElnv4VZpuUGAIwaIsM6jo2cAh4yPeL + rbFov6ZP2pu7ePkbtdVyr94U+5CS3b9FBnks1B77p8BfMlvJuKRWbbZt4aVdrDn+vkoU9ZkmYRDRM5Dh + fJWgUvL/42iWk6IwJgqXTADjwMH55gsaAjDoBE5qE/lnzAYJP6BdhJ1zTt9ugoWk916HVO7dC7zg+8Wf + IZWBPygUdo/P+ftTwPPA3wG/CLxtyTGAtHtB/j6JE4KGYup0lUxP6qzKTylFEic0qwFKqXNII4kkKOh4 + NouUFo9q9w1DAAYrYRGESJppxveLx5HI+xDSEHO7JoLWwNRuIgNHk0CvXl+/Pt17gEHfL7aGch6BA7VC + YXc975ef0PeQ59xGnS9PABY4rt6wFmdrIJWSX2qVprgJaRfHtUni5Kzw54LQgII4ikVMtLjk/FFtwRgC + MFg1Mvg6gO8XM9rkfhNwS5daAy1s0ddtwK8iasn/Af5TSIBmqTC8N++XW30ZNy82FmBZFo7nYDtCAnNP + dYCZyTq2IwSQ60sThQlBY/5iPZUowiAWl2JxDHAQqag0BGCw6mgikt09+mTdhqTTXovM6WtJjrsN65kd + hvJbSGnyPuA/nmXs8Be5+g90rGOQJQQ9vbRDFDmE82zuWqVB0IjYcu16mrWA+vT8iuYkUQT1iExPCvvi + 39y0dgGeNwRgcCksAoVEnuu+X5xBhDoZ/VK+gGgLrtKuwiDdIy5qlUunmB2A4gHBdcyc+GNGTnwu3lSe + slJWzXL7sBa3bDfl4DbtedsexbGCZkSt0qRRDS9iAUSoxWkbR4DTpcJwaAjA4FKTQYzkoffoC98vvh2p + P3i79sG7dfbBWn29xkVVeokmXts84T/tre+t2j1brUXq+r2US+AtvLEjpaiM1wia0Vn137wWwOIqAxMk + +He6E1+AIQCDlYCPyG0/rv3qm5G++g90MRn0AX1vyIUfXjd9WB2YiYKHmz0pp28Au6cPJ7OwQNJxbdyX + qwRUMHNymiSIUXGCM5CdlyiatXAxBGAh7djHDAEYdKtVkOiTKtJR9wRRHR5mtoXZ7dptSHfJsi39izuU + tpNEOeqpmSrNqYiwNk2S68NOpbG8FPZ5ZOB49kWrAJNmRNIMUVGC3ZsW7cCcdJ9SChTEcUKSqJerJUgQ + /f+4IQCDy4EMTiEtq0q+X9yD9Cm4hdlW2PacqyuqU9elHLvftekfm+FMdYZGAknPDE7vGpxcL3YqM7t5 + LQvHdbAv0gsgCSKSRghRjApj8Bys86oGVSI6ARUnvEwkUCHtvxsdYz0Dg0viJ/jFHUjA8Dc1KWztlrUp + 4Ewz5jvHqjw90aDRku5aFtg27sAgTk8/7pr12KkU0xMNjh1cQJKvFMHoOCpKIEmwUi7uuj7snguNn6Ft + a8n2pkhn5+0AfwI4UioMv75T92ksAINLidNIS7N/Rtp0vUpbCK9GRDyXzD2wgB7X5pq+FLFSPDHeOLuZ + SRKS2gwqDEhqVexcD0kDPAJCvHPPVaVAKb35xcxXUUJSD8ACO3fuLUZBTBwm0kP5QhxFqh8xBGBwJbgH + U4gc95DvFweR1OG9SKruGiRCn9Xv6aq/qxnHYmuPiwU8M9EkUkqK/pQiadShUSdmCrvZTxK7OIlNpEBh + a0vB0YShYE71H3GCaoQkloWdTZ0TC4jD+Jw6gXksgH2GAAyuRDI4g6QTnwU+7fvFIaCgr12IeGfVsSnj + 0uva3LI2w8h0wPg8abxkpkLSjLAqTZJqgkrlsLL90L8eFSao5oUpwqQeYEUxSS6FlXJppRzDZkQULLgt + x+iA+s8QgMHlgCmkgGcEqUF4FaI23K6vLKsUw0rbFrety1CLE2qxoh5fWLlnWxaOZ0MSoJpViAJoTJNE + Fiq0ULGHZbvMFRepOCGeqOIM9mDZHlgWURgvVBo8jpRqHzYEYPBKsAiaiN79oK49GNTv641Iye9mJHff + wwprC1zbYnuvx+Zpl8kgYbSWzBs0cBwbSCTSHwXQrMrmDyyw+1COJoEWESRiCdjNNMqxsTx3tjeAuoDe + TiHqvwlDAAavNDJoIAGwv5ozCKWA1B3cg9QirBgsbQXcuT7LVVmXfz14YQs+227NBZhTFgjQrJNM1yE5 + DY6HclLQsw68HDhpLGziyRoqiHE39J0lgCRJztcWPI0UL2EIwOCVjAiZFbAHaYf1RaTS7xqk2/HdK/WD + +z2bq7Mut67L8HwloDKniYdl23gp65zeACqMUVHMWYF/EoFKYOakWAGOh0r1ouJeICGZSWHnUiRJQtCM + SGe9ub0BHu+0+W8IwOBytAZaKsNj+sL3i1NIJ6MjSOpwQLsHG7R70JFiJM+26Pdsru9PcbIR04wVTS3d + tSywHAvLtmZLg6P4bOpPGEGBiiGJdZbA1X+WoJKIxAXLW0MSpYiCmFTGm0soI3RI/Xe+dWNgcEXA94s2 + Iia6E5l78C5NAh3vdPyN0WmerwSM1c+N8J8eqxAGkZjylRqqGaGCRQzsdTxI9+Fds5PMhrX0bxxg7cbe + uW7ANuBkqTDc0dHqtnltDK4w6+AYUoj0aeAdwEeAT2ofeqZTP+uNG3K8aShH2j63fcfcugDViGCxzT6T + CBoV4sMjhEcOE9SarcKgo8D3kVqKwLgABgYvTwJNpGHJGaThRx3pb9hE+gQOIRmEq7W7sKzGJYNph6sj + l+Fej3I1pKmlwo5rSyGPVgyqRRb4iysQoarTJNMZwskp1KvWAM4U8CIQlgrDiSEAA4OlEcKLegM95PvF + TYio6FeQyUDLdg9cC9ZnHO4aynFqdJpmHJ9DACpRcoKrpU3+VWFAVKlQPzKG2rUF0t4EIo5KVuL7MQRg + 8ErCKWQc2n7gM0ivwJuB9+rfL6m3YY8jAcFb12UYmQ4ZmQ5wPQcbhWqEnJMOXAKSWpVg9DAqfh1Il6Xv + AqEhAAOD9qyBGJmm09BzBSs6LmBrAtiGpBLXA+su9nm2BSnLYnuPRxArjtUjYs/BtizJAKhlLlQpVBgQ + TldDLKua6us5vlLfiSEAg1cqGTQQbf0YsNf3i1sQLcEHkbkC6xb7WTv7UkQJPD8d0IhtbEsq/pYNXUFY + H58MwkYw/dx7bxo3BGBgsLI4isxIfFzHBfqB9wF3IfMCNi/0D9O2xTV9Hu/z+vnMyCSTtoXltp9gyzrW + qOdZZ1bypg0BGBhwQRuzCMkaPKwthEeZbViyiXkal6Rti8G0w7V9KVTWY9JunwA8W01lHGvGEICBweqS + QYRIjh8DHvP9Yg6pOfgFJGi4mdn0oSWb1WLAttg1kGI65/GiaxOdVxawVKRsJjOuVV3JezVKQAODJUAX + I20G7gd+HilR7p1DCDx6pMLXXzjDyL4j844BuyhsG0tGi+9Iih87aCwAA4PuQWsOwveAA4hKr9XkdBew + 8er+tPPm7Ws4+OOjJCpZshbAy2Xi3qs2hEqpeGKFb8YQgIHB0tyDGEkfPjXHKrgPyRxYgDOUS2Vv2+x6 + D+ZSmVo9tMLF1AKctckt3Ey60bd56Ciw4gRgXAADg866CDcihUhv/vbYzLsff/ZE+snnTrgqjBd3+q8d + wPLcrzYf/Oh7VmO9xgIwMOgsxpCe/SMp23pkYP3A7Tfmc7f+9NnRvAoj6Q8w30bMplXP5qEwnUl9wXGd + /z26Sos1BGBg0FkXYRKRG//M94v7j3trJnrDJH7uhWOeY9v9Vkr1KtEYACjLtuIkSqbcbLaa3TB4ZtPm + df7mLRueOfrXq7Ne4wIYGKwS7v7SD+8PgvC+scMnHwCwHTvK9edOp/v7vpzu631s7/03fWe112QsAAOD + 1cMPLMt6AfgaswqBwLKsMW01GBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgY + GBgsBv8PNAlKsBafvBgAAAAASUVORK5CYII= + + + \ No newline at end of file diff --git a/hub-tools/CSHubUpdater/CSHubUpdater/oe-logo-only-color_a.ico b/hub-tools/CSHubUpdater/CSHubUpdater/oe-logo-only-color_a.ico new file mode 100644 index 0000000000000000000000000000000000000000..383c503499745262edf13ef272f9a8ba8128750b GIT binary patch literal 98966 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 Pf}&n90QUXgHS7Na1TER@ literal 0 HcmV?d00001