commit fea1a0c770b6064dc6c32b84ed3ef132b48dad05 Author: xeons Date: Mon Jun 29 20:48:49 2015 -0500 Initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1c8ad5f --- /dev/null +++ b/.gitignore @@ -0,0 +1,205 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +build/ +bld/ +[Bb]in/ +[Oo]bj/ + +# Visual Studio 2015 cache/options directory +.vs/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUNIT +*.VisualState.xml +TestResult.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# DNX +project.lock.json +artifacts/ + +*_i.c +*_p.c +*_i.h +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opensdf +*.sdf +*.cachefile + +# Visual Studio profiler +*.psess +*.vsp +*.vspx + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# JustCode is a .NET coding add-in +.JustCode + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# NCrunch +_NCrunch_* +.*crunch*.local.xml + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# TODO: Comment the next line if you want to checkin your web deploy settings +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# NuGet Packages +*.nupkg +# The packages folder can be ignored because of Package Restore +**/packages/* +# except build/, which is used as an MSBuild target. +!**/packages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/packages/repositories.config + +# Windows Azure Build Output +csx/ +*.build.csdef + +# Windows Store app package directory +AppPackages/ + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ + +# Others +ClientBin/ +[Ss]tyle[Cc]op.* +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.pfx +*.publishsettings +node_modules/ +orleans.codegen.cs + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm + +# SQL Server files +*.mdf +*.ldf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings + +# Microsoft Fakes +FakesAssemblies/ + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt \ No newline at end of file diff --git a/ProjectCarbon.sln b/ProjectCarbon.sln new file mode 100644 index 0000000..849806e --- /dev/null +++ b/ProjectCarbon.sln @@ -0,0 +1,36 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProjectCarbon", "ProjectCarbon\ProjectCarbon.csproj", "{AF67D418-BCEB-4318-8ED7-201466FAECB4}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpPcap-vs2005", "..\SharpPcap\SharpPcap\SharpPcap-vs2005.csproj", "{67DFA5F8-6D82-4F58-A23F-F56A6598ABA5}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {AF67D418-BCEB-4318-8ED7-201466FAECB4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AF67D418-BCEB-4318-8ED7-201466FAECB4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AF67D418-BCEB-4318-8ED7-201466FAECB4}.Debug|x86.ActiveCfg = Debug|x86 + {AF67D418-BCEB-4318-8ED7-201466FAECB4}.Debug|x86.Build.0 = Debug|x86 + {AF67D418-BCEB-4318-8ED7-201466FAECB4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AF67D418-BCEB-4318-8ED7-201466FAECB4}.Release|Any CPU.Build.0 = Release|Any CPU + {AF67D418-BCEB-4318-8ED7-201466FAECB4}.Release|x86.ActiveCfg = Release|x86 + {AF67D418-BCEB-4318-8ED7-201466FAECB4}.Release|x86.Build.0 = Release|x86 + {67DFA5F8-6D82-4F58-A23F-F56A6598ABA5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {67DFA5F8-6D82-4F58-A23F-F56A6598ABA5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {67DFA5F8-6D82-4F58-A23F-F56A6598ABA5}.Debug|x86.ActiveCfg = Debug|x86 + {67DFA5F8-6D82-4F58-A23F-F56A6598ABA5}.Debug|x86.Build.0 = Debug|x86 + {67DFA5F8-6D82-4F58-A23F-F56A6598ABA5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {67DFA5F8-6D82-4F58-A23F-F56A6598ABA5}.Release|Any CPU.Build.0 = Release|Any CPU + {67DFA5F8-6D82-4F58-A23F-F56A6598ABA5}.Release|x86.ActiveCfg = Release|x86 + {67DFA5F8-6D82-4F58-A23F-F56A6598ABA5}.Release|x86.Build.0 = Release|x86 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/ProjectCarbon/BinaryConverter.cs b/ProjectCarbon/BinaryConverter.cs new file mode 100644 index 0000000..4882665 --- /dev/null +++ b/ProjectCarbon/BinaryConverter.cs @@ -0,0 +1,372 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace ProjectCarbon +{ + public enum EndianType + { + BigEndian, + LittleEndian + } + public interface IBinaryConverter + { + EndianType Type { get; } + byte[] GetBytes(bool value); + byte[] GetBytes(char value); + byte[] GetBytes(float value); + byte[] GetBytes(double value); + byte[] GetBytes(short value); + byte[] GetBytes(int value); + byte[] GetBytes(long value); + byte[] GetBytes(ushort value); + byte[] GetBytes(uint value); + byte[] GetBytes(ulong value); + + bool ToBoolean(byte[] value, int startIndex); + char ToChar(byte[] value, int startIndex); + float ToSingle(byte[] value, int startIndex); + double ToDouble(byte[] value, int startIndex); + short ToInt16(byte[] value, int startIndex); + int ToInt32(byte[] value, int startIndex); + long ToInt64(byte[] value, int startIndex); + ushort ToUInt16(byte[] value, int startIndex); + uint ToUInt32(byte[] value, int startIndex); + ulong ToUInt64(byte[] value, int startIndex); + } + #region BigEndianConverter + public class BigEndianConverter : IBinaryConverter + { + public EndianType Type + { + get { return EndianType.BigEndian; } + } + + public byte[] GetBytes(bool value) + { + return new byte[] { (byte)(value ? 0x01 : 0x00) }; + } + + public byte[] GetBytes(char value) + { + return GetBytes((short)value); + } + + public unsafe byte[] GetBytes(float value) + { + return GetBytes(*((int*)&value)); + } + + public unsafe byte[] GetBytes(double value) + { + return GetBytes(*((long*)&value)); + } + + public byte[] GetBytes(short value) + { + byte[] buffer = new byte[2]; + + buffer[0] = (byte)(value >> 8); + buffer[1] = (byte)value; + + return buffer; + } + + public byte[] GetBytes(int value) + { + byte[] buffer = new byte[4]; + + buffer[0] = (byte)(value >> 0x18); + buffer[1] = (byte)(value >> 0x10); + buffer[2] = (byte)(value >> 8); + buffer[3] = (byte)value; + + return buffer; + } + + public byte[] GetBytes(long value) + { + byte[] buffer = new byte[8]; + + buffer[0] = (byte)(value >> 0x38); + buffer[1] = (byte)(value >> 0x30); + buffer[2] = (byte)(value >> 0x28); + buffer[3] = (byte)(value >> 0x20); + buffer[4] = (byte)(value >> 0x18); + buffer[5] = (byte)(value >> 0x10); + buffer[6] = (byte)(value >> 8); + buffer[7] = (byte)value; + + return buffer; + } + + public byte[] GetBytes(ushort value) + { + byte[] buffer = new byte[2]; + + buffer[0] = (byte)(value >> 8); + buffer[1] = (byte)value; + + return buffer; + } + + public byte[] GetBytes(uint value) + { + byte[] buffer = new byte[4]; + + buffer[0] = (byte)(value >> 0x18); + buffer[1] = (byte)(value >> 0x10); + buffer[2] = (byte)(value >> 8); + buffer[3] = (byte)value; + + return buffer; + } + + public byte[] GetBytes(ulong value) + { + byte[] buffer = new byte[8]; + + buffer[0] = (byte)(value >> 0x38); + buffer[1] = (byte)(value >> 0x30); + buffer[2] = (byte)(value >> 0x28); + buffer[3] = (byte)(value >> 0x20); + buffer[4] = (byte)(value >> 0x18); + buffer[5] = (byte)(value >> 0x10); + buffer[6] = (byte)(value >> 8); + buffer[7] = (byte)value; + + return buffer; + } + + public bool ToBoolean(byte[] value, int startIndex) + { + return (value[startIndex] == 0) ? false : true; + } + + public char ToChar(byte[] value, int startIndex) + { + return (char)ToInt16(value, startIndex); + } + + public unsafe float ToSingle(byte[] value, int startIndex) + { + int rv = ToInt32(value, startIndex); + return *((float*)&rv); + } + + public unsafe double ToDouble(byte[] value, int startIndex) + { + long rv = ToInt64(value, startIndex); + return *((double*)&rv); + } + + public short ToInt16(byte[] value, int startIndex) + { + return (short)((value[startIndex] << 8) | (value[++startIndex] & 0xff)); + } + + public int ToInt32(byte[] value, int startIndex) + { + return ((value[startIndex] << 0x18) | (value[++startIndex] << 0x10) | (value[++startIndex] << 8) | (value[++startIndex] & 0xff)); + } + + public long ToInt64(byte[] value, int startIndex) + { + uint hi = (uint)((value[startIndex] << 0x18) | (value[++startIndex] << 0x10) | (value[++startIndex] << 8) | (value[++startIndex] & 0xff)); + uint lo = (uint)((value[++startIndex] << 0x18) | (value[++startIndex] << 0x10) | (value[++startIndex] << 8) | (value[++startIndex] & 0xff)); + + return (long)((((ulong)hi) << 0x20) | lo); + } + + public ushort ToUInt16(byte[] value, int startIndex) + { + return (ushort)((value[startIndex] << 8) | (value[++startIndex] & 0xff)); + } + + + public uint ToUInt32(byte[] value, int startIndex) + { + return (uint)((value[startIndex] << 0x18) | (value[++startIndex] << 0x10) | (value[++startIndex] << 8) | (value[++startIndex] & 0xff)); + } + + + public ulong ToUInt64(byte[] value, int startIndex) + { + uint hi = (uint)((value[startIndex] << 0x18) | (value[++startIndex] << 0x10) | (value[++startIndex] << 8) | (value[++startIndex] & 0xff)); + uint lo = (uint)((value[++startIndex] << 0x18) | (value[++startIndex] << 0x10) | (value[++startIndex] << 8) | (value[++startIndex] & 0xff)); + + return ((((ulong)hi) << 0x20) | lo); + } + } + #endregion + #region LittleEndianConverter + public class LittleEndianConverter : IBinaryConverter + { + public EndianType Type + { + get { return EndianType.LittleEndian; } + } + + public byte[] GetBytes(bool value) + { + return new byte[] { (byte)(value ? 0x01 : 0x00) }; + } + + public byte[] GetBytes(char value) + { + return GetBytes((short)value); + } + + public unsafe byte[] GetBytes(float value) + { + return GetBytes(*((int*)&value)); + } + + public unsafe byte[] GetBytes(double value) + { + return GetBytes(*((long*)&value)); + } + + public byte[] GetBytes(short value) + { + byte[] buffer = new byte[2]; + + buffer[0] = (byte)value; + buffer[1] = (byte)(value >> 8); + + return buffer; + } + + public byte[] GetBytes(int value) + { + byte[] buffer = new byte[4]; + + buffer[0] = (byte)value; + buffer[1] = (byte)(value >> 8); + buffer[2] = (byte)(value >> 0x10); + buffer[3] = (byte)(value >> 0x18); + + return buffer; + } + + public byte[] GetBytes(long value) + { + byte[] buffer = new byte[8]; + + buffer[0] = (byte)value; + buffer[1] = (byte)(value >> 8); + buffer[2] = (byte)(value >> 0x10); + buffer[3] = (byte)(value >> 0x18); + buffer[4] = (byte)(value >> 0x20); + buffer[5] = (byte)(value >> 0x28); + buffer[6] = (byte)(value >> 0x30); + buffer[7] = (byte)(value >> 0x38); + + return buffer; + } + + + public byte[] GetBytes(ushort value) + { + byte[] buffer = new byte[2]; + + buffer[0] = (byte)value; + buffer[1] = (byte)(value >> 8); + + return buffer; + } + + + public byte[] GetBytes(uint value) + { + byte[] buffer = new byte[4]; + + buffer[0] = (byte)value; + buffer[1] = (byte)(value >> 8); + buffer[2] = (byte)(value >> 0x10); + buffer[3] = (byte)(value >> 0x18); + + return buffer; + } + + + public byte[] GetBytes(ulong value) + { + byte[] buffer = new byte[8]; + + buffer[0] = (byte)value; + buffer[1] = (byte)(value >> 8); + buffer[2] = (byte)(value >> 0x10); + buffer[3] = (byte)(value >> 0x18); + buffer[4] = (byte)(value >> 0x20); + buffer[5] = (byte)(value >> 0x28); + buffer[6] = (byte)(value >> 0x30); + buffer[7] = (byte)(value >> 0x38); + + return buffer; + } + + public bool ToBoolean(byte[] value, int startIndex) + { + + return (value[startIndex] == 0) ? false : true; + } + + public char ToChar(byte[] value, int startIndex) + { + return (char)ToInt16(value, startIndex); + } + + public unsafe float ToSingle(byte[] value, int startIndex) + { + int rv = ToInt32(value, startIndex); + return *((float*)&rv); + } + + public unsafe double ToDouble(byte[] value, int startIndex) + { + long rv = ToInt64(value, startIndex); + return *((double*)&rv); + } + + public short ToInt16(byte[] value, int startIndex) + { + return (short)((value[startIndex] & 0xff) | (value[++startIndex] << 8)); + } + + public int ToInt32(byte[] value, int startIndex) + { + return ((value[startIndex] & 0xff) | (value[++startIndex] << 8) | (value[++startIndex] << 0x10) | (value[++startIndex] << 0x18)); + } + + public long ToInt64(byte[] value, int startIndex) + { + uint lo = (uint)((value[startIndex] & 0xff) | (value[++startIndex] << 8) | (value[++startIndex] << 0x10) | (value[++startIndex] << 0x18)); + uint hi = (uint)((value[++startIndex] & 0xff) | (value[++startIndex] << 8) | (value[++startIndex] << 0x10) | (value[++startIndex] << 0x18)); + + return (long)((((ulong)hi) << 0x20) | lo); + } + + + public ushort ToUInt16(byte[] value, int startIndex) + { + return (ushort)((value[startIndex] & 0xff) | (value[++startIndex] << 8)); + } + + + public uint ToUInt32(byte[] value, int startIndex) + { + return (uint)((value[startIndex] & 0xff) | (value[++startIndex] << 8) | (value[++startIndex] << 0x10) | (value[++startIndex] << 0x18)); + } + + + public ulong ToUInt64(byte[] value, int startIndex) + { + uint lo = (uint)((value[startIndex] & 0xff) | (value[++startIndex] << 8) | (value[++startIndex] << 0x10) | (value[++startIndex] << 0x18)); + uint hi = (uint)((value[++startIndex] & 0xff) | (value[++startIndex] << 8) | (value[++startIndex] << 0x10) | (value[++startIndex] << 0x18)); + + return ((((ulong)hi) << 0x20) | lo); + } + } + #endregion +} diff --git a/ProjectCarbon/Functions.cs b/ProjectCarbon/Functions.cs new file mode 100644 index 0000000..ee017ac --- /dev/null +++ b/ProjectCarbon/Functions.cs @@ -0,0 +1,174 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using System.Diagnostics; +using Microsoft.Win32; + +namespace ProjectCarbon +{ + public static class Functions + { + const string REG_RUN = @"Software\Microsoft\Windows\CurrentVersion\Run"; + + public static void SetStartup() + { + RegistryKey key = Registry.CurrentUser; + try + { + key = key.OpenSubKey(REG_RUN, true); + key.SetValue(Application.ProductName, + Application.ExecutablePath); + } + catch (Exception e) + { + //return "error " + e.Message; + Debug.WriteLine(e.Message); + } + finally + { + key.Close(); + } + } + + public static void RemoveStartup() + { + RegistryKey key = Registry.CurrentUser; + try + { + key = key.OpenSubKey(REG_RUN, true); + key.DeleteValue(Application.ProductName); + } + catch (ArgumentException e) + { + //this just means it didnt exist... + Debug.WriteLine(e.Message); + } + catch (Exception e) + { + //return "error " + e.Message; + Debug.WriteLine(e.Message); + } + finally + { + key.Close(); + } + } + + public static string GetHexBlock(byte[] txt) + { + int i; + // disp is the 16-bytes of display + StringBuilder disp = new StringBuilder(); + // hex is the complete output (hex+disp) + StringBuilder hex = new StringBuilder(); + + for (i = 0; i < txt.Length; i++) + { + if (i == 0) + hex.Append("0000: "); + + if (i > 0) + { + if (i % 16 == 0) + { + if (hex.Length > 0) + { // end current line + hex.Append(" " + disp.ToString() + "\r\n"); + if (i % 16 == 0) + hex.Append(String.Format("{0:X4}: ", (i / 16) * 16)); + disp.Length = 0; + } + } + } + hex.Append(string.Format("{0:X2} ", txt[i])); + if (txt[i] >= ' ' && txt[i] <= 127) + disp.Append(Convert.ToChar(txt[i])); + else disp.Append('.'); + } + // end of text - make sure we end the last line of hex + if (disp.Length > 0) + { + if (disp.Length < 16) + { + for (i = disp.Length; i < 16; i++) + hex.Append(" "); + } + hex.Append(" " + disp.ToString()); + } + return hex.ToString(); + } + + public static string GetHexOnly(byte[] txt) + { + StringBuilder disp = new StringBuilder(); + for (int i = 0; i < txt.Length; i++) + disp.Append(String.Format("{0:X2} ", txt[i])); + return disp.ToString().Trim(); + } + + public static string GetDecBlock(byte[] txt) + { + int i; + // disp is the 16-bytes of display + StringBuilder disp = new StringBuilder(); + // hex is the complete output (hex+disp) + StringBuilder hex = new StringBuilder(); + + for (i = 0; i < txt.Length; i++) + { + if (i == 0) + hex.Append("0000: "); + + if (i > 0) + { + if (i % 16 == 0) + { + if (hex.Length > 0) + { // end current line + hex.Append(" " + disp.ToString() + "\r\n"); + if (i % 16 == 0) + hex.Append(String.Format("{0:X4}: ", (i / 16) * 16)); + disp.Length = 0; + } + } + } + hex.Append(string.Format("{0:000} ", txt[i])); + if (txt[i] >= ' ' && txt[i] <= 127) + disp.Append(Convert.ToChar(txt[i])); + else disp.Append('.'); + } + // end of text - make sure we end the last line of hex + if (disp.Length > 0) + { + if (disp.Length < 16) + { + for (i = disp.Length; i < 16; i++) + hex.Append(" "); + } + hex.Append(" " + disp.ToString()); + } + return hex.ToString(); + } + + public static string GetDecOnly(byte[] txt) + { + StringBuilder disp = new StringBuilder(); + for (int i = 0; i < txt.Length; i++) + disp.Append(txt[i].ToString() + " "); + return disp.ToString().Trim(); + } + + public static string GetSafeString(byte[] txt) + { + StringBuilder disp = new StringBuilder(); + for (int i = 0; i < txt.Length; i++) + if (txt[i] >= ' ' && txt[i] <= 127 || + (txt[i] == 9 || txt[i] == 10 || txt[i] == 13)) + disp.Append(Convert.ToChar(txt[i])); + else + disp.Append('.'); + return disp.ToString().Trim(); + } + } +} diff --git a/ProjectCarbon/Global.cs b/ProjectCarbon/Global.cs new file mode 100644 index 0000000..89c1777 --- /dev/null +++ b/ProjectCarbon/Global.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Net; +using ProjectCarbon.Properties; +using ProjectCarbon.Protocols; +using Tamir.IPLib; + + +namespace ProjectCarbon +{ + static class Global + { + public static System.Net.IPAddress[] LocalIPAddresses = + Dns.GetHostEntry(Dns.GetHostName()).AddressList; + + public static PacketCaptureInterface[] PacketCaptureArray; + + public static PcapDeviceList DeviceList = SharpPcap.GetAllDevices(); + + public static List CapturedPackets = + new List(); + + public static List FilteredPortList = new List(); + public static bool PortFilterInclusive = true; + public static List FilteredProtocolList = new List(); + public static bool ProtocolFilterInclusive = true; + + public delegate void PacketCapturedEvent(Tamir.IPLib.Packets.Packet packet); + } +} diff --git a/ProjectCarbon/Internet Explorer.ico b/ProjectCarbon/Internet Explorer.ico new file mode 100644 index 0000000..47fad92 Binary files /dev/null and b/ProjectCarbon/Internet Explorer.ico differ diff --git a/ProjectCarbon/PacketCapture.cs b/ProjectCarbon/PacketCapture.cs new file mode 100644 index 0000000..5a771c9 --- /dev/null +++ b/ProjectCarbon/PacketCapture.cs @@ -0,0 +1,151 @@ +using System; +using System.Text; +using System.Net; +using System.Net.Sockets; +using System.Net.NetworkInformation; +using System.Runtime.InteropServices; +using System.Diagnostics; +using System.Timers; +using System.Collections; +using System.Collections.Generic; + +namespace ProjectCarbon +{ + class PacketCapturedEventArgs : EventArgs + { + private DateTime timestamp; + private byte[] buffer; + + public PacketCapturedEventArgs(byte[] buffer) + { + this.timestamp = DateTime.Now; + this.buffer = buffer; + } + + public DateTime TimeStamp + { + get { return timestamp; } + } + + public byte[] Buffer + { + get { return buffer; } + } + } + + class PacketCaptureInterface: IDisposable + { + public delegate void PacketCapturedEventHandler(object sender, PacketCapturedEventArgs e); + + public event PacketCapturedEventHandler OnPacketCaptured; + + private Socket socket; + private IPAddress ipAddress; + private byte[] packetBuffer; + private NetworkInterface[] networkInterfaces; + private IPAddress[] addressList = Dns.GetHostEntry(Dns.GetHostName()).AddressList; + private AsyncCallback receiveCallback; + private bool isCapturing = false; + + public PacketCaptureInterface (IPAddress ip) + { + this.ipAddress = ip; + this.networkInterfaces = NetworkInterface.GetAllNetworkInterfaces(); + this.packetBuffer = new byte[2000]; // default max mtu is 1500, allow for 500 bytes of extra + this.receiveCallback = new AsyncCallback(OnReceiveCallback); + } + + public NetworkInterface[] NetworkInterfaces + { + get { return networkInterfaces; } + } + + public IPAddress[] AddressList + { + get { return addressList; } + } + + public void StartCapture() + { + if (isCapturing) + return; + + try + { + socket = new Socket(ipAddress.AddressFamily, + SocketType.Raw, ProtocolType.IP); + + socket.Bind(new IPEndPoint(ipAddress, 0)); + + socket.IOControl(IOControlCode.ReceiveAll, + BitConverter.GetBytes(1), null); + + isCapturing = true; + + BeginReceive(); + } + catch + { + socket.Close(); + } + } + + public void StopCapture() + { + if (isCapturing) + { + if (socket != null) + socket.Close(); + isCapturing = false; + } + } + + private void BeginReceive() + { + try + { + socket.BeginReceive(packetBuffer, + 0, + packetBuffer.Length, + SocketFlags.None, + receiveCallback, + null); + } + catch (ObjectDisposedException) + { + Console.WriteLine("BeginReceive: Socket has been closed."); + } + } + + private void OnReceiveCallback(IAsyncResult ar) + { + try + { + int bytesReceived = socket.EndReceive(ar); + + byte[] receivedBuffer = new byte[bytesReceived]; + + Array.Copy(packetBuffer, 0, receivedBuffer, 0, bytesReceived); + + Console.WriteLine(bytesReceived); + + if(OnPacketCaptured != null) + OnPacketCaptured(this, new PacketCapturedEventArgs(receivedBuffer)); + + BeginReceive(); + } + catch (ObjectDisposedException) + { + Console.WriteLine("OnReceiveCallback: Socket has been closed."); + } + } + + #region IDisposable Members + public void Dispose() + { + if (socket != null) + socket.Close(); + } + #endregion + } +} \ No newline at end of file diff --git a/ProjectCarbon/Program.cs b/ProjectCarbon/Program.cs new file mode 100644 index 0000000..e8dc5cc --- /dev/null +++ b/ProjectCarbon/Program.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Windows.Forms; +using System.Net; + +namespace ProjectCarbon +{ + static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new frmMain()); + } + } +} \ No newline at end of file diff --git a/ProjectCarbon/ProjectCarbon.csproj b/ProjectCarbon/ProjectCarbon.csproj new file mode 100644 index 0000000..cf1760b --- /dev/null +++ b/ProjectCarbon/ProjectCarbon.csproj @@ -0,0 +1,223 @@ + + + + Debug + AnyCPU + 9.0.21022 + 2.0 + {AF67D418-BCEB-4318-8ED7-201466FAECB4} + WinExe + Properties + ProjectCarbon + ProjectCarbon + Internet Explorer.ico + false + PublicPrivateKeyFile.snk + false + + + + + 3.5 + false + FCAFA7D01546AD80C88DBF8A74E793CA031DB9C6 + ProjectCarbon_TemporaryKey.pfx + true + true + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 1 + 1.0.0.%2a + false + true + v2.0 + + + false + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + true + + + none + true + bin\Release\ + TRACE + prompt + 4 + true + + + bin\x86\Debug\ + DEBUG;TRACE + true + full + x86 + prompt + + + bin\x86\Release\ + TRACE + true + true + x86 + prompt + + + + + + + + + + + + Form + + + frmAboutDialog.cs + + + + Form + + + frmCaptureFilters.cs + + + Form + + + frmDnsLookup.cs + + + Form + + + frmMain.cs + + + Form + + + frmCaptureSettings.cs + + + Form + + + frmSocketInformation.cs + + + + + + + + Designer + frmAboutDialog.cs + + + Designer + frmCaptureFilters.cs + + + Designer + frmDnsLookup.cs + + + Designer + frmMain.cs + + + Designer + frmCaptureSettings.cs + + + Designer + frmSocketInformation.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + + + + + + + + + + + + + + + + + False + .NET Framework 2.0 %28x86%29 + true + + + False + .NET Framework 3.0 %28x86%29 + false + + + False + .NET Framework 3.5 + false + + + + + {67DFA5F8-6D82-4F58-A23F-F56A6598ABA5} + SharpPcap-vs2005 + + + + + \ No newline at end of file diff --git a/ProjectCarbon/ProjectCarbon.idc b/ProjectCarbon/ProjectCarbon.idc new file mode 100644 index 0000000..6da2d34 --- /dev/null +++ b/ProjectCarbon/ProjectCarbon.idc @@ -0,0 +1 @@ + diff --git a/ProjectCarbon/ProjectCarbon.rct b/ProjectCarbon/ProjectCarbon.rct new file mode 100644 index 0000000..f521697 Binary files /dev/null and b/ProjectCarbon/ProjectCarbon.rct differ diff --git a/ProjectCarbon/Properties/AssemblyInfo.cs b/ProjectCarbon/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..1e2f59b --- /dev/null +++ b/ProjectCarbon/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Resources; +using System.Security.Permissions; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Project Carbon")] +[assembly: AssemblyDescription("A network analyzer and diagnostic tool for Windows NT4/2000, Windows XP/2003/Vista (x86 and x64), and Windows Server 2008 (x86 and x64).")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Xeon Productions")] +[assembly: AssemblyProduct("Project Carbon")] +[assembly: AssemblyCopyright("Copyright (c) Xeon Productions 2008")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("37ed6208-3a61-4bbe-b98b-465dbb73d136")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: NeutralResourcesLanguageAttribute("en-US")] diff --git a/ProjectCarbon/Properties/Resources.Designer.cs b/ProjectCarbon/Properties/Resources.Designer.cs new file mode 100644 index 0000000..defad3f --- /dev/null +++ b/ProjectCarbon/Properties/Resources.Designer.cs @@ -0,0 +1,73 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.18034 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace ProjectCarbon.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ProjectCarbon.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap aboutlogo1 { + get { + object obj = ResourceManager.GetObject("aboutlogo1", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/ProjectCarbon/Properties/Resources.resx b/ProjectCarbon/Properties/Resources.resx new file mode 100644 index 0000000..ff93825 --- /dev/null +++ b/ProjectCarbon/Properties/Resources.resx @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + ..\Resources\aboutlogo.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/ProjectCarbon/Properties/Settings.Designer.cs b/ProjectCarbon/Properties/Settings.Designer.cs new file mode 100644 index 0000000..56462af --- /dev/null +++ b/ProjectCarbon/Properties/Settings.Designer.cs @@ -0,0 +1,194 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.18034 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace ProjectCarbon.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("False")] + public bool StartUpWindows { + get { + return ((bool)(this["StartUpWindows"])); + } + set { + this["StartUpWindows"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("False")] + public bool StartUpMinimized { + get { + return ((bool)(this["StartUpMinimized"])); + } + set { + this["StartUpMinimized"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("False")] + public bool StartUpCapture { + get { + return ((bool)(this["StartUpCapture"])); + } + set { + this["StartUpCapture"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("0")] + public int ProtocolFilterType { + get { + return ((int)(this["ProtocolFilterType"])); + } + set { + this["ProtocolFilterType"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Window")] + public global::System.Drawing.Color PacketListBackgroundColor { + get { + return ((global::System.Drawing.Color)(this["PacketListBackgroundColor"])); + } + set { + this["PacketListBackgroundColor"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("WindowText")] + public global::System.Drawing.Color PacketListTextColor { + get { + return ((global::System.Drawing.Color)(this["PacketListTextColor"])); + } + set { + this["PacketListTextColor"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("WindowText")] + public global::System.Drawing.Color PacketDisplayFontColor { + get { + return ((global::System.Drawing.Color)(this["PacketDisplayFontColor"])); + } + set { + this["PacketDisplayFontColor"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Window")] + public global::System.Drawing.Color PacketDisplayBackgroundColor { + get { + return ((global::System.Drawing.Color)(this["PacketDisplayBackgroundColor"])); + } + set { + this["PacketDisplayBackgroundColor"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Courier New, 9.75pt, style=Bold")] + public global::System.Drawing.Font PacketDisplayFontFace { + get { + return ((global::System.Drawing.Font)(this["PacketDisplayFontFace"])); + } + set { + this["PacketDisplayFontFace"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("False")] + public bool AutoScrollPacketList { + get { + return ((bool)(this["AutoScrollPacketList"])); + } + set { + this["AutoScrollPacketList"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool ToolbarVisible { + get { + return ((bool)(this["ToolbarVisible"])); + } + set { + this["ToolbarVisible"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool StatusBarVisible { + get { + return ((bool)(this["StatusBarVisible"])); + } + set { + this["StatusBarVisible"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool PacketListVisible { + get { + return ((bool)(this["PacketListVisible"])); + } + set { + this["PacketListVisible"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool PacketDisplayVisible { + get { + return ((bool)(this["PacketDisplayVisible"])); + } + set { + this["PacketDisplayVisible"] = value; + } + } + } +} diff --git a/ProjectCarbon/Properties/Settings.settings b/ProjectCarbon/Properties/Settings.settings new file mode 100644 index 0000000..4d62bc5 --- /dev/null +++ b/ProjectCarbon/Properties/Settings.settings @@ -0,0 +1,48 @@ + + + + + + False + + + False + + + False + + + 0 + + + Window + + + WindowText + + + WindowText + + + Window + + + Courier New, 9.75pt, style=Bold + + + False + + + True + + + True + + + True + + + True + + + \ No newline at end of file diff --git a/ProjectCarbon/Protocols/GenericProtocol.cs b/ProjectCarbon/Protocols/GenericProtocol.cs new file mode 100644 index 0000000..706e7c3 --- /dev/null +++ b/ProjectCarbon/Protocols/GenericProtocol.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace ProjectCarbon.Protocols +{ + class GenericProtocol: IpSubProtocol + { + public GenericProtocol() + : base(Protocol.None, "Generic", "This is not a real protocol!") + { + } + + public override void ProcessData(byte[] bufferData) + { + m_protocolProperties.Add("Payload", bufferData); + m_protocolProperties.Add("PacketPayload", bufferData); + } + } +} diff --git a/ProjectCarbon/Protocols/IcmpProtocol.cs b/ProjectCarbon/Protocols/IcmpProtocol.cs new file mode 100644 index 0000000..64f7585 --- /dev/null +++ b/ProjectCarbon/Protocols/IcmpProtocol.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace ProjectCarbon.Protocols +{ + enum IcmpCode + { + NetUnreachable = 0, + HostUnreachable = 1, + ProtocolUnreachable = 2, + PortUnreachable = 3, + FragmentationNeeded = 4, + SourceRouteFailed = 5 + } + + class IcmpProtocol: IpSubProtocol + { + public IcmpProtocol() + : base(Protocol.Icmp, "ICMP", "Internet Control Message Protocol") + { + } + + public override void ProcessData(byte[] bufferData) + { + BigEndianConverter endianConverter = new BigEndianConverter(); + byte type = bufferData[0]; + byte code = bufferData[1]; + int checksum = endianConverter.ToUInt16(bufferData, 2); + m_protocolProperties.Add("Type", type); + m_protocolProperties.Add("Code", code); + m_protocolProperties.Add("Checksum", checksum); + + m_protocolProperties.Add("Payload", bufferData); + } + } +} diff --git a/ProjectCarbon/Protocols/IpEnumerations.cs b/ProjectCarbon/Protocols/IpEnumerations.cs new file mode 100644 index 0000000..1746317 --- /dev/null +++ b/ProjectCarbon/Protocols/IpEnumerations.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace ProjectCarbon +{ + public enum Precedence + { + Routine = 0, + Priority = 1, + Immediate = 2, + Flash = 3, + FlashOverride = 4, + CRITICECP = 5, + InternetworkControl = 6, + NetworkControl = 7 + } + public enum Delay + { + NormalDelay = 0, + LowDelay = 1 + } + public enum Throughput + { + NormalThroughput = 0, + HighThroughput = 1 + } + public enum Reliability + { + NormalReliability = 0, + HighReliability = 1 + } + public enum Protocol + { + None = -1, + Hopopt = 0, + Icmp = 1, + Igmp = 2, + Ggp = 3, + Ip = 4, + St = 5, + Tcp = 6, + Cbt = 7, + Egp = 8, + Igp = 9, + Bbnrrcmon = 10, + Nvp2 = 11, + Pup = 12, + Udp = 17, + Idp = 22, + Nd = 77 + } + public enum ControlBit + { + Urg = 0, + Ack = 1, + Psh = 2, + Rst = 3, + Syn = 4, + Fin = 5 + } +} diff --git a/ProjectCarbon/Protocols/IpProtocol.cs b/ProjectCarbon/Protocols/IpProtocol.cs new file mode 100644 index 0000000..37d1fd7 --- /dev/null +++ b/ProjectCarbon/Protocols/IpProtocol.cs @@ -0,0 +1,85 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace ProjectCarbon.Protocols +{ + [Serializable] + public class IpProtocol + { + + /// + /// Provides a list of properties for this protocol. + /// + private Dictionary m_protocolProperties = + new Dictionary(); + + public IpProtocol(byte[] packetBuffer) + { + BigEndianConverter endianConverter = new BigEndianConverter(); + + if (packetBuffer == null) + throw new ArgumentException("Incoming Packet is null."); + + if (packetBuffer.Length < 20) + throw new ArgumentException("Incomplete IP Header"); + + int version = (packetBuffer[0] & 0xF0) >> 4; + int headerLength = (packetBuffer[0] & 0x0F) * 4; + + if ((packetBuffer[0] & 0x0F) < 5) + throw new ArgumentException("Smaller then 5"); + + Precedence precedence = (Precedence)((packetBuffer[1] & 0xE0) >> 5); + Delay delay = (Delay)((packetBuffer[1] & 0x10) >> 4); + Throughput throughput = (Throughput)((packetBuffer[1] & 0x08) >> 3); + Reliability reliability = (Reliability)((packetBuffer[1] & 0x04) >> 2); + + int totalLength = (packetBuffer[2] * 256) + packetBuffer[3]; + int identification = (packetBuffer[4] * 256) + packetBuffer[5]; + int timeToLive = packetBuffer[8]; + + Protocol protocol = (Protocol)packetBuffer[9]; + + ushort checksum = endianConverter.ToUInt16(packetBuffer, 10); + + string sourceAddress = String.Format("{0}.{1}.{2}.{3}", + packetBuffer[12], packetBuffer[13], packetBuffer[14], packetBuffer[15]); + string destinationAddress = String.Format("{0}.{1}.{2}.{3}", + packetBuffer[16], packetBuffer[17], packetBuffer[18], packetBuffer[19]); + + byte[] payload = new byte[packetBuffer.Length - headerLength]; + + Array.Copy(packetBuffer, headerLength, payload, 0, payload.Length); + + DateTime packetTime = System.DateTime.Now; + + // add all these to the properties + m_protocolProperties.Add("Version", version); + m_protocolProperties.Add("HeaderLength", headerLength); + m_protocolProperties.Add("Precedence", precedence); + m_protocolProperties.Add("Delay", delay); + m_protocolProperties.Add("Throughput", throughput); + m_protocolProperties.Add("Reliability", reliability); + m_protocolProperties.Add("TotalLength", totalLength); + m_protocolProperties.Add("Identification", identification); + m_protocolProperties.Add("TimeToLive", timeToLive); + m_protocolProperties.Add("Protocol", protocol); + m_protocolProperties.Add("Checksum", checksum); + m_protocolProperties.Add("SourceAddress", sourceAddress); + m_protocolProperties.Add("DestinationAddress", destinationAddress); + m_protocolProperties.Add("Payload", payload); + + m_protocolProperties.Add("PacketTime", packetTime); + m_protocolProperties.Add("PacketPayload", packetBuffer); + } + + /// + /// Allows you to access the properties of this protocol + /// + public Dictionary Properties + { + get { return m_protocolProperties; } + } + } +} diff --git a/ProjectCarbon/Protocols/IpSubProtocol.cs b/ProjectCarbon/Protocols/IpSubProtocol.cs new file mode 100644 index 0000000..5e61051 --- /dev/null +++ b/ProjectCarbon/Protocols/IpSubProtocol.cs @@ -0,0 +1,97 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace ProjectCarbon.Protocols +{ + /// + /// All protocols within the IP protocol should derive from this + /// class. + /// + abstract class IpSubProtocol + { + /// + /// Provides a list of properties for this protocol. + /// + protected Dictionary m_protocolProperties = + new Dictionary(); + + /// + /// Stores what protocol this handles. + /// + protected Protocol m_protocol; + + /// + /// This will get you the protocol name. + /// + protected string m_name = null; + + /// + /// You may optionally provide a protocol description + /// + protected string m_description = null; + + /// + /// Creates a new protocol + /// + /// The protocol this class will handle. + public IpSubProtocol(Protocol protocol, string name, string description) + { + m_protocol = protocol; + m_name = name; + m_description = description; + } + + /// + /// Allows you to access the properties of this protocol + /// + public Dictionary Properties + { + get { return m_protocolProperties; } + } + + /// + /// Returns the protocol name + /// + public string Name + { + get { return m_name; } + } + + /// + /// Returns a short description of this protocol + /// + public string Description + { + get { return m_description; } + } + + /// + /// This must be implemented, it's the parsing routine for this protocol. + /// + /// Incoming packet data + public abstract void ProcessData(byte[] bufferData); + + /// + /// Returns the correct processor for the protocol, but + /// it might return null if it has no processor. + /// + /// + /// A new instance of the protocol + public static IpSubProtocol GetProtocolInstance(Protocol protocol) + { + switch (protocol) + { + case Protocol.Tcp: + return new TcpProtocol(); + case Protocol.Udp: + return new UdpProtocol(); + case Protocol.Icmp: + return new IcmpProtocol(); + default: + return new GenericProtocol(); + } + //return null; + } + } +} diff --git a/ProjectCarbon/Protocols/TcpProtocol.cs b/ProjectCarbon/Protocols/TcpProtocol.cs new file mode 100644 index 0000000..b0e0021 --- /dev/null +++ b/ProjectCarbon/Protocols/TcpProtocol.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace ProjectCarbon.Protocols +{ + class TcpProtocol: IpSubProtocol + { + public TcpProtocol() + : base(Protocol.Tcp, "TCP", "Transmission Control Protocol") + { + } + + public override void ProcessData(byte[] bufferData) + { + BigEndianConverter endianConverter = new BigEndianConverter(); + + int sourcePort = endianConverter.ToUInt16(bufferData, 0); + int destinationPort = endianConverter.ToUInt16(bufferData, 2); + uint sequenceNumber = endianConverter.ToUInt32(bufferData, 4); + uint packNumber = endianConverter.ToUInt32(bufferData, 8); + int dataOffset = ((bufferData[12] & 0xF0) >> 4) * 4; + byte[] payload = new byte[bufferData.Length - dataOffset]; + + Array.Copy(bufferData, dataOffset, payload, 0, payload.Length); + + // These are all the properties for TCP. + m_protocolProperties.Add("SourcePort", sourcePort); + m_protocolProperties.Add("DestinationPort", destinationPort); + m_protocolProperties.Add("SequenceNumber", sequenceNumber); + m_protocolProperties.Add("AckNumber", packNumber); + m_protocolProperties.Add("DataOffset", dataOffset); + m_protocolProperties.Add("Payload", payload); + } + } +} diff --git a/ProjectCarbon/Protocols/UdpProtocol.cs b/ProjectCarbon/Protocols/UdpProtocol.cs new file mode 100644 index 0000000..9a39e3f --- /dev/null +++ b/ProjectCarbon/Protocols/UdpProtocol.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace ProjectCarbon.Protocols +{ + class UdpProtocol : IpSubProtocol + { + public UdpProtocol() + : base(Protocol.Udp, "UDP", "User Datagram Protocol") + { + } + + public override void ProcessData(byte[] bufferData) + { + // The UDP protocol uses big-endian. + BigEndianConverter endianConverter = new BigEndianConverter(); + + // Read the header information + int sourcePort = endianConverter.ToUInt16(bufferData, 0); + int destinationPort = endianConverter.ToUInt16(bufferData, 2); + int length = endianConverter.ToUInt16(bufferData, 4); + int checksum = endianConverter.ToUInt16(bufferData, 6); + byte[] payload = new byte[length - 8]; + + // Copy the buffer + Array.Copy(bufferData, 8, payload, 0, length - 8); + + // Add the properties + m_protocolProperties.Add("SourcePort", sourcePort); + m_protocolProperties.Add("DestinationPort", destinationPort); + m_protocolProperties.Add("Length", length); + m_protocolProperties.Add("Checksum", checksum); + m_protocolProperties.Add("Payload", payload); + } + } +} diff --git a/ProjectCarbon/PublicKeyFile.snk b/ProjectCarbon/PublicKeyFile.snk new file mode 100644 index 0000000..7c20084 Binary files /dev/null and b/ProjectCarbon/PublicKeyFile.snk differ diff --git a/ProjectCarbon/Resources/aboutlogo.png b/ProjectCarbon/Resources/aboutlogo.png new file mode 100644 index 0000000..ebba004 Binary files /dev/null and b/ProjectCarbon/Resources/aboutlogo.png differ diff --git a/ProjectCarbon/Resources/capturefilters.gif b/ProjectCarbon/Resources/capturefilters.gif new file mode 100644 index 0000000..465d329 Binary files /dev/null and b/ProjectCarbon/Resources/capturefilters.gif differ diff --git a/ProjectCarbon/Resources/clear.gif b/ProjectCarbon/Resources/clear.gif new file mode 100644 index 0000000..d84bfa9 Binary files /dev/null and b/ProjectCarbon/Resources/clear.gif differ diff --git a/ProjectCarbon/Resources/help.gif b/ProjectCarbon/Resources/help.gif new file mode 100644 index 0000000..8e45945 Binary files /dev/null and b/ProjectCarbon/Resources/help.gif differ diff --git a/ProjectCarbon/Resources/open.gif b/ProjectCarbon/Resources/open.gif new file mode 100644 index 0000000..9ce6d60 Binary files /dev/null and b/ProjectCarbon/Resources/open.gif differ diff --git a/ProjectCarbon/Resources/save.gif b/ProjectCarbon/Resources/save.gif new file mode 100644 index 0000000..fb97f68 Binary files /dev/null and b/ProjectCarbon/Resources/save.gif differ diff --git a/ProjectCarbon/Resources/search.gif b/ProjectCarbon/Resources/search.gif new file mode 100644 index 0000000..2cdf38a Binary files /dev/null and b/ProjectCarbon/Resources/search.gif differ diff --git a/ProjectCarbon/Resources/settings.gif b/ProjectCarbon/Resources/settings.gif new file mode 100644 index 0000000..f6c3ce9 Binary files /dev/null and b/ProjectCarbon/Resources/settings.gif differ diff --git a/ProjectCarbon/Resources/startcapture.gif b/ProjectCarbon/Resources/startcapture.gif new file mode 100644 index 0000000..b2d11d4 Binary files /dev/null and b/ProjectCarbon/Resources/startcapture.gif differ diff --git a/ProjectCarbon/Resources/stopcapture.gif b/ProjectCarbon/Resources/stopcapture.gif new file mode 100644 index 0000000..3b177f7 Binary files /dev/null and b/ProjectCarbon/Resources/stopcapture.gif differ diff --git a/ProjectCarbon/Resources/text.gif b/ProjectCarbon/Resources/text.gif new file mode 100644 index 0000000..07d679d Binary files /dev/null and b/ProjectCarbon/Resources/text.gif differ diff --git a/ProjectCarbon/Resources/winsock.gif b/ProjectCarbon/Resources/winsock.gif new file mode 100644 index 0000000..71e2bf0 Binary files /dev/null and b/ProjectCarbon/Resources/winsock.gif differ diff --git a/ProjectCarbon/Search.ico b/ProjectCarbon/Search.ico new file mode 100644 index 0000000..82c3825 Binary files /dev/null and b/ProjectCarbon/Search.ico differ diff --git a/ProjectCarbon/app.config b/ProjectCarbon/app.config new file mode 100644 index 0000000..aaf6085 --- /dev/null +++ b/ProjectCarbon/app.config @@ -0,0 +1,54 @@ + + + + +
+ + + + + + False + + + False + + + False + + + 0 + + + Window + + + WindowText + + + WindowText + + + Window + + + Courier New, 9.75pt, style=Bold + + + False + + + True + + + True + + + True + + + True + + + + \ No newline at end of file diff --git a/ProjectCarbon/frmAboutDialog.Designer.cs b/ProjectCarbon/frmAboutDialog.Designer.cs new file mode 100644 index 0000000..82b0819 --- /dev/null +++ b/ProjectCarbon/frmAboutDialog.Designer.cs @@ -0,0 +1,176 @@ +namespace ProjectCarbon +{ + partial class frmAboutDialog + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.labelProductName = new System.Windows.Forms.Label(); + this.labelVersion = new System.Windows.Forms.Label(); + this.labelCopyright = new System.Windows.Forms.Label(); + this.labelCompanyName = new System.Windows.Forms.Label(); + this.okButton = new System.Windows.Forms.Button(); + this.picLogo = new System.Windows.Forms.PictureBox(); + this.panel1 = new System.Windows.Forms.Panel(); + this.textBoxDescription = new System.Windows.Forms.TextBox(); + ((System.ComponentModel.ISupportInitialize)(this.picLogo)).BeginInit(); + this.panel1.SuspendLayout(); + this.SuspendLayout(); + // + // labelProductName + // + this.labelProductName.AutoSize = true; + this.labelProductName.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.labelProductName.Location = new System.Drawing.Point(72, 8); + this.labelProductName.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelProductName.MaximumSize = new System.Drawing.Size(0, 17); + this.labelProductName.Name = "labelProductName"; + this.labelProductName.Size = new System.Drawing.Size(86, 13); + this.labelProductName.TabIndex = 26; + this.labelProductName.Text = "Product Name"; + this.labelProductName.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // labelVersion + // + this.labelVersion.AutoSize = true; + this.labelVersion.Location = new System.Drawing.Point(72, 24); + this.labelVersion.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelVersion.MaximumSize = new System.Drawing.Size(0, 17); + this.labelVersion.Name = "labelVersion"; + this.labelVersion.Size = new System.Drawing.Size(42, 13); + this.labelVersion.TabIndex = 25; + this.labelVersion.Text = "Version"; + this.labelVersion.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // labelCopyright + // + this.labelCopyright.AutoSize = true; + this.labelCopyright.Location = new System.Drawing.Point(72, 40); + this.labelCopyright.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelCopyright.MaximumSize = new System.Drawing.Size(0, 17); + this.labelCopyright.Name = "labelCopyright"; + this.labelCopyright.Size = new System.Drawing.Size(54, 13); + this.labelCopyright.TabIndex = 27; + this.labelCopyright.Text = "Copyright"; + this.labelCopyright.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // labelCompanyName + // + this.labelCompanyName.AutoSize = true; + this.labelCompanyName.Location = new System.Drawing.Point(72, 56); + this.labelCompanyName.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelCompanyName.MaximumSize = new System.Drawing.Size(0, 17); + this.labelCompanyName.Name = "labelCompanyName"; + this.labelCompanyName.Size = new System.Drawing.Size(82, 13); + this.labelCompanyName.TabIndex = 28; + this.labelCompanyName.Text = "Company Name"; + this.labelCompanyName.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // okButton + // + this.okButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.okButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.okButton.Location = new System.Drawing.Point(261, 183); + this.okButton.Name = "okButton"; + this.okButton.Size = new System.Drawing.Size(75, 23); + this.okButton.TabIndex = 30; + this.okButton.Text = "&OK"; + this.okButton.UseVisualStyleBackColor = true; + // + // picLogo + // + this.picLogo.Image = global::ProjectCarbon.Properties.Resources.aboutlogo1; + this.picLogo.Location = new System.Drawing.Point(8, 8); + this.picLogo.Name = "picLogo"; + this.picLogo.Size = new System.Drawing.Size(57, 54); + this.picLogo.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; + this.picLogo.TabIndex = 31; + this.picLogo.TabStop = false; + // + // panel1 + // + this.panel1.BackColor = System.Drawing.Color.White; + this.panel1.Controls.Add(this.textBoxDescription); + this.panel1.Controls.Add(this.picLogo); + this.panel1.Controls.Add(this.labelCompanyName); + this.panel1.Controls.Add(this.labelProductName); + this.panel1.Controls.Add(this.labelCopyright); + this.panel1.Controls.Add(this.labelVersion); + this.panel1.Dock = System.Windows.Forms.DockStyle.Top; + this.panel1.Location = new System.Drawing.Point(0, 0); + this.panel1.Name = "panel1"; + this.panel1.Size = new System.Drawing.Size(344, 176); + this.panel1.TabIndex = 32; + // + // textBoxDescription + // + this.textBoxDescription.Location = new System.Drawing.Point(8, 80); + this.textBoxDescription.Margin = new System.Windows.Forms.Padding(6, 3, 3, 3); + this.textBoxDescription.Multiline = true; + this.textBoxDescription.Name = "textBoxDescription"; + this.textBoxDescription.ReadOnly = true; + this.textBoxDescription.ScrollBars = System.Windows.Forms.ScrollBars.Both; + this.textBoxDescription.Size = new System.Drawing.Size(328, 88); + this.textBoxDescription.TabIndex = 32; + this.textBoxDescription.TabStop = false; + this.textBoxDescription.Text = "Description"; + // + // frmAboutDialog + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.SystemColors.Control; + this.ClientSize = new System.Drawing.Size(344, 213); + this.Controls.Add(this.panel1); + this.Controls.Add(this.okButton); + this.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "frmAboutDialog"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "About Dialog..."; + this.Load += new System.EventHandler(this.frmAboutDialog_Load); + ((System.ComponentModel.ISupportInitialize)(this.picLogo)).EndInit(); + this.panel1.ResumeLayout(false); + this.panel1.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Label labelProductName; + private System.Windows.Forms.Label labelVersion; + private System.Windows.Forms.Label labelCopyright; + private System.Windows.Forms.Label labelCompanyName; + private System.Windows.Forms.Button okButton; + private System.Windows.Forms.PictureBox picLogo; + private System.Windows.Forms.Panel panel1; + private System.Windows.Forms.TextBox textBoxDescription; + } +} diff --git a/ProjectCarbon/frmAboutDialog.cs b/ProjectCarbon/frmAboutDialog.cs new file mode 100644 index 0000000..4399596 --- /dev/null +++ b/ProjectCarbon/frmAboutDialog.cs @@ -0,0 +1,125 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; +using System.Reflection; +using System.Globalization; +using Tamir.IPLib; + +namespace ProjectCarbon +{ + partial class frmAboutDialog : Form + { + public frmAboutDialog() + { + InitializeComponent(); + + // Initialize the AboutBox to display the product information from the assembly information. + // Change assembly information settings for your application through either: + // - Project->Properties->Application->Assembly Information + // - AssemblyInfo.cs + this.Text = String.Format(CultureInfo.CurrentCulture, + "About {0}", AssemblyTitle); + this.labelProductName.Text = AssemblyProduct; + this.labelVersion.Text = String.Format(CultureInfo.CurrentCulture, + "Version {0}", AssemblyVersion); + this.labelCopyright.Text = AssemblyCopyright; + this.labelCompanyName.Text = AssemblyCompany; + this.textBoxDescription.Text = AssemblyDescription; + this.textBoxDescription.Text += "\r\n\r\n" + SharpPcap.Version; + } + + #region Assembly Attribute Accessors + + public static string AssemblyTitle + { + get + { + // Get all Title attributes on this assembly + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false); + // If there is at least one Title attribute + if (attributes.Length > 0) + { + // Select the first one + AssemblyTitleAttribute titleAttribute = (AssemblyTitleAttribute)attributes[0]; + // If it is not an empty string, return it + if (titleAttribute.Title.Length != 0) + return titleAttribute.Title; + } + // If there was no Title attribute, or if the Title attribute was the empty string, return the .exe name + return System.IO.Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase); + } + } + + public static string AssemblyVersion + { + get + { + return Assembly.GetExecutingAssembly().GetName().Version.ToString(); + } + } + + public static string AssemblyDescription + { + get + { + // Get all Description attributes on this assembly + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false); + // If there aren't any Description attributes, return an empty string + if (attributes.Length == 0) + return ""; + // If there is a Description attribute, return its value + return ((AssemblyDescriptionAttribute)attributes[0]).Description; + } + } + + public static string AssemblyProduct + { + get + { + // Get all Product attributes on this assembly + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false); + // If there aren't any Product attributes, return an empty string + if (attributes.Length == 0) + return ""; + // If there is a Product attribute, return its value + return ((AssemblyProductAttribute)attributes[0]).Product; + } + } + + public static string AssemblyCopyright + { + get + { + // Get all Copyright attributes on this assembly + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false); + // If there aren't any Copyright attributes, return an empty string + if (attributes.Length == 0) + return ""; + // If there is a Copyright attribute, return its value + return ((AssemblyCopyrightAttribute)attributes[0]).Copyright; + } + } + + public static string AssemblyCompany + { + get + { + // Get all Company attributes on this assembly + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCompanyAttribute), false); + // If there aren't any Company attributes, return an empty string + if (attributes.Length == 0) + return ""; + // If there is a Company attribute, return its value + return ((AssemblyCompanyAttribute)attributes[0]).Company; + } + } + #endregion + + private void frmAboutDialog_Load(object sender, EventArgs e) + { + + } + } +} diff --git a/ProjectCarbon/frmAboutDialog.resx b/ProjectCarbon/frmAboutDialog.resx new file mode 100644 index 0000000..19dc0dd --- /dev/null +++ b/ProjectCarbon/frmAboutDialog.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectCarbon/frmCaptureFilters.Designer.cs b/ProjectCarbon/frmCaptureFilters.Designer.cs new file mode 100644 index 0000000..acd64af --- /dev/null +++ b/ProjectCarbon/frmCaptureFilters.Designer.cs @@ -0,0 +1,416 @@ +namespace ProjectCarbon +{ + partial class frmCaptureFilters + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.tcCaptureFilters = new System.Windows.Forms.TabControl(); + this.tabPage1 = new System.Windows.Forms.TabPage(); + this.grpFilterType = new System.Windows.Forms.GroupBox(); + this.rbExclusiveProtocolFilter = new System.Windows.Forms.RadioButton(); + this.rbInclusiveProtocolFilter = new System.Windows.Forms.RadioButton(); + this.label1 = new System.Windows.Forms.Label(); + this.clbProtocolFilters = new System.Windows.Forms.CheckedListBox(); + this.tpPortFilters = new System.Windows.Forms.TabPage(); + this.grpAddCustomPort = new System.Windows.Forms.GroupBox(); + this.txtPort = new System.Windows.Forms.TextBox(); + this.lblPort = new System.Windows.Forms.Label(); + this.btnAddCustomPort = new System.Windows.Forms.Button(); + this.btnRemoveAll = new System.Windows.Forms.Button(); + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.rbExclusivePortFilter = new System.Windows.Forms.RadioButton(); + this.rbInclusivePortFilter = new System.Windows.Forms.RadioButton(); + this.btnRemovePort = new System.Windows.Forms.Button(); + this.btnAddPort = new System.Windows.Forms.Button(); + this.lblCommonPorts = new System.Windows.Forms.Label(); + this.lstCommonPorts = new System.Windows.Forms.ListBox(); + this.label3 = new System.Windows.Forms.Label(); + this.lblFilteredPorts = new System.Windows.Forms.Label(); + this.lstFilteredPorts = new System.Windows.Forms.ListBox(); + this.cmdCancel = new System.Windows.Forms.Button(); + this.cmdApply = new System.Windows.Forms.Button(); + this.tcCaptureFilters.SuspendLayout(); + this.tabPage1.SuspendLayout(); + this.grpFilterType.SuspendLayout(); + this.tpPortFilters.SuspendLayout(); + this.grpAddCustomPort.SuspendLayout(); + this.groupBox1.SuspendLayout(); + this.SuspendLayout(); + // + // tcCaptureFilters + // + this.tcCaptureFilters.Controls.Add(this.tabPage1); + this.tcCaptureFilters.Controls.Add(this.tpPortFilters); + this.tcCaptureFilters.Location = new System.Drawing.Point(8, 8); + this.tcCaptureFilters.Name = "tcCaptureFilters"; + this.tcCaptureFilters.SelectedIndex = 0; + this.tcCaptureFilters.Size = new System.Drawing.Size(400, 296); + this.tcCaptureFilters.TabIndex = 0; + // + // tabPage1 + // + this.tabPage1.Controls.Add(this.grpFilterType); + this.tabPage1.Controls.Add(this.label1); + this.tabPage1.Controls.Add(this.clbProtocolFilters); + this.tabPage1.Location = new System.Drawing.Point(4, 22); + this.tabPage1.Name = "tabPage1"; + this.tabPage1.Padding = new System.Windows.Forms.Padding(3); + this.tabPage1.Size = new System.Drawing.Size(392, 270); + this.tabPage1.TabIndex = 0; + this.tabPage1.Text = "Protocol"; + this.tabPage1.UseVisualStyleBackColor = true; + // + // grpFilterType + // + this.grpFilterType.Controls.Add(this.rbExclusiveProtocolFilter); + this.grpFilterType.Controls.Add(this.rbInclusiveProtocolFilter); + this.grpFilterType.Location = new System.Drawing.Point(120, 8); + this.grpFilterType.Name = "grpFilterType"; + this.grpFilterType.Size = new System.Drawing.Size(264, 64); + this.grpFilterType.TabIndex = 4; + this.grpFilterType.TabStop = false; + this.grpFilterType.Text = "Filter Type"; + // + // rbExclusiveProtocolFilter + // + this.rbExclusiveProtocolFilter.AutoSize = true; + this.rbExclusiveProtocolFilter.Location = new System.Drawing.Point(8, 40); + this.rbExclusiveProtocolFilter.Name = "rbExclusiveProtocolFilter"; + this.rbExclusiveProtocolFilter.Size = new System.Drawing.Size(69, 17); + this.rbExclusiveProtocolFilter.TabIndex = 4; + this.rbExclusiveProtocolFilter.Text = "Exclusive"; + this.rbExclusiveProtocolFilter.UseVisualStyleBackColor = true; + // + // rbInclusiveProtocolFilter + // + this.rbInclusiveProtocolFilter.AutoSize = true; + this.rbInclusiveProtocolFilter.Checked = true; + this.rbInclusiveProtocolFilter.Location = new System.Drawing.Point(8, 16); + this.rbInclusiveProtocolFilter.Name = "rbInclusiveProtocolFilter"; + this.rbInclusiveProtocolFilter.Size = new System.Drawing.Size(67, 17); + this.rbInclusiveProtocolFilter.TabIndex = 3; + this.rbInclusiveProtocolFilter.TabStop = true; + this.rbInclusiveProtocolFilter.Text = "Inclusive"; + this.rbInclusiveProtocolFilter.UseVisualStyleBackColor = true; + // + // label1 + // + this.label1.Location = new System.Drawing.Point(8, 224); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(368, 32); + this.label1.TabIndex = 3; + this.label1.Text = "Each IP header contains a protocol id, this will let you filter out or in packets" + + " using this identifier."; + // + // clbProtocolFilters + // + this.clbProtocolFilters.FormattingEnabled = true; + this.clbProtocolFilters.IntegralHeight = false; + this.clbProtocolFilters.Items.AddRange(new object[] { + "ICMP", + "IGMP", + "GGP", + "IP", + "ST", + "TCP", + "CBT", + "EGP", + "IGP", + "PUP", + "UDP", + "IDP", + "ND"}); + this.clbProtocolFilters.Location = new System.Drawing.Point(8, 8); + this.clbProtocolFilters.Name = "clbProtocolFilters"; + this.clbProtocolFilters.Size = new System.Drawing.Size(104, 208); + this.clbProtocolFilters.TabIndex = 0; + // + // tpPortFilters + // + this.tpPortFilters.Controls.Add(this.grpAddCustomPort); + this.tpPortFilters.Controls.Add(this.btnRemoveAll); + this.tpPortFilters.Controls.Add(this.groupBox1); + this.tpPortFilters.Controls.Add(this.btnRemovePort); + this.tpPortFilters.Controls.Add(this.btnAddPort); + this.tpPortFilters.Controls.Add(this.lblCommonPorts); + this.tpPortFilters.Controls.Add(this.lstCommonPorts); + this.tpPortFilters.Controls.Add(this.label3); + this.tpPortFilters.Controls.Add(this.lblFilteredPorts); + this.tpPortFilters.Controls.Add(this.lstFilteredPorts); + this.tpPortFilters.Location = new System.Drawing.Point(4, 22); + this.tpPortFilters.Name = "tpPortFilters"; + this.tpPortFilters.Size = new System.Drawing.Size(392, 270); + this.tpPortFilters.TabIndex = 2; + this.tpPortFilters.Text = "Ports"; + this.tpPortFilters.UseVisualStyleBackColor = true; + // + // grpAddCustomPort + // + this.grpAddCustomPort.Controls.Add(this.txtPort); + this.grpAddCustomPort.Controls.Add(this.lblPort); + this.grpAddCustomPort.Controls.Add(this.btnAddCustomPort); + this.grpAddCustomPort.Location = new System.Drawing.Point(128, 120); + this.grpAddCustomPort.Name = "grpAddCustomPort"; + this.grpAddCustomPort.Size = new System.Drawing.Size(112, 96); + this.grpAddCustomPort.TabIndex = 14; + this.grpAddCustomPort.TabStop = false; + this.grpAddCustomPort.Text = "Custom Port"; + // + // txtPort + // + this.txtPort.Location = new System.Drawing.Point(8, 64); + this.txtPort.Name = "txtPort"; + this.txtPort.Size = new System.Drawing.Size(96, 21); + this.txtPort.TabIndex = 17; + // + // lblPort + // + this.lblPort.AutoSize = true; + this.lblPort.Location = new System.Drawing.Point(8, 48); + this.lblPort.Name = "lblPort"; + this.lblPort.Size = new System.Drawing.Size(31, 13); + this.lblPort.TabIndex = 16; + this.lblPort.Text = "Port:"; + // + // btnAddCustomPort + // + this.btnAddCustomPort.Location = new System.Drawing.Point(8, 16); + this.btnAddCustomPort.Name = "btnAddCustomPort"; + this.btnAddCustomPort.Size = new System.Drawing.Size(96, 23); + this.btnAddCustomPort.TabIndex = 15; + this.btnAddCustomPort.Text = "<< Add Custom"; + this.btnAddCustomPort.UseVisualStyleBackColor = true; + this.btnAddCustomPort.Click += new System.EventHandler(this.btnAddCustomPort_Click); + // + // btnRemoveAll + // + this.btnRemoveAll.Location = new System.Drawing.Point(128, 88); + this.btnRemoveAll.Name = "btnRemoveAll"; + this.btnRemoveAll.Size = new System.Drawing.Size(112, 24); + this.btnRemoveAll.TabIndex = 13; + this.btnRemoveAll.Text = "Remove All >>"; + this.btnRemoveAll.UseVisualStyleBackColor = true; + this.btnRemoveAll.Click += new System.EventHandler(this.btnRemoveAll_Click); + // + // groupBox1 + // + this.groupBox1.Controls.Add(this.rbExclusivePortFilter); + this.groupBox1.Controls.Add(this.rbInclusivePortFilter); + this.groupBox1.Location = new System.Drawing.Point(8, 224); + this.groupBox1.Name = "groupBox1"; + this.groupBox1.Size = new System.Drawing.Size(160, 40); + this.groupBox1.TabIndex = 12; + this.groupBox1.TabStop = false; + this.groupBox1.Text = "Filter Type"; + // + // rbExclusivePortFilter + // + this.rbExclusivePortFilter.AutoSize = true; + this.rbExclusivePortFilter.Location = new System.Drawing.Point(80, 16); + this.rbExclusivePortFilter.Name = "rbExclusivePortFilter"; + this.rbExclusivePortFilter.Size = new System.Drawing.Size(69, 17); + this.rbExclusivePortFilter.TabIndex = 4; + this.rbExclusivePortFilter.Text = "Exclusive"; + this.rbExclusivePortFilter.UseVisualStyleBackColor = true; + // + // rbInclusivePortFilter + // + this.rbInclusivePortFilter.AutoSize = true; + this.rbInclusivePortFilter.Checked = true; + this.rbInclusivePortFilter.Location = new System.Drawing.Point(8, 16); + this.rbInclusivePortFilter.Name = "rbInclusivePortFilter"; + this.rbInclusivePortFilter.Size = new System.Drawing.Size(67, 17); + this.rbInclusivePortFilter.TabIndex = 3; + this.rbInclusivePortFilter.TabStop = true; + this.rbInclusivePortFilter.Text = "Inclusive"; + this.rbInclusivePortFilter.UseVisualStyleBackColor = true; + // + // btnRemovePort + // + this.btnRemovePort.Location = new System.Drawing.Point(128, 56); + this.btnRemovePort.Name = "btnRemovePort"; + this.btnRemovePort.Size = new System.Drawing.Size(112, 23); + this.btnRemovePort.TabIndex = 8; + this.btnRemovePort.Text = "Remove >>"; + this.btnRemovePort.UseVisualStyleBackColor = true; + this.btnRemovePort.Click += new System.EventHandler(this.btnRemovePort_Click); + // + // btnAddPort + // + this.btnAddPort.Location = new System.Drawing.Point(128, 24); + this.btnAddPort.Name = "btnAddPort"; + this.btnAddPort.Size = new System.Drawing.Size(112, 23); + this.btnAddPort.TabIndex = 7; + this.btnAddPort.Text = "<< Add"; + this.btnAddPort.UseVisualStyleBackColor = true; + this.btnAddPort.Click += new System.EventHandler(this.btnAddPort_Click); + // + // lblCommonPorts + // + this.lblCommonPorts.AutoSize = true; + this.lblCommonPorts.Location = new System.Drawing.Point(248, 8); + this.lblCommonPorts.Name = "lblCommonPorts"; + this.lblCommonPorts.Size = new System.Drawing.Size(80, 13); + this.lblCommonPorts.TabIndex = 6; + this.lblCommonPorts.Text = "Common Ports:"; + // + // lstCommonPorts + // + this.lstCommonPorts.FormattingEnabled = true; + this.lstCommonPorts.IntegralHeight = false; + this.lstCommonPorts.Items.AddRange(new object[] { + "80", + "21", + "23", + "25", + "53", + "109", + "110", + "113", + "143", + "194", + "443", + "540", + "758", + "774", + "2004", + "4000", + "5050", + "5180", + "5190", + "6000", + "6667"}); + this.lstCommonPorts.Location = new System.Drawing.Point(248, 24); + this.lstCommonPorts.Name = "lstCommonPorts"; + this.lstCommonPorts.Size = new System.Drawing.Size(136, 192); + this.lstCommonPorts.TabIndex = 5; + // + // label3 + // + this.label3.Location = new System.Drawing.Point(176, 224); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(208, 40); + this.label3.TabIndex = 4; + this.label3.Text = "Note: Filtered ports apply to packet source port OR destination port."; + // + // lblFilteredPorts + // + this.lblFilteredPorts.AutoSize = true; + this.lblFilteredPorts.Location = new System.Drawing.Point(8, 8); + this.lblFilteredPorts.Name = "lblFilteredPorts"; + this.lblFilteredPorts.Size = new System.Drawing.Size(75, 13); + this.lblFilteredPorts.TabIndex = 1; + this.lblFilteredPorts.Text = "Filtered Ports:"; + // + // lstFilteredPorts + // + this.lstFilteredPorts.FormattingEnabled = true; + this.lstFilteredPorts.IntegralHeight = false; + this.lstFilteredPorts.Location = new System.Drawing.Point(8, 24); + this.lstFilteredPorts.Name = "lstFilteredPorts"; + this.lstFilteredPorts.Size = new System.Drawing.Size(112, 192); + this.lstFilteredPorts.TabIndex = 0; + // + // cmdCancel + // + this.cmdCancel.Location = new System.Drawing.Point(240, 312); + this.cmdCancel.Name = "cmdCancel"; + this.cmdCancel.Size = new System.Drawing.Size(80, 23); + this.cmdCancel.TabIndex = 4; + this.cmdCancel.Text = "Cancel"; + this.cmdCancel.UseVisualStyleBackColor = true; + this.cmdCancel.Click += new System.EventHandler(this.cmdCancel_Click); + // + // cmdApply + // + this.cmdApply.Location = new System.Drawing.Point(328, 312); + this.cmdApply.Name = "cmdApply"; + this.cmdApply.Size = new System.Drawing.Size(80, 23); + this.cmdApply.TabIndex = 3; + this.cmdApply.Text = "Apply"; + this.cmdApply.UseVisualStyleBackColor = true; + this.cmdApply.Click += new System.EventHandler(this.cmdApply_Click); + // + // frmCaptureFilters + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(416, 344); + this.Controls.Add(this.cmdCancel); + this.Controls.Add(this.cmdApply); + this.Controls.Add(this.tcCaptureFilters); + this.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "frmCaptureFilters"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Capture Filters"; + this.Load += new System.EventHandler(this.CaptureFilters_Load); + this.tcCaptureFilters.ResumeLayout(false); + this.tabPage1.ResumeLayout(false); + this.grpFilterType.ResumeLayout(false); + this.grpFilterType.PerformLayout(); + this.tpPortFilters.ResumeLayout(false); + this.tpPortFilters.PerformLayout(); + this.grpAddCustomPort.ResumeLayout(false); + this.grpAddCustomPort.PerformLayout(); + this.groupBox1.ResumeLayout(false); + this.groupBox1.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.TabControl tcCaptureFilters; + private System.Windows.Forms.TabPage tabPage1; + private System.Windows.Forms.TabPage tpPortFilters; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.CheckedListBox clbProtocolFilters; + private System.Windows.Forms.Button cmdCancel; + private System.Windows.Forms.Button cmdApply; + private System.Windows.Forms.Label lblCommonPorts; + private System.Windows.Forms.ListBox lstCommonPorts; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Label lblFilteredPorts; + private System.Windows.Forms.ListBox lstFilteredPorts; + private System.Windows.Forms.Button btnRemovePort; + private System.Windows.Forms.Button btnAddPort; + private System.Windows.Forms.GroupBox grpFilterType; + private System.Windows.Forms.RadioButton rbExclusiveProtocolFilter; + private System.Windows.Forms.RadioButton rbInclusiveProtocolFilter; + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.RadioButton rbExclusivePortFilter; + private System.Windows.Forms.RadioButton rbInclusivePortFilter; + private System.Windows.Forms.Button btnRemoveAll; + private System.Windows.Forms.GroupBox grpAddCustomPort; + private System.Windows.Forms.TextBox txtPort; + private System.Windows.Forms.Label lblPort; + private System.Windows.Forms.Button btnAddCustomPort; + } +} \ No newline at end of file diff --git a/ProjectCarbon/frmCaptureFilters.cs b/ProjectCarbon/frmCaptureFilters.cs new file mode 100644 index 0000000..370b244 --- /dev/null +++ b/ProjectCarbon/frmCaptureFilters.cs @@ -0,0 +1,100 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using ProjectCarbon.Properties; + +namespace ProjectCarbon +{ + public partial class frmCaptureFilters : Form + { + public frmCaptureFilters() + { + InitializeComponent(); + } + + private void cmdApply_Click(object sender, EventArgs e) + { + Global.FilteredProtocolList.Clear(); + for (int i = 0; i < clbProtocolFilters.CheckedIndices.Count; i++) + { + Global.FilteredProtocolList.Add((string)clbProtocolFilters.Items[clbProtocolFilters.CheckedIndices[i]]); + } + Global.ProtocolFilterInclusive = rbInclusiveProtocolFilter.Checked; + + Global.FilteredPortList.Clear(); + for (int i = 0; i < lstFilteredPorts.Items.Count; i++) + Global.FilteredPortList.Add((int)lstFilteredPorts.Items[i]); + Global.PortFilterInclusive = rbInclusivePortFilter.Checked; + + this.Close(); + } + + private void CaptureFilters_Load(object sender, EventArgs e) + { + for (int i = 0; i < Global.FilteredProtocolList.Count; i++) + { + int itemIndex = clbProtocolFilters.FindString(Global.FilteredProtocolList[i]); + clbProtocolFilters.SetItemChecked(itemIndex, true); + } + + if (Global.ProtocolFilterInclusive) + rbInclusiveProtocolFilter.Checked = true; + else + rbExclusiveProtocolFilter.Checked = true; + + if (Global.PortFilterInclusive) + rbInclusivePortFilter.Checked = true; + else + rbExclusivePortFilter.Checked = true; + + for (int i = 0; i < Global.FilteredPortList.Count; i++) + lstFilteredPorts.Items.Add((int)(Global.FilteredPortList[i])); + } + + private void btnAddCustomPort_Click(object sender, EventArgs e) + { + int i = 0; + if (txtPort.Text.Length > 0) + { + try + { + i = int.Parse(txtPort.Text); + if (i > 0) + lstFilteredPorts.Items.Add((int)i); + } + catch (FormatException) + { + MessageBox.Show("There was a problem with the port you attempted to add.", + "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } + + private void btnAddPort_Click(object sender, EventArgs e) + { + if(lstCommonPorts.SelectedItem != null) + lstFilteredPorts.Items.Add(int.Parse((string)lstCommonPorts.SelectedItem)); + } + + private void btnRemovePort_Click(object sender, EventArgs e) + { + if (lstFilteredPorts.SelectedItem != null) + lstFilteredPorts.Items.RemoveAt(lstFilteredPorts.SelectedIndex); + } + + private void cmdCancel_Click(object sender, EventArgs e) + { + this.Close(); + } + + private void btnRemoveAll_Click(object sender, EventArgs e) + { + lstFilteredPorts.Items.Clear(); + } + } +} \ No newline at end of file diff --git a/ProjectCarbon/frmCaptureFilters.resx b/ProjectCarbon/frmCaptureFilters.resx new file mode 100644 index 0000000..19dc0dd --- /dev/null +++ b/ProjectCarbon/frmCaptureFilters.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectCarbon/frmCaptureSettings.Designer.cs b/ProjectCarbon/frmCaptureSettings.Designer.cs new file mode 100644 index 0000000..1300a05 --- /dev/null +++ b/ProjectCarbon/frmCaptureSettings.Designer.cs @@ -0,0 +1,425 @@ +namespace ProjectCarbon +{ + partial class frmCaptureSettings + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.btnApply = new System.Windows.Forms.Button(); + this.btnCancel = new System.Windows.Forms.Button(); + this.tabControl1 = new System.Windows.Forms.TabControl(); + this.tabCaptureSettings = new System.Windows.Forms.TabPage(); + this.grpStartupOptions = new System.Windows.Forms.GroupBox(); + this.chkStartCaptureAtStartup = new System.Windows.Forms.CheckBox(); + this.chkStartMinimized = new System.Windows.Forms.CheckBox(); + this.chkStartWithWindows = new System.Windows.Forms.CheckBox(); + this.tabUISettings = new System.Windows.Forms.TabPage(); + this.grpOther = new System.Windows.Forms.GroupBox(); + this.chkAutoScrollPacketList = new System.Windows.Forms.CheckBox(); + this.grpVisibleInterfaceElements = new System.Windows.Forms.GroupBox(); + this.chkHeaderInfoVisible = new System.Windows.Forms.CheckBox(); + this.chkPacketListVisible = new System.Windows.Forms.CheckBox(); + this.chkPacketDisplayVisible = new System.Windows.Forms.CheckBox(); + this.chkStatusBarVisible = new System.Windows.Forms.CheckBox(); + this.chkToolbarVisible = new System.Windows.Forms.CheckBox(); + this.grpInterfaceAppearance = new System.Windows.Forms.GroupBox(); + this.btnPacketListFont = new System.Windows.Forms.Button(); + this.picPacketDisplayBackground = new System.Windows.Forms.PictureBox(); + this.label4 = new System.Windows.Forms.Label(); + this.picPacketDisplayFontColor = new System.Windows.Forms.PictureBox(); + this.label3 = new System.Windows.Forms.Label(); + this.picPacketListTextColor = new System.Windows.Forms.PictureBox(); + this.label2 = new System.Windows.Forms.Label(); + this.picPacketListBackgroundColor = new System.Windows.Forms.PictureBox(); + this.label1 = new System.Windows.Forms.Label(); + this.tabControl1.SuspendLayout(); + this.tabCaptureSettings.SuspendLayout(); + this.grpStartupOptions.SuspendLayout(); + this.tabUISettings.SuspendLayout(); + this.grpOther.SuspendLayout(); + this.grpVisibleInterfaceElements.SuspendLayout(); + this.grpInterfaceAppearance.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.picPacketDisplayBackground)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.picPacketDisplayFontColor)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.picPacketListTextColor)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.picPacketListBackgroundColor)).BeginInit(); + this.SuspendLayout(); + // + // btnApply + // + this.btnApply.Location = new System.Drawing.Point(336, 280); + this.btnApply.Name = "btnApply"; + this.btnApply.Size = new System.Drawing.Size(80, 24); + this.btnApply.TabIndex = 1; + this.btnApply.Text = "Apply"; + this.btnApply.UseVisualStyleBackColor = true; + this.btnApply.Click += new System.EventHandler(this.btnApply_Click); + // + // btnCancel + // + this.btnCancel.Location = new System.Drawing.Point(248, 280); + this.btnCancel.Name = "btnCancel"; + this.btnCancel.Size = new System.Drawing.Size(80, 24); + this.btnCancel.TabIndex = 2; + this.btnCancel.Text = "Cancel"; + this.btnCancel.UseVisualStyleBackColor = true; + this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click); + // + // tabControl1 + // + this.tabControl1.Controls.Add(this.tabCaptureSettings); + this.tabControl1.Controls.Add(this.tabUISettings); + this.tabControl1.Location = new System.Drawing.Point(8, 8); + this.tabControl1.Name = "tabControl1"; + this.tabControl1.SelectedIndex = 0; + this.tabControl1.Size = new System.Drawing.Size(408, 264); + this.tabControl1.TabIndex = 5; + // + // tabCaptureSettings + // + this.tabCaptureSettings.Controls.Add(this.grpStartupOptions); + this.tabCaptureSettings.Location = new System.Drawing.Point(4, 22); + this.tabCaptureSettings.Name = "tabCaptureSettings"; + this.tabCaptureSettings.Padding = new System.Windows.Forms.Padding(3); + this.tabCaptureSettings.Size = new System.Drawing.Size(400, 238); + this.tabCaptureSettings.TabIndex = 0; + this.tabCaptureSettings.Text = "Capture Settings"; + this.tabCaptureSettings.UseVisualStyleBackColor = true; + // + // grpStartupOptions + // + this.grpStartupOptions.Controls.Add(this.chkStartCaptureAtStartup); + this.grpStartupOptions.Controls.Add(this.chkStartMinimized); + this.grpStartupOptions.Controls.Add(this.chkStartWithWindows); + this.grpStartupOptions.Location = new System.Drawing.Point(8, 8); + this.grpStartupOptions.Name = "grpStartupOptions"; + this.grpStartupOptions.Size = new System.Drawing.Size(384, 72); + this.grpStartupOptions.TabIndex = 5; + this.grpStartupOptions.TabStop = false; + this.grpStartupOptions.Text = "Startup Options"; + // + // chkStartCaptureAtStartup + // + this.chkStartCaptureAtStartup.AutoSize = true; + this.chkStartCaptureAtStartup.Location = new System.Drawing.Point(8, 48); + this.chkStartCaptureAtStartup.Name = "chkStartCaptureAtStartup"; + this.chkStartCaptureAtStartup.Size = new System.Drawing.Size(196, 17); + this.chkStartCaptureAtStartup.TabIndex = 2; + this.chkStartCaptureAtStartup.Text = "Start capturing packets at start up."; + this.chkStartCaptureAtStartup.UseVisualStyleBackColor = true; + // + // chkStartMinimized + // + this.chkStartMinimized.AutoSize = true; + this.chkStartMinimized.Location = new System.Drawing.Point(8, 32); + this.chkStartMinimized.Name = "chkStartMinimized"; + this.chkStartMinimized.Size = new System.Drawing.Size(168, 17); + this.chkStartMinimized.TabIndex = 1; + this.chkStartMinimized.Text = "Start up minimized to the tray"; + this.chkStartMinimized.UseVisualStyleBackColor = true; + // + // chkStartWithWindows + // + this.chkStartWithWindows.AutoSize = true; + this.chkStartWithWindows.Location = new System.Drawing.Point(8, 16); + this.chkStartWithWindows.Name = "chkStartWithWindows"; + this.chkStartWithWindows.Size = new System.Drawing.Size(121, 17); + this.chkStartWithWindows.TabIndex = 0; + this.chkStartWithWindows.Text = "Start With Windows"; + this.chkStartWithWindows.UseVisualStyleBackColor = true; + // + // tabUISettings + // + this.tabUISettings.Controls.Add(this.grpOther); + this.tabUISettings.Controls.Add(this.grpVisibleInterfaceElements); + this.tabUISettings.Controls.Add(this.grpInterfaceAppearance); + this.tabUISettings.Location = new System.Drawing.Point(4, 22); + this.tabUISettings.Name = "tabUISettings"; + this.tabUISettings.Padding = new System.Windows.Forms.Padding(3); + this.tabUISettings.Size = new System.Drawing.Size(400, 238); + this.tabUISettings.TabIndex = 1; + this.tabUISettings.Text = "UI Settings"; + this.tabUISettings.UseVisualStyleBackColor = true; + // + // grpOther + // + this.grpOther.Controls.Add(this.chkAutoScrollPacketList); + this.grpOther.Location = new System.Drawing.Point(8, 184); + this.grpOther.Name = "grpOther"; + this.grpOther.Size = new System.Drawing.Size(384, 40); + this.grpOther.TabIndex = 16; + this.grpOther.TabStop = false; + this.grpOther.Text = "Other"; + // + // chkAutoScrollPacketList + // + this.chkAutoScrollPacketList.AutoSize = true; + this.chkAutoScrollPacketList.Location = new System.Drawing.Point(8, 17); + this.chkAutoScrollPacketList.Name = "chkAutoScrollPacketList"; + this.chkAutoScrollPacketList.Size = new System.Drawing.Size(131, 17); + this.chkAutoScrollPacketList.TabIndex = 0; + this.chkAutoScrollPacketList.Text = "Auto-scroll Packet List"; + this.chkAutoScrollPacketList.UseVisualStyleBackColor = true; + // + // grpVisibleInterfaceElements + // + this.grpVisibleInterfaceElements.Controls.Add(this.chkHeaderInfoVisible); + this.grpVisibleInterfaceElements.Controls.Add(this.chkPacketListVisible); + this.grpVisibleInterfaceElements.Controls.Add(this.chkPacketDisplayVisible); + this.grpVisibleInterfaceElements.Controls.Add(this.chkStatusBarVisible); + this.grpVisibleInterfaceElements.Controls.Add(this.chkToolbarVisible); + this.grpVisibleInterfaceElements.Location = new System.Drawing.Point(8, 8); + this.grpVisibleInterfaceElements.Name = "grpVisibleInterfaceElements"; + this.grpVisibleInterfaceElements.Size = new System.Drawing.Size(120, 168); + this.grpVisibleInterfaceElements.TabIndex = 15; + this.grpVisibleInterfaceElements.TabStop = false; + this.grpVisibleInterfaceElements.Text = "Visible Elements"; + // + // chkHeaderInfoVisible + // + this.chkHeaderInfoVisible.AutoSize = true; + this.chkHeaderInfoVisible.Location = new System.Drawing.Point(16, 120); + this.chkHeaderInfoVisible.Name = "chkHeaderInfoVisible"; + this.chkHeaderInfoVisible.Size = new System.Drawing.Size(84, 17); + this.chkHeaderInfoVisible.TabIndex = 9; + this.chkHeaderInfoVisible.Text = "Header Info"; + this.chkHeaderInfoVisible.UseVisualStyleBackColor = true; + // + // chkPacketListVisible + // + this.chkPacketListVisible.AutoSize = true; + this.chkPacketListVisible.Location = new System.Drawing.Point(16, 72); + this.chkPacketListVisible.Name = "chkPacketListVisible"; + this.chkPacketListVisible.Size = new System.Drawing.Size(77, 17); + this.chkPacketListVisible.TabIndex = 8; + this.chkPacketListVisible.Text = "Packet List"; + this.chkPacketListVisible.UseVisualStyleBackColor = true; + // + // chkPacketDisplayVisible + // + this.chkPacketDisplayVisible.AutoSize = true; + this.chkPacketDisplayVisible.Location = new System.Drawing.Point(16, 96); + this.chkPacketDisplayVisible.Name = "chkPacketDisplayVisible"; + this.chkPacketDisplayVisible.Size = new System.Drawing.Size(95, 17); + this.chkPacketDisplayVisible.TabIndex = 7; + this.chkPacketDisplayVisible.Text = "Packet Display"; + this.chkPacketDisplayVisible.UseVisualStyleBackColor = true; + // + // chkStatusBarVisible + // + this.chkStatusBarVisible.AutoSize = true; + this.chkStatusBarVisible.Location = new System.Drawing.Point(16, 48); + this.chkStatusBarVisible.Name = "chkStatusBarVisible"; + this.chkStatusBarVisible.Size = new System.Drawing.Size(76, 17); + this.chkStatusBarVisible.TabIndex = 6; + this.chkStatusBarVisible.Text = "Status Bar"; + this.chkStatusBarVisible.UseVisualStyleBackColor = true; + // + // chkToolbarVisible + // + this.chkToolbarVisible.AutoSize = true; + this.chkToolbarVisible.Location = new System.Drawing.Point(16, 24); + this.chkToolbarVisible.Name = "chkToolbarVisible"; + this.chkToolbarVisible.Size = new System.Drawing.Size(62, 17); + this.chkToolbarVisible.TabIndex = 5; + this.chkToolbarVisible.Text = "Toolbar"; + this.chkToolbarVisible.UseVisualStyleBackColor = true; + // + // grpInterfaceAppearance + // + this.grpInterfaceAppearance.Controls.Add(this.btnPacketListFont); + this.grpInterfaceAppearance.Controls.Add(this.picPacketDisplayBackground); + this.grpInterfaceAppearance.Controls.Add(this.label4); + this.grpInterfaceAppearance.Controls.Add(this.picPacketDisplayFontColor); + this.grpInterfaceAppearance.Controls.Add(this.label3); + this.grpInterfaceAppearance.Controls.Add(this.picPacketListTextColor); + this.grpInterfaceAppearance.Controls.Add(this.label2); + this.grpInterfaceAppearance.Controls.Add(this.picPacketListBackgroundColor); + this.grpInterfaceAppearance.Controls.Add(this.label1); + this.grpInterfaceAppearance.Location = new System.Drawing.Point(136, 8); + this.grpInterfaceAppearance.Name = "grpInterfaceAppearance"; + this.grpInterfaceAppearance.Size = new System.Drawing.Size(256, 168); + this.grpInterfaceAppearance.TabIndex = 14; + this.grpInterfaceAppearance.TabStop = false; + this.grpInterfaceAppearance.Text = "Interface Appearance"; + // + // btnPacketListFont + // + this.btnPacketListFont.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.btnPacketListFont.Location = new System.Drawing.Point(16, 96); + this.btnPacketListFont.Name = "btnPacketListFont"; + this.btnPacketListFont.Size = new System.Drawing.Size(224, 32); + this.btnPacketListFont.TabIndex = 22; + this.btnPacketListFont.Text = "Packet Display Font"; + this.btnPacketListFont.UseVisualStyleBackColor = true; + this.btnPacketListFont.Click += new System.EventHandler(this.btnPacketListFont_Click); + // + // picPacketDisplayBackground + // + this.picPacketDisplayBackground.BackColor = System.Drawing.Color.Red; + this.picPacketDisplayBackground.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.picPacketDisplayBackground.Location = new System.Drawing.Point(16, 136); + this.picPacketDisplayBackground.Name = "picPacketDisplayBackground"; + this.picPacketDisplayBackground.Size = new System.Drawing.Size(24, 16); + this.picPacketDisplayBackground.TabIndex = 21; + this.picPacketDisplayBackground.TabStop = false; + this.picPacketDisplayBackground.Click += new System.EventHandler(this.picPacketDisplayBackground_Click); + // + // label4 + // + this.label4.AutoSize = true; + this.label4.Location = new System.Drawing.Point(40, 136); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(135, 13); + this.label4.TabIndex = 20; + this.label4.Text = "Packet Display Background"; + // + // picPacketDisplayFontColor + // + this.picPacketDisplayFontColor.BackColor = System.Drawing.Color.Red; + this.picPacketDisplayFontColor.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.picPacketDisplayFontColor.Location = new System.Drawing.Point(16, 72); + this.picPacketDisplayFontColor.Name = "picPacketDisplayFontColor"; + this.picPacketDisplayFontColor.Size = new System.Drawing.Size(24, 16); + this.picPacketDisplayFontColor.TabIndex = 19; + this.picPacketDisplayFontColor.TabStop = false; + this.picPacketDisplayFontColor.Click += new System.EventHandler(this.picPacketDisplayFontColor_Click); + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(40, 72); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(129, 13); + this.label3.TabIndex = 18; + this.label3.Text = "Packet Display Font Color"; + // + // picPacketListTextColor + // + this.picPacketListTextColor.BackColor = System.Drawing.Color.Red; + this.picPacketListTextColor.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.picPacketListTextColor.Location = new System.Drawing.Point(16, 48); + this.picPacketListTextColor.Name = "picPacketListTextColor"; + this.picPacketListTextColor.Size = new System.Drawing.Size(24, 16); + this.picPacketListTextColor.TabIndex = 17; + this.picPacketListTextColor.TabStop = false; + this.picPacketListTextColor.Click += new System.EventHandler(this.picPacketListTextColor_Click); + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(40, 48); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(111, 13); + this.label2.TabIndex = 16; + this.label2.Text = "Packet List Text Color"; + // + // picPacketListBackgroundColor + // + this.picPacketListBackgroundColor.BackColor = System.Drawing.Color.Red; + this.picPacketListBackgroundColor.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.picPacketListBackgroundColor.Location = new System.Drawing.Point(16, 24); + this.picPacketListBackgroundColor.Name = "picPacketListBackgroundColor"; + this.picPacketListBackgroundColor.Size = new System.Drawing.Size(24, 16); + this.picPacketListBackgroundColor.TabIndex = 15; + this.picPacketListBackgroundColor.TabStop = false; + this.picPacketListBackgroundColor.Click += new System.EventHandler(this.picPacketListBackgroundColor_Click); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(40, 24); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(145, 13); + this.label1.TabIndex = 14; + this.label1.Text = "Packet List Background Color"; + // + // frmCaptureSettings + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(422, 311); + this.Controls.Add(this.tabControl1); + this.Controls.Add(this.btnCancel); + this.Controls.Add(this.btnApply); + this.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "frmCaptureSettings"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Capture Settings"; + this.Load += new System.EventHandler(this.CaptureSettings_Load); + this.tabControl1.ResumeLayout(false); + this.tabCaptureSettings.ResumeLayout(false); + this.grpStartupOptions.ResumeLayout(false); + this.grpStartupOptions.PerformLayout(); + this.tabUISettings.ResumeLayout(false); + this.grpOther.ResumeLayout(false); + this.grpOther.PerformLayout(); + this.grpVisibleInterfaceElements.ResumeLayout(false); + this.grpVisibleInterfaceElements.PerformLayout(); + this.grpInterfaceAppearance.ResumeLayout(false); + this.grpInterfaceAppearance.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.picPacketDisplayBackground)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.picPacketDisplayFontColor)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.picPacketListTextColor)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.picPacketListBackgroundColor)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button btnApply; + private System.Windows.Forms.Button btnCancel; + private System.Windows.Forms.TabControl tabControl1; + private System.Windows.Forms.TabPage tabCaptureSettings; + private System.Windows.Forms.GroupBox grpStartupOptions; + private System.Windows.Forms.CheckBox chkStartCaptureAtStartup; + private System.Windows.Forms.CheckBox chkStartMinimized; + private System.Windows.Forms.CheckBox chkStartWithWindows; + private System.Windows.Forms.TabPage tabUISettings; + private System.Windows.Forms.GroupBox grpOther; + private System.Windows.Forms.CheckBox chkAutoScrollPacketList; + private System.Windows.Forms.GroupBox grpVisibleInterfaceElements; + private System.Windows.Forms.CheckBox chkPacketListVisible; + private System.Windows.Forms.CheckBox chkPacketDisplayVisible; + private System.Windows.Forms.CheckBox chkStatusBarVisible; + private System.Windows.Forms.CheckBox chkToolbarVisible; + private System.Windows.Forms.GroupBox grpInterfaceAppearance; + private System.Windows.Forms.Button btnPacketListFont; + private System.Windows.Forms.PictureBox picPacketDisplayBackground; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.PictureBox picPacketDisplayFontColor; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.PictureBox picPacketListTextColor; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.PictureBox picPacketListBackgroundColor; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.CheckBox chkHeaderInfoVisible; + } +} \ No newline at end of file diff --git a/ProjectCarbon/frmCaptureSettings.cs b/ProjectCarbon/frmCaptureSettings.cs new file mode 100644 index 0000000..fd1bb30 --- /dev/null +++ b/ProjectCarbon/frmCaptureSettings.cs @@ -0,0 +1,128 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Text; +using System.Windows.Forms; + +namespace ProjectCarbon +{ + public partial class frmCaptureSettings : Form + { + public frmCaptureSettings() + { + InitializeComponent(); + } + + private void CaptureSettings_Load(object sender, EventArgs e) + { + chkStartCaptureAtStartup.Checked = + ProjectCarbon.Properties.Settings.Default.StartUpCapture; + + chkStartMinimized.Checked = + ProjectCarbon.Properties.Settings.Default.StartUpMinimized; + + chkStartWithWindows.Checked = + ProjectCarbon.Properties.Settings.Default.StartUpWindows; + + picPacketDisplayBackground.BackColor = + ProjectCarbon.Properties.Settings.Default.PacketDisplayBackgroundColor; + + picPacketDisplayFontColor.BackColor = + ProjectCarbon.Properties.Settings.Default.PacketDisplayFontColor; + + picPacketListBackgroundColor.BackColor = + ProjectCarbon.Properties.Settings.Default.PacketListBackgroundColor; + + picPacketListTextColor.BackColor = + ProjectCarbon.Properties.Settings.Default.PacketListTextColor; + + btnPacketListFont.Font = + ProjectCarbon.Properties.Settings.Default.PacketDisplayFontFace; + + chkAutoScrollPacketList.Checked = + ProjectCarbon.Properties.Settings.Default.AutoScrollPacketList; + + } + + private void btnApply_Click(object sender, EventArgs e) + { + ProjectCarbon.Properties.Settings.Default.StartUpCapture = + chkStartCaptureAtStartup.Checked; + + ProjectCarbon.Properties.Settings.Default.StartUpMinimized = + chkStartMinimized.Checked; + + ProjectCarbon.Properties.Settings.Default.StartUpWindows = + chkStartWithWindows.Checked; + + ProjectCarbon.Properties.Settings.Default.PacketDisplayBackgroundColor = + picPacketDisplayBackground.BackColor; + + ProjectCarbon.Properties.Settings.Default.PacketDisplayFontColor = + picPacketDisplayFontColor.BackColor; + + ProjectCarbon.Properties.Settings.Default.PacketDisplayFontFace = + btnPacketListFont.Font; + + ProjectCarbon.Properties.Settings.Default.PacketListBackgroundColor = + picPacketListBackgroundColor.BackColor; + + ProjectCarbon.Properties.Settings.Default.PacketListTextColor = + picPacketListTextColor.BackColor; + + ProjectCarbon.Properties.Settings.Default.AutoScrollPacketList = + chkAutoScrollPacketList.Checked; + + ProjectCarbon.Properties.Settings.Default.Save(); + + this.Close(); + } + + private void picPacketListBackgroundColor_Click(object sender, EventArgs e) + { + ColorDialog colorDlg = new ColorDialog(); + if (colorDlg.ShowDialog() != DialogResult.Cancel) + picPacketListBackgroundColor.BackColor = colorDlg.Color; + } + + private void picPacketListTextColor_Click(object sender, EventArgs e) + { + ColorDialog colorDlg = new ColorDialog(); + if (colorDlg.ShowDialog() != DialogResult.Cancel) + picPacketListTextColor.BackColor = colorDlg.Color; + } + + private void picPacketDisplayFontColor_Click(object sender, EventArgs e) + { + ColorDialog colorDlg = new ColorDialog(); + if (colorDlg.ShowDialog() != DialogResult.Cancel) + picPacketDisplayFontColor.BackColor = colorDlg.Color; + } + + private void picPacketDisplayBackground_Click(object sender, EventArgs e) + { + ColorDialog colorDlg = new ColorDialog(); + if (colorDlg.ShowDialog() != DialogResult.Cancel) + picPacketDisplayBackground.BackColor = colorDlg.Color; + } + + private void btnPacketListFont_Click(object sender, EventArgs e) + { + FontDialog fontDialog = new FontDialog(); + fontDialog.Font = btnPacketListFont.Font; + fontDialog.AllowVectorFonts = false; + fontDialog.FontMustExist = true; + fontDialog.ShowEffects = true; + fontDialog.AllowVerticalFonts = false; + if (fontDialog.ShowDialog() != DialogResult.Cancel) + btnPacketListFont.Font = fontDialog.Font; + } + + private void btnCancel_Click(object sender, EventArgs e) + { + this.Close(); + } + } +} \ No newline at end of file diff --git a/ProjectCarbon/frmCaptureSettings.resx b/ProjectCarbon/frmCaptureSettings.resx new file mode 100644 index 0000000..19dc0dd --- /dev/null +++ b/ProjectCarbon/frmCaptureSettings.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectCarbon/frmDnsLookup.Designer.cs b/ProjectCarbon/frmDnsLookup.Designer.cs new file mode 100644 index 0000000..c7ba541 --- /dev/null +++ b/ProjectCarbon/frmDnsLookup.Designer.cs @@ -0,0 +1,109 @@ +namespace ProjectCarbon +{ + partial class frmDnsLookup + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.lblHostname = new System.Windows.Forms.Label(); + this.txtHostname = new System.Windows.Forms.TextBox(); + this.btnLookup = new System.Windows.Forms.Button(); + this.lstResults = new System.Windows.Forms.ListBox(); + this.lblResults = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // lblHostname + // + this.lblHostname.AutoSize = true; + this.lblHostname.Location = new System.Drawing.Point(8, 8); + this.lblHostname.Name = "lblHostname"; + this.lblHostname.Size = new System.Drawing.Size(58, 13); + this.lblHostname.TabIndex = 0; + this.lblHostname.Text = "Hostname:"; + // + // txtHostname + // + this.txtHostname.Location = new System.Drawing.Point(8, 24); + this.txtHostname.Name = "txtHostname"; + this.txtHostname.Size = new System.Drawing.Size(304, 20); + this.txtHostname.TabIndex = 1; + // + // btnLookup + // + this.btnLookup.Location = new System.Drawing.Point(240, 56); + this.btnLookup.Name = "btnLookup"; + this.btnLookup.Size = new System.Drawing.Size(72, 24); + this.btnLookup.TabIndex = 2; + this.btnLookup.Text = "Lookup"; + this.btnLookup.UseVisualStyleBackColor = true; + this.btnLookup.Click += new System.EventHandler(this.btnLookup_Click); + // + // lstResults + // + this.lstResults.FormattingEnabled = true; + this.lstResults.Location = new System.Drawing.Point(8, 88); + this.lstResults.Name = "lstResults"; + this.lstResults.Size = new System.Drawing.Size(304, 160); + this.lstResults.TabIndex = 3; + // + // lblResults + // + this.lblResults.AutoSize = true; + this.lblResults.Location = new System.Drawing.Point(8, 72); + this.lblResults.Name = "lblResults"; + this.lblResults.Size = new System.Drawing.Size(45, 13); + this.lblResults.TabIndex = 4; + this.lblResults.Text = "Results:"; + // + // frmDnsLookup + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(322, 256); + this.Controls.Add(this.lblResults); + this.Controls.Add(this.lstResults); + this.Controls.Add(this.btnLookup); + this.Controls.Add(this.txtHostname); + this.Controls.Add(this.lblHostname); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "frmDnsLookup"; + this.Text = "DNS Lookup"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label lblHostname; + private System.Windows.Forms.TextBox txtHostname; + private System.Windows.Forms.Button btnLookup; + private System.Windows.Forms.ListBox lstResults; + private System.Windows.Forms.Label lblResults; + } +} \ No newline at end of file diff --git a/ProjectCarbon/frmDnsLookup.cs b/ProjectCarbon/frmDnsLookup.cs new file mode 100644 index 0000000..baf8878 --- /dev/null +++ b/ProjectCarbon/frmDnsLookup.cs @@ -0,0 +1,46 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using System.Net; + +namespace ProjectCarbon +{ + public partial class frmDnsLookup : Form + { + public frmDnsLookup() + { + InitializeComponent(); + } + + private void btnLookup_Click(object sender, EventArgs e) + { + char[] alpha = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ-".ToCharArray(); + try + { + IPHostEntry ipHostEntry = Dns.GetHostEntry(txtHostname.Text); + lstResults.Items.Clear(); + if (txtHostname.Text.IndexOfAny(alpha) != -1) + { + foreach (IPAddress ip in ipHostEntry.AddressList) + lstResults.Items.Add(ip.ToString()); + } + else + { + lstResults.Items.Add(ipHostEntry.HostName); + } + } + catch (System.Net.Sockets.SocketException se) + { + MessageBox.Show(se.Message); + } + catch (ArgumentException ae) + { + MessageBox.Show(ae.Message); + } + } + } +} \ No newline at end of file diff --git a/ProjectCarbon/frmDnsLookup.resx b/ProjectCarbon/frmDnsLookup.resx new file mode 100644 index 0000000..19dc0dd --- /dev/null +++ b/ProjectCarbon/frmDnsLookup.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectCarbon/frmMain.Designer.cs b/ProjectCarbon/frmMain.Designer.cs new file mode 100644 index 0000000..8c7598a --- /dev/null +++ b/ProjectCarbon/frmMain.Designer.cs @@ -0,0 +1,823 @@ +namespace ProjectCarbon +{ + partial class frmMain + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(frmMain)); + this.menuStrip1 = new System.Windows.Forms.MenuStrip(); + this.fileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuOpenCaptureFile = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuOpenAndAppend = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem2 = new System.Windows.Forms.ToolStripSeparator(); + this.mnuSaveCaptureFile = new System.Windows.Forms.ToolStripMenuItem(); + this.savePacketDumpToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem1 = new System.Windows.Forms.ToolStripSeparator(); + this.mnuExit = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuCapture = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuStartCapture = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuStopCapture = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuClearCapturedPackets = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem3 = new System.Windows.Forms.ToolStripSeparator(); + this.mnuSettings = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuFilters = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuTools = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuDisplayWinsockInfo = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuDnsLookup = new System.Windows.Forms.ToolStripMenuItem(); + this.helpToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuVisitWebsite = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem4 = new System.Windows.Forms.ToolStripSeparator(); + this.mnuAbout = new System.Windows.Forms.ToolStripMenuItem(); + this.tsMainToolbar = new System.Windows.Forms.ToolStrip(); + this.btnLoadCaptureFile = new System.Windows.Forms.ToolStripButton(); + this.btnSaveCaptureFile = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator2 = new System.Windows.Forms.ToolStripSeparator(); + this.tslInterface = new System.Windows.Forms.ToolStripLabel(); + this.tscbInterface = new System.Windows.Forms.ToolStripComboBox(); + this.btnStartCapture = new System.Windows.Forms.ToolStripButton(); + this.btnStopCapture = new System.Windows.Forms.ToolStripButton(); + this.btnClearCaptureLog = new System.Windows.Forms.ToolStripButton(); + this.btnCaptureSettings = new System.Windows.Forms.ToolStripButton(); + this.btnCaptureFilters = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator4 = new System.Windows.Forms.ToolStripSeparator(); + this.btnShowHelp = new System.Windows.Forms.ToolStripButton(); + this.statusStrip1 = new System.Windows.Forms.StatusStrip(); + this.spynetStatusPanel = new System.Windows.Forms.ToolStripStatusLabel(); + this.packetsInBufferStatus = new System.Windows.Forms.ToolStripStatusLabel(); + this.splitContainer1 = new System.Windows.Forms.SplitContainer(); + this.packetCaptureList = new System.Windows.Forms.ListView(); + this.columnHeader1 = new System.Windows.Forms.ColumnHeader(); + this.columnHeader2 = new System.Windows.Forms.ColumnHeader(); + this.columnHeader3 = new System.Windows.Forms.ColumnHeader(); + this.columnHeader4 = new System.Windows.Forms.ColumnHeader(); + this.columnHeader5 = new System.Windows.Forms.ColumnHeader(); + this.columnHeader6 = new System.Windows.Forms.ColumnHeader(); + this.columnHeader7 = new System.Windows.Forms.ColumnHeader(); + this.columnHeader8 = new System.Windows.Forms.ColumnHeader(); + this.columnHeader9 = new System.Windows.Forms.ColumnHeader(); + this.splitContainer2 = new System.Windows.Forms.SplitContainer(); + this.tvwPacketHeaderInfo = new System.Windows.Forms.TreeView(); + this.rtbDisplay = new System.Windows.Forms.RichTextBox(); + this.panel1 = new System.Windows.Forms.Panel(); + this.lblDisplayMode = new System.Windows.Forms.Label(); + this.chkStripHeaders = new System.Windows.Forms.CheckBox(); + this.cboDisplayMode = new System.Windows.Forms.ComboBox(); + this.niTrayIcon = new System.Windows.Forms.NotifyIcon(this.components); + this.cmsTrayMenu = new System.Windows.Forms.ContextMenuStrip(this.components); + this.mnuTrayStartCapture = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuTrayStopCapture = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem8 = new System.Windows.Forms.ToolStripSeparator(); + this.mnuTraySettings = new System.Windows.Forms.ToolStripMenuItem(); + this.mnuTrayFilters = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem5 = new System.Windows.Forms.ToolStripSeparator(); + this.exitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.lblPacketSize = new System.Windows.Forms.Label(); + this.menuStrip1.SuspendLayout(); + this.tsMainToolbar.SuspendLayout(); + this.statusStrip1.SuspendLayout(); + this.splitContainer1.Panel1.SuspendLayout(); + this.splitContainer1.Panel2.SuspendLayout(); + this.splitContainer1.SuspendLayout(); + this.splitContainer2.Panel1.SuspendLayout(); + this.splitContainer2.Panel2.SuspendLayout(); + this.splitContainer2.SuspendLayout(); + this.panel1.SuspendLayout(); + this.cmsTrayMenu.SuspendLayout(); + this.SuspendLayout(); + // + // menuStrip1 + // + this.menuStrip1.BackColor = System.Drawing.SystemColors.ButtonHighlight; + this.menuStrip1.GripMargin = new System.Windows.Forms.Padding(0); + this.menuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.fileToolStripMenuItem, + this.mnuCapture, + this.mnuTools, + this.helpToolStripMenuItem}); + this.menuStrip1.Location = new System.Drawing.Point(0, 0); + this.menuStrip1.Name = "menuStrip1"; + this.menuStrip1.Padding = new System.Windows.Forms.Padding(0); + this.menuStrip1.Size = new System.Drawing.Size(929, 24); + this.menuStrip1.TabIndex = 9; + this.menuStrip1.Text = "menuStrip1"; + // + // fileToolStripMenuItem + // + this.fileToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.mnuOpenCaptureFile, + this.mnuOpenAndAppend, + this.toolStripMenuItem2, + this.mnuSaveCaptureFile, + this.savePacketDumpToolStripMenuItem, + this.toolStripMenuItem1, + this.mnuExit}); + this.fileToolStripMenuItem.Name = "fileToolStripMenuItem"; + this.fileToolStripMenuItem.Size = new System.Drawing.Size(35, 24); + this.fileToolStripMenuItem.Text = "File"; + // + // mnuOpenCaptureFile + // + this.mnuOpenCaptureFile.Image = ((System.Drawing.Image)(resources.GetObject("mnuOpenCaptureFile.Image"))); + this.mnuOpenCaptureFile.Name = "mnuOpenCaptureFile"; + this.mnuOpenCaptureFile.Size = new System.Drawing.Size(186, 22); + this.mnuOpenCaptureFile.Text = "Open"; + this.mnuOpenCaptureFile.Click += new System.EventHandler(this.mnuOpenCaptureFile_Click); + // + // mnuOpenAndAppend + // + this.mnuOpenAndAppend.Name = "mnuOpenAndAppend"; + this.mnuOpenAndAppend.Size = new System.Drawing.Size(186, 22); + this.mnuOpenAndAppend.Text = "Open && Append..."; + this.mnuOpenAndAppend.Click += new System.EventHandler(this.mnuOpenAndAppend_Click); + // + // toolStripMenuItem2 + // + this.toolStripMenuItem2.Name = "toolStripMenuItem2"; + this.toolStripMenuItem2.Size = new System.Drawing.Size(183, 6); + // + // mnuSaveCaptureFile + // + this.mnuSaveCaptureFile.Image = ((System.Drawing.Image)(resources.GetObject("mnuSaveCaptureFile.Image"))); + this.mnuSaveCaptureFile.Name = "mnuSaveCaptureFile"; + this.mnuSaveCaptureFile.Size = new System.Drawing.Size(186, 22); + this.mnuSaveCaptureFile.Text = "Save"; + this.mnuSaveCaptureFile.Click += new System.EventHandler(this.mnuSaveCaptureFile_Click); + // + // savePacketDumpToolStripMenuItem + // + this.savePacketDumpToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("savePacketDumpToolStripMenuItem.Image"))); + this.savePacketDumpToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Fuchsia; + this.savePacketDumpToolStripMenuItem.Name = "savePacketDumpToolStripMenuItem"; + this.savePacketDumpToolStripMenuItem.Size = new System.Drawing.Size(186, 22); + this.savePacketDumpToolStripMenuItem.Text = "Save Packet Dump..."; + this.savePacketDumpToolStripMenuItem.Click += new System.EventHandler(this.savePacketDumpToolStripMenuItem_Click); + // + // toolStripMenuItem1 + // + this.toolStripMenuItem1.Name = "toolStripMenuItem1"; + this.toolStripMenuItem1.Size = new System.Drawing.Size(183, 6); + // + // mnuExit + // + this.mnuExit.Name = "mnuExit"; + this.mnuExit.Size = new System.Drawing.Size(186, 22); + this.mnuExit.Text = "Exit"; + this.mnuExit.Click += new System.EventHandler(this.mnuExit_Click); + // + // mnuCapture + // + this.mnuCapture.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.mnuStartCapture, + this.mnuStopCapture, + this.mnuClearCapturedPackets, + this.toolStripMenuItem3, + this.mnuSettings, + this.mnuFilters}); + this.mnuCapture.Name = "mnuCapture"; + this.mnuCapture.Size = new System.Drawing.Size(58, 24); + this.mnuCapture.Text = "Capture"; + // + // mnuStartCapture + // + this.mnuStartCapture.Image = ((System.Drawing.Image)(resources.GetObject("mnuStartCapture.Image"))); + this.mnuStartCapture.Name = "mnuStartCapture"; + this.mnuStartCapture.Size = new System.Drawing.Size(198, 22); + this.mnuStartCapture.Text = "Start Capture"; + this.mnuStartCapture.Click += new System.EventHandler(this.mnuStartCapture_Click); + // + // mnuStopCapture + // + this.mnuStopCapture.Image = ((System.Drawing.Image)(resources.GetObject("mnuStopCapture.Image"))); + this.mnuStopCapture.Name = "mnuStopCapture"; + this.mnuStopCapture.Size = new System.Drawing.Size(198, 22); + this.mnuStopCapture.Text = "Stop Capture"; + this.mnuStopCapture.Click += new System.EventHandler(this.mnuStopCapture_Click); + // + // mnuClearCapturedPackets + // + this.mnuClearCapturedPackets.Image = ((System.Drawing.Image)(resources.GetObject("mnuClearCapturedPackets.Image"))); + this.mnuClearCapturedPackets.Name = "mnuClearCapturedPackets"; + this.mnuClearCapturedPackets.Size = new System.Drawing.Size(198, 22); + this.mnuClearCapturedPackets.Text = "Clear Captured Packets"; + this.mnuClearCapturedPackets.Click += new System.EventHandler(this.mnuClearCapturedPackets_Click); + // + // toolStripMenuItem3 + // + this.toolStripMenuItem3.Name = "toolStripMenuItem3"; + this.toolStripMenuItem3.Size = new System.Drawing.Size(195, 6); + // + // mnuSettings + // + this.mnuSettings.Image = ((System.Drawing.Image)(resources.GetObject("mnuSettings.Image"))); + this.mnuSettings.Name = "mnuSettings"; + this.mnuSettings.Size = new System.Drawing.Size(198, 22); + this.mnuSettings.Text = "Settings..."; + this.mnuSettings.Click += new System.EventHandler(this.mnuSettings_Click); + // + // mnuFilters + // + this.mnuFilters.Image = ((System.Drawing.Image)(resources.GetObject("mnuFilters.Image"))); + this.mnuFilters.Name = "mnuFilters"; + this.mnuFilters.Size = new System.Drawing.Size(198, 22); + this.mnuFilters.Text = "Filters..."; + this.mnuFilters.Click += new System.EventHandler(this.mnuFilters_Click); + // + // mnuTools + // + this.mnuTools.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.mnuDisplayWinsockInfo, + this.mnuDnsLookup}); + this.mnuTools.Name = "mnuTools"; + this.mnuTools.Size = new System.Drawing.Size(44, 24); + this.mnuTools.Text = "Tools"; + // + // mnuDisplayWinsockInfo + // + this.mnuDisplayWinsockInfo.Name = "mnuDisplayWinsockInfo"; + this.mnuDisplayWinsockInfo.Size = new System.Drawing.Size(232, 22); + this.mnuDisplayWinsockInfo.Text = "Display Winsock Information..."; + this.mnuDisplayWinsockInfo.Click += new System.EventHandler(this.mnuDisplayWinsockInfo_Click); + // + // mnuDnsLookup + // + this.mnuDnsLookup.Name = "mnuDnsLookup"; + this.mnuDnsLookup.Size = new System.Drawing.Size(232, 22); + this.mnuDnsLookup.Text = "DNS Lookup..."; + this.mnuDnsLookup.Click += new System.EventHandler(this.mnuDnsLookup_Click); + // + // helpToolStripMenuItem + // + this.helpToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.mnuVisitWebsite, + this.toolStripMenuItem4, + this.mnuAbout}); + this.helpToolStripMenuItem.Name = "helpToolStripMenuItem"; + this.helpToolStripMenuItem.Size = new System.Drawing.Size(40, 24); + this.helpToolStripMenuItem.Text = "Help"; + // + // mnuVisitWebsite + // + this.mnuVisitWebsite.Name = "mnuVisitWebsite"; + this.mnuVisitWebsite.Size = new System.Drawing.Size(202, 22); + this.mnuVisitWebsite.Text = "Visit Xeon Productions..."; + this.mnuVisitWebsite.Click += new System.EventHandler(this.mnuVisitWebsite_Click); + // + // toolStripMenuItem4 + // + this.toolStripMenuItem4.Name = "toolStripMenuItem4"; + this.toolStripMenuItem4.Size = new System.Drawing.Size(199, 6); + // + // mnuAbout + // + this.mnuAbout.Name = "mnuAbout"; + this.mnuAbout.Size = new System.Drawing.Size(202, 22); + this.mnuAbout.Text = "About..."; + this.mnuAbout.Click += new System.EventHandler(this.mnuAbout_Click); + // + // tsMainToolbar + // + this.tsMainToolbar.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.btnLoadCaptureFile, + this.btnSaveCaptureFile, + this.toolStripSeparator2, + this.tslInterface, + this.tscbInterface, + this.btnStartCapture, + this.btnStopCapture, + this.btnClearCaptureLog, + this.btnCaptureSettings, + this.btnCaptureFilters, + this.toolStripSeparator4, + this.btnShowHelp}); + this.tsMainToolbar.Location = new System.Drawing.Point(0, 24); + this.tsMainToolbar.Name = "tsMainToolbar"; + this.tsMainToolbar.Size = new System.Drawing.Size(929, 25); + this.tsMainToolbar.TabIndex = 10; + // + // btnLoadCaptureFile + // + this.btnLoadCaptureFile.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.btnLoadCaptureFile.Image = ((System.Drawing.Image)(resources.GetObject("btnLoadCaptureFile.Image"))); + this.btnLoadCaptureFile.ImageTransparentColor = System.Drawing.Color.Magenta; + this.btnLoadCaptureFile.Name = "btnLoadCaptureFile"; + this.btnLoadCaptureFile.Size = new System.Drawing.Size(23, 22); + this.btnLoadCaptureFile.Text = "Open"; + this.btnLoadCaptureFile.Click += new System.EventHandler(this.btnLoadCaptureFile_Click); + // + // btnSaveCaptureFile + // + this.btnSaveCaptureFile.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.btnSaveCaptureFile.Image = ((System.Drawing.Image)(resources.GetObject("btnSaveCaptureFile.Image"))); + this.btnSaveCaptureFile.ImageTransparentColor = System.Drawing.Color.Magenta; + this.btnSaveCaptureFile.Name = "btnSaveCaptureFile"; + this.btnSaveCaptureFile.Size = new System.Drawing.Size(23, 22); + this.btnSaveCaptureFile.Text = "Save"; + this.btnSaveCaptureFile.Click += new System.EventHandler(this.btnSaveCaptureFile_Click); + // + // toolStripSeparator2 + // + this.toolStripSeparator2.Name = "toolStripSeparator2"; + this.toolStripSeparator2.Size = new System.Drawing.Size(6, 25); + // + // tslInterface + // + this.tslInterface.Name = "tslInterface"; + this.tslInterface.Size = new System.Drawing.Size(56, 22); + this.tslInterface.Text = "Interface:"; + // + // tscbInterface + // + this.tscbInterface.CausesValidation = false; + this.tscbInterface.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.tscbInterface.Name = "tscbInterface"; + this.tscbInterface.Size = new System.Drawing.Size(200, 25); + // + // btnStartCapture + // + this.btnStartCapture.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.btnStartCapture.Image = ((System.Drawing.Image)(resources.GetObject("btnStartCapture.Image"))); + this.btnStartCapture.ImageTransparentColor = System.Drawing.Color.Magenta; + this.btnStartCapture.Name = "btnStartCapture"; + this.btnStartCapture.Size = new System.Drawing.Size(23, 22); + this.btnStartCapture.Text = "Start Capture"; + this.btnStartCapture.Click += new System.EventHandler(this.btnStartCapture_Click); + // + // btnStopCapture + // + this.btnStopCapture.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.btnStopCapture.Image = ((System.Drawing.Image)(resources.GetObject("btnStopCapture.Image"))); + this.btnStopCapture.ImageTransparentColor = System.Drawing.Color.Magenta; + this.btnStopCapture.Name = "btnStopCapture"; + this.btnStopCapture.Size = new System.Drawing.Size(23, 22); + this.btnStopCapture.Text = "Stop Capture"; + this.btnStopCapture.Click += new System.EventHandler(this.btnStopCapture_Click); + // + // btnClearCaptureLog + // + this.btnClearCaptureLog.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.btnClearCaptureLog.Image = ((System.Drawing.Image)(resources.GetObject("btnClearCaptureLog.Image"))); + this.btnClearCaptureLog.ImageTransparentColor = System.Drawing.Color.Magenta; + this.btnClearCaptureLog.Name = "btnClearCaptureLog"; + this.btnClearCaptureLog.Size = new System.Drawing.Size(23, 22); + this.btnClearCaptureLog.Text = "Clear Captured Packets"; + this.btnClearCaptureLog.Click += new System.EventHandler(this.btnClearCaptureLog_Click); + // + // btnCaptureSettings + // + this.btnCaptureSettings.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.btnCaptureSettings.Image = ((System.Drawing.Image)(resources.GetObject("btnCaptureSettings.Image"))); + this.btnCaptureSettings.ImageTransparentColor = System.Drawing.Color.Magenta; + this.btnCaptureSettings.Name = "btnCaptureSettings"; + this.btnCaptureSettings.Size = new System.Drawing.Size(23, 22); + this.btnCaptureSettings.Text = "Capture Settings"; + this.btnCaptureSettings.Click += new System.EventHandler(this.btnCaptureSettings_Click); + // + // btnCaptureFilters + // + this.btnCaptureFilters.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.btnCaptureFilters.Image = ((System.Drawing.Image)(resources.GetObject("btnCaptureFilters.Image"))); + this.btnCaptureFilters.ImageTransparentColor = System.Drawing.Color.Magenta; + this.btnCaptureFilters.Name = "btnCaptureFilters"; + this.btnCaptureFilters.Size = new System.Drawing.Size(23, 22); + this.btnCaptureFilters.Text = "Capture Filters"; + this.btnCaptureFilters.Click += new System.EventHandler(this.btnCaptureFilters_Click); + // + // toolStripSeparator4 + // + this.toolStripSeparator4.Name = "toolStripSeparator4"; + this.toolStripSeparator4.Size = new System.Drawing.Size(6, 25); + // + // btnShowHelp + // + this.btnShowHelp.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.btnShowHelp.Image = ((System.Drawing.Image)(resources.GetObject("btnShowHelp.Image"))); + this.btnShowHelp.ImageTransparentColor = System.Drawing.Color.Magenta; + this.btnShowHelp.Name = "btnShowHelp"; + this.btnShowHelp.Size = new System.Drawing.Size(23, 22); + this.btnShowHelp.Text = "Help"; + // + // statusStrip1 + // + this.statusStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.spynetStatusPanel, + this.packetsInBufferStatus}); + this.statusStrip1.Location = new System.Drawing.Point(0, 516); + this.statusStrip1.Name = "statusStrip1"; + this.statusStrip1.RenderMode = System.Windows.Forms.ToolStripRenderMode.ManagerRenderMode; + this.statusStrip1.Size = new System.Drawing.Size(929, 22); + this.statusStrip1.TabIndex = 11; + this.statusStrip1.Text = "statusStrip1"; + // + // spynetStatusPanel + // + this.spynetStatusPanel.Image = ((System.Drawing.Image)(resources.GetObject("spynetStatusPanel.Image"))); + this.spynetStatusPanel.ImageAlign = System.Drawing.ContentAlignment.MiddleLeft; + this.spynetStatusPanel.Name = "spynetStatusPanel"; + this.spynetStatusPanel.Size = new System.Drawing.Size(809, 17); + this.spynetStatusPanel.Spring = true; + this.spynetStatusPanel.Text = "Network Adapter Placeholder"; + this.spynetStatusPanel.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // packetsInBufferStatus + // + this.packetsInBufferStatus.Name = "packetsInBufferStatus"; + this.packetsInBufferStatus.Size = new System.Drawing.Size(105, 17); + this.packetsInBufferStatus.Text = "Captured Packets: 0"; + // + // splitContainer1 + // + this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainer1.Location = new System.Drawing.Point(0, 49); + this.splitContainer1.Name = "splitContainer1"; + this.splitContainer1.Orientation = System.Windows.Forms.Orientation.Horizontal; + // + // splitContainer1.Panel1 + // + this.splitContainer1.Panel1.Controls.Add(this.packetCaptureList); + // + // splitContainer1.Panel2 + // + this.splitContainer1.Panel2.Controls.Add(this.splitContainer2); + this.splitContainer1.Size = new System.Drawing.Size(929, 467); + this.splitContainer1.SplitterDistance = 221; + this.splitContainer1.TabIndex = 12; + // + // packetCaptureList + // + this.packetCaptureList.Activation = System.Windows.Forms.ItemActivation.OneClick; + this.packetCaptureList.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.columnHeader1, + this.columnHeader2, + this.columnHeader3, + this.columnHeader4, + this.columnHeader5, + this.columnHeader6, + this.columnHeader7, + this.columnHeader8, + this.columnHeader9}); + this.packetCaptureList.Dock = System.Windows.Forms.DockStyle.Fill; + this.packetCaptureList.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.packetCaptureList.FullRowSelect = true; + this.packetCaptureList.HideSelection = false; + this.packetCaptureList.Location = new System.Drawing.Point(0, 0); + this.packetCaptureList.MultiSelect = false; + this.packetCaptureList.Name = "packetCaptureList"; + this.packetCaptureList.Size = new System.Drawing.Size(929, 221); + this.packetCaptureList.TabIndex = 1; + this.packetCaptureList.UseCompatibleStateImageBehavior = false; + this.packetCaptureList.View = System.Windows.Forms.View.Details; + this.packetCaptureList.SelectedIndexChanged += new System.EventHandler(this.packetCaptureList_SelectedIndexChanged); + this.packetCaptureList.ItemSelectionChanged += new System.Windows.Forms.ListViewItemSelectionChangedEventHandler(this.packetCaptureList_ItemSelectionChanged); + // + // columnHeader1 + // + this.columnHeader1.Text = "No"; + this.columnHeader1.Width = 52; + // + // columnHeader2 + // + this.columnHeader2.Text = "Time"; + this.columnHeader2.Width = 100; + // + // columnHeader3 + // + this.columnHeader3.Text = "Source MAC"; + this.columnHeader3.Width = 110; + // + // columnHeader4 + // + this.columnHeader4.Text = "Dest MAC"; + this.columnHeader4.Width = 110; + // + // columnHeader5 + // + this.columnHeader5.Text = "Protocol"; + // + // columnHeader6 + // + this.columnHeader6.Text = "Source IP"; + this.columnHeader6.Width = 105; + // + // columnHeader7 + // + this.columnHeader7.Text = "Destination IP"; + this.columnHeader7.Width = 105; + // + // columnHeader8 + // + this.columnHeader8.Text = "Port Source"; + this.columnHeader8.Width = 70; + // + // columnHeader9 + // + this.columnHeader9.Text = "Port Dest"; + this.columnHeader9.Width = 70; + // + // splitContainer2 + // + this.splitContainer2.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainer2.Location = new System.Drawing.Point(0, 0); + this.splitContainer2.Name = "splitContainer2"; + // + // splitContainer2.Panel1 + // + this.splitContainer2.Panel1.Controls.Add(this.tvwPacketHeaderInfo); + this.splitContainer2.Panel1Collapsed = true; + // + // splitContainer2.Panel2 + // + this.splitContainer2.Panel2.Controls.Add(this.rtbDisplay); + this.splitContainer2.Panel2.Controls.Add(this.panel1); + this.splitContainer2.Size = new System.Drawing.Size(929, 242); + this.splitContainer2.SplitterDistance = 217; + this.splitContainer2.TabIndex = 2; + // + // tvwPacketHeaderInfo + // + this.tvwPacketHeaderInfo.Dock = System.Windows.Forms.DockStyle.Fill; + this.tvwPacketHeaderInfo.Font = new System.Drawing.Font("Tahoma", 6.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.tvwPacketHeaderInfo.Location = new System.Drawing.Point(0, 0); + this.tvwPacketHeaderInfo.Name = "tvwPacketHeaderInfo"; + this.tvwPacketHeaderInfo.ShowRootLines = false; + this.tvwPacketHeaderInfo.Size = new System.Drawing.Size(217, 242); + this.tvwPacketHeaderInfo.TabIndex = 2; + // + // rtbDisplay + // + this.rtbDisplay.BackColor = System.Drawing.Color.White; + this.rtbDisplay.DetectUrls = false; + this.rtbDisplay.Dock = System.Windows.Forms.DockStyle.Fill; + this.rtbDisplay.Font = new System.Drawing.Font("Courier New", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.rtbDisplay.Location = new System.Drawing.Point(0, 24); + this.rtbDisplay.Name = "rtbDisplay"; + this.rtbDisplay.ReadOnly = true; + this.rtbDisplay.ScrollBars = System.Windows.Forms.RichTextBoxScrollBars.ForcedBoth; + this.rtbDisplay.ShowSelectionMargin = true; + this.rtbDisplay.Size = new System.Drawing.Size(929, 218); + this.rtbDisplay.TabIndex = 1; + this.rtbDisplay.Text = ""; + this.rtbDisplay.WordWrap = false; + // + // panel1 + // + this.panel1.Controls.Add(this.lblPacketSize); + this.panel1.Controls.Add(this.lblDisplayMode); + this.panel1.Controls.Add(this.chkStripHeaders); + this.panel1.Controls.Add(this.cboDisplayMode); + this.panel1.Dock = System.Windows.Forms.DockStyle.Top; + this.panel1.Location = new System.Drawing.Point(0, 0); + this.panel1.Name = "panel1"; + this.panel1.Size = new System.Drawing.Size(929, 24); + this.panel1.TabIndex = 2; + // + // lblDisplayMode + // + this.lblDisplayMode.AutoSize = true; + this.lblDisplayMode.Location = new System.Drawing.Point(8, 4); + this.lblDisplayMode.Name = "lblDisplayMode"; + this.lblDisplayMode.Size = new System.Drawing.Size(74, 13); + this.lblDisplayMode.TabIndex = 1; + this.lblDisplayMode.Text = "Display Mode:"; + // + // chkStripHeaders + // + this.chkStripHeaders.AutoSize = true; + this.chkStripHeaders.Location = new System.Drawing.Point(232, 2); + this.chkStripHeaders.Name = "chkStripHeaders"; + this.chkStripHeaders.Size = new System.Drawing.Size(91, 17); + this.chkStripHeaders.TabIndex = 14; + this.chkStripHeaders.Text = "Strip Headers"; + this.chkStripHeaders.UseVisualStyleBackColor = true; + this.chkStripHeaders.CheckStateChanged += new System.EventHandler(this.chkStripTCPIPHeaders_CheckStateChanged); + this.chkStripHeaders.CheckedChanged += new System.EventHandler(this.chkStripTCPIPHeaders_CheckedChanged); + // + // cboDisplayMode + // + this.cboDisplayMode.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.cboDisplayMode.FormattingEnabled = true; + this.cboDisplayMode.Items.AddRange(new object[] { + "Hex + Text", + "Hex only", + "Decimal + Text", + "Decimal Only", + "Text Mode"}); + this.cboDisplayMode.Location = new System.Drawing.Point(88, 0); + this.cboDisplayMode.Name = "cboDisplayMode"; + this.cboDisplayMode.Size = new System.Drawing.Size(136, 21); + this.cboDisplayMode.TabIndex = 0; + this.cboDisplayMode.SelectedIndexChanged += new System.EventHandler(this.cboDisplayModes_SelectedIndexChanged); + // + // niTrayIcon + // + this.niTrayIcon.ContextMenuStrip = this.cmsTrayMenu; + this.niTrayIcon.Icon = ((System.Drawing.Icon)(resources.GetObject("niTrayIcon.Icon"))); + this.niTrayIcon.Text = "Project Carbon"; + this.niTrayIcon.Visible = true; + this.niTrayIcon.DoubleClick += new System.EventHandler(this.niTrayIcon_DoubleClick); + // + // cmsTrayMenu + // + this.cmsTrayMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.mnuTrayStartCapture, + this.mnuTrayStopCapture, + this.toolStripMenuItem8, + this.mnuTraySettings, + this.mnuTrayFilters, + this.toolStripMenuItem5, + this.exitToolStripMenuItem}); + this.cmsTrayMenu.Name = "cmsTrayMenu"; + this.cmsTrayMenu.Size = new System.Drawing.Size(152, 126); + // + // mnuTrayStartCapture + // + this.mnuTrayStartCapture.Name = "mnuTrayStartCapture"; + this.mnuTrayStartCapture.Size = new System.Drawing.Size(151, 22); + this.mnuTrayStartCapture.Text = "Start Capture"; + this.mnuTrayStartCapture.Click += new System.EventHandler(this.mnuTrayStartCapture_Click); + // + // mnuTrayStopCapture + // + this.mnuTrayStopCapture.Name = "mnuTrayStopCapture"; + this.mnuTrayStopCapture.Size = new System.Drawing.Size(151, 22); + this.mnuTrayStopCapture.Text = "Stop Capture"; + this.mnuTrayStopCapture.Click += new System.EventHandler(this.mnuTrayStopCapture_Click); + // + // toolStripMenuItem8 + // + this.toolStripMenuItem8.Name = "toolStripMenuItem8"; + this.toolStripMenuItem8.Size = new System.Drawing.Size(148, 6); + // + // mnuTraySettings + // + this.mnuTraySettings.Name = "mnuTraySettings"; + this.mnuTraySettings.Size = new System.Drawing.Size(151, 22); + this.mnuTraySettings.Text = "Settings..."; + this.mnuTraySettings.Click += new System.EventHandler(this.mnuTraySettings_Click); + // + // mnuTrayFilters + // + this.mnuTrayFilters.Name = "mnuTrayFilters"; + this.mnuTrayFilters.Size = new System.Drawing.Size(151, 22); + this.mnuTrayFilters.Text = "Filters..."; + this.mnuTrayFilters.Click += new System.EventHandler(this.mnuTrayFilters_Click); + // + // toolStripMenuItem5 + // + this.toolStripMenuItem5.Name = "toolStripMenuItem5"; + this.toolStripMenuItem5.Size = new System.Drawing.Size(148, 6); + // + // exitToolStripMenuItem + // + this.exitToolStripMenuItem.Name = "exitToolStripMenuItem"; + this.exitToolStripMenuItem.Size = new System.Drawing.Size(151, 22); + this.exitToolStripMenuItem.Text = "Exit"; + this.exitToolStripMenuItem.Click += new System.EventHandler(this.exitToolStripMenuItem_Click); + // + // lblPacketSize + // + this.lblPacketSize.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.lblPacketSize.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.lblPacketSize.Location = new System.Drawing.Point(744, 0); + this.lblPacketSize.Name = "lblPacketSize"; + this.lblPacketSize.Size = new System.Drawing.Size(184, 21); + this.lblPacketSize.TabIndex = 15; + this.lblPacketSize.Text = "Packet Size: 0"; + this.lblPacketSize.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // frmMain + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(929, 538); + this.Controls.Add(this.splitContainer1); + this.Controls.Add(this.statusStrip1); + this.Controls.Add(this.tsMainToolbar); + this.Controls.Add(this.menuStrip1); + this.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.Name = "frmMain"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Project Carbon (Beta 5)"; + this.Load += new System.EventHandler(this.frmMain_Load); + this.Shown += new System.EventHandler(this.frmMain_Shown); + this.Resize += new System.EventHandler(this.frmMain_Resize); + this.menuStrip1.ResumeLayout(false); + this.menuStrip1.PerformLayout(); + this.tsMainToolbar.ResumeLayout(false); + this.tsMainToolbar.PerformLayout(); + this.statusStrip1.ResumeLayout(false); + this.statusStrip1.PerformLayout(); + this.splitContainer1.Panel1.ResumeLayout(false); + this.splitContainer1.Panel2.ResumeLayout(false); + this.splitContainer1.ResumeLayout(false); + this.splitContainer2.Panel1.ResumeLayout(false); + this.splitContainer2.Panel2.ResumeLayout(false); + this.splitContainer2.ResumeLayout(false); + this.panel1.ResumeLayout(false); + this.panel1.PerformLayout(); + this.cmsTrayMenu.ResumeLayout(false); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.MenuStrip menuStrip1; + private System.Windows.Forms.ToolStripMenuItem fileToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem mnuOpenCaptureFile; + private System.Windows.Forms.ToolStripMenuItem mnuOpenAndAppend; + private System.Windows.Forms.ToolStripSeparator toolStripMenuItem2; + private System.Windows.Forms.ToolStripMenuItem mnuSaveCaptureFile; + private System.Windows.Forms.ToolStripSeparator toolStripMenuItem1; + private System.Windows.Forms.ToolStripMenuItem mnuExit; + private System.Windows.Forms.ToolStripMenuItem mnuCapture; + private System.Windows.Forms.ToolStripMenuItem mnuStartCapture; + private System.Windows.Forms.ToolStripMenuItem mnuStopCapture; + private System.Windows.Forms.ToolStripMenuItem mnuSettings; + private System.Windows.Forms.ToolStripMenuItem mnuTools; + private System.Windows.Forms.ToolStripMenuItem mnuDisplayWinsockInfo; + private System.Windows.Forms.ToolStripMenuItem helpToolStripMenuItem; + private System.Windows.Forms.ToolStrip tsMainToolbar; + private System.Windows.Forms.ToolStripButton btnStartCapture; + private System.Windows.Forms.ToolStripButton btnStopCapture; + private System.Windows.Forms.ToolStripButton btnCaptureFilters; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator4; + private System.Windows.Forms.ToolStripButton btnLoadCaptureFile; + private System.Windows.Forms.ToolStripButton btnSaveCaptureFile; + private System.Windows.Forms.ToolStripButton btnClearCaptureLog; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator2; + private System.Windows.Forms.ToolStripButton btnCaptureSettings; + private System.Windows.Forms.ToolStripButton btnShowHelp; + private System.Windows.Forms.StatusStrip statusStrip1; + private System.Windows.Forms.ToolStripStatusLabel spynetStatusPanel; + private System.Windows.Forms.SplitContainer splitContainer1; + private System.Windows.Forms.ListView packetCaptureList; + private System.Windows.Forms.ColumnHeader columnHeader1; + private System.Windows.Forms.ColumnHeader columnHeader2; + private System.Windows.Forms.ColumnHeader columnHeader5; + private System.Windows.Forms.ColumnHeader columnHeader6; + private System.Windows.Forms.ColumnHeader columnHeader7; + private System.Windows.Forms.ColumnHeader columnHeader8; + private System.Windows.Forms.ColumnHeader columnHeader9; + private System.Windows.Forms.ToolStripMenuItem mnuFilters; + private System.Windows.Forms.ToolStripMenuItem mnuVisitWebsite; + private System.Windows.Forms.ToolStripSeparator toolStripMenuItem4; + private System.Windows.Forms.ToolStripMenuItem mnuAbout; + private System.Windows.Forms.ToolStripMenuItem mnuClearCapturedPackets; + private System.Windows.Forms.CheckBox chkStripHeaders; + private System.Windows.Forms.ToolStripSeparator toolStripMenuItem3; + private System.Windows.Forms.SplitContainer splitContainer2; + private System.Windows.Forms.TreeView tvwPacketHeaderInfo; + private System.Windows.Forms.RichTextBox rtbDisplay; + private System.Windows.Forms.NotifyIcon niTrayIcon; + private System.Windows.Forms.ContextMenuStrip cmsTrayMenu; + private System.Windows.Forms.ToolStripMenuItem mnuTrayStartCapture; + private System.Windows.Forms.ToolStripMenuItem mnuTrayStopCapture; + private System.Windows.Forms.ToolStripSeparator toolStripMenuItem8; + private System.Windows.Forms.ToolStripMenuItem mnuTraySettings; + private System.Windows.Forms.ToolStripMenuItem mnuTrayFilters; + private System.Windows.Forms.ToolStripMenuItem savePacketDumpToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem mnuDnsLookup; + private System.Windows.Forms.Panel panel1; + private System.Windows.Forms.Label lblDisplayMode; + private System.Windows.Forms.ComboBox cboDisplayMode; + private System.Windows.Forms.ToolStripStatusLabel packetsInBufferStatus; + private System.Windows.Forms.ToolStripSeparator toolStripMenuItem5; + private System.Windows.Forms.ToolStripMenuItem exitToolStripMenuItem; + private System.Windows.Forms.ToolStripLabel tslInterface; + private System.Windows.Forms.ToolStripComboBox tscbInterface; + private System.Windows.Forms.ColumnHeader columnHeader3; + private System.Windows.Forms.ColumnHeader columnHeader4; + private System.Windows.Forms.Label lblPacketSize; + + + + } +} + diff --git a/ProjectCarbon/frmMain.cs b/ProjectCarbon/frmMain.cs new file mode 100644 index 0000000..602cc90 --- /dev/null +++ b/ProjectCarbon/frmMain.cs @@ -0,0 +1,508 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using System.Net; +using System.Collections; +using System.IO; +using System.Globalization; +using System.Threading; +using System.Runtime.Serialization; +using System.Runtime.Serialization.Formatters; +using System.Runtime.Serialization.Formatters.Binary; + +using ProjectCarbon.Properties; +using ProjectCarbon.Protocols; + +using Tamir.IPLib; +using Tamir.IPLib.Packets; + +namespace ProjectCarbon +{ + public partial class frmMain : Form + { + public frmMain() + { + InitializeComponent(); + } + + private void frmMain_Load(object sender, EventArgs e) + { + foreach (PcapDevice dev in Global.DeviceList) + { + tscbInterface.Items.Add(dev.PcapDescription); + } + tscbInterface.SelectedIndex = 0; + + spynetStatusPanel.Text = "Status: Idle..."; + cboDisplayMode.SelectedIndex = 0; + + ApplySettings(); + + // This event is fired when the properties are saving + Settings.Default.SettingsSaving += + new System.Configuration.SettingsSavingEventHandler(Default_SettingsSaving); + } + + + void Default_SettingsSaving(object sender, CancelEventArgs e) + { + ApplySettings(); + if (Settings.Default.StartUpWindows) + Functions.SetStartup(); + else + Functions.RemoveStartup(); + + } + + private void ApplySettings() + { + // Let's load the options + rtbDisplay.BackColor = + Settings.Default.PacketDisplayBackgroundColor; + rtbDisplay.ForeColor = + Settings.Default.PacketDisplayFontColor; + rtbDisplay.Font = + Settings.Default.PacketDisplayFontFace; + packetCaptureList.BackColor = + Settings.Default.PacketListBackgroundColor; + packetCaptureList.ForeColor = + Settings.Default.PacketListTextColor; + } + + private void device_PcapOnPacketArrival(object sender, Packet packet) + { + try + { + Global.PacketCapturedEvent packetCapturedEvent + = new Global.PacketCapturedEvent(OnPacketCaptured); + + this.BeginInvoke(packetCapturedEvent, new object[] { packet }); + } + catch (Exception e) + { + Console.WriteLine(e.Message); + } + } + + private void OnPacketCaptured(Packet packet) + { + ListViewItem listViewItem = + packetCaptureList.Items.Add(packetCaptureList.Items.Count.ToString()); + + listViewItem.SubItems.Add(packet.Timeval.Date.ToString()); + listViewItem.SubItems.Add(((EthernetPacket)packet).SourceHwAddress.ToUpper()); + listViewItem.SubItems.Add(((EthernetPacket)packet).DestinationHwAddress.ToUpper()); + + if (packet is IPPacket) + { + listViewItem.SubItems.Add(((IPPacket)packet).IPProtocol.ToString()); + listViewItem.SubItems.Add(((IPPacket)packet).SourceAddress.ToString()); + listViewItem.SubItems.Add(((IPPacket)packet).DestinationAddress.ToString()); + } + else + { + listViewItem.SubItems.Add("--"); + listViewItem.SubItems.Add("--"); + listViewItem.SubItems.Add("--"); + } + + if (packet is TCPPacket) + { + listViewItem.SubItems.Add(((TCPPacket)packet).SourcePort.ToString()); + listViewItem.SubItems.Add(((TCPPacket)packet).DestinationPort.ToString()); + } + else if (packet is UDPPacket) + { + listViewItem.SubItems.Add(((UDPPacket)packet).SourcePort.ToString()); + listViewItem.SubItems.Add(((UDPPacket)packet).DestinationPort.ToString()); + } + else + { + listViewItem.SubItems.Add("--"); + listViewItem.SubItems.Add("--"); + } + + + // Add this captured packet to the list. + Global.CapturedPackets.Add(packet); + + // Update the packet list. + packetsInBufferStatus.Text = "Captured Packets: " + Global.CapturedPackets.Count; + + // Scroll if autoscroll is enabled. + if (Settings.Default.AutoScrollPacketList == true) + { + //lvi.Selected = true; + listViewItem.EnsureVisible(); + } + } + + private void DisplayCapture(byte[] buffer) + { + rtbDisplay.Clear(); + switch (cboDisplayMode.SelectedIndex) + { + case 0: + rtbDisplay.AppendText(Functions.GetHexBlock(buffer)); + break; + case 1: + rtbDisplay.AppendText(Functions.GetHexOnly(buffer)); + break; + case 2: + rtbDisplay.AppendText(Functions.GetDecBlock(buffer)); + break; + case 3: + rtbDisplay.AppendText(Functions.GetDecOnly(buffer)); + break; + case 4: + rtbDisplay.AppendText(Functions.GetSafeString(buffer)); + break; + } + } + + #region Form Events + private void btnStartCapture_Click(object sender, EventArgs e) + { + StartCapture(); + } + + private void packetCaptureList_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e) + { + Packet packet = Global.CapturedPackets[e.ItemIndex]; + lblPacketSize.Text = "Packet Size: " + ((EthernetPacket)packet).Bytes.Length.ToString(); + if (chkStripHeaders.Checked == true) + DisplayCapture(packet.Data); + else + DisplayCapture(((EthernetPacket)packet).Bytes); + + } + + private void btnStopCapture_Click(object sender, EventArgs e) + { + StopCapture(); + } + + private void mnuAbout_Click(object sender, EventArgs e) + { + frmAboutDialog aboutDialog = new frmAboutDialog(); + aboutDialog.ShowDialog(); + } + + private void btnClearCaptureLog_Click(object sender, EventArgs e) + { + ClearCaptureLog(); + } + + private void btnSaveCaptureFile_Click(object sender, EventArgs e) + { + SaveCaptureFile(); + } + + private void btnLoadCaptureFile_Click(object sender, EventArgs e) + { + LoadCaptureFile(false); + } + + private void btnCaptureFilters_Click(object sender, EventArgs e) + { + ShowCaptureFiltersDialog(); + } + + private void chkStripTCPIPHeaders_CheckStateChanged(object sender, EventArgs e) + { + if (packetCaptureList.SelectedItems.Count > 0) + packetCaptureList_ItemSelectionChanged(packetCaptureList, new ListViewItemSelectionChangedEventArgs(packetCaptureList.SelectedItems[0], packetCaptureList.SelectedItems[0].Index, true)); + } + + private void mnuOpenCaptureFile_Click(object sender, EventArgs e) + { + LoadCaptureFile(false); + } + + private void mnuOpenAndAppend_Click(object sender, EventArgs e) + { + LoadCaptureFile(true); + } + + private void mnuStartCapture_Click(object sender, EventArgs e) + { + StartCapture(); + } + + private void mnuStopCapture_Click(object sender, EventArgs e) + { + StopCapture(); + } + + private void mnuClearCapturedPackets_Click(object sender, EventArgs e) + { + ClearCaptureLog(); + } + + private void mnuSettings_Click(object sender, EventArgs e) + { + ShowCaptureSettings(); + } + + private void mnuFilters_Click(object sender, EventArgs e) + { + ShowCaptureFiltersDialog(); + } + + private void mnuSaveCaptureFile_Click(object sender, EventArgs e) + { + SaveCaptureFile(); + } + + private void btnCaptureSettings_Click(object sender, EventArgs e) + { + ShowCaptureSettings(); + } + + + private void mnuDisplayWinsockInfo_Click(object sender, EventArgs e) + { + frmSocketInformation socketInformation = new frmSocketInformation(); + socketInformation.ShowDialog(); + } + + private void mnuAdapterPerformance_Click(object sender, EventArgs e) + { + } + + private void mnuVisitWebsite_Click(object sender, EventArgs e) + { + Help.ShowHelp(this, "http://www.xeons.net/"); + } + + private void frmMain_Resize(object sender, EventArgs e) + { + if (FormWindowState.Minimized == WindowState) + Hide(); + } + + private void niTrayIcon_DoubleClick(object sender, EventArgs e) + { + Show(); + WindowState = FormWindowState.Normal; + } + + private void frmMain_Shown(object sender, EventArgs e) + { + // Start capturing at startup + if (Settings.Default.StartUpCapture) + StartCapture(); + + // Startup Minimized to tray + if (Settings.Default.StartUpMinimized) + WindowState = FormWindowState.Minimized; + } + + private void savePacketDumpToolStripMenuItem_Click(object sender, EventArgs e) + { + SavePacketDump(); + } + + private void mnuTrayStartCapture_Click(object sender, EventArgs e) + { + StartCapture(); + } + + private void mnuTrayStopCapture_Click(object sender, EventArgs e) + { + StopCapture(); + } + + private void mnuTraySettings_Click(object sender, EventArgs e) + { + ShowCaptureSettings(); + } + + private void mnuTrayFilters_Click(object sender, EventArgs e) + { + ShowCaptureFiltersDialog(); + } + + private void mnuExit_Click(object sender, EventArgs e) + { + Application.Exit(); + } + + private void mnuDnsLookup_Click(object sender, EventArgs e) + { + frmDnsLookup dnsLookup = new frmDnsLookup(); + dnsLookup.ShowDialog(); + } + + private void chkStripTCPIPHeaders_CheckedChanged(object sender, EventArgs e) + { + + } + + private void cboDisplayModes_SelectedIndexChanged(object sender, EventArgs e) + { + if (packetCaptureList.SelectedItems.Count > 0) + packetCaptureList_ItemSelectionChanged(packetCaptureList, new ListViewItemSelectionChangedEventArgs(packetCaptureList.SelectedItems[0], packetCaptureList.SelectedItems[0].Index, true)); + } + + private void exitToolStripMenuItem_Click(object sender, EventArgs e) + { + Application.Exit(); + } + + private void packetCaptureList_SelectedIndexChanged(object sender, EventArgs e) + { + + } + #endregion + + private void StartCapture() + { + Global.DeviceList[tscbInterface.SelectedIndex].PcapOnPacketArrival += + new SharpPcap.PacketArrivalEvent(device_PcapOnPacketArrival); + + Global.DeviceList[tscbInterface.SelectedIndex].PcapOpen(true, 1000); + + Global.DeviceList[tscbInterface.SelectedIndex].PcapStartCapture(); + + tscbInterface.Enabled = false; + btnStartCapture.Enabled = false; + mnuStartCapture.Enabled = false; + + spynetStatusPanel.Text = "Status: Capturing Packets..."; + } + + private void StopCapture() + { + Global.DeviceList[tscbInterface.SelectedIndex].PcapStopCapture(); + + Global.DeviceList[tscbInterface.SelectedIndex].PcapClose(); + + tscbInterface.Enabled = true; + btnStartCapture.Enabled = true; + mnuStartCapture.Enabled = true; + + spynetStatusPanel.Text = "Status: Capture Stopped."; + } + + private void ClearCaptureLog() + { + if (MessageBox.Show("Are you sure you want to clear the captured packets list?", + "Project Carbon", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) + { + packetCaptureList.Items.Clear(); + Global.CapturedPackets.Clear(); + packetsInBufferStatus.Text = "Captured Packets: " + Global.CapturedPackets.Count; + } + } + + private void LoadCaptureFile(bool append) + { + OpenFileDialog openFileDialog = new OpenFileDialog(); + + openFileDialog.CheckFileExists = true; + openFileDialog.CheckPathExists = true; + openFileDialog.Title = "Load Capture"; + openFileDialog.Filter = "ProjectCarbon Capture File (*.cap2)|*.cap2|CaptureNet Files (*.cap)|*.cap|All Files (*.*)|*.*"; + + if (openFileDialog.ShowDialog() == DialogResult.OK) + { + BinaryFormatter bf = new BinaryFormatter(); + // Let's open the capture file and start reading it. + using (FileStream fs = new FileStream(openFileDialog.FileName, + FileMode.Open)) + { + BinaryReader br = new BinaryReader(fs); + + byte nameLength = br.ReadByte(); + byte[] fileIdentifier = new byte[5]; + + if (nameLength > 1 && nameLength < 20) + fileIdentifier = br.ReadBytes(nameLength); + + if (Encoding.ASCII.GetString(fileIdentifier).IndexOf("SpyNet") != -1) + { + do + { + ushort packetLength = br.ReadUInt16(); + byte[] preData = br.ReadBytes(28); + byte[] packetData = br.ReadBytes(packetLength - 14); + if (packetData.Length > 0) + { + //PacketCaptured(); + // TODO: Fix + } + } + while (br.BaseStream.Position < br.BaseStream.Length); + return; + } + + fs.Position = 0; + + try + { + if (!append) + { + packetCaptureList.Items.Clear(); + Global.CapturedPackets.Clear(); + } + + //List capturedPacketsLoaded = (List)bf.Deserialize(fs); + //foreach (IpProtocol ipp in capturedPacketsLoaded.ToArray()) + //{ + // PacketCaptured(ipp); + //} + } + catch (FileLoadException) + { + } + catch (SerializationException) + { + MessageBox.Show("There was an error while attempting to load this capture file. It may have become corrupted or obsolete.", + "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } + } + + private static void SaveCaptureFile() + { + SaveFileDialog saveFileDialog = new SaveFileDialog(); + + saveFileDialog.CheckFileExists = false; + saveFileDialog.CheckPathExists = true; + saveFileDialog.Title = "Save Capture"; + saveFileDialog.Filter = "ProjectCarbon Capture File (*.cap2)|*.cap2|All Files|*.*"; + + if (saveFileDialog.ShowDialog() == DialogResult.OK) + { + BinaryFormatter bf = new BinaryFormatter(); + using (FileStream fs = new FileStream(saveFileDialog.FileName, + FileMode.OpenOrCreate)) + { + bf.Serialize(fs, Global.CapturedPackets); + } + } + } + + private static void SavePacketDump() + { + } + + private static void ShowCaptureFiltersDialog() + { + frmCaptureFilters captureFilters = new frmCaptureFilters(); + captureFilters.ShowDialog(); + } + + private static void ShowCaptureSettings() + { + frmCaptureSettings captureSettings = new frmCaptureSettings(); + captureSettings.ShowDialog(); + } + } +} \ No newline at end of file diff --git a/ProjectCarbon/frmMain.resx b/ProjectCarbon/frmMain.resx new file mode 100644 index 0000000..a39c3e4 --- /dev/null +++ b/ProjectCarbon/frmMain.resx @@ -0,0 +1,5828 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAqJJREFUOE+Fkt9L + FFEUx8f3/pR6KrenoIceepEgWwsC6yGIoAcDIRBCy1wVw1zHQoyUoHqwwAd9SgnUtXT9uf7a3XFd192d + /aHlujM7P3Z+3G9nZhMS1AY+3Jm593zuOefeKgDcSc9gYB9ly+Isi7nTgvhbrWKoknQrnUrpH42Dg67p + /hqNcwQn8fa7CEYTednGHpGTLKQKBrKSgY7xPXjblkevPBo7d6qAH0/jt8IwE7fwM2FiKlbG2JoCucwQ + SBrgJ3/h+rNp/lRBLwkOVYbFpIXFlIXZHQMTUQ3beQX7sgFZN1HbGmRnCooaw6poIZS2sJA0EdguYzys + YiQkI03l3GlfYFx07NLK7lS9kZy+/w/3DD9lIGnARpa5hEQbwYSBQLzsZpKVbNx2BMKoR2fMpnZRy5hD + 5d3/jUpwBcBm1sZ6xsYKZTKfcvphICcz1PkcwUj1IbM06OluKHE/lMQQ1N2vuPkyiCIJonlga68yhkm2 + KgLzSbhz3rZ5Egx7JNsoUnAfSjEe+YkHEPqq/0tBNeFtdTL4Um2Yag7ZiQYkh71IfKrB/pwfBeq0TeVY + VFEFBtNi9I+58pxUQN3zJXDC58uGW7+tEyqtVMAsGaX0ALTMANTMOyjie2IQJXEIuiy4goOSjVstwTIn + fPCUmaVCF/sI/i9+5Ld4pMI8Yqs8wks9WJ59hR+TPmxG5lzBtcaZXG1zsMgJAx7dNiToGUfQS/RAT3VB + S/qg7TZDjT+FGnuMUrQe8sYNmNKCKzi6/hx9aMwoVHZOv6bgTgp8AW2niYKfQNl6iFLkLuT1GkihqyQI + HhdEuy+axmGMjq4fauIN1J1eOhE60lgnSkIb7dwCOdxEuzdCWmuAvjd1XBDxnQ9FOi5okXbCGc/iaA3F + HJXwBw19LQH5404pAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAk5JREFUOE+lU89P + 01Ac18S7NxMT/wAP20Fk5WI8mXgx8SBRE40OFDUME4NK4o9ElwibMjfBTRNDNCQEE0cgYwuGyUU9oBh1 + gelKN5DxY2GLrKPr2q7r+vG9Dhh44cBLP/32277Pj9e8txvArh0NKrAT7IhspKe36VBtJPnpgjr/2boJ + F9X4yJEZdti0j2DvFgRJHzTt2RDggoyi62XS6+SiqDyX5AwWx23FhXGbso7U9zvy0sSt5HSg5nRVYMiS + 0zUZyqIbhdkuFObeQEoOQC/xREuEruUJVit9KQuU1SI3xESrAu8YoayuErIXYuI5hF92rEw0I/OtBfxU + O/jJh+Ajd5H92UbQSpKlwQ3W5qsCfotakpbBR73I/nAi/fEmpPRX4iqsudOaqyYgy+P8jFwV6K9TjfWX + FQIJ0AoGUZNYKCkv5IV2SH/aUIhfg8iehybGwPVZNgn0MkVdk6AJX1DiR6H+HUBxuYcQOyHN3YeUaEHo + /TncfnkWV9wn0fDkOLpdNaVqgleMUlYFqCtBFNN9xNUHeZ64zlLXJgwG62H3NyAU9SGSCsPzoRlnPGbU + 2fa7jH3AeS2yrvKE3AtlqQty0k7IrShwlyDG6tH4+BgCU88Q+N1NpgOusSZ4xq5SAbmykdyHU2oukRNn + 3pbF+GvkuRfIs27kYx0Qog9w4t4hjER7DPL6GJ70UYHKOWA7TDdYp7mfdZgzpMr/4+j1A+gMN8IRthp8 + x6h1a4LtDhNxenTKdRBPw5dBnWml/cY/2E6AfieTnQQCjb1WnfT9P6X82Esr9ir8AAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAsFJREFUOE9VkslP + E2EYh0s8oF78M7goDaiJR0NSFDkYRbmQKEtZEqNEogcTiQQxwcSTW0xMjCcvHkB2pYUAbaGyKXRT2Vqg + QBfazrTzTWfpz3em0MIkz3zfLN/z/d53psBAh+npRG3hmcKaEwWG80wwnDx12lCg3dfPoBMyBjmTWU1E + MtbYxs5jz9dqSX9+eFS8sE2FOBbZCu0r0aSIKJ8nwomIcAzeIIf2vgBqXvlSV+8PFR4TVHbbQ7uRuDK9 + IcHpl+EMyJjZkGFfT2Pin4gRTxKiDAz4BLT3+tHw2iUck5Q/swiJVBrzmwoWNmUaZczqkjQmV0T88KRI + oGI+qMC5LaFrKICyJ2NfcikqXzqYJlgkwa8tGYtbii776ZdgW03D8kfA+l5SL4VnMvZiKZgeTcrHBPFk + Gsu0g4tY3lHxW5doKSQ9xSilGHTx6F9KIE59Ku+0sZzgWreDxUjg3cnAQ4vdhCuoYolkc9ST6fWsxPpX + wCj1IZaUUP7ckRdUkCBKAt9uRsdLeEi2vJ1NoksoyRSVo4miJDB1HhFc6XKwCJ+GJ7dYzSXRJFpf5qgc + LYmDCHESyjqOCEyddham763tqpVwiJvKOEwxH1Awq31igqNGXmyz50so67Cz3YQI93Y2dhZqJqGVsECL + 5wgn/RszJGCSipLWibzgcpuNBeMMtwdEVA8w3BpkqKJ5VZ+Im/1M50Yfw/UDUmkFxtbBvKCUbJtRhgeT + Kj77gE9e4KMH+EDjexrfEW/dwBsX0DgmI0klGJu/5QWXHo6n3P5wpmVcRbNV0V8yjyk69XTdYJVRZ5FR + q11bFOwnePXc3QE+9x+UtljW/IkU5w5E1bWwgLWQgJUDwrwEDa3zPFMQ2udUQRDiRXeG3TnBhZbv94zm + EUtJ02jU2NTLcjTSnChu7Mli7mFF5uHY2fpha3HdUIMm+A/hPMu7HWqN8wAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAArNJREFUOE+lk+1L + U1Ecx+vf2N12TUECGVGIICHUXgVJxKbZUMyHZWm6BzcfaZsxbKZFGTkfxkgpLbPUanNOberU5taUMnHZ + VULMvemBasPowb6de6Ft+iKCLnwv58Lv8zn3nPM7uwHs+q+HFcSmwHsoIXfmoC7bncpkPNkfkoyKQhJn + EiNxJOmO2fYm7KzfBud50qQyd0pQ65bhVsCM/pVuLl1LLShxHoe4jw6Ke2lprCQiILNKMyeSw9fmDXCs + DcD66jqM81Vc2LF9rR9Ns9U4YBWEU6yCiIQT5LhT4zNdyRsszBbW+stQ6StB+exZaEkqSGq852B7cx+X + pishMvM3RDf48dz+sS+ZK1mvGs/iZmZhFlR5TkMxUwjFdAHU04VwrQ9B71HCTiS5vUeQeJWvjwgyRkVM + V6AFlkAzKr3FUD6VEzAfyikSdz4m3jpJLRAMr6P9RROs802Ia+AzEcFRW+Lmw9U7qPOXQ+MpIn8yiKWP + C1BNFmJ8fZiDf279QPvzy9BPFqM/0AWhgdqMCMQP6M2BlR4YfCrU+TT4/O0TB334+i4Cm+caoHZmQ+c6 + g4FAJ4S1sYJemrm50IyOxSvQTslh8tYg/P0LB2/92oL52UWUObJQTgSt/np0eEygq6noEtJuC/XywXTY + Vu+hZlIOtesU6mcqsPx+Ee1zjSgdOgGF/SS0jhzYXvfgmOUw6CoquokpFkH8PnI0Jnc5HjF3UTWWB81I + DlTDMijtbFg4G4+Xu2EYLoZQzdug1VT0GNnNSGrmS+MaqbDRVQY7kbT5TdCNFeH8iBxtZAk2AuscRRCU + 8sIE3t5If1pzTyNfShupoKRTjA6fCX0vLehbsMDsMSK9NQ1CBS9Iq6Jw5BRie5u+wE+g9ZSOrqUYoYYX + Eqp4ITIjQ6KjS6m/X6adN+1fvn8DPGaAEztEPfgAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAoNJREFUOE+lk+tL + U2Ecx+tNf0ghRIl0JaIwrdC5eQs1mIVJa4ihlmmh0DTxUro0dV5m5jRlRqmFEXSxC5kvemPh8q6p1Lyc + 2WWMKNpmn54z59QwCDrwwHk45/O9nPP81gPr/uuSBVYuW0Odar7FZPlkbrLPNzdI8031ks1ktEu1lZYZ + fVHM9JX8DSvfXwXPGauU9s7bVve7bhh8CX3P4G0XvHmM+/VDPjca+ZCTfW5NgbkaQ9iXjtZJd38PdLfA + PT20FcOtAmjKgbsVuF49wGa4OjaVnqpcEvEkmKutVH5tN1vdfcL1RRPcKRJgITTnQcNFMGZB+Rm4WYjr + STtz+nzrZLLGI+IRsF2v7nf3PoWuG2AWkAyaBFgnQEMmlAm4OBkuJYp9Fq4OE1Mp2n6fgGSsdND7SETV + LTp6wAwBpi2C+VrIEXCWGs5GiYRGpk5rHD6B2Qq9jZ5OEfXCGuAJyI6HjDhIE3CSQlQpZ+JkvM0nMFNS + KPG8DUpTVzh6wUwBnomGZBVoQuD4AagvYfxYjOQTmC7QOehqhVwB5ax09IKnBJgQDOp9ELVdVLzMWFzE + coWPWekD7vvNcE30ljvKUWXHJTB+P8TtAZW/qBCJ01DAsCJowJdgQpugms3LnnZ1NEJeknALWlxqLxi9 + k4WQzSxolXyvKWYiIXa6f5e/cPD+Rvlm9GhkhPV8yqTTXAOZ4qNF7xBxt/ErzB/nQT9+Jir4VlXEe/WR + 8b4Av4hVB2lpM6QIDremaKzOWnECqwtwl+fiLNPxo1SHQ6+TYfq2bBQ9l+dn1SzIDwaD94aPqA5bRqNC + 7SOqQ9KQIkgaDg20DwTutlgC/GItWzf9fZj+nMx/2f8G++2we3vfkZMAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAjRJREFUOE+Vk+1P + UmEYxl1b21l/Q0W5msuT01xvpoBHRYhp2qa8C8IhURMQOIOhxKoPtfWX9HdpVsabkRzg8ByubjDQs2Mf + /PBsz3ae63ff93XdZwDAwFVOY128cfG9VixlDJAy/P+AjUCIr3vX4jWH29R7cw7oiDN7aKezUONJHaTh + D/KNYBjNzW38eb3ytbq49KADOQP8EyP/AW06akJCa2unD6mvrfNUHa1oHMjl0bmfWO3x8ozl2hkgleba + CUlt770DPn+Bms11AGgGRb7uC/BUHcpODKDv9UAQJ/MvWVmYu37eAUHUWIJjb2NMlTLAx09gqTQaoTCo + OpTtKJDd794rFhuJZzm9BwRpRba4prjBWtFdIP8e2M+TMAdksqj7/KjMWVl5eqYv1nTQI1K7nOxZU5Gl + cbx+wOUFpDQqs/NqySxoxJcCZLevExVAacDhBlacwG6S5rahMDGlS0ezB7LLy8seH5RwBEhKJEwBMRqH + DKyvOlE2mvFzbFwD6QNqTg8vu71QxA2AYpRdHpBZrDhlUk8Xl4HIJmqvllF4/BRHQ8N9SBdAm8VTdSih + N1Q1AZlaJ7NYcdLEFZ5NcMfjT1jVYgVCIk5tdhyPjOLwzmAX0gXQZgk1hwtKUIS86gKZxYovjH3DfoyM + cd+HH7LfZgGyfQG/Rh/h4JZB0JhImyVUF5ZQMk2rZJbO7aP7Q9y3wXvsoliXQsloFgrPJ3XiXsSHhrvc + wc3b3cqXLtJVfuve279yu6THdnerNQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAgVJREFUOE+Vk8tv + EmEUxXHhX2L8U4waY4wrVy5lK0YXkqZpYIBhkEccCk6dIgttsHZaYyi2jKgjb5NR0pGHL2iKFAQtrhoX + mDnemQWa2EKd5Mu3ub/znXvunWMALNO+eDxu03XdSrUn6bZYrdbjY8YQmHRisZhNFMX9TqeD4XCIaDRK + 5X+YibBRSHC93W6j1+shnU4jHA7/n4AgCCPj9UqlAp7ns4ZoMBiE3++Hz+cbTXVAln81m00UCgWEQqFX + gUAgJ0kSGo0GWJadLBCJRM6QZb1araJcLiOTyUCWZWSzWeTzebjd7vqBDm6tfuG9iY8VsjwqlUpQVRXG + XSwWkcvloCgKXC7XvtPptP0jwC3v8IvpHoSnXfiX30PTNKRSKXAcpxuW6dURwzB1h8NhM1fg75GwBrzR + RabyA/LbIfxrbcyIGrxe70+Px3PioHGPBdyJHX6B4GcEJpQ+7j//imT5OxwPtnGZ014ftiumALO0zQvr + Xchvhlh62Ud0fRcxamOt+A32eAsXmdqjQwXmCJ5PdrGpEvyij/nkLkRyspof4Oa9Fi443kmTNtVijzex + oe6ZlvknHdyl8KTcADcWWzg/Nxk2Q7x65xP1ugdxk5KnNlYIvk7w2dmtx9P+E1Pgyu0PqhHUSnaAh8oA + 1xY+4/TM0eDxGC+xtRoFhXOzWzhlPzpsCPwGZiza7bmUpcQAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAflJREFUOE+NkzmL + okEQhnUn3HCDTXZg/sMM80dMRUwMDDQwNNNARQNZ0MAjUMFIGJD1QvBAhPXIREVMPAJv8b5d3+1q1PGY + HfaDl6+hq563qrtaCEAgFAp/CASC70wPTJ99PbbZZDmHcxAB2Pe8Xq/Hu93uz36/x0di+7BYLD9Z7BPT + F8rjuUfAKyXP53MsFouzJpMJRqMRut0uh7bbbVit1isIuQuZXilgtVphs9nwP2k2m2E8HqPX63HAcrkE + mdhsNg45mr8DKPkkAlDCdDpFv9+/a4tMj+bvANbGOZDW1De1RK0MBgNeSavV4jEfAm4P7xISjUYRCAQw + HA7/H1Cr1RCPx7lzMpnk63q9Dr/fD7PZ/HbXwm0F5FqtVpFIJFAul1GpVBCJRFAsFmEwGKBWq79e3cIt + gJIKhQJ8Ph80Gg2MRiNvI5fLQavV/vq0glNgp9OBTqfDdrvlh2q329FsNhEKhaDX6/kUnufgsgKv14tw + OIxGowGn08kBJIfDgVKpRLMAmUz2bwDNQD6fRzabRSwW4xByDwaDSKVSkEqlfqZvlxUcbs/A5XJxAFVD + fVOi2+1GOp2GQqGAUql8OL2FFzaBCwa4ekzkJpfL+Q14PB6YTCZkMpmDRCKBSCT6ffmYHlkpL8fpohG9 + k0qlglgsPk3gM4t5JMBfRaCjuAogfgcAAAAASUVORK5CYII= + + + + 126, 17 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAqNJREFUOE+FkstP + E1EUxsvef4SFMcaAS124MCbE+CiYmLgyMTEuMCGa4KJoECEYoBQfwSAbNRFNWMhChRioqFBeLa/SUkpp + O30hFmY6rzsz9/PMFI0kVm/y5U5mzvmd850zVa4KZ+BzAbppukyTOxFRYUdRDVQx3UgLgv5C0YTOqe4G + tVK+6/EnARxAXrJQIOVEE6kiQ1ZkaB8twN06/+7E9aFDFQG+0TR2ZI4vcRPfEgb8MR0jSzIknWMyyeCb + +I7Td/y+ioBeAuwqHHNJE3MpE1ObDGMRFRt5GdsSg6QZuOAZL/v727EBeyrHomAilDYxmzQwuaFjNKxg + OCQhTXYuefzctTpyLLj1/iJLfqj/Q27mJYCoAitZ7igkWAgkGCbjutNJVrTQYAOCr2s1zi0aF42M2yo/ + ez+SBQcArGYtLGcsBKmTmZQ9D4acxFFvA5aHa3a5qUJLd0GOeyEnBqFsvcX51gBZACJ5YL1QvsMEWxSA + mSScb27PBHdFXx0VLbZHyX0oxXzIj11FtK/mvyoqBgGog+ibGmYoOWTHGpEcciPxsg7b014UadIW2THJ + UVkchsnpHXfgObGI+rvzoA6OM8e/pZEUipTBTQmldD/UTD+UzDPIwgDpOUrCIDQp6gB+lCycaRnXXdEn + tTo3FWhCH8m3Ly/y6z6kwj7EFn0Iz/dgYeohvk60YXVt2gGcavLnzt0K7LmC/bWaxURoGRvQS+qBluqE + mmyDuuWBEr8NJXYDpcgVSCtnYYizDuD3vxPsPqJyVixXTndTcgcl3oO62UzJNyGvX0Np7TKk5TqIoZME + CBwERLqqDbYbo9U9hZJ4BGWzlzZCK411oBS9T5VbIIWbqXoTxKVGaAX/QcBKW3Voof2wuvCAZN//0n6M + nfPLwk/NAcmQGlykogAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAlFJREFUOE/dU89P + 02AY5uCdm3GJfwBRkcxJ8aQXEy8mHkQ00QNDUbNhNBg5qIkuETZkMsFNEkM0JgSjIAYhKIOEeMIfURpW + oW4DGeDCFqGj7dqu7fr4tcgAL9z90idv3zbPj/f78hUV/R9ratBBJ95XqvPDVZtwSo0NHZqJv96/c+aV + o3gLRhzFY2NHdhSmp19SimHkARjkMbH2rslpLI65cgvjTmUdya9X5cR4fYLtP1BVEGDelGcMXYay2Irs + bBuyc88gJXphaBzREmHoAsHqWq+tICtkcmwfxRQEot12Pq+uEnIQYvwR+O8eLH92If2lDlykEdzkXXD0 + TaxMNBDUk2QpRPsOChsCPeWqJi2BY4JY+eZD6sN1SKlPxJX/627WTCGBOR7dUyZvSlChWvPnFQIJ0LMW + UZdYKMkg5IVGSD8bkI1dhsiegy5Og+7aLNBB5Qxdgs5/hMYNQ/3di9xSJyG2QJq7DSleh8F3Z3Gj4wwu + tp6A8/4xtPtLtI1TeEIpeZWHujyAXKqLuIYgzxPXWdO1Fn0DlfD0ODHIhEAnwwiMuHA6UArKbfNbInSg + TDZUjpCfQ/nVBjnhIeR6ZKPnIU5Xoqb5KPojD9E/1U6OF/CP1iIwegll7uK1ffjRXJqUMkwmHXmRF2NP + IUQfQ2BbIUw3gWfu4PgtO4aYTou8vt5OhlDhtsESYJv2XmN9+7oZ7570hK9U/heHr+xGS7gG3nC1xfcO + V29NsN2FpFy2eyf9JXgQvgDT2axmX9iD7QTM/5Rrl8/utvFmbLOavfn9D37dAnBgRP0wAAAAAElFTkSu + QmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAqhJREFUOE+tk91L + k1Ecx/0Xuptbe57S8CLzohhFpZBeRIiEa+BLmmYu86Vtz17UlLYJw2ZapIGPL0tSRLMstdqcM5k6Z9M5 + pUxc9igh5m56odowerFvzzNwWZQX0YEvnIvz+Zzf+Z1zwsL+98iaio88NX5Ym+Y4yCSa9/oTzTF+sS2a + EVt3a5P7d0VuuV+2K06S4tjv0zjS0e6l0bPYEUzbfD0KbclI6CJ9R7oIyR8l2c5DEvGIKFA7o4d1uRct + z6/DMFMaDDe3LPegZuIC9tHCwIEbgl8lJ8diIyR20SoHcwvLPTKUuAuhmsiHhk0xm7LJIphf3sVlZwn2 + 0LzVGJqICFWSbhfpqOHU4M4czIGU6yzk47mQO89A6cyFfaUfOpcCFlaSdfsYoq5t14UE4kcxTJu3HiZv + HUomC6B4LGXBHCjG2DhyMPLKBm74AitoelqDlpkakFU8JiQ4ao5au790CxUeFdSuPLaSPsy/mwU1movh + lYEg/G39K5qeXIFutAA93jYQ+m1rIUHCPXKtd7ETejeFCrcaHz6/D0JvP70OwfR0FZS2DGjt59DrbQVR + vlnQSTI3Z+vQPHcVmjEpjJNlCHz5GITXv6+DnroEmTUVKlbQ4KlEs8sIUrPpCLHthE7alwTz0h2UjUqh + tGejcrwYC2/m0DRdjfP9KZBb0qCxZsL8ohPHTfEgSvk/myhqISK4qzE6VHjAdKF06DTUg5mgBtKhsHDh + 4Aw8XOiAfqAABMVbJahN18g1I7pWINlRIQgY7DJYWEmjxwjtUB4uDkrRyB7BzMJaax6E+fwAofztIW10 + c2e1QELqw30nWhPQ7Dai+5kJ3bMm0C4DkhriEF4U7iPkf4E3JEKDMJLQ8bVkOY8h1Hw/QfH9pIydU3yt + UCbc+jP9y8/+AXgysSbksUp9AAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAmdJREFUOE+tk9tL + 02EYx7vq/wgMQizKiAiDZZSHTdMwhUmltIZYptZEJjSX5DQd2jxthssjFuQhiqCDHci86MbS9XNRmsvc + JtuIxoiibfbpXdpU0C6iF96L9+LzPbw8z6ZN//t4re0KX0+HzdXT7fdZrR6ftcPj6jT5PWaTzV1fmyXp + 9Zs39HRbWuX+4X5n+M0o2J/D5BN4PQKvHhJ+eZ/PXe3M6bQX1hVwm5tTfQN9jrA0BqN9cNsIA3Vwsxq6 + K2G4idCLe3ib6qcd54vla0TcFpP8y6BwnhSuz7rhVo0ADdBbBdcvQrsWTCXQYyD0aJCFK3qno0C1IuK1 + tEnh8ccwYoV+AUXATgFeE2BLGTQKuK4QLuWLt5bQUCezRWopmmKupTnA+AMRVbfk+BvUCLB4CbyshkoB + a5VQmiEStvPxjCoQFVgwGr2M3RFRy9cB86AiFzTZUCzgghRRxcTsqVxvVOCTweDh6QA0nFvluAyWCbAk + EwoVoEqC4zLoqMeek+VZqaDXBRi5AXoBVa52XAZPC/BkIigTIGOXqFjLdPahlQrz5aVT4bu9cFX0jnSM + RI04/gFz90P2XlDEiQpHCLZU8/awbCqaYEadp3BXVbhCQ11QVSDcDixd5TKYuZvFpG0squV8M9cxcyLL + ZYuPU6yZhfc5GenzmrOOYL8ZysSnZcaLuDv5mRpH8OBWfuSn8LW1hg/KozMTO2LS151Ge5IszVmkcgYt + YgLbqgmb9AQbdXxv0BEw6iIwE7FbNH/dP7tsX9o7RaJNSkv22xUyjz1F5pGSE/xSwh7b5PaYY1Js7MbL + 9C+b/QsljedGUVEodQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAgRJREFUOE+Vk2tr + 01AYx4cgBL+CSEB90wYpMt3Ubgl5sYtlathclzVbai+2M66XrSUlW23VFwp+Ej+TCEW7OnS6ubZL2jTJ + 39NAp6WNsMCBA+f5/Z4bmZi44IdU6oon4hQKtKOqjFdAV04yHUnK6eEIOxLTh1Hag6NqcPL5EUlXlplO + LInuloJTYeVjMyT4ziUDGJU3cMixd4roKsq5xIWjcfQyOaBcQf9+vPAwh2r1kishF6qdVmxn7xXw/gNs + rYzei230S3ZhOQZzOwuQdyMaw7cZzsLk5OWhNhCtUs2XWcsuloC372AVVHTiSRibz2AqGUDbd++NIGvV + OI4aOydEo9RJImX1Mnmg8hrYrxCwDJQ0GBsyGg9mveGBsS/5KazY0Eg7kgyIElBU0eA42zPzv+W0RJkx + pE2AbAPhdeDpGpDfxe/5RfwKBj1X7DpaosjokQ2YyTSwWyRgAciSdsgAjdU1HM9yOAwExktceF2CmUgB + ZI26GMHB9H3r6wxrtx8JQHoLZ48FHN2ZwqHPNyxxYdKrGX9Osu5AJ6UfTN1zB+YeP2M15xaAeALtxRC+ + 3wrgy7UbfyWt5WX+LCzCjCWgr4qo350emnaN5qjPfr91yvHQQ0v4EbiN+lWaH1rlyXyIby49QZ0dP+0a + TVOfrt+0xsID0xHL8v9bVV8ykvmCf/NI+B/GLEizmT4EuQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAepJREFUOE+Vkk1v + ElEYhduFv8T0n5jUxGjSlRu3ytIaTbSaZoKAAzgQHCZ06hS7UIOVaY2h2DLSOs7wZTI6dsJHq4IpUhC0 + 46pxgZnjvTWurEBvcnM35znveU/u+NgIJx6PTwO4RO6E4zhjLpfrxAjYHwmFJUk6aLVasG0bsVgMI8NU + KIpitdlsotPpIJPJIBqNHtugT6ebpolIJKJR03A4DI7jEAwG+0PTEOGver2OfD6PUCj0mlxdlmXUajWw + LDvYQBCE04FAwCmXyyiVSshms1AUBZqmIZfLwefzVY9McDf5hWcTH0ye5/vFYhGGYYC+hUIBuq5DVVV4 + vd4Dt9s9/Y+Bf2mXX8h0IL5og1vahmVZSKfTYBjGoZHJ1L7H46keCd+h8FobWfMHlHc2uJUmbkkW/H7/ + TwKdHFiYN7HLzxP4JQETahcPN74iVfoO96PPuBCw3gyEiYgXV9tQ3tp4/KqL2Ooe4mSNlcI3zCw2MHW7 + 8vS/BgyBhVQb6waBN7sQUnuQSJLlXA83HjRwjrHkgdNnFutYM/YPI/PPW7hPypP1Hq4tNHB2GEydL899 + JLvuQ1onzZM1kgS+SuDJ2ffPhv4yKrh4b8egRSW1Hp6oPVyZ/4TJmyPCfyecZyuVKU8FZ2a3cOr68eDf + Mu5hwBUCkOEAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAfBJREFUOE+NkzmL + WlEUx2eSMmWKNAnkO8wwX0TsVGwsLGz0E9ioaCGDiLgUKlgJAYkbggsiBLUTFbFxKdzFfTf+c8+NvnGe + MyEP/rx73zvnd5Z77v3d3+cr0xemj+f9e68B+9FmOokNHtbr9XQ2m/0+Ho94S9vtFjab7Zk5fmf6IAY8 + kfNyucRqtRLEvmEymaDf73Not9uF3W6/gdwz2hMZbDYb7HY7/iYtFgtMp1MMBgMOYFmCgjgcjguEJyIA + yPkiApDDfD7HcDi8KYuCnn1fAIfDQTCkNdVNJVEpo9GIZ9LpdLjNmwBx864hiUQC4XAY4/H4/wGNRgOp + VIpHzmQyfN1sNhEKhWC1Wn/clCDOgKLW63Wk02lUq1XUajXE43GUy2WYTCbodLpPr5ooBpBTqVRCMBiE + Xq+H2WzmZRQKBdr//GcGF8NerweDwYD9fs+b6nK50G63EY1GYTQaqZkvp3CdQSAQQCwWQ6vVgsfj4QCS + 2+1GpVKB0+mESqV6H0AzUCwWkc/nkUwmOYSiRyIRZLNZKJXKkFwu/yxkwAbmJO6B1+vlAMqG6iZHn8+H + XC4HjUYDqVQqXL5HBlgxvbpMFE2tVvMT8Pv9sFgsdJQnhUIBiUTy6/pCfWObx/N00YjeSKvVQiaTXSbw + gdmQz90fjMx+s1Cwrp0AAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAA5hJREFUOE9tk3tM + 0wcQx39ExJjNbP9scQm6xC2L20JY41CHxSwhIxuZqDNIAEEqo3XYVhkPIw6pwGYHq7YbQ+ShtLWAoLal + D6D2RWkptW9oaaGsOGQOuzEcC87Qje9K/1im2SX3x13y/dxd7i6GeMboxoKUGCKGsQoi6e8Y4qU4YiWW + CMf9TqwnLFhdbfpuL3/gWU00rtZVxzINBdeZxtwnd34UwRZSQXvPBPmUCRKfBjd9nTgqzwtTVdnKYl3m + 809BqDbqeqaRYhT4v8H8sh1TCx6MLzggnnFCEZyAwOMB3+VAj8sInuUCcm8fcGf2ZL7wL4RhpIg6fBcQ + XNJjYskM76IXzocudAa86A1Og2sPoGHUh4tDFoi9GvDMlfhEkK6MApjDFDJTlbUy+4ce8kUFbj5SoH9h + CP33PWjzT+L78SkwFHYwZGbUWRVomWmE/WcxUnnkv9Ib399PRFq/pQg2w/aLAl2LUtz4zQJLyA2O04sG + 6ySocjtoajVKJlpQGqxByXQlhC4ero+ykXqJPEhE2p8d+1UGwWwrOKH2SHUPzCEXmINOUKU2lFusoAUq + sG+Sin2+IuSN03HuTikMARH2snc/IJi67OXpR1rU+s+DETiNlp906JqxIa/7LugaAxqmBlDg78TxLjKK + rpFwQJ0Nem8hHHN9eK/67cdE4WDB4x8Wtahyl4Lu5uLqPTXyu8zIl4zj0JURMNUjqHSL8algD87LcpDV + vB00YQ4c96VILEv8kyjWZc85H0rA9dSiflqHGuswDgtsOClKAUOYDBo/CZR2Er4QZ6LHykNZ736kXdoM + tZ8PUmXiPFGkyukT+76FPNiBUyN1YLm6cURkwgnhLkgcTbhlb4wKu61ccNVl4JvrcVyUhl3sjSCdSdAR + x/qy0vJEh8LjIQXK1J+hRMMEQ6lFYWTeNfFF1Ul8PXACXyqpYMkoqFHQ0GyoxZEOMl4tJ8LRWzjc/bGU + o6+AzHcFLP0ZnDOokdv6Jm7c5UI0ygF/pB5XTewIpBiXDTWgij7Ea6Vxy/ElxMYoIKMtY1N68wfur/pP + wTx/Gx1jehy8vA0f8eIju34ZexpeRP61ZDQNsXBMmIbNVRuevHV629an/iGjLXlTKidFmVT/Trjd1Ip2 + gwxtQxq0D2shHZPgXfZzOMpPxZazG5YSKl6P/9+PXEvurks6uJO1o39HFWlu++dvLK95QnnCg1eq1q1s + PbsORDUR+1/xP0nxUG1dHedsAAAAAElFTkSuQmCC + + + + 225, 17 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAqdJREFUOE+Vk9tP + 0mEYx2nzxr+gOy47mGvZcslWKtOVukXmRUw35zJn6mKEGToPkSYkwvgpQhIqKJC4QAGVSeIB85AHQp15 + wswysdW6bJpC+/aDlpPSNt/tuXufz57n837fYwAoRzkCw2r09vaP/u87Pu/W9m4KxQ84rFoc30Ia7Z+p + MquHJupYY5Trl2UV+iWIjIuo1M/hJn9o69Bm9cDXUIVtc6yu+xMkljUIDW6I291QWN+hxrSIggYn4ot6 + dg8FyK0eblPvBgwjm9ANrKPx5XvUdS6Dp50Fv3UWN3h2ROd1xBwIUNhXTgi6Rn9qyUZlzxoEbfMoa5nB + feUUHmlcyBQN4lKOQR7wt39//9hK26ZJ2tm7UzFaiHKzFVLzEoiORbDrJ5BNDIPbMI4kjgUX0zSMIICq + /0tIfY/HrbZvwF/81mYfb4iLNMLsYz99jRLVFFL5fbgrHUbM7VZEJCtpQQBpt4dKWD783nlwHZL2JXBk + bbvMakNhQpHOl15pRy7hwK3qPkSmNCI8vpYaBKhqX6UJDSvQ9H/EkxcLkHUto1jtQoZQ7i3tY+EKuw7X + H5hBz9ThTBzhPkUXhQQBSjULjIfat4Fn8gsrUDrxWDcNrnIcWeIyFNvyEJks9obRJaaTsVWhf9ztSWQp + XBZB2xwkxgVwFBPIqRlBRvUg7hCvkEVav5rD855nCE7/HboAIFfmzOc2uSA2zpOWp1Da7AzYZstHA3sn + sIyIuKbgHpRYSnbtJIfzzIly7Uxg5BLVJNJJ24kcE2Kz9IhiqnAuqX4sPI7YG3s/iJJaNYwyzTQZkDfI + FjuQmG9GVPpz+QWmmhGRrKCdTZRRw+KIgLADJ0gq6SVNO5ApJPdkmfwBof/vg/3jgH7PcvxyrgG0DP1W + JFMdc5Rm/91fC+qcYjKYn/oAAAAASUVORK5CYII= + + + + 472, 17 + + + 576, 17 + + + + AAABAAgAgIAAAAEAIAAoCAEAhgAAAGBgAAABACAAqJQAAK4IAQBISAAAAQAgAIhUAABWnQEAQEAAAAEA + IAAoQgAA3vEBADAwAAABACAAqCUAAAY0AgAgIAAAAQAgAKgQAACuWQIAGBgAAAEAIACICQAAVmoCABAQ + AAABACAAaAQAAN5zAgAoAAAAgAAAAAABAAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAABgAA + AAgAAAAJAAAACQAAAAkAAAAJAAAACQAAAAkAAAAJAAAACQAAAAkAAAAJAAAACQAAAAgAAAAFAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAcAAAAKAAAADAAAAA0AAAAMAAAACgAAAAcAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAFAAAADQAAABYAAAAdAAAAIgAAACMAAAAjAAAAIwAAACMAAAAjAAAAIwAA + ACMAAAAjAAAAIwAAACMAAAAjAAAAIAAAABsAAAATAAAACwAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAAAAsAAAAUAAAAHQAA + ACUAAAAqAAAAKwAAACoAAAAlAAAAHAAAABEAAAAHAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACgAAABcAAAAoAAAAOAAA + AEUAAABMAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE4AAABKAAAAQgAA + ADQAAAAjAAAAEwAAAAgAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAADAAAACAAAAA8AAAAZAAAAJgAAADUAAABEAAAAUQAAAFgAAABbAAAAWAAAAFAAAABCAAAALgAA + ABwAAAAPAAAACQAAAAcAAAAFAAAABAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAwAAAAwAAAAdAAAANgAAAFAAAABkAAAAcQAAAHYAAAB4AAAAeQAAAHkAAAB5AAAAeQAA + AHkAAAB5AAAAeQAAAHkAAAB5AAAAeAAAAHUAAABuAAAAYAAAAEoAAAAwAAAAGQAAAAkAAAACAAAAAAAA + AAEAAAABAAAAAgAAAAEAAAABAAAAAQAAAAIAAAAFAAAACwAAABQAAAAfAAAALQAAAD4AAABQAAAAYQAA + AHEAAAB6AAAAgAAAAIAAAACAAAAAegAAAGwAAABXAAAAQQAAAC4AAAAmAAAAIQAAAB8AAAAbAAAAFwAA + ABMAAAAQAAAADQAAAAoAAAAIAAAABQAAAAMAAAACAAAAAgAAAAIAAAACAAAAAQAAAAEAAAABAAAAAQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAALAAAAHwAAADw3NjV+VFJRtVdV + VMZaWFfMWlhXzltZWM5bWVjOW1lYzltZWM5bWVjOW1lYzltZWM5bWVjOW1lYzllXVcxHRkW9HBsbnQAA + AIsAAACCAAAAcAAAAFUAAAA1AAAAGgAAAAsAAAAHAAAACwAAABEAAAATAAAAEwAAABAAAAAPAAAAEwAA + ABoAAAAmAAAANgAAAEcAAABZBgoSdRcoRbEfN13ZIjxl6CM+ae4iPGXpHTVZ3RYnQ8UDBQmZAAAAjQAA + AH8AAABuAAAAXgAAAFQAAABOAAAASwAAAEUAAABAAAAAOgAAADQAAAAuAAAAKgAAACMAAAAdAAAAGAAA + ABQAAAAQAAAADQAAAAkAAAAHAAAABwAAAAYAAAAFAAAABQAAAAQAAAAEAAAAAwAAAAIAAAACAAAAAQAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAACAAAABs2NTRVamdmx4WCgP2bmJf/pqOi/5KQjv+AfXv/gH17/4aDgf+Gg4H/hYKA/4WC + gP+FgoD/hYKA/4WCgP+FgoD/hYKA/4WCgP9/fHr4V1VU0A0NDZsAAACKAAAAdgAAAFgAAAA3AAAAIgAA + AB8AAAAnAAAAMgAAADYAAAA0AAAAMQAAADAAAAA2AAAAQwAAAFMAAQFlDhoskhwyVcokQG3zJ0R1/ydH + ef8kTID/I0+F/yZQhv8qT4P/KUh6/x84YesJEBqtAAAAmAAAAJAAAACIAAAAgwAAAIAAAAB9AAAAegAA + AHUAAABvAAAAaQAAAGEAAABZAAAAUgAAAEkAAABBAAAAOQAAADEAAAAoAAAAIAAAABkAAAAVAAAAEgAA + AA8AAAAOAAAADQAAAAwAAAALAAAACgAAAAkAAAAIAAAABwAAAAYAAAAFAAAABAAAAAMAAAADAAAAAgAA + AAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAUUE5NY3p3deqtq6n/5eTk//v8 + /f/+////9/z+/9XY2f+VlZT/f3x6/4mGhP+JhoT/iYaE/4mGhP+JhoT/iYaE/4mGhP+JhoT/iYaE/4iF + g/+Gg4H/cW5t6BkYGKEAAACLAAAAdgAAAFoAAABGAAAARgAAAFMAAABhAAAAZgAAAGYAAABiAAAAYgAA + AGgGChF9FSZAsSA5YeEmQ3P9JkV2/yhHef8mTID/HlWR/xtYlf8bWZf/G1qZ/yBbmf8qWpT/K1CE/yU/ + avQ7T1LUQVVS0TZGRcguPDvBISwrthEWFqoHCQiiAQEBnAAAAJcAAACUAAAAkAAAAIoAAACFAAAAfgAA + AHYAAABsAAAAYgAAAFcAAABLAAAAQAAAADcAAAAvAAAAJwAAACAAAAAdAAAAGgAAABgAAAAWAAAAFQAA + ABMAAAARAAAAEAAAAA4AAAANAAAACwAAAAoAAAAJAAAACAAAAAYAAAAFAAAABAAAAAMAAAACAAAAAgAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACAAAADUxLSkt7eXfsw8HA////////////+/Ht//vWy//8zL7//9/V//Ho5v+hpKT/gH59/4yJ + iP+Mioj/jIqI/4yKiP+Mioj/jIqI/4yKiP+Mioj/jIqI/4yKiP+IhYP/c3Bv6w4ODpwAAACKAAAAewAA + AHAfHh2CKSgokx8eHZcFBQSNAAAAiwUHCY8THiymGS9RzyM/bPQmRHX/J0d3/yhJe/8qS37/Kk+D/yFZ + lf8eXJz/H12c/x9env8gX6D/H2Ch/yBho/8sY6H/LFGI/zVTdv9oiYf/aYqH/2mKh/9oiYb+ZoaD+2B+ + e/VUb23rSF9d4DlLSdMnMzLGERYWtQQFBasAAAClAAAAoAAAAJoAAACSAAAAigAAAH4AAABzAAAAZwAA + AFsAAABQAAAARgAAAD0AAAA1AAAALgAAACoAAAAmAAAAIwAAACEAAAAfAAAAHQAAABsAAAAZAAAAFwAA + ABUAAAATAAAAEQAAAA8AAAANAAAACwAAAAkAAAAIAAAABgAAAAUAAAADAAAAAgAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYyMTAneHVz2sC/vf/+////+ff3//i/ + rf/5nXz/+q6H//u5kf/6q4X//qKB//PAr/+cmpj/hIOC/5COjP+PjYv/kI2L/5CNi/+QjYv/kI2L/5CN + i/+QjYv/kI2L/5CNi/+IhYP/ZGJg3AAAAJQvLi2ra2lo3YJ+fPqHg3/9h4J9+25tbuw/UF3dLEls8yZE + dP4mRXb/KEh6/ylLfv8rToH/K1CE/y5Rhv8nWpX/ImGh/yNhov8jY6P/I2Sl/yRlpv8kZqj/JGap/yRo + q/8xaan/KEl//0lofP9uj4n/aYqH/2iJhv9miIX/ZoiF/2eIhf9oiYb/aIqG/2mKh/9lhYL8W3d080dd + W+Q1RkTWGB8fwwAAALMAAACuAAAAqAAAAKAAAACYAAAAjgAAAIIAAAB2AAAAagAAAF4AAABTAAAASgAA + AEIAAAA8AAAANwAAADMAAAAxAAAALgAAACsAAAApAAAAJgAAACMAAAAgAAAAHQAAABsAAAAYAAAAFQAA + ABMAAAAQAAAADgAAAAsAAAAJAAAABwAAAAYAAAAEAAAAAwAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAADXBtap+npaP/+vz9//jy8P/4qI7/+qmB//7mvf///NP////W///70v/95Lr//6yF/+eZ + gP+MhIH/jIyL/5SRj/+TkI7/k5CP/5OQj/+TkI//k5CP/5OQj/+TkI7/k5CP/5KPjv+GhIL/ZmRi34B9 + fPuJhoP/jImG/3V4gf9PX3r/L0p1/yNCdf8lRXj/KUp8/ypNgP8sT4P/LFKG/y5Viv8vVoz/LlqS/yZk + o/8mZqf/J2eo/ydoqv8naav/J2qt/yhrrv8obK//J22x/ytxtf8yZaL/ME14/4Wfov+NqKX/h6Kg/4Ge + m/98mpf/dpSR/26OjP9qi4j/aImG/2aHhP9niIX/aImG/2iKh/9nh4T9U21q7zpNS98eKCfNBQYGvAAA + ALYAAACxAAAAqgAAAKIAAACYAAAAjQAAAIEAAAB0AAAAagAAAGAAAABXAAAATwAAAEkAAABFAAAAQgAA + AD8AAAA8AAAAOAAAADUAAAAxAAAALgAAACoAAAAmAAAAIwAAAB8AAAAcAAAAGQAAABUAAAASAAAADwAA + AAwAAAAKAAAABwAAAAUAAAAEAAAAAgAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARgXltEioeF+eXm5v/49/b/96eN//uw + iP//+M////3T///5z///+M////nP///91P//987//7SM/8iFb/+DhIT/lpOS/5aUkv+WlJL/lpSS/5aU + kv+WlJL/lpSS/5aUkv+WlJL/mJaU/46Lif+EgX//jouI/5GOi/9OX3v/JEJ0/yFCdv8mSHr/KUt//ytO + gv8sUYX/LVOJ/y9WjP8vWI//MVuS/zNclP8vY5//KWus/yprrf8rba//K26x/ytusv8rb7P/LHC1/yxy + tv8scrf/K3O5/zV3u/8pT4f/aIGT/6G4tP+bs7H/nLSy/5uzsf+Zsa//l7Cu/5Krqf+JpKL/gZ2b/3iW + lP9ujov/aYqH/2aIhf9niYX/aIqH/2iJhv9ceXf2RFpY5yUxMNUHCQnDAAAAvQAAALgAAACwAAAAqAAA + AJ0AAACSAAAAhgAAAHsAAABwAAAAaAAAAGAAAABaAAAAVwAAAFMAAABQAAAATAAAAEkAAABFAAAAQQAA + AD0AAAA4AAAANAAAAC8AAAArAAAAJgAAACIAAAAeAAAAGgAAABYAAAASAAAADwAAAAsAAAAIAAAABgAA + AAQAAAACAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACXd0cra6ubj/+P7///W5pv/7pn3///XL///4zv//9cv///bL///2y///9sv///XL///4 + zv//9Mj/96eD/5d/d/+Oj4//mpiX/5mXlf+Zl5X/mZeV/5mXlf+al5b/m5iX/5mXlf+TkY//h4SC/42L + if+bl5P/ZXCC/yBAdP8nSX3/Kk6B/yxQhP8tUof/LVWL/y9Yjv8wWpH/MlyU/zNel/80YJn/NWKc/zBr + q/8ucLP/LnG0/y5ytv8vc7f/L3S4/y91uf8wdrv/MHe8/zB3vv8veL7/NH3E/zJmpf9DXoH/m7Kw/5uy + sP+bsrH/m7Kx/5uzsf+cs7L/nLSy/561s/+etbT/nLOy/5iwr/+Qqqj/g5+c/3KRjv9qi4j/ZoiF/2eI + hf9oiYb/aYqH/198evhCV1XnICop1AIDA8UAAAC/AAAAugAAALMAAACpAAAAnwAAAJMAAACIAAAAfQAA + AHQAAABtAAAAaAAAAGQAAABhAAAAXgAAAFsAAABXAAAAVAAAAFAAAABLAAAARwAAAEIAAAA8AAAANwAA + ADIAAAAtAAAAJwAAACIAAAAdAAAAGAAAABQAAAAPAAAACwAAAAgAAAAFAAAAAwAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjYV82i4iH+Obp6f/13tb/+Zl1//7k + uf//98z///PI///zyP//88j///PI///zyP//88j///PI///4zP//4rb/yox1/4WFhf+cm5n/nZqZ/52a + mP+cmpj/nZuZ/5uZl/+Rj43/iIWD/4OAfv+IhYP/nJmX/5KSk/8zTXb/Jkp//y1Sh/8uVYr/LlaN/zBZ + kP8xW5P/Ml2W/zNgmf80Ypz/NmWf/zdlof83aKT/M3Gz/zJ1uf8ydrr/Mne8/zN4vv8zeb//M3rA/zN7 + wf8zfMP/NHzE/zR9xf80gMj/O3vA/y9Off+Ppqn/nrWy/5yzsv+cs7H/nLSy/5y0sv+ctLL/nbSy/520 + sv+dtLL/nbSz/561tP+ftrT/m7Kx/5Osqv+FoZ//d5WT/2uMif9niIX/Z4iF/2iKhv9piYb/WHNx9DZH + RuIRFxbPAAAAxQAAAMAAAAC6AAAAsgAAAKcAAACbAAAAkAAAAIYAAAB9AAAAdgAAAHIAAABvAAAAawAA + AGkAAABmAAAAYwAAAGAAAABcAAAAWAAAAFMAAABOAAAASQAAAEMAAAA9AAAANwAAADAAAAAqAAAAJAAA + AB4AAAAYAAAAEwAAAA4AAAAKAAAABgAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABHRxbo+vrq3/8/b2//Wqkv/9vJL///fK///wxP//8MT///DE///wxP//8MT///DE///w + xP//8MT///HF///2yf/0uZT/kX54/5eXl/+hn53/oJ2c/6Genf+dmpj/iYaE/4SBf/+HhYP/hIKA/5OR + j/+opKD/c3uL/yJEd/8uVYv/MFiP/zBbkv8yXZX/M1+Y/zRhm/81Y57/Nmah/zdoo/84a6b/OWyp/zpv + rf82eLv/NXrA/zZ7wf82fMP/Nn3E/zd+xf83f8b/N4DH/zeAyf83gcr/OILL/zaDzP8+hs3/L1WK/3yT + nv+hubX/nbSz/520s/+dtbP/nbWz/561s/+dtbP/nbWz/521s/+etbP/nbSz/521s/+etLP/n7W0/5+2 + tf+dtLP/lq6s/4iiof93lZP/aouI/2aIhf9niYb/aYqH/2SDgPxIX13sICop2AABAcgAAADEAAAAvQAA + ALYAAACrAAAAoQAAAJUAAACMAAAAgwAAAHwAAAB4AAAAdQAAAHQAAABxAAAAbwAAAGwAAABpAAAAZgAA + AGIAAABeAAAAWQAAAFQAAABOAAAARwAAAEAAAAA5AAAAMQAAACoAAAAiAAAAGwAAABUAAAAPAAAACgAA + AAYAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsKyoMf3x719HT1P/z3db/+Zt2///k + uP//8MP//+7B///uwf//7sH//+7B///uwf//7sH//+7B///uwf//7sH///HE///itf+zi3r/jI6O/6Wi + of+koaD/oqCf/4mHhf+IhIL/kI2L/5GOjP+GhIL/oJ6c/6yopP9XZ4L/JEqA/zJelf8zXpf/M2Ca/zVj + nf81ZaD/N2ii/zhppf85a6j/Om6r/ztwrv88crD/PXS0/zp8wf85f8X/OoDH/zqCyf86g8r/OoPL/zqE + zP86hc7/OobO/zuH0P87h9H/OojS/0GM1/8vXJf/bYSV/6W7uP+etbT/n7a0/5+2tP+ftrT/n7a0/5+2 + tP+ftrT/n7a0/5+2tP+ftrT/n7a0/561tP+etbT/nrW0/561s/+ftrT/oLa1/520s/+UrKv/g5+d/3GQ + jv9niYb/ZoiF/2iJhv9piYb/VG5r8yo3Nt0EBQXLAAAAxQAAAL8AAAC3AAAArQAAAKIAAACYAAAAjQAA + AIYAAACBAAAAfQAAAHwAAAB5AAAAeAAAAHYAAABzAAAAcQAAAG4AAABqAAAAZgAAAGEAAABcAAAAVgAA + AE8AAABIAAAAPwAAADcAAAAuAAAAJQAAABwAAAAUAAAADQAAAAgAAAAEAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAG9sakCUkY/85urr//O2o//8s4n///DC///rvv//673//+u9///rvf//673//+u9///r + vf//673//+u9///rvf//677///DB/9msjv+Jg4L/paOj/6mmpf+cmZj/iIWD/5WSkP+YlZP/lJGP/4uI + hv+rqKf/q6mo/0Zbfv8qVIz/NWOd/zZln/83ZaL/OGik/zhrp/86bar/O3Cs/zxxsP89c7P/PnW1/z93 + uP8/ebr/PoHG/z2EzP89hc7/PofP/z6H0P8+iNH/PojT/z6K1P8+itT/PovW/z+M1v8+jdf/RZPg/zBi + of9jeo//qL25/5+2tf+ftrX/oLe1/6C3tf+gt7X/oLe1/6C3tv+gt7X/oLe1/6C3tf+gt7X/oLa1/5+2 + tf+ftrX/n7a0/5+2tP+etbP/nrWz/5+2tP+ftrX/m7Kx/42npf95l5X/a4uI/2aIhf9oiYb/aYqH/1h0 + cfUtPDrfBAUFywAAAMUAAAC/AAAAtwAAAKwAAAChAAAAlgAAAI4AAACIAAAAhQAAAIEAAAB/AAAAfQAA + AHwAAAB6AAAAeAAAAHYAAABzAAAAcAAAAGwAAABoAAAAYgAAAFwAAABVAAAATQAAAEMAAAA5AAAALgAA + ACMAAAAYAAAADwAAAAkAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAABdXJwgq2srP/t6Of/9p+A//7T + pv//7L7//+i6///ou///6Lv//+i7///ou///6Lv//+i7///ou///6Lv//+i7///ouv//7b7/9s6l/5CC + ff+hoaH/raup/5eUk/+UkpD/nZuZ/6Cenf+WlJL/kI6M/7Oxr/+trKz/O1N7/y9dl/84aaX/OGum/zls + qf86bqz/O3Gv/zxzsv89dbT/Pne3/z95uv9Ae7z/QX2//0J+wf9Chcr/QYrT/0GK1P9BjNX/QYzW/0GN + 1v9Cjtj/Qo/Z/0KP2v9CkNv/QpDc/0GR3P9Imeb/MWWl/2B3jv+pv7r/obe2/6G3tv+huLb/obi2/6G4 + tv+huLb/obi2/6G4tv+huLb/obi2/6G4tv+gt7b/obe2/6C2tv+gt7X/oLa1/5+2tf+ftrT/n7a0/561 + tP+etbT/n7a1/521s/+TrKr/gJya/22Niv9miIT/aImG/2mKh/9ZdHL1LTw63wQFBcoAAADFAAAAvwAA + ALYAAACsAAAAogAAAJkAAACSAAAAjAAAAIYAAACDAAAAgAAAAH8AAAB+AAAAfQAAAHwAAAB6AAAAdwAA + AHQAAABxAAAAbAAAAGcAAABgAAAAWAAAAE0AAABBAAAANAAAACYAAAAaAAAADwAAAAgAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAN8eXe0wsPE/+/Vzv/6n3r//+O0///muP//5rf//+a3///mt///5rf//+a3///m + t///5rf//+a3///mt///5rf//+a3///nuP//4bL/p46A/5iamv+urKv/ko+N/6CenP+lo6L/qaem/5eV + k/+Wk5H/urm2/7Kxsf85Unr/MmKe/zpvrP87cK7/PHOw/z10tP8+d7b/P3m5/0B7vP9Bfb7/Qn/B/0OB + w/9Dg8b/RITI/0WIzv9Ejtf/RY/a/0WQ2/9Fkdz/RZLd/0WS3f9Fk93/RZPf/0WU4P9FleH/RZXi/0ub + 6f8yY5//bYSV/6m/uv+iuLf/ori3/6K4t/+iuLf/ori3/6K4t/+iuLf/ori3/6K4t/+iuLf/ori3/6K4 + tv+iuLf/obi3/6G4tv+ht7b/obe2/6C3tf+gtrX/n7a1/562tP+etbP/nrWz/561tP+ftrT/lq+t/4Of + nf9vj4z/ZoiF/2iJhv9piof/V3Jw9SYyMdsAAADJAAAAxAAAAL4AAAC3AAAAsAAAAKgAAACfAAAAlQAA + AI0AAACGAAAAgQAAAIAAAAB/AAAAfwAAAH4AAAB9AAAAfAAAAHoAAAB3AAAAdAAAAG8AAABoAAAAYAAA + AFQAAABGAAAANgAAACUAAAAXAAAADAAAAAUAAAABAAAAAAAAAAAAAAAAV1VUD4WCgOXT2dv/8Lys//2v + hP//57f//+O0///jtP//47T//+O0///jtP//47T//+O0///jtP//47T//+O0///jtP//47T//+O0///n + tf+/pIz/kZCR/62rqv+Rjoz/qqin/62rqv+xr67/nJmY/5iVlP/Av73/ubi4/z9Xfv8zZaL/PnS0/z51 + tf8/eLj/P3q7/0F8vf9CfsD/QoDD/0SCxf9EhMj/RYbK/0aHzf9Hic//SIvS/0iS3P9IlN//SJXg/0iV + 4f9JluL/SZbj/0mY5P9JmOX/SZnl/0mZ5v9Jmuj/TZ3q/zBblP95kJ3/qL66/6O4uP+jubj/o7m3/6O5 + uP+jubj/o7m4/6O5uP+jubj/o7m4/6O5uP+jubj/o7m4/6O4uP+jubf/ori3/6K4tv+iuLf/obi2/6G3 + tv+gtrb/n7a1/5+2tf+ftrT/nrW0/520s/+etbP/nrW0/5iwr/+EoJ7/bo6L/2aIhf9oiYb/aYqH/1Jq + ZvAUHibYAgQHzAAAAMUAAADBAAAAvAAAALQAAACqAAAAnQAAAJEAAACIAAAAggAAAIAAAAB/AAAAfwAA + AH8AAAB/AAAAfgAAAH0AAAB7AAAAeQAAAHQAAABuAAAAYwAAAFUAAABDAAAAMAAAAB4AAAAQAAAABwAA + AAIAAAAAAAAAAAAAAAByb2wwj42L+93f3//yq5P//r6R///ltP//4LH//+Cx///gsf//4LH//+Cx///g + sf//4LH//+Cx///gsf//4LH//+Cx///gsf//4LD//+a0/9W2lv+Qi4v/qaem/5WSkP+zsbD/tbOy/7m3 + tv+lo6H/lZOR/8XDwv/Fw8H/T2SF/zBin/9Be73/QHu8/0F9v/9Cf8L/Q4HE/0SDx/9Fhcn/RofM/0aJ + zv9Ii9H/SYzT/0mO1f9Kj9f/S5Te/0yZ5P9MmuX/TJrm/0yb5/9Mm+j/TJzp/0yc6f9Mner/TJ3r/02f + 7v9Nmeb/L1CB/5Sqrv+mvLr/pLq4/6O6uP+kurn/pLq4/6S6uP+kurj/pLq4/6S6uP+kurj/pLq4/6S6 + uf+jurj/pLq4/6O5uP+jubj/o7i4/6O5t/+iuLf/ori2/6G4tv+ht7b/oLa2/6C2tf+ftrT/nrWz/560 + s/+dtLP/nbSz/561tP+Wrq3/gZ2b/2yMiv9miIT/a42H/1p6gv8jP2n5GCxM6wsVI9gAAADIAAAAxAAA + ALwAAACxAAAAogAAAJMAAACHAAAAggAAAIAAAACAAAAAgAAAAH8AAAB/AAAAfwAAAH8AAAB9AAAAewAA + AHYAAABsAAAAXgAAAEwAAAA3AAAAIwAAABMAAAAIAAAAAgAAAAAAAAAAAAAAAHd0clOfnpz/4dzb//ag + gf/+zJ3//+Cv///erf//3q3//96t///erf//3q3//96t///erf//3q3//96t///erf//3q3//96t///e + rf//4a//6sef/5CLiP+opqb/mJWU/7u5uP+9u7r/wb++/7Gvrv+Sj47/yMfG/9PQzP9od5D/KlqW/0SC + xf9DgcP/Q4PG/0SEyP9Fh8v/R4jN/0iK0P9IjNL/SY3U/0qP2P9Lkdr/TJPc/0yU3f9Old//T5vo/0+e + 6/9Pnuv/T5/s/0+f7P9PoO7/T6Du/0+g7/9Poe//U6j5/z9/xv9FX4L/p727/6vAvv+pvr3/qL28/6a8 + uv+mu7r/pbu6/6W6uv+lurr/pbq6/6W7uv+lu7r/pLu5/6W6uf+kurn/pLq4/6S6uf+kurj/o7m4/6O5 + uP+jubj/ori3/6K4t/+huLb/oLe1/6C2tf+ftrX/nra0/561s/+dtLL/nLSy/520sv+dtLP/k6yr/3uZ + lv9piof/a4yG/09vf/8jQ3T/I0R1/xs0WvEIEh7WAAAAyAAAAMEAAACzAAAAoQAAAJAAAACFAAAAgAAA + AIAAAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH0AAAB7AAAAdgAAAG0AAABfAAAATQAAADgAAAAjAAAAFAAA + AAkAAAACAAAAAAAAAAAAAAAAeHVzc6moqP/k2NT/+Jx5///Wpf//3Kr//9up///bqf//26n//9up///b + qf//26n//9up///bqf//26n//9up///bqf//26n//9up///dq//30qT/kouE/6elpf+amJf/w8HA/8XD + w//Ix8b/wsC//4yKiP/IxsX/3NnW/4+Xp/8nT4j/RIXJ/0WGyv9Gh83/R4nO/0iL0f9IjdT/So7W/0qR + 2P9Lktr/TJTd/02V3/9Ol+H/T5jj/0+Z5P9Rnen/U6Lw/1Ki8P9To/H/UqPy/1Kk8/9SpPP/UqTz/1Om + 9v9VqPf/LFeQ/0Nkcv9rjon/dZaT/4Shnv+SrKr/obi2/6a8u/+rwL//qr++/6i9vP+nvLv/pbu6/6W7 + uv+mu7r/pbu6/6W7uv+lu7r/pLu5/6W6uf+kurj/o7q4/6O5uP+jubj/o7m3/6K4t/+huLf/obi2/6C2 + tv+ftrX/nra0/561tP+dtLP/nLOy/5yzsf+cs7L/nLKy/42npf9yko7/aYuF/zxhfv8aRXr/HUl7/xxI + ef0OJj/jAAAAyQAAAMAAAACwAAAAmwAAAIsAAACCAAAAgAAAAH8AAAB+AAAAfQAAAHwAAAB7AAAAeAAA + AHUAAABvAAAAZgAAAFgAAABHAAAAMwAAACAAAAASAAAACAAAAAIAAAAAAAAAAAAAAAB7d3WNsLKy/+jO + x//6oXr//9aj///Zpv//2Kb//9mm///Zpv//2ab//9mm///Zpv//2ab//9mm///Zpv//2ab//9mm///Z + pv//2ab//9qn//zWpP+dkIb/qKen/52amP/KyMf/zczL/9DPzv/Pzs3/lZKR/7y7uv/f3dz/w8TI/zFO + fP8/fcH/SYzT/0mM0/9JjtX/SpDX/0uR2/9Mk93/TZXf/02W4P9PmOP/T5nl/1Cb5/9QnOn/UZ7q/1Kg + 7P9Uo/H/VaX0/1Wm9f9Vp/b/Vqf3/1Wn9/9VqPn/WrD//z56vv8uS3D/TXVy/0Zwa/9DbWn/RG5q/0Vv + a/9Pd3P/YoWC/3aWk/+Mp6X/n7a1/6i+vf+twcD/qr69/6e9u/+mu7r/pry6/6W7uv+mu7r/pbu6/6W7 + uv+lurn/pLq4/6O6uP+jubj/o7m4/6O5t/+huLb/obi2/6G3tv+ftrX/n7a0/561s/+dtLP/nLSy/5yz + sf+bsrH/nLOy/5Stq/94lpL/X4OE/x9SgP8WTID/Fk+C/xVPgv8JJz/hAAAAxgAAALoAAACoAAAAlQAA + AIcAAAB/AAAAewAAAHkAAAB3AAAAdAAAAHEAAABuAAAAaQAAAGIAAABYAAAASgAAADsAAAAqAAAAGgAA + AA4AAAAGAAAAAgAAAAAAAAAAAAAAAH57eZ62ubn/58W6//ungP//26v//9qr///Xpv//1qL//9aj///W + o///1qP//9aj///Wo///1qP//9aj///Wo///1qP//9aj///Wo///16P//9Wi/6WXiP+pqKn/oaCe/87N + zP/V1NP/19bV/93c3P+ppqX/pqSj/+Li4f/l4+D/ZXWS/yxfnv9MlN3/SpDZ/0yT3P9MlN3/Tpbg/06X + 4v9PmeT/T5rm/1Gc6P9Rner/Up/r/1Kg7v9Toe//U6Px/1Sk8/9VpvX/Vqj4/1eq+v9Xq/z/Wa///1qv + //9BgMb/Kkh2/2SCiv95mJP/dpSS/3CQjv9pi4j/YISB/1Z7eP9Jcm7/Qm1o/0Ruaf9MdHD/ZIeD/32b + mf+Wrq3/qL28/6zAv/+pvrz/p7y7/6a8uv+mvLr/pbu6/6W7uv+lu7r/pbq5/6S6uP+kurj/o7m4/6O4 + uP+iuLf/obi2/6G3tv+gt7X/n7a1/561s/+dtLP/nLSy/5yzsf+asrD/mrKw/5iwr/+Iop3/RXKI/wxP + hf8QU4f/D1SI/w1RgvwBBwvLAAAAwQAAALMAAACiAAAAjwAAAH8AAAB1AAAAbwAAAGsAAABnAAAAYwAA + AF4AAABYAAAAUAAAAEUAAAA5AAAAKwAAAB4AAAASAAAACgAAAAQAAAABAAAAAAAAAAAAAAAAgH17sLq9 + v//ovK7//KuF///etf//27P//9qx///Wqf//06D//9Og///ToP//06D//9Og///ToP//06D//9Og///T + oP//06D//9Og///UoP//1KH/rJqH/6qqrP+op6X/ysjH/9/f3f/f3tz/5OPj/8vKyP+Qjoz/3t3c/+7s + 6f+8wcn/KUp7/0SHzv9PmeT/TZbh/0+Y5P9QmuX/UJvn/1Gd6f9Rnuv/UqDt/1Kh7/9TovD/VKTy/1Sl + 9P9WqPf/WKz8/1mv//9Yq/z/Vaf3/1Gf7P9FidL/MWKh/y9Mdv9igIn/fpyX/3yZl/99m5n/f52a/4Ke + nP+Dn53/gZ2b/36bmf91lJH/Z4mG/1h9ev9IcG3/QWxn/0Vva/9fg4D/iKSh/6G4tf+rwL7/rMC//6i9 + vP+nvLv/pru6/6W7uv+lu7r/pbu6/6S6uf+kurn/o7m4/6O5uP+iuLb/ori3/6C3tv+gt7X/n7a0/561 + s/+dtLP/nLOx/5uysf+asbD/mbGv/5yzsP+HpKb/GF+O/wdVjP8KWI7/A1eP/yBATuIAAADCAAAAugAA + AK0AAACaAAAAhQAAAHIAAABkAAAAWwAAAFUAAABQAAAASgAAAEIAAAA6AAAAMAAAACYAAAAcAAAAEwAA + AAsAAAAGAAAAAgAAAAEAAAAAAAAAAAAAAACCf328vcHC/+a5q//8q4T//tuy//7ZsP/+2bD//tmx//7U + p//+0J7//tCf//7Qn//+0J///tCf//7Qn//+0J///tCf//7Qn//+0J///9Cf///ToP+ynoj/qKmr/7Cu + rf+vraz/6urp/+fm5f/p6Oj/6+rq/5iWlP+9vLv/8fHw//Ty8P98iqL/I0+K/06Z5P9Rnur/UJzo/1Ge + 6v9Sn+z/U6Hu/1Sj8f9UpPP/Vqj3/1er/P9YrPz/Vqf3/1Gf7f9FidL/PHa6/zRkov8vV4z/Lk98/zlW + ef9Pan3/cpCR/3+dmP99m5j/fpyZ/4Ccm/+Bnpz/gp6c/4Ofnf+EoJ7/haCf/4aioP+Io6H/hqKg/3+d + m/9xkY7/X4OA/0pzb/9BbGf/TnZy/2yNiv+Mp6X/pbu5/63Av/+qv77/p7y7/6a7uv+mu7r/pbu6/6W6 + uf+jurj/pLq4/6O5uP+iuLf/obi3/6C3tv+gtrX/n7a0/560tP+dtLL/nLOy/5qysf+asa//mLCu/5+0 + sP9HgZ7/AFeR/wNdlP8AW5X/LHGP/0hcWOQEBQW8AAAAsgAAAKQAAACOAAAAdQAAAF4AAABMAAAAQQAA + ADkAAAAzAAAALAAAACUAAAAeAAAAFwAAABAAAAAKAAAABgAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAIJ/ + fbq7v8D/6bKg//2uhv/+2rL//tau//7Wrv/+1q7//tau//7Qov/+zZv//s2c//7NnP/+zZz//s2c//7N + nP/+zZz//s2c//7NnP//zZz//8+d/7GciP+pqqz/xcLC/4yJh//a2tr/8/Pz//Dw8P/49/f/z83M/5GO + jP/r6+r/+ff2/+3t7v9bbpD/JleT/0+c6P9Vpvb/VKXz/1ao+f9Wqfn/VKX0/1Kg7/9Kkdv/QX/F/zhs + rv8xXZb/LlGA/zVTd/9BXnb/T2t8/2B+hf9vjo7/eJWT/3+dmP9+m5j/fpyZ/3+cmv+Bnpv/gp+d/4Sg + nv+FoZ//haGg/4aioP+HoqH/h6Oh/4ejof+Ho6H/iKOh/4qlo/+KpKP/gJ2b/2qLif9VfHj/Q25p/0Nt + aP9Ve3f/d5aU/5mxr/+qv77/q7++/6e9u/+lu7r/pbu6/6S7uf+kurj/pLq4/6O4uP+iuLf/obi2/6G3 + tv+ftrX/nra0/561s/+dtLL/nLOx/5qysP+Zsa//nbOv/3qgqP8CYJb/AF+W/wBel/8PZZT/ZomI/1Ns + aeoNERC3AAAAqAAAAJgAAACAAAAAYgAAAEcAAAAzAAAAJwAAAB8AAAAaAAAAFQAAABAAAAALAAAABwAA + AAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAgn99urm9v//or53//q+H//7asv/+1a7//tWu//7V + rv/+1a7//tSu//7Nn//+yZj//sqZ//7Kmf/+ypn//sqZ//7Kmf/+ypn//sqZ///Kmf//zJr/sZuG/6qq + rP/V09T/o6Gg/5mWlP/w8PH//f39//v8/P/9/f3/pKKh/7CtrP/8/f3////+/+7w8/9leJj/JE2G/zl6 + wP9Ei9b/OHi+/zJoqf8yXpf/LlCB/y5Ndv82VXL/QF5x/01teP9fgIH/bIyJ/3OUjv93l5H/eJeT/3qY + lf97mZf/fZuZ/3+bmv+Bnpz/gp+d/4Sgnv+FoaD/hqKg/4ejof+IpKL/iaSi/4mlo/+KpaP/iqWj/4ql + o/+KpaP/iaSi/4qlo/+KpKP/i6Wk/4ejof97mJf/ZYiF/052cv9Aa2f/SHFt/2iKh/+Qqaj/qL28/6vA + v/+nvLv/pbu6/6S6uf+kurj/pLq4/6O4uP+iuLf/obi2/6C2tv+ftrX/n7a0/561s/+ctLL/m7Ox/5qx + sP+asa//l6+u/yFwmv8AW5T/AV6V/wNelP9TgYn/bYyG/1t4de4TGRmyAAAAngAAAI0AAAByAAAAUQAA + ADMAAAAdAAAAEgAAAA0AAAAJAAAABgAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACCf327t7u7/+O0pP/9q4X//ti0//7Vsf/+1bH//tWx//7Vsf/+1bL//tSw//7Ln//+xpb//saW//7H + mP/+x5j//seY//7HmP/+x5j//8eY///Jmf+xmoX/q6yt/9fV1f/Rz8//mZaV/52bmf/r6ur/+/v7//j3 + 9//j4eH/kI6M/8rIx/////////////n4+P+mrr//XnKT/0tljP9rfZv/gYmd/2hseP9Xc3T/VXx5/16D + fv9mioP/aYyG/2yOiv9wkI7/c5OQ/3aVkv94l5X/e5qX/36bmf+AnJn/gp6c/4Sgnv+FoZ//hqKh/4ij + of+JpKH/iqWj/4ulpP+LpqT/jKal/4ynpf+Np6X/jael/42npf+Mp6X/jKal/4umo/+KpaT/iqWi/4ul + o/+LpaP/g6Ce/3GRj/9Yfnr/Q25p/0Nuav9fg3//iKOh/6e8u/+rv77/pry7/6S6uf+kurj/pLq4/6O5 + uP+iuLf/obi2/6C2tv+ftrX/nrW0/520s/+cs7L/mrKw/5mxsP+gtbD/UIih/wBYkv8DXZP/AFqU/zx2 + jv9ujIX/aYqH/2B+e/McJSSwAAAAlgAAAIQAAABnAAAARAAAACUAAAAQAAAABgAAAAMAAAACAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIF+fLWxtbX/4LOk//yqhv/+17b//tW0//7V + tP/+1bT//tW0//7VtP/+1bT//tW0//7OqP/9xpn//cOT//3Dk//9xJT//cSV//3Elf/+xZX//sWV/6yW + hP+ys7T/2NfX/9bV1P/U09L/oqCe/4yJiP+sqqj/wb+9/7+9vP+YlpT/fnt5/7u5uP/s6+r/7u7t//Pw + 7f/p5uX/4eDg/93a2P+ro57/cH55/1d+eP9cgX3/YYWB/2WIhP9pi4j/bo+M/3KSkP91lJL/eJaV/3ua + l/9+nJr/gJyb/4KenP+EoJ7/haGg/4ejof+JpKL/iqWj/4ulpP+Mp6X/jaem/46opv+Op6b/j6in/4+o + p/+PqKf/j6in/4+op/+Op6b/jqim/42npf+MpqT/iqWk/4qlo/+JpKL/iqSj/4eioP94l5T/XoJ//0Zv + a/9Ca2f/W4B9/4mkov+nvbz/qb69/6W7uf+kurj/o7m4/6O4uP+huLb/obe2/6C2tf+ftbT/nrWz/5y0 + sv+bsrH/mrGw/52zsP99oan/Bl2T/wNbkv8AWJH/L3KY/3uYlP9piYb/aYqH/2GAffMdJiWsAAAAkAAA + AH4AAABgAAAAPAAAABwAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAfnx6oaqsrf/btKf/+6iE//7XuP/+1rf//ta2//7Wtv/+1rb//ta2//7Wtv/+1rf//te4//7U + tP/9zaf//cac//3Clf/9wJL//b+Q//7Bkf/9wJH/pZKE/7u8vf/b2tn/19bV/9nY1//b2tn/w8HA/6Si + oP+al5b/m5mX/6mmpf+1s7L/jouK/5mVk/+/urr/zMnI/8vIx/+6tbP/kY2L/2x5d/9Ve3f/WX97/1+D + gP9jh4P/Z4qH/2uNiv9wkY7/dZWS/3iWlP97mZf/fpuZ/4Cdm/+Dn53/haCe/4eioP+Io6H/iaSj/4um + pP+Np6X/jqem/46opv+Pqaf/kKmo/5CpqP+Rqqj/kaqo/5GqqP+Rqqj/kaqo/5CpqP+Qqaj/j6in/46o + pv+Np6X/jKal/4ulo/+Io6L/iKOh/4ijof+GoqD/epiW/2CEgf9GcGz/Qmxo/2GEgf+Qqqn/qb69/6e8 + u/+kurj/o7m4/6K5t/+huLb/obe1/6C2tf+etbT/nbSz/5yzsf+bsrH/m7Kw/5Wvrv8gapX/AliQ/wNZ + kP8UY5P/iaan/3yZlv9niIX/aYqH/2GAffMdJiapAAAAjgAAAHkAAABZAAAANQAAABcAAAAHAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+e3mRpaal/9S3rv/5ooD//tW5//7X + u//+1rr//ta6//7Wuv/+1rr//ta6//7Wuv/+1rr//te6//7XvP/+1rr//tS2//7Qrv/+yaT//8KW//q6 + jf+ejYL/xMXG/97d3P/b2tn/2tnZ/9va2f/e3d3/397d/9rZ2f/b2tn/4N/e/+Lh4f+ioJ//ZHJv/215 + dv9+gn//fYF+/3B7eP9eeXb/Unp2/1d9ef9dgn7/YoWC/2aJhv9qjIn/bo+N/3OTkP94lpT/e5mW/32b + mf9/nZv/gp6d/4Wgn/+HoqD/iaOi/4qlo/+MpqT/jael/46opv+Pqaf/kKmo/5GqqP+Rqqn/kqup/5Kr + qv+Sq6r/kquq/5Krqv+Sq6r/kqup/5Gqqf+Qqqj/kKmo/4+opv+OqKb/jKal/4ulpP+KpKL/h6Kh/4ah + oP+FoZ//hKCe/3eWk/9cgH3/RG5q/0Zwa/9tj4v/nbSz/6m+vf+kurn/o7m4/6K4t/+huLb/oLe2/5+2 + tP+etbP/nLOy/5uzsf+asrD/n7Ww/0R+nP8AVI3/B1mP/whZjv9wlqL/lq2p/3mXlf9niYX/aYqH/2GA + ffIUGhmjAAAAjAAAAHYAAABTAAAALwAAABMAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAH57eXecnZz/ybm0//ebef/+1Lr//tm///7Yvv/+2L7//ti+//7Yvv/+2L7//ti+//7Y + vv/+2L7//ti+//7Yvv/+2L///tnA//7ZwP//2Lz/9sKg/5OJgv/R0dL/4N/f/97d3f/e3d3/3t3d/97d + 3P/e3d3/397d/9/e3f/f3t7/3t3c/5iVlP9QcW3/THZy/1R6df9TeXX/UXl1/1F6dv9Ue3f/WoB8/2CE + gP9liIX/a4yJ/2+Qjf9yko//dpWT/3uZl/9+m5n/gp+d/4aioP+Io6H/iqSj/4ulo/+MpqT/jKel/46o + pv+PqKf/j6mo/5Gqqf+Sq6n/kquq/5Osqv+TrKv/lKyr/5Ssq/+UrKv/lKyr/5Ssq/+TrKv/k6yq/5Kr + qv+Rqqn/kKqo/4+pp/+NqKb/jael/4ulpP+KpKL/iKOg/4ahn/+En57/gp+d/4Cdm/9wkY7/VHp2/0Fr + Z/9Qd3P/hKGe/6e9vP+mvLr/ori3/6K4t/+ht7b/n7a1/561tP+ds7L/m7Oy/5qysf+htrH/ZJCj/wVW + jf8JWI7/AlOM/1OFnP+asKr/j6mn/3mXlP9oiYb/aYqH/1t4dusMDw+cAAAAiQAAAHAAAABMAAAAKAAA + AA4AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgH58VpSTkv+/uLX/8pl5//7N + s//928P//dnB//3Zwf/92cH//dnB//3Zwf/92cH//dnB//3Zwf/92cH//dnB//3Zwf/92cH//dnB///d + xf/pxrH/k4+M/9zc3P/i4uH/4eDg/+Hg4P/h4OD/4eDg/+Hg4P/h4OD/4eDg/+Li4f/e3Nz/i4qI/1Bz + b/9Renb/Unp2/1J6dv9Tenb/VHt3/1d9ev9cgX3/XoJ//12Bfv9bgH3/WoB8/1l+e/9Zfnv/W398/1uA + ff9hhYL/ZYiF/2yNiv90k5D/fJqY/4ahn/+LpqT/kKqo/5WtrP+Vrqz/lKyr/5Ssq/+Urav/lKys/5Wt + rP+Vraz/la6s/5WurP+Vrqz/la2s/5WtrP+Uraz/k6yr/5Osqv+Sq6r/kaqp/4+pqP+OqKb/jael/4ul + pP+KpKL/h6Kh/4Whn/+Dn53/gJ2b/3+cmv96mZb/ZYiE/0lybv9CbGj/Z4qH/5yzsv+ovbz/ori3/6G4 + tv+gt7X/nra0/520s/+ctLL/m7Ox/52zsf+Eo6r/D1uO/wlXjP8EU4r/OXOW/5Ssqf+Qqaf/jqim/3aU + kv9niYb/aYqH/1Ntat8EBQWWAAAAhgAAAGkAAABDAAAAIAAAAAoAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACAfXw0jYqJ/La1s//nm4H//8Gl//7eyv/+2sX//trF//7axf/+2sX//trF//7a + xf/+2sX//trF//7axf/+2sX//trF//7axf/92sX//+DK/9W1pP+bl5X/4+Pi/+Xk5P/k5OP/5OTj/+Tk + 4//k5OP/5OTj/+Tk4//k5OP/5+bm/9fV1P9/gX//UXdz/1N6dv9Tenb/VHt3/1N6dv9ReHT/TnZy/0py + bv9Gb2v/RW9q/0Zva/9GcGz/SHFt/0lybv9JcW7/SHFu/0ZvbP9Fb2v/RW9r/0Vvav9GcGz/SnNv/1J4 + df9eg3//a4yK/3mYlf+KpaP/k6yq/5iwr/+asbD/mLCv/5evrv+Xr63/lq+t/5avrf+Wrq3/lq6t/5au + rf+Vraz/lK2r/5Osq/+Sq6r/kaqp/4+pqP+OqKb/jael/4ulo/+Jo6L/h6Kg/4Sgnv+Bnpz/fpya/3yZ + l/97mZf/cJCO/1Z8eP9Ba2f/Unl2/4ynpf+nvLv/o7m4/6C3tf+ftrX/nbWz/520s/+cs7L/nLOx/5av + r/8mZpH/CFSK/wlUiv8eYI7/jKeo/5Gqp/+OqKb/i6ak/3KSj/9niIX/aYqH/0RaWM4AAACSAAAAgAAA + AF8AAAA3AAAAFwAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIOAfhCFgoDsqq+v/9ie + iv//s5X//uHP//7dyv/+3Mr//tzK//7cyv/+3Mr//tzK//7cyv/+3Mr//tzK//7cyv/+3Mr//tzK//7d + yv//4c3/vqOV/6enp//s7Oz/6Ofn/+jn5v/o5+b/6Ofm/+jn5v/o5+b/6Ofm/+fn5v/t7Oz/ycXE/3J7 + ef9ReXX/U3p2/1N6dv9PdnL/SXFt/0Vvav9IcW3/Unh2/16Cgf9oiYn/b4+Q/3WUlf95l5j/fpqc/36b + nP9+m5z/eZeY/3eWlv9ykpL/bY6O/16CgP9SeXX/T3Zz/0lxbv9Dbmn/RG5q/0hxbf9Ve3j/ZoiF/3mY + lv+MpqT/l6+u/5yzsv+bsrH/mbCv/5ivrv+Xr63/l6+u/5aurf+Vrqz/la2s/5Osq/+Sq6r/kaqp/4+p + qP+OqKb/jKak/4qko/+Io6L/haKg/4Ofnf+AnZv/fZqY/3qYlv94lpT/dJOR/1+EgP9Gb2v/RnBr/3qZ + lv+mu7r/o7m4/6C2tf+etbP/nbSz/5yzsv+bs7H/nrSx/0F3l/8GUIf/DVSJ/xFXiv96nKP/lKyp/4+o + pv+OqKb/iKOh/26Oi/9oiYb/aYmG/y07OrcAAACOAAAAdwAAAFIAAAArAAAADwAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAhIF/AoJ/fsCfoqL/x6aa//uig//+3s7//t/P//7fzv/+387//t/O//7f + zv/+387//t/O//7fzv/+387//t/O//7fzv/+387//9/P///dy/+oj4X/vL6+//Hw8P/r6ur/6+rq/+vq + 6v/r6ur/6+rq/+vq6v/r6ur/6+rq//Hw8P+3s7L/Znd0/1B6dv9QeHT/SnNv/0Ruav9NdXL/YoWE/3WU + lf9/m53/g5+h/4Sgov+Dn6H/g5+h/4Kfof+Dn6H/g5+h/4Sgof+FoKL/haGj/4eipP+IpKb/dZOS/2mJ + hv91lJH/eZeV/2+PjP9lh4T/WoB8/052cv9Fb2r/RG5p/0hxbf9Zfnv/b4+N/4Sgnv+Wrq3/nLOy/5yz + sv+YsK//l6+u/5aurf+Wra3/la2r/5Osq/+Sq6r/kaqp/4+pp/+Op6b/jKWk/4mko/+Ho6H/hKGf/4Ke + nP9/nJr/e5mX/3iWlP90lJH/cZKP/2WIhP9MdHD/Qmxo/26PjP+ht7b/ori2/5+1tP+dtbP/nLSy/5uz + sf+iuLP/W4ie/whPhv8PU4j/DFGH/2WMnv+Yr6r/jqmn/42npf+Np6X/gp+c/2qLiP9oiYb/YoF/9BEW + FqAAAACIAAAAagAAAEIAAAAdAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgH17iJaV + lP+0qqb/8pZ1///Uwv/+5Nb//uHT//7h0//+4dP//uHT//7h0//+4dP//uHT//7h0//+4dP//uHT//7h + 0///5df/9869/5WGf//Z2tr/8fHx/+7u7v/u7u7/7u7u/+7u7v/u7u7/7u7u/+7u7v/v7u7/7+7u/6Cc + m/9eeHT/THZy/0ZwbP9IcW3/YoWE/3uZmv+Dn6H/gp6g/4Gdn/+BnZ//gZ2g/4Gen/+CnqD/gp6h/4Of + of+En6H/hKCh/4Sgov+FoaP/h6Gj/4Whov9tjYv/aYqH/32al/+AnZv/f5yZ/3+bmf99mpf/eJeU/3KR + jv9lh4X/WH56/0tzb/9DbWn/RW5q/1J5dv9rjIr/g6Ce/5evrv+cs7L/mbCv/5evrf+Wraz/lK2s/5Os + q/+Sq6n/kKqo/46op/+NpqX/i6Wk/4ijov+FoqD/g5+d/3+cm/98mpj/eZeV/3WVkv9xkY//bo+M/2aI + hf9Pd3P/QGtm/2+Rjf+lu7r/oLa1/521s/+dtLP/m7Ox/5+2sv91mKT/EVOG/xBShv8JTYT/TXyX/5mw + q/+Pqaf/jqim/4ympP+LpaT/e5iW/2iJhv9piof/T2hm2wAAAJIAAAB9AAAAWgAAADEAAAARAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAfnxKjImI/6anqP/blX3//7uh//7q3//+5Nj//uTY//7k + 2P/+5Nj//uTY//7k2P/+5Nj//uTY//7k2P/+5Nj//uTY///p3f/bsJ//lpCN/+7u7//z8vL/8fHx//Hx + 8f/x8fH/8fHx//Hx8f/x8fH/8fHx//T09P/k4+P/hoaE/1J2cv9Fb2v/TXVx/3KSkv+EoKL/gp6g/4Gd + n/+BnaD/gZ6f/4KeoP+Cn6D/g5+h/4Ofof+EoKL/hKCi/4Whov+FoaP/hqKj/4eipP+IpKX/hKCg/2mK + h/9rjIn/gp+c/4Ofnf+BnZv/gJya/36cmf9+mpj/fZqY/32amP96mJb/dpSR/2uMiP9dgX7/TXZy/0Nt + af9EbWn/V3x5/3yal/+Sq6r/mrKx/5mwr/+Vrqz/k6yr/5Orqv+Rqqn/j6mn/46opv+MpqT/iaSi/4ai + of+EoJ7/gZ2b/36bmf96mJb/dpWT/3KSkP9uj4z/aoyJ/2SIhP9Pd3P/R3Fs/4aioP+lu7n/nrW0/520 + s/+cs7L/nrSx/4unq/8ZV4f/EFGE/w1Ng/87bpD/k6yp/5GqqP+OqKb/jKak/4qlo/+Io6H/cpGO/2eI + hf9piof/Kzk4tgAAAIsAAABvAAAARgAAACAAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAISB + fw6EgoDnnJ6e/76dkf/7oH///uXZ//7p3//+6N3//ujd//7o3f/+6N3//ujd//7o3f/+6N3//ujd//7o + 3f//6d///+PV/7SLfP+vsLD/+vr6//X19f/19PT/9fT0//X09P/19PT/9fT0//X09P/19PT//Pv8/8rH + xv9ueHX/RW9r/011cv92lZb/hKCj/4Gen/+Bnp//gp6g/4KfoP+Dn6H/g5+h/4Ofof+EoKH/haGi/4Wh + ov+GoaP/hqKk/4ejpP+Io6X/iKSl/4umpv+BnZ3/aImG/3GQjf+Io6D/hqKf/4Wgn/+DoJ3/gp6c/4Gd + m/9/m5r/fpuY/3yal/98mZf/e5mX/3qYlf92lZL/a4yJ/12Cfv9LdHD/Qm1o/052cv9qjIn/iaSi/5iw + r/+YsK//lKyr/5Gqqf+Qqaj/j6in/4ynpf+KpaP/h6Oh/4Whn/+Cnpz/f5ya/3uZl/94lpT/dJOR/3CQ + jf9qjIn/Z4mF/2GFgf9NdnL/S3Nv/4mlov+jurj/nbSz/5yzsv+cs7H/l6+v/yphi/8QToP/EU6D/ylg + if+Pqaj/kaqo/46opv+Mp6X/iqWj/4mkov+Bnpz/aouI/2iJhv9denfsBggHlgAAAH8AAABbAAAAMQAA + ABEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIF+fJqSkI//pKGf/+aRc///yLT//vDp//7r + 4v/+6+L//uvi//7r4v/+6+L//uvi//7r4v/+6+L//uvi///x6f/3wa7/lH51/9nb3P/9/f3/+Pf3//j4 + +P/4+Pj/+Pj4//j4+P/4+Pj/+Pj4//n5+f/6+vr/pqKh/1hxbf9FcGz/cpKS/4Wgo/+CnqD/gp6g/4Of + of+Dn6H/hJ+h/4Sgof+EoKL/haGi/4aho/+GoqP/hqKj/4ijpP+Jo6X/iaSm/4qkpv+Kpqb/jqip/36b + m/9lh4T/dpWS/4ympP+KpaP/iKSh/4eioP+GoZ7/hKCe/4Ofnf+Bnpv/gJ2b/3+bmf99mpj/fJmX/3uY + lv97mJb/epiV/3OSkP9ihYH/TnZy/0JsaP9HcG3/YYSC/4Sgnv+Wrq3/la6s/5Gqqf+PqKf/jaem/4ul + pP+Io6L/haGf/4Ofnf9/nJr/fJqX/3iXlP90lJH/cJCO/2yNiv9niYb/YoaD/1p/e/9Fb2v/TXVx/4+q + qP+iuLb/nLSy/5yzsf+bs7H/P26Q/w9LgP8UToH/HVSE/4aipv+TrKj/j6im/42npf+LpaP/iaSi/4ij + of93lZP/Z4mG/2mKh/82RkW/AAAAiwAAAG4AAABDAAAAHQAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAg4B+PoiFg/6Zm5z/u5aJ//2ffv/+6N7//u7n//7s5P/+7OT//uzk//7s5P/+7OT//uzk//7s + 4//+7+f//+XZ/86Qe/+Yl5b/+vr7//38/P/7+/v/+/v7//v7+//7+/v/+/v7//v7+//7+/v//v7+/+bk + 5P9/gX//R25q/1+Dgv+GoaP/gp6g/4OfoP+En6H/hKCh/4Sgov+FoaL/haGj/4aio/+HoqT/h6Kk/4ij + pf+JpKX/iaSl/4qlp/+Lpaf/jKen/42nqP+Qqav/e5mX/2SGgv99mZf/kaqp/42npv+MpqT/iqWj/4mk + of+Io6H/hqKg/4Whnv+En57/gp6c/4Gemv9/nJr/fpuZ/32al/97mJb/e5iW/3qYlf92lJL/aYqI/1V7 + d/9Dbmn/RW9r/2GEgf+GoZ//la2s/5Grqf+NqKb/i6ak/4ikov+GoqD/g5+d/4Cdm/99mpj/eZeV/3WU + kv9xkY7/bI6L/2iKh/9ihoL/XYJ+/1F4df9DbWn/WH56/5mxr/+ftbT/m7Ox/6G3s/9TfJf/Dkh+/xZN + gP8ZT4H/d5ag/5Wuqv+Pqaf/jael/4ulo/+JpKL/h6Kg/4Ofnf9sjYr/aImG/117eO0GCAeVAAAAfAAA + AFYAAAAsAAAADgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEgX8Dg4B+xZKPjv+bmpr/2o5z//+3 + nf/+7+n//uzl//7r4//+6+P//uvj//7r4//+6+P//u3l///v5//6spn/l3pv/8rNzv///////f39//39 + /f/9/f3//f39//39/f/9/f3//f39//7+/v//////trGw/2Jzb/9Ic2//e5ma/4Who/+EoKH/hKCi/4Wh + ov+FoaP/hqKj/4aipP+IoqT/iKOk/4ijpf+JpKX/i6Wm/4qlpv+Lpqf/jaeo/42nqP+OqKn/j6iq/5Gr + q/95lpX/ZYeE/4OfnP+Urav/kKqo/4+pp/+OqKb/jael/4umpP+KpKP/iKOh/4eiof+Gop//hKCd/4Of + nf+Bnpv/gJ2a/3+bmv99mpj/e5mX/3qYlf97mJb/eJeU/2yNiv9WfHj/Q21p/0dxbf9niYb/iaSj/5Kr + qv+Mp6X/iaSi/4aioP+DoJ7/gJ2b/32amP95mJX/dZWS/3GRj/9tjov/aIqH/2OGg/9dgX7/Vnx4/012 + cv9CbGj/aYuI/6C3tf+ctLL/orez/2aJnP8TSX7/GEx//xZLfv9oipr/l6+r/46pp/+Np6X/i6ak/4ik + ov+HoqD/hqKg/3iWk/9niYb/aYqH/zFAP7kAAACHAAAAZwAAADsAAAAXAAAABAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACDgH5Oh4SC/5OUkv+jlI7/7I9w///Drf//7ub//u/p//7s5f/+6+T//uzl//7v + 6f//7eX//8Kq/8mDa/+UlJT/8vLy//f39//29vb/9vb2//b29v/29vb/9vb2//b29v/29vb//Pz8/+Lf + 3/+Dg4D/SW5p/12CgP+Ho6T/haCi/4Who/+GoaP/hqKj/4eipP+Io6T/iaOk/4mkpf+KpKb/i6am/4um + p/+Mpqf/jaao/46pqv+PqKn/kKqq/5GqrP+Sq6z/k6yt/3WUkv9niIX/iaSi/5ewrv+Urav/k6yq/5Gr + qf+Qqqj/jqmn/42npf+Mp6T/i6Wj/4mkov+Io6D/h6Kg/4Whn/+EoJ7/g5+d/4Gdm/9/nJr/fZuY/3yZ + l/97mZb/e5iW/3qXlf9sjYr/U3l2/0Ntaf9NdXH/dJOR/4ylpP+Mp6b/h6Oh/4Sgnv+BnZv/fZuY/3qY + lv92lZL/cpKP/22Oi/9oiof/ZIeD/12Bfv9WfHj/U3p2/0pzbv9Fb2v/gZ6b/6G3tv+gtrP/dpai/xpM + fv8ZS37/FEZ7/1t/lf+Zsaz/j6mn/42npf+MpqT/iaSi/4aioP+FoZ//gJ2b/2uLif9oiYb/VG5s4AAA + AI4AAABzAAAASAAAAB8AAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCf31/iIWC/4+P + j/+cj4r/zY95//yqjf//ybX//+PZ///o4P//4tf//8iy//qpjP/Ch3L/komF/9TV1f/t7Oz/6unp/+rp + 6f/q6en/6unp/+rp6f/q6en/6ejo/+7t7f/d3Nv/jY6N/2qBf/9Yf3v/dJST/4mkpv+HoqT/h6Kl/4ik + pf+JpKb/i6Wm/4qlpv+Lpqf/jKan/42nqP+Op6n/j6ip/4+pqv+Qqqr/kqus/5OsrP+UrK3/la2u/5av + r/+Wrq//cZGO/2iKh/+Rqqn/nLOx/5ixr/+XsK7/lq+t/5SurP+TrKv/kqyp/5GqqP+Pqaf/jqim/42n + pf+LpqT/iqWj/4mkof+Ho6H/hqGf/4Sgnv+Cn53/gZ2b/4Cdmv9+m5n/fZqY/36amP96mJb/b4+N/1yB + ff9HcGz/Unl1/22Ni/+GoqD/hqGg/4Gdm/99m5j/epiW/3aVkv9yko//bY6L/2iKh/9kh4P/XoJ+/1V8 + eP9Tenb/U3l1/0hxbf9NdXH/i6ak/6G3tf+Lpqr/IU9//xtJfP8VRHn/TnOP/5avq/+Qqaf/jqim/4ym + pP+KpKL/h6Oh/4Wgn/+EoJ7/dZSS/2iJhv9niIX9Iy8uqwAAAHkAAABQAAAAJQAAAAoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDgH6vh4SC/4uLi/+Ki4v/q4l8/9qMcf/0mXn/+KCD//SY + d//ZjXH/o4V5/36AgP/Cw8L/5+bl/+Dg3//h4N//4eDf/+Hg3//h4N//4eDf/+Dg3//k4+L/3Nva/5SS + kv+jlYb/eJKK/2iKiP+AnZ3/iaSm/4mkpf+Kpab/i6am/4ump/+Mp6j/jaeo/46oqf+Pqan/j6mq/5Cq + q/+Rq6z/kqut/5Osrf+Urq3/lq+v/5evr/+YsLD/mrGx/5iwsP9vj4z/aouI/5iwrv+ftrT/nLSy/5uz + sf+asrD/mLGv/5evrv+Wrq3/la2s/5Osqv+Sq6r/kaqo/4+pp/+OqKb/jaek/4umpP+KpaP/iKOh/4ei + oP+FoZ//hKCd/4Kenf+BnZv/gJ2Z/36bmf9/nJn/f5uZ/2+Pjf9Pd3P/QWxn/1l+e/99mpn/hKCe/32b + mP95mJX/dpWS/3KSj/9tjov/aIqH/2SHg/9dgn7/VXx4/1N6dv9Uenb/UXh0/0Ntaf9egoD/nrSy/5av + rv8vWIL/G0d5/xlEeP9DaYn/k6yp/5Cqp/+OqKb/jKak/4qkov+Io6H/haCf/4Ognf99m5j/aYqH/2mK + h/9EWVfLAAAAfQAAAFYAAAAoAAAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAISB + fxGEgX/NhoOB/4qHhv+GiIj/iYiG/5WHgf+eh37/lYiC/4SDgv9/gID/t7Wz/+De3v/b2tn/29rZ/9va + 2f/b2tn/29rZ/9va2f/c29r/4N7d/9TT0/+Sk5T/qpWG///Ppv+uqJT/X4WF/4Cdnf+Mp6f/i6Wn/4ym + p/+Np6j/jqeo/46oqf+Pqqr/kKmq/5Grq/+Sq6z/k6yt/5Strv+Vra7/la6v/5evsP+YsLH/mbGx/5uy + sv+ctLT/mbGx/2uMif9sjIn/nrW0/6G3tv+ftrX/nrW0/520s/+cs7H/mrKx/5mxsP+YsK7/l6+t/5Wu + rP+Urav/k6yq/5Grqf+Qqqj/j6mn/42npf+LpqT/iqWj/4mkov+HoqD/hqGg/4Whnv+Dn53/gp6c/4Cd + mv9/nJr/gJya/3uYlv9dgn7/Q21p/011cf9zk5D/gJ2b/3mYlf91lZL/cZGP/22Oi/9oiof/Y4aD/12B + fv9Ue3f/U3p2/1N6dv9Ue3f/S3Nv/0dwbP+IpKH/nLSy/z5ih/8aRHf/G0R3/z5jhv+Sq6n/kKqn/46o + pv+MpqT/iqSi/4ijof+FoJ//g5+d/4Gem/9tjYv/aIqG/01mZNYAAAB/AAAAWQAAACoAAAANAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAISBfx2DgH+4hIF//4SCgf+Eg4L/hIOC/4KD + gv+CgYD/joyK/768u//c29r/2dfW/9jX1v/Y19b/2NfW/9jX1v/Z19b/2NbV/9PR0f+2tbb/i4uK/7Ga + if/7yqP//9Go/7Wrlv9chIP/fZua/4+pqv+NqKj/jqip/4+oqv+Qqqv/kaqr/5Krq/+TrK3/lKyt/5Wt + rv+Wrq7/l6+v/5iwsP+YsbH/mrKy/5uzs/+dtLT/nrW1/6C3t/+dtLT/a4yJ/2yMif+huLX/pbq5/6K5 + t/+ht7b/oLe1/562tP+etbP/nLSy/5uzsf+asrD/mbGv/5ewrv+Wr63/la2s/5Stq/+SrKn/kaqo/4+p + p/+OqKb/jKak/4ulo/+KpaP/iKOh/4eioP+FoZ//hKCe/4Ofnf+BnZv/gZ2b/4Gdm/9pi4j/SHFt/0hx + bf9qjIn/e5mX/3WUkv9xkY7/bI6L/2iKh/9jhoP/XYF9/1R7d/9Tenb/U3p2/1R6dv9QeHT/Q21p/2mL + h/+gtrT/SmuL/xtCdv8eRHX/Nlh//5Cppv+Rqqj/jqim/4ympP+KpKL/iKOh/4Wgn/+Dn5z/gp6c/3KR + jv9oiYb/VG9t3wAAAIAAAABbAAAALAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAIGAfwR7fX1wiYF+54WBf/+BgH//f35+/4CAf/+Xlpb/o6Ki/5+env+enp7/np6e/56e + nv+enp7/np6d/5+env+dm5r/ko6M/52PhP/UsJT//8yl///Mpf//0Kf/s6uW/1yDg/94lpT/kKqr/5Cp + qv+Rqqv/kaur/5Orrf+Ura3/la2u/5Wurv+Wr6//mLCw/5mwsf+asrL/m7Ky/5yzs/+dtLT/n7a2/6C3 + tv+huLj/pLm5/6C3tv9sjIn/bIyJ/6S6uP+ovbv/pbu5/6S6uf+jubj/ori3/6G3tv+ftrX/nrW0/520 + s/+cs7L/m7Kx/5mxsP+YsK//l6+t/5aurf+Urav/kqyq/5GqqP+Pqqf/jqin/42npf+MpqT/iqWi/4mk + ov+Io6H/hqKg/4Wgn/+Dn53/gp+c/4Sgnf9oiob/SHFt/0Vuav9jhoP/dpWT/3CQjv9rjYr/Z4mG/2KG + gv9cgH3/VHt3/1N6dv9Tenb/U3p2/1N6dv9Icm7/T3Zz/5qyrf9Zd5D/Gjxv/yBAcf80W4f/hqux/5St + qf+OqKb/jKak/4qkov+Ho6H/hKCf/4OfnP+Cnpz/dZSR/2iJhv9ZdHLlAAAAgQAAAFwAAAAsAAAADQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfpn3/R4KGE/9Ge + hP/MnYb/zZ+H/8qehv/JnYX/yZ+H/8mgiP/Joon/yaKK/8qji//KpIz/yaSN/86pkP/nuZn//cii///O + pf//zKX//8yl///RqP+9r5j/YIaE/26OjP+Qqar/k6yt/5Ssrf+Vra3/la6v/5evr/+Xr7D/mLCx/5my + sv+asrL/nLOz/520tP+etbX/n7a2/6G3t/+iuLj/o7q5/6W6uv+nvLz/pLm5/2yMif9sjIn/pry7/6q/ + vv+ovbz/p7y7/6a8uv+lurn/pLq4/6K4t/+iuLf/oLe1/5+2tP+dtbP/nbSy/5uzsf+asrD/mbGv/5iv + rv+Vrq3/lK2r/5Osq/+Sq6n/kaqo/4+pp/+OqKb/jael/4ulpP+KpKL/iKOi/4ejoP+HoqD/fZqX/2qL + iP9lh4X/UXh0/0Ntaf9ghIH/cZGP/2uMif9miYX/YYSB/1uAfP9Tenb/U3p2/1N6dv9Tenb/VHt3/011 + cf9Fb2v/iaWd/2aIn/8fVZD/J2mj/ydsqP8yZ5n/d5Kb/5Grp/+MpqT/iqSi/4ejof+EoJ//g5+d/4Ke + m/93lpP/aIqH/1x5duoAAACBAAAAXAAAACwAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA0oxsM/2pg/n/rof//7GK//+0jP//t4///7mS//+8lP//vpb//8CY///C + mv//xJz//8ad///Hn///yaD//8ui///Lo///y6P//8ul///Mpf//zab//9Go/8u2nP9liIb/Z4mG/4ei + ov+Xr7D/lq6w/5evsP+ZsbD/mbGx/5uysv+bs7P/nLS0/561tf+ftrX/oLe3/6K4t/+iuLj/pbq6/6a8 + u/+nvLz/qL69/6u/v/+nvLz/bIyJ/2yMif+ovrz/rcHA/6vAv/+qvr3/qb68/6i9vP+nvLr/pbu6/6S6 + uf+jubj/ori3/6G3tv+gt7X/n7a0/521s/+ctLL/m7Kw/5mxr/+Yr67/l6+t/5WurP+Urav/k6yq/5Gr + qf+Qqqj/j6im/42opf+MpqX/i6ak/4mkov9wkI3/ZoeE/3iWlf9/nJ3/Unl1/0Ntaf9dgn7/bI2K/2WI + hf9ghID/Wn97/1N6dv9Tenb/U3p2/1N6dv9Tenb/UXh0/0duZ/9Xi5j/O4G4/yZel/8mUIP/JUR0/xs5 + a/9bd43/lK+p/4ympP+JpKL/hqKg/4Whn/+Dnp3/gZ2b/3iWlP9piof/Xnt57QAAAIAAAABaAAAAKwAA + AA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHnnHpy+6uF//yu + iP/8sIv//LON//21j//9t5L//bqU//28lv/9vpj//sCZ//7BnP/+xJ3//sWf//7GoP/+yKL//8qj///L + pP//zKX//82m///Op///0aj/276f/2qKh/9lh4T/dpSS/5mxsf+ZsbH/mrKy/5yzs/+cs7T/nbW1/5+2 + tv+gt7b/obe4/6K5uP+kurn/pbq6/6a8u/+nvbz/qr++/6u/v/+swcD/rsLB/6m+vf9sjIn/bIyJ/6i9 + vP+uwsH/rcHA/63BwP+swL//qr++/6m+vf+ovbz/p7y7/6a8uv+lurr/pLm5/6O5uP+huLf/obe2/5+2 + tf+dtbP/nbSy/5uysf+ZsrD/mbGv/5ewrv+Wrq3/la2s/5Osq/+Sq6n/kaqp/4+pp/+Qqqj/fpuZ/2aI + hP9sjIr/hJ+g/4ijpf9+mpz/UXh1/0Ruav9cgH3/ZYiF/16DgP9YfXr/U3p2/1N6dv9Tenb/U3p2/1N6 + dv9Tenb/THJq/zVxj/8gRn3/JEFw/yNEc/8iRXX/HkN1/2WBk/+Traj/i6ak/4mkov+HoqD/haGf/4Of + nf+BnZv/eJaT/2mKh/9de3jsAAAAfgAAAFcAAAApAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAu+if6v8rYf//K+K//yyjP/8tI7//beR//25k//9u5X//b6X//3A + mf/+wZv//sOd//7Env/+xqD//seh//7Jo///y6T//8yl///Mpv//zqf//86n///Qqf/wyKX/cI2J/2aI + hv9niYb/jKam/5+2tv+dtLT/nra2/6C3tv+huLf/ori4/6S5uf+lu7r/pru7/6e9vP+pvb3/qr++/6zA + v/+twsD/rcHA/63BwP+twcD/p728/2yMif9sjIn/pLq5/6u/vv+rwL//rcHA/63BwP+swcD/rMHA/6u/ + vv+qv77/qb68/6i9vP+nvbv/pru6/6S6uf+kurj/orm3/6G3tv+gtrX/nrWz/520s/+bs7L/m7Kw/5mx + sP+YsK//l6+t/5WurP+Urav/lK2r/4ynpf9sjIn/ZoiF/3yZmf+JpKX/haGj/4eipf98mZr/TnZy/0Zv + a/9bgHz/XoN//1d9eP9Tenb/U3p2/1N6dv9Tenb/U3p2/1N6dv9NdGz/N2uH/x9Jfv8gR3j/H0h5/x5J + ev8aRnn/ZYGT/5Osp/+LpaP/iaSi/4ein/+FoJ7/gp+d/4Gdm/92lJL/aImG/1p3dOcAAAB8AAAAUwAA + ACYAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACJXUkL96iD3Pyu + iP/8sYv//LON//22kP/9uJL//bqV//29l//9v5j//sGa//7DnP/+xJ7//sWf//7Hof/+yaL//8qj///M + pf//zab//82n///Op///z6j//9Cp//3OqP+Hl43/aIuK/2qMif9xkY7/nrW0/6K4uP+iuLj/o7m5/6W6 + uv+mvLv/p728/6i+vf+qvr7/q8C//6zBwP+twcD/rcHA/63BwP+rwL//qr++/6vAvv+lu7r/bIyJ/2qL + iP+etbX/pru7/6a8u/+pvb3/qr++/6zAv/+twcD/rcHA/63BwP+swL//q8C+/6m+vf+ovbz/p7y8/6a8 + uv+lu7n/pLq4/6O5t/+ht7b/oLa1/5+2tP+etbP/nbSy/5uzsf+asrD/mLGv/5ewrv+XsK7/eJaT/2WG + g/9ykY//iqWm/4mkpf+HoqT/haGj/4iipP93lpb/SnJu/0lxbf9Zf3v/Vn15/1N6dv9Tenb/U3p2/1N6 + dv9Tenb/U3p2/051bv84aoL/G0yC/xlMfv8YTYD/Fk+C/xBKgP9jgZL/k6yn/4ulo/+JpKL/hqGg/4Og + nf+Cnpz/gZ2b/3OSkP9oiYb/V3Jw4gAAAHkAAABQAAAAJAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAM+Nbif7rIb3/K+K//yyjP/8tI///beR//25k//9vJb//b6Y//7A + mf/+wpv//sSd//7Fn//+xqD//sih//7Jo///y6T//8ym///Npv//zqf//8+o///PqP//z6j//9Kq/6em + lP9kion/f5ya/2WGg/+Dn53/p728/6a7u/+nvLv/qL29/6m/vv+rwL//rMHA/63BwP+twcD/rcHA/6zB + wP+rwL//qr++/6m+vf+ovr3/qL68/6S6uf9ykY7/aYqH/5evrv+juLn/ori4/6S6uf+mu7v/qL28/6m+ + vf+rv7//rMHA/63BwP+twcD/rMDA/6vAvv+qv77/qb69/6i9vP+nvLr/pru5/6S6uf+iubj/ori3/6G3 + tv+ftrX/nrW0/520s/+cs7L/nrWz/4aioP9miIX/aoqI/4aiov+Np6j/iqSm/4ijpP+HoqP/haGi/4ii + pP9uj47/Rm9r/0tzb/9Ue3f/U3p2/1N6dv9Tenb/U3p2/1N6dv9Tenb/TnVu/ztug/8VUYj/DlSJ/wxX + i/8IUoj/GVGD/3aRmv+Qqqb/iqWj/4ijof+GoqD/hKCe/4KenP+AnJr/b4+M/2iJhv9QamfYAAAAeAAA + AE4AAAAjAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6J98WPyt + iP/8sYv//LOO//21kP/9uJL//buV//29l//9v5n//sGb//7DnP/+xZ7//sag//7Iof/+yaL//8qk///M + pf//zab//86n///OqP//z6j//8+o///PqP//06r/ybac/2KGhP+IpKP/e5mX/2SHg/+TrKv/rsHB/6q/ + v/+swb//rcHA/63CwP+twcD/rMDA/6zAv/+qv77/qb++/6m+vf+ovbz/pry7/6a8uv+lu7r/o7m3/3ST + kf9oiYb/kKqp/6C2tv+ftbb/oLe3/6K4uP+jubn/pbu6/6e8u/+ovb3/qr6+/6zAv/+twcD/rcHA/6zB + wP+swL//q8C//6m+vf+ovbz/p7y7/6a8uv+lurn/pLm4/6K4uP+iuLf/oLa1/6G4tv+Vrqz/bIyJ/2WH + hP9+m5v/kaqr/42nqP+Lpqf/iqSm/4ijpP+GoaP/haGj/4eipP9jhoX/RG5p/051cf9Uenb/U3p2/1N6 + dv9Tenb/U3p2/1N6dv9PdW7/Pm9+/xBXjP8JV43/EEyB/zhhhv97lp3/kKqn/4ympP+KpaP/iKOh/4ah + n/+DoJ3/gp6c/32amP9qi4f/aYqH/0dcXs0AAAB4AAAATwAAACMAAAAJAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADupIGA/K+J//yyjP/8tI///beR//25lP/9u5b//b6Y//7A + mv/+wpz//sSd//7Fnv/+x6D//sii///Jo///y6T//8yl///Op///zqf//8+o///PqP//z6j//8+o///R + qf/xyab/cY2I/3eXlf+cs7P/bY6K/2qLiP+gt7X/sMTD/63BwP+twcD/q8C//6q/vv+qv77/qb69/6i+ + vP+nvbz/pry7/6W7uv+kurn/o7q4/6O4t/+ht7f/eJeU/2aHhP+KpKT/nLOz/5uzs/+dtLT/nrW1/5+2 + tv+ht7f/ori4/6S6uf+mu7v/p7y8/6i+vf+rv77/rMDA/63BwP+twcD/rMHA/6u/vv+qvr3/qb69/6i9 + vP+nvLr/pbu6/6S6uf+lurn/oLa1/3STkf9khoL/dZSS/5KsrP+Rq6v/jqip/42mqP+Lpaf/iaSl/4ej + pf+GoqT/hqGj/4Ofof9Uenf/R3Bs/1N6dv9Tenb/U3p2/1N6dv9Tenb/U3p2/011cP9DbG3/HE59/xxJ + fP8dQXT/aIOU/5qzrP+NqKb/jKak/4qkov+HoqD/haCf/4Kfnf+Cnpz/dZSR/2iJh/9piob/OmI0yAAA + AHkAAABQAAAAJAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfOn + g6L8sIv//LOO//22kP/9uJH//buV//29l//9v5n//sGb//7DnP/+xZ7//sag//7Hof/+yaL//8uk///L + pf//zab//86n///PqP//z6j//8+o///PqP//z6n//9Gp///UsP+eoZX/Y4iH/560tP+Xr67/Z4iF/3CQ + jf+kurn/rcLB/6q+vf+pvr3/qL29/6e9vP+nvLv/pry6/6W7uv+kurn/o7m4/6G4tv+ht7b/oLe1/6G3 + tv98mpf/ZIaD/4Ofnv+ZsbL/l7Cw/5mxsf+asrL/nLOz/520tP+ftrb/oLa2/6K4t/+jubn/pLq6/6a8 + u/+nvbz/qr6+/6zAv/+twcD/rcHA/63BwP+rwL//qr++/6m/vf+ovbz/qL28/6i9vP9/nJr/ZIaD/26O + i/+Rq6v/la6v/5KrrP+Qqav/jqip/4ynp/+Kpab/iaSl/4eipP+GoaL/iKKl/3eVlv9Icm7/Tndy/1R6 + dv9Tenb/U3p2/1N6dv9Tenb/TXVv/zxpcf8YT4H/Gkp9/yJJev98mJ//kqyo/42npf+LpaP/iaSi/4ei + n/+FoJ//g5+d/3+cmf9sjIn/aoiL/2aPdP80dwvNAAAAegAAAFIAAAAlAAAACgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+WEUC9aqFwPyxjP/8tI///beR//24k//9vJb//b6Y//7A + mf/+wpz//sOd//7Fn//+x6D//smi///Ko///y6T//8ym///Op///zqf//8+o///PqP//z6j//8+o///Q + qv//07L/1MB9/3CYR/9hhYP/iKOi/67Cwf+Qqqj/Y4aC/3OSkP+hubf/qr++/6a8uv+murv/pbu5/6S6 + uf+jurj/ori3/6G4tv+gt7X/nra0/561s/+dtLL/n7a0/4Gem/9jhYL/fZqZ/5aur/+Vra7/la6v/5ev + r/+YsLH/mbGy/5uys/+cs7T/nrW1/5+2tv+ht7f/ori4/6O5uf+lu7v/pry8/6m9vf+rwL//rcHA/63B + wP+twcD/rMHA/6vAvv+twcD/iaSj/2WHg/9piof/j6io/5uys/+Vrq//la2t/5KrrP+Qqar/jqip/4ym + qP+Kpab/iKSl/4eio/+GoaP/iKOl/2GFg/9GcGz/U3l1/1N6dv9Tenb/U3p2/1N6dv9NdW3/M2R2/xVM + gv8YR3v/NFqC/46opv+Pqaf/jKel/4qlo/+JpKL/hqKg/4Sgnv+DoJ3/dZOR/2iJhv9qiI7/TKJP/zR7 + CM8AAAB7AAAAUwAAACYAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMSI + agn4rYjX/LON//21kP/9t5L//bqU//28l//9v5n//sGb//7Dnf/+xJ7//sag//7Iof/+yaL//8uk///M + pf//zab//86n///PqP//z6j//8+o///PqP//0Kr//9Oy/7+5bv9NnQP/R6oS/2SRff9yj5D/pru6/6/D + wv+PqKb/Y4WC/3KSj/+ftrX/p7y7/6O5uP+iubf/ori2/6G3tf+gtrT/nraz/521sv+cs7L/m7Kx/5qy + sP+cs7L/haGe/2SHg/92lZP/kaqr/5Grq/+SrKz/k62t/5Wurv+Wr6//l6+w/5mxsf+asrL/m7Oz/520 + s/+etbX/oLe2/6G4t/+iuLj/pbq6/6e8u/+pvb3/qr++/6zAv/+twcD/scTD/5Kqqf9miIX/ZoiF/4ql + pP+htrb/mrKy/5iwsP+Wrq//lKyt/5GrrP+Qqar/jaip/4ymp/+KpKb/iKOl/4ejpP+Io6X/dZWV/0Zw + bP9OdXH/VHp2/1N6dv9Tenb/Unl1/0tzbP8pXnr/FEyD/xVFev9YeZH/lq+q/46opv+MpqT/iqWj/4ij + of+GoqD/haGf/3uZl/9piof/boeJ/1OUgf8auj//N4EL1QAAAHwAAABVAAAAJwAAAAsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3Jp6EPuwiu/8tI7//baR//24kv/9u5X//b2Y//6/ + mv/+wpv//sSd//7Fn//+x6D//smi///Ko///y6T//8ym///Np///zqj//8+o///PqP//z6j//9Cq///T + s/+/u27/S6QG/0u7K/9Z3Hj/Y7mO/2aDhP+Rqqj/scTD/7DEw/+Np6X/ZIWC/3KRjv+asrD/o7q4/6C2 + tf+ftbT/nrSz/520sv+bs7L/mrKx/5mxr/+YsK7/l6+u/5iwrv+JpKL/Z4mF/3CPjf+Np6j/j6ip/4+p + qf+Rq6v/kqus/5Osrf+Ura7/la6u/5avr/+Yr7H/mbGy/5qys/+ctLP/nbS1/5+2tf+gt7f/o7i4/6S6 + uf+lu7r/qL28/63Bwf+Urav/aImG/2SGg/+HoqH/pbq7/6C3t/+ctLT/mrKy/5ewsP+Vrq7/k6yt/5Kq + q/+Pqan/jaeo/4ump/+Kpab/iKOk/4ijpP+DnqD/UHdz/0dxbP9TeXb/U3p2/1R6dv9ReHP/R3Ft/x5X + gP8US4H/IE5+/4Gdov+Sq6j/jael/4ylo/+KpKL/h6Kh/4ain/+AnZr/a4yJ/2qIh/9qiYf/GbNi/w7A + Pv85gw3XAAAAfQAAAFYAAAAoAAAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADmon8j+7GL9vy0j//9t5H//bmT//28lv/9vpj//sGa//7DnP/+xJ7//saf//7Iof/+yaL//8qk///M + pf//zab//86n///PqP//z6j//8+o///Qqv//0rL/vrtu/0unB/9NxEP/Wt+Q/1/lmP9i2pT/ZpCG/3SQ + j/+qv77/rsPC/63BwP+MpqX/ZIaD/22Oiv+Sq6n/oLe1/5yzsv+bsrH/mrGw/5mwr/+Yr67/lq+t/5au + rP+Vraz/lK2r/42npf9qioj/aouI/4mjpP+Mpqj/jaeo/46oqP+Oqan/kKqq/5Gqq/+Tq6z/k62t/5Su + rv+Wr6//l7Cw/5iwsf+asrL/m7Kz/5y0tP+ftbb/oLa3/6K4uP+nvLz/kKmo/2iJhv9khoP/hqGg/6m9 + vf+lu7r/obi3/5+2tv+ds7T/mrGy/5evsP+Wrq7/k6yt/5Gqq/+Pqar/jaeo/4umpv+JpKb/iKOk/4qk + pv9pi4r/RG5q/093c/9Uenb/VHp2/092cP89a3H/FFGE/xBIf/9KcY7/la6q/4+opv+Mp6X/i6Wj/4mk + ov+Io6H/gZ6b/26Oi/9piIb/b4eK/zOmbP8AxVD/Db9F/zqID9sAAAB/AAAAWAAAACkAAAAMAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOymgy/7sYz5/bWP//24kv/9upT//b2X//2/ + mf/+wZv//sOd//7Fn//+x6D//sii///Ko///y6T//8ym///Npv//zqf//8+o///PqP//0Kr//9Cv/7O5 + Y/9Lqgr/TcdM/1ngk/9d4ZT/YeGT/2XomP9ou5H/ZYKD/42npf+vw8L/qr++/6q/vv+Mp6X/Z4iF/2mK + h/+JpKL/m7Kx/5mxr/+XsK3/la6s/5WtrP+TrKr/k6uq/5Kqqf+Rqqj/jqim/26Oi/9piYb/gp6e/4ul + p/+Kpqf/i6Wn/42mp/+Op6n/j6eo/4+pq/+Qqqv/kqur/5Osrf+Ura3/la6u/5avr/+XsLD/mbGx/5uz + s/+dtLT/oLe3/4qko/9oiYb/ZIaD/4eiof+vw8L/q7+//6e8u/+jubn/obe3/5+1tf+btLP/mbGx/5ev + r/+Vra7/kqys/5Cqqv+OqKn/jKao/4ulp/+JpKb/iaSm/3+cnv9LdHD/SnJu/1N6dv9Tenb/TXRt/yxi + ef8MTYX/IVWE/4OfpP+TrKj/jqel/4ympP+LpaP/iqSi/3+bmf9sjIn/aImG/3CGi/9An3L/AMNQ/wDD + Uv8JwEr/O40Q3wAAAH8AAABZAAAAKwAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA8KqFP/yzjfz9tpD//biT//27lf/9vpj//sCa//7Cm//+xJ7//saf//7Hof/+yaL//8qj///M + pf//zab//86n///OqP//z6j//9Cq///QsP+ut17/RqkF/03JUv9Y4JT/W+CS/1/gk/9j4pb/Z+WZ/2vi + m/9omYn/bYmJ/6G4tv+rv77/p7y7/6e8u/+Rq6n/a4yJ/2WHhP9/nJn/la6s/5aurP+TrKr/kqup/5Cq + qP+Qqaf/j6im/46opv+Np6X/dJOR/2aHhP96mJf/iaSm/4ijpP+JpKb/iqWm/4ump/+Mpqf/jaep/46n + qP+PqKr/kKmq/5Gqq/+SrKz/lKyt/5Strf+Wrq//mLGx/5qxsv+Cnpz/ZoeF/2WHg/+GoZ//rsHA/67C + wf+twb//qr+9/6a8vP+juLr/oLi3/561tf+ctLP/mbGx/5avr/+Tra3/k6us/5Cpq/+OqKn/jKen/4ul + p/+JpKX/iaSm/16CgP9Fbmr/Unl1/1J5dP9HcW3/GFiC/wxNhP9lipv/l6+q/4+opv+Np6X/jael/4ik + ov95l5T/aYqH/2qJh/9uiIn/P6Bx/wLBUf8Aw1D/AMJS/wTBTf87kRHiAAAAgAAAAFsAAAArAAAADQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADyrIdM/LSO//23kf/9uZP//byW//2+ + mP/+wZr//sOc//7Fnv/+xqD//sih//7Jo///y6T//8yl///Npv//zqf//8+o///Qqf//0LD/rrdd/0ap + Bf9MyFH/Vd+S/1rfkP9e4JH/YuGV/2bjl/9p5Jr/buqe/2/LmP9mhoX/e5eW/6m+vf+mvLr/pLq4/6S6 + uf+Wrqz/cpGO/2SGg/90k5D/jael/5Krqf+Oqab/jaim/42npf+LpqT/iqWj/4ulo/96l5X/ZYeE/3SS + kf+GoqP/hqKj/4ejpP+HoqT/iKSk/4mlpf+KpKf/jKWn/4ynp/+Np6f/jqiq/4+pqv+Qqqr/kaqr/5St + rv+Sq6z/eZaV/2SHhP9niIX/iaSi/6q/vv+rv77/rMC//63BwP+swcD/qb6+/6a6u/+jubn/oLe2/560 + tP+asrP/mbGx/5aur/+Ura3/k6ur/5Cpqv+Op6n/jKao/4qlpv+Lpaf/cpGR/0Zwa/9OdnL/T3Zv/zNo + dv8FTof/S3qV/5auqv+Rqqj/kKmn/42npf+BnZv/cI+M/2eJhf9niIj/Z4qJ/zOna/8AxE//AMNQ/wDC + Uf8AwlL/A8FO/ziWFuYAAACBAAAAXAAAACwAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPKsiEr8tY///biS//26lP/9vJf//b+Z//7Bm//+w53//sWf//7HoP/+yKL//8qj///L + pP//zKb//86n///Op///z6j//9Cu/6+3Xv9HqQX/S8hQ/1PekP9Y3o//XN+Q/2Dhk/9k4pb/aOOY/2zk + nP9w5p//dOqh/2inff9lgYH/i6ak/6m+vf+jubj/oLe1/6C2tf+YsK//e5iW/2WHhP9sjIn/g5+d/42n + pf+KpaP/iqSi/4ijof+GoqD/h6Kg/36bmP9oiYb/bY2L/4Ofof+FoKL/haGi/4Who/+HoaP/hqKk/4mj + pP+JpKX/iqSm/4ulpv+Lp6f/jaan/46oqf+Qqqv/jKen/3GRjv9khoP/a4uJ/46npv+nvbz/p7y7/6i9 + vP+qv73/rMC//63BwP+swL//qL28/6W7uf+iuLj/n7W2/521tP+bs7L/mLCw/5aur/+TrK3/kaur/4+p + qv+NqKj/i6an/4ulp/+Cnp//S3Nw/0lybf9IcW3/EFeD/ztzlv+UrKv/la6r/46opv+Cnpz/cpGP/2iJ + hv9liIb/Y4eJ/3uPgf9LqT//AMRL/wDDUf8AwlH/AMJR/wDCUv8CwU//NpoZ6AAAAIEAAABcAAAALAAA + AA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8q2ISv21j//9uJL//buV//29 + l//+wJn//sKc//7Enf/+xp///seg//7Jov//yqP//8yl///Npv//zqf//86n///Ss//Uwn//SakH/0nH + Tv9Q3Y7/Vd2N/1nej/9e4JL/YuGU/2bjl/9q5Jr/b+Wd/3PmoP9366X/cduL/2iVgf9phof/la6s/6W7 + uv+ftrX/nLSy/5uzsf+Zsa//g6Cd/2mLiP9piof/f5ya/4mjof+HoqD/haGf/4Sgnv+Dn53/gJ2a/2uL + if9piof/fpuc/4Sfof+Dn6H/hKCh/4Sgov+FoaP/h6Kj/4aio/+Ho6T/iKOl/4mkpf+Lpab/jaeo/4ah + ov9wkI7/ZIaD/3CQjf+TrKv/o7m5/6O5uP+lurn/p7y7/6m+vP+rv77/rMG//63BwP+rwL//qLy8/6W7 + u/+it7j/oLe3/520tP+bsrL/l7Cw/5Surv+UrK3/kqqr/4+pqv+Np6j/i6an/4mkpf9VfHj/R29o/yhl + fP9Be5z/kqup/42no/98mpf/b4+M/2iJhv9oiIj/aYmO/3eOjv+9npX/v6th/0O0Ff8Awk7/AMJS/wDC + Uf8AwlH/AMJS/wDCUf8yoR/tAAAAgAAAAFsAAAAsAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD5so1K/baQ//25kv/9u5X//b6Y//7Amv/+wpz//sSe//7Gn//+yKH//smi///L + pP//zKX//82m///Op///0bD/38SL/2atIv9FyE//Td2M/1Hci/9W3o3/W9+Q/1/hk/9k4pb/aOOZ/2zl + nP9x5p//deei/3jopP9+76v/e9ei/2iMh/9vjIv/mrKx/6G3tv+cs7H/mbGv/5evrf+Wr63/i6aj/3CQ + jP9miIX/dZSR/4GenP+Dn53/gZ6b/4Ccmv9/nJr/cJCN/2aIhP92lZT/hKCi/4Ofof+Dn6H/g5+h/4Og + of+En6L/haCi/4Whov+GoqT/iaOl/4eipP96l5f/aoqH/2aHhP96l5X/l6+t/5+3tf+ftrT/ore2/6S5 + uP+mu7n/qLy7/6m+vP+rv77/rMHA/63BwP+rv7//p728/6S6uv+huLf/nra2/52zs/+asbL/lq+w/5au + rv+TrK3/kaqr/46pqv+Np6n/iaOl/1l+ef81anP/Q3qQ/36al/9zko7/aYqH/2eIhv9qh4n/a4iM/2WJ + fP9hjFT/u6Rr/72oVv9eqxL/Hboz/wDDVP8AwlH/AMJR/wDCUf8AwlL/AMJR/zCiH+0AAAB/AAAAWQAA + ACoAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPSwizv9t5H8/bmT//28 + lf/9vpj//sGa//7DnP/+xZ7//seg//7Iof/+yqP//8uk///Mpf//zab//9Ct/+fGkv9gqBT/Qb4z/0rc + jP9P3In/U92L/1jejv9c4JH/YOGU/2Xjl/9q5Jr/buWd/3LnoP936KP/e+mm/37rqf+F8q7/fMqg/2WF + hP9zkI//m7Kw/520s/+YsK//la+s/5Osqv+Sq6n/iqWj/3GQjv9miIT/a4uJ/3iWk/9+m5j/fZqY/3yZ + l/9xkY7/Z4iF/2yNi/91lJT/eZeX/3+cnf+Dn6H/g5+h/4OfoP+EoKH/haCj/4Whov99mpr/bo6M/2aI + hP9miIX/e5mW/5iwrv+ZsrD/mrKx/560s/+gtrX/ori2/6O5uP+lu7r/qL27/6q+vf+rwL//rcHA/63B + wP+qv73/p727/6S5uf+ht7j/n7W1/5u0s/+ZsbH/l6+v/5Wtrv+SrKz/kKqr/4+pqv97mJb/W4KD/1F/ + if9sjIn/aImH/2mHi/9rh43/bImE/2GSc/9Zn0f/UZwU/0mOAP9QkgH/S6UE/yy3J/8BwlL/AMJS/wDC + Uf8AwlH/AMJR/wDCUv8BwlD/NJ0b6gAAAH0AAABWAAAAKAAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA97KNLP23kfj9uZT//byW//2/mf/+wZv//sOd//7Fn//+x6D//smi///K + o///y6T//8ym///Oqv/4zaT/dK8p/0C4JP9G13z/TNyI/1DciP9V3Yz/Wd+P/17gkv9i4pX/Z+OY/2vk + m/9w5p7/c+eh/3jppP996qf/geuq/4Xtrf+L9LL/fMGf/2SDg/92k5H/mLCu/5mxsP+Vraz/kquq/4+p + p/+Np6X/iKOh/3mXlf9qi4j/Z4iF/2+Oi/91lJH/bo6L/2mKh/9piof/aImG/2eJhf9oiYb/aouI/3KS + kP9+mpz/g5+h/4KeoP97mZn/cJCO/2eJhv9miIT/bo6L/4GenP+Sq6n/la6s/5avrf+YsbD/nLKy/521 + s/+gtrX/obi3/6S6uP+mu7r/qL28/6q+vf+swL//rcHA/63BwP+qv73/pry8/6O4uf+guLj/nrW1/5y0 + s/+YsbH/lq+v/5Wtrv+Tra3/h6Ki/2qKif9piI7/bImO/2mIh/9niH7/Y5Bk/1ydSP85sEn/EcJR/xXC + P/89tBv/T6YJ/0urDP8uuCr/AsJR/wDCUv8AwlH/AMJR/wDCUf8AwlH/AMJS/wPBTv86lxTkAAAAegAA + AFIAAAAlAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9tpEd/LaR9v26 + lP/9vZf//b+Z//7Cm//+xJ3//saf//7Gof/+yaL//8qj///Mpf//zaf//86s/5S6Rv8/uCT/QdV6/0ba + hv9N24b/UtyJ/1bejP9b35D/X+GT/2Tilv9o5Jn/beWb/3Hmn/916KP/euml/37rqP+D7Kz/hu2u/4zw + sv+R9Lb/fLic/2OCgv91k5D/la2s/5aurf+Rqqn/j6mn/4ulo/+Ho6D/hqGf/36bmf9xkY7/aYqH/2mK + h/9oiYb/aouH/22Niv9wkI3/cZCN/2+PjP9ri4n/Z4mF/2uMif92lJT/b4+N/2iJhv9miIT/a4yJ/3eW + k/+Io6H/jqim/5Cpp/+SrKr/la2s/5evrv+Zsa//m7Oy/521tP+gtrX/o7i3/6W6uf+nvLr/qb28/6q/ + vv+swL//rcHA/6zBwP+pvr7/prq7/6O5uP+gt7b/nrS1/5qys/+YsLH/l6+w/5OsrP9wj5D/Z4eD/1+U + Wv9bm0P/Vpgn/1GgEf9KsBP/KsE4/wvJW/8Ix1r/AsVY/wXCT/8avTz/Er9C/wDCUv8AwlL/AMJR/wDC + Uf8AwlH/AMJR/wDCUf8Aw1P/DL9H/zyND90AAAB2AAAATAAAACIAAAAIAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP23kgz8t5Hs/buU//29l//+wJn//sKc//7Env/+xp7//sih//7J + ov//yqT//8yl///Orv+3wGX/QrQb/z3TdP9C2YP/SNmD/07bh/9T3Yr/V96N/1zgkf9g4ZP/ZeKX/2nk + mv9u5Z3/cueg/3fopP976qf/gOuq/4Ttrf+J7rD/je+y/5Hztv+X9br/frmf/2SCgv9ykY7/j6mn/5Os + qv+Np6X/iqWj/4ahoP+Dn53/gZ6b/36bmf9zkpD/aImG/2uLiP9ykY7/eJaU/3yZmP99mpf/epiW/3aU + kv9vjoz/aYqH/2iJhv9oiYb/a4uI/3SSj/+AnJr/h6Kg/4ikov+JpKP/jqem/5Gqqf+TrKv/lq6s/5aw + rv+asbD/nLSy/5+1s/+ht7b/ori3/6S6uf+nvLv/qb28/6q/vv+swL//rcHA/6zAv/+ovbz/pbu5/6O4 + uf+ftbf/nbW0/5uzsv+bs7T/haCg/2iGi/9ZkkD/S6oC/0W3Fv88vCv/NcA7/yDHVv8SymP/EMdd/wzG + WP8HxFX/AcNT/wDDVP8Aw1T/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDDVP8YvD3/OYAM0wAA + AHEAAABFAAAAHQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/biSB/u3 + kdX9u5T//b6X//7Amv/+wpz//sSe//7GoP/+yKH//smj///LpP//zar/6smT/1qyHf86y1z/PtiC/0TY + f/9J2oT/T9uI/1Tdiv9Y3o7/XeCR/2LhlP9m45f/auSb/2/mnv9056H/eOmk/33qp/+B7Kv/hu2u/4ru + sf+O8LP/kvG3/5j1u/+d977/hMCj/2WFhP9tjIv/iKOh/4+op/+JpKL/hqGf/4KfnP+AnJn/fZqY/3SS + kP9qi4j/cpKO/3uZl/+Dn53/iKOh/4mkov+GoqD/gJ2b/3iVlP9tjov/aIqH/2qLiP95l5T/gJyZ/4Ge + nP+EoJ7/haKg/4ijoP+MpqT/j6mm/5GrqP+Urar/lK6s/5iwr/+bsrH/nLOz/561tP+gt7b/o7m3/6W6 + uf+nvLv/qb69/6q/vv+swb//rcHA/6vAv/+ovLz/pLu7/6K4uP+gt7f/oLe3/42np/9tiYz/XpNQ/0uv + D/86xEb/Kc5q/yLObf8czmv/Gctl/xXJYP8Rx1z/DMZZ/wfEVv8DwlP/AMJR/wDCUf8AwlH/AMJR/wDC + Uf8AwlH/AMJR/wDCUf8AwlH/AMNV/yW5Mv83dgnIAAAAawAAAD0AAAAXAAAABAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+reRuv27lf/9vpj//sCa//7CnP/+xZ7//sWg//7I + of/+yqP//8uk///Orf+fu0//Obwv/zrXf/9A137/RNiA/0rahP9Q3Ij/Vd2L/1nfjv9e4JL/Y+KV/2fj + mP9r5Zv/cOaf/3Xoov956aX/fuqo/4Lsq/+H7a7/i++y/5DwtP+U8rj/mPO7/572v/+l+8T/jcur/2iJ + hv9oh4b/gJya/4qkov+FoZ//gp6c/3+cmv99mpf/dJOQ/2uMif94l5T/g5+d/42npf+Urav/lq+t/5Kr + qf+JpKL/f5yZ/3STkP9qi4j/aYqH/3aUkv99mpj/fpua/4GdnP+En57/hqGe/4mkof+Mp6X/j6mn/5Kr + qf+TrKv/lq+t/5mwr/+ZsrD/nLSy/5+2tf+it7b/pLm4/6a7uf+ovLv/qb68/6u/vv+twcD/rcHA/6q/ + v/+nvLz/pru7/6W6uv+Np6b/bYeK/2CUfv9Cwkj/N8xd/yzTdv8oz2//JM5q/x/MZ/8by2T/Fslg/xLI + Xf8Nxlr/CMVX/wPCU/8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUv8Aw1L/M7Ym/yxe + B7MAAABjAAAANAAAABIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD6t5GY/buV//2+mP/+wJr//sOc//7Fnv/+x6D//sih///Ko///y6f/88qa/1+zIv83zGD/O9d//0HX + ff9F2IH/StqF/1Hcif9V3Yz/Wt+P/1/gkv9j4pb/aOOZ/2zlnP9x5p//deii/3rppf9/66n/hOys/4ju + r/+N77L/kfG1/5XyuP+a9Lz/nvW//6P4wv+r/8j/mty3/2+Ujf9kg4L/eJaU/4Ognf99m5j/d5WT/3GQ + jf9sjIn/aImG/3eVk/+KpaP/lK2r/5+2tP+jubf/m7Kx/4+pp/+Dn57/eJaT/2yMif9oiYb/cpGO/3uY + lv99mpj/f5ya/4Kem/+Dn53/hqKg/4mlo/+Np6X/kKmo/5Krqv+Urav/l66t/5ixr/+asrH/nrSz/6C2 + tP+huLb/o7m4/6W7uv+ovbv/qr69/6vAv/+twcD/rcHB/67Cwf+kurn/g5+e/2qFhv9kkIX/R8V//zTZ + fP8x03f/LtFx/ynPbf8lzmr/IMxn/xvLZP8WyWD/Eshd/w3GWv8JxVf/BMNT/wDCUf8AwlH/AMJR/wDC + Uf8AwlH/AMJR/wDCUf8AwlH/AMJS/wHCUP8/shz+Gz0FmgAAAFoAAAAsAAAADgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPu4knb9u5X//b6Y//7Bmv/+w53//sWe//7H + n//+yKL//8qj///Nq//JwnT/Q7gm/zbTd/881nv/Qdd9/0XYgf9L2oX/UdyJ/1bejP9b35D/X+GT/2Ti + lv9p5Jn/beWd/3HnoP926KP/e+qm/4Drqf+E7az/ie6w/43ws/+S8bb/l/K5/5v0vP+f9b//o/fC/6n4 + xv+x/8z/qe3E/3ynmf9lhYP/a4yJ/2qLiP9oiYb/aImG/2uLif9ujoz/bIyJ/4Kem/+Ysa//pbq5/6m+ + vf+etbT/kaup/4Whnv95lpT/bY2K/2iJhv9qi4j/cI+M/3aVkv98mpb/gJ2a/4Ofnf+FoZ//iKSi/4um + pP+OqKb/kKqn/5Ksqf+Urav/l6+t/5mxsP+cs7L/nbS0/5+2tf+iuLf/pLq4/6e7u/+pvbz/rMC//6/D + wv+swcD/lq6t/3SSkf9ng4X/YJ2F/0jNgf882nz/N9R3/zPSdP8u0XH/Ks9u/yXOav8gzGf/HMtk/xfJ + YP8SyF7/DsZa/wnFV/8Ew1P/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8Aw1L/CcBK/0eo + E/YJFQKCAAAAUQAAACUAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA+riST/27lf/9vpj//sGb//7Dnf/+xZ7//seg//7Iov//yqP//82u/6u8V/83vjX/NtZ9/z3W + e/9B137/RtiB/0vbhf9S3In/Vt6N/1vfkP9g4ZP/ZOKW/2nkmf9u5Z3/cueg/3foo/986qb/gOuq/4Xt + rf+K7rD/jvCz/5Lxt/+X87r/nPS9/6D2wP+l98P/qvnG/676yf+1/8//uPzR/428qP9jgoL/ZoeE/2yN + iv93lZb/fJma/3yZmv90k5P/bIyJ/32bmP+Xr63/oLe1/5uzsf+Pqaj/g6Cc/3aUkv9qi4f/a4uJ/2uL + if9oiYb/aImG/2uMif9xkY7/eJaT/4Cdmv+GoZ//iqWj/42npf+Pqaf/kaqp/5Ksq/+Vrq3/mLCu/5qy + sP+ctLL/n7a1/6K4t/+lurn/qL28/6e8u/+gt7X/j6mn/3eVk/9oh4r/ZoiC/1q1hf9I2YP/QtqA/z7W + fP841Hj/M9J0/y/Rcf8qz27/Jc5r/yHMZ/8cy2T/F8lg/xPIXv8Oxlr/CcVX/wTDVP8AwlH/AMJR/wDC + Uf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDDVP8VvUD/QpYO5AEDAHUAAABIAAAAHwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9u5Uh/byV9v2+mP/+wZv//sOd//7F + n//+x6D//sii///KpP//zav/lrpI/zPDQv831n7/PdZ7/0LXf/9G2IH/TNuG/1Lciv9X3o3/W9+Q/2Dh + k/9l4pf/aeSZ/27lnf9z56D/d+ik/3zqpv+B66r/he2t/4rusP+O8LP/k/G3/5jzuv+c9L3/ofbA/6b3 + xP+q+cf/r/rK/7P8zf+6/9L/v//W/5rHsv9vkYz/Y4OC/2yMiv92lZX/fJmb/32anP94lpj/bo6N/26O + i/94l5T/fZqY/3uZlv9zko//bIyJ/2yNi/9zkpL/dpSU/3OSkv9wj47/bIyK/2iJhv9niYb/aYqH/3CP + jP92lZL/fJmX/4KfnP+Ho6H/jKel/5CqqP+Tq6r/lK2s/5evrv+Xr63/k6yq/42npf+EoJ7/eZeU/2yM + if9jhoT/Z4aL/2WMbf9TqjL/S9x+/0jbhf9E14D/PtZ8/zjUd/8z03X/L9Fx/yrPbv8lzmr/Icxo/xzL + ZP8XyWH/E8hd/w7GW/8JxVf/BMNU/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMNV/yK6 + Nf87gArQAAAAbAAAAD4AAAAZAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP28lgX8u5XS/b6Y//7Bm//+w53//sWf//7HoP/+yaL//8qk///Mqv+Sukf/NMNG/zfW + ff891nv/Qtd//0bYgf9M24b/UtyK/1fejf9b35D/YOGU/2Xilv9p5Jr/buWd/3PnoP936KT/fOqm/4Hr + qv+F7a3/iu6x/4/ws/+T8bf/mPO6/530vf+h9sH/pvfE/6v5x/+v+sr/tPzO/7j90P/A/9X/zP/f/8Dv + 0/+XvK//bo+L/2GCgP9pioj/c5KS/3uYmv99mZv/eJaX/3KRkf9ujY3/Z4mF/2mKh/9wkI7/dJOT/3WU + lP93lZX/eJeX/3qYmP96l5n/eJaX/3STk/9wj47/aouJ/2iJhv9niYX/aImG/2iKhv9qiof/aouI/2qL + iP9ri4j/a4yJ/2uLiP9qi4j/Z4mG/2WHhP9jhoT/YIWF/3qQkf96m2H/T6cN/03HRf9N3In/SdmE/0TY + gP8+1nz/ONR3/zPTdf8v0XH/Ks9u/yXOav8hzGj/HMtk/xfJYf8TyF3/DsZb/wnFV/8Ew1T/AMJR/wDC + Uf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8Aw1T/Lrcq/zBnCLkAAABiAAAANAAAABMAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPu7lZ39vpj//sGb//7D + nf/+xZ///seg//7Jov//yqT//8yq/5O6R/80w0X/N9Z9/z3We/9C13//RtiB/0zbhv9S3Ir/V96N/1vf + kP9g4ZT/ZeKX/2nkmv9u5Z3/c+eg/3fopP986qb/geuq/4Xtrf+K7rH/j/C0/5Pxt/+Y87r/nfS9/6H2 + wf+m98T/q/nH/6/6yv+0/M7/uP3Q/7//1P/H/9r/0P/h/9j/5//K7tn/osK2/3eXkv9ihIH/ZIaD/3CP + j/92lZX/epiZ/3uYmv9ujoz/aYqH/3KSkP91lJT/dpWV/3eWlv95l5f/epiY/3uYmf98mZv/fZqc/36a + nf98mpv/e5ia/3iWlv91lJT/c5KS/3GQkP9xkJD/cZGQ/3GQkP9vj47/bIyK/2iJh/9jh4X/YIaF/3KP + if+zrJ//rrVu/1OrCf9OxUT/Ut6N/03bh/9I2YP/RNeA/z7WfP841Hj/M9J1/y/Rcf8qz27/Jc5r/yHM + aP8cy2T/F8lh/xPIXv8Oxlv/CcVX/wTDVP8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJS/wDC + Uf88sx//HkMGnAAAAFYAAAApAAAADQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA+ruVZP2+mP/+wZv//sOd//7Fn//+x6D//sii///KpP//zKr/lLpH/zTD + RP831n3/PdZ7/0LXfv9G2IH/TNuG/1Lciv9X3oz/W9+Q/2Dhk/9l4pf/aeSZ/27lnf9z56D/d+ik/3zq + pv+B66r/he2t/4rusP+O8LT/k/G3/5jzuv+c9L3/ofbA/6X3xP+q+cf/r/rK/7T8zf+4/dD/vv7V/8b/ + 2v/L/93/0f/h/9v/6P/k/+7/3Pjn/7nTyf+LqaL/aIqF/2qIjf9sjI//cZCR/3CPjv9oiYb/bY2L/3aV + lf93lpb/eZeX/3qYmf97mJn/fJmb/32ZnP99mpz/fpud/3+cnv+AnJ//gJ2g/4Cdn/+AnJ//fpud/3uY + mf92lZX/cJCQ/2iKif9hhoX/aImH/4OXjv+3sZv/8Myu/+/Rmf9drhX/TMVE/1ffkf9S3Yz/TduG/0jZ + g/9E2ID/PtZ8/zjUeP8z0nT/L9Fx/yrPbv8lzmv/Icxn/xzLZP8XyWH/Eshe/w7GWv8JxFf/BMNU/wDC + Uf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8Aw1P/CcBK/0epE/cMGwJ9AAAASAAAAB8AAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9vZcn/b6Y+f7B + m//+w53//sWe//7HoP/+yKL//8qk///Mpv+Ctzv/NMZN/zfWff891Xv/Qdd+/0bYgf9L24X/UtyK/1be + jP9b35D/YOGT/2Tilv9p5Jn/buWd/3LnoP936KP/fOqm/4Drqv+F7a3/ie6w/47ws/+T8bf/l/O6/5z0 + vf+g9sD/pffD/6n5xv+u+sr/s/zN/7f90P+9/9T/xP/Z/8r/3P/P/+D/1f/k/9v/6P/i/+z/7v/2/+v/ + 8v93u1v/UI84/2KHaP9oiIP/aoqN/2qKjv9lh4b/bI2L/3CRj/9zk5L/dpSU/3iWlv94lpf/eZeY/3qX + mP95l5j/d5aX/3WUlP9ykpL/cJCQ/2uNjP9liIf/YIWF/2SHhf9si4f/hZiO/6+tmv/WwaT/+9Ot///Z + sv/y0qH/b7Yr/03ERP9b4ZT/Vt+P/1Hcif9N24b/SNmD/0PYf/8913//NtZ8/zLTdv8u0XH/Ks9t/yXO + av8gzGf/HMtk/xfJYf8SyF3/DsZa/wnEV/8Ew1P/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDD + Vf8cuzr/QZEM3AAAAGUAAAA4AAAAFgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP29lwL8vZfI/sGZ//7Dnf/+xZ7//seg//7Iov//yqb/9Mma/12z + Iv8zzWP/N9R6/zzVe/9B137/RdiB/0vahf9R3In/Vt6M/1rfkP9f4ZP/ZOKW/2jkmf9t5Z3/cuef/3bo + o/976qb/gOup/4TtrP+J7rD/jfCz/5Lxtf+W8rn/m/S8/6D1v/+k98L/qfnH/676yv+x+8z/tv3P/7v/ + 0//C/9f/yP/b/83/3//T/+L/2P/m/93/6f/h/+z/7f/5/6zjmP9GqgH/QpgA/02PF/9Vijj/ZI5c/4Ka + kP9tjIn/Z4mG/2OHhf9ghYT/X4SE/1+EhP9fhYT/X4SE/2CFhP9jh4X/ZoiF/2mKhv9ujIf/e5OL/5Og + k/+rrZr/ybyi/+jMqv/71bD//9qx///Ysf//1a///9a2/7zDbf9JvC7/XuGV/1rgkv9V3Yv/UdyJ/0za + hf9H2YP/QtmE/zzRa/82yFP/Ms9p/y3SdP8pz23/Jc5q/yDMZ/8by2T/Fslh/xHIXv8Mxlv/B8VY/wLD + VP8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMNU/zC2Kf8zbQi0AAAAUwAAACkAAAANAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPu9 + l37+wJn//sOc//7Fnv/+x6D//sih///Lrf+7vmX/Prcl/zHSdP831Hj/PNV7/0DXff9F2IH/StqF/1Hc + if9V3Yz/Wt+P/1/gkv9j4pb/aOOZ/2zlnP9x5p//duii/3rppf9/66j/g+ys/4jur/+N77L/kfG1/5Xy + uP+a87v/oPbB/6f6y/+o+cf/rvzO/7L9z/+0/M3/uf7S/8D/1v/F/9r/y//d/9D/4f/U/+P/2f/m/93/ + 6f/h/+z/5v/x/7vqs/+AzVz/T68R/0KXAP9JjgD/ysuM/+nZvv/QyK3/w8Co/7e4o/+xtKD/srWh/7O0 + oP+ys6D/trah/8O8pP/Owaf/28iq/+3Rr//417L//tqz///ctP//27P//9my///XsP/+1a///tWv//7U + rv//1rb/tsJn/03CPv9e4pf/Wd+P/1Xdi/9Q3Ij/S9qF/0bahf9EyFT/XrUm/3i2NP9PtB3/NMdU/yfQ + cf8kzWn/H8xm/xvKY/8YyF3/FchZ/w7GVP8Cwkv/AcJS/wDDU/8AwlH/AMJR/wDCUf8AwlH/AMJR/wDC + U/8FwU3/Ra8X/RcyBYIAAABCAAAAHAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/b+ZHv7Amev+wpz//sWe//7Gn///yaf/38SG/1i0 + Iv8vylz/MdN2/zbUd/871Xr/P9d9/0TYgP9K2oT/UNyI/1Tdi/9Z34//XeCS/2Lilf9n45j/a+Wa/3Dm + n/906KH/eeml/33qqP+C7Kv/h+2u/4vvsf+P8LT/lPK3/5v2wv+b87v/ddVt/2nGSP9vzFX/o/K1/7T9 + 0P+3/dD/vP/U/8H/1//G/9r/y//d/8//4P/T/+L/1v/l/9n/5f/b/+f/4//y/+H/8P/H88v/ectW/z6Y + AP+1wXL//+rK///mwP//58D//+a////mv///5r7//+S9///kvP//47v//+G5///guP//3rb//9u1///a + tP//2bP//tiy//7Xsf/+17H//taw//7Vr//+1a7//tSu///Vs//by4r/U7go/1rei/9Y35D/VN2L/0/b + iP9J24n/Rs5h/1OrEf/hx4r//tCu/9bFff9PtSH/J81m/yLOa/8dzGj/I8ZU/0axGv9FoAz/XaUe/4u3 + Sv9DtSf/Db5E/wDDU/8AwlH/AMJR/wDCUf8AwlH/AMNV/yK6Nf8/iQzSAAAAXgAAADIAAAARAAAAAgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/L6Ynf7Bm//+xJ7//8ag//7IpP+DtTf/L744/yrSdv8x0nP/NdN2/zrVef8+1nz/Q9d//0na + g/9P24j/U92K/1fejv9c4JH/YeGU/2Xjl/9q5Jr/buad/3PnoP936KP/fOqn/4Drqv+F7a3/ie6w/47w + tf+V9L//heaX/1a+Mv91tzD/zc6K/4a5PP9wz1z/tP7U/7T8zv+5/tH/vf/U/8H/1//F/9n/yf/c/83/ + 3//P/+D/0v/h/9P/4//U/+P/1f/k/9z/8f+38br/Ua0V/9jSl///5MP//OG8//zhvP/84Lv//OC6//3f + uf/93rn//d64//3dt//927b//du1//3atf/92rT//dmz//7Ysv/+2LL//tex//7WsP/+1rD//tWv//7V + rv/+1K7//9Sv//jRpf9jtSf/VNZ1/1ffkf9S3Yr/TtuH/0jciv9Hw0L/V58K//jKoP//0K7//82l/2G0 + I/8nyVv/Ic5r/xzMZ/8byF3/Q7Qf/0ycAP9Xjgn/9LiM/6i1Sf8cuCj/AMNW/wDCUf8AwlH/AMJR/wDC + Uv8BwlD/P7Mc/yFIBpkAAABPAAAAJQAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+wJlE/sGa//7EnP//x6X/2MF+/0az + G/8nzGX/K9Bw/zDRcv8003X/OdR5/z7WfP9C13//R9mD/07bh/9S3Ir/V96N/1vfkP9g4ZP/ZOKX/2nk + mv9t5Zz/cueg/3boo/976ab/f+up/4PsrP+J77H/jfC1/2rSZP9Sshj/p8Nf//vas///38X/0s+K/1y8 + L/+p+MP/svzO/7b9zv+5/tH/vf/U/8H/1//F/9n/yP/b/8r/3P/N/97/zv/f/8//3//P/9//0v/m/63t + r/9suTH/99+3///ivv/84bv//OC7//zgu//93rr//d65//3euP/93bj//dy3//3btv/927X//dq0//3Z + s//+2bP//tiy//7Xsf/+17H//taw//7Wr//+1a///tSu//7Trf//067//9Ov/4e5P/9Ly1X/V+CU/1Hc + if9M24b/R9uH/0fAOv9UnAj/88mc///StP/OxHj/RLUg/yXNaP8hzWj/Hctk/xbKZP8bxlX/RbMZ/0aV + AP/JrGr/t7hZ/xq4KP8Aw1b/AMJR/wDCUf8AwlH/AMNU/xG+Q/9GoRDuBQsBbwAAAEAAAAAaAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP7BmgT9wJnM/8Od///Gpf+Wt0X/Lb00/yPQcP8rz27/L9Fy/zPTdP841Hj/PdZ7/0HX + ff9G2YL/TNuG/1Hcif9V3oz/Wt+P/17gk/9j4pb/Z+OZ/2zlnP9w5p//deih/3nppf996qj/guyr/4bu + sP9hx0v/b7Uq/9XOjf//273//9u3///bt//22a3/Z7cr/5Pqn/+y/dD/s/zO/7f90P+5/tH/vP/T/7// + 1v/C/9f/xf/Z/8f/2v/I/9v/yf/b/8j/2//P/+j/hdh1/4m+R///48L//OC8//zgu//84Lr//d+6//3e + uf/93rn//d24//3dt//93Lb//du1//3atf/92rT//dmz//7Ys//+2LL//tex//7XsP/+1rD//tWv//7V + rv/+1K7//tOt//7TrP//1bb/r8Bf/0a/OP9V4JH/UNyJ/0vbhv9G2ob/RL84/1+gEv/6y6T/7MuZ/2iz + I/8ww0f/I89v/yDMZ/8cy2T/F8lg/w7JY/8qvjn/SqEE/8ytbf+1uFj/Grgo/wDDVv8AwlH/AMJR/wDC + Uf8Aw1X/KLgw/zp8CccAAABdAAAAMQAAABEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPy/mmn/w57/+sSZ/2Oz + I/8kxlT/I89t/yrPbf8u0XH/MtJ0/zfUd/871Xr/QNZ9/0XZgf9L2oX/UNyI/1Tdi/9Z34//XeCS/2Hh + lf9l45j/auSb/2/mnv9y56H/d+ik/3zqpv+C7bD/ctyB/06qDP/fzJL//9u+//7Zs//92rT//tq1///c + uf+IvUX/fdt6/7D90f+w+8v/s/zN/7b9z/+4/dH/uv7S/73/1P+//9X/wP/W/8H/1//C/9f/w//Z/8H+ + 1/9gvzb/wM19///jw//837r//d+6//3fuv/93rn//d65//3duP/93Lf//dy3//3ctv/92rX//dq0//3Z + tP/+2bP//tiy//7Ysf/+17H//taw//7Wr//+1a///tWu//7Urv/+06z//tOs///TsP/kzJH/VLQd/0/X + ef9P3o3/StqF/0Xahv9Avjb/orhR///Rs/+Xukr/M7or/yfQcP8jzmr/H8xn/xrLY/8WyWD/D8hg/xnC + Sf9LqQ3/3bN7/662U/8auCj/AMNW/wDCUf8AwlH/AMJS/wLCUP9Asxz/IkoGmQAAAE0AAAAjAAAACgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA/8KlD/3Dq9y+uWT/PLQa/x7MZf8jzmr/KM9t/y3QcP8x0nP/NtN2/zrV + ev8+1nz/RNiA/0rahP9O24f/U92K/1fejf9c35D/X+GT/2Tilv9p5Jn/beWc/3Hmn/926KL/euml/4Lu + sv9m0F3/QJgA/7C1Y///3L3//tiz//3Zs//+2bT//9u7/5G+TP932HH/rfzQ/6z6yP+v+8v/svvM/7T8 + zv+3/c//uP3Q/7r+0v+7/9P/vP7T/7z+0//F/+H/jOCG/2i1KP/33rb//uC8//3fuf/937n//d65//3e + uP/93bj//dy3//3ct//93Lb//du1//3atP/92bT//dmz//7Ysv/+2LL//tex//7WsP/+1rD//tWv//7V + r//+1K7//tSt//7TrP/+06z//9Ks///TsP+Vu0r/P7sq/0rYfv9H24f/QtmD/z+7LP/Cw2///8+p/2G0 + Jf8rylz/JtBw/yPNaf8ezGb/Gcpi/xXJX/8OyF//HcFG/0qlCv+Eni//ZrEi/xG9Pf8Aw1T/AMJR/wDC + Uf8Aw1T/FL1B/0efDusECgFsAAAAPAAAABgAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAp7JYiWSx + Hv8mwEP/HM1q/yPNaf8nz2z/LNBv/zDRcv8003b/OdR5/z3We/9C13//SNmD/03bhv9R3In/Vt2M/1rf + j/9e4JL/Y+KV/2fjmP9r5Jv/cOae/3TnoP946KT/f+2w/2jSZf9DnAD/XZQU//DSo///27n//diy//7Z + tP//2rf/hrxD/3vbev+p+8z/qfjG/6v5yP+u+sr/sPvL/7P7zf+0/M7/tf3P/7f90P+3/dD/vf/Z/6Hu + q/9RtRz/ys+G///hwv/93rn//d65//3euf/93rj//d24//3ct//93Lb//924///fv///38D//9q1//3Z + s//+2LP//tiy//7Xsf/+17H//taw//7Wr//+1a///tSu//7Urf/+063//tOs//7SrP//0qv//9Ku//PP + ov+HuT7/TbUe/0S+NP9Auy3/Z7Up/+7Mmf/6zaH/VrQf/yrMZP8lzm3/Ic1o/x3LZf8YymL/FMhe/wzI + X/8fwET/TqYL/0qgAP8stib/AcNT/wDCUf8AwlH/AMJR/wDDVP8ruC7/OHgJvwAAAFUAAAArAAAADgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEGvBgRCrQjCKb07/xbKZf8dy2X/Icxo/ybOa/8q0G7/LtFx/zPS + dP831Hj/PNV6/0HXfv9H2IL/S9qF/1DciP9U3Yv/WN6O/13gkf9h4ZT/ZeKX/2nkmv9t5Zz/ceaf/3Xo + ov9766n/deGP/06vE/8/jQD/g6Q6//jWr///3L3//9u5//XXqv9itib/jOid/6P4xv+l98T/qPjF/6r5 + x/+s+cj/rvrK/7D7y/+x+8v/svvM/7b+0v+n9Ln/V7km/6rFZf//4MD//t65//3duP/93bj//d23//3c + t//93Lf//dy3///fvv/42K//ub1x/7C5aP/62LD//9q2//7Ysv/+2LH//tex//7WsP/+1rD//tWv//7V + rv/+1K7//tSt//7Trf/+06z//9Kr///Sq///0ar//9Kt///RrP/dyYn/usFo/7vBaf/uzJn//9Cu//zN + pf90tjH/K8VP/yLPbv8gzGf/G8tk/xfJYf8SyF7/DMdc/xTBTP9Gshj/NrYk/wXBTv8Aw1P/AMJR/wDC + Uf8AwlL/A8FO/0OxGf4gRgaJAAAAQAAAABsAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATrAQBkyv + EdYew1D/FMpl/xzLZP8gzGf/JM5q/yjPbf8t0HD/MdJz/zbTdv861Xn/P9Z9/0TYgf9J2oT/TtuH/1Lc + iv9W3o3/W9+P/1/gkv9j4pX/Z+OY/2vkm/9u5p7/c+eh/3fopP987Kz/YMhM/0eeAP9AiAD/b5wn/8XB + fP/01Kz/usRw/1q9Mv+Y8rn/nvW//6H2wf+k98L/pvfE/6j4xf+q+cf/q/nI/636yf+u+sr/sfzP/2bH + Sf+Ku0T//+DD///duf/93bf//d24//3dt//93Lf//dy3//3ctv//3r3/0MaH/2mcI/8+iwD/OogA/4qo + QP/+2rb//9m2//7Xsf/+1rD//tav///WsP//1rD//9Ww///Wsf//1rT//9a0///Vs///1LH//9Ou///S + q///0ar//9Cq///Rrv//0bL//9Gx///Qq///z6j//8+v/6C7UP8uvDL/IM9v/x7MZv8aymP/Fslg/xHH + Xf8Mxln/B8VX/wfCUP8AwlH/AMJS/wDCUf8AwlH/AMJR/wDDVf8duzj/RJYM2gIEAFEAAAApAAAADgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAT64OgDy3J/8UyWH/Gctk/x7MZv8izWn/J89s/yzQ + b/8v0XL/NNJ1/zjUeP891nz/Q9iA/0jZgv9M2oX/UNyI/1Tdi/9Y3o7/XOCR/2Dhk/9k4pf/aOSZ/2zk + nP9w5p//dOeh/3nqqP935Jn/VLkm/0ibAP9BiwD/RooA/1SRCv9JoQL/cdNo/5r2wv+a9Lz/nfW+/6D1 + wP+i9sH/pPfC/6X3xP+n+MX/qPjG/6v6y/+f8bH/RqsM/42uRP//4L///t24//3ct//93Lb//dy3//3c + tv/927X//9+//83Hhf9ImgH/RKgH/1CyGP9IoAb/P4kA/5mtTv/82LP//9y9///auv//2rv//9i3///V + sP/50qn/7Myb/9LCg//Kv3r/y756/9jDhv/wy53//9Ks///Ts///0Kr//9Cp///PqP//z6j//8+o///P + qP//z63/3MaF/0myGf8iyV3/G8xo/xnKYv8UyF//EMdb/wvGWf8GxFX/AcNT/wDCUv8AwlH/AMJR/wDC + Uf8Aw1P/BcFN/0SyGf8nVweJAAAANwAAABYAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABNsBENUK8N0Cy+Pv8Vy2b/Hctl/yHNaP8mzmv/Kc9u/y7Qcf8y0nT/N9N2/zrVev9C137/RtiB/0ra + hP9O24f/UtyJ/1bejf9a34//XuCS/2LilP9m4pj/auSa/27lnP9x56D/deei/3rrq/914pL/WsE6/0up + DP9GmwD/RaAA/1m9Mv+M7Kv/lPK5/5byuf+Z87v/nPS9/571vv+f9b//ofbB/6L2wv+k98L/p/nI/5nu + q/9LrBD/WJUP//DWqP//3br//du2//3btv/927b//du1///cuv/p1aL/YK8d/1e/M/+D45H/je6u/2bJ + Tv9GmAD/QogA/3GdKP+utmP/ubpt/6myXf+Uqkn/gKE0/2eXHP9SkQf/So4A/0eNAP9IjQD/So0B/1OQ + Cf96oDD/wrty///RrP//0a3//8+o///PqP//z6j//86o///Op///zav/nbpM/zK2IP8ay2T/Fcpj/xPI + Xf8Oxlv/CsVY/wXDVP8BwlH/AMJR/wDCUf8AwlH/AMJS/wDDU/8ttiv/Q5ALygAAAEIAAAAfAAAACgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOrw83SrEV9h/FVf8Yy2b/IMxn/yTN + av8ozmz/LdBw/zHSc/8103X/OdR5/z/Wff9E2ID/SNmC/0zahf9Q3Ij/VN2L/1jejv9c35H/X+CT/2Pi + lv9n45n/a+Sb/2/mnv9y5qD/duii/3vqqv9966j/c92D/2nRYf9v1W//h+up/47wtv+P8LP/kvG2/5Xy + uP+Y87r/mvS8/5v0vv+c9L7/nvW//5/1v/+g9sL/nvS8/1q7LP8/jwD/srlq///fv//927X//du1//3b + tP/+27b/+Nmy/3W3Mf9hylD/lPK6/5Pzvf+Q87v/hOmh/1G0HP9GmgD/QYwA/z+KAP9CjQD/PY4A/z2R + AP9AlQD/RJwA/0mkB/9Kpgr/SqYK/0qkCP9JngD/R5YA/0CMAP9BiQD/hqQ5//DLnv//0Kv//8+o///P + qP//zqf//82m///MqP/3yp//hLY4/zO3I/8WyFz/D8hf/w3GWf8HxFb/A8JT/wDCUf8AwlH/AMJR/wDC + Uf8Aw1X/Grw7/0qjDuwSKARcAAAAKAAAAA4AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABPrQ2APrYn/xjKZP8dy2b/Isxo/ybOa/8r0G7/L9Fx/zPSdP841Hj/PNZ7/0HX + fv9F2IH/SdqE/03ah/9R3In/Vd2L/1nfj/9d4JH/YeGU/2Til/9o45n/bOWc/2/mnv9z56D/duij/3rp + p/9/7K7/hO+0/4fwtf+H7rH/iO6v/4vvsf+O8LP/kvK5/5f1wP+V87n/l/O7/5r1v/+Z87v/mvS8/5v0 + vP+f98X/cNFe/z+ZAP9rmiH/+dix///bt//92rT//dm0///bvP+2xm7/U70w/5Dxtf+Q8bj/jO+y/4ru + sP+I77P/d+CM/1vCPP9OrxT/TawR/06xF/9Styb/Vr42/1nGSf9bzVr/XNNs/1vUcP9Y1G7/VNFn/1DJ + Uf9OvC//TasN/0mYAf84hwD/pa5U///Tsv//z6j//8+o///Op///zab//8uk///Kp//6yKH/j7Y9/zO1 + HP8Rxlf/CcZb/wbEVP8CwlL/AMJR/wDCUf8AwlH/AMNU/wq/Sf9GsBb8KVsIhQAAADIAAAAUAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2wEQhPrw3IL78//xjM + af8gzGf/Jc5q/ynPbf8t0HD/MdJy/zbTdv871Xr/PtZ9/0LXf/9G2IL/S9qF/0/biP9S3Yr/Vt2N/1rf + kP9e4JL/YuKV/2Xil/9p5Jn/bOWc/2/mnv9z56D/duij/3rppf986qj/f+up/4Lsq/+F7a3/h+2v/4zx + tv+H6qb/atJl/1zBPP9fw0D/huaZ/5fzvf+W8rn/l/K5/5n1wP+I5pn/S6wO/0uRAv/gzJb//9u5//3Z + s//+2bT//tm1/3+5O/9t1m//kfS9/4rusP+I7q//he2t/4Lsq/+B7a//fOup/3Pjk/9u34n/b+OV/27k + mv9s5Jv/aeaf/2bln/9i45r/XuKX/1rhlP9W4JP/UuCT/07djP9K0Wn/Rrgj/2mqI//kxY///9Cs///P + qP//zqf//82n///Mpf//y6T//smi///Ipf/6xqD/j7U9/zK1Hf8JxFb/A8NV/wDCUf8AwlH/AMJR/wDC + Uv8BwlH/OLQj/z2CCrUAAAA9AAAAGwAAAAgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAE6vDzZKsRX2IcZW/xvMaP8izWj/Js5r/yvPbv8v0HD/M9J1/zjU + eP881Xr/QNd+/0TYgP9I2YL/TNuG/1Dcif9U3Yv/V96O/1vfkP9f4ZP/YuGV/2bjl/9p5Jr/bOWd/3Dm + nv9z56D/duij/3nppf986af/fuuo/4Hrqv+H8LX/duCK/1O3JP+AuDn/vMd1/5W7SP9fxUX/kfK5/5Hx + tv+S8bb/kvG3/5Tyuv9gxUL/TpwG/+XMmv//27j//tmz///Ztf/z1ab/YLYm/37ll/+L77P/hu2u/4Ts + rP+B7Kr/f+uo/3vppv946aX/dumm/3Popf9w56D/bOWd/2jkm/9l45f/YeGU/17gkf9a35D/V+CT/1Le + jv9M2H//RtFr/0HOYf86wTv/U7MX//DNm///0Kv//86n///Op///zab//8ul///Ko//+yaL//seg///G + ov/7w53/hrQ2/ye2JP8Bw1X/AMJS/wDCUf8AwlH/AMNV/yS5Mv9ImwzdBxACTAAAACMAAAALAAAAAgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE+t + DYA+tyf/Gstl/x/MaP8kzWr/KM9s/yzQb/8x0XP/NtN3/zrVef8+1nz/Qtd//0XYgf9J2oT/TdqH/1Dc + if9U3Yz/WN+O/1zgkP9f4JL/Y+KV/2bjl/9p5Jr/bOWc/2/mnv9y56D/deii/3jopP966ab/f+2u/2/d + gv9euCn/ysl9///Ytv//28L/0MuD/1zAOv+K7rD/jfCz/43wsv+O77P/kvS+/23Vbf98tjb//dez///Y + s//+2LL//9m3/9XMif9ZvDD/g+yq/4Ttrv+C7Kv/gOup/37qqP976ab/d+ik/3Toof9y56D/b+Wd/2zl + nP9o5Jn/ZeOX/2LilP9e4JL/W+CR/1fej/9MzWD/Rb41/1K1If9otiv/gLg7/427Rv+wwWX//M+m///P + qf//zqf//82m///Mpv//y6T//smi//7Hof/+xqD//sSe///Dof/wv5D/arIi/xe6NP8Aw1T/AMJR/wDD + VP8RvkP/S6oR9h5EBm0AAAAsAAAAEQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATbARCE+uDcgwv0D/Gs1r/yHNaf8lzmz/KdBv/y7S + c/8y1Hn/NtV9/zrXf/8/1n3/Q9d//0fZgv9K2oX/TtuH/1Lcif9V3oz/Wd+O/1zgkP9f4ZP/YuGV/2bj + mP9p5Jn/bOWc/2/mnv9x56D/dOeh/3jppf915Zz/Trch/73Fb///2b3//9ax///YuP/HyHr/WsE8/4bu + rv+J7rD/iO6w/4nusP+O87z/XMpR/5m/Uf//2bv//9ey//7Xsf//2bv/q8Jg/1nGR/+D7rH/gOuq/37q + qP986qb/euml/3foo/9z56H/cOaf/27lnf9r5Zv/aOSZ/2Xjl/9h4pT/XuGS/1vfkf9X3o//TcNB/2qz + JP+vv17/48qQ//nPpP//z6j//9Ct///Qr///z6n//86n///Op///zab//8yl///Ko//+yKL//seg//7F + nv/+xJ3//sKb///Aof/UunT/RbEV/wbASf8Aw1X/BcFO/0CzG/82dwmVAAAAMgAAABYAAAAGAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAATq8PNkqxFPgrwkr/H8xm/yLNaP8mzWf/LMxh/zHHUv86xUv/QMdT/z3Tdv9A137/RNeA/0fZ + gv9L2YX/T9uH/1Ldiv9V3o3/Wd+O/1zgkP9f4ZP/YuGV/2Xjl/9o5Jn/a+Sb/23lnf9w5p7/deqo/1zP + YP+AuDj//9az///Wsf//1rD//9m8/52+Uf9byE3/he+z/4PsrP+E7az/iPC2/3Hbf/9Ssxr/1s2M///Y + t//+17D//9ex///Xtf+Ku0P/YNBh/4Husf986qb/euml/3jopP926KL/c+eg/2/mnv9t5Zz/auSb/2fj + mf9k4pf/YeGV/17gkv9b35D/WOGU/1DPY/9UrBD/68uV///Ttf//0a7//8+q///Pqf//z6n//8+o///O + p///zqf//82m///Mpf//y6T//8qj//7Hof/+xqD//sSe//7DnP/+wZr//r+Z//+9nf+Xs0L/I7ci/wDD + VP8vtyr/R5oLvQAAACsAAAAXAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATrAPT02wENlCtiP+QLcn/0y1 + Iv9ctCP/gLg8/3KvKP9MrAn/Pstf/zzXf/9B137/RNh//0jZg/9L2ob/TtyH/1Ldiv9V3oz/Wd+O/1zg + kf9f4ZP/YeGV/2Til/9n45j/auWc/23nov9x66v/UMI//7HCY///17n//tWv///Yuf/OxYD/VbAX/3Dd + hP+A7a//f+up/4Lvs/9u237/TrIX/77Gc///2Lf//9aw//7Wr///1rH//NWt/3i5OP9n2Xj/e+yr/3fo + pP926KL/dOeh/3Lmn/9v5p7/a+Wc/2nkmf9m45j/ZOKW/2HhlP9e4JL/W9+Q/1jejv9V35L/TMND/1af + Cv/4y6H//9Gs///PqP//z6j//8+o///PqP//z6j//86n///Npv//zab//8ul///Ko//+yaL//sef//7F + nv/+xJ3//sKb//7Amv/9vpj//7yZ/+y4hv9ksST/NbQe/0qqENshSwcvAAAAEAAAAAcAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAS7AOD1SsE0HEvm2r5cSL//jKn//wx5b/aqse/0G5K/830nT/OtV6/z7W + fP9B137/RNeA/0jZg/9M2oX/TtuH/1Lciv9V3Yz/WN6O/1vfkP9e4JL/YOGU/2Tkmv9l4pb/W9Vx/1HL + U/9QtR7/18uJ///Vs///1rX/zcOA/1CmCf9ayU7/euur/3rppf997a//a9p7/06yFv++xnL//9i5///V + sP/+1a///tWv///Vsf/506n/bbgx/2ndhP926qb/c+eh/3Hmn/9w5p7/buWd/2vkm/9o45n/ZeKX/2Lh + lf9g4ZT/XeCS/1rfkP9X3o3/VN2M/1Hdjf9MwDz/TZkD/97Civ//0rD//8+o///PqP//z6j//8+o///O + p///zqf//82m///Mpf//y6P//smj//7Iof/+xp///sSd//7CnP/+wZr//b+Z//28l//9upT//7mc/4CC + QJk2hAVzL2wKLAAAAAcAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPrI + ngr/yqm6+smi/4C2Nv85uiv/MNFx/zPTd/8303f/O9V6/z7WfP9C137/RdiA/0jZg/9L2oX/TtuI/1Hc + if9U3Yz/V96O/1rfj/9e4ZX/W9h8/0+6K/9utSv/j7pF/8bHef//1LD//9W0/+HMk/9VqhH/VcVF/3Pn + of916aT/eOur/2bYeP9Oshb/vsZy///XuP//1a///9Ww///Wsv//1bD//9Ww//nTqP9ltin/Z92F/3Ho + ov9v5p7/beWc/2vkm/9p5Jr/ZuOY/2Tilv9h4ZT/X+CT/1zgkf9Z34//Vt6N/1Tdi/9R3In/Td2N/0zF + Rv9DmAD/jqU////Rrf//0Kn//8+o///PqP//zqf//86n///Npv//zKX//8qk///Ko//+yKL//seg//7E + nv/+w5z//sGb//3Amf/9vpj//buV//24k/+8iHKbAAAAKQAAABEAAAAFAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/LtRDVwHy/O7gm/yfPbf8s0XP/MNFy/zTT + df841Hf/O9V6/z7WfP9B137/RNiA/0jZg/9L2oX/TtuH/1Hcif9T3Yv/Vt6P/1jbh/9JtR7/nbpO//vS + q///07L//9Sz///Tr//z0aP/b7Qq/1LGR/9v56L/b+eh/3HopP9g1W//UrMa/77Fc///1rf//9Su///W + sv/806z/5suY//7Urv//2r//28uM/1O2I/9p4pT/bOWd/2rkm/9p5Jn/Z+OY/2Xil/9i4pX/YOCT/13g + kf9b35D/WN6O/1XejP9T3Iv/UNyJ/03bh/9K3Yv/SstX/0ujBP9BigD/vrdr///Ssf//z6j//86n///O + p///zab//8yl///LpP//yqP//smi//7Hof/+xp///sOc//7CnP/+wJr//b6Y//28lv/9upP/vIhsmgAA + ACkAAAARAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAH6zM1YvwUL/ItF0/yrPbv8t0HD/MdJz/zTTdf841Hf/O9V6/z7Wff9B13//RNiA/0fZ + g/9K2oX/TduH/1DciP9T3o//UtNs/0KkAv+nr1b//9W4///SrP//0qv//9Oy/8fGd/9Pwj7/Z+Wd/2nl + nP9r5qD/YNd1/1iyG//NyH///9a3///Urf//1rT/6cua/3SdKf9JjQb/f6I0/6qzYf9rrSH/VcdM/2rm + n/9n45n/ZuOY/2Tilv9j4pX/YeGU/17gkv9c35D/Wd+P/1fejf9U3Yv/UtyK/0/biP9M24b/SdmE/0bZ + hP9F1Hb/TLUd/z+TAP+OpT///9Gv///OqP//zqf//82m///Mpf//y6X//8qk//7Jov/+yKH//sag//7F + nv/+w5z//sGa//2/mf/9vZf//bqU/76LbpgAAAAmAAAAEQAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAR64INEa1IP8oymD/JNBw/yvP + bf8u0HD/MdJ0/zTTdf831Hf/OtZ9/z3YgP9A2IP/Q9iA/0bYgv9J2YT/TNuG/0/ejv9Q0Wj/R6UG/16V + FP/yzJ3//9W1///TsP//1bn/tsRs/1TTbf9j5Jz/ZOOX/2Xjl/9GuCT/n7lR///Xu///06z//9Sy/+rL + mv9qpSD/P5wA/0eYAP9BjAD/PpcA/0u2IP9k343/ZeOZ/2Lilv9h4ZX/YOGT/17gkv9d4JD/W9+Q/1je + jf9V3Yz/U92K/1DciP9O24f/S9qF/0jZg/9G2YL/Qtd//z/Ygv9Cy1v/QqgF/5CoQf//0K3//86o///N + pv//zKb//8yl///KpP/+yaP//seh//7GoP/+xZ///sSd//7Bm//9v5n//b2X//u6lPy7iG2NAAAAIgAA + AA8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABNsBEBT68Nika1IP8pyl//JdBw/yrPbv8u0HD/MdJz/zPUef85zGD/PL0y/0DI + U/8/13//Qtd//0XZg/9H2ob/SNh//03Xev9NsRn/Qo4A/3edKv/UwoX/4saP/+PGk/+evVn/Utd1/17h + lv9g4pb/XtuD/0WrC/96oi7//9Ov///Vsv/60ar/ebIw/0a3IP9az17/Ubwv/02vE/9SvjP/XtqD/2Hj + mP9f4JP/XuCS/13gkv9b35D/Wt+P/1jejv9W3o3/U9yK/1Dcif9P24j/TNqG/0rZhP9H2YP/RdiB/0LX + f/8/1n3/PNZ8/zrUd/8/sRf/kaxB///Prf//zaf//8ym///Mpf//y6T//smj//7Iof/+x6D//sWf//7E + nf/+wpz//sCa//29mP/3uJLzrYBleAAAAB0AAAAMAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATq4Nd0iz + G/8ryFr/JNBx/yrPbv8s0XP/Msxi/1GzHf+fukr/YLQi/zzOZf8+2IH/Qtd9/0XBQP9Psxv/S788/0zA + Pf9MoAL/Q4oA/0qNAP9PjwT/T4wE/06iD/9X2n7/WuCT/1zhk/9a2oH/Ta4S/0ONAP+crE3//dSy/5O7 + Sf9Iuyv/Xt6M/2Hknf9f4JH/Xd6J/17gkv9e4ZX/XN+Q/1vfkP9a34//WN6O/1fejf9V3Yz/VN2L/1Hc + iv9P24j/TNuG/0vahP9I2YP/RtiC/0PYgP9B137/PtZ8/zvVev841Hn/NtN0/z6xGP+Rq0H//86s///M + pv//zKX//8uk//7Jo//+yKH//seg//7Fn//+xJ3//sKc//7Bmv/9vpj/7rGN45FrVV4AAAAaAAAACgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATq4Nc0iyGv8ryFr/JNBx/yjRcv83vDH/ortP///R + uP+PuUP/N8VH/znYhP9BwDv/gLYy/9rHiP9wtS7/Q8pX/0y7Lv9MpQf/SqAD/0mgBP9JnwD/TLUk/1Td + iv9V3o3/Vt6O/1jfjv9Quy7/SJgA/0WJAP+CqDT/U7gl/1fchv9b4ZX/Wt+P/1rgkf9a4JH/Wd+Q/1je + jv9Y3o7/Vt6N/1XdjP9U3Yv/U92K/1Hcif9P3Ij/TduH/0vahf9I2YP/R9mC/0TYgP9C137/P9Z9/z3W + e/861Xn/ONR4/zTTd/8z0XH/PrEY/5GrQP//zav//8yl///KpP/+yaP//sih//7HoP/+xZ///sSe//7D + nP/+wZv//r+Z/+GohspjSjtFAAAAFwAAAAgAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAATq4Nc0iyGv8qyFv/JM5q/0q0HP/ixon//8+x/5O6R/8zxEj/N9Jx/0KsCv+nslX//9W9/4W6 + P/89zFv/RdiA/0nLW/9Kylb/S8tY/0zKVv9N02//UNyK/1Hcif9S3Ir/VN+Q/1LTb/9NsRb/SJYA/0OQ + AP9NtyX/Vt2K/1bejv9W3Yz/Vt6M/1Xdi/9V3Yz/U92L/1Pdiv9S3In/UdyJ/0/ciP9O24f/TNuG/0va + hf9J2oT/R9mB/0TYgP9D13//QNd+/z3WfP881Xr/OdR4/zbTd/8003X/MdJ0/y/Qbv89sRf/kqtA///M + qv//yqT//smj//7Iof/+x6D//sWf//7Env/+w5z//sGb//7Amf/jq4nEIxoVLAAAABMAAAAHAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATq4Nc0e0Hf84uSn/erU18/7L + pf//zaz/lbpH/zDDRf84zGD/SqYJ/1GPB/+hq1D/brIq/z7LWv9A2YT/Q9qF/0Tah/9G24j/SNuK/0rb + iP9L2oX/TduG/07bhv9O24f/T96P/0/Rav9NsRb/SZgB/0uhBf9Pw0P/Ud2M/1Hdif9R3In/UNyJ/1Dc + iP9P24f/TtuH/03bh/9M24b/S9qF/0rahP9I2YP/R9mC/0TYgf9D137/Qdd9/z/WfP881Xv/OdV5/zjU + eP8103b/M9J0/zDRcv8t0XL/K89s/zywF/+Sqj///8up///Jo//+yKH//seg//7Fn//+xJ7//sOc//7B + m//9vpn82KKCoEc2KycAAAAOAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAATq8PTEGsAn6csFUs+Mapc/7LrOyzvV7/N7sv/zHPa/9MrxT/SZIA/0GQ + AP9KrRD/PtBq/zzXfv8+13//P9mE/0DZhP9C2YX/RdmC/0fZgv9I2YP/SdmE/0rahP9L2oX/S92M/0vQ + aP9NsRf/S54A/02tDf9N1nf/TdyJ/0zbhf9M2oX/S9qF/0vahf9K2oT/SdmD/0jZgv9G2YL/RdiB/0TY + gP9C13//QNd+/z7WfP871Xv/OtV5/zjUd/8203b/NNJ0/zHRc/8v0XH/LNBv/ynQb/8ozmn/O7AW/5Cp + Pv//yqj//8ii//7HoP/+xZ///sSe//7CnP/+wZr/8baS1rSIbVoAAAATAAAACAAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/8uoJ+jGj6RWsx//Lctg/znFTf9LsBX/S7AV/z7ESv811Xz/N9V8/zrPZ/85xEX/Qb84/0fE + Sf9B1Xn/QtiA/0PYf/9F2ID/RdiB/0bYgv9H2YL/R9uI/0jScP9Lvjf/Sr86/0jXff9I2oT/SNmD/0fZ + gv9H2YL/RtmB/0XYgf9E2ID/Q9iA/0LXf/9B137/P9Z9/z7WfP881Xv/OtV5/zfUeP8203b/NNN1/zLS + c/8w0XL/LdBw/yvQbv8oz23/Jc5s/yTNZ/88sRf/qLFU///Kqf/+xqD//sWf//7Enf/+wpz/+LyW7dej + gotEMykeAAAACwAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGaxIoBCtR3/LM1n/yzQ + bf8wz2v/LtR7/zLPav86vDL/V7Md/5O6SP+YtkX/TqwK/z7OZf8913//P9Z9/0DXff9A137/Qtd+/0LX + fv9D13//Q9mD/0PZgv9D2IL/Q9iB/0PXf/9D13//Q9d//0LXfv9B137/Qdd9/z/Wff8/1n3/PdZ7/zzV + e/871Xr/OdR5/zfUeP8203b/NNN1/zLSc/8w0XL/LtFx/yzQb/8pz27/J85s/yTOav8hzWn/Hstj/0e0 + H//cwYD//8ek//7Fnv/+w5z//MCa+eWujKaadV44AAAADQAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEquCIxGtSH/Lspe/yrPb/81xEv/R7MZ/5K5RP/myZX/+M2l/4W3 + Of8/uzD/N9R3/znUef861Xr/O9V6/zzVe/891nv/PtZ8/z7WfP8+1nz/PtZ9/z7Wff8/1nz/P9Z8/z7W + fP8+1nv/PdZ8/zzWe/881Xr/O9V6/zrVef851Hj/ONR3/zbTdv8103X/M9N1/zHRc/8v0XL/LtFw/yzQ + b/8qz27/KM9s/yXOav8jzWn/IMxn/xzNav8fxVL/W7Mf//TElv//xKD//MGb9+myj6y2i29DAAAADQAA + AAUAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2u + DnpMsRPlRrIY9VqwGdzJwXT3/82s///OsP+Xukv/NLoo/zHSdf8z03f/NdN1/zbTdv831Hf/N9R3/zjU + eP851Hj/OdR4/zrVef861Xn/OtV5/zrVef861Xn/OtV5/znUeP841Hn/N9V7/zXWff811Xr/NdN3/zTT + dv8z03T/MtJz/zHSc/8v0XH/LdBw/yvPb/8qz23/KM9s/ybOa/8kzWn/Icxo/x7LZv8azGj/Gspi/zS2 + If+juVH/+sGg6uexj523jXE9AAAACwAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE6wEA9HrgohZaMpCvrHozL9yqeL/sqk3IC3 + OP8ywUD/K9J1/y3Sdv8w0nP/MdJ0/zLSdP8z03T/NNJ0/zTTdf8003b/NdN2/zXTdf8103X/NdN1/zXT + df810nX/NNN3/zPTdv80ylv/NMNE/zPIVv8w0XH/LtN4/y7Rc/8t0XH/LNBv/yvQbv8pz23/J85s/yXN + a/8jzWn/Is1n/x/MZv8dzGb/F8xo/x7HWf86tiH/ZaUi1cieen+GZ1QqAAAACgAAAAMAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/zKsLlrlNVkKuCNlDuSn/NMdW/yrRcv8s0HD/L89s/y3S + dP8u0nT/MNFy/zDRcv8w0nL/MdJz/zDSc/8x0nP/MdFy/y/Tdf8xz23/Pbkr/2ezJv+OuUL/bbQq/0C2 + IP8ww0T/Ks5p/yfRc/8nz2//Js9r/yTOav8izWn/Icxo/x7MZ/8czGb/GMxo/xbLZf8nwUj/R7IZ/z6U + BZ0cJw0lAAAADgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAQq4HD06sDGVNrxLTQbov/0O5K/9Lsxz6Pr44/y3NZ/8p0XT/K9Bw/yzQb/8s0G//LNBv/yzQ + b/8r0XL/Lc5q/zq3If+Ntz3/8sqd///Nq//5yqD/xcBw/3u1Mv9GtBz/L786/yjKYP8gzmz/HM5t/xvN + av8cy2b/HMpi/x3IW/8owUj/O7gr/0yrEN9AjwtnAAAAEgAAAAkAAAADAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2wEBBNrAtbVa4TVGCo + ITRMqwigR7Qe/zPFT/8nzmv/JNBx/yXQcP8m0G//JNFy/yjNZ/8/tyT/jrc///vKpP//y6n//8qk///L + pv//y6v//8mk/9LCe/uHtTr0S7EX9zu6L/80vjz/Nrw3/z24K/9DtB/7SbAW8EyqD8NJoAx1LmgJGwAA + AAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNrQ5XTq8OzkS2JP84vj7/MMRP/yzG + Vv80wUb/Q7Ue/1KiE7DPrIJz6Lmabe++mWn0wZ1n9MGdafPAm2DxvppL7b2jObOnax5How0oTKwLaE+r + C4JOqgx/S6YMYEedDTo8iAwWDyMDBQAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABNsBAHTq0OT06tDJFNrxC7S68S0E2rDaxFoQtbAAAACQAAAAUAAAACAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP////////////////////////////////////////////AAAf//gA/////////////A + AAB//gAH////////////gAAAP/AAAB///////////wAAABAAAAAAAD////////4AAAAAAAAAAAAAP/// + ///8AAAAAAAAAAAAAAA//////AAAAAAAAAAAAAAAAP////gAAAAAAAAAAAAAAAAP///4AAAAAAAAAAAA + AAAAAH//8AAAAAAAAAAAAAAAAAAP//AAAAAAAAAAAAAAAAAAAf/wAAAAAAAAAAAAAAAAAAB/4AAAAAAA + AAAAAAAAAAAAH+AAAAAAAAAAAAAAAAAAAA/gAAAAAAAAAAAAAAAAAAAD4AAAAAAAAAAAAAAAAAAAA8AA + AAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAA + AAHAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAA + AAAAAAABwAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAAAAAAHwAAAAAAA + AAAAAAAAAAAAH8AAAAAAAAAAAAAAAAAAAH/AAAAAAAAAAAAAAAAAAAH/wAAAAAAAAAAAAAAAAAAA/8AA + AAAAAAAAAAAAAAAAAP/AAAAAAAAAAAAAAAAAAAB/wAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAA + AD/AAAAAAAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAAAAAAD+AAAAAAAAAAAAAAAAAAAA/gAAAAAAAAAAAA + AAAAAAAH4AAAAAAAAAAAAAAAAAAAB/AAAAAAAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAAAAAAD8AAAAAAA + AAAAAAAAAAAAA/gAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAD/gAAAAAAAAAAAAAAAAAAA/4A + AAAAAAAAAAAAAAAAAAP/AAAAAAAAAAAAAAAAAAAD/4AAAAAAAAAAAAAAAAAAA//AAAAAAAAAAAAAAAAA + AAP/wAAAAAAAAAAAAAAAAAAD/4AAAAAAAAAAAAAAAAAAA/+AAAAAAAAAAAAAAAAAAAP/gAAAAAAAAAAA + AAAAAAAD/4AAAAAAAAAAAAAAAAAAA/+AAAAAAAAAAAAAAAAAAAP/gAAAAAAAAAAAAAAAAAAD/wAAAAAA + AAAAAAAAAAAAA/8AAAAAAAAAAAAAAAAAAAP/AAAAAAAAAAAAAAAAAAAD/wAAAAAAAAAAAAAAAAAAA/8A + AAAAAAAAAAAAAAAAAAP/AAAAAAAAAAAAAAAAAAAD/wAAAAAAAAAAAAAAAAAAA/8AAAAAAAAAAAAAAAAA + AAP/AAAAAAAAAAAAAAAAAAAD/wAAAAAAAAAAAAAAAAAAA/8AAAAAAAAAAAAAAAAAAAP/AAAAAAAAAAAA + AAAAAAAD/wAAAAAAAAAAAAAAAAAAA/8AAAAAAAAAAAAAAAAAAAP/AAAAAAAAAAAAAAAAAAAD/wAAAAAA + AAAAAAAAAAAAA/+AAAAAAAAAAAAAAAAAAAP/gAAAAAAAAAAAAAAAAAAD/4AAAAAAAAAAAAAAAAAAB/+A + AAAAAAAAAAAAAAAAAAf/gAAAAAAAAAAAAAAAAAAH/4AAAAAAAAAAAAAAAAAAB//AAAAAAAAAAAAAAAAA + AAf/wAAAAAAAAAAAAAAAAAAP/8AAAAAAAAAAAAAAAAAAD//AAAAAAAAAAAAAAAAAAA//4AAAAAAAAAAA + AAAAAAAf/+AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAD//8AAAAAAAAAAAAAAAAAA///AAAAAA + AAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAH//+AAAAAAAAAAAAAAAAAB///wAAAAAAAAAAAAAAAAAf//4 + AAAAAAAAAAAAAAAAAP//+AAAAAAAAAAAAAAAAAD///wAAAAAAAAAAAAAAAAB///8AAAAAAAAAAAAAAAA + Af///gAAAAAAAAAAAAAAAAP///8AAAAAAAAAAAAAAAAH////AAAAAAAAAAAAAAAAB////4AAAAAAAAAA + AAAAAA/////AAAAAAAAAAAAAAAAf////wAAAAAAAAAAAAAAAH////+AAAAAAAAAAAAAAAD/////wAAAA + AAAAAAAAAAB/////+AAAAAAAAAAAAAAA//////4AAAAAAAAAAAAAA///////AAAAAAAAAAAAAAf///// + /4AAAAAAAAAAAAAP//////+AAAAAAAAAAAAAH///////gAAAAAAAAAAAAD///////+AAAAAAAAAAAAD/ + ///////wAAAAAAAAAAAB////////+AAAAAAAAAAAA/////////wAAAAAAAAAAAf////////+AAAAAAAA + AAAf/////////+AAAAAAAAAAP//////////4AAAAAAAAAP///////////AAAAAAAAAP///////////4A + AAAAAAAP////////////AAAAAAAAP/////////////gAAAAAAP/////////////+AAAAAAH///////// + /////4AAAAAH///////////////8AAAAP////////////////gA///////////////////////////// + ////////////////////////KAAAAGAAAADAAAAAAQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAB+fn4Bfn5+An5+fgN+fn4Dfn5+A35+fgN+fn4Dfn5+A35+fgN+fn4Dfn5+A35+fgEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfn5+An5+ + fgR+fn4Ffn5+BX5+fgN+fn4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAOjo6AgAAAAoAAAATAAAAGQAAABsAAAAbAAAAGwAAABsAAAAbAAAAGwAA + ABsAAAAbAAAAGQAAABIAAAAKKysrAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAACsrKwMAAAALAAAAFAAAAB4AAAAiAAAAIQAAABsAAAARAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAAAAGQAAADUAAABIAAAAVAAA + AFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAVQAAAEkAAAA0AAAAHQAAAAkAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAJAAAAEwAAACQAAAA3AAAASgAAAFwAAABiAAAAYgAA + AFcAAABCAAAAKQAAABQAAAANAAAACwAAAAgAAAAFAAAAAwAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAkAAAAfEhIRTCkoJ4cqKSiZLCsqoSwrK6IsKyuiLCsroiwrK6IsKyuiLCsroiwrKqMnJiWdERAQjAAA + AHgAAABmAAAASQAAACAAAAAKAAAAAwAAAAUAAAAIAAAACQAAAAcAAAAIAAAADQAAABoAAAArAAAAPQQG + DWIMFieODxwwqBEdM7QOGy6xChQjpQAAAIUAAABzAAAAXAAAAEIAAAA5AAAANAAAAC0AAAAoAAAAIgAA + ABsAAAAWAAAAEQAAAAsAAAAJAAAABgAAAAQAAAADAAAAAgAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABwgIBAYFBSA6ODd0aGVk0IuIh+6LiIfxd3Vz8nd1c/J8eXfye3h38nt4 + d/J7eHbye3h38nt4dvJ4dnTwbGlo5TExMLMBAQGLAAAAcwAAAEYAAAAkAAAAGAAAACEAAAAqAAAAKwAA + ACcAAAApAAAANAAAAEoECA1qESA3oh41W9okQG7xI0Z4+SNKfvolSXz3JEFw8xIiPMoBAgWaAAAAiQAA + AHoAAAB0AAAAcAAAAGoAAABjAAAAXAAAAFEAAABIAAAAPwAAADQAAAArAAAAIgAAABcAAAASAAAADgAA + AAsAAAAKAAAACQAAAAcAAAAGAAAABQAAAAQAAAADAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdXV0CCAgHGGhmY6GopKP55OPi//78 + /P/99vT/6OPh/6Cfnv+Fg4H/iYaE/4mHhf+Jh4X/iYeF/4mHhf+Jh4X/iYaE/4WCgPxUUVHQCwsLlwAA + AHQAAABYAwMDUgcHB2UCAgJuAAAAbgECAm0EBw15ChIgkxsxVM4kQW/1JkZ4/ydKfv8gU4z/G1iW/xta + mf8dW5r/JVyZ/ypQhf0wSWbqSF9f3UFVU9Q3SUfMKDU0wBkhILURGBesDRIRpQYICJsAAQGRAAAAiQAA + AH4AAAByAAAAZgAAAFQAAABGAAAAOwAAAC4AAAAmAAAAIAAAABsAAAAZAAAAFgAAABMAAAARAAAADwAA + AA0AAAALAAAACgAAAAcAAAAFAAAABAAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAADAwMNTk1Lc66tq/rw8fH+/Obh/fnCrv/5v6X9/MKp/+7Bsf2pnpn9h4aF/Y2Lif+Mi4n9jIuJ/Y6L + iP+Mi4n9jIuJ/Y2KiP+Gg4D5SkhHygAAAI4kIyObSUdGuFdVUshHRUPCJisvtRgpPsUeNVrcJEFw9idI + ev4pS33+K0yA/yZWj/0fXZz9H1+f/yFhof0gYqP9IGOl/yljov4tU4j+Tm1//2uMh/5oiof+Z4iF/WKC + f/hbeHbyU21r6kRaWOA1RUTTJTEwxxQcG7YDBASnAAAAnQAAAJAAAACEAAAAdwAAAGUAAABXAAAASwAA + AD0AAAA2AAAALwAAACoAAAAnAAAAJAAAACAAAAAdAAAAGgAAABYAAAAUAAAAEQAAAA0AAAALAAAACAAA + AAUAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmJgEsKylEi4mH2vL08//42M79+KyN/f3ZsP/97ML9/enA//zJ + ov3qo4j9mYeB/Y2NjP+Sj439ko6M/ZKOjv+Sjoz9ko6M/ZKPjf+QjYz+goB++FJQT9J3dXPvioeC+3V4 + gP5NXnf8Lkhw9ydGdvwoSXv+KkyA/ypPg/0tUof9LlaM/yRioP0kZaX9JmWm/yVmqP0laar9J2ms/yZs + sP0sZqX9MVN+/4Kenf2Bnpv9epiV/3STkP5ujYv+aYqH/2aIhf5khYL9YIB9+Vp2dPNIYF7nLz491g4U + FL8AAACwAAAAqAAAAJ0AAACRAAAAhAAAAHEAAABjAAAAWAAAAEwAAABEAAAAPwAAADoAAAA2AAAAMgAA + AC0AAAApAAAAJQAAACAAAAAcAAAAGAAAABMAAAAPAAAADAAAAAgAAAAFAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8ODhp+e3mu1tnZ//fY + zP/5r4r//uzC///70f//+M7///jO///80f//3rX/4Jh6/4eEhP+Vk5L/lpSS/5aUkv+VlJL/l5ST/5eV + k/+WlJL/joyK/4mGhP+Ni4r/UmJ8/yBBdv8jRnn/KEt//ytQhf8tU4n/L1aN/zBakf8yW5P/MGOf/yls + rv8rba//LG+y/yxus/8scbX/LXK3/ytyuf8wdrz/KlqZ/2+Hlv+etbL/m7Ox/5qysP+Ysa//lq6s/4yn + pf+EoJ7/eZeV/3CQjf9rjIn/aIuI/2aHhf1Wc3HyO05N4xceHs0KDg3DAAEBtwAAAKsAAACfAAAAkQAA + AIEAAAB0AAAAaQAAAF4AAABaAAAAVQAAAFAAAABMAAAARwAAAEEAAAA7AAAANgAAAC4AAAAoAAAAIwAA + ABwAAAAXAAAAEgAAAAwAAAAIAAAABQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAD89PEuoqKft7ern/viri//93bP9/fXM/f/zyP/99Mj9//PI//3zyP3+9sv9/dGn/aOD + eP+RkZD9mpiX/ZmYlf+amJb9mpiW/ZSSkP+Mioj9h4SC/ZaTkP9xeYf9Kkl5/SlOgv8sUob9LlOJ/S9Y + j/8vW5P9MV6X/zRhm/01Yp39MWur/y5ytv0ucrb9MHW6/y92uv0xdr39MHm//zB4wf0xfMP9NHS4/05o + h/2ZsK79m7Gx/5uxsf2bs7H9nLOy/520sv2cs7L9m7Kx/5WurP2LpaP9f5yZ/XKSj/9ri4j+aIqH/mB/ + fflNZmPuMkFB3xQbG8wCAgK/AAAAtgAAAKoAAACcAAAAjgAAAH4AAAB0AAAAbQAAAGgAAABkAAAAYAAA + AFwAAABXAAAAUgAAAEsAAABFAAAAPgAAADUAAAAuAAAAJwAAAB4AAAAYAAAAEQAAAAsAAAAHAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH17d5rMzc7/88W3//3Blv//88f///DE///x + xf//78X///HF///vxf//8cb///PH/9Kghf+QiYj/npya/5+cm/+em5r/kI2L/4aDgf+EgoD/jImH/5ya + mv9OYYD/KE6C/y9Xjf8wWpD/MF2V/zNfmP8zY53/Nmaf/zZppf84aqj/NXS1/zN5vv81ecD/NHrC/zZ9 + wv82fsT/Nn7H/zZ/x/81gMr/OoPL/0Fhiv+RqKr/nbWz/5uzsf+bs7H/nbWz/5yzsf+cs7H/nbWz/520 + s/+dtLL/nLOx/5evrv+Pqaf/gp6c/2+PjP9niYb/ZIWC/Vp2c/ZCWFbpHScm1QAAAMIAAAC6AAAAsQAA + AKIAAACTAAAAhwAAAHwAAAB1AAAAcQAAAG8AAABsAAAAaAAAAGQAAABfAAAAWQAAAFIAAABLAAAAQwAA + ADcAAAAvAAAAJgAAABsAAAAUAAAADQAAAAYAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaWhnDpeW + levl2NT++KmJ/f/rvf/97cD9/e2+/f/twP/97b79/+3A//3tvv397L79/u7B/e/Sqf+hjIL9nZyb/aSh + oP+TkY/9iIWD/ZKPjf+LiIb9m5mX/ZaYnP85Vn/9LlmR/TNgmf80Yp39NGSg/ThppP85aqj9Om6s/zpx + sP09c7L9Onu//zqAx/05gsn9O4PL/zmEzP05hc79O4bO/zuI0f06h9H9QI3Y/ztjlf2JnqT9oLa1/5+2 + tP2ftrT9n7a0/5+2tP2ftrT9n7a0/5+2tP2dtLT9nrW0/Z61tP+etbP9n7W0/Zyysf+Qqaj9fpqY/m6O + i/9piof+aYqH/lJsafIoNDPcDBAPzQAAAL8AAAC1AAAAqQAAAJoAAACMAAAAhAAAAH4AAAB8AAAAegAA + AHcAAAB0AAAAcQAAAGwAAABmAAAAYQAAAFgAAABQAAAARgAAADoAAAAtAAAAIQAAABQAAAALAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAcnBuRrKysf/vyb7++rqS/f/uwP/96Lr9/ei6/f/ovP/96Lr9/+i8//3o + uv3+6Lv+/um7/frjt/+4nYr9nJmZ/aakov+Sj479lpKQ/ZqXlv+QjYv9p6Si/ZKWnv8zVYX9MmKd/Tdo + o/84aKX9OW2q/Ttvrv88c7D9PHS1/z94uf1Aebv9QIHE/z2Hz/0/iNH9PonR/z+K0v0+i9X9QIzX/0CM + 2P0+jdj9RJXh/zllm/2Fm6P9ori2/5+1tP2gt7X9oLe1/6C3tf2gt7X9oLe1/6C3tf2gtbX+nra1/Z+2 + tf+ftrP9nbS0/Z61sv+etbT9nLOy/ZOsqv+FoJ79dZOQ/WiKh/9khIH8UWpo8ScyMdsKDQzKAAAAvgAA + ALMAAACmAAAAmQAAAI4AAACHAAAAggAAAH4AAAB9AAAAewAAAHkAAAB2AAAAcgAAAGwAAABmAAAAXwAA + AFQAAABIAAAAOgAAACcAAAAYAAAADQAAAAQAAAAAAAAAAAAAAAAAAAAAVVNRfcrHxv/zu6b9/c+i/f/n + uf/95rb9/ea2/f/muP/95rb9/+a4//3mtv395rf9/ea3/f/mtv/OspX9mZWT/aeko/+XlJL9oZ+e/aKg + n/+TkY/9sK6r/ZOYov8yVon9Nmqm/TpvrP86cLD9O3Oy/T54uP8+ebv9QX29/0J+wP1BgMT9RIXK/0KN + 1v1Cjdf9RI7a/0SP2/1EkNr9Q5Hc/0OT3f1Dkt/9SJnn/zxnm/2Kn6X9o7m3/6C2tf2gtrb9oLi1/6C2 + tf2gtrX9oLi1/6C2tf2gtrX9obe1/Z+2tv+ft7T9oLW1/Z62s/+ftLP9nrW0/Z61s/+cs7L9mbCu/Yej + oP9zko/+Z4mF/mKBfvtPZ2XwJC8u2QAAAMQAAAC7AAAAsgAAAKcAAACdAAAAkgAAAIgAAACBAAAAfgAA + AH4AAAB9AAAAewAAAHkAAAB1AAAAcQAAAGkAAABfAAAAUgAAADwAAAApAAAAFwAAAAgAAAABAAAAAAAA + AACurawIeXZ0tt3V0f/3s5P//tmq///is///4rP//+Kz///hsv//4rP//+Gy///is///4rP//+Gz///j + s//ix6H/mpON/6Wjov+em5r/rqyr/66rqv+YlpT/t7a0/56jq/83XI7/O3Gx/z53t/8/erv/QXy+/0J/ + wv9DgsX/Q4TJ/0aHzP9Hic//SIrR/0iT3f9JleD/SZbi/0mX4/9JmOT/SZnm/0ma5v9Imej/TJzr/0Bj + kP+Uq63/pLq4/6K4uP+jubb/o7m4/6O5uP+jubj/o7m4/6O5uP+jubj/o7e4/6O5tv+it7f/ori3/6G4 + tv+gt7b/nrW0/5+2tf+etbT/nbSz/561s/+csrH/jqim/3STkP9pi4j/aYuI/0xlY+8VICzbBgoUzwEC + BMQAAAC7AAAAsQAAAJ4AAACPAAAAhAAAAH8AAAB/AAAAfwAAAH4AAAB9AAAAfAAAAHkAAAByAAAAaAAA + AFIAAAA7AAAAIwAAAA0AAAADAAAAAAAAAAC4t7UeiomHz+XRy//4s439/tuq/f/fr//93a39/d2t/f/f + r//93a39/9+v//3drf393a79/d2t/f/gr//w0aX9oZWL/aOhof+lo6L9uLa1/bi2tf+dmpn9ube2/bGz + t/9BYpD9PHa3/UF+wP9Cf8P9QoPF/UWGyv9GiM39RonP/0mN1P1Kj9f9SZDY/0yU4P1Nmub9TZzo/02b + 6f1Nnen9TZ7q/0yd6/1OofD9R5Hf/1Bri/2lurn9p7y7/6W7uf2kurn9o7m4/6O4t/2juLf9pLq5/6S6 + t/2iurf9ori3/aK4uP+jubj9o7e2/aK3t/+guLX9oba2/aC3tP+ftrP9nrW0/Zyzsv+dtLH9nLSy/Zau + rf+HoqD9c5KP/WiJhv9NbXz9Iz5m9hQnROcHEBzTAAABwwAAALUAAACiAAAAjgAAAIEAAAB+AAAAfwAA + AH8AAAB+AAAAfgAAAHwAAAB4AAAAbgAAAFoAAABBAAAAKAAAAA8AAAAEAAAAAAAAAAC6t7Yzl5aW2+nL + wf/7to39/tqp/f/bqv/926j9/duo/f/aqv/926j9/9qq//3bqP3926j9/dqo/f/cqv/616f9qJqK/aKg + of+sqqn9wsDA/cTCwf+joaD9ube2/cfGyP9TbZP9O3e4/USFyf9Ehcr9RYjN/UiM0f9IjdT9So/X/0qT + 3P1Lk939TpXg/0+Y4/1Rnuv9UaHu/1Gg7v1RovH9UKPw/1Ci8f1UqPf9N3Cz/1Buev1/npn9iqaj/5uz + sf2mu7n9qb++/6m9vP2mu7v9pbu6/6W5uf2lubj9o7m5/aS6uf+kurf9ori3/aO5uP+ht7b9ori3/aC4 + tf+ft7b9nrW1/Z22s/+ctbP9m7Ox/Zyzsf+asrD9lq2s/X6bmP9piob9P2N9/htDeP4ZQGz3DSM64QAA + AMMAAAC0AAAAnAAAAIYAAAB/AAAAfwAAAH4AAAB9AAAAfAAAAHgAAABzAAAAaQAAAFUAAAA+AAAAJQAA + AA4AAAAEAAAAAAAAAAC7ubhGoaKj5O3Bsv/8vI7//9im///XpP//2KT//9il///YpP//2KX//9ik///Y + pf//2KX//9il///Ypf//2KT/tKCL/6SjpP+zsbD/zszL/9LR0P+1s7L/rauq/93c2/+Dj6X/OGyp/0mN + 1v9JjtT/SpDY/0yR3f9Nld//TJXh/0+Z5P9Qm+f/T5vq/1Cf6v9Tou7/VKPz/1Wm9v9Vp/f/Vqj5/1Wp + +v9FiM//N1qB/1Z8dv9NdXH/SnJu/0lybv9TeXX/Y4eD/36cmf+Rqqn/n7a1/6a7uv+nvLv/p7y6/6S6 + uf+kurr/pbu6/6W5uf+iurf/o7i4/6O5uP+iuLf/obi1/6C3tv+ftrP/nrWy/520s/+cs7D/m7Kx/5ux + sP+KpaL/cJCN/yBUgf8TTYL/E1KG/wYkO98AAADAAAAArwAAAJMAAACDAAAAeQAAAHYAAAByAAAAbgAA + AGgAAABhAAAAVQAAAEIAAAAvAAAAGgAAAAoAAAACAAAAAAAAAAC8u7pSpqqq6u26p//9wZj9/dqv/f/Y + qv/91KL9/dOg/f/UoP/91KD9/9Sg//3UoP391KD9/dSg/f/UoP//1aH9vKWL/aemqP+3trT91tXU/dzb + 2v/Ny8r9npyb/eXk4v++wsj9PmGP/UmQ2f9MlN79TZTe/U+Y4/9OmOT9UJro/1Ge6f1Qnuv9UaDu/1Oj + 8v1VpvX9Vqr6/1aq+v1Up/j9UJ/t/0B+w/08YIv9Z4SL/3uZlf14lpT9dpWS/3CQjf1miIX9W4F8/1F4 + dP1QdnP9WX98/3GRj/2PqKb9o7m3/aq/vP+nvbv9pbq5/aS7uv+jubj9pLq5/aK6t/+jt7j9ore3/aG4 + tf+gt7T9n7a1/Z61sv+btLL9nLOw/Zmwr/+ZsK/9layo/VB+kv8LU4j9DFWK/gpIc/MHDhLKAAAAuQAA + AKIAAACKAAAAdgAAAGYAAABgAAAAWgAAAFIAAABIAAAAPQAAACsAAAAcAAAADwAAAAUAAAAAAAAAAAAA + AAC+vLtbq66w7u21oP/9wpr9/tqx/f3ZsP/+1ar9/tCf/f3Pn//+0J/9/dCf//7Qn/3+0J/9/tCf/f3P + n///05/9w6mL/aepq/+wraz929va/eXk4//m5eX9paOg/dDPzv/v7e39hJGo/S9oqv9QnOf9T5vn/VCd + 6f9Rnuv9U6Hu/1Oj8/1VqPf9Vqr7/1Sm9v1Nmuf9Q4bQ/zlxs/00Y539N16O/0tqhP1tio79e5mW/3yb + l/1/nJr9gZ6b/4Ofnf2Dnp39gp6c/36bmf11lZL9Z4mG/1N6dv1MdXH9W4F8/YGenP+dtbP9rL+9/ai9 + vP+mu7r9pbm4/aO5uf+iuLf9o7m2/aG3t/+htrb9oLe0/Z+2s/+es7P9m7Ky/Zuxsf+Ysa79mbCu/YOj + qP8bZZP9AVmR/glcj/0xVmHpDREPwgAAAKwAAACWAAAAeQAAAFoAAABJAAAAPwAAADUAAAAsAAAAJAAA + ABcAAAAOAAAABwAAAAIAAAAAAAAAAAAAAAC+vbxcqa2v7u+vmP/9xJv//tav//7Vrf/+1a7//tKn//7M + mv/+y5r//syb//7Mmv/+zJr//sya//3Lmv//zZv/wqaK/7Cxs/+rqKf/ubi3//T09f/29fX/4+Hh/6Kg + nv/t7Ov/+fj2/2l9nv84b6//S5fk/0+f7P9Mmuj/SpTg/0aJ0P8/ebn/OWmh/zZdiP88XHn/SGd5/1x4 + gf9riov/eJWT/3+dmP9+m5n/fpua/4KenP+DoJ7/haGf/4aioP+HoqH/h6Oh/4ejof+Io6H/iaSi/4mj + ov96mJb/ZIeE/0t0cP9Lc2//YISC/4ulo/+ftrX/p726/6a8u/+ju7j/pLq3/6S5uP+ht7f/obi1/6C3 + tv+dtrP/nrWz/520sv+bsa//mbGv/5ewrf9Eg6D/AF6U/wFelv82do//X3x59BYeHb0AAQGhAAAAiAAA + AF4AAAA9AAAAJwAAABkAAAATAAAADQAAAAcAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAC+vLtcp6us7uyv + mP/9w5v9/NWw/f7Vrv/80679/NSv/f7Oo//8x5j9/seW//zImP38yJj9/MiY/f7HmP//yZj9wqSI/bS0 + tv/Ixsb9nZmY/dLR0P/5+fn9/f39/bi2tf+/vbz9+vr6/ejq7v+Il7L9THOj/UZ1rf9Td6X9T2eM/0Bg + dv1EZnX9T3F3/11/f/1pioj9cZOO/3aWkv15l5T9fJmX/32amP2BnJr9g5+d/4Whn/2FoqD9iKKg/4mk + of2KpaP9iaWk/4ulov2LpaL9iaSi/4mlo/2KpKP9iKSi/YGcmv9wkI39Wn98/U51cf9cgX79fJmY/Z21 + s/+ovbz9pbu6/aO5t/+jubb9ore3/aG2tf+etbX9n7S0/Zyzs/+as7D9mbCw/Zuxr/9qlqb9C2CU/QBc + lP8jao/9ZIiG/ll1c+0hLSy7AQIClQAAAHMAAABKAAAAJgAAAA4AAAAGAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC/vLtao6em7eiwm//9v5z9/NWz/f7Vs//807P9/NOz/f7Usv/8z6n9/Maa//3C + k/39w5P9/cOU/fzFlP//xZX9v6CG/bi5u//X1dX9ysjH/ZyamP+urKv9ysnH/bu5uP+OjIr9vLm4/fT0 + 8v/s6uv9z9DV/b/DzP+0srX9e4GA/1Z8d/1dgn79ZIeC/2qMiP1vkI39cpKR/3iVk/16mpf9f5qa/4Cc + mv2EoJ79hqKg/4iioP2Io6H9i6ak/4ylpf2Np6T9jqam/46mpv2Opqb9jqem/42lpP2LpqP9i6Si/Yql + o/+Io6H9haCe/XeWk/9eg4D9SnNv/Vd7eP9/nJr9o7m5/ai8u/+kurj9orm2/aK4t/+ft7T9nra1/Z61 + sv+btLL9m7Gx/ZqxsP+JqKv9HGmW/QBZkf8XZJP9Z42R/WiIhf5cenfwIi0stAAAAIYAAABoAAAAPQAA + ABMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC9vLpMm5yd5+Kxn//8vZz//ta4//7W + tv/+1rf//ta3//7Wtv/+1rj//tW2//zOqv/9x5///cOZ//zAk//+wJD/tpqE/8TFx//a2dj/2djX/9fW + 1f+9u7r/qaem/6yqqP+8urn/nJmY/5GQjv+ysK//ube2/5+fm/9yfnz/V3p2/1qAff9hhYL/ZYiF/22N + i/9zk5D/eJWU/3yamP9/m5n/gZ2d/4ahn/+IoaH/iKSj/4ympP+Np6X/jqim/4+pp/+QqKj/kaqo/5Gq + qP+Rqqj/kaqo/5CpqP+Pp6f/jqim/42npf+LpKT/iaSi/4ijof+HoqD/gJ2b/2KFgv9Kcm7/UXh0/4Sh + n/+gt7X/pbq5/6K4uP+guLX/obe0/5+2tf+cs7P/nLOw/5uysf+bsq//Q36b/wBVjv8HWo//aJKh/3yZ + lv9piYb/ZoeE+SEtLLAAAQGHAAAAZwAAADMAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAC9u7pAlJWU4dmxo//6uJn9/de8/f7XvP/81br9/NW6/f7XvP/81br9/te8//zXvP391rv9/NS3/f7Q + r//8xZ79rZSE/c/P0f/d3Nz929rZ/d3c2//e3dz93Nzc/d7d3P/h4OD9rquq/VZwbP9geHT9Znt3/Vx3 + dP9TeHX9Vnx4/1+DgP1liIX9a42K/3GRjv12lZP9e5mX/4Cdm/2Dn579hqGg/4mjof2KpaP9jKaj/42m + pf2Op6b9j6io/5Gpqf2Sq6j9kauq/5Gqqv2Rqqr9k6qq/5KrqP2Rqqn9kKio/Y+npf+Mp6T9jKak/Yqj + of+GoZ/9haGf/YKenP91lJH9XoJ//Ux0b/9kh4P9j6mn/aa8u/+jubb9oLa2/aC1tf+etbL9m7Ky/Zmx + sf+ds7D9Z5Kj/QBTjP8EVYz9SX6a/Zarp/94lpT9aYuH/lp4de0cJiWsAAAAhAAAAFgAAAAsAAAADQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+vbwtjY2M186wpf/5s5T9/de+/fzXwP/82L/9/Ni//fzX + v//82L/9/Ne///zXv/382L/9/NjA/f3Zwf/20bj9pZiP/dzc3P/g4N/9397f/d/e3v/f3t79397f/d/g + 3v/g39/9op+e/Uxybv9QeXX9UXh0/VF6dv9Ue3f9Wn97/16Cf/1egn/9X4OA/16Cf/1gg4D9YoWC/2qM + if1wkI39d5aT/4Kenf2KpaP9j6mn/5Ssq/2TrKr9k6uq/5Osqv2UrKv9lKuq/5Otqv2Trar9k62q/5Sr + q/2TrKv9kquo/ZGqqf+Pqab9jKam/YympP+KpKL9h6Kf/YSgnv+BnZv9fJqX/WuNif9Rd3P9THRw/YCe + nP+kubj9o7i3/Z+2tP+dtrT9nbOz/ZqysP+cs7D9hqSq/QdXjP8EVIr9Lm2T/ZatqP+MpqT9d5SS/meI + hf1Ub2zkDxQToAAAAHgAAABNAAAAIgAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+vbwShYKBxb+u + p//xqpD//tbB//7bxv/+2cb//tnG//7Zxv/+2cb//tnG//7Zxv/+2cb//tnG//7cx//nyLX/pp2Y/+bm + 5f/l4+T/5eTi/+Xl5P/l5OL/5eTi/+bl5f/f3dz/kJGQ/093c/9Tenb/Unl1/053cv9MdHD/SnJv/0py + bv9NdHH/T3Zz/1J4dv9UeXf/U3l3/1B3dP9OdnP/THVx/0lybv9LdHD/VXp3/2GFgv9xkY7/gZ6b/46n + pv+UrKr/lq6t/5iwrv+Xr63/la2t/5aurf+VrKz/lK2r/5Osq/+Qqan/kKmo/46opv+MpqT/iaKi/4ai + oP+Bn53/f5ya/3yZl/93lZP/YoWC/0Zva/9ihYL/lK2s/6O5uP+gtbT/nLWy/5y0s/+bs7H/nLOv/yBi + j/8GUoj/E1mL/4ynp/+Qqab/jKak/3KSj/9oiYb/VnFv5AUHBpQAAAB0AAAARwAAABZiYmIDAAAAAAAA + AAAAAAAAAAAAAAAAAAC/vbwBf3x6o66mo//mpIz9/dK9/f7ezP/83Mr9/N3K/f7dzP/83cr9/t3M//zd + yv383cr9/NzK/f7ezP/Yuqv9rqmn/e7t7f/o5+f96ejm/enn6P/p6Ob96Ofm/erq6f/Y1dX9foeF/U54 + dP9Pd3P9SXJu/Utyb/9YfXv9ZoaH/3GRkv13lZb9e5ia/36bnP2AnJ79gJ2e/36bnP19mpv9fJqb/2aI + hv1egn79YIOA/1V7d/1Qd3P9TnZy/1V7d/1ihoL9dJKR/4iiof2UrKv9mrCv/5iwr/2Vraz9lK6r/ZWr + rP+Tq6n9kaqp/Y6pqP+Np6T9i6Oi/Yajov+EoZ/9gZ6c/X2Zl/95l5X9dJSR/WOHg/9NdHD9VXx3/ZGq + qf+ht7b9n7Sy/Zu0sf+asrD9oLax/TpylP8IT4b9C1GH/Xubov+Sqqf9jael/YWhn/9vj4z9aYqH/zdJ + SMYCAgKKAAAAZgAAAC0AAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlZKRb56cmv/Wnov9/cex/f7i + 0//839D9/N/Q/f7f0P/839D9/t/Q//zf0P3839D9/N/Q/f7g0f/Hqp39wb+9/fHw8P/s6+v97Ovr/ezt + 7f/s6+v97Ovr/e7t7f/Lycj9b4B9/Ul0cP9Gb2v9VHl3/XKSkv98mZv9gJye/4Gdn/2BnZ/9gp6g/4Ke + oP2DnZ/9hJ+h/4Sgov2FoaP9hqGj/2yMiv1xkY79fZqY/3qYlf12lJH9b5CM/2OFgv1We3j9THVx/0x0 + cf1Zfnv9cZCP/42opv2ZsbD9mLCv/ZaurP+Uq6v9kaqq/ZGqp/+NqKf9jaal/Yiko/+GoqD9g5+c/X2a + mv96mJb9dZWS/W+Qjf9liIT9TnVy/VR7dv+Qq6n9oLa1/Zyzs/+asrD9n7ax/VWCmv8NUIX9CE2E/WWM + nf+UrKj9jKim/Yulo/9/nJr9aoqI/l58evEdJyasAAAAfgAAAEkAAAAcAAAABAAAAAAAAAAAAAAAAAAA + AAAAAAAAnZqZKY6Njf26nJP/9KuP//7p3v/+5Nj//uXZ//7l2f/+5dn//uXZ//7l2f/+5dn//uXZ//TY + y/+zm5L/29vb//Py8v/y8fH/8vHx//Ly8v/y8fH/8vHx//Hw8P+urq3/WXVy/0lxbv9miYj/gZ6f/4Ge + n/+BnZ//gJ6e/4KdoP+Bn5//gp6h/4Sgov+Dn6L/hKGj/4Wiov+Io6T/hKCg/2eIhf94lpP/g6Cd/4Gc + m/9/nJr/fpuZ/32amP97mZf/eZaT/2yNif9cgX3/THVx/0lxbf9egn//fJqX/5Cqqf+Wraz/lK2s/5Gr + qv+QqKj/jqim/4ukov+Go6H/hKCf/4Cbmf98mZf/d5aU/3CQj/9sjYr/ZomF/052cv9dgn7/la6s/561 + tP+bsrH/nrOx/3KWo/8TUoT/DEyC/0x5lP+Sq6j/jqim/4qmpP+JpKL/epiV/2iJhv9Ra2nhDRAQmgAA + AGkAAAA2AAAADwAAAAAAAAAAAAAAAAAAAAAAAAAA0M/PAYSCgdKhmpj+4Zd8/f7d0P/86uH9/One/f7p + 3//86d/9/unf//zp3/386N79/u3j/eW9rv+wopz97u7v/fb29v/29PT99vT0/fb29v/29PT99vb2/ezr + 6/+MkpD9SW5p/WeJiP+BnJ79gJ6f/YKdoP+BnaD9g5+f/4Keof2EoKD9haGi/4Sgof2HoqL9hqOj/4ei + pf2Kpab9gp6e/2eIhf1+m5j9iKOh/4agn/2EoJz9gZ2c/3+bmf19mpj9fZqY/3uZl/15l5T9dJOQ/2iK + h/1WfHn9S3Rv/Vh9ev9ykI/9iqWj/ZWsq/+Rqqn9j6em/Yympf+HoqL9haGf/YGcmv99mpj9eJeT/XOR + kP9tjov9Z4mG/V6Cf/9Lc2/9YIOA/Zy0sv+dtLP9m7Ox/YCfp/8eV4b9D0uA/Tprjf+Qqaf9j6im/Yym + pP+JpKL9haGf/W2Niv9mh4P6Ljw7vAAAAHsAAABPAAAAHjw8PAIAAAAAAAAAAAAAAAAAAAAAAAAAAH98 + en+SkpH/upWI//+4n//+7eX//uzk//7s4//+6+P//uzj//7q4//+7eT//+zi/8aVhP/CwL//+/r7//r6 + +v/6+vr/+vr6//r6+v/6+vr//f39/9TS0v9neXb/Unh2/4KeoP+CnqD/g52f/4Keof+EoKD/g5+i/4Sh + o/+FoKL/hqGk/4ijo/+IpKX/iqOm/4qmpv+Np6n/gJ2c/2iIhf+FoJ7/jaem/4mlov+HoqD/h6Gg/4Wh + nf+Dn53/gJya/36cmP98mZj/fJmX/3qXlf92lJL/bo6L/1p/fP9Lc2//T3Zy/3WUkf+Pqaf/kaqp/4yn + pP+Jo6P/hqKg/4Kdm/9+m5n/eZaV/3KTkf9uj4z/aIqH/2CFgf9Ve3f/RG5q/3OTkP+dtLP/nLOx/4yn + q/8sXoj/EUp+/zBgiP+IpKX/kKqn/4ulo/+KpKL/h6Kg/3qYlv9oiof/Wnd16gAAAIoAAABkAAAAMQoK + CggAAAAAAAAAAAAAAAAAAAAAAAAAAJaUkiiHhILVlJWV/tiUfP/9yLX9/uvk/f7r5P/86+P9/uvj//7s + 5P3+6uD99LSe/Z+RjP/p6+z9+/v7/fv7+//7+/v9+/v7/fv7+//8/Pz9/Pv7/ZOVk/9QcW39cZKS/YSg + ov+DoKD9hZ+i/YSho/+FoqL9h6Gk/4ijo/2JpKX9iqWm/4mkpf2Mpab9jKen/42nqP2Qqar9fpua/2uL + iP2MpqT9kqup/46opv2OqKb9jKel/4qjo/2Ho6D9h6Kg/4OfnP2Bn5v9gZ6b/3+amv17mpj9e5iW/XqY + lf90k5D9YoaB/Ulxbf9QeHT9cpKQ/Yumpf+KpaP9h6Kg/YGfnf9+mpn9epiU/XOUkf9vj4z9aYqH/WGF + gf9Zfnr9UHh0/UhxbP98mpf9nLSy/ZStrf89aYz9FUl9/SdXg/9/nKH9kKqo/Yulo/+IpKL9h6Kg/YKf + nf9vj4z9aYuI/yo3NrMAAAB4AAAASQAAABJ+fn4BAAAAAAAAAAAAAAAAAAAAAPLy8gefnZtyiYeF8KGP + iv/UmYT9+cOu/f7g1f/+6eL9/ujh//7Yyf3wt6L9t4h4/cLDxP/w8PD98O/v/fDv7//u7+/97+/v/fDv + 7//w7+/9xMPD/Wp8ef9af3v9gJ2e/Yaho/+FoKL9hqGk/Ymipf+IpKT9iaOk/4ukp/2Lpab9jKan/42n + qf2QqKr9kKmq/5Oqrf2UrK39epiW/26Oi/2TrKr9lq+t/5Ssqv2RrKr9j6mp/4+ppf2MpqT9iqak/4qj + of2Io6H9haKe/4Sgnv2CnZv9fp2Z/X6al/98mpf9e5iW/XGQjv9egn/9Unl1/V+CgP91lJL9hKCe/YSf + nv99mpj9epiW/XWUkf9vjov9aYmH/WKFgf9YfXn9U3p2/Utzb/9Uenb9i6ak/Zqxsf9NdJH9GEh8/SJQ + f/93lZ79kaqo/Y2npf+Ko6H9hqGf/YSgnv94lpT9aYqH/ktjYdoGCAiIAAAAVgAAABp/f38DAAAAAAAA + AAAAAAAAAAAAAAAAAADy8vEMmJWTm4iHhf+Ti4j/tY5//+qdgv/6rpT/+quP/9mWff+fg3n/qaWk/+Tk + 4//i4eH/4uHg/+Lh4P/i4eD/4eLg/+Xk4//CwsH/nJOL/22Lhf9wkY//hqGj/4ijpf+JpKT/iaWm/4ym + p/+Lp6j/jqin/42nqP+Qqan/kams/5Gsq/+Ura3/lq6u/5avrv+YsLD/eJaU/3KSkP+asrD/nLSy/5iy + sP+Yr63/lq+t/5Otqv+Tqqr/kamp/4+pp/+MpqT/jKWi/4ilo/+Io6H/hqCf/4KgnP+Cnpz/f5uZ/3+b + mP98mZf/eJWT/12Cf/9Kcm7/XIF+/4GdnP+AnZr/epeW/3WUkP9vkI3/aYuI/2KFgP9Yf3v/Unl1/1J5 + df9IcGz/XoJ//5+0s/9fgZf/HUl6/yFLe/9sjJr/kqqn/4ympf+LpaP/iKOh/4Sgnv9/nJn/bI2K/157 + efAcJiWeAAAAXgAAAB9+fn4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a1BYF+fLaFgoH4hIWF/oeF + hP+Rg3/9kIV//4SFhf2mpqX92NbW/drZ2P/a2dj92tnY/drZ2P/Z2Nf919XV/bW1s/+nl4z988ah/Zue + j/9sj4/9iaSk/Yump/+Lpab9jqan/Y+pqP+QqKr9kamr/5GrrP2UrK39la2u/5Wtr/2YsLD9mLCw/5yz + s/2bs7P9dJSS/3eVkv2htrX9oLe1/560tP2dtLL9m7Ox/5mxsP2YsK79lq+t/5Stqv2SrKr9kaup/4+p + p/2Lp6X9i6Si/Ymkov+HoZ/9hqGf/YKenf+Anpr9gJya/YCbmf9xkI79T3dz/U93c/9ykY79eZiV/XSS + kf9tj4v9aYqH/WGEgf9XfHn9Unl1/VN6dv9Qd3P9RG1p/Ymkof9vjZ39IUl6/SFJef9mhZb9kaqn/Y2n + pf+Jo6H9iKOh/YOenv+Cnpv9cpGP/mKCf/UmMzKrAAAAYQAAACJ/f38FAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAK+urR9+fXyKg4B/5YKAf/9/f3/9fX5+/5mYl/22trb9urq6/bq5uv+4ubn9uLm5/bq5 + uf+0srL9p6Of/bagjv/rv539/9Cm/ZygkP9oi4v9iqWl/Y6oqf+Oqar9kaqr/ZGqrP+TrKv9k6ys/5au + r/2Wrq79ma+v/5mysv2csrL9nrW1/6C2tv2gtrb9dpWT/3eWk/2lurj9pLq4/6K3t/2ft7T9n7az/52z + s/2as7D9mrKv/5ivr/2Vr6z9la6s/5Ksqf2Rqaf9j6mn/Y2mpP+KpqT9iqOh/Yijn/+GoJ/9g6Ce/YGd + m/+BnZv9epiV/VJ4dP9NdHH9aYqI/XSTkf9sjYz9aIqH/WGEgf9XfHj9Unl1/VN6dv9SeXX9Rm9r/WyN + iP95k5/9Jkh3/SJEdf9hgZf9kayp/YympP+Jo6H9iKOh/YOenv+Cnpv9d5WS/mOEgfcqNzaxAAAAYwAA + ACN/f38FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5e3wNonZjqMeYgv+6lYL/uJWD/72b + if+9nIr/vJ2L/7yfjP+8n43/vaCO/72hj//HqJL/4LaY//jJov//zKX//9Cn/6Gjkf9kiIb/iKOj/5Kr + rP+TrKv/k6yu/5aur/+Vrq7/mLGx/5qwsP+as7P/nbS0/520tP+ft7f/obm3/6S6uv+lurn/d5aU/3iX + k/+ovbv/qL28/6a6uf+jurn/o7m4/6C2tf+gtbX/nbW0/5u0sf+bsbH/mLGu/5iurv+Urqz/kqup/5Cr + qf+QqKb/jaim/4unpf+LpaL/iaKi/4ein/+FoZ//gJ2a/2aIhf9Tenf/SHFu/2mKh/9tjoz/Z4mG/16D + gP9WfHj/Unl1/1N6dv9Tenb/THRw/1h9ef97mJ//LVqL/yVhmv82b6D/cJCe/4+ppv+LpaP/h6Oh/4Ke + nf+Cnpz/eZeU/2SGg/ksOjm0AAAAZAAAACN+fn4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADNqJge9aN9zf+uiP//sov9/7WO//+5kv3/vJT9/76X/f/Cmv//xJz9/8ae/f/IoP//yqL9/sqj/f/L + pf/9y6T9/9Gn/bSrl/9jhoP9epeW/ZevsP+WrrD9mbGv/Zqwsv+bs7P9m7S0/520tf2gt7b9ori2/6K4 + uf2mu7v9p7u8/6m+vv2qvr79eJaT/3mWk/2rwL/9rMC//6q+vf2pvbz9p7y7/6S7uv2kurf9o7e4/6G3 + tv2gtrX9nrW0/5y0sv2asrD9mbCt/Zevrf+Vrqz9k6yp/ZCrqf+Qqab9jqim/Yympf+JpKL9cpGO/WuL + if9/m5z9ZoiF/UdxbP9fg3/9ZYiF/V6Cff9Ve3f9UXh0/VN6dv9ReHT9UXh0/Uhzcf9AfKD9KF2V/SVJ + e/8dPG39S2iE/ZKtp/+Jo6H9haGf/YSgnv+BnZv9epeV/maHhPotPDu2AAAAYQAAACJ/f38FAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsRjZG+qmE4/yvif/6sYv9+7SO//u3kf37upX9+72W/f7A + mf/8wZv9/MSd/f7Gof/9yKH9/cuk/f/MpP/9zKX9/8+o/ce1m/9mh4X9aoqI/ZWtrv+bs7P9m7S0/Z61 + tf+etbb9oba2/6O5uf2jubj9pbq7/6i9u/2qv779q8C//6zBwP2rv7/9eZaT/3iVk/2qvbz9rMC//6zA + v/2rwL/9qr++/6m8u/2mvbr9pby7/6W5uP2iubj9ori3/6C3tf2etbL9m7Ky/Zmysf+Zsa79lq6u/Zau + rf+Uq6v9kqqq/ZCqqP+BnZv9Z4iF/XeVlP+GoaP9hJ+i/V6BgP9Kcm79XIB9/VyBff9Uenb9UXh0/VN6 + dv9ReHT9Unl1/UZxcv8oWYT9IEJ0/SBFdf8bQ3b9UXCK/ZKrpv+Io6H9h6Kg/YSgnv+BnZv9eZaU/mWG + g/ksOzmzAAAAXQAAAB9/f38EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACrcldr+62G9Pyx + i//8tI7//beQ//26lf/9vZf//cCZ//7DnP/+xJ7//sWg//3Jov//yaL//8yl///Np///zqf//8+o/9y+ + oP9xjYn/ZomG/4Cdm/+gtrX/oba3/6G5t/+kubj/pry7/6a9vP+pvr3/q8C//6zAv/+swcD/rMC//6u/ + vv+pvrz/eJaT/3WVkf+kubj/p728/6q+vv+rwL//rMHA/6zAv/+rwL//qr+8/6e8vP+lvLv/pLu6/6S6 + t/+it7f/n7e0/5+0tP+ctLH/nLOw/5qysP+Xr63/lq+t/5GqqP9wj43/a4uI/4eio/+HoqT/haGj/4Cb + nf9Yfnz/SnFt/1l/e/9Tenb/U3p2/1N6dv9Tenb/U3p2/0hycv8oWYL/Gkl8/xlMff8SSX7/TXKM/5Kr + pv+Jo6H/h6Kg/4KenP+BnZv/d5WT/2SEgfgqODeuAAAAWgAAABx+fn4EAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPTk3AronHmW+66J/vyyjf/7tJD9/bmT//u8lv39v5f9/MCZ/f7Enf/8xJ/9/Mef/f7I + o//9y6X9/cum/f/Op//9zqf9/s6n/e3Jpf+Gl439eZiX/WuMif+OqKf9pru7/ai9vP+pvr39q8C//6zA + v/2swL/9rMC//6vAv/2ovbz9p7y7/6e9vP2lu7n9fZqY/3GQjv2bsrL9obe3/6K4t/2ku7n9pr28/6q+ + vv2rwL/9rMC//6zAv/2qv779qr69/6i9vP2murn9pbq5/aK5uP+itrb9oLa1/Z21tP+dtLP9nbSy/XiW + k/9oiIb9gp6e/Yymp/+IoqX9h6Ki/YWhov9+m5z9VXp3/Upybv9SeXX9U3h0/VN6dv9ReHT9Unl1/Ulz + cv8mYIX9DFSJ/QxUiP8fWof9aYqY/Y2opP+HoqD9hqKg/YOfnf+AnJr9cpGO/mKBfvQlMjGlAAAAVwAA + ABt/f38DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP3r4xnypYC2+7CK/vy0j//7t5D9/bmT//28 + lv38wJr9/MGc/f7Fnf/8x6D9/sei/f/LpP/9zKT9/c2l/f/OqP/9zab9/s6m/ffNp/+ho5L9d5eW/YKf + nf9wkIz9nbOz/azBwP+swL/9rMG//6u+vf2qv779qb69/6a8u/2lvLv9pbu6/6S6t/2iuLf9gJya/26N + i/2Vra39nbS0/520tf2gtbX9ore4/6O6uP2lurv9qb29/6q/vv2rwL/9rMC//6vAv/2ovr39p728/ae8 + u/+kubj9ori4/aG3tv+ht7b9i6ak/WeIhP95l5b9jqip/Y2nqP+Lpab9h6Kj/YWgov+FoaP9eJaY/Ulx + bf9NdXH9U3l1/VN6dv9ReHT9Unl1/Upzb/8qXnv9EU+E/SJPff9vjJj9jqil/Yukov+Io6H9hJ+f/YKf + nP99mpj9a42K/l+AePIfLSOgAAAAWAAAABx/f38DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF9O + RiX6rIfN/LKM//22kP/9uZH//byW//y/mf/+wJv//sSc//7GoP/+yKD//cqj///Kpf//zab//86n///P + qP//z6j//86n///Sq//Kt6H/b4yL/5uysv94lZP/dJOP/6q/vv+rwL//qr28/6i9vf+nvbz/pry7/6W7 + uv+kurn/orm3/6G2tv+gt7X/g5+d/2qKiP+PqKj/mLGx/5qysv+as7P/nLOz/6C2tv+itrb/orm5/6W7 + u/+nvbz/qr6+/6zAv/+swL//rMC//6q/vv+pvr3/pr26/6e8u/+Yr6//bY2L/3GQjf+Pqan/kqus/46n + qv+Lp6b/iqWm/4ijo/+FoKL/h6Gj/2OGhf9Jc27/Unl1/1N6dv9Tenb/U3p2/0lybv8qW3f/GUp8/zRY + f/+HoaL/jqim/4mlo/+Io5//hZ+f/4KenP93lZL/aoiK/1uHYPIYNwehAAAAWgAAAB1+fn4DAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKVvVjL5r4jk/LOO/v23kf/7upT9/b2W//3Amv38wpz9/MOe/f7H + n//+yaL9/cmi/f/Mpv/9zqf9/c2m/f/PqP/9zqf9/9Cs/eLHkv+JqEj9X4pt/Yymp/+jubf9dZSR/XWU + kv+ftrX9pry6/6O4uP2iuLf9obm3/6G2tP2etbP9nrSy/5u0sf2dtLL9iaSh/2eIhf2HoqL9lKyt/5Os + rv2Vra79l7Cx/5mwsf2cs7L9nLW1/6C1tf2gtrb9ori4/6S6u/2ovb39q7++/azAv/+swL/9rMC//Z20 + s/9wkI39bIyJ/Zaurv+YsLD9la2s/ZKpqv+Pp6j9i6Wo/Yqlpv+Go6P9hqGj/YCdnv9Te3j9TXRw/VN6 + dv9ReHT9Unl1/UVwbv8hVnz9FEV7/VByjf+Qqqb9i6el/Yijof+HoaD9hKCe/X2amP9si4n9ZoiL/jug + OPMZPQKkAAAAXAAAAB5/f38EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmVc0D6sIvy/LOP/v24 + kv/7u5T9/b2Z//zBm/38wp39/MSf/f7Iof/9yqP9/cql/f/Npf/9zqf9/c2m/f/Op///0Kz96sma/XKq + K/9Jtin9Xax1/XaQkv+mu7r9pLq4/XGRjf93lZL9m7Ox/6K4t/2ftbT9n7S0/5y0sf2as7D9mbKv/5iv + rv2ZsK/9i6ak/2aIhP2AnZz9j6mp/4+pqf2SrKz9lK2s/5Sur/2Wrq79ma+x/5uxsf2btLT9nbS0/5+3 + tf2jubf9pru5/ae9vP+rv779pru6/XWSkP9qjIn9j6io/Z+1tf+YsLD9l6+u/ZKrrf+Rqqv9jaio/Yyl + pv+Io6T9hqOk/YWgov9ihYP9SHJt/VN5dv9TeXT9UXh0/T9sb/8aUX/9FEZ7/XeUnf+Qqqf9jKSi/Ymk + ov+GoqD9g5+d/W+PjP9rhof9Q5t4/huxL/QbPgSpAAAAXgAAAB9/f38EAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAOihfVH7soz7/LaQ//24kv/9u5X//sCY//7DnP/+xZ7//seg//3Jov//y6T//8yk///O + p///z6j//8+n///QrP/qyZr/fq4y/0zBQf9Z3YX/YNiS/2mLh/+Tq6r/rsPC/52zsv9xkY//cZGO/5mx + r/+etbP/nLOy/5qwsP+ZsK//l6+u/5auq/+Vraz/jqim/2eIhf95mJf/jKan/42mqP+Nqan/j6qp/5Kr + rP+TrK3/k66u/5evsP+Yr7H/mrKy/5yys/+etbX/n7W3/6S5uf+gtrb/epiW/2iIhv+PqKf/o7m5/5+3 + tf+dtLT/mrCy/5Wtrv+UrK3/kaqr/46oqf+KpqX/iKOk/4ijpP91lJT/SnJv/1F4dP9Tenb/UHdx/zVm + c/8QS4H/MF2F/5OrqP+OpqT/iqWj/4mjof+FoJ7/dZWR/2qGh/9ZkX//Eblb/xezNvYcQQWsAAAAYAAA + ACB+fn4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO+mgWP8s43++7eR/v27lf/9vpj9/L+Z//zC + nf38xp/9/Mah/f/Ko//9yqX9/cum/f/Opv/9z6f9/8+r/dnEiP9tsS39S8VK/Vrhlv9f35P9ZOaX/We0 + jv9zkI/9orm3/aq+vf+etrT9d5WT/2yNiv2JpKL9l6+t/5aurP2Tq6r9kaqq/5Cpp/2QqKb9jqim/2uM + if1zkY/9h6Kk/4ilpv2LpKX9jaWo/46mp/2Np6r9j6qp/5KqrP2Sq6v9la6u/5Wurv2ZsbD9m7Oz/ZKr + q/9ykI79aIiF/ZmwsP+uwsH9qL28/aK4uf+gtbX9m7Sy/Zmxsf+Wra39kayr/ZCoqf+Mpqf9i6Sn/Ymk + pv+GoKP9W4B9/Upybv9SeXX9TnRu/R5Zff8bVIb9dJOe/ZGqpv+LpaT9iqWj/YKenP9xj439aYeH/ViR + fv8Wtlr9AMJQ/hS1PPcdRAavAAAAYQAAACJ/f38FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPKq + g3L8tI7/+7aS/f28lv/8v5f9/sKb//zEnv38xaD9/Mei/f/Lov/9zKX9/c2l/f/NqP//z6v948aT/Wmw + KP9JxUz9VtyM/V3gkv9i4JX9Z+OY/Wzamf9omYn9g56d/aq/vf+lu7n9nrW0/3mXlf1sjIn9fpuZ/5Gq + qP2Rqqj9jamn/46mpP2LpaP9jKak/3GQjv1tjIr9g5+g/4eio/2Io6T9iKSk/4mlpv2MpKb9jaeo/42n + p/2OqKr9kKmq/5Oqq/2Ura79jKam/W2Ni/9sjIn9j6mn/a3AwP+swL/9q8C+/aW8vP+ht7n9n7a2/Zyz + s/+Xr6/9lK6u/ZOqrP+Qqar9jKen/Yukp/+JpKX9cJCP/UZvav9Qd3L9Qm9w/RBUhf9Uf5f9kKmn/Y6o + pv+JpKL9fpuZ/W2Niv9oh4f9V5J+/RS3Wv8Awk/9AMJR/hG3P/gcSAeyAAAAYwAAACJ/f38FAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPOrhXb8tpD//bmS//27l//8wJj//sGc//7Fn//+x5///smi///K + pP//zab//86m///Pqv/kxpL/dq0p/0jFTP9U24r/Wt6Q/2Dhkv9l4pX/aeKa/3Dnnv9swI3/ZoiB/5mx + r/+lu7r/obi2/5qxr/+AnJv/aYqH/3eVk/+KpKL/i6ak/4qkov+Go6H/h6Kg/3aUkf9qioj/fpuc/4Wg + ov+EoaH/h6Cj/4ahpP+Jo6X/iqOm/4umpf+Lp6b/jqip/4+pqv+DoJ//a4uJ/26Ni/+Sq6n/pbu6/6m+ + vf+rv77/rMC//6q+vv+mu7n/obi4/52ztP+bs7H/mLCw/5Wsrv+Qq6r/j6mq/4unpv+Kpab/gp2f/0dw + bP9Lcmz/IV56/0B1l/+OqKn/kamn/4KenP9ykY7/Z4mH/2WHhv9llmr/G7dQ/wDDT/8Awk//AMJR/w+5 + QfkbSwq0AAAAZAAAACN+fn4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPWthnb8tpD/+7qU/f2+ + lv/8v5r9/sOd//zGn/38yKH9/sih/f/Mpf/9zaX9/s6o/erKm/99tDv9RsRJ/VHekP9X3I79Xd+Q/WPg + lf9o45f9buOb/XTnof915pv9bbOJ/W+LjP+Xr639oLa1/5qzsf2Zsa/9jKek/22Oi/1vkI39gZ2b/4Wg + nv2Dn539gp6c/3qYlf1piYf9d5WV/4Ofof2Dn5/9gp6g/4Ofov2EoaH9haKi/4ahpP2Jo6X9iKOk/3mW + lv1piYf9c5KP/Zqysf+iuLf9pLi3/ae8uf+pvrz9q8C+/azAv/+qvr39pru7/aK2uP+etbX9m7Kx/Zau + sP+Uraz9kqmq/Y+nqf+Mpab9iqWm/VB3cv81aXP9RXuV/Yylof99mpf9bo6M/WeGhv9mh4P9fpCF/b2j + ef9ysDD9C79B/QDCUf8AwE/9AMFR/gu7RfoYTw62AAAAYgAAACJ/f38FAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPevinD8t5H/+7mT/f2+mP/8wZn9/sSd//zFnv38x6D9/cqj/f/MpP/+zaf9+Mym/Yqz + Qf9Kwkn9S9mF/VPdi/9Z3Y39XeCR/WXil/9p5Jn9cOad/Xbmo/976qf9f+ip/W6fjv92kpH9mbCv/5uy + sf2Wrqz9lK2r/4qkov1zko/9a4uI/3eVk/1+m5j9fpuZ/3qXlf1qi4f9bY2L/3yam/1/nJ39gp6g/4Of + n/2CnqH9hKCi/4Sgov1+m5v9cZCP/2iIhf17mJb9la2r/Z20s/+etLP9ora1/aW6uf+nu7n9qL67/avA + v/+swL/9qb69/aO5uv+ft7b9nrOz/Ziwsv+Vr679lKut/Y+qq/+OqKn9haCg/VJ7fP9LeoX9bY6O/WyK + i/9phof9Z4mA/WGSYf9Vjjb9epYx/XWoJf8nty39AcFO/QDCUf8AwE/9AMFR/gu7Q/oYTg20AAAAYAAA + ACB/f38EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPewiWH9uJL+/bqU//y/mf/+wpr//sOe//7H + oP/+yaL//8mi///Mpv//zar/q7lZ/0K5LP9H1nv/TdyI/1XcjP9b35D/X+GU/2fjmP9t5Zz/ceWg/3np + o/9+6af/g+2s/4PcqP9tmY3/d5OS/5qysP+Wr63/k6yq/46opv+HoqD/dpWS/2iJhv9ujYr/dpSR/26O + i/9oiYb/aImG/2qLiP9sjIr/c5KR/4Ccnv+CnqD/fpuc/3KRkP9oiob/aYmG/36cmf+Rqqj/lq+t/5iw + sf+dsrH/nraz/6G5t/+lu7n/qLu7/6q/vv+swL//rMC//6i9u/+kuLr/n7e3/5u0tP+ZsLD/la+v/5Os + rf+NqKj/dJKR/2WFjP9ohoz/Z4aE/2SOaP9Tnlb/K7JY/yy2Nf9Ipgz/TaEE/yq2KP8EwE3/AMJR/wDC + Uf8AwlH/AMJR/w+5QfgdSwiwAAAAWwAAAB1+fn4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPy0 + jk37t5H7+7yW/v3AmP/8wZz9/sWd//zGof3+yaH9/suk/fzMp/+3wGn9Sbsy/UHYgf9I2oX9UNqH/Vfe + jf9d4JH9YeCV/WnkmP9v5Jz9c+ei/Xvopv+A66r9hOus/Y3xs/+J36z9bpqN/3WSkP2Rqaf9kqup/42n + pP2Io6H9haGe/3yZl/1ujov9aImG/2iJhv1sjIn9cZCP/3KRjv1ujov9aYqG/2uLif1ujoz9aImG/2qK + h/10k5D9hKCe/42npf2Qqaj9kqur/ZevrP+YsLD9m7Sx/aC1tf+jt7f9pLm4/ai9vP+qv779rMC//avA + v/+ou7z9pLi3/aC2tf+bsrT9mbCw/ZWur/9+mZv9ZYh6/VibPf9SoCz9S6UZ/Ti5J/8Wxk/9B8dZ/QHE + Vf8JwEj9Db9F/QDCUv8AwVH9AMBP/QDCUf8AwE/9AMJS/hqzNvYdQgWnAAAAUwAAABl/f38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPu0jD38t5Hx+7uW/v7Amv/8wZz9/sWd//zIof3+yKP+/sum/dvH + if9fujn9O89s/UTYgf9L2oX9UtyI/Vfdjv9d4JL9ZOKW/Wnjm/9v5p39duij/X3qp/+B7Kv9iOyv/Y3w + sv+U9Lj9keGy/2+Yjv1ykI79iaSi/4ympf2GoZ/9gp6d/3+cmf14lpT9aouI/2+Pi/15l5X9gJ2b/4Ke + nP19mpj9dZOR/2mKh/1niIX9bo6L/3uYlf2Cnpz9hqKg/4ijof2Op6b+kaqn/ZWtq/+Vrq79mrKv/Z60 + s/+gtbX9obe2/aa7uv+nvbz9qr++/azBv/+qv779p7y6/aG3uf+etbX9nbW0/Y2mqP9sjoH9Vpk0/T66 + J/8xw0b9KcZR/RnJX/8QyF79DcZY/QTCU/8AwlL9AMJS/QDCUf8AwE/9AMBP/QDCUf8AwE/9AMJU/iWs + LPIbOwSdAAAASwAAABN/f38BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP3f0C/6tpDh+72V/v6/ + mv/8w5v9/sSf//zIof3+yqL9/82s/ZS8T/85xU79PdZ9/UXYf/9M2YT9U9uK/Vrfj/9g35P9ZOGV/Wzl + nP9y5aD9duei/X7pqP+E66z9iO6w/ZDvs/+U8bn9nPa9/5fgtv10npL9a4qJ/4Wgnv2HoqD9gp+c/36b + mf14lpP9bIyJ/3mXlP2FoZ/9j6mn/5Grqf2KpaP9f5yZ/2+Oi/1oiYb9c5KP/32amP2Am5v9gp6e/4ei + nv2LpaP9jaim/ZKrqP+TrKz9mLCt/Zmxsf+ctbP9obe0/aS4uP+nu7r9p7y8/avAvv+swL/9qr6+/aa7 + u/+lubn9l6+u/W+MjP9WoWP9PsFG/SzPbf8kzm39Hsxo/RjKY/8TyF39DcZa/QXEVP8AwFD9AMBP/QDC + Uf8AwE/9AMBP/QDCUf8AwFH9AMJT/jCkH+4XLwKNAAAAQAAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP7u5CH6t5DI/b2X//7Bmf/+xJ3//saf//7IoP//yqX/8cmY/0q4Lf840nL/P9d9/0bX + gv9N24f/VN2L/1vfkP9h4ZT/Z+OY/23lnf9z55//eemj/4Drqf+G7a3/iu+w/5Lxtv+W87r/nPS+/6T5 + w/+m88P/hbii/2mJhv94lZP/eZiV/3GQjf9sjIn/aYmH/3mVlP+OqKb/nbWz/6K4tv+Vrqz/hqKg/3WS + j/9piYb/bY2K/3mWlP98mpf/gJ2a/4Oenf+Go6H/iqaj/5CpqP+Rqqj/lays/5ixr/+bsbH/nbWy/6G4 + tv+iuLf/p7y5/6q+vf+swL//rcHA/6W7uv+Ko6P/a4uI/1Wpgf860nz/MdR4/yvPcP8nzmr/Icxm/xrK + Y/8UyF3/DsZa/wfEVv8AwVH/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJQ/ziREuMKFgF0AAAANAwM + DAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7t5Bb6t5Cx+72X/v7Bm//8wp39/sae//7H + of3/y6j9zMF2/TfAPf841Xv9PtV7/UXXgv9O24X9U92K/VzfkP9g4ZT9ZuOX/W7lnf9y56H9euml/YHr + qv+F7a79jO+y/ZPxt/+Z87n9nfW9/6X2wv2s+sj9sPnK/5HFrf1skIv9ZYaD/2qKiP1xkI/9dJOS/3CP + jf1/nJn9mrGv/6O5uP2Wrq39h6Kf/3ORkP1piYb9aYmH/2uLiP1wj4z9d5aS/36bmf2EoJ79iaSi/Y6o + pf+Qqqf9kqyq/Zavrf+Zsa/9nLOy/Z+2tf+juLf9pru6/ae8u/+juLf9lK2s/XmVl/9lkYb9VrKD/ULV + fv851Xj9NNFz/S3QcP8nzmz9Icxm/RnKY/8TyF39D8ZZ/QbEVv8AwVH9AMBP/QDCUf8AwE/9AMBP/QDC + Uf8AwlH9CsBJ/jZ7CtAAAQBiAAAAKzw8PAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7t + 5Qn7uJGS+7yW/v7Bm//8wpz9/sae//7Hof3/y6j9tL5h/TDFTP841X39QNV8/UfXgv9N24f9Vd2M/Vzf + j/9i4ZP9ZuOX/W/lnf9z56D9eemk/YHrqv+H7a39i++x/ZTxt/+Y87v9nvW+/6b3xP2r+Mj9svzM/7j8 + 0P2f0bj9cZWO/2SEhP1ykZH9epiZ/3mXmP1ykZD9dJSQ/4Gem/2Cnpz9eZeU/2yMif1tjYv9cpGQ/26O + jf1ri4n9aYqH/2uLiP1xkI39eJaT/YGdm/+Ho6D9jKel/ZKrqf+Urav9l6+u/Zmwrv+Urav9jqim/YCc + mv9xkI79aYiN/WKNZ/9SuV/9SNmD/ULXf/8503j9NNN1/SzPb/8nzmz9Icxo/RnKY/8TyF39D8Zb/QbE + Vf8AwVH9AMBP/QDCUf8AwE/9AMBP/QDCUf8AwlL9Fr0+/i5kBrsAAABWAAAAIjs7OwIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7wp9j+7yW8f7Bm//+xJ7//sWe//3Jof//y6j/rb1d/zDH + Uf861nz/P9V+/0bZgf9P24j/VN2M/1zfkf9i4ZX/aOOZ/2/lnP9156L/eemk/4Lrqv+G7a//je+x/5Tx + uP+a87r/oPXA/6f3xP+t+cf/s/rN/7r90P/G/9r/x/na/53CtP94mZP/aouI/26Ojv93lZb/eJaX/3KR + kf9sjIr/aImG/3GRj/90k5P/dpWV/3iXl/96l5j/eZeY/3WUlP9wj47/bIyK/2mLh/9piYf/aYmH/2mK + iP9qioj/aouJ/2iKhv9lh4T/YYWC/2eIhf98k4r/d5xZ/0y2Iv9M1W//SdmF/0LXf/871Xj/NNN1/yzP + b/8mzmz/Isxo/xnKYv8VyF//D8Zb/wbEVf8AwVH/AMJR/wDCUf8AwlH/AMJR/wDCUP8AwlL/Jrsy/yBE + BJwAAABHAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD73Mk++7yV4P7B + m//8wpz9/sae//7Hof3/yqf9r71d/TDGUP841Xv9QNV8/UfXgv9N24f9Vd2K/Vzfj/9i4ZX9ZuOX/W/l + nf9z56D9eemk/YLrqv+G7a39je+z/ZTxtv+a87v9nvW+/6b3xP2s+cj9sfvL/7j90P3B/db9y//d/9T9 + 5P3L7Nr9r83C/4aknv1vjoz9b42Q/3OSlP1ykZH9aYmH/3CQj/11lJT9d5aW/3mXmP16mJn9fJib/32a + nP19mpz9fZqc/XuZmv95l5j9d5WW/XWTlP9xkZH9a4yM/WSHhv9qiYf9gpaN/buxnf+vt279WbUm/VHW + df9P3Ir9SdiC/ULXf/8503j9NNF1/SzQb/8nzmz9Icxo/RnKYv8TyF/9D8Zb/QbEVf8AwVH9AMBP/QDC + Uf8AwE/9AMBP/QDCUf8AwVD+NLUl/A4gAXwAAAA4AAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD83MkY+7uVy/7Bm//8wp39/sae//7Iof3/yqf9pbtW/THIVf841Xv9QNV8/UfX + gv9O24f9Vd2K/VzfkP9i4ZP9ZuOX/W/lnf9056H9eumk/YHrqv+H7a79i++x/ZTxt/+Y87v9n/W//6b2 + wv2q+cj9svvL/7f90f3A/db9x//a/9H+4f3Z/uf94P7r/+Dz6v2jzKD9WZJO/2WGd/1qiYv9aomO/2aI + h/1vj479cpKS/3eVlf14lpf9eZeY/3qXmf14l5j9d5WX/XSTlf9wkJH9aouM/WSIh/9miYf9dZCJ/aKm + lf/Mu6D97M2r/dzMjf9suzn9U9Nv/VXej/9P2ob9SdmD/UDXf/841n39MtN2/S3QcP8nzmr9Icxm/RrK + Y/8UyF/9DsZZ/QfCVv8AwlH9AMBP/QDCUf8AwE/9AMBP/QDCUf8Jv0r+OaMY6gAAAF0AAAApAAAACAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+7+biP7Amf/+xJ3//sae//7I + o//1yJz/d7Y4/zHPa/851Hr/PtZ8/0bXgv9M24f/VN2L/1vfkP9h4ZT/Z+OY/27lnf9y55//eOml/4Dr + qf+G7az/jO+y/5Hxtv+Y87n/nvW9/6X4xv+r+cr/sPvM/7X9zv++/9P/xv/a/87/3//T/+L/2//m/+L/ + 7//U9dX/dsVH/0yfDv9LkBr/WI08/5Okkv+DmpL/eZSM/3KPif9wjon/cY6J/3GOif91kIr/e5OL/4SY + jf+SnpH/qKuY/8W7ov/kyqn/+9Wv///ZsP//1q///9W2/5u/Wf9Rz2L/WuCU/1Tcif9O24X/SNmD/0LS + cf9CxU//OcZR/yzPbf8lzmv/Icxn/xjKYv8TyF7/C8Za/wLEVP8AwlL/AMJR/wDCUf8AwlH/AMJR/wDC + Uf8bvDv+L3QNvQAAAEIAAAAXKCgoAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA+8yuN/6/mPn8w5v+/saf//vIov29v239SL09/THTdv8403f9PdZ7/UTYgf9N2Yb9UtuJ/Vrf + j/9g35P9ZuGW/WvlnP9y5aD9eOek/X/rp/+D66z9ie2v/ZHxtP+X87r9nfXB/4vllf2J4Ir9o/K3/7T8 + z/25/tH9wP/X/8n93P3P/eD91f/i/9r95/3e/uv91fjc/6jhmf1ywEn9RJcC/8/Nkf3w3b/949W0/9vO + sP3Zza/92syu/9rLrf3ezq795tCv/fHUsP/62LL9/9qy/f/Zsv/+2LH9/taw/f7Urf/80639/9Wz/anD + ZP9SzmH9Wd+Q/VPbif9L2of9RdV4/V64N/+wv2T9nr1U/TfBRP8jzWv9Hsxn/SPFU/8utzX9M7U2/Ty8 + Rv8SvEL9AMFQ/QDCUf8AwE/9AMBP/QPBUP8rrin0GTYFjAAAADAAAAAMAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/vPtAfy9lsb8wZz+/sWf/+jEkP1muDn9K8pg/TLS + dP821Hb9PNR6/UPYgP9M2oX9UtyI/Vfdj/9d4JH9Y+KW/Wvjmf9v5p39deah/X3qqP+B7Kr9h+yu/Y/x + t/+Q77L9bNJj/4C+R/2Zwlr9ec9i/7X+1P22/M/9vf7U/8P+2P3I/dr9zf/f/9H94f3T/eH91//m/9j+ + 6v3C88n9XbUu/9zTnP3+48H9/OK9//zhu/394br9/d+6//3fuP393bf9/dy1/f3atf/92bP9/tey/f7W + sP/81a/9/Naw/f7Vrf/81Kz9/9Sw/c3IgP9WxU39Vt2M/VHciP9K24n9RctY/XupKv/8zaj9/syk/Uy3 + LP8jy2T9HMxo/SXCS/9Hpgz9UpMH/dC3cP9TtjT9BMBL/QDCUf8AwE/9AMFR/Q3ARv8yhxLTCRMAZgAA + ACBfX18FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP69 + lWH+wZr6/8al/6W7Wv8uwEH/KM9u/zDQcf820nX/PNV7/0PWfv9K2oT/T9qJ/1fejP9d4JH/YeCU/2nk + mv9v5pz/c+ag/3vopv9/6qn/hu6w/3zfiv9qvz7/qMNi///cu//x163/eb1A/6f3wv+z/M7/tv3P/73+ + 1P/A/9f/xv/Y/8j/2v/M/93/zP/d/87/4P+79Mb/esNL//3gvf/94bz/+9+6//veuv/93bn//d63//3b + t//92rb//dm1//3atP/82bP//tiy//7Xsf/+1rD//tSu//7Vrv/+0qz//tOt/+XNl/9qv0b/UtqC/0/c + iP9I24f/RMZK/3ulKv/7zqn/ycR1/zS9Nf8hzWn/Hcpl/xTJYf8qvjz/QZ0F/8quaP9ouD7/A8BK/wDC + Uf8AwlD/AMJT/yG1MvkjTQWnAAAARgAAABF+fn4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7XviX8wJnN/8Sh/2S3Mv0jyFn9J89t/S/Rcv8z03T9OdV4/UHX + fv9H2IP9T9uG/VTejP9b3pD9X+GU/Wfjmf9t5Zz9ceeg/Xnppf9/66r9feef/Wi4Mv/KyoL9+9i2//7a + tf3+2rb9lcBR/5Dpnf2x/M/9tPvO/7j9z/26/tH9vf/V/8L91/3C/dj9xf/Y/8f+3P2c5Jr9lMVa///i + wv373rn9+9+6//zeuf373bj9/du2//vctv3727X9+9qz/f3Zsv/917H9/Naw/f7Xr//81q79/NWv/f7T + rv/80639/dKs/fPQpf+JvU39TtJu/U7cif9G2ob9P8RI/Z+yTv/iyJH9Z7c0/SfKYP8gzWn9HMtj/RPJ + YP8WxFL9PaoS/dKxcP9ltjz9A8BK/QDCUf8AwFD9AMJT/jSiHewVLwKBAAAAMxsbGwkAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7w6Af/wKSE3b2A+Ti4 + KP4gzGb9J81s/S7Pcf8z0XP9OdR5/T7Vff9H2YL9TNmF/VTdi/9Z3Y39XeCR/WXhl/9r5Jn9b+Sd/Xfo + ov9+66z9btl3/V2hF//hzJr9/9m2//zYsv3/2rn9qcNj/4LgiP2t+839rvvJ/7P6zf22/M/9uf3P/7v+ + 0v27/tL9vf7U/7v60f16zVz9yNCH//7gvf373bj9/d65//vduP3727b9/dy3//zbtf382rT9+9i0/f3X + s//82LL9/Nex/f7VsP/81K/9/NWt/f7UrP/806v9/NGq/f7SrP++xHL9Tr03/Ujahv9E2oj9OsI//c/E + ef+3wWz9OcBF/STPb/8gy2b9Gslj/RLIX/8TxFP9PKsW/ZWmPv9FtTD9AsFN/QDCUf8AwlL9CcBJ/jiC + C9IDCABaAAAAIzs7OwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACuzYNJYbEn5h3FUv8ezGj/JM5r/yzQbv8w0nP/NtJ4/z7Wev9D2H//S9qF/1Lc + iP9X3o3/W96R/2Pilf9n4pn/buWb/3Tmn/966qn/cNuA/0WaAf+Uq0n/9tau//3Ztf//2bb/m8BV/4fl + k/+n+cn/qPfG/636yf+w+cv/sfrN/7P8zv+2/c7/uf3U/4DVbv+cxFz/9924//3cuP/93bj//d24//3b + tv/93Lf//ty3/+7Wrf/116///dmz//7Ysf/+17H//tWv//7WsP/+1a3//tOu//7UrP/+0qv//tGq///S + q//80Kr/usJr/2m5NP9cvDr/erk9//nNo/+sv2D/NMRO/yLObP8ezGX/GMpi/xDIXv8TxFL/Qa0a/zuo + Dv8PvkH/AMJR/wDCUf8AwlH/Jbsz/yZPBJgAAAA6AAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/qgBoKrs39BTKZf4eymT9Is1o/SrO + bv8u0XD9NNN2/TzVef9C13/9R9mC/VDbiP9T3Yr9Wt+P/WHhk/9k4Zf9aeSZ/W/mn/926KP9eeii/VCx + H/9Okgr9n69W/+vRpf3t06P9eLs+/5Xwsv2h9sL9pffC/6j4xf2p98f9rfrJ/6/5yf2x+879kOWU/4W9 + Rv3s2Kv9/t25//vbtv3727f9/dy3//3ct/302LH9v8B4/3SgMv2Zr1P98tSp/f7Ys//81a/9/NWu/f7W + rv/+1a/9/tSv/f7VsP/+1LD9/tOu/f/SrP/+0an9/9Ct/evMmP/dx4398syd/f/Pq//EwnT9QL09/R/O + bf8cymP9F8lh/Q/HXP8LxFX9ILs6/RO9P/8AwVD9AMJR/QDCUf8GwEz+OK0d8goXAVwAAAAjAAAABwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACQy2ZKOLUk5hPJZP4cy2X9IMtn/SjPbf8s0G/9M9Bz/TjUef9A1n79RdiA/U3Zhv9S3Ij9VtyN/V3g + kf9i4JX9ZuOX/W3lnf9x5Z/9eOmo/WnSbP9Jogn9Ro4D/2mYIP1toiL9ZsJH/5r1wf2c87z9oPXA/6P2 + wP2l98P9p/jF/6n4x/2o98P9XsA8/6m7Y/3/37/9/Nu2//vctf373Lb9/du0//jatf2gtlj9TqIL/0Wi + Cf1GkgX9ma1Q/f/buv//2rr9/9m6/f/Yt///1LD999Cm/d3Gj//ZxIr94caQ/frPpv//07H9/9Cr/f/Q + qv/+z6r9/s+p/f/Pqf/nyZP9YLYv/R3LZf8ZymT9Fcde/Q/FWf8HxVf9AsNT/QDCUf8AwFH9AMBP/QDC + Uv8fvDf/M3wNtgAAADIAAAAPkZGRAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC84aUBV7EVgiu9Pv8XymT/H8xn/ybOa/8rzm//L9Fz/zfS + df881Xr/RNaA/0rahP9P2ob/U92L/1rfj/9f35H/ZOKW/2rkmv9t5Zz/cuWg/3jqpv9s2Hf/V7ox/0yn + FP9XuTD/guWY/5Pxt/+V8bj/mfK7/53zvP+d9b7/n/bB/6P3wv+g9bz/Xr05/3KfKf/y16z//du3//3b + tP/927T//9u5/7HGbP9dvjj/gOGN/4fpo/9atzH/P44A/22bJv+Wq07/kKlG/3egL/9jmBj/TpME/0SR + AP9EkAD/RI4A/1KRCf+Dojn/08CC//3Pqv//zqf//8+o///Opv//zan/ycBz/zi4K/8Yx1v/Eche/wzE + WP8FwlX/AMFQ/wDCUf8AwlD/AMJS/xC+Q/43lRTVCxgBVgAAABUYGBgDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvuGnEEKw + Fs0hw1L+G8tm/STNaP8pzW39LdFx/TXTdf8503r9Qdd+/UfZgv9M2YT9UNyJ/Vfejf9c3o/9X+GU/Wbh + mP9r5Jv9buSd/XXoov956af9eeee/3fgjf2A56H9iu6y/4zusf2R8bb9lvO9/5fzvP2Z8779m/S9/5vz + vP2e9cH9ctFi/02WC/3Gwn/9/tu3//vZs/392rb94tKb/2O/Pv2G6KD9kPG4/4vvs/102n/9VLMo/USZ + BP9EmwX9RJ8M/UinGf9MsCX9ULk1/VK9O/9Ouzj9TbUr/UikEP9CkwD9UpEP/djBhv/+0Kz9/c2m/f/M + pf/+zKT9/sql/ai8W/8+uTH9E8RU/QjFWP8DwVL9AMBQ/QDCUf8AwlH9AcFQ/jSqIO0hRwV+AAEAJhsb + GwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAESqBFA4uCvsG8lh/iHMaP8nzmr9LM5v/TLScv841Hj9PNR8/ULW + gP9J2YP9TtmH/VLdi/9Y3o79Xd6Q/WPilv9n45f9auOa/XHmn/915qH9eumm/37rrP2C7Kz9he2s/4nu + sP2L77L9eN+H/2XLVv1523/9lPC3/5fyuP2Z8779ieea/0WfA/2ar1H9+diz//3Zsv3/2bf9p8Ff/27Y + dP2P8Lj9iO2v/4Xtrf2A66r9duOV/WjVcf9m1HD9Ztl8/WbchP9k3439Yd6Q/Vzejf9X3Iv9UtuG/U3S + b/9Huzb9U6IW/eHDjP/+z6r9/c6m/f/Npv/9y6P9/smj/fnGnv+sulv9Obco/QTEWP8BwlH9AMBQ/QDC + Uf8AwlL9Ibs1/zRwCKgDBwA1AAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOHy2Adftih/MLw79xrM + aP8jzWj/Kc1r/y/PcP810Xb/OtN4/0DXfv9E2H//SdqD/1Dcif9T3Yz/WN2P/1/hkf9j4JX/ZuOX/2zl + nP9w5p3/c+ag/3fno/986KX/f+uq/3znnP9sxlH/kb1L/8XHfP9+v0f/guaZ/5Dwtf+P77T/lPO8/12+ + Ov+gtlb/+9ez//7Ys//41qz/fbxA/4Hpo/+H7a//guyq/37rqf986KX/d+ik/3Topf9w56L/bOWc/2bj + mf9i4ZT/XuCR/1jejv9Q2ID/StFq/0zKWf9LxEn/Xbcp//nOpP//z6j//8yl///Mpf//yqL//sii//7G + oP//xKL/urhf/ye3Kf8BwVD/AMJR/wDCUf8YvD3+PJQQ0gADADcAAAASKCgoAgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACm1YUfRq4QvCDHWf8ezGn9Jc5q/SrQcP8x0nX9NdR6/TzWff9C1X39RdeC/Uza + hv9P2on9VN2M/Vvfjv9f4JL9Y+CU/Wjjmf9q45r9buae/3Pnof136KL9eeqo/2bFS/25xnL9/NWx//XV + sP2Swln9euKS/4rusf2J7bD9j/O9/2vJVf3EyHz9/9e0//7Xs/3gz5f9bsBE/4Ltr/1/66n9fuqo/3vp + pP115qP9ceef/W/knP9r45r9Z+OY/WHik/9e35H9Wd+R/VLLXf9nvUD9kb5R/bXBaf/Dw3T91MeF/f/P + p//9zqf9/c2m/f/Kpf/9yaH9/Mef/f7Fnf/+w539/cCc/YG1Pv8Vujf9AMJR/Qq/Sf82pxzkGjsEawAA + ABkAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAarozQTq2J/8hyF7+H8xp/iXN + af8ry2D9NclX/T3NZP8+1Xr9Q9d//UjZg/9N2Yb9UdyI/Vbejf9b3479Xd+R/WPilv9n45f9a+Ob/23k + nP1z56P9Zdl9/5C8Sf351K79/9ax/+zSpf1+wUz9eeSX/4TsrP2G7rH9fOWa/2u5Nf3k0Jv9/tey///X + s/3IyX/9Z8dS/4DusP166KX9eeek/3bnov1w5p79buWd/Wrkm/9m4Zj9YuCV/V7gkf9a35H9UdZ4/W60 + Lv/eyY799s6m/f/Pqf//z6r9/s+p/f/Np//9zKb9/cyl/f/LpP/+x6L9/Mag/f7EnP/8wpr9/7+a/dq5 + fP9MtC3+AcFM/i21KvQqXQaJAQMAJQAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAGq8NFRGrhG8WLYu5HS4Of+QuUj/fa8u/0W0If860XL/PtZ9/0TYfv9H2YP/S9uF/1Dd + iv9W3ov/Wt+P/17gkf9g4JX/ZeOY/2jjmv9o45j/UcdJ/83Hf///1rX/+NOv/5a5Tv9hylb/e+mn/37r + qv9w3YX/Y7oy/93Nkv//1rP//dau///VsP+3xW//aNFo/3jqqf905qH/c+eg/3Dknv9s5Zz/Z+KY/2Pi + l/9h4ZP/XeCS/1ndjv9V3pD/TMhT/3mmKf/8zqj//8+p///Pp///z6j//82m///Opf//zaX//8uk//3I + of/+x5///sWe//7DnP/+v5r//b6Y//26lf+wr1zzQaka4DqEC4wJFwAVAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACk1YQQ0sWESPfHnujdw4b+arMw/TXI + V/8103b9O9V6/UDVff9D1oD9SdmD/U3Zhf9Q2on9Vd2M/Vndj/9d4JL9X96P/1nKWP1mwUj9gL1G//PQ + pP360q79p7tc/1K8Nf1v4JH9eOqp/2vbgf1svkD9ycqA///WtP3+1bD9/tWv//7Ur/2ww2j9ZdJs/3Lo + o/1u5J39beWb/2nkmf1n4Zj9Y+CU/V7fkv9c3pH9V96N/VPdiv9P3Iz9S8lS/WCcFf/dwoz9/8+p/f/P + qP/9zab9/c6n/f/Npv/9yqP9/cqj/f7Iov/8xp/9/MKb/f7Bm//9v5f9/LyW/vm0kvSQcFSVIT8HRw0k + ABE7OjwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPjGpV2Vu1XoL8VO/izRc/8y0nT9N9J2/TzVe/9A1nz9Q9Z//UnZhP9N2oX9T9qJ/VTd + jP9Y3Y39TcRH/569VP3gy5H978+i//7Sr/3AxHT9W7s1/2rhk/1w56T9aN+J/2O6NP3JyID9/dSv///V + sv330aj9/NOt//vWtv2cv1j9YtZ0/2zlnv1q5Jn9aOOZ/2Xil/1g4ZP9XuCS/VvfkP9W3oz9VNuL/VDc + if9M3Ir9Ss5g/UiZAf+PpUP99Myk/f/Op//9zqf9/c2m/f/Mpf/9yaL9/smi/f7HoP/8w5z9/cKc/f2+ + mP/8vZf+/72W/6d5YJcRCwssAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN3szBBOtiqmJctj/yjPbv8uz2//MdJ0/zfU + dv861Xv/Ptd+/0LYgf9G2YP/S9qE/0/cif9R2H3/Qq4X/7CyYf//07L//9Kt//LQpP+GxVv/Xt6K/2jk + nP9g2oD/Ybgv/+fOmv//1LL//tOw/7C3Y/9Qkwr/YZYa/4SqPP9avDn/ZN+P/2XimP9i4pb/YuGT/1/g + kf9c35D/V96O/1Tdiv9S3Ij/TduG/0nahf9F14P/Qtd9/0axHv9jnRv/5MaT///Op///zab//8yl///J + pP/+yaH//seh//7En//+w5v//MGa//2+mP/3tpLyqXthlAAAABgAAAAHAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANLr + wwRDrAZvOrsz8iTNa/8oz279Ls9w/TPTdf820nT9Octc/T/ScP9B13/9RteC/Urah/9L2H79SrQk/2aX + HP3RwIP98c2h/+PKmP18yWf9XN+Q/2Hhlf1Rx1D9eawy///VuP3/07D9xsJ3/1CtHf1LriH9Rp4I/0iv + Iv1b1HP9YuGW/17fkv1e4JL9XN+P/1jdjf1V3Yv9U9uJ/VDaiP9L2ob9SdiE/UTXgP9C1379PdZ//TzG + Uv9lqSP95caU/f/Np//9zKT9/cuk/f7Jo//8xqH9/MSf/f7Enf/8wZv9/b6Y/vS2kOuZcVqGEQsJJAAA + AAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADV7MgOabs1eji8Nf8lzGn+KM9u/S3Qcf87wkj9d7g6/U+9 + Ov8803b9QNiA/UTDR/9Jvzz9TL46/0mWAP1bkRL9b5oi/22bIv1ZwEz9WN6O/1zfkP1Rwkb9SpYG/8q+ + e/3Zy4z9Zbgy/1jXev1d24T9WdNu/1vZgP1d35L9XN+R/1rfjv1Y3o79VtyN/1Tdi/1R2on9TNuH/Uva + g/9H14P9RNiB/UHXfv891Hr9ONR5/TbKXf9lrCj95cWS/f/Mpv/9y6P9/sij/f7Iof/8xp79/MSc/f7C + m//+v5n++bqU8otmUWwPCggeAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGm7 + M3Y7tyzvJstl/ynKX/92ukD/88ym/3i7Qf81zWT/PMBA/6S5Uf+xwGT/S8VO/0q9N/9Jqxb/R6kV/0is + Gf9OzGD/U92M/1Xejv9T0Gf/SqYP/0yOBf9fqyP/VNRw/1nfk/9Z34//WN+P/1fejv9V3I3/Vd2L/1Lb + i/9S3Ij/UNyH/0zbh/9L2oX/RtmB/0XYf/9A133/PdZ7/zrVeP841Hb/M9N2/zPJWv9lrCf/5cSR///L + pP/+yKP//sih//7Gnv/+xJ7//sKc//3AmvzXoYHKYkg5UQAAAA0XFxcCAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAO335gt1wEV4Orku7ze/QP6qvV38/8ys/nm7Qv8xyVj9QLEd/ZOn + Rf+oul/9SsVP/0LXgP1G0nD9SNJw/0rTc/1M2IH9TtuH/1DbiP1Q2ob9TsZP/0idBP1GnQf9UMdT/1Pd + jf1T24n9UduK/1LciP1P2of9TtuI/07bh/1M2YT9SdqD/0jZg/1E2H/9Q9d9/UDVff871Xv9OtR5/TXT + df8z0nT9LtFz/S7HV/9lqyf95cOQ/f7Jo//8xqH9/Mae/f7Env/9wpz+/sGb/9qkg7pQOzBHAAAADhgY + GAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADs9eYLaLs2YEyr + Eo/Gunh3/8qs3Iu6S/8vxU/+RbUk/UyPAv9UoBH9QsZR/zzXgP0+2IP9QNmH/0PZhv1H2YP9SNmD/0rY + hP1L2ob9TNuH/0vAQf1LogX9TKoO/03Ygf1N24f9TdmG/0zahf1L2oX9StiE/0jZgf1F14L9RdiB/0HX + f/1A1n39PdR7/TrVef820nf9NdF1/THRc/8uz2/9KdBv/SvGVP9iqiX95cGO/f7Iof/8xp79/cSe/v/C + nP/9wJny16ODmSQaFSkAAAAIkZGRAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/+DOEcvLh5RCujLxMsdV/0O3J/8/wD//NNFy/zjN + ZP9Fw0r/VL06/0XCRv8/1Xn/QNd+/0PXfv9D1n//RNiB/0bYg/9HzF//SMRJ/0XXgP9F2YL/RteA/0TY + f/9D2ID/Q9Z+/0DXf/9A1Xz/PdZ7/zzVe/8403n/NdR3/zPRdf8y0nP/L9Fx/yrOb/8oz2v/I85r/ybG + Uv94sjn/7sSW//7Fn//9w53//MCb8NShgKtnTT0+AAAACTk5OgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO72 + 5w15wUuCObw08ivOa/8tzmr+NcJH/3K5Pf21wGj9oLhM/0G4LP0503X9PNV7/zzUev0+1nz9PtZ7/0DV + fP0/13/9P9eA/z/Vfv0/1Xz9QNZ9/z/We/0+1nr9PdR6/zzVef0603n9N9R4/zXSdf000nX9MNBz/S/R + cf8r0G79Ks9s/SXOav8jzWj9Hsxp/SfCSv+cuVP++8Se/vzCm/Prs4+6jGpVaS8iGhU4OToDAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADs9eYOZ7s1fUG1I/JEtiXwkrlM9u7Jmv/WxYf+Xrk1/zLN + av0z03b9NtJ1/zjUd/031Hj9OtR5/zrTef061Xj9O9V6/zvVeP071Xn9OtN5/zfUev021Xz9NdV7/zTT + d/0003X9M9Fz/zHSc/0tz3H9LM5v/SrPbP8nzmz9Jcxq/SHLaP8cy2f9F8xm/kS5L//IvnP59r2axaV+ + ZVsqHxchAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPA + QQt7vE0N4c2kGv/UuHjBv26/Rbox7y7MZ/8t0HH/LtFz/zDRcv8x0nT/MdJz/zPSdf8y0XP/MtNz/zTR + c/8y0XP/MtJ1/zbKXP9CwUX/QMFG/y/LYP8sz27/KtFx/ynObv8oz2v/Js5q/yLNaP8hy2b/Hcxm/xrL + Zf8fxVX/NrQi7maCLJeBYlA+DgoGCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADm4L8VX7YnYEOxGsA6wEL1NsRO/zrB + R/4wy2L+K9By/y3Qb/0uz2/9LtFx/y7Pcf0s0HH9MMZQ/3S3Ov27v2z9ur9p/3W6QP1CvTr9K8ZQ/yXM + af4gzmz9Hc1p/R3LZ/8aymP+Hcdb/iu+Qf1ArhzSKF8EbQYIAhAAAAAEAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAALPbliBEqwdhSa0PgFOnFXhBshzdM8RO/yXOb/4lz3H+JtBv/yTQcf4vxU//Z7gy/+zH + lf//yqf//8ql/+7HmP/IwHX/f7hA+ju4Kvwvv0L/LL9D/zO7Nf86tij6QbIc3UKcDoQeSQEzAAAACign + KAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+4KYdVLEUhUGz + Htk3ujTpMb9A9Dm3LOc8kQyvhHxLYa6Jck/UrZJM98+0TPXNsUL0zbYu07+aF3G5Qyd4vkNWeL1DXnW4 + RD5vq0UaTmc/AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXVhC2m1YRRpdaGZaXThEqPpYEWAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////////////////AA//8D/////////8AAP/wB/////////4A + AD+AAAf///////wAAAAAAAAB//////gAAAAAAAAAA/////AAAAAAAAAAAAP///AAAAAAAAAAAAB//+AA + AAAAAAAAAAAH/+AAAAAAAAAAAAAA/+AAAAAAAAAAAAAAH+AAAAAAAAAAAAAAD8AAAAAAAAAAAAAAA8AA + AAAAAAAAAAAAA8AAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAYAA + AAAAAAAAAAAAAYAAAAAAAAAAAAAAA4AAAAAAAAAAAAAAA4AAAAAAAAAAAAAAD4AAAAAAAAAAAAAAH4AA + AAAAAAAAAAAAf4AAAAAAAAAAAAAAP4AAAAAAAAAAAAAAP4AAAAAAAAAAAAAAH4AAAAAAAAAAAAAAD4AA + AAAAAAAAAAAAD8AAAAAAAAAAAAAAB8AAAAAAAAAAAAAAB8AAAAAAAAAAAAAAA+AAAAAAAAAAAAAAA+AA + AAAAAAAAAAAAAeAAAAAAAAAAAAAAAfAAAAAAAAAAAAAAAfgAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAf4A + AAAAAAAAAAAAAf4AAAAAAAAAAAAAAf4AAAAAAAAAAAAAAf4AAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwA + AAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwA + AAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwA + AAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAA/wAAAAAAAAAAAAAA/wA + AAAAAAAAAAAAA/wAAAAAAAAAAAAAA/4AAAAAAAAAAAAAB/4AAAAAAAAAAAAAB/4AAAAAAAAAAAAAB/8A + AAAAAAAAAAAAB/8AAAAAAAAAAAAAD/8AAAAAAAAAAAAAD/+AAAAAAAAAAAAAD/+AAAAAAAAAAAAAH/+A + AAAAAAAAAAAAH//AAAAAAAAAAAAAP//AAAAAAAAAAAAAP//AAAAAAAAAAAAAP//AAAAAAAAAAAAAf//g + AAAAAAAAAAAA///wAAAAAAAAAAAB///wAAAAAAAAAAAB///4AAAAAAAAAAAD///8AAAAAAAAAAAH///+ + AAAAAAAAAAAP////AAAAAAAAAAAf////wAAAAAAAAAB/////wAAAAAAAAAD/////wAAAAAAAAAH///// + 4AAAAAAAAAP/////+AAAAAAAAAf/////+AAAAAAAAA///////AAAAAAAAB///////8AAAAAAAH////// + /+AAAAAAAf////////AAAAAAB/////////wAAAAAP//////////AAAAAf//////////wAAAA//////// + ////AAAP////////////wf///////////////////////ygAAABIAAAAkAAAAAEAIAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMjIwBFxcXBxoaGgwaGhoPGhoaDxoaGg8aGhoPGhoaDxoa + Gg8aGhoMGBgYB25ubgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABubm4BGBgYCBoa + Gg8aGhoTGhoaERkZGQk8PDwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAACkpKQUAAAAZAAAAMwAAAEUAAABKAAAASgAAAEoAAABKAAAASgAAAEoAAABFAAAANAAA + ABoWFhYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPDw8BBYWFg0AAAAfAAAANgAAAEsAAABUAAAATwAA + ADkAAAAcJycnDDw8PAg7OzsFOzs7Ajs7OwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJycnBAAA + ACMiISFqODc2oDk3N646OTixOjk4sTo5OLE6OTixOjk4sTY1NKwUFBOSAAAAdwAAAFQAAAAhAAAACAAA + AAgAAAANAAAADAAAAAwAAAAVAAAAKAAAAEUIDxt5EyM7rxUnQsETIzy+CA4anwAAAHwAAABdAAAARgAA + AD0AAAA1AAAALAAAACQAAAAcAAAAEwAAAA0AAAAJAAAABQAAAAQAAAADAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbW1sBDAsMI2dlY7O0s7P70dHS/7a5 + uf+Eg4L+h4SC/oeEgv6HhIL+h4SC/oeEgv+Bf334R0VFxwECAogAAABYAAAANAAAADoAAABLAAAASgAA + AEkDBQljDhsunR01XNgnRnf9Ik6G/x9Tjv4jVY/+KEt++hkoOccdJyWuFRwcogkMDJUAAACKAAAAgQAA + AHcAAABsAAAAXgAAAE4AAAA9AAAALQAAACEAAAAYAAAAEwAAABAAAAAOAAAACwAAAAkAAAAHAAAABQAA + AAMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCgoSc3JwteHh4v785d//+sq2//zIs/3cvbP/jIqJ/4uK + iP+Nioj/jYqI/Y2KiP+Nioj/ioeF/UxLSswCAgKJLCsqmkdFRLQ0MzGxFBwlqxktSsoiP2zwJ0d5/SpM + f/8kVo/+H12d/x9foP8gYaL/JGOk/i1Uif1Xd4D8ZoeD/GKDgPlaeHTxTWdl5T1QTtcmMjHGFRwbtQQF + BaMAAACTAAAAggAAAHAAAABaAAAASQAAADoAAAAwAAAAKAAAACMAAAAgAAAAHAAAABgAAAATAAAAEAAA + AAwAAAAJAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFhXVwNLSUdx0dHS/fnTxv/6wp7//enA//7uxP3+0qr/zZmF/42Jhv+TkI7/k5CN/ZOQ + j/+TkI3/k5CO/4mHhftkYmDhg4GA+Wdvfv8/VHf8J0d2+ilLff4rT4P/LVSJ/y5Xj/8lZKT9J2ep/ydp + qv8ma67/Jmyw/Sxrrf9CY4j/h6Kg/4Sgnf9+m5j+dpWS/3CQjf5qiof9YIB9+FNta+45S0rcHCUkyAoN + DbcAAAClAAAAlQAAAIIAAABuAAAAXQAAAE8AAABGAAAAQAAAADoAAAA0AAAALgAAACcAAAAhAAAAGwAA + ABUAAAAPAAAACwAAAAYAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1M + SyGdm5ra9uDZ/vu+mP/+9cr///bM//32y/3/+M7/+tGo/6iKff+UlJP/mJaU/ZeWlP+YlpT/lpSS/4yJ + h/+Sjoz+XmuB/yZGev8oTID/K1KH/i1Xjf8xW5L/M12W/zJkof8sb7H9LHGz/y5xt/8tdLn/L3a6/S94 + v/82ZJ3/g5qj/5yysf+asrD9mrGw/5evrf+Sq6n/iKOh/nqYlf9ujov/ZoaE/Fh0cvQ8T03jGSIhzgUG + BrwAAACtAAAAnAAAAIgAAAB2AAAAaQAAAGAAAABbAAAAVQAAAE8AAABHAAAAPwAAADUAAAAtAAAAJAAA + ABwAAAATAAAADAAAAAYAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFNSUGnS0tH/97KW/v7u + wf398cb9/fHE/f7xxf798MT9//PH/dmukf2Rjo39npya/p6bmf2QjYv9hYSC/YiGhP2WlZf+ME98/SxT + iv0uWZD9Ml2U/jJgm/00ZKD9N2ik/TZwsf0yeL3+NHjA/TV6wv01fcP9NH3G/jSAyP01dLf9bYaZ/Z62 + s/2bsrH+m7Sy/Z20sv2dtLL9nbSz/p20sv2ZsK/9jael/n2amP5rjYr+ZoaD/VNta/IuPTzfBQgHxgAA + ALkAAACpAAAAlgAAAIQAAAB4AAAAcAAAAG0AAABpAAAAYwAAAFwAAABUAAAASgAAAD4AAAAyAAAAJgAA + ABoAAAAQAAAACAAAAAIAAAAAAAAAAAAAAAAAAAAAycjIB4OCgrvs0sr//MWa/f/uwf//677//+y+//3s + v/3/677//+2///Xcsv+ejYX/paKj/ZaTkv+Nioj/kI2L/5iVlP+EiZX9LFSJ/zRhmv81ZJ//N2ik/Tls + qf87cK7/PXKy/zx6vf85gcj9O4TL/zqFzf86hdD/PIjR/TyJ0/87gsr/XHqY/6K5tv+etrP9n7a0/5+2 + tP+ftrT/n7az/Z+2tP+etbT/nrWz/5+1tP2cs7L/jKal/3eWlP9rjIj/ZISB+zxPTecRFhXOAAAAvQAA + AK8AAACcAAAAiwAAAIEAAAB8AAAAegAAAHYAAAByAAAAbAAAAGQAAABbAAAATwAAAEAAAAAvAAAAHgAA + AA4AAAAFAAAAAAAAAAAAAAAATEtLKa2sq+P0vKb//uCx/f/ouf//5rr//+a6//3muP3/5rr//+e5//7m + uP+4oY3/pKSl/ZaTkv+dm5r/mJaU/6WjoP98hJb9MV6X/zhrp/86baz/PHOx/T51tv8+erv/QXy+/0KB + xv9BitT9QIzW/0KM1v9Cj9j/QpDb/UKR3f9AitT/W3mY/6W7t/+gtrb9oba2/6G2tv+htrb/obe2/aG2 + tv+ft7b/oLW0/562tf2ftrT/nrW0/5yzsv+TrKr/fpyZ/m2Niv5ffnv5PlJQ5xAWFs4AAAC7AAAArAAA + AJ0AAACRAAAAhgAAAH8AAAB9AAAAewAAAHgAAABzAAAAbAAAAGIAAABTAAAAPgAAACQAAAAPAAAAAwAA + AAAAAAAAamlnTcO9vPj5tZX//uW1/f/itP//47T//+O0//3jtP3/47T//+O0///ktP/TuZn/nZ2d/ZuY + l/+sqqn/oZ6d/66sqv+EjZ39NGWh/z11tP8/d7n/QXy+/UGAw/9Eg8f/RIXK/0eJz/9Gktz9SJTf/0iV + 4f9IleP/SJbk/UiZ5v9Ci9T/aISb/6a7uP+ht7b9o7m2/6O5tv+jubb/obe2/aG5tv+it7f/ori3/6C2 + tv2ht7T/nrW1/5+0s/+etbT/nLOy/ZWtq/+AnZv/bY2K/l58evgwQEHiBwwUzgECBcAAAAC0AAAAoQAA + AI0AAACCAAAAfgAAAH4AAAB9AAAAewAAAHcAAABtAAAAWQAAADsAAAAcAAAABwAAAAAAAAAAjYuJdtLC + vP/6uZH//uGv/f/drv//3q7//96u//3erv3/3q7//92u///frv/pyqL/mZaW/aOhoP+7ubj/rqyr/7Cu + rf+fpK39Nmij/0J/wf9CgsX/RYTI/UeJzv9HjNH/So/X/0qR2f9Nl+L9Tpzo/06d6v9Onur/Tp3r/U+i + 8f9CfsL/gZik/6e9uv+lu7r9pbq5/6S6uf+jurn/o7m4/aS6uf+kurf/ori4/6O5tv2it7f/obi1/5+3 + tv+etbP/nrWy/Z20sv+cs7L/lKyq/3uZl/5qioj/OVh0+xgwVu8IEyHWAAAAvwAAAKgAAACMAAAAgAAA + AH8AAAB+AAAAfgAAAHwAAAB2AAAAZQAAAEUAAAAhAAAACgAAAAAAAAAAlZSTl9u/tv/8wJL9/tmn/v3Y + pv392Kb9/dim/f7Ypv792Kb9/dim/f7ap/3306P9nJaT/qupp/3Jx8f9wsHA/aqop/3Kycz+PWaa/UWH + zf1GidH9SY7V/kuR2v1MlN39TJXh/U+Z5f1Pm+f+U6Lw/VOk8v1TpfT9U6X1/lKi8v02X4n9UXd0/V2C + f/1uj4z+hqKg/Zqzsf2ovLv9qb69/qa7uv2lu7n9o7m4/aS6uf6iuLj9o7m2/aK3t/2huLb9oLW1/p20 + tP2cs7P9nLOx/Zyysf6Np6T9Z4iJ/iVSfv4YS379CiU+4gAAAL0AAACfAAAAhgAAAH0AAAB6AAAAdwAA + AHIAAABqAAAAVwAAADsAAAAcAAAACAAAAAAAAAAAnJubrN+7rf/9yJz//tmr/f/Uo///1aH//9Wh//3V + of3/1aH//9Wh///Vov/60qD/pZ6X/bKwr//X1tX/2NfX/6Siof/n5eP9cISj/0CBx/9Mk93/TJbg/U+X + 5P9Qm+f/UZ7r/1Kg7v9To/H9Vaj3/1aq+/9Vp/j/TJnn/Ttnm/9mhIr/dpSS/3GRjv9niYb9Wn98/1J5 + df9XfXn/b4+M/ZKrqf+nu7n/qb68/6a7uv2lu7j/o7m5/6K6t/+jt7j/oLi1/aC3tP+ftrT/nLOz/5yz + sP2asbD/la2r/1mDk/8LUof/C1SK/QYRGM4AAACzAAAAlgAAAHgAAABoAAAAYAAAAFcAAABLAAAAOAAA + ACEAAAAPAAAAAwAAAAAAAAAAn6CfueC3qP/9yaD//tiv/f3WrP/90J///c6d//7Onv39zp7//c6e//7P + nv/7z53/qqGY/a2sq//b2tn/6unp/8C9vP/Qz8390NPY/0hwo/9KleH/UZ7r/VKh7/9To/H/UqLx/0+d + 6/9Jkdr9QoDB/z9xqP9Ca5X/Tm+K/W6Lj/99mpj/f5ya/4KenP+Dn539g5+e/4Kem/94l5X/Z4qH/Vd9 + ef9egn7/e5mW/5mxr/2nvLv/pru6/6W6uf+iurf/o7m2/aC4t/+gt7T/n7S0/520sf2asbH/mbGv/42q + q/8aZpX/AFqU/i5hdPIZHh7GAAAApAAAAIAAAABXAAAAPwAAADEAAAAmAAAAGQAAAA0AAAAFAAAAAAAA + AAAAAAAAnp+eueCyof/9yaD//NWu/f7Vrv/+0qj//sqa//zJmP3+ypj//sqY//7KmP/7yJn/qqCY/by6 + uv+2tLP/9fX1//b29f+rqaj99PPy/8HJ1P9HcaX/RYnQ/USDyP9Ac67/OmaW/z5khv9KbX/9XHuC/2mI + iP91k5D/fZmX/X+cmv+Anpz/hKCe/4aioP+Go6H9iKSi/4mkov+JpKL/iaSi/YWgnv92lZP/YIOA/1N6 + dv1qi4j/kaup/6S6uf+lu7r/o7m3/aO5tv+guLb/oLW1/521tP2dtLL/mbKw/5qxrv9FgqD/AFqT/SJs + kf9ee3fzICsqvwAAAJEAAABgAAAAMQAAABYAAAAMAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAnJ2cuNuy + o//9xqL//NSy/f7Vsf/+1LL//tGr//zGmv38w5T//MSU//3Elf/6w5T/q6CY/dTU1P+2tLP/rayq/9XU + 0/+0srH9q6mo//Lx7//g4OP/pq69/aepsv9vfHv/WH14/2KGgP9qjIj9cZGP/3aVk/97mpf/gJuZ/YKf + nP+GoqD/h6Ki/4qlov+MpqX9jaek/46npv+Op6b/jael/YympP+LpaP/iaSi/4OenP1pi4j/T3dz/16B + fv+Pqaf/qL29/aS6uP+jubb/oba2/562tf2es7P/mrOw/5qxsP94nqj/AFiR/RFikv9oi4z/ZIOA9yQw + L7cAAAB/AAAATAAAABkAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAl5aWp9Kvov/9w6P9/da4/vzU + tv381Lb9/Na4/f3Vt/79z639/cih/f3CmP34uo39raWf/trZ2P3Z2Nf90M/O/ba0s/26uLf+uLa1/YeJ + h/2lpaP9o6Of/nB/ff1Xe3f9X4N//WaJhv1uj4z+dpWS/XuZl/2AnJv9hKCe/oiiof2JpaP9jael/Y2o + pv2Qqab+j6io/ZGqp/2Rqqf9kaqo/pCpqP2OqKX9jKWl/Yqko/6Io6H9hKCf/W+Qjf1PdnH9XoJ//pWu + rP2lu7r9ori3/aG3tP6ftLT9nbSy/ZuysP2Wrq39FWKS/gVYjv1tlKD9dZOP/miJhvwiLi2yAAAAegAA + AEMAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk5KQjsOrov/7vKD//di//f3Yvf/92L7//di9//3Y + vv392L7//Ne+//7Xvf/yxqj/sK2q/d/f3v/d3N3/3t3d/9/e3f/g39/9ycfG/2B4dP9Td3P/VHd0/VN5 + df9af3z/YYWB/2aJhv9qjIn9cJCO/3aVk/99mpj/hZ+d/Yukov+PqKb/kKqo/5Kqqf+Sq6r9k6yr/5Sr + q/+Uq6v/kqyr/ZGrqv+Rqqn/j6mm/42npP2Jo6P/h6Kf/4Sfnv99mpn/ZYiE/VB3dP91lJL/n7a0/6K4 + t/2gtbX/nLOz/5qzsP+csrD/NnSX/QJTi/9ShJv/kKil/3KRjv5igX71GyMiqQAAAHIAAAA4AAAACgAA + AAAAAAAAAAAAAAAAAAAAAAAAkI6Ma7Sln//2s5j//d3I/fzZxP/82cX//NnF//3Zw/382cX//NnF//3b + xf/hwrD/vbu7/eTj4//k4+H/5OPh/+Pi4f/l5OX9vry7/1l4dP9Renb/UXl1/U52cv9NdnH/T3Zy/1F4 + df9UeXf9VXp4/1R6d/9Tenf/Vnt4/Vp+e/9liIX/c5OQ/4Sgnv+Qqqj9lq2t/5evrf+Wr63/lqyr/ZWt + rP+SrKv/kquq/46pqP2Np6X/iqSh/4ahoP+Cnpz/fZqY/XCQjv9Ve3j/XoF+/5Wtq/2juLb/nbS0/5u0 + sf+csrH/XImf/QVSif81cJP/kKmn/4mkov1tjoz/WHRy6hAWFp0AAABmAAAAJTU1NQQAAAAAAAAAAAAA + AAAAAAAAko+OQqCbmPTrp4///d/O/f7ey//+3sv//t7L//zcy/3+3sv//t7L///fzf/Lr6L/0dLS/erp + 6f/q6ef/6unn/+no5//t7Oz9qaqo/1R3c/9NdXH/SnJu/VuAfv9ujo7/eJaX/3yam/9/nJ79gp2f/4Cd + nv+AnJ3/dJOT/WKEgf9khoP/WX56/1F4df9TenX9Y4aD/3uZl/+Qqaj/mLCv/Zevrv+Wrq3/k6uq/5Kr + qv2Pqab/jKal/4eiov+EoZ//f5ya/XmXlf9yko//XIB9/052cf2OqKb/oLa1/5yzs/+bs7H/ep2m/QpR + h/8iYIz/iqWm/42npf2EoJ3/a4yJ/0pgX9oCAwOJAAAATgAAABMAAAAAAAAAAAAAAAAAAAAA2NfWHY2M + i9vSnYv+/9jG/vzi1f384dX9/OHV/f3h1f784dX9/eLV/fvf0f21oJX96+vs/u/v7/3u7+/97u/v/e/v + 7/3v7+/+ipGP/Ulxbf1Venj9eZeY/oKdn/2BnZ/9gZ2f/YKeoP2Dn6H+hKCg/YWfov2GoaP9dpST/nGQ + jf2AnZv9f5uZ/XyZlv10k5D+ZoiF/VZ7d/1MdHH9Wn98/n2amP2Vraz9mK6t/ZOsq/6Rqan9jqil/Yul + ov2GoqD9gZyc/nuZl/11lJL9bo+M/V+DgP5MdG/9lKyr/Z61tP2cs7L9kaus/hVVhf0XVYb9fJyi/Y6o + pv6LpaP9fJmX/meHhfwtPDu9AAAAdAAAAC8ZGRkGAAAAAAAAAAAAAAAAAAAAAI+OjKatm5X/+rqi/f7q + 4P/+6N7//uje//zo3v3+6N7//ung/+7Nv/+2qaX/+fn5/fT09P/19fX/9PX1//b19f/j4OD9Y3h1/1l/ + fP9/nJ7/gZ6f/YGdoP+Dn5//gp6h/4Wgov+EoKH9h6Gk/4eipf+KpaX/cpGP/XmWlP+HoqD/g6Ce/4Ke + nP9/nJr9fZqY/3qYlv92lJL/aouH/VV7eP9SeHT/bI2K/4umpP2Uraz/kKmo/4ylpf+Io6L/g5+c/X2b + mf93lpL/cJCO/2iKh/1Yfnr/Vnx4/5Stq/+dtLL/m7Kw/Sdeif8TT4L/bY+d/4+ppv2KpqT/h6Kg/3GR + j/9ffnvxCAsKkgAAAFMAAAAVAAAAAAAAAAAAAAAAAAAAAKCdnE+SkI/72JqE/v7h1f/+7OT//uvj//zr + 4/3+6+P//+nf/8yjlP/W1dX//Pz8/fv7+//7+/v/+/v7//7+/v+0s7L9VHVz/3uYmv+Dn6D/gp6h/YOg + ov+EoaH/haKi/4ahpP+HpKX9iaWl/4ympv+Np6j/bY2L/YOenP+Np6b/iaWi/4ijoP+EoZ/9g5+d/4Gd + mf9+m5n/fJmX/XiWlP9ujov/W398/1F3c/1rjIr/iaSi/42opv+JpKL/hKCe/X6amP94l5T/cZGN/2mL + iP1fg4D/THRw/16Cf/+asa//n7Wx/T1qjv8SSX3/XIKX/5KrqP2MpaP/iKOh/3+cmf9piof9NERCwgAA + AG8AAAAsNDQ0BAAAAAAAAAAAAAAAANXU0xGIhoS/oJGM/+yqk//+4tf//uvj//7r4/3/6eD/7rqm/7Kf + l//y8/T/9vb2/fb29v/29vb/9/f3/+7t7f9xfnv9Y4eF/4Sgov+EoaH/haCi/Yaho/+JoqX/iqOm/4qk + pf+Lp6j9jaeo/5Coq/+Qqqr/bIyJ/Yumo/+TrKr/kamn/42np/+MpaP9iKOh/4ahoP+Fn53/gZ2b/X6c + mv98mpf/epiV/3KRj/1Zfnv/VXp3/3STkf+HoqH/haGf/X+cmv95l5X/cpKP/2qLiP1ghID/VXt3/0py + bv9xkY7/obez/VN5lP8UR3v/TXOP/5OtqP2LpaP/h6Kg/4Sgnv9xkY7/Wnh17AQFBYcAAABCGRkZCwAA + AAAAAAAAAAAAAAAAAADZ2Nkog4GA7JaLhv/Ol4P/97Sc//y8pf3cnIT/oIyE/9TU0//l5OP/4+Li/eTj + 4v/l5OP/39/f/6Gclv9mhoH9fJqa/4ijpf+JpKT/iaWm/Yymp/+Mp6j/jaeo/5Cqq/+Sqqz9lK2s/5au + r/+Wra3/aYuI/ZWurP+asrD/mLCu/5Surf+TrKn9kaqo/4+npf+Lp6X/iqWh/YehoP+EoJ7/gp6c/3+c + mv19mpj/dZSS/12Bfv9Qd3T/d5WU/YGdmv95l5X/cpKP/2qLiP1hhID/VHt3/1J4dP9JcW3/iqWi/WuM + nP8ZRnn/QGaI/5KsqP2Np6X/iaSi/4Wgn/98mpf/aYuI/yMvLqgAAABOGhoaEQAAAAAAAAAAAAAAAAAA + AAAAAAAAmpiWQYOAf+iChIT+iIOB/YuCfv6MjYz9ysnI/dva2v3Z2Nj92djY/tnY1/3Ix8j9pZyW/e3C + nv2KmIz+fpuc/Yymp/2Npqj9jaeo/o+qqf2Sq6r9lKut/ZSurf2WrrD+mLCw/Zyzs/2YsLD9aIiF/p60 + sv2gt7X9nrWy/Zyzsv2YsLD+l7Cu/ZWurP2TrKr9j6qo/o6opv2LpqT9iaKg/YWioP6Enpz9gZ6b/X+c + mv1xkY79S3Nv/meJhv14lpT9cZGP/WmLiP5ggoD9U3p2/VN6dv1OdXH9XoJ//nyXov0fRnf9OV2B/ZKr + p/6Np6X9iaKg/YWgn/2AnZr9a42K/jNEQroAAABUGhoaEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIqK + ii6UfnXRmol//5SHgP2qnJX/saOd/6+knP+vpJz/sKSd/bGimv/AppL/7sGf///Ppv+MmI39eJeX/5Cp + qv+Qq6r/k6yt/ZWsrv+Vr67/ma+x/5uxsf+dtLT9nra2/6K4uP+ftbb/aIiF/aO5t/+lu7r/ori4/6K4 + tv+ftrP9nbSz/5uxsf+Zsa//la+t/ZStq/+Qqaf/j6mn/42npf2JpaH/iKOh/4Sfn/+Dn53/cpKN/U10 + cf9dgX7/cI+N/2iKh/1fg3//U3p2/1N6dv9SeXX/SnJu/X+anv8mTX7/MV+O/3+fp/2Np6X/iaSi/4Of + n/+BnZv/bo+M/jhKSMEAAABVGhoaFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGtpA/pm3jR9quI//Kv + i/3yso7/8raR//K5lP/yvJf/8r6Z/fbDnf/+yqP//8yl///Qp/+boJD9b46O/5Krq/+Wra//l6+v/Zmy + sv+ctLT/nbS0/5+3tf+jt7f9pLu7/6i9vP+lurr/aIiF/aa8u/+qv77/qb28/6e8uf+jurn9ore3/5+3 + tP+etrT/nLSy/Zqwrv+Wrqz/la6s/5Osqv2Pqqj/jqam/4umpP+GoqD/aouH/XWUk/9XfHr/WH16/2aJ + hf1dgH7/Unl1/1N6dv9Tenb/SnJs/VGDm/8oXJL/Ik2B/0NjhP2Qq6b/h6Kg/4Ogn/+BnZv/cJCO/jtN + S8QAAABUGhoaEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGFENjj7rIbt/LCL//y1j/39uZP//b2X//3A + mv/+w53//cag/f7Jov//y6P//82m///PqP+yq5b9ZYiF/4mko/+cs7P/nrW1/aC3tf+it7f/o7q6/6e8 + u/+pvr39q8C//6zAv/+nvLv/aIiF/aW6uf+rwL//rMC//6vAv/+pvr39pr26/6a7uv+iuLj/ori2/Z62 + tP+dtLH/mbGx/5evr/2Wra3/lKur/5Gqqf96l5X/bIyK/Yahov9/nJ3/VXp3/1V7d/1agHz/Unl1/1N6 + dv9Tenb/T3Zv/S1eg/8fRHX/HUV3/0Jkhv2QqqX/h6Kg/4Sgnv+AnZv/b4+N/jlMSsEAAABPGhoaEQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2OcWT8roj8/LON/vy2kP77vJb9/b6X/fzDnP38xJ/9/Mig/v7J + pP39y6b9/c6n/f/PqP3Rup7+bY2L/XKRjv2dtbT9pLm5/qa8u/2ovr39q7++/azAv/2swL/+q7++/am+ + vf2jubf9aYmG/puysv2kurn9p7y8/aq/vv2swL/+rMC//aq/vv2ovbz9pby5/qW6t/2ht7f9oLe0/Z61 + sv6csrL9mrKw/YumpP1oiYf9g5+f/oijpf2GoaP9fpub/U11cP5Tenb9U3p2/VF4dP1SeXX9UHdw/i1g + gv0ST4T9DU6D/UJsi/6PqaT9hqOh/YKenP2AnJr9bI2K/jVGRLkAAABKGhoaDwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPGohpf8sYr/+7WQ//u4lP39vpj//sGb//7DnP/+x6D//sij/f/Mpf//zqf//82o///P + qP/uyaX9epSP/3+cmv95mJX/rL+//azAv/+swL//q7+//6q/vf+ovLz9pby7/6W7uf+htrX/a4yJ/ZKr + qv+etbX/oLW1/6G5t/+ku7n9qL29/6u/vv+swL//q8C//am+vf+mu7r/pru6/6K4uP2iuLf/mrKw/3CP + jP96mJf/jqip/Yukp/+Io6P/haGj/3iXl/1IcW3/Unl1/1N6dv9Tenb/UHdx/TBkfP8PTYP/PWWI/4qk + pP2LpaP/h6Kg/4Ofnf98mZf/aouH/ys9M68AAABLGhoaDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOyj + f7z8s43//beQ//u6lv38wJj//sOb//7Gn//+x6D//cmk/f/Npv//zab//8+o///PqP/+0Kj9iZqF/4ul + pv99mpf/haKg/aq/vv+ovbz/p7y7/6a7uv+kurn9ore3/6C3tf+ftLP/bo6L/Ymjo/+XsLD/mLCw/5yy + sv+ftLT9oLa2/6S6uf+mvLv/qb6+/avAv/+swL//qr++/6i+vP2lu7r/eZeV/3SSkP+Tq63/kaqr/Yym + p/+Jpab/hqGj/4eho/1ihYT/TnZx/1N5df9Tenb/T3dx/S5edv8ZR3v/ZIKU/5Cqpv2Jo6H/hqCe/4Ke + nP9xkI//Zo5+/iFKDbAAAABNGhoaEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPSqhdj8tY///bmT//29 + lv3+wZv//sOe//7Hn//9yqP//cyl/f/Op///z6j//8+o//7Qq/+htFL9WqFC/3qYlv+mu7r/dpSR/Yij + of+kurn/o7m3/6G2tv+ftrP9nbSx/5qxsf+asbD/cpGO/X+bm/+Sq6z/kq2s/5atr/+XsLH9mbKx/52z + s/+etbb/obe3/aa7u/+pvr3/q7++/6zBwP2En53/b5CM/5atrv+YsLD/lKus/Y+qq/+Np6f/iKOm/4ei + pP1+nJ3/THRw/1J4dP9TeXX/T3Zv/SJYfP8iUID/gJug/4ynpf2JpKL/haGf/3qYlv9riIj/PKVj/iFS + B7UAAABPGhoaEQAAAAAAAAAAAAAAAAAAAAAAAAAA7828Cvmviez8tpD//bmT//y9mf3+w5v//saf//3H + ov//y6T//c2m/f/NqP//z6j//tCs/6a3V/9KwD39XNuJ/2iaiv+ds7P/qL69/XKRj/+Anpv/nrW0/5yz + sv+asLD9mLCv/5Wvrf+Vraz/eJaU/XaUk/+Npqj/jamo/4+qqf+Rqqv9k62u/5evsP+YsbD/nLOz/Z20 + tP+itrj/pbu6/4ijof1piob/mrGx/6G3t/+cs7L/lq6w/ZSrrf+QqKr/i6Wm/4ikpP2IoqP/WX97/011 + cf9TeXX/SXJv/RVPgP9DbIz/kKmm/4ukov2Io6H/f5yZ/22Kiv9Vkn3/CMJL/iJWCrkAAABRGhoaEgAA + AAAAAAAAAAAAAAAAAAAAAAAA9dLAF/uwi/H7uJL+/byW/f3Amv78xJ79/Meg/f7Iof39zKX9/syl/v7P + qP36zab9lbZM/UrFSv1b4ZX+YuKV/WbGkv12kpH9q7++/qO5uP15lpT9dJOQ/ZStq/2Vrqv+k6qq/ZGq + p/2PqKf9fZuZ/m6Oi/2HoqT9iKOm/Yymp/2Mpqf+jqeo/ZCpq/2Sq6v9lK6t/piwsP2asbH9fpqZ/WmK + hv6juLf9q7++/aO5uv2gtbb9mrOx/peurv2RrKv9j6eo/Yqmpv6JpKb9dZSU/Upybv1SeXT9NWdz/htV + hv2AnqL9jqel/Yqlo/58mZf9bImI/VaSff0KvFX9AcNP/iJbC70AAABUGhoaEwAAAAAAAAAAAAAAAAAA + AAAAAAAA99TBIfuyjPX9uZP//byX//zBm/3+xZ///sih//3Kov//y6b//s6n/fjNpf+Ttkv/TMVN/1jd + j/9f35P9ZuOY/23jnP9ppYr/jKSk/aa8uf+etrT/gJya/26OjP+HoqD9jail/4ympP+JpKL/gp6b/WqK + h/+Cnp//hqKj/4ahpP+JpKX9i6Wm/4ulpv+NqKn/kKmq/Y6oqP90kpH/cJCO/5uzsf2rv77/rMC//6m+ + vf+kuLn/n7S0/Zmysv+Wra//kqus/42oqP2Lpaf/hJ+g/1F5dv9Kc2//HFyA/WyQn/+Rqab/haCe/3OS + j/1oiIf/UJlw/wy8Vf8Awk//AMNR/iBfD8EAAABVGhoaFAAAAAAAAAAAAAAAAAAAAAAAAAAA+NXCIvyz + jfX9upT//b+Y//zBnP3+xp7//cmi///LpP//zaX//s6r/aW6W/9KxEv/UtuL/1vfkP9j4JX9aeSZ/3Lm + oP9y2JT/a5CH/Zeurv+ftrX/mbGv/4eioP9tjov9fpuZ/4ahn/+EoJ7/gZ2b/WmLiP97mJn/g5+h/4Sg + oP+EoKH9haKi/4ijpP+KpKX/hqGi/XCPjf92lJL/mbGw/6S5uP2ou7r/q7++/6zAv/+ovbz/o7e5/Z21 + tf+asLD/lK6t/5Kpqv2MqKn/i6Wn/1yBfv84a3X/W4ia/YWgnf90kpH/aomJ/3OMhf2nnnT/NLU0/wDC + UP8AwlH/AMNS/h1lFMQAAABVGhoaEwAAAAAAAAAAAAAAAAAAAAAAAAAA+dbEHPy2j/P9upX//cCZ//zC + nf3+x6D//cih///Mpf//zan/vb1r/UvCRv9N3Ij/Vt2N/17gkv9m45b9buWd/3Xmof9866j/e8+g/XCP + jf+Xr63/mbGv/5Stq/+Io6H9bo2L/3KRjv99mpf/fJmX/WyMif9vj43/e5mZ/4Cdnv+Cn6D9hJ+h/4Of + oP94l5f/aIqH/XuZlv+XsK7/nbSz/6G3tv2jurn/qL26/6u/vv+swL//p726/aK3uP+cs7P/l7Gx/5Ws + rv2Qqqv/iqSk/1+Ehf9Vf4j/b42M/WiIhf9gj3T/V5VB/2iTIf1crB//Cr5F/wDCUf8AwlH/AMNS/h1l + E8MAAABRGhoaEgAAAAAAAAAAAAAAAAAAAAAAAAAA+9jFD/y1j+77vJb+/b+a/f3Env78xqH9/sqi/f/M + p/3YxoX9Rroz/kfZgv1R3In9Wd2N/WHhlP1p4pj+ceaf/XfnpP2A6qj9iPCv/n3Fn/1wj4z9kqqq/ZOr + qv2Np6X+haGe/XSTkP1ri4j9a4yJ/mmJhv1qi4j9aouH/WmLh/13lZX+dpWU/WqKiP1ri4j9gZ2b/pGq + qP2Vrqz9mbCw/Zyzs/6htrX9pbm5/am9vP2rwL/9q8C//qW6u/2gtrb9nbS0/Zavr/6Ura39d5SV/WWL + d/1hjlv9Wpc9/jazQ/0Nw1H9Grw3/TKyIv4Kv0f9AMFR/QDAT/0AwlH9AsNP/iJeDLsAAABKGhoaDwAA + AAAAAAAAAAAAAAAAAAAAAAAA/NrGAvu2kOL9vZf//sGb//zFnf3+yKH//sqk/+rJlv9euz3/PtZ8/Ura + hP9T24r/W9+Q/2PglP9r5Jv9c+eh/3vopv+D7Kz/i+2x/ZLzt/+Dx6X/b5CM/4mkov+MpqT9haGf/4Cd + mv91lJL/aoqH/XWVkv9/m5n/fpuZ/3SSkP9oiYf9aoqH/3eUkv+Cnpz/h6Oh/Y6npv+Sqqj/lK+t/5qy + r/2etbT/ori3/6a7uv+pvr3/q8C//au/vv+ku7n/n7a3/520tP2LpKb/YY9i/0avI/81wD3/JMVP/RHI + Xf8KxVj/AsNT/wDCUv0AwlH/AMJR/wDCUf8AwlH/DcBH/yJRB64AAAA/GhoaCgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPq6lcf9vpb//sCa//zFn/3+yKD//8un/6O/Xv84zF//Qdd//Urahf9V3Yv/Xd6R/2Xi + lf9t5Zz9deii/33qpv+F663/je+x/ZXyuP+e9L7/j9Gt/2+SjP9/mpn9g5+d/32amP90k4//b4+M/Yah + n/+TrKr/kqup/4Ofnf9ujov9bIyJ/3uYlv+AnJv/hKCc/Yijov+PqaX/k6yq/5evrP2ZsbH/n7Sz/6O3 + tv+murn/qL69/azAv/+qvr7/pbu7/5GoqP1mkYf/Qr5Y/y/NZ/8kzmz/G8tl/RTHX/8Mxln/A8JS/wDA + T/0AwlH/AMJR/wDCUf8AwlH/Gb87/xo8BJgAAAAyFxcXBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPq7 + lqb9vZf//sKc//zGnf3+yKL/9Mmb/2S+Rf841Hj/Q9d//UvZhv9W3Yz/XuCS/2bjl/9u5J39deij/3/r + p/+H7a7/j/C0/ZfxuP+f9b//p/nF/6DjvP9zmZD9bo6M/2yMiv9sjIn/bo2L/YeioP+gt7X/n7a0/4mk + ov9ykI39aYmG/3CPjf95l5T/gJya/YWhn/+LpqT/kKmn/5Osqv2YsK7/nLOy/5+2tf+jubj/qLy7/au+ + vf+kurn/haCf/2WUhv1Hxn7/NdV4/y3Rcf8mzmv/HMtl/RXHX/8Nxlj/BMJU/wDAT/0AwlH/AMJR/wDC + Uf8AwlH/Jrcv+woYAHkAAAAmg4ODAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPu7lnv9vZf//MKc/fzE + n/7+yKL948WN/UvCSv051n39QtZ+/k3bhf1W3I39XeCR/Wfjlv1v5J7+duii/YDrqf2I7K/9kPCz/pjz + uv2f9MD9qfjE/bH7y/2z9Mz+fKSZ/WaGhf10k5T9epeZ/nGRkP1/m5n9iaSi/X6bmP1sjIr+b42N/W2N + i/1qi4j9bIyJ/nSSj/1+m5n9hqKg/Y2npv6TrKr9l6+u/ZqxsP2Zr679kKmn/nyamP1riov9XJhi/UvV + gv4/1379N9J2/S/Pcf0lzmv9Hstl/hTHXv0Nxlr9BMJT/QDAT/4AwE/9AMBP/QDAT/0AwlL+L6Uh7AIF + AGQAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP3PtEX9vZf0/sKc//zGn/3+yaL/38aK/0jD + Tf861n3/QtZ+/U3bh/9X3I3/X+CT/2bjmP9w5J79eOik/4DrqP+I7K//j/C1/Znzu/+h9MH/qvjG/7D7 + zP+7/dH9yf7c/7PbyP+CpJ3/aYmI/XKQkP92lZX/cpCQ/2eJhf9ykZD9dZSU/3iWlv96l5j/eJaX/XOS + kv9vjo3/a42L/2qKif1rjIr/a4yK/2mJh/9jhoT/YYWD/YiYjP9ppT3/TMpS/0rahv1B1X7/NtJ2/y/R + cf8lzmv/Hstl/RTHXv8Nxlr/BMJT/wDAT/0AwlH/AMJR/wDCUf8BwlD/MIcV1gACAE8AAAARAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzl2B77vJbg/sKc//zGn/3+yaL/3sSJ/0jDTf861Xv/QtZ+/U3b + h/9V3Iv/X+CR/2fjmP9w5J79eOik/4Drqf+I7K//kPC1/Znzu/+h9L//qfjG/7H7yv+5/dD9xv/a/9D+ + 4f/Z+ub/yePX/Y+wn/9li3f/bYyM/2uKi/9tjYz9dJSU/3iWlv96l5n/e5ia/XyZm/97mZr/eZeZ/3ST + lf1uj4//bIyL/3iRi/+aopP/1cCl/aC+XP9Sy1f/UtyL/0rYhP1B137/NdR4/y3Rcf8mzmv/Hstl/RTI + Xv8NxFr/BMNT/wDAT/0AwlH/AMJR/wDCUf8LwEj+KFwItAAAADc0NDQIAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP7q3wH7vpiy/sGa//zGn/3/yaX/xcF0/zvGVf851Xr/Q9Z+/UvZhv9W3Yz/XuCS/2Xj + lv9v5J39d+ij/3/rp/+H7K7/j/C0/Zbxuv+g9cD/qPjH/7D7zP+3/c/9w//Y/83/3v/W/+T/4f7s/dT0 + 1f9lsTn/UJIr/1qKTP+Fm5D9eZSN/3OQjP9xj4z/co+M/XSRjP96lI3/gpeO/5Kfk/2urpr/0b+j/+vN + qv/91K//5s6W/VjGT/9Y34//UdyJ/0nZhP1A0m//PMhX/y3Oaf8mzmv/HMtl/RTIYP8Kxln/AcNT/wDC + Uf0AwlH/AMJR/wDCUf8duTf7GDMCgwAAACFVVVUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD8y6xd/sCa+/3Fnv73x57/brtF/y/Pav851Hn/QNd9/Uzahf9U3Yv/W+CR/2Xhl/9t5Zz9deii/33p + pv+F7a3/jO6x/Zbyuv+U7q7/g9p9/5fpoP+1/ND9vv7V/8f/2v/P/+D/1v3k/d3/6f/S9tj/oNyO/0yi + Ef/b05/979u6/+XWtP/i1LL/49Kx/ebTsf/v1bH/+Ney///as/3/2rL//9ex//7Vr//+1K7/6M2Z/VnI + Vf9X3o//UNuI/0XVef15uED/wcJy/1e/Rf8izWr/Hclg/TK1Lv9EsTX/OLs//wHBTf0AwlH/AMJR/wLC + T/8vnR7lAgQATgAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+7+cZ/L6X1P/F + oP6xvGH9LcZT/S7Rc/020nb9QNV9/krYhP1S24r9Wt+O/WHglf1r5Jn+c+ef/Xnopv2B7Kr9jPC1/nXb + e/2EwU791M6Q/X/BSv2x/M/+uP3P/b3+1f3F/dj9y/7d/s793v3R/uH90/3m/X/MXv3z3LP+/OG8/fzf + uv383rn9/N24/vzbtv382rX9/dmz/f3Ysf781rH9/Nau/fzVrf3+0qz9/9Ku/mvASP1T24j9TNuH/UTM + XP6brkb9/s6q/W+7RP0gzGb9GMpj/je0KP1ymiD9s7Va/Qe+P/4AwVD9AMJR/RC+Q/4kVAirAAAAMV5e + XgUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/cWigf/Eov9auDf/JM1p/y7P + cf8203b/PdZ6/UbZgv9Q3If/WN2O/2DhlP9o4pn9cOaf/3jnpP9/66r/atFq/a7Eaf/517H//9q4/6rF + Zv+a7639s/zO/7j9z/+7/tT/wf7V/cX/2f/G/9r/v/nS/4bFVv//4cD9+965//veuf/93bj/+9u3/f3b + tP/92rT//dmz//zWsv3+1a///tSv//7Trv/+0qz//9Ox/Za/V/9N1nn/S9uJ/z/KV/2zt2D/scBp/zPD + TP8fzGj/F8lh/RTEVP9lqin/sLRb/we+P/0AwlH/AMJR/yWuLfIRJQF4AAAAHAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/tzNJs25c+srvjz/I85q/yzQbv800XX/PNV5/UXY + gf9O24f/VtyM/1zgkP9k4Zf9beWb/3XmoP9966r/UbQs/cG+eP//2rb//tm1/77Id/+M6Jr9rPrJ/7H7 + zP+1/M3/t/3P/br+0f+9/tb/k+CM/7zMfP/+37z9/d65//3duP/93Lf//ty4/f7bt//92LL//Niy//zX + sf3+1rD//tWv//7UrP/+06v//tKs/drKjP9bwUj/Q9Jv/z/DRf3myI7/ZL1D/yTNaP8fzGb/Fclg/RHF + Vv9SqBz/Zq4u/wPASv0AwlH/BcFN/y6KF9UBAwBKAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAntV/FUezJt8ZyWD/Isto/yrPbv8w0HL/ONR5/ULXf/9L2oX/U9uK/1vf + jv9j4JX9auSa/3Hmn/946af/XcNJ/WOaHv/izJr//tm3/6XDYP+S7az9pvfF/6r5x/+u+sn/sfvK/bT8 + z/+b6qL/k8Vb//rcuP/83bj9/d22//3ct//727f/1MmO/c3Gh//92bP//taw//zVr/3+1K7//tSu//7U + rv/+063//tKr/f7Rq//YyIj/osBg/7PCa/3/zqr/ab1E/yLMZv8by2X/E8hf/Q7FVv83siH/GLo4/wDC + Uf0AwlH/FL1A/iRWCJ0AAAAoVFRUAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAveGmFDe0INoUymX+H8xn/SfObP0tz3H9NdN1/j/Wff1I2YP9UNuI/Vfcjf1d4JL+ZuGX/Wvj + nP1056H9dOKT/kiiDP1XkhH9jahC/Wu8Pf2b9cD+n/W+/aP1wv2m9sT9qfjG/qv5yP1sv0P93tGb/f7c + t/373LX+/Nq2/fvbt/2jt1r9Rp0H/kaSBf3Cvnn9/9u7/f/ZuP7/17X9/dOt/evLnf3jyJX98s2h/v/S + r/3/0Kz9/9Cs/f/Pq/7/zqv9nr5b/SLGVP0ZymP9EsZd/gjFV/0BwlP9AMFR/QDAT/4Aw1L+L6Uh5wsZ + AFQCAgMPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGy7 + M1ApvkH/G8tm/yTNav8qzm//MtJz/TzVef9F2ID/TNqF/1Pciv9a3Y/9YOGU/2jjmf9v5Jz/deil/XPg + jf9bvz//VbYv/3/ikf+S8bb9l/K6/5z0vf+e9b//ofTA/aH2wf9Zsyz/r7lo//7cuv/72bT9/9q3/7fJ + dP9nylb/j/Cy/WTFT/9FkQD/cJ0r/3yhNf1lmh7/UZYH/0WVAP9DlAD/RY8A/WmZIv/KvXv//s+p//7N + pv3/zaf/8MmZ/2W5O/8Wxlb/DsZb/QbCVv8AwVD/AMJQ/wDCU/4guzb9IUsGhQAAABpJSUkBAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBrQ2kIMZX/R/M + aP8pz2v/MNFy/TjUeP9A1X7/RtmB/0/bh/9W3Yz9Xd6R/2Lilv9q5Jr/cOad/Xboo/986qf/geuq/4bt + rv+L77L9je2w/4Pllf+P66n/mfO7/Zz1wP9tzV//aJ8h//zZtP/92bP959Of/3XJWf+N8LX/iu6x/YDo + o/9iylf/VLcy/1W9Pv1ZxlP/W9Bn/1nTcP9U0Wv/TsdR/UarHP9lnSL/7cmb//7Op/3/zab//8qk/+fE + j/9otzr/DsNP/QPDU/8AwVD/AMJR/wvASP8zfQ24AgUALiIiIgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACn1oYgPLgs3B3KY/8lzWr/LM5u/TTR + dP881Xv/Q9Z+/0rahP9R3In9WN6O/17fkv9j4pX/aeSb/XDmnf926KP/e+mm/4Drqv985pr9e8dW/6PE + Zf93yFb/kfG5/ZLxt/+E5Zj/ZKwn//fVrv//2LT9xst//3XafP+I7rH/geyq/X3qqP946Kb/ceaf/23k + nf1n45r/YeGW/1rfkv9Q2YL/S9Fs/UnGTf+BukP//c6n//7Mpv3/zKX//cih///Hov/qwY3/VbYz/QLB + Tv8AwlH/BMBO/jOmHuYIEQBDCAgJDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY7gvXSy/QfUezGn/Js9t/S/RdP821Hn/PtZ8/0TY + gf9M2ob9U9uK/1nfjf9f35H/ZeKX/Wrkmf9u5p7/dOei/3foo/90wEb969Gh//nWsf+ExFX/h+6w/Yru + sP+B6aL/jcNY///Xtv//17X9ocVk/3bikv9/66n/fOim/XXoo/9x5Z7/bOWc/2fjmP1h4ZP/Wt+R/1XN + Yf99vUn/ucNt/dLGgf/ny5b//s6n//3Npv3/y6T//cih//7Enf//wp7/2bp5/Si4Mf8AwVL/JLUw9R9F + BHQAAAASVFRUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA5/TfBVq4K44xvTj6L8BC/0i+Qf5SuDb9P8hY/T/Wfv1H2ID+TdmG/VPd + i/1Z3439Xd+R/mLilv1p45n9buei/V7XdP3Gx3n+/9a1/dvMkP1qx1T9geyv/n/rqv1ox1L9z8uH/f/W + sv3/1rL+hMNV/XXmnP146KP9dOeh/m/mnv1q5Jn9ZOGW/V/flP5b35D9Uth//W6zM/3/0K39/8+q/v/O + qP3+zqf9/c2m/f7Mpf79yqP9/sWe/fzEnf38wZn9/72b/pi1Tv4ouiz9MngMjwAAABIwMDACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAOb03gORyWUp3sGFreTEi/5jtTT/Ns1l/zrVev9A1X79R9eC/03Zhf9R24r/WN6O/V3g + kv9e3Ij/Xstc/26/Qv/z0KX93suT/2e4OP9w4pH/d+ij/WXFTP/MyoP//9Wy///Vr///1K/9eMRU/2/l + nP9w5p7/beOc/Wjjmf9i4Jb/X+CT/1rfjv1T3Yv/TtR0/12mIP/syJn//s+o/f/Npv//zqf//8yl//3J + ov3+yKH//sWe//7Cmv/9v5j//7yW/7KJaLcmTwdPDxwIDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/+bcEpm8WsYqyVz/LtFy/zTTdv881Xr9QNd+/0fXgv9M2ob/UNyJ/VXci/9buzz/zcaA//LP + o//40aj9ecBM/2PbhP9t5Jv/ZsVP/czJg///1bH/48mU/9PDhv/eypP9Z8ZS/2rkm/9o4pn/ZeKX/WHh + lP9b3pH/WN6O/1Lbi/1O24f/SNZ7/0epGf+WqEn//9Gt/f/Opv//y6T//8uk//7Jov3+xqD//sOb//3A + mv/+vJb+yJF0uxYPDCwGBQcFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFGz + IHkqx1j+KM9u/zDRcf8203b9OtR5/z/WfP9E2IL/S9qF/U7agv9PqRv/yLx5///Sr//izJT9YNNx/2Tk + nP9Xy1r/vMFx/f/Us//Vxof/XaMd/0uUBv9aqSL9X9d7/2Pil/9h4ZT/XuCQ/Vrdj/9U3Yz/UdyJ/03Z + hv1G2YP/QdeA/0DDSf92piz//86t/f/Lpf//y6P//smj//zFn/3+xJ7//cGa//y8l/vKlXe6FA0LKQMD + AwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALbenBNVuS2xKsdX/yjP + cP0v0HD+UL0+/VW+QP0+1Xv9QtFw/kjFS/1KtCj9VZML/YujO/2BpTb+WNV4/Vzgkv1OujX9kadD/urO + nP1ovUD9WdZ0/VfMW/1a1nn+Xd+S/VvfkP1Z3Y39VtyM/lLciv1O24f9StiE/UbYgf5B1X79O9V7/TfN + Zf12rTT9/82r/v3LpP3+yaP9/Mef/f3Dnv79wpv+/r+Y/LmKbaIRCwggQUJCAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADr9eMMXLguoivGVf8sxU3+yMR6/57A + Yf8zzWL/abMv/cPDdf9KxlD/Sbo1/0ewJP9Jti/9UdmC/1Tdjf9SzGH/RZQA/VmkGf9V2Hv/WN6Q/1je + j/9W3Y39Vd2M/1Pbif9R3In/TtuH/Unag/9F14D/Qdd//z7UfP041Hn/NNN2/zHLYP92rTP//8up/f7J + o//+x5///sWe//3CnP7+wJn2fV1LdQIAABJISEgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6PPfEFu6MJtQsibK8cac3KK/YP4xx1L/UJsI/X6o + M/9Dylz/QNiC/0PZg/9G2YT9StqE/0zZhv9N2of/TMRL/UmeA/9Nv0L/UNyJ/07aiP9O24f9TdmG/0va + hf9J2IL/RteA/UPWf/8/1nv/O9V6/zbSd/0z0nT/LdFx/yzJXP92rDH//8mn/f7Hn//+xJ7//sOc/vS4 + lN5xVEJbGBgXDWZnZwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAOjz3wja6skT/OfZJs7JiJc5vz/4Prcw/kCzKf820Gv/PMxh/0zE + Tf9Dyl79Qdd//0TYf/9G2IH/R9iD/UjFUP9Jw0j/SNiC/0fZgv9G14D9Rdh//0PWfv9B137/PtZ8/TvV + ev821Hb/NNF1/zHRcv0s0G//Js9s/ybIWf+FsUD//8el/v7Env/5v5nrv5FzmjsqISwjJSUDAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPf79AV5w02DMcRL/C3MZv5MvkD/pb5f/6u7Wf88wEL9OdR6/zzV + e/8+1nr/P9Z8/T7Xf/8+1n//QNZ9/z/We/8+1nz9PdV7/zvVev8503f/NtJ1/TLRdf8w0XH/LdBw/yrP + bf0lzGn/H8xo/yTET/+3vWb+/8Sg9t2ohq1gSDpDJyMiCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAdcBDWkipC4DUvn+a9cmf5VO5M/8r03n+MdJ0/jPSdf0003X9NtN1/jfS + d/030nX9N9J1/TXTd/0z0XH+MMxi/TDRcv0v0nX9LdFx/izQbv0ozW39JMxp/SHMaP4cy2f+HsdY/1iz + NOm/nHSaYEg5NigpKQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD+/PoB+ObTEXG7PWw9tijZMcdU/zXFUf8uzmn/LNBz/i7Rcf8u0XH/LtFx/y7L + X/9zuT/+q75g/3O6RP83wUb/J8tk/iLObP8ezGr/HMtm/xvKX/8rwUP7OJMRsRQkAzABAAAGAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACx3JYcdcBIWn6/UFlSuTG7McVO+ijLZf8mzWj/LMdW/Wy2OePzx5za/sek2/TF + mtjLvXjOX68twzS4LtwzuC/fObAjzzaXFKwpaANXPks2ElVUVQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADa7csQXLUmX1m7NqhWvTy/U6criElLMy1fUEYf6tvQHfvr4Bv56uIQ1+LDB8jk + siDJ5LQjx+C0EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////8A + AAD8AD/gP/////8AAAD4AB+AAf////+8lv7wAAAAAAD////Fnf/gAAAAAAAB///LpP3gAAAAAAAAB/+7 + Mv3AAAAAAAAAAH/ah/3AAAAAAAAAAB/glf3AAAAAAAAAAAfnov2AAAAAAAAAAAPrrP2AAAAAAAAAAAGa + jf+AAAAAAAAAAAGrqf+AAAAAAAAAAAGhnv+AAAAAAAAAAAGJhv+AAAAAAAAAAAGQj/+AAAAAAAAAAAOK + hv+AAAAAAAAAAAeJhv+AAAAAAAAAAB+gnv+AAAAAAAAAAB+rq/2AAAAAAAAAAA+0sf2AAAAAAAAAAAe5 + uP2AAAAAAAAAAAfAv/2AAAAAAAAAAAO4t/3AAAAAAAAAAAOwsP3AAAAAAAAAAAGIev3AAAAAAAAAAAGl + Gf3gAAAAAAAAAAHHWf3wAAAAAAAAAAG/Rf34AAAAAAAAAAHAT/34AAAAAAAAAAHCUv74AAAAAAAAAAEA + AFP4AAAAAAAAAAEAAAD4AAAAAAAAAAEAAAD4AAAAAAAAAAEAAAD4AAAAAAAAAAG7lv7wAAAAAAAAAAHF + nf/wAAAAAAAAAAHLpv3wAAAAAAAAAAHPbP3wAAAAAAAAAAHciP3wAAAAAAAAAAHilv3wAAAAAAAAAAHo + o/3wAAAAAAAAAAHsr/34AAAAAAAAAAHhsv/4AAAAAAAAAAGkov/4AAAAAAAAAAOenf/4AAAAAAAAAAOL + iP/4AAAAAAAAAAOdm//4AAAAAAAAAAOTkf/8AAAAAAAAAAeOi//8AAAAAAAAAAeioP/+AAAAAAAAAA+q + p/3+AAAAAAAAAA+yr/3+AAAAAAAAAA+3tv3+AAAAAAAAAB+/vv3/AAAAAAAAAB+8uv3/gAAAAAAAAD+1 + tP3/gAAAAAAAAH+ZNP3/wAAAAAAAAH/GUf3/wAAAAAAAAP/GWP3/4AAAAAAAA//CUv3/+AAAAAAAB//A + T/3//AAAAAAAD//CVP7//AAAAAAAH/8AAEv//gAAAAAAP/8AAAD//wAAAAAAf/8AAAD//4AAAAAB//8A + AAD///AAAAAH//+9lf7///wAAAAf///En/////8AAAB////NrP3////gAAD////Wff3////8AA/////b + iv3////////////hlf0oAAAAQAAAAIAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAAAASAAAAFQAAABUAAAAVAAAAFQAA + ABUAAAAUAAAADDo6OgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADo6OgMAAAANAAAAGAAA + ABoAAAATAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODg4AwAAABsAAABDAAAAXQAA + AGIAAABjAAAAYwAAAGMAAABjAAAAYAAAAFEAAAArAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAA + ABYAAAAxAAAAUAAAAGcAAABrAAAAXgAAADcAAAAZAAAAEgAAAA0AAAAIAAAABAAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANzc3AQYG + BiNHRUSgfHl44HBubOdwbWzncm9u53Jubedybm3ncW9t51pYV9UWFRWdAAAAcQAAADYAAAASAAAAHAAA + ACMAAAAeAAAAJwAAAEMJER5+Gi1OxyRCcPEkR3j3Ij1o6QkRHq4AAACEAAAAbgAAAGQAAABcAAAAUAAA + AEMAAAA1AAAAKAAAABwAAAARAAAADAAAAAgAAAAHAAAABQAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAgHBxiCf37R6enp//708v/14t7/p6en/4WDgv+KiIb/ioiG/4qIhv+LiIb/hoSC+yMi + IqsAAAB0BAQEXRAPD3YAAAB4BQcKfQ8dMqogO2XmJ0h5/yZOhP8cWZj/HFyb/yFdnf8qUIb9SGJp6E5m + ZOJAVFLWLjw7xx4oJ7cLDw+lAAAAkwAAAIcAAAB1AAAAXgAAAEkAAAA2AAAAKQAAACAAAAAbAAAAFwAA + ABMAAAAQAAAADQAAAAkAAAAGAAAABAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAADY2NgJubGmo8fLz//i9qP/8yKD//Nat//+7mf+hjIX/jo6M/5GN + i/+RjY3/kY6N/5GOjP+EgH73QT8/xYWCf/d5e4D/QFNu8ihHd/wpSn3/K1CD/y1Tif8kYaD/JWOl/yRn + qP8lZ6v/KGuv/zJVg/99m5b/dZSR/2+Qjf9qjIn/aImG/117ePZHXlzmISwrywUHB7QAAACjAAAAkQAA + AHsAAABjAAAAUQAAAEMAAAA6AAAANAAAAC4AAAAnAAAAIQAAABsAAAAVAAAADwAAAAoAAAAGAAAAAgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKSg+y87O//i8pv/+5rz///nP///3 + zf//+9H/8rOO/4uHhv+XlZT/lpWS/5eVk/+YlZT/kI2L/5GNif9ZZ3//IUN5/ylMgf8rU4j/L1aO/zFb + k/8xYp3/Km2w/ytws/8tcLT/LnO4/yx1u/8vaKr/epKd/5yzsv+bsrD/mbCu/5Gqqf+GoaD/eJaU/2qM + if9lhoP9T2hm7ik2NdcFBwfAAAAArwAAAJ0AAACHAAAAcgAAAGMAAABaAAAAVQAAAE4AAABGAAAAPQAA + ADIAAAApAAAAIAAAABcAAAAOAAAACAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoB+sPPc + 1f/8yp////PI///wxf//8Mb///DG///zx/+zjn3/m5qZ/56bmv+XlZP/h4SC/4eFgv+VlJb/JUl7/y5W + jP8vWpL/M1+Y/zVknv83Z6L/NnCv/zJ4vf80esD/NXzC/zV8xf80f8f/N4HJ/1h0kP+ftrP/m7Ox/5y0 + sv+dtLL/nbSy/521s/+bsbH/jqim/3yZlv9sjYn/ZIWC/EVbWesYHx7SAAAAvQAAAK0AAACYAAAAhAAA + AHcAAABwAAAAawAAAGUAAABeAAAAVQAAAEsAAAA/AAAAMAAAACMAAAAWAAAADAAAAAQAAAAAAAAAAAAA + AAAAAAAAp6akD7Cys/f3tZv//+2////svv//7L7//+y+///rvv//7sD/48Ke/5STlP+ioaD/iYaE/5OQ + jv+XlJL/foST/ypVjv80Ypz/NWWi/zlrpv87bq3/PXKx/z16vf86gsn/PITM/zyEzf88h9H/O4jS/z6N + 2f9IbJT/pLm2/561s/+ftrT/n7a0/5+2tP+ftrP/nrW0/561tP+ftbT/nLOy/4ulpP9zk5H/aYuH/1Rw + bfMgKyrZAAAAwAAAALEAAACbAAAAiQAAAIAAAAB8AAAAeAAAAHQAAABuAAAAZgAAAFsAAABOAAAAPQAA + ACkAAAAWAAAACAAAAAEAAAAAAAAAAC8tLEzVz87/+7uS///puf//57n//+e5///nuf//57n//+e4//7i + tP+Zj4z/oZ6d/5yamP+cmpn/paOg/3N/k/8yZKH/Om6r/zxysf8+d7b/QHu8/0B/wf9Dgsf/QYzW/0OO + 2P9Dj9r/Q5Ha/0KR3f9Fl+X/SWyW/6e8uP+gtrX/obi2/6G4tv+huLb/obi2/6G2tv+ft7b/oLW0/5+2 + tP+etbT/n7az/5WsrP96mJb/aYuI/1ZycPQeJybWAAAAvwAAAK8AAACfAAAAkAAAAIQAAAB+AAAAfQAA + AHsAAAB2AAAAbwAAAGMAAABQAAAANQAAABgAAAAGAAAAAAAAAABxb22H5sjA//7Nnv//4bL//+Cy///g + sv//4LL//+Cy///gsv//5rT/q5uN/56bmv+vraz/qaem/62qqf+DjJ7/Nmys/z95uv9Bfb//Q4HE/0WF + yf9Hic7/SIvS/0mU3/9Kl+P/Spfl/0qa5v9Jm+j/TJzr/1l2lf+nvLr/o7m4/6K4t/+iuLf/o7i4/6O4 + uP+jubj/obe2/6K4t/+htrb/oLW0/562tf+etbP/nbSz/5avrv95mJb/aYuH/0tlZvEMGC3dAQMExgAA + ALcAAACfAAAAiAAAAH8AAAB/AAAAfgAAAH0AAAB5AAAAbAAAAFAAAAAqAAAACwAAAAAAAAAAiIeGsu28 + qv/+16X//9yr///cq///3Kv//9yr///cq///26r//96s/7+qkv+enJz/wL69/7+9vP+qqKf/q662/zJp + qv9EhMj/RobL/0iL0f9Ij9b/SpLb/02V3v9PmOT/UKDt/1Ch7f9QovD/UKLy/0KJ0v9mgYv/lK6s/6G4 + tv+pvbz/qL28/6W7uv+lu7n/o7m4/6S6uf+kuLf/o7m4/6K4t/+htrb/oLW1/520tP+dtLL/nbOy/5Kq + qv90k5D/RGd+/x1BdPsMHzTfAAAAvwAAAJ4AAACDAAAAfwAAAH4AAAB9AAAAeQAAAG4AAABSAAAAKwAA + AAwAAAAAAAAAAJKTk8zytZ3//9mn///WpP//16P//9ej///Xo///16P//9ej///YpP/Ps5T/oKCg/8/O + zf/V1NT/paKh/+De3P86YZb/SpDZ/0mR2P9MlN7/Tpfi/1CZ5v9RnOr/UqDs/1Sk8/9VqPj/Vqv8/1Kj + 8/87Xob/YIR+/1V6d/9OdnL/VHt3/2yNiv+NqKb/pbq5/6m+vP+mu7r/pLu6/6O5uP+iuLf/o7m2/6C4 + tf+gt7T/n7a0/5yzsf+bs7H/mrKw/3+bmP8dVIL/ElOH/wQdMdsAAAC1AAAAkgAAAHoAAAByAAAAawAA + AGMAAABTAAAAOgAAABwAAAAHAAAAAAAAAACZm5vc8rGX//7cs//92K7//dGg//3Qnv/90Z///dGf//3R + n//+0Z//17aT/6eoqf/R0M//5eTk/7OysP/h4N//lJ+y/zyAyP9Pm+b/UJzo/1Kf7f9TpPL/Vaj4/1Sl + 9v9LluP/QoHI/zxwqv9FZoT/eZaU/32bmf+BnZv/g56c/3+cmv9ykY//W398/052cv9sjYn/lK6s/6q/ + vP+ovLv/pbu6/6O5uf+jubj/ori3/5+3tv+ftbT/nbKx/5mxsf+asq//Yo+g/wJWj/8UWoP3ERUSxgAA + AKcAAAB9AAAAWQAAAEYAAAA5AAAAKgAAABkAAAAKAAAAAgAAAAAAAAAAmZub3vSukP/+17D//tSt//7T + q//+y5n//sqZ//7Lmv/+y5n//sua/9ezj/+6urz/o6Gg//j4+P/y8vL/r62r/////f9xhqX/O3/I/0eU + 4f9BhMv/PHGv/zlkkv9AY3//VHJ9/2eEh/94lZL/f5yY/4Cdm/+Dn53/hKGf/4eiof+Io6L/iKSi/4qk + ov+Io6L/c5KQ/1V7eP9ReHX/e5mX/6S6uf+ovbz/pLq5/6K4uP+iuLf/oLW0/521tP+ctLL/mrGw/5au + rf8DX5X/AV6W/2OFg/ocJSS+AAAAjwAAAFoAAAAoAAAAFQAAAAwAAAAFAAAAAAAAAAAAAAAAAAAAAJWY + l93wrpL//taz//7Usf/+1bL//tKt//zHmf/8xJP//MSV//7Flv/VrYv/wsLE/8XDwv+opqX/2tfW/7Cu + rf+9u7r//Pv5/7q+yf+fqLf/g4SJ/1Z6df9ihoD/a42J/3KSkP94l5T/fZuZ/4Kemv+FoZ//iKOh/4ql + o/+MpqX/jaek/46npv+Np6b/jKal/4ulo/+LpqT/gp+d/2SHg/9MdHD/cZCO/6K5t/+mvLn/o7i4/6C4 + tf+gtrX/nrOz/5qxsP+es7D/MnWa/wBYkf9WhI//aYqG/SQwL7gAAAB9AAAAQAAAAAwAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACNjo7O6ayV//7XuP/+1bf//tW3//7WuP/+1rj//NCu//zIof//wZT/zKOG/83O + z//Z2Nf/1tXU/7q5uP++vbv/sa6v/4eKiP+mpqT/h4yK/1d4df9cgn7/ZomG/2+Qjf94lpT/fZuZ/4Ke + nf+HoaD/iKSh/4unpf+OqKX/kKmo/5Gqp/+Rqqn/kaqp/5CpqP+PqKf/jaek/4qko/+Io6H/g6Ce/2aJ + hv9Lc3D/epiW/6e8uv+jubj/oLa1/5+2tP+bsrL/m7Kw/2eTo/8AVI7/RX6a/32alv9oiof9Ii4tsgAA + AHUAAAAyAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAhoaEs92olf/91rz//Ni///zXvv/8177//Ne+//zY + v//82MD//9rB/76llP/b3Nz/397e/9/e3v/f3t7/4eDg/7m3tv9Kcm7/T3dz/1B5df9Yfnr/YIOA/2OH + g/9lh4X/aouJ/3OTkf98mZf/h6Kg/46opv+TrKr/kquq/5Osqv+UrKv/k62q/5Srq/+TrKv/kquq/5Cq + qP+MqKb/i6Si/4eioP+Dn53/fJqY/1p/e/9SeXX/lq6s/6S6uf+ft7T/nLOz/5uzsf+MqKv/BFWL/yFl + kf+Xran/eJaT/2eIhfsVHBulAAAAagAAACUAAAACAAAAAAAAAAAAAAAAAAAAAH98e4vHp5v//8y0//7b + x//+2sb//trG//7axv/+2sb//trG///fyv+xoZn/6Ofn/+bk4//m5eP/5uTj/+jo5/+kpKP/UHdz/1J5 + df9Kc27/SnJu/1J4df9af37/YYSC/2KFhP9cgH//WH17/011cv9PdXL/V356/22Oi/+EoJ7/la6s/5qx + sP+Xr63/lq6t/5Wsq/+TrKv/j6qp/46opv+Ko6P/hqGg/4Cdm/97mZf/bI2K/0lxbv98m5j/pbq4/520 + s/+csrL/nbSw/xldjf8NVIn/jaim/46npf9ykY//YoF98wgJCZQAAABXAAAAFAAAAAAAAAAAAAAAAAAA + AACenJpQqqCd//y5oP/+4NL//t/P//7fz//+38///t/P//7g0P//3Mz/sKej/+/v7//r6+z/6+zs/+vs + 7P/x7+//hI2L/0p1cP9Lc3D/a4yM/36bnf+DnqH/gp6g/4Keof+Dn6H/hKCi/4ejpP9si4n/e5iX/3ST + kP9miIX/VXt3/011cf9bgH3/e5mX/5StrP+ZsbD/lq2s/5Osq/+Qqqj/jaWl/4ijov+DoJ7/fZmZ/3aV + k/9ujov/THRx/22PjP+juLf/m7Ox/5+2sf84bpL/CU2E/3qaov+OqKb/iqSi/22Niv9LZGLcAAAAfwAA + ADkAAAAGAAAAAAAAAAAAAAAAvr28EpCSkvzloYj//une//7l2v/+5tr//uba//7m2v/+5tz/48Cx/8jI + yP/z8/T/8/Hx//Px8f/z8vL/6unp/150cf9SeXf/f52e/4Gdn/+BnqD/gZ2f/4KeoP+Dn6H/hKCi/4ei + pP+GoaL/aYmG/4Sgnv+Cnpz/f5ya/32amP97l5X/b4+M/1p/e/9MdHH/ZYiE/4qlo/+Xr67/kqqp/4+o + p/+KpaL/haGf/4Ccmv93l5X/cZGO/2eKhv9OdXH/f52a/5+2tf+dtLH/WYOb/wtLgf9hiJr/kKmn/4ul + o/+BnZv/aYuI/yEsK68AAABjAAAAGQAAAAAAAAAAAAAAAAAAAACBf363tpaL///Qv//+7eT//uvj//7r + 4//+6+L//+/l/7eThv/09ff/+fn5//n5+f/5+fn/+/v7/8PAv/9KcG3/gJ2f/4KeoP+CnqH/g6Cg/4Sh + of+FoqL/iKOj/4ijpv+Lpqb/haGh/22Mif+Np6X/iKOi/4ainv+CoJz/gZyb/36bmP98mZf/eZaU/2eI + hf9NdXL/WH16/4Whn/+Sq6r/jKal/4Win/+BnZv/epiW/3KSj/9pi4j/XoN//0Vva/+JpaL/nbSy/3SW + ov8NSH3/S3WR/5Krp/+MpqT/iKOh/3OSkP9beHXrAAAAgQAAADc7OzsEAAAAAAAAAAAAAAAAnpyaQo2O + jv/bl37//+bb//7t5//+6+T///Do//K3ov+0sK7//Pz8//n5+f/5+fn/+fn5//r6+v90gH3/Z4uK/4Sg + ov+EoKH/haKi/4iho/+IpKT/iaSl/4ulpv+NqKf/kKmq/4Sgn/90ko//k62r/4+pp/+MqKb/iaSi/4ii + of+EoJ3/gZ+b/4Cbmv98mpf/e5iV/22Oi/9OdnL/XYF+/4ijov+JpKL/gp6c/3uZlv9zk5D/aoyJ/2CC + gP9Tenb/SnNv/5qysP+JpKn/E0h8/zlkif+Vran/i6Wj/4ejof+AnZv/aYuJ/x8pKKoAAABXAAAADwAA + AAAAAAAAAAAAAAAAAACgnJuLi4qJ/76QgP/2tJ3//cGs/96dhv+fj4n/5OTk/+Tj4//k4+P/5eTk/+fm + 5v+koJz/ZIWB/4Gen/+Io6X/iKWm/4ump/+Np6j/jaio/5Coq/+Sq6z/la2s/5evr/+Cnp3/fZqY/5uz + sf+Ysa//la2t/5Osqv+Qqqj/jqim/4umov+Io6H/haGf/4KdnP9/nJr/fpqY/3KRj/9ReHX/YYSB/4Sf + nf97mZb/dJOQ/2qMif9ghID/U3p2/092cv9bgH3/nbSx/x1Ke/8sV4H/lK2o/42npf+HoqD/hKCe/3CQ + jf9OaGbdAAAAZgAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAH97eaqEhIT/hYOB/4mBfv+OkI//1tXU/9nZ + 2P/Z2dj/2dnY/9HQ0P+hnZv/7MCd/4WWi/+GoqL/jKan/46oqf+QqKn/kquq/5Srrf+Wrq3/lrCv/5my + sv+dtLT/gp6c/4Sgnf+huLb/n7S0/5u0sv+asrD/lrCu/5WurP+Sqqr/j6mm/4ynpf+Io6H/h6Kg/4Sg + nv+Bnpv/gJya/2CDgP9Rd3P/eJeV/3OSkP9qjIn/YIOA/1J5df9Tenb/Rm9r/4+ppf8sUX3/KE16/5Os + qP+Np6X/iaOh/4Sfnf94lpT/XXx57QAAAGsAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdGBYia2Q + gf+jjIH/spuQ/7CbkP+wnZH/sZ2S/7Cek//BpI//9sag///Ppv+Ilov/gJyd/5Kqq/+Sq63/lK6t/5au + sP+YsbD/nLOz/521tf+htrb/pLm5/4ahn/+HoqD/p727/6W5uf+jt7f/n7W1/561s/+as7D/mbGu/5at + rf+TrKn/j6qo/46opv+LpqL/iKKh/4Shn/+Dn53/XoJ//0tzb/9uj43/aIqH/16Cf/9SeXX/U3p2/052 + cv9vkIr/PmOL/yVbkP9xlaT/jael/4ijof+Dn53/fJmW/2KCf/QAAABtAAAAGwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAO+eeaf/r4n//7SN//+5k///vpf//8Ga///Fnv//yKH//8qj///Mpf//0Kf/m6CR/2+P + jf+Yr7H/mbGw/5qxs/+ctbP/oLW1/6G3t/+lubn/qL29/6zAv/+Jo6H/iaOh/63BwP+rv77/qL28/6a7 + uv+kuLf/ori3/5+2tf+btLH/mrCw/5ewrv+VrKz/kqqq/46ppv+Np6b/dpSS/3KRj/92lZX/SXJu/2WH + hf9cf33/Unl1/1N6dv9SeXT/Rnd9/yhYkP8jRXX/O1p+/5Gsp/+GoqD/hJ+e/3yZl/9khIH2AAAAagAA + ABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD5qYPj/LGL//u2kP/9uZX//L+X//7BnP/+xJ7//ceh///M + pf//zKX//8+o/7mtl/9jh4X/j6in/5+2tv+iuLj/o7m6/6e8vP+pvr7/rMC//6zBv/+rwL//iKOh/4Wg + nv+ovbz/q7++/6zAv/+rwL//qr69/6a7u/+lu7j/o7m3/6C1tf+cs7P/m7Ox/5mxr/+Wr63/jKak/2eH + hf+HoaL/hqGj/3KRkf9KcW3/WX96/1J5df9Tenb/U3p1/0Jvd/8bSHz/GEp8/zlihv+RqaX/hqGf/4Of + nf96mJb/YYB+8gAAAGUAAAAWAAAAAAAAAAAAAAAAAAAAAAAAAADvy7sc+62G//yyjv/9t5H//L2X//7B + mf/+xZ7//sah//3KpP//zab//86n///PqP/cwKH/cJOS/26Oi/+lurn/qb69/6vAv/+swMD/rMC//6q/ + vv+ovLz/pry7/4qkov98mpf/oba3/6K5t/+mu7v/qb69/6zAv/+swL//qr++/6i9vP+mu7r/orm4/6G2 + tv+ftLT/nbSy/2yNif9/nJz/i6an/4eio/+HoaT/ZoiH/0pybv9Tenb/U3p2/1N6df9GcXb/DFOL/xNT + hf9miJj/jaak/4eioP+Cn5z/dZSR/1t3dukAAABiAAAAFQAAAAAAAAAAAAAAAAAAAAAAAAAAso17Rv2x + i//7tpD//buV//y/mf/+w5z//sWe//3Jof//yqX//86n///PqP//zqf//9Gs/3eQjf+Qqqj/dJOQ/63C + wf+qv77/p769/6e9uv+lu7r/o7i4/6G4tv+Np6b/c5KQ/5mxsv+as7P/nbW0/6G2tv+kurj/p7y8/6q/ + vv+swL//q7++/6m+vf+mu7r/p7y7/3uYlv90kpD/k62t/46mqf+JpaX/hqGj/4aho/9Uenf/Unl1/1N6 + dv9Tenb/Rm9u/xhKfP9HZ4f/lK2o/4mjof+GoJ//gZ6b/2yLjP9Qfk7lAAAAZAAAABYAAAAAAAAAAAAA + AAAAAAAAAAAAAMiIaWf9s47//biR//y9l//+wZv//sOe//3Iof//y6T//82m///Npv//zqf//9Gu/7i5 + Zv9ak1D/layu/4ulo/92lZP/p7y7/6S4uP+iuLf/oLe1/5y1s/+cs7H/kKqn/2yMiv+TrKz/k6ys/5eu + sP+YsLL/m7S0/562tP+it7j/pLm6/6q+vf+swL//rsLB/4qko/9rjIn/mrGx/5aurf+Qqar/jKap/4qj + pv+HoqP/epmZ/0lxbf9Tenb/Unl1/z1qcf8RRn3/bYqY/42npf+JpKL/haGf/3eVk/9liYn/M5ol6QAA + AGYAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAADtpH+G/LWP//26lP/8vZn//sOb//7Gnv/9yaL//8yl///O + p///z6f//9Gu/7G6Yv9Jvjv/XtiO/3KOjv+xxcT/iaOi/3OSj/+etbP/nbOy/5mysP+YsK3/lq6t/5Cq + qP9oiYb/jKan/42nqP+Pqav/k6yr/5Strf+Yr7H/mbGx/5yzs/+gtrb/pry7/46opv9oiYf/n7a1/5+2 + tv+asLL/lKyt/5Gqq/+Np6j/iKOk/4ijpP9PdnL/Unl1/1J4cv8sYHf/HlCB/5Cpp/+MpqT/iKOh/32a + l/9shYj/K6pp/yOmJu0AAABpAAAAGQAAAAAAAAAAAAAAAAAAAAAAAAAA86qEmP22kf/9vJb//MCa//7E + nv/9x6H//8qi///Npv//zab//9Cv/6m4Wf9JxUr/XOGW/2Tllv9mrIz/kqmp/6u/vv+JpKL/bI2K/5Os + qv+Vrqv/kaqo/5GoqP+OqKb/aoqH/4SfoP+JpKb/jKan/4ymp/+OqKr/kquq/5StrP+Vrq7/m7Oz/4Of + nf9oiYb/pru7/6q+vf+iuLj/nrW1/5mxsf+Traz/j6ip/4ulpv+JpKb/bI2N/0xzb/9Pd3D/EVGA/2mM + m/+Qqab/i6Wj/3mYlf9shof/PKBv/wDEUP8hqi7wAAAAawAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAPat + h6b9uJL//L2X//7Cm//+xZ///cii///LpP//zKX//8+s/6i3WP9GxEj/WN+T/2Hhkv9n45n/cOSd/2iL + gv+iuLf/o7m3/5Cpp/9qi4j/g5+d/4ynpf+JpaP/iKOh/3CPjP95mJj/haGi/4Whov+HoqX/iqWm/4ul + pv+OqKn/kaur/3aUkv9ujYv/ori2/6q+vf+swL//qL29/6G3t/+ds7P/l7Cv/5Srrf+Oqar/i6an/4Of + oP9IcGz/M2dz/0V4l/+Wrqn/hJ+d/22Oi/9qhob/OKde/wDETv8AwlH/Ha8z9AAAAG0AAAAbAAAAAAAA + AAAAAAAAAAAAAAAAAAD4r4ql/bmT//y+mP/+w5z//sae//3Jof//zKT//86r/8nAd/9DxEf/U96P/1ze + kP9l4pX/beWc/3Xoov9zzpX/co6O/6C3tv+bsrD/k6yq/3CQjf93lZP/hKCe/4KenP92lZL/b4+N/4Of + of+Dn6H/g6Ci/4Sgof+Io6T/hqGi/2+OjP93lZL/nrW0/6O4t/+nvLn/qr+9/6zAv/+nvLz/oLi4/5yy + sv+VrrD/k6yr/42nqP+Lpqf/R3Jw/0h8kP+BnZn/boyM/2eGhv+AkHj/rqdW/xS8N/8AwlH/AMJR/xi1 + OPcAAABrAAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAA+LGKlv26lP/8v5n//sSd//7HoP/9yqP//8yn/9jD + hP9CuzH/TN2M/1bcjP9f4JP/aOOZ/2/mn/956KX/gu6r/3nAnP94kpH/mrKx/5Osq/+PqKb/dZOR/2uL + iP93lZP/cZCN/2iJhv9ujoz/dpaU/4Gdn/+BnZ//dZST/2eJhP98mZf/mLCu/5uysf+ftrP/orm4/6i7 + u/+rv77/rMC//6a8uv+ft7f/m7Oz/5Wurv+SrKz/fpua/1+CjP9qiIf/ZYtx/0SiZP8/rCn/TZoA/ye1 + Jv8AwlL/AMJR/wDCUf8dsDP0AAAAZgAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAPuzjYL9u5T//MCa//7F + nv/9yKH//8uk//LKnP9NvDb/Q9mE/1Dah/9Z3o7/YuGT/2vkmf9y56H/fOqn/4XsrP+P87X/e7ic/3aQ + kP+TrKr/jKak/4Whn/97mZb/aoqI/2qLh/9zko//dJOQ/2yMiv9ri4n/aIqH/3CPjP+Dn53/jael/5Gq + qv+Xr6z/mrOy/6C1tf+jurf/qL28/6vAv/+rwL//pLm5/6C1tf+asrL/k6yt/2WId/9SpCf/Rqwi/yfB + Pv8IyFr/AcNT/wrASv8AwlL/AMJR/wDCUP8AwlP/J6Um7AAAAF0AAAASAAAAAAAAAAAAAAAAAAAAAAAA + AAD7x6pk/buV//7Bm//+xZ///ceh///Mqf+EukX/OdR3/0XZgf9S3In/W9+O/2Tilv9t5Zv/duij/3/r + qf+I7K//ke+0/5v3vf+FwaT/boqL/4mjof+Dn53/fpuY/26Oi/96mJX/i6Wj/42opv+AnJr/a4yJ/3CQ + jf9/m5n/g5+e/4ein/+Oqab/kqup/5iwr/+asrH/obe2/6W6uf+pvLv/rMC//6q/vv+kurr/nrS0/3GO + jv9HtDv/K85m/x7Na/8WymL/D8Vb/wTCU/8AwlH/AMJR/wDCUf8AwlD/AMNT/zCSGd8AAABNAAAACgAA + AAAAAAAAAAAAAAAAAAAAAAAA+9vIQf27lP/+wJv//sad//7Jov/yyZn/PcFC/z3Wfv9G2YP/U9uK/1ve + kf9m4Zf/beSe/3jnpP+B6qn/iu6x/5Pxt/+b87z/p/vF/5jYtv9rjIj/dZOQ/22Miv9pioj/epiV/520 + sv+iuLf/iqWj/3GQjf9qiof/d5WT/3+cmf+EoJ7/iqWj/5Cpp/+Urav/mLCv/520s/+ht7b/pru6/6q+ + vf+vwsH/mK+v/2yMif9JwH//MdV4/yrQb/8izWf/Gcpi/w7HWv8FxFT/AMFQ/wDCUf8AwlH/AMJR/wDD + UP8sawvFAAAAPTs7OwUAAAAAAAAAAAAAAAAAAAAAAAAAAPzbyBn9upT//sKc//7Gn///yaL/0MN9/zDL + Wv8/1nz/R9iC/1Tdi/9d4JD/ZeOW/3Dmnv956aP/geyr/4zvsP+V8rj/nvW9/6b3xf+x/Mv/sfDK/3CT + jf9piYn/epiZ/3SSk/97mJb/jKak/4Cdmv9tjYr/b4+O/2uLiv9qi4f/cZCN/32Zl/+Gop//jaim/5Ss + q/+YsK//m7Kw/5ivrv+KpaP/co+S/2CNZ/9M04L/P9d+/zXSdf8s0G7/I81p/xjKYf8Qx1z/BcNU/wDB + UP8AwlH/AMJR/wDCUf8Mwkj/IEQEpQAAAC2AgIABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+7qT3f7C + nP/+xp7//8mk/8rCd/8wy1//P9Z9/0nYgv9U3Yv/XOCS/2fjmP9w5p3/eOml/4Psqv+M77L/lPK3/5/1 + v/+o+MT/sPvM/7v+0v/L/t3/qc6+/3SVkP9qion/dpSW/3WSlP9niIX/cpKR/3aVlf95l5f/epeZ/3eV + lv9xkJD/bo6M/2uMif9rjIv/a4yK/2eIhv9ehIL/d46N/3+gWP9NxEP/StqG/0HVfv8003X/LNBu/yPN + af8YymH/EMdc/wXEVP8AwVD/AMJR/wDCUf8AwlH/Gr47/xMnAYIAAAAeAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPu6k6H+wpz//sae///JpP/IwXT/Mcxg/z/WfP9H2IL/VN2L/13gkP9l45b/cOae/3np + o/+C7Kv/iu+w/5XyuP+e9b3/pvjF/7H7yv+5/NL/x//b/9X/5P/i/+z/yuDX/2GTY/9piIT/a4qN/2uL + i/9zk5L/d5WX/3mWmf96mJr/eZea/3eWmP9xkpL/aYyN/22Mif+QnZH/z76j/9fKhf9PxUb/VN6Q/0ra + g/8/137/M9N4/yzQb/8hzWf/Gcpi/xDHW/8FwlX/AMFQ/wDCUf8AwlD/AMJT/y2xKPYBAQBWAAAADwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7y65Q/sCZ//7Gn///yaj/krpN/zHRcv8+1nz/RtmD/1Pb + iv9c3pH/ZeGX/2/knP9456T/geup/4rusf+S8LX/nfS9/6f5yP+w/M7/tv3P/8P/2P/O/9//2P/m/+X/ + 8f+k3o7/UaUW/02MHv+qs5r/laSX/4abkP+FmpD/hpqQ/5Ohk/+lqpj/wbmf/93JqP/71a///9iw///W + tP99vkr/WuGW/1LbiP9I2YX/RchY/0i+Pf8qzmr/Isto/xjJYf8OyFr/AMNR/wDCUf8AwlH/AMJR/wDD + Uv8ygxHNAAAANDo6OgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/vDmA/y+mOT+xZ7/28GD/zLC + R/8y03X/O9R7/0bXgP9R3In/Wt+Q/2Pilv9r5Zz/dOih/33pqf+I7K7/kvK6/4Hjkf+ExVT/fs9j/7X+ + 0v+7/tT/xf/Y/87/3//T/+H/2v/p/9v/7P9pvkL/5dmm///kv///5L3//+K8///huf//3rf//9y1///Z + s//+17H//taw//7Urf//1LD/ocBb/1Xcif9Q3In/RNJs/6K0Tv//zab/PL08/x3Na/8xuzj/UpgH/6K2 + Uv8Gv0T/AMJR/wDCUf8Yvz7/GDEChQAAABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD8vZSE/8Wi/3W4P/8lzm3/MNJy/zvVev9D2H//T9uI/1jejv9h4ZT/auSa/3Pnn/986Kf/he6w/23O + X/+xxWv//9y//5/DXv+o98L/tv3P/7v+0v/D/9j/yP/b/8r/3P/Q/+X/hM1i///hvv/74Ln/+926//3c + t//827f//Nm0//zYsv/+2LL//tev//7Urv/+067//9Ou/87Hf/9L0mv/TtuI/0PNXf+oslP/zsV8/yvE + TP8dy2X/E8hh/zynEP/JsWX/Cb09/wDCUf8AwlP/MKgi7gAAAE0AAAALAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA/9/QGvS/k/kyvTj/Jc5t/y/Rcv841Hj/QNd9/0zahv9V3Yz/XuCS/2fj + mP9u5p7/eOik/3bhkP+GrTv//9u9//7ZtP/Gy3//keuh/6/7yv+1/M7/uP3Q/73+1P++/tX/tvjJ/5rE + Xf//4L7//d24//3dt//927f//du2//3Ys//817P//tew//7WsP/+1a///tSs//7TrP/80ar/Vr46/0jb + iP86y1f/38aK/1C6OP8izm7/HMtj/xDIYP8vsyf/pa1H/wa+Qv8AwlH/A8NO/y1pCrwAAAAvgICAAgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYsCbTGshe/yPNav8t0HD/NNN2/z/W + e/9J2YT/UtyK/1vfkP9k4pb/bOOa/3Tnof9145X/RJYA/9/Klf//27z/t8Zv/5Ltqv+o+MX/rfjJ/7H7 + zP+y/Mz/tvzR/3TFSv/127P//d24//3dtv/93Lf//926/9rNl///2rb//tix//7Vr//91K7//tSu//7T + rf/+0qv//9Gr/+HKj/+GvUr/kb1R///Np/9BvTz/Ic1r/xnKY/8Nx17/MrUp/yuyIv8AwlP/AMJR/xy/ + O/8WLAF2AAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7Ie2RXK + Zf8hy2f/Ks9u/zHSdP861Xr/RtiB/0/bh/9X3o3/Xt+R/2fjmP9u5J3/eeqp/1vAP/9HjQD/lapL/2+6 + PP+b9cD/oPTA/6X3w/+o+Mb/rPnL/3rVcP/IyoP//ty4//3ct//927b/99mx/2ulI/87lAD/lqxP///b + u///2bj//9e0//zTrf/oy5v/68qb///RrP//0q///9Cu///Prf//z63/eblD/xrMZ/8XyWH/DsZZ/wPD + U/8AwlH/AMJQ/wDDU/82mhfaAAAALjo6OgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAHbAQ0InvkL/HMtm/yXOav8v0XL/NtJ2/0LXf/9L2oP/U9uK/1vfkP9h4JX/auSZ/3Dl + oP956Kb/ZMxb/1S1LP9+4pH/kvG2/5jzuv+c9L7/n/XA/6P2xP900WT/i6lE///dvP/927T//9q4/4G+ + SP9/4pD/g+ec/0GWAP9jlx3/dp4u/2CZGf9MlgL/RJYA/0SUAP9PkAf/oa1U//3Oqf//z6j//82n/+nH + kf85uTD/EMhg/wvFWP8BwVH/AMJQ/wDCU/8lujH9FCoBYgAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ6sGkx3IXv8izWn/LNBv/zTRdf891nz/RNeA/07Z + h/9U3Yv/XeCQ/2Phl/9s5Zr/ceeg/3rpqP+C7rH/he2u/4vvs/+E6KL/ddh3/5Xwtv+Y87r/jemi/0iX + Af/417D//tm0/8zKhP903oP/jO+0/4btr/9z34r/XcZN/13LWv9g027/X9uB/1rbhf9T2Hv/S8ZN/0Wd + Cf/ixZH//86n///Npv//yqX/5sOK/zu3LP8DxFf/AMFQ/wDCUf8PwUX/LWMInAAAABcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbsyAg6sx/gG8xp/yfN + av8uz3H/OdR4/0HXfv9H2YL/UNqJ/1bejv9f35H/ZuOX/2zlnP9x55//d+ej/37rqv9u2Xj/psFf/8zJ + gP9x2Hb/j/C1/5LyvP9fuTT/+9Ww///Ytv+ewlz/g+yq/4Psq/9+6aj/d+ik/3LnpP9s5Z3/ZeOY/17g + kv9T2ob/SMlU/1fCSf9suzr//c6o///Npv//y6X//ceh///Fof/ivoP/JLgu/wDCU/8CwlH/OZMT0QAA + ACg6OjoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAdsBDPiy+P/8ezWr/Js5q/zHNY/880XH/Q9d//0nYg/9S3Ij/V9+O/1/fkf9l4Zf/a+Oa/3Dm + n/9t4ZP/oL9Y///XuP/czZH/bNh3/4btr/+E7Kv/gsBL///Xt///17b/dsJM/4Dtrv976KT/duii/27m + nf9q5Jv/Y+GX/17gkv9U24b/e7k8/+jLlv//z6n//8+u///Op///zab//8qi//3HoP/+xJz//8Cd/661 + WP8DwEX/MLYm8QsXAD8AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0wEJLYbIqvKO8Wv+ZtET/Pr48/zzWff9E1n//S9qF/1Db + iP9Y3o7/XuCR/2PimP9j4ZP/UMlQ/+TOl//40qz/bbUx/3noo/966aX/a749//LSp//+1a///9Sw/2nH + Vf926ab/ceWf/27lnf9o45n/Y+CU/13gkv9X3o3/TM9l/6CvTP//0a7//8+o///Opv//zab//8uj//3J + ov/+xJ3//sKb//2+mP//u5j/U50exCRWBU0AAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6xaGjQLw4/y3R + df830nb/PtZ8/0PYf/9L2oX/UdyJ/1bejf9U0m3/lbxO/9bJiP//1LH/eLk8/2jfjP9v5Zz/ar08//PR + p///1bL/+9Ot//rUrP9dyFT/beWf/2rkmf9k4Zf/YN+S/1vfkP9U3Iv/UNyJ/0rTbv9Slgj/8cuf///O + p///zab//8yl//3Io//+x6D//sOb//y/mf//vpf/oHRdlwAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAArtaLHinDSv8oz2//MdBz/zfUdv881n//QtiB/0nYg/9P3Y3/Rrkx/8G5cv//1bT/4cyU/1bX + eP9n5Z3/Y7w7//jTrP//07D/fKcx/06PBv9kqCH/YdyG/2Til/9h4ZT/XeCQ/1jejv9T3Yn/TtuH/0fY + g/9C2ID/P6wZ/8e6d///zaj//8yk//3KpP/+xqH//sWe//3Bmv//v5j/oHVckQAAAA8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1wUaALMRP/yjPcP8u0HH/V7s4/0THVP9A2IP/RMhV/0vC + RP9NkQT/lKdF/4epOv9W3Yj/Xd+N/06eCf/uzKD/kbxO/1TTav9Vylb/WtZ4/13gk/9b34//WN6O/1Td + jP9O2of/S9qF/0bXgv9B137/OtV8/zfCRP/KvHb//8yn//3KpP/+yKD//sWd//7Cm///v5j7jmhTdwAA + AAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHS/Qngsw0//LcJH/+rI + lP9hvkP/N8VM/8vBd/9bwUb/SMBE/0izKf9Jujb/UtyM/1Xfj/9MtCj/UJAG/1HLWP9Y3pH/V96P/1bd + jf9U3Yr/UtyK/0/biP9M2ob/RtmB/0PWf/8+1nz/ONN3/zPTd/8zv0D/yrp1///Kpf/+yKD//sWf//7C + nP/+v5n0Uz4xUAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAc8FFb1uuI6j/ya3ZZ7xC/z28Of9ekg//Tb09/z7Zhf9A2oj/RduJ/0nYg/9K2oX/TdqG/0qw + If9LqA7/T9yH/07bh/9N2Yb/S9qF/0nZgv9G2IL/Q9eA/z/We/871Xj/NdJ1/zLQc/8r0HH/Lr49/8m5 + cv//yKL//sWf///Enf/wtZDNPS0jNDY3NwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//PsBKjIbogwxEv/O78//zHQbf87w0j/aro//0TC + SP8/13//Qtd//0TXgP9F2IH/Rspc/0TYgP9F2ID/RNh+/0LWff9A1n3/PdR8/zrTev8103f/M9J0/y/R + cf8qz27/I85r/yy+Pf/jwIn//8Wf//3Cm+qZc1tuAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc8FEgTS+ + O/pjuDX25MeQ/5S9U/8zzWT/N9N3/znUd/871Xj/OtV6/zzVe/881Xr/OtV6/znVe/821Xv/NtN3/zPT + dP8y0nL/Ls9x/yvPbv8nzmr/IMto/xnLaP9SujT//8Og5KZ/ZHkdFA0RAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACg1YAJ2dqzC//XwFpbtCrNMMla/yvRdP8v0XP/MNJz/zLSdP8x0XP/M9Jy/zDR + df8+wUT/Vrw8/y7GUP8o0HH/KM9t/yTOa/8gzGj/G8xn/xrKYP84tCPpVFcpXxQMCgoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHa/RFBDsBWtSq0WszHF + Uf8mz3D/J9Bw/ybQcf9LvTb/58eN///LqP/SwXv/cbg8/S+/Qf8kxFD/K79B/zS4Lu8/mw+cBhYAHDc2 + OQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB1v0FJQa8WuTi4K+U9rxbDQkkeSWxTQzP849Ey+d/MJ+rXxhGi0oIhptODPqXQ + gyORp4ECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /////////AD/A//////wAHwAD////+AAAAAAA///4AAAAAAAD//AAAAAAAAA/8AAAAAAAAAfwAAAAAAA + AAeAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAGAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAGAAAAAAAAAB4AA + AAAAAAAfgAAAAAAAAA+AAAAAAAAAB4AAAAAAAAAHgAAAAAAAAAOAAAAAAAAAA8AAAAAAAAABwAAAAAAA + AAHgAAAAAAAAAfAAAAAAAAAB+AAAAAAAAAH4AAAAAAAAAfgAAAAAAAAB8AAAAAAAAAHwAAAAAAAAAfAA + AAAAAAAB8AAAAAAAAAHwAAAAAAAAAfAAAAAAAAAB8AAAAAAAAAHwAAAAAAAAAfAAAAAAAAAB8AAAAAAA + AAHwAAAAAAAAAfAAAAAAAAAB+AAAAAAAAAP4AAAAAAAAA/gAAAAAAAAD+AAAAAAAAAf8AAAAAAAAB/wA + AAAAAAAH/gAAAAAAAA/+AAAAAAAAD/4AAAAAAAAf/wAAAAAAAD//AAAAAAAAP/+AAAAAAAB//8AAAAAA + AP//8AAAAAAD///wAAAAAAf///gAAAAAD////AAAAAAf///+AAAAAD////+AAAAA/////+AAAAP///// + 8AAAD///////AAAf///////gAP//////////////KAAAADAAAABgAAAAAQAgAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAANAAAAFQAAABcAAAAXAAAAFwAAABcAAAAUAAAACwAA + AAIAAAAAAAAAAAAAAAEAAAACAAAABgAAAA8AAAAcAAAAIwAAAB8AAAAUAAAACgAAAAgAAAAIAAAACAAA + AAcAAAAHAAAABgAAAAUAAAAEAAAAAwAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAABwAAAA9AAAAUAAAAFUAAABVAAAAVQAA + AFQAAABOAAAANwAAABkAAAAMAAAAEAAAABYAAAAfAAAAMgAAAEsAAABlAAAAcwAAAGsAAABTAAAAPwAA + ADUAAAAwAAAAKQAAACIAAAAdAAAAGQAAABgAAAAVAAAAEgAAAA8AAAAMAAAACQAAAAYAAAAEAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAGl1dW5J0dnfJZWZm0WBf + XtFjYF/RY2Bf0mFeXc46OTiqAAAAcwAAAFEAAABFAAAATgAAAFcCAwVqER0yoxw0WNghRXX2Hj1o6w4Z + KL8DBASeAAAAjgAAAIQAAAB9AAAAcgAAAGYAAABZAAAATQAAAEIAAAA3AAAAMAAAACoAAAAlAAAAIAAA + ABsAAAAWAAAAEQAAAA0AAAAJAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANfX19q+DV + 0v/61sX/4Lyt/5OJhv+KiYj/jYqI/42KiP+LiIb/QkFAvSUkI6FNSka7ISYutRIkQMohPGbuKUx+/yNY + k/8fXp7/IWGi/ylXjf5OaG7yT2di6D9TUd4wQD7RGiIhwAUHB64AAAChAAAAlAAAAIQAAABzAAAAYwAA + AFYAAABKAAAAQwAAADwAAAA1AAAALgAAACYAAAAfAAAAGAAAABEAAAALAAAABQAAAAIAAAABAAAAAAAA + AAFnZ2Zk2MnF///Utf//7sH//+/E/9yskf+PiYj/lZSS/5aUkv+XlZP/iYaD+359f/tMXnv/LUx7/ypO + g/8vVYv/L2Cb/ylrrf8qbbD/KnC0/ydstP9We5z/kaqk/4eioP9/nJn/c5GO/mB8efdFW1noKTY11QoN + Db0AAACtAAAAnwAAAIwAAAB7AAAAbAAAAGEAAABbAAAAVAAAAEwAAABDAAAAOAAAAC0AAAAiAAAAFgAA + AAwAAAAFAAAAARwcGwmcmZnN+8qx///rvf//9sr///bK///pvP+wmYv/mZmZ/5uYl/+Nioj/lI+L/2Bv + iP8iTIX/L1qR/zRhmv83ZqH/NnGx/zN5vv81esD/NX3E/zF/yv9RhLT/nbGu/6C2tP+ftrT/nLOy/5ev + rv+LpqP/fJmW/2SCgPpDWFbpHicn0QAAALkAAACrAAAAmAAAAIgAAAB8AAAAcwAAAGwAAABlAAAAXQAA + AFIAAABEAAAANAAAACIAAAARAAAABmRkYzbKta77/9Sq///vwf//677//+u9///ywv/Vu57/npqa/5ST + kf+Rjoz/nZmX/09qj/8wYZ3/OGun/ztwrv8+dbT/Pn/C/z6Gzv8+iNH/PorU/zuM2v9Ri8D/nLGv/6C3 + tP+gtrX/oLa1/6C2tf+huLb/oLa1/5mxr/+Io6H/c5OQ/09oZvAiLSzWAAAAvAAAAK4AAACgAAAAlAAA + AIcAAAB8AAAAdQAAAG4AAABlAAAAVAAAAD0AAAAiAAAADnh6e2/lvqz//9ys///mtv//5LT//+S0///n + tv/x06n/n5mW/56dnP+npaP/qqil/1Nymv84cbP/QHm6/0J/wf9FhMj/RovR/0eT3f9HlOD/SJbi/0WZ + 6f9blcr/oraz/6W7uP+jubj/orm3/6K4t/+huLf/obi2/6G3tv+huLb/nbSz/42opf92lJL/Umxn8Bso + MNkECRDGAAAAtgAAAKUAAACPAAAAgAAAAHoAAABzAAAAZQAAAEwAAAAtAAAAEouIiJbwwKX//9qm///e + rP//3az//92s///erf/62Kj/pp2U/6+vr/+7urj/t7Sw/2aDqP87fML/R4jN/0mM0/9KkNj/TZXe/1Cc + 6f9Roe//UaPy/02j9/9Vh7L/j6eh/5+2tP+mu7r/qr++/6e9u/+kurn/pLq4/6K5uP+guLb/oLa1/6C2 + tf+ctLL/jKej/2yKjP8rTXH7ECxM5gIFCL4AAAChAAAAhAAAAHIAAABpAAAAWwAAAEQAAAAoAAAAEJWO + jqvzw6T//9mp///WpP//1qP//9ak///XpP/91KH/tKeY/7S0tf/V1NP/wr65/5uouv85esH/TZfh/0+Z + 4/9Rnuv/VKTz/1Wo+f9Tpfj/T6H0/0WEx/9YeYX/ZYmD/2OGg/9tjov/fJuY/5Stq/+mu7r/qr++/6e8 + u/+jurj/obe2/6C3tf+etrT/nrWz/5yzrv9mi5f/DVCF/ws2U+EAAACtAAAAigAAAGcAAABOAAAAPQAA + ACsAAAAYAAAACZ6Vk774wqP//9qy//7TqP/+zZz//s6c///Pnf/7y5r/v7Ci/6+vsP/p6en/0dDP/9rY + 1/9wkr3/PYnZ/0mY6f9Mld//R4jK/0Z/tv9Nfaf/VHiU/2eFjP+Bnpr/haGf/4Sgnf99m5j/cJCN/2WI + hP9oiof/fZqZ/5uzsv+qv77/pru7/6O4t/+gt7X/nbS0/520sv+asq//I3Ca/wpejfwyQ0LNAAAAlwAA + AG0AAAA+AAAAIQAAABIAAAAJAAAAA5qSj731vqH//9ez//7Vsv/+z6f//saY//7FlP/6wI//xrWn/8TF + xv/CwL//0c/P/7u4tv/f3eD/lKbB/3iLqP9PbXv/VXl7/2WDgP9zkIv/f5uV/4OgnP+GoaD/i6Wk/4ym + pf+Np6b/j6mn/42mpf+Bnpv/bI2L/2GEgv91lZL/mrKx/6i9vP+kubj/n7a1/520sv+jtrL/VIuj/wBa + kv9Yg4z/PU9MyQAAAIQAAABSAAAAIQAAAAcAAAABAAAAAI+Jh6TsuqL//9e5//7Xuv/+17r//tS1//7P + rP/4wpr/xbOn/9rc3f/R0M//xcPC/8C/vv+MkpD/naWf/3iKg/9cgHr/aIqF/3GRjv96mJb/g5+d/4ul + o/+Qqaf/kqup/5Krqv+Sq6n/kqup/5CqqP+Qqaj/jqem/4Whn/9tjoz/XoJ//3mYlf+ht7b/pbu6/561 + tP+gtbL/f6Gp/wVYj/9ThZv/e5aQ/zxQTcUAAAB4AAAAQgAAABIAAAABAAAAAISCgo3gsJ7//9nA//3b + xP/92sP//drE///cx//z0Lr/xbu3/+bm5//k4+P/6Ofn/9nY1v9hfHj/SHJt/0p0cP9Tenf/WX57/12C + f/9ghIH/Y4aD/2qMif92lZP/iaSi/5StrP+asbD/mLCv/5WtrP+TrKr/j6mo/4ympP+Io6H/fZqY/2GF + gf9fhID/kqup/6W7uf+ftrP/lq+v/xpgj/87dJb/kKml/3CQjP8yQkG3AAAAbQAAADEAAAAJAAAAAH1/ + f13IopT//9jF//7h0f/938///d/P///i0v/pybj/zcjG/+/w7//r6+r/8fHw/8jJx/9TdXD/Tndz/2aI + h/9zk5P/fJma/36bnP9+m5z/e5ma/2WHhf9niYb/XoJ//2KGg/9wkY7/hqKg/5atrP+asbD/lK2s/4+p + p/+KpKL/hKCe/32amP9niob/VXx4/4aioP+jubf/n7Wy/zxxlP8hX4z/jqin/4ein/9nh4T5GiIimwAA + AFgAAAAcAAAAAn18eiCikIn1+si1///s4v/+59z//ufc///r3//Tua7/5OTk//b29v/19PT//fr6/6Or + qf9QdXL/e5ma/4Wgov+EoaL/haCi/4aio/+IpKX/hqGi/3WUkf+GoqD/f5ya/3aVkv9pi4j/X4OA/2CE + gf9zk5H/jKel/5Wtq/+OqKb/hqGg/36bmf91lJL/ZIiE/1B3c/+EoZ7/qr24/1eBmv8ST4P/hKGk/5Cp + pv97mJb/Umxq3gAAAHYAAAA3AAAACgAAAACFg4K206OR///m2v//8Or///Hr//jXy//Ita3/+vz9//z8 + /P//////8e/v/3GFg/90lJX/hqKk/4Whov+GoqP/iKOl/4qlpv+Np6n/haCh/3qXlP+Pqaf/iaSi/4ah + n/+Dn53/f5ya/3WUkv9lh4T/W4B8/26Oi/+KpKL/iqWk/4Cdmv92lZL/a4yJ/1l+e/9Pd3T/lK2o/3CR + ov8XTH//dJSf/5Gppv+GoZ//b42K/yYzMaIAAABMAAAAEwAAAAB+fHs/k4iD+96rmP//3c///dTF/8ud + jP/V09L/8vLx/+/u7v/y8vL/rrKx/2WDgv+HoqT/iKOl/4qlpv+Mpqf/jqip/5Cqqv+Vra7/hqGh/4Cd + m/+ZsrD/kquq/4+op/+LpqT/h6Oh/4Wgn/+Cn53/e5mW/2aIhP9bgH3/dZWT/4Sfnf93lZP/a4yJ/1yC + fv9MdXH/ZIeC/3+cpv8cS33/Z4iY/5Krp/+Io6H/eZeU/0hfXcsAAABYAAAAGQAAAAAAAAAAfn9+coaB + f/mjh37/nYR8/6ysrP/S1tj/z9HT/8/R0//Curb/xauT/3+ZlP+Lpqj/jqip/5Cpqv+Sq63/la2u/5iw + sP+dtLT/iaSi/4ijof+iubj/m7Kw/5ewrv+Urav/kaqp/42npv+KpaP/h6Kg/4Wgn/94l5T/XYF9/2aJ + hv94lpT/a4yK/1yBfv9Tenb/Tndx/3WTlf8lSnr/ZYSV/5StqP+HoqD/fpyZ/1Nta9kAAABcAAAAGwAA + AAAAAAAAAAAAAJuCdpC8l4P/v52L/9Ctmv/Orpn/zq+b/8yvm//ovJv/+cmi/3qUkP+Pqqv/la2u/5ev + sP+asbL/nbS0/6C3tv+nvLz/jKak/4+op/+qv77/o7m4/6C2tf+dtLL/mrGw/5avrf+TrKr/j6mn/4ym + pP+LpaP/fpuZ/1p+e/9dgX7/aYuH/1uAfP9Tenb/T3Zx/12Ehv8uYJP/RnCW/4ympP+Io6D/gJ2a/1l0 + ceAAAABcAAAAGwAAAAAAAAAAAAAAAeWbeaP/s4v//7qR//++lv//w5r//8ie///Mo///z6b/+cul/3qS + iv+HpKT/oLa2/5+2tv+jubj/pry7/6q/vv+vw8P/j6mo/4ynpf+vw8P/q8C//6i9vP+lurn/ori3/5+1 + tP+cs7H/mLCv/5WurP+Sq6n/dJOQ/36bm/9niYj/VXt4/1h+ev9Tenb/VXpz/0Bygf8gToL/IEp8/4Sf + oP+Io6H/gJya/1p1c98AAABaAAAAGgAAAAAAAAAAjWBLCfOng9n8tI7//bqU//7Amf/+xJ7//sii///M + pf//zqf//9Co/5mglP9xkpP/obe2/6zAv/+swL//rcHA/6vAv/+rwL//kaqo/4Ognv+nvLz/qb69/6zA + v/+swL//qr++/6e8u/+kurj/obe1/6C3tv+En53/dpWU/4ulp/+HoqT/X4OB/011cf9Tenb/VXt0/0Fx + ff8OUIX/NGSK/4qko/+HoqD/fZuY/1RtbNkAAABYAAAAGQAAAAAAAAAAzIxuH/qvifX9t5H//b2X//7D + nP/+x6D//8uj///Npv//z6j//9Sv/7askP94mJj/g5+e/6q+vf+sv7//p727/6W6uf+kurn/kKmn/32a + mf+bsrP/nrW1/6O5uP+nvLz/q7+//6zBwP+rwL//rMC//5aurP90k5D/jqip/46oqf+JpKb/gp6f/1N6 + d/9Qd3P/VXx1/z9sdP8aTH7/dpKc/4+opP+FoZ//eJKX/0lyS9YAAABZAAAAGQAAAAAAAAAA2ph3PPuy + jPz9upT//sCZ//7Fn//+yaL//8yl///PqP//0bH/z8F3/2KwRf99opn/lKur/36bmf+gtrb/ori3/520 + tP+cs7L/kaqo/3aVk/+Qqqv/la6u/5ixsP+cs7T/oLe3/6S6uv+swMD/oLa1/3aVkv+TrKv/mbGy/5Gq + q/+Mpqf/i6an/3OSk/9MdXH/Vnx1/zFidf8rWYX/jKak/4umo/+Dmpv/YI+K/yqKK9oAAABcAAAAGwAA + AAAAAAAA5aJ/Tvy1kP/9vJb//sKc//7HoP//yqT//86n///QsP/Pv3n/V71D/1biiv9os5H/nq+z/5Ks + qv95l5X/k6uq/5iwr/+Urav/jqim/3KRj/+Io6X/jaip/5Cqq/+UrK3/l6+v/5y0tP+Sq6v/dpWS/5ev + rv+ovb3/nLOz/5Wur/+Qqar/i6ao/4ejpP9Zfnv/TXZw/x5XfP9fhJr/lKyn/4Cbnf9rjYz/H69l/xWa + Kt4AAABeAAAAHAAAAAAAAAAA5aOBTvy3kf/9vpj//sSd//7Iof//zKX//9Cv/8/Bef9VwEv/U9+N/2Xm + m/9r3Jn/dZ6Q/6S3uP+SrKn/dpSR/4OfnP+Np6X/iaSi/3OSkP9/nJ3/iKOl/4mlpv+Np6n/kKmq/4Of + nv9zkpD/mbGv/6/Dwv+rv77/o7m4/5qzsv+Vra7/j6mq/46oqv9ujYr/NWhx/0J2lf+MpKb/f5ee/3qO + g/8rrVf/AMZT/xubLeEAAABfAAAAHAAAAAAAAAAA6KeETf25k//+wJn//sWe//7Jov//zqz/0MJ6/1LC + Sf9M3Yn/XuGU/2rjmv927KP/dc6b/36cmf+ftLT/kaqp/3aVkv91lJL/f5ya/3SSj/9zkpL/g5+h/4ah + o/+Cn6D/dZSS/3aUkv+Wr6z/pbq5/6i9u/+swcD/qb69/6G4uP+asrL/lKyt/5OrrP9xkZj/RXOL/3SQ + j/9mk3j/Z49I/2mlMf8IwkP/AMRW/xqeL+QAAABcAAAAGgAAAAAAAAAA76yJSv26lP/+wZr//saf///L + qP/kx4z/VMJL/0Pagv9W3o//YuGU/27lnf956aX/h/Kv/4DKo/9+mpn/lKuq/42npf97mJb/b46M/2yM + if9vjoz/cZGP/3STkv9vj43/fJqX/5Grqf+Zsa//nbSz/6O5uP+ovbz/rMHA/6i9vf+ftrb/nLOz/4+l + qv9nkHH/V5tG/0GtR/8WwFD/Hrgu/w29O/8Aw1T/AMNV/x2YK90AAABWAAAAGAAAAAAAAAAA8rCMLfy6 + lPr+wZz//8eh///Ko/+Bwlz/NNZ2/03cif9Z347/ZeOX/3HmoP996qj/ie6w/5f3u/+Kzqr/d5aT/4Se + nf+Cnp3/cZCN/3iWlP+Oqaf/eJaT/2uLh/99mpj/iKOh/4ympf+Sq6n/mbCv/561tP+kurj/qr69/67C + wf+rv8D/mKuw/2uYiP9BuUz/J89X/xbMX/8Kx1v/AMRW/wDDVP8AwlH/AMNU/yKMIdMAAABPAAAAFAAA + AAAAAAAA7K2JD/u7lOz+wpz//8ik/+fGjf9EyFn/PdmC/0/bh/9b35D/Z+OY/3Pnof+A66n/jO+y/5jz + uv+n/Mb/nd65/3melv9piIf/bYyM/32amP+Zsa//gZ2b/2qLiP9xkY7/epeV/4Sfnf+MpqT/lK2r/5uy + sf+huLb/pbu5/6S5uv+Ppaj/ZaOI/0HLe/8x1nX/Js9u/xrKY/8Oxlr/AsJS/wDCUf8AwlL/AMJR/yl+ + FscAAABFAAAAEAAAAAAAAAAA/buVAve4ksj+wpz//8im/8zEfv86zWT/QdiB/0/biP9c35D/aOOZ/3Tn + of+B66r/je+y/5nzu/+l98P/tf/Q/7f0z/+XwK//eJeV/2+Oj/94lJf/cZCP/3KSkv90k5P/cpGR/3KR + kP91lJL/eZeW/3qYl/93mJf/c5SV/3mQh/9ZnE3/SdV4/z7af/8z0nX/J85r/xvKY/8Oxlr/AsJS/wDC + Uf8AwlL/BMFN/ytuDrIAAAA1AAAACAAAAAAAAAAAAAAAAPS2kpD+wpv//8in/83Eff86zWX/QdiB/0/b + iP9b35D/aOOZ/3Tnof+A66r/jO+y/5nzu/+m+Mb/svzN/7//1v/R/+L/0fLg/6jItv9jjmz/aYmH/2yO + kP9tj5L/b5GU/2+RlP9vkJL/b5CQ/3KQjP+JmpD/vbCc/5W6YP9O0WL/S96K/znWev8s0nH/J85s/xnL + Zf8Kx13/AMJT/wDCUf8Aw1T/E7xB/yBIB4gAAAAkAAAAAgAAAAAAAAAAAAAAAPa5lEr+wZv//8em/5/B + Zf8u0Gr/Qdd//07bh/9a35D/ZuOX/3LnoP9/66j/i++x/5j1wP+V8K//pfW8/7v/1P/H/9r/2P/n/+X/ + 7/+Pznb/c6FF/7+9p/+0tqP/s7Wh/7O0oP+/uaH/z8Cl/+vNq//+1rH//9Sj/3bNZv9R4ZP/R9d7/2/E + Wv9mxFn/Ic5p/yHGVv8jvkT/CsBL/wDDUv8Aw1X/JKgs7QcOAVUAAAAWAAAAAAAAAAAAAAAAAAAAAP2+ + mAv8wJ3e68KK/0fEUP8u1Hb/QNZ9/0zahv9Y3o7/ZOKW/3Dmn/976af/iO+y/4LhjP+iymv/mNN4/6/7 + y/++/9X/yP/b/9P/5f/I/df/m8hj///kvv//5r///+O8///iuv//37j//9y1///Ysv//1rD//tKq/4rK + a/9J3ov/Qstd/8W7bP+/xHL/Gsth/yW/Qv9zox7/ULhF/wDDUf8CwlD/LoAUxAAAADkAAAAKAAAAAAAA + AAAAAAAAAAAAAAAAAAD1uqGBpbtg/x7LXf8w0nT/PdZ7/0nZg/9V3Yv/YOGT/2zknP9566r/bdl8/63B + Zv//3MH/uM59/53ztv+1/dD/vP7T/8P/2v+y9sD/xdSL///gwP/93rn//969///eu//92bT//tey//7W + sP/+1a7//9Sz/7fHdv881W//QMtd/8W/b/9kxFj/Gsxn/xHJXf9jrC3/V7VC/wDEU/8UvUH/JFEHjAAA + ACMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAACdrk5AQr5I/xvNaf8u0HH/OdR5/0XYgf9R3In/XN+R/2fj + mf916qj/Y9Jr/3+lMP/41K//tc16/5Xxsf+r+sn/sPvL/7T+0v+n5p7/8dmq///euv//3bv/3MqQ/9bI + iv//2rn//9m2///Yt///17j//9e5//7Rqf+gxmz/mMVn/+HIif80xVL/Gc1r/xLIXf8xtS7/FLxA/wDE + V/8nqCnrBw4BSAAAABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqQUiKL087hrNa/8qz27/NdN2/0HX + fv9L2oX/V96N/2Lilf9t5Z7/deeg/1W1M/9lnRr/fMtk/5j1vv+h98P/pvjH/5/2vP+ay27//diy///e + vv/KyoT/YLQ0/1KgE/+ztGH/3seN/8a8cv+tslj/qK9S/8+8e///zqr//8+s//7Mo/9ov1D/Dcld/w3G + XP8Dw1L/AMNU/wq/SP8wdw+gAAAAIgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASK4VbiLG + V/8izm3/MdFy/zvVev9G2YH/UNyJ/1vfkP9l4pb/cOeg/3fooP9t2n7/gumk/47yuP+G6qH/lO+x/5n2 + vf+DxWH/99Oo//DVpP+A0Gz/h/Gz/3PbgP9QqyX/WK8u/1S3Ov9Mv0b/Qbo8/z2jFP+msFb//9Gw///O + q//ixIj/Rb1C/wHEVP8AwlT/AcJS/y+eHtkKFgI4AAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAUK4NAj20JrwezGn/JtFx/zLUef8/2IH/StqE/1Tdi/9d4JH/Z+OY/3DmoP9666v/e+uo/3vT + cv+zxm7/jNR3/471v/+K2Yf/+9So/8rNhf9545L/hO+x/37srP9z6Z//auWZ/2Plm/9Z4ZH/VtFs/2LF + Uf/Dw3b//8+t///MpP//yKn/4b+A/zW7Pv8AxFX/IrMy9CFHBlsAAAASAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEyqDic2uzfjMsdX/0bFVf9Bylv/Qth//0zbhv9V3Yz/XuCS/2bi + mP9r6aX/YdVw/9XJhP/6zqD/gtN0/3jwrv+U1oH//9Wy/63Md/9v5Zj/eOml/3LnoP9r5Zz/ZOOY/1Xf + jf9uw1X/5siM//rNof//z6j//82m///Kov/+xp///8Kj/7q4av8iuDL9M34NgAAAABUAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKqAwZt7pnnrK+Zf84xE3/ONV7/0TY + gf9M24b/VN2M/1nfjv9q0W7/oMdr//rPof+Hw1r/ZeGN/3fTc//bzI3//9Oy/5vMdP9n5Jf/beWd/2fj + mP9g4ZT/Wt+Q/03cg/9grS7/8MWU///Qrv//zqf//8uk//7Hof/+w53//76Z/+qqh+JJcRpkAAAADgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8cSPBF+5 + QMgiz2z/MtN3/zfUeP8/13z/St2L/0PUcv+LsD///9Cy/7fGdf9U233/aNBr/+fNk//Nv3r/eqQu/2vL + Yf9k5Zr/YeGU/1zgkf9W3o3/T9yI/0fbh/8/uTj/ubZj///Qr///y6X//sih//7Env/+wJr/7K2L4GtO + PkQAAAALAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFatFy44vDfjJdFy/07GWP9exVf/RNJv/2DHVP9OqBv/e6Ar/2a4P/9V4o//VrQ1/7Cy + V/9vyGD/Ssxd/1ndiv9a35H/Vd2M/1Hcif9M2oX/RdiB/z3Xf/81y17/t71q///NrP/+yaL//sWf//7B + mv/iqIbNcFJBOQAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJqgsuNLgrz6XAZvibxm//QbYy/4KtMv9A0Wv/O8pd/0fS + cP9Q3o7/Tc5n/0agBv9Pylv/VOKY/1Hdiv9O24f/StqE/0bYgf9A137/O9V6/zPTd/8ryVr/tr1q///K + qv/+xZ///cCa/NKefqA1Jx8dAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ60DCKy1Xiq4v3GfMroy/za7 + Pf8+zWP/VcZV/0HRcP9C2IL/RduH/0fNYv9Hy17/RtqF/0TZgv9C14D/PtZ8/zrVef8103b/MdJy/yfQ + cf8lx1b/wb5x///GpP/qso/NuItvWAAAAAsAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAPbEYf0m6PsvDwHPtgb1O/yzQa/801n7/ONV7/zrXfv8713//NNV3/y7Raf8u0nL/L9N3/y7R + cv8qz2//I89u/xjMZ/9Ivkn+3rOEzcycfmkSDgsOAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAG2zJQPww5UearM2dTW8Ods5wkv1M8th/yrTd/8o0nT/UsZY/6TA + Y/9zwVb/NcdX/yTMZv8hymL/JMVU/y+vJtZagCdYEg4LDgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEeuDApIowweRqwXcje7 + O9ozuzrhra5kkeu8oovsuJOEhqhDbzapHoU/pht9Q5kPUx9NAxIAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAGAAAP/wAAwAAAAAD/ + AACAAAAAAA+U/4AAAAAAAZ7/AAAAAAAApP8AAAAAAAA2/wAAAAAAAIf/AAAAAAAAk/8AAAAAAACh/wAA + AAAAAKz/AAAAAAAAnP8AAAAAAAGq/wAAAAAAAZ//AAAAAAABiP8AAAAAAACP/wAAAAAAAIr/gAAAAAAA + h/+AAAAAAACd/8AAAAAAAKr/4AAAAAAAsv/AAAAAAAC3/8AAAAAAAL//wAAAAAAAuf/AAAAAAACy/8AA + AAAAAHf/wAAAAAAAIv/AAAAAAABa/8AAAAAAAEr/wAAAAAAAUf/AAAAAAABT/8AAAAAAAABd4AAAAAAA + AADgAAAAAAEAAOAAAAAAAQAA8AAAAAABlf/wAAAAAAOf//AAAAAAA6n/+AAAAAAHd//4AAAAAAeJ//wA + AAAAD5b//gAAAAAfo///AAAAAD+v//+AAAAAf73//8AAAAH/i///4AAAA/+d///8AAAP/4v///4AAD// + o////8AA//+a/ygAAAAgAAAAQAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AA8AAAAiAAAAKQAAACkAAAAoAAAAHQAAAAYAAAADAAAACAAAAA8AAAAmAAAAOAAAADEAAAAeAAAAFAAA + ABIAAAAOAAAADAAAAAkAAAAHAAAABAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAQEBAKQUFBekNFRqI+Pj2nQkA+qDg1NJwJCQlsAAAAOAAAADQAAABEBwsUbBMmQbMUKkjEBAkOmAAA + AHgAAABmAAAAWwAAAEoAAAA9AAAAMAAAACYAAAAeAAAAGAAAABEAAAAMAAAABwAAAAMAAAAAAAAAAAAA + AAAAAAAAfHx8C29sbJL33cz/9da8/5+Pif+PjIv/kY+N/2xqaOFGRkjFMzxN0Bw3X+QpTYH9JGCg/yJm + qP81Y5L8YHp68lJpZuc8TU3ZHCUkwQ4TEq4AAACRAAAAfAAAAGIAAABSAAAARQAAAD0AAAAvAAAAJAAA + ABYAAAAMAAAAAwAAAAAyMjI50LWq5P/pvv//9cj/2r+g/5qUkf+Wk5L/kY2J/lZog/4sU4f/MVyU/zNm + pP8vdLn/MHa9/zh6u/+CoKv/mK+t/5Grqf6Ampj6Z4B98ztPTeAZISHHAAAApAAAAI4AAAB2AAAAagAA + AF0AAABTAAAAQAAAAC0AAAAVAAAABouDgYLyzav//+u8///ouv/14LX/sqaa/5WUk/+gnJn/Q2iX/zdr + qv8+drb/QIDC/0GK1P9Bjdf/Q47W/4amtf+ht7X/oLe1/6C3tf+huLb/mbKw/4ilov9Xb23vJDAt1AQG + CbYAAACjAAAAjAAAAHsAAABvAAAAXwAAADgAAAAVpZWOr/nSp///4K///9+u//3erf+9rZr/rKur/7Wy + rP9PeKr/QH/D/0eJzv9Jjtf/TZrm/02e7P9MmeH/gKGs/6O5t/+nvbv/pLq5/6O5t/+huLb/n7a0/5ev + rf+CnZn7Pldj7w8jO9wAAACrAAAAiQAAAHEAAABjAAAAPQAAABi0n5XK/NKp//7Tov/90qD//9Og/822 + mv+/v8H/z8zJ/46mwf9EitT/TJrn/0+b5/9PmeH/T5TZ/1WCpP9rjIn/bI2K/3STkP+Ho6D/l7Cu/6S6 + uf+jubj/oLe1/561s/+Trar/M2+U/wozS9kDBASbAAAAXQAAADkAAAAcAAAACregldL90K3//tKp//7J + mv/9xZP/1Lee/8HCw//Qzs7/w8TH/46qzv9eh7L/TXqV/16DkP9tjJL/fZqY/4eioP+Io6L/haGf/3yZ + l/9ykY//eJaU/5evrf+mu7r/n7a1/5+0sf9ikqX/GGGH+DVHR8oAAABqAAAALQAAAAcAAAAAqJSMvPjN + sv/92L3//da7//vPrv/Tuaf/293d/9LQz/+vsrD/f4+K/2KAeP9egnz/bI2K/3aUkf+Cnpz/jKak/5Ss + qv+UrKv/kaqp/4+op/+Bnpz/aYqI/3eWk/+Zsa//oLa0/5Krrf8cY5H/c5aa/zhKR78DBARjAAAAEgAA + AACXiYWc8ci1//3ezP/93Mr/+NnH/9PEvP/q6+v/7uzs/6exrv9Kcm3/X4OB/2yNjf9ykZH/cpGR/2aI + hf9qi4j/dJSS/4ejof+Xrq3/lKyr/4ympP+En53/bI6L/2SHg/+Yr63/oLaz/yllj/9uk5//c5CM9iYy + MagAAAA3AAAAB6CcmVXQqZv2/+zh//7r4f/t1Mn/4dnW//j4+P/8+fn/fJGO/3KRkv+FoKP/haGi/4ij + pP+HoqP/e5mW/4Sgnv93lZL/aouI/2aJhv92lZL/iqSh/4mjov97mZb/ao2I/1p+e/+Vrqn/Q3GS/1qB + lv+MpqL/aYaD8gUHBmwAAAAb1dbVH5WEfszzy73//+LW/9S1qf/o5+f/9fX1/9XX1v9siYj/haCi/4ek + pP+KpKb/j6mp/4ijo/+EoJ7/kaqp/4qlo/+FoZ//fZqY/3KRjv9miIX/dZSS/3+bmP9uj4z/VHx3/2eJ + hP9afpf/TnSP/5CopP98mpf/JzQzmgAAACkAAAAAx8nILpGAeeWliHz/vrWw/83Fwf/LwLj/1LSc/4Cb + mv+PqKr/k6qr/5Wtrv+cs7P/kKmo/5Krqf+gtrX/mbGv/5WtrP+PqKf/iqWj/4Sfnv9ujov/ZIeD/2uM + iv9XfXn/TXZw/1Z5i/9HbI7/kKik/4KfnP83SkiwAAAALgAAAAAAAAAA1pl7vequjP/vuZf/7r2Z//HD + oP/7yqP/epeS/5aur/+ctLT/ori2/6i9vf+Xr67/lq+t/6q/vv+kubj/oLa1/5uxr/+Vra3/kaqo/3+c + mf9sjIv/XIF9/1d9ef9TeXL/PGyE/yZRg/+JoqH/g5+d/zpNTLMAAAAtAAAAAL6bigb4rYfu/LmT//7C + m//+x6H//82m///Rqv+QnJL/iaWk/6zAv/+rv77/qL69/5evrf+LpaT/pLq5/6m+vf+qvr7/p727/6W6 + uf+Sq6r/fJmY/4ulp/90k5P/TnVx/1V6c/8uY3v/NGWK/4ulov+AnJz/NEg/rQAAACwAAAAA4rWgHvuy + jP39vZX//sWf//3Kov//z6r/7cqW/3qnbf+Io6L/k6uq/6O5uP+ftbX/la2r/3+dnP+Wr6//nbS0/6K4 + uP+ovb3/p7y7/4Cdmv+Rqqr/jaip/4qlpv9dgoD/Unly/y1cd/9khpf/i6Si/3OUlv8gViCuAAAALQAA + AADsv6gy/LeR//3Amv/+yKH//82o/9nGjP9rw1v/XNmS/4OvoP+QqKj/hJ+d/5GqqP+OqKb/dpST/4mk + pf+OqKr/k6ys/46pqf+AnJr/o7m4/6G3t/+UrK3/jqip/3yZmf9NdnP/PW6M/4WepP9xlYz/KK5o/w5n + GrQAAAAwAAAAAO7BqjH9uZP//MKc//7KpP/vx5b/Z8Vd/1TciP9r5Zz/csuY/5Cnp/+Op6b/eZeU/4Cd + m/9zkpD/gJye/4aio/9/nJz/fZqY/5mxr/+qv77/qL28/5uzs/+UrK3/h6Gk/013iP9rjI//cpJw/1Km + SP8DxFH/EWgdtgAAAC4AAAAA9MavJ/27lf/+xJ7/7siZ/2zGYP9I24j/X+CS/3LloP+D76z/hMil/4ak + oP+FoJ//c5GP/3KQjv90k5D/cJCO/3qYlv+Rq6n/mrGw/6O5uP+pvr3/p7y8/56ztf91nYv/TaZQ/yW8 + Tv8QvkD/A8BH/wDEVf8UYhmtAAAAKQAAAADyx64N/LyV+P/Fof+8xX//P9Jx/1Lciv9h4JP/duij/4ft + rf+Z8rv/lNKx/3WVkv9si4v/hZ+d/4aioP9rjYj/e5iW/4mjof+Tq6r/nrSz/6W6uf+jt7r/gqWe/0TA + df8pz2b/E8lf/wTDVf8AwlH/AMRS/xpWD58AAAAhAAAAAAAAAAD3uJPP/8aj/5rGc/871Hb/U9yK/2Lg + lv946KT/h+yu/530vv+w/Mz/te7M/5y+tP95mZP/bY2L/26QkP9vkJH/b4+Q/3GSkv91lJH/g5mV/3Kg + av9LyW7/Ntd7/ynPbv8UyWD/BMJV/wDCUf8Fw03/Gz4FfAAAABEAAAAAAAAAAPe4kZX/xaT/hMVp/znU + dv9S3Ir/YeCU/3boo/+H7a7/mPO8/6L1vv/C/9f/0/7k/7bcuf9woFz/oaqf/5qom/+dqJv/qa2c/8m7 + ov/oxqP/bc1s/0jbgv9YyGH/Mcxn/xzFVv8LwEz/AMJS/xS5P/kHDwBKdHR1CAAAAAAAAAAA/cqwQuW+ + h+svylz/ONV6/0/bh/9d4JH/cuah/3zoo/+g04D/q815/676yv/B/tb/yv7e/67bjf//47///+O9///g + uv//3LT//9aw///Trv94z3P/O9Bo/8C8a/9EyGX/OLc7/2GvN/8Aw1D/II0izAAAACCurq4BAAAAAAAA + AADp5c8ZfrdUxx7Naf8203f/StmE/1jdjv9t5Z//aNqB/7W4Zv/Qz4//nfS6/7L7zP+z+Mf/z92h///e + vP/w06j/7tKl///Yt///17b//9e5/8XMif93x2P/qMNx/yLKYv8gwE3/M7Y4/wjAS/sVTw+PMzIzDQAA + AAAAAAAAAAAAANTrxwVGujWJHsxo/y7Qcf9C13//T9yI/2Pilv9x56H/XrxI/3PHX/+V9L3/nPS+/5bm + nv/Zz5b/49aj/37IZP9orzf/p7hg/5i3V/+EsUj/tLhp//rLpf/cyJD/QMJV/wPEV/8Aw1T/G5YqzQcV + ADkAAAAAAAAAAAAAAAAAAAAAAAAAAIXGWBUpv0TkI89w/zfVe/9I2YT/Wd6O/2bjmP9z56D/eumm/4nY + gv+V14P/i+qo/9TSl/+404r/gOqk/3Thkf9j0nP/WNV6/0rOZf9vuEb/6MmX//3KpP/JwHz/EL9I/w6/ + Rv0aQgZgAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGm9Q0RQvEjLXMNX/zzSb/9M2ob/Vt2N/2Ph + lf9t1Hf/48iN/5XSf/+E35L/6NOm/5HTf/9w5p7/bOWc/2Lil/9X0nL/wsJ3///Oqf//zab//sef///C + of+ar1zoJG0QfxMQFAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjJjiNcv1DpLtBx/zzW + fP9J24j/Wc1q/8bGg/+rzH3/YdRz/83Lh/+2tWP/cdN1/2XjmP9d4JL/VN2M/0bNaP+ft1r//86t//3K + o///w53//LuW9GlSOVwAAAAPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG6/ + SEorwUfYbsNc/1DHXP9hukD/Wq00/1bLZP9Rx1z/gLJD/1HPaf9V3Yz/UduK/0rahP9D14D/NNFx/4jA + Y///yqj//sWe/9ulg8diSDhJTE5PAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA7/bpA2K+OjSuuGKJW7lC7Ea9R/9EyVz/Q9R4/0fYgf9FwEf/StZ8/0bZg/9D13//PNV6/zXT + dv8lzWn/isFk///Eo/bfqIeqJRkSKXJwcAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACm25Y1e7dIkpm6VcQty2D3NdBx/jPWff830XH/Tcpl/zTO + av8ozm3/Is1o/y28SeWBiU+hdl5RL0xNTQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADd58MB4enNGj2tFlRAsSeLLsJN6G65 + V8bVu4uuirRaoS6yMao4rCiUHlEJP3+BeQoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAwAAA/4AAAA8AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAgAAAAMAA + AACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAADAAAAAwAAAAMAAAADAAAABwAAAA+AAAAPwAAAH+AAAD/wA + AB/8AAA//4AA///AA/8oAAAAGAAAADAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADo6 + OgYAAAAoAAAAMwAAADIAAAAnAAAABwAAAAcAAAATAAAAMwAAAEYAAAApAAAAGgAAABQAAAAOAAAACwAA + AAgAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGlnZ5awnpfpd3Rz6np3dulAPz63GhkXegoP + F4gWKUW/H0yC9h1DcOsnMjLBGCEgrAMGBpEAAAB1AAAAWwAAAEMAAAAzAAAAJwAAABsAAAAQAAAABwAA + AAAAAAAAPkA/S/vYvv//9sn/xqyX/5aWlf+Sj4v+VGaC/y1Vi/8yY5//LXK2/yt1vv93mKn/lK2r/4Oe + nP1ddXLvKjc21AMEBK0AAACJAAAAbwAAAF8AAABPAAAAOAAAAB0AAAAGoZOOpv/js///57j/89uw/5iV + lf+gnZn/Pmid/zxztP9BgML/Qo3X/z+R3/96obv/pLm2/6G3tv+huLf/mrOy/32Ylvw4SUfgAwgMuwAA + AJwAAACAAAAAcQAAAFEAAAAavqWWzv/apv//2ab//9mm/6yno//Fwr7/WYW4/0qR2v9Pmuf/UqP1/0qa + 7f9mipL/hKCe/5ixr/+nvLv/o7m4/6C2tf+ctLL/Z4eT/wcrS+IAAACWAAAAYwAAAEEAAAAVyKiY3v/X + r//+y5v//caU/7u0rv/U09L/vcHL/2KTzP9LfqX/WYGY/2+Nkf+GoZ//haKg/3qXlf9xkI7/haGg/6S5 + uP+gtrX/obay/xtsmv8yRUXLAAAAXgAAABQAAAACtZuQyv/Zvv/9173/+86w/9DLyP/Y19b/oaim/2eD + e/9afnn/aYqH/3aVkv+Io6H/la6s/5StrP+Rqaj/gJ2b/2mLiP+NqKb/o7i1/0qAnP9pkp3/NkdFvQAA + ADoAAAAAlIeBm//dzf/949b/7tLE/+Tk4//39fX/gJSR/2uNjP9+m5z/gp+g/3WUk/9wkI3/aYuI/3ST + kf+LpqT/kKmn/4Gdm/9ihYL/gJya/3iap/9Oe5X/gp+b/xgfIJEAAAAVvr++Oc+snf//6N7/1ryy//f5 + +v/m5uf/b4uL/4eipP+Jo6X/j6ip/4Ccm/+Qqqj/iKOh/4Cbm/9tjYr/bIyJ/4GenP9wkI3/UXh0/3ya + nf8/aYr/j6ml/1ZvbdwAAAAyAAAAAKOem3ypin3/xbeu/8u+tv/buJ7/gZ6d/5KrrP+Wrq//n7W1/4qk + ov+iuLf/mrGw/5Osq/+Mp6X/haCe/2OGg/9qi4j/Vnx4/1uBfv89ZY7/jaik/2yJhu8AAAA4AAAAAJFf + SF//uJD//8GY///Kof//z6b/fZeT/6S5uf+ovbz/rMHA/4mkov+rwL//qb28/6S6uf+etbP/kquq/3ua + mf9niYj/UXh0/0p2eP8aToH/iqSi/2yIh+8AAAA2AAAAAOafe5P9u5X//saf///Mpf/4zqD/gKJ+/46n + p/+mu7r/oLa2/4OenP+Xr7D/n7a2/6a8vP+pvr3/gZ6b/5Gqq/+JpKX/Vnx5/0Vwcv9PdpD/i6Oi/1OI + Zu0AAAA3AAAAAO+phKf9wJn//smi//jLof9txF//YNeT/5Oqqv+Dnpz/j6im/36amP+HoqT/jqip/5Gq + qv+CnZz/p7y7/5qzs/+Pqar/eJWU/zNme/+Em6X/ZpaB/xCvQvEAAAA6AAAAAPOuiab+w5z//cqi/2jG + X/9V35H/ceif/3zIoP+Rpqj/e5mW/3KRjv9zk5L/eZeX/3yZl/+ds7H/p727/6e9vP+asbL/f5uY/1WQ + aP9ApUz/Hbo9/wyzQvEAAAA2AAAAAPSxioj/xKD/qcV3/z7Zgv9g4ZP/eOek/5Lytv+Qz6//d5SS/3KR + j/+KpKL/bo6L/4Sfnv+Sq6n/n7a0/6m+vf+Pqqr/Rbxu/x3PYP8ExFf/AMJS/xKmN+gAAAArAAAAAPjI + rFX/xKL/gcdv/0bZhP9h4ZT/euml/5Lxtv+t/Mv/ue7P/5e1rf9qioT/bI6Q/2yPkP9vj5D/dpOQ/4+g + hP9LyGn/MtZ4/yDMZ/8ExFf/AMNS/xmPKNAAAAAVAAAAAPzcyRH/wZv5S8li/0XYgv9f4JL/d+ij/4vu + rf+a3o//u//U/9r/6f+VzHf/39Cy/9rMrf/kzqz//dWw/8DPhf9C2X7/nb9j/xzHV/8/tDr/AMVU/xRI + C4+DgYMGAAAAAAAAAACdtWCwIM5p/0HWfv9Y3o7/cOij/33BWf/g0Zr/ofbA/7j90//C4qP//969/+7T + pP//2bj//9a1//LQpf9myWP/kMNn/xDKZP9CsjT/DMBH/QMMAEAAAAAAAAAAAAAAAABlwU1eH8xo/zfU + eP9O24f/Y+KW/2vahP9xx2L/kfO4/5v1vf/EzIf/0NOU/2PGWf+Nskv/gbdO/3avQf/ux5r/1ceK/xDE + UP8AxFX/HHoarTk2OQkAAAAAAAAAAAAAAAAAAAAAL7UrszDMZf9D1Xb/VN2L/2bimf9s55z/xMl+/4Hj + lv/I1pn/ldeH/3vrq/9q5p3/XNuE/6XKef/xy5z//8ml/7e9cv8asTDgAAEAHQAAAAAAAAAAAAAAAAAA + AAAAAAAA0+rEAbK5YZsszmr/P9d+/0vchv+qxHH/pMt7/4jVgP/OvXj/ctiA/2Pilv9W3o//R8VX/+7F + lv/+y6T//8We/9eafcMEDQAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbryAcsty25fMNf/1m+ + R/9Ntj//UtN1/2ayOP9U0Gv/VN2M/03Zhv9D13//L89q/9zEiv//yKH/uYlto09JRw0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3dy2LjC1KNV2w139NdR4/z7Wev891Hb/M9R2/zTT + d/8r0HL/Jspc/+O2h9BiRzdKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADc3rYgO7AgfDTASdJUv1jcw7x9wUK4RLswtDezJ1kOTQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgAAfAIAAAycAAAD/AAAA/wAAAP8AAAD/AAAB/wAAAP8AAAD/gAAA/4AA + AP+AAAD/gAAA/4AAAP+AAAD/gAAA/4AAAP/AAAH/wAAB/+AAA//gAAf/8AAP//wAP///AP//KAAAABAA + AAAgAAAAAQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAFAAAAB0AAAAgAAAAHwAA + ABwAAAAXAAAAFgAAABkAAAAeAAAAIAAAABcAAAAIAAAAAAAAAAAAAAAEAAAAHQAAAEkAAABiAAAAZQAA + AGUAAABeAAAAVQAAAFIAAABYAAAAYgAAAGYAAABNAAAAHwAAAAQAAAAANDQ0FpuLhbfHsZzomYd87Hx7 + eu16d3Pmal1MzWBOUcsxPl3UH0l65yNbl/YgRnTfBAcOgQAAAD0AAAANAAAAAHx3dmz1y6z///fG//DV + r/+dlpL/l5OO/2Z1if8kVJD/MmSg/zd3uf82gMj/NXzL/xguLq8AAABdAAAAIQAAAASkkIiu/9ut///n + t///47P/saSW/6ekoP9ug6D/NHC1/0WEx/9HkNj/SZnp/0OQ6v8leUDdAgYAfAAAAD4AAAANuJqNyf/a + qv//1qL//9ai/8Cvmv/ExMP/mqW0/0KFzv9DlOX/SZjo/16a7/9SjK3/A7dR/xpgFLYAAABWAAAAF7+h + kdT/1bD//tCm//7Hlv/Ot6T/vr/A/767uv+Kor7/f5W1/62jnv+Pom7/ULRP/wDFUf8TkzDaAAAAYQAA + AB2tkYW7/9i///7aw//60rj/1cW6/9/f4f/EycL/uLSH///PqP+e1Hv/ONRs/xPLX/8AxFb/DqQ65wAA + AGQAAAAfjYJ+kPjOvf//7eH/9trN/9nQzP/7/P7/1dTO/+PRof//2rP/s9OO/1bZg/8tz2z/Hb1G/xKq + O+wAAABjAAAAHpWGfEDDopf9/97V/96+tv/p5Ob/8O/y/8fDqP//4bz//925///Ws/+Y0oX/OMpa/yS7 + Qf8SpzjqAAAAXAAAABvksJIKxqKK6JSTfP+dq5v/vMvB/7jLvv+m1Jb/1teZ///hwv//17X/otCF/zPQ + af8Sx13/EJ003QAAAE8AAAAUAAAAALu9gKMrznD/WN6U/3rPff+i3pb/tf/S/9DZnf/r0aH/98+i/7TN + hv9lxmH/FL9H/xmNJ8UAAAA0AAAACgAAAABosj0+Jsxg+Unbh/9k34z/ht2L/5jknP/E0o//etF3/27H + ZP+9wnf/08iQ/yC+T/shZA9uAAAAFAAAAAIAAAAAAAAAAHa0PF8/zGf5TNV6/4PIav+Mym3/i854/1zn + nP9P1Hf/4MeQ//zCpfmBgUR+AAAAFAAAAAMAAAAAAAAAAAAAAAAAAAAAWbpBRma5SMpUyWL8Qs1o/0TS + dP861nr/O8pi/9izg9G2iHNUAAAADAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5v1EDe7lWOzC8 + QId7uF6KTLNNgjOfL08oIBgMAAAAAgAAAAAAAAAAAAAAAAAAAACAA5n/AAGI/wABdP8AAHj/AACB/wAA + ov8AAIfvAAAANgAAAAAAAHuTAACV/4AAn/+AAKX/wAGg/+ADfv/wD6f/ + + + + + AAABAAgAgIAAAAEAIAAoCAEAhgAAAGBgAAABACAAqJQAAK4IAQBISAAAAQAgAIhUAABWnQEAQEAAAAEA + IAAoQgAA3vEBADAwAAABACAAqCUAAAY0AgAgIAAAAQAgAKgQAACuWQIAGBgAAAEAIACICQAAVmoCABAQ + AAABACAAaAQAAN5zAgAoAAAAgAAAAAABAAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAABgAA + AAgAAAAJAAAACQAAAAkAAAAJAAAACQAAAAkAAAAJAAAACQAAAAkAAAAJAAAACQAAAAgAAAAFAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAcAAAAKAAAADAAAAA0AAAAMAAAACgAAAAcAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAFAAAADQAAABYAAAAdAAAAIgAAACMAAAAjAAAAIwAAACMAAAAjAAAAIwAA + ACMAAAAjAAAAIwAAACMAAAAjAAAAIAAAABsAAAATAAAACwAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAAAAsAAAAUAAAAHQAA + ACUAAAAqAAAAKwAAACoAAAAlAAAAHAAAABEAAAAHAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACgAAABcAAAAoAAAAOAAA + AEUAAABMAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE4AAABKAAAAQgAA + ADQAAAAjAAAAEwAAAAgAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAADAAAACAAAAA8AAAAZAAAAJgAAADUAAABEAAAAUQAAAFgAAABbAAAAWAAAAFAAAABCAAAALgAA + ABwAAAAPAAAACQAAAAcAAAAFAAAABAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAwAAAAwAAAAdAAAANgAAAFAAAABkAAAAcQAAAHYAAAB4AAAAeQAAAHkAAAB5AAAAeQAA + AHkAAAB5AAAAeQAAAHkAAAB5AAAAeAAAAHUAAABuAAAAYAAAAEoAAAAwAAAAGQAAAAkAAAACAAAAAAAA + AAEAAAABAAAAAgAAAAEAAAABAAAAAQAAAAIAAAAFAAAACwAAABQAAAAfAAAALQAAAD4AAABQAAAAYQAA + AHEAAAB6AAAAgAAAAIAAAACAAAAAegAAAGwAAABXAAAAQQAAAC4AAAAmAAAAIQAAAB8AAAAbAAAAFwAA + ABMAAAAQAAAADQAAAAoAAAAIAAAABQAAAAMAAAACAAAAAgAAAAIAAAACAAAAAQAAAAEAAAABAAAAAQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAALAAAAHwAAADw3NjV+VFJRtVdV + VMZaWFfMWlhXzltZWM5bWVjOW1lYzltZWM5bWVjOW1lYzltZWM5bWVjOW1lYzllXVcxHRkW9HBsbnQAA + AIsAAACCAAAAcAAAAFUAAAA1AAAAGgAAAAsAAAAHAAAACwAAABEAAAATAAAAEwAAABAAAAAPAAAAEwAA + ABoAAAAmAAAANgAAAEcAAABZBgoSdRcoRbEfN13ZIjxl6CM+ae4iPGXpHTVZ3RYnQ8UDBQmZAAAAjQAA + AH8AAABuAAAAXgAAAFQAAABOAAAASwAAAEUAAABAAAAAOgAAADQAAAAuAAAAKgAAACMAAAAdAAAAGAAA + ABQAAAAQAAAADQAAAAkAAAAHAAAABwAAAAYAAAAFAAAABQAAAAQAAAAEAAAAAwAAAAIAAAACAAAAAQAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAACAAAABs2NTRVamdmx4WCgP2bmJf/pqOi/5KQjv+AfXv/gH17/4aDgf+Gg4H/hYKA/4WC + gP+FgoD/hYKA/4WCgP+FgoD/hYKA/4WCgP9/fHr4V1VU0A0NDZsAAACKAAAAdgAAAFgAAAA3AAAAIgAA + AB8AAAAnAAAAMgAAADYAAAA0AAAAMQAAADAAAAA2AAAAQwAAAFMAAQFlDhoskhwyVcokQG3zJ0R1/ydH + ef8kTID/I0+F/yZQhv8qT4P/KUh6/x84YesJEBqtAAAAmAAAAJAAAACIAAAAgwAAAIAAAAB9AAAAegAA + AHUAAABvAAAAaQAAAGEAAABZAAAAUgAAAEkAAABBAAAAOQAAADEAAAAoAAAAIAAAABkAAAAVAAAAEgAA + AA8AAAAOAAAADQAAAAwAAAALAAAACgAAAAkAAAAIAAAABwAAAAYAAAAFAAAABAAAAAMAAAADAAAAAgAA + AAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAUUE5NY3p3deqtq6n/5eTk//v8 + /f/+////9/z+/9XY2f+VlZT/f3x6/4mGhP+JhoT/iYaE/4mGhP+JhoT/iYaE/4mGhP+JhoT/iYaE/4iF + g/+Gg4H/cW5t6BkYGKEAAACLAAAAdgAAAFoAAABGAAAARgAAAFMAAABhAAAAZgAAAGYAAABiAAAAYgAA + AGgGChF9FSZAsSA5YeEmQ3P9JkV2/yhHef8mTID/HlWR/xtYlf8bWZf/G1qZ/yBbmf8qWpT/K1CE/yU/ + avQ7T1LUQVVS0TZGRcguPDvBISwrthEWFqoHCQiiAQEBnAAAAJcAAACUAAAAkAAAAIoAAACFAAAAfgAA + AHYAAABsAAAAYgAAAFcAAABLAAAAQAAAADcAAAAvAAAAJwAAACAAAAAdAAAAGgAAABgAAAAWAAAAFQAA + ABMAAAARAAAAEAAAAA4AAAANAAAACwAAAAoAAAAJAAAACAAAAAYAAAAFAAAABAAAAAMAAAACAAAAAgAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACAAAADUxLSkt7eXfsw8HA////////////+/Ht//vWy//8zL7//9/V//Ho5v+hpKT/gH59/4yJ + iP+Mioj/jIqI/4yKiP+Mioj/jIqI/4yKiP+Mioj/jIqI/4yKiP+IhYP/c3Bv6w4ODpwAAACKAAAAewAA + AHAfHh2CKSgokx8eHZcFBQSNAAAAiwUHCY8THiymGS9RzyM/bPQmRHX/J0d3/yhJe/8qS37/Kk+D/yFZ + lf8eXJz/H12c/x9env8gX6D/H2Ch/yBho/8sY6H/LFGI/zVTdv9oiYf/aYqH/2mKh/9oiYb+ZoaD+2B+ + e/VUb23rSF9d4DlLSdMnMzLGERYWtQQFBasAAAClAAAAoAAAAJoAAACSAAAAigAAAH4AAABzAAAAZwAA + AFsAAABQAAAARgAAAD0AAAA1AAAALgAAACoAAAAmAAAAIwAAACEAAAAfAAAAHQAAABsAAAAZAAAAFwAA + ABUAAAATAAAAEQAAAA8AAAANAAAACwAAAAkAAAAIAAAABgAAAAUAAAADAAAAAgAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYyMTAneHVz2sC/vf/+////+ff3//i/ + rf/5nXz/+q6H//u5kf/6q4X//qKB//PAr/+cmpj/hIOC/5COjP+PjYv/kI2L/5CNi/+QjYv/kI2L/5CN + i/+QjYv/kI2L/5CNi/+IhYP/ZGJg3AAAAJQvLi2ra2lo3YJ+fPqHg3/9h4J9+25tbuw/UF3dLEls8yZE + dP4mRXb/KEh6/ylLfv8rToH/K1CE/y5Rhv8nWpX/ImGh/yNhov8jY6P/I2Sl/yRlpv8kZqj/JGap/yRo + q/8xaan/KEl//0lofP9uj4n/aYqH/2iJhv9miIX/ZoiF/2eIhf9oiYb/aIqG/2mKh/9lhYL8W3d080dd + W+Q1RkTWGB8fwwAAALMAAACuAAAAqAAAAKAAAACYAAAAjgAAAIIAAAB2AAAAagAAAF4AAABTAAAASgAA + AEIAAAA8AAAANwAAADMAAAAxAAAALgAAACsAAAApAAAAJgAAACMAAAAgAAAAHQAAABsAAAAYAAAAFQAA + ABMAAAAQAAAADgAAAAsAAAAJAAAABwAAAAYAAAAEAAAAAwAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAADXBtap+npaP/+vz9//jy8P/4qI7/+qmB//7mvf///NP////W///70v/95Lr//6yF/+eZ + gP+MhIH/jIyL/5SRj/+TkI7/k5CP/5OQj/+TkI//k5CP/5OQj/+TkI7/k5CP/5KPjv+GhIL/ZmRi34B9 + fPuJhoP/jImG/3V4gf9PX3r/L0p1/yNCdf8lRXj/KUp8/ypNgP8sT4P/LFKG/y5Viv8vVoz/LlqS/yZk + o/8mZqf/J2eo/ydoqv8naav/J2qt/yhrrv8obK//J22x/ytxtf8yZaL/ME14/4Wfov+NqKX/h6Kg/4Ge + m/98mpf/dpSR/26OjP9qi4j/aImG/2aHhP9niIX/aImG/2iKh/9nh4T9U21q7zpNS98eKCfNBQYGvAAA + ALYAAACxAAAAqgAAAKIAAACYAAAAjQAAAIEAAAB0AAAAagAAAGAAAABXAAAATwAAAEkAAABFAAAAQgAA + AD8AAAA8AAAAOAAAADUAAAAxAAAALgAAACoAAAAmAAAAIwAAAB8AAAAcAAAAGQAAABUAAAASAAAADwAA + AAwAAAAKAAAABwAAAAUAAAAEAAAAAgAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARgXltEioeF+eXm5v/49/b/96eN//uw + iP//+M////3T///5z///+M////nP///91P//987//7SM/8iFb/+DhIT/lpOS/5aUkv+WlJL/lpSS/5aU + kv+WlJL/lpSS/5aUkv+WlJL/mJaU/46Lif+EgX//jouI/5GOi/9OX3v/JEJ0/yFCdv8mSHr/KUt//ytO + gv8sUYX/LVOJ/y9WjP8vWI//MVuS/zNclP8vY5//KWus/yprrf8rba//K26x/ytusv8rb7P/LHC1/yxy + tv8scrf/K3O5/zV3u/8pT4f/aIGT/6G4tP+bs7H/nLSy/5uzsf+Zsa//l7Cu/5Krqf+JpKL/gZ2b/3iW + lP9ujov/aYqH/2aIhf9niYX/aIqH/2iJhv9ceXf2RFpY5yUxMNUHCQnDAAAAvQAAALgAAACwAAAAqAAA + AJ0AAACSAAAAhgAAAHsAAABwAAAAaAAAAGAAAABaAAAAVwAAAFMAAABQAAAATAAAAEkAAABFAAAAQQAA + AD0AAAA4AAAANAAAAC8AAAArAAAAJgAAACIAAAAeAAAAGgAAABYAAAASAAAADwAAAAsAAAAIAAAABgAA + AAQAAAACAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACXd0cra6ubj/+P7///W5pv/7pn3///XL///4zv//9cv///bL///2y///9sv///XL///4 + zv//9Mj/96eD/5d/d/+Oj4//mpiX/5mXlf+Zl5X/mZeV/5mXlf+al5b/m5iX/5mXlf+TkY//h4SC/42L + if+bl5P/ZXCC/yBAdP8nSX3/Kk6B/yxQhP8tUof/LVWL/y9Yjv8wWpH/MlyU/zNel/80YJn/NWKc/zBr + q/8ucLP/LnG0/y5ytv8vc7f/L3S4/y91uf8wdrv/MHe8/zB3vv8veL7/NH3E/zJmpf9DXoH/m7Kw/5uy + sP+bsrH/m7Kx/5uzsf+cs7L/nLSy/561s/+etbT/nLOy/5iwr/+Qqqj/g5+c/3KRjv9qi4j/ZoiF/2eI + hf9oiYb/aYqH/198evhCV1XnICop1AIDA8UAAAC/AAAAugAAALMAAACpAAAAnwAAAJMAAACIAAAAfQAA + AHQAAABtAAAAaAAAAGQAAABhAAAAXgAAAFsAAABXAAAAVAAAAFAAAABLAAAARwAAAEIAAAA8AAAANwAA + ADIAAAAtAAAAJwAAACIAAAAdAAAAGAAAABQAAAAPAAAACwAAAAgAAAAFAAAAAwAAAAIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjYV82i4iH+Obp6f/13tb/+Zl1//7k + uf//98z///PI///zyP//88j///PI///zyP//88j///PI///4zP//4rb/yox1/4WFhf+cm5n/nZqZ/52a + mP+cmpj/nZuZ/5uZl/+Rj43/iIWD/4OAfv+IhYP/nJmX/5KSk/8zTXb/Jkp//y1Sh/8uVYr/LlaN/zBZ + kP8xW5P/Ml2W/zNgmf80Ypz/NmWf/zdlof83aKT/M3Gz/zJ1uf8ydrr/Mne8/zN4vv8zeb//M3rA/zN7 + wf8zfMP/NHzE/zR9xf80gMj/O3vA/y9Off+Ppqn/nrWy/5yzsv+cs7H/nLSy/5y0sv+ctLL/nbSy/520 + sv+dtLL/nbSz/561tP+ftrT/m7Kx/5Osqv+FoZ//d5WT/2uMif9niIX/Z4iF/2iKhv9piYb/WHNx9DZH + RuIRFxbPAAAAxQAAAMAAAAC6AAAAsgAAAKcAAACbAAAAkAAAAIYAAAB9AAAAdgAAAHIAAABvAAAAawAA + AGkAAABmAAAAYwAAAGAAAABcAAAAWAAAAFMAAABOAAAASQAAAEMAAAA9AAAANwAAADAAAAAqAAAAJAAA + AB4AAAAYAAAAEwAAAA4AAAAKAAAABgAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABHRxbo+vrq3/8/b2//Wqkv/9vJL///fK///wxP//8MT///DE///wxP//8MT///DE///w + xP//8MT///HF///2yf/0uZT/kX54/5eXl/+hn53/oJ2c/6Genf+dmpj/iYaE/4SBf/+HhYP/hIKA/5OR + j/+opKD/c3uL/yJEd/8uVYv/MFiP/zBbkv8yXZX/M1+Y/zRhm/81Y57/Nmah/zdoo/84a6b/OWyp/zpv + rf82eLv/NXrA/zZ7wf82fMP/Nn3E/zd+xf83f8b/N4DH/zeAyf83gcr/OILL/zaDzP8+hs3/L1WK/3yT + nv+hubX/nbSz/520s/+dtbP/nbWz/561s/+dtbP/nbWz/521s/+etbP/nbSz/521s/+etLP/n7W0/5+2 + tf+dtLP/lq6s/4iiof93lZP/aouI/2aIhf9niYb/aYqH/2SDgPxIX13sICop2AABAcgAAADEAAAAvQAA + ALYAAACrAAAAoQAAAJUAAACMAAAAgwAAAHwAAAB4AAAAdQAAAHQAAABxAAAAbwAAAGwAAABpAAAAZgAA + AGIAAABeAAAAWQAAAFQAAABOAAAARwAAAEAAAAA5AAAAMQAAACoAAAAiAAAAGwAAABUAAAAPAAAACgAA + AAYAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsKyoMf3x719HT1P/z3db/+Zt2///k + uP//8MP//+7B///uwf//7sH//+7B///uwf//7sH//+7B///uwf//7sH///HE///itf+zi3r/jI6O/6Wi + of+koaD/oqCf/4mHhf+IhIL/kI2L/5GOjP+GhIL/oJ6c/6yopP9XZ4L/JEqA/zJelf8zXpf/M2Ca/zVj + nf81ZaD/N2ii/zhppf85a6j/Om6r/ztwrv88crD/PXS0/zp8wf85f8X/OoDH/zqCyf86g8r/OoPL/zqE + zP86hc7/OobO/zuH0P87h9H/OojS/0GM1/8vXJf/bYSV/6W7uP+etbT/n7a0/5+2tP+ftrT/n7a0/5+2 + tP+ftrT/n7a0/5+2tP+ftrT/n7a0/561tP+etbT/nrW0/561s/+ftrT/oLa1/520s/+UrKv/g5+d/3GQ + jv9niYb/ZoiF/2iJhv9piYb/VG5r8yo3Nt0EBQXLAAAAxQAAAL8AAAC3AAAArQAAAKIAAACYAAAAjQAA + AIYAAACBAAAAfQAAAHwAAAB5AAAAeAAAAHYAAABzAAAAcQAAAG4AAABqAAAAZgAAAGEAAABcAAAAVgAA + AE8AAABIAAAAPwAAADcAAAAuAAAAJQAAABwAAAAUAAAADQAAAAgAAAAEAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAG9sakCUkY/85urr//O2o//8s4n///DC///rvv//673//+u9///rvf//673//+u9///r + vf//673//+u9///rvf//677///DB/9msjv+Jg4L/paOj/6mmpf+cmZj/iIWD/5WSkP+YlZP/lJGP/4uI + hv+rqKf/q6mo/0Zbfv8qVIz/NWOd/zZln/83ZaL/OGik/zhrp/86bar/O3Cs/zxxsP89c7P/PnW1/z93 + uP8/ebr/PoHG/z2EzP89hc7/PofP/z6H0P8+iNH/PojT/z6K1P8+itT/PovW/z+M1v8+jdf/RZPg/zBi + of9jeo//qL25/5+2tf+ftrX/oLe1/6C3tf+gt7X/oLe1/6C3tv+gt7X/oLe1/6C3tf+gt7X/oLa1/5+2 + tf+ftrX/n7a0/5+2tP+etbP/nrWz/5+2tP+ftrX/m7Kx/42npf95l5X/a4uI/2aIhf9oiYb/aYqH/1h0 + cfUtPDrfBAUFywAAAMUAAAC/AAAAtwAAAKwAAAChAAAAlgAAAI4AAACIAAAAhQAAAIEAAAB/AAAAfQAA + AHwAAAB6AAAAeAAAAHYAAABzAAAAcAAAAGwAAABoAAAAYgAAAFwAAABVAAAATQAAAEMAAAA5AAAALgAA + ACMAAAAYAAAADwAAAAkAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAABdXJwgq2srP/t6Of/9p+A//7T + pv//7L7//+i6///ou///6Lv//+i7///ou///6Lv//+i7///ou///6Lv//+i7///ouv//7b7/9s6l/5CC + ff+hoaH/raup/5eUk/+UkpD/nZuZ/6Cenf+WlJL/kI6M/7Oxr/+trKz/O1N7/y9dl/84aaX/OGum/zls + qf86bqz/O3Gv/zxzsv89dbT/Pne3/z95uv9Ae7z/QX2//0J+wf9Chcr/QYrT/0GK1P9BjNX/QYzW/0GN + 1v9Cjtj/Qo/Z/0KP2v9CkNv/QpDc/0GR3P9Imeb/MWWl/2B3jv+pv7r/obe2/6G3tv+huLb/obi2/6G4 + tv+huLb/obi2/6G4tv+huLb/obi2/6G4tv+gt7b/obe2/6C2tv+gt7X/oLa1/5+2tf+ftrT/n7a0/561 + tP+etbT/n7a1/521s/+TrKr/gJya/22Niv9miIT/aImG/2mKh/9ZdHL1LTw63wQFBcoAAADFAAAAvwAA + ALYAAACsAAAAogAAAJkAAACSAAAAjAAAAIYAAACDAAAAgAAAAH8AAAB+AAAAfQAAAHwAAAB6AAAAdwAA + AHQAAABxAAAAbAAAAGcAAABgAAAAWAAAAE0AAABBAAAANAAAACYAAAAaAAAADwAAAAgAAAADAAAAAQAA + AAAAAAAAAAAAAAAAAAN8eXe0wsPE/+/Vzv/6n3r//+O0///muP//5rf//+a3///mt///5rf//+a3///m + t///5rf//+a3///mt///5rf//+a3///nuP//4bL/p46A/5iamv+urKv/ko+N/6CenP+lo6L/qaem/5eV + k/+Wk5H/urm2/7Kxsf85Unr/MmKe/zpvrP87cK7/PHOw/z10tP8+d7b/P3m5/0B7vP9Bfb7/Qn/B/0OB + w/9Dg8b/RITI/0WIzv9Ejtf/RY/a/0WQ2/9Fkdz/RZLd/0WS3f9Fk93/RZPf/0WU4P9FleH/RZXi/0ub + 6f8yY5//bYSV/6m/uv+iuLf/ori3/6K4t/+iuLf/ori3/6K4t/+iuLf/ori3/6K4t/+iuLf/ori3/6K4 + tv+iuLf/obi3/6G4tv+ht7b/obe2/6C3tf+gtrX/n7a1/562tP+etbP/nrWz/561tP+ftrT/lq+t/4Of + nf9vj4z/ZoiF/2iJhv9piof/V3Jw9SYyMdsAAADJAAAAxAAAAL4AAAC3AAAAsAAAAKgAAACfAAAAlQAA + AI0AAACGAAAAgQAAAIAAAAB/AAAAfwAAAH4AAAB9AAAAfAAAAHoAAAB3AAAAdAAAAG8AAABoAAAAYAAA + AFQAAABGAAAANgAAACUAAAAXAAAADAAAAAUAAAABAAAAAAAAAAAAAAAAV1VUD4WCgOXT2dv/8Lys//2v + hP//57f//+O0///jtP//47T//+O0///jtP//47T//+O0///jtP//47T//+O0///jtP//47T//+O0///n + tf+/pIz/kZCR/62rqv+Rjoz/qqin/62rqv+xr67/nJmY/5iVlP/Av73/ubi4/z9Xfv8zZaL/PnS0/z51 + tf8/eLj/P3q7/0F8vf9CfsD/QoDD/0SCxf9EhMj/RYbK/0aHzf9Hic//SIvS/0iS3P9IlN//SJXg/0iV + 4f9JluL/SZbj/0mY5P9JmOX/SZnl/0mZ5v9Jmuj/TZ3q/zBblP95kJ3/qL66/6O4uP+jubj/o7m3/6O5 + uP+jubj/o7m4/6O5uP+jubj/o7m4/6O5uP+jubj/o7m4/6O4uP+jubf/ori3/6K4tv+iuLf/obi2/6G3 + tv+gtrb/n7a1/5+2tf+ftrT/nrW0/520s/+etbP/nrW0/5iwr/+EoJ7/bo6L/2aIhf9oiYb/aYqH/1Jq + ZvAUHibYAgQHzAAAAMUAAADBAAAAvAAAALQAAACqAAAAnQAAAJEAAACIAAAAggAAAIAAAAB/AAAAfwAA + AH8AAAB/AAAAfgAAAH0AAAB7AAAAeQAAAHQAAABuAAAAYwAAAFUAAABDAAAAMAAAAB4AAAAQAAAABwAA + AAIAAAAAAAAAAAAAAAByb2wwj42L+93f3//yq5P//r6R///ltP//4LH//+Cx///gsf//4LH//+Cx///g + sf//4LH//+Cx///gsf//4LH//+Cx///gsf//4LD//+a0/9W2lv+Qi4v/qaem/5WSkP+zsbD/tbOy/7m3 + tv+lo6H/lZOR/8XDwv/Fw8H/T2SF/zBin/9Be73/QHu8/0F9v/9Cf8L/Q4HE/0SDx/9Fhcn/RofM/0aJ + zv9Ii9H/SYzT/0mO1f9Kj9f/S5Te/0yZ5P9MmuX/TJrm/0yb5/9Mm+j/TJzp/0yc6f9Mner/TJ3r/02f + 7v9Nmeb/L1CB/5Sqrv+mvLr/pLq4/6O6uP+kurn/pLq4/6S6uP+kurj/pLq4/6S6uP+kurj/pLq4/6S6 + uf+jurj/pLq4/6O5uP+jubj/o7i4/6O5t/+iuLf/ori2/6G4tv+ht7b/oLa2/6C2tf+ftrT/nrWz/560 + s/+dtLP/nbSz/561tP+Wrq3/gZ2b/2yMiv9miIT/a42H/1p6gv8jP2n5GCxM6wsVI9gAAADIAAAAxAAA + ALwAAACxAAAAogAAAJMAAACHAAAAggAAAIAAAACAAAAAgAAAAH8AAAB/AAAAfwAAAH8AAAB9AAAAewAA + AHYAAABsAAAAXgAAAEwAAAA3AAAAIwAAABMAAAAIAAAAAgAAAAAAAAAAAAAAAHd0clOfnpz/4dzb//ag + gf/+zJ3//+Cv///erf//3q3//96t///erf//3q3//96t///erf//3q3//96t///erf//3q3//96t///e + rf//4a//6sef/5CLiP+opqb/mJWU/7u5uP+9u7r/wb++/7Gvrv+Sj47/yMfG/9PQzP9od5D/KlqW/0SC + xf9DgcP/Q4PG/0SEyP9Fh8v/R4jN/0iK0P9IjNL/SY3U/0qP2P9Lkdr/TJPc/0yU3f9Old//T5vo/0+e + 6/9Pnuv/T5/s/0+f7P9PoO7/T6Du/0+g7/9Poe//U6j5/z9/xv9FX4L/p727/6vAvv+pvr3/qL28/6a8 + uv+mu7r/pbu6/6W6uv+lurr/pbq6/6W7uv+lu7r/pLu5/6W6uf+kurn/pLq4/6S6uf+kurj/o7m4/6O5 + uP+jubj/ori3/6K4t/+huLb/oLe1/6C2tf+ftrX/nra0/561s/+dtLL/nLSy/520sv+dtLP/k6yr/3uZ + lv9piof/a4yG/09vf/8jQ3T/I0R1/xs0WvEIEh7WAAAAyAAAAMEAAACzAAAAoQAAAJAAAACFAAAAgAAA + AIAAAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH0AAAB7AAAAdgAAAG0AAABfAAAATQAAADgAAAAjAAAAFAAA + AAkAAAACAAAAAAAAAAAAAAAAeHVzc6moqP/k2NT/+Jx5///Wpf//3Kr//9up///bqf//26n//9up///b + qf//26n//9up///bqf//26n//9up///bqf//26n//9up///dq//30qT/kouE/6elpf+amJf/w8HA/8XD + w//Ix8b/wsC//4yKiP/IxsX/3NnW/4+Xp/8nT4j/RIXJ/0WGyv9Gh83/R4nO/0iL0f9IjdT/So7W/0qR + 2P9Lktr/TJTd/02V3/9Ol+H/T5jj/0+Z5P9Rnen/U6Lw/1Ki8P9To/H/UqPy/1Kk8/9SpPP/UqTz/1Om + 9v9VqPf/LFeQ/0Nkcv9rjon/dZaT/4Shnv+SrKr/obi2/6a8u/+rwL//qr++/6i9vP+nvLv/pbu6/6W7 + uv+mu7r/pbu6/6W7uv+lu7r/pLu5/6W6uf+kurj/o7q4/6O5uP+jubj/o7m3/6K4t/+huLf/obi2/6C2 + tv+ftrX/nra0/561tP+dtLP/nLOy/5yzsf+cs7L/nLKy/42npf9yko7/aYuF/zxhfv8aRXr/HUl7/xxI + ef0OJj/jAAAAyQAAAMAAAACwAAAAmwAAAIsAAACCAAAAgAAAAH8AAAB+AAAAfQAAAHwAAAB7AAAAeAAA + AHUAAABvAAAAZgAAAFgAAABHAAAAMwAAACAAAAASAAAACAAAAAIAAAAAAAAAAAAAAAB7d3WNsLKy/+jO + x//6oXr//9aj///Zpv//2Kb//9mm///Zpv//2ab//9mm///Zpv//2ab//9mm///Zpv//2ab//9mm///Z + pv//2ab//9qn//zWpP+dkIb/qKen/52amP/KyMf/zczL/9DPzv/Pzs3/lZKR/7y7uv/f3dz/w8TI/zFO + fP8/fcH/SYzT/0mM0/9JjtX/SpDX/0uR2/9Mk93/TZXf/02W4P9PmOP/T5nl/1Cb5/9QnOn/UZ7q/1Kg + 7P9Uo/H/VaX0/1Wm9f9Vp/b/Vqf3/1Wn9/9VqPn/WrD//z56vv8uS3D/TXVy/0Zwa/9DbWn/RG5q/0Vv + a/9Pd3P/YoWC/3aWk/+Mp6X/n7a1/6i+vf+twcD/qr69/6e9u/+mu7r/pry6/6W7uv+mu7r/pbu6/6W7 + uv+lurn/pLq4/6O6uP+jubj/o7m4/6O5t/+huLb/obi2/6G3tv+ftrX/n7a0/561s/+dtLP/nLSy/5yz + sf+bsrH/nLOy/5Stq/94lpL/X4OE/x9SgP8WTID/Fk+C/xVPgv8JJz/hAAAAxgAAALoAAACoAAAAlQAA + AIcAAAB/AAAAewAAAHkAAAB3AAAAdAAAAHEAAABuAAAAaQAAAGIAAABYAAAASgAAADsAAAAqAAAAGgAA + AA4AAAAGAAAAAgAAAAAAAAAAAAAAAH57eZ62ubn/58W6//ungP//26v//9qr///Xpv//1qL//9aj///W + o///1qP//9aj///Wo///1qP//9aj///Wo///1qP//9aj///Wo///16P//9Wi/6WXiP+pqKn/oaCe/87N + zP/V1NP/19bV/93c3P+ppqX/pqSj/+Li4f/l4+D/ZXWS/yxfnv9MlN3/SpDZ/0yT3P9MlN3/Tpbg/06X + 4v9PmeT/T5rm/1Gc6P9Rner/Up/r/1Kg7v9Toe//U6Px/1Sk8/9VpvX/Vqj4/1eq+v9Xq/z/Wa///1qv + //9BgMb/Kkh2/2SCiv95mJP/dpSS/3CQjv9pi4j/YISB/1Z7eP9Jcm7/Qm1o/0Ruaf9MdHD/ZIeD/32b + mf+Wrq3/qL28/6zAv/+pvrz/p7y7/6a8uv+mvLr/pbu6/6W7uv+lu7r/pbq5/6S6uP+kurj/o7m4/6O4 + uP+iuLf/obi2/6G3tv+gt7X/n7a1/561s/+dtLP/nLSy/5yzsf+asrD/mrKw/5iwr/+Iop3/RXKI/wxP + hf8QU4f/D1SI/w1RgvwBBwvLAAAAwQAAALMAAACiAAAAjwAAAH8AAAB1AAAAbwAAAGsAAABnAAAAYwAA + AF4AAABYAAAAUAAAAEUAAAA5AAAAKwAAAB4AAAASAAAACgAAAAQAAAABAAAAAAAAAAAAAAAAgH17sLq9 + v//ovK7//KuF///etf//27P//9qx///Wqf//06D//9Og///ToP//06D//9Og///ToP//06D//9Og///T + oP//06D//9Og///UoP//1KH/rJqH/6qqrP+op6X/ysjH/9/f3f/f3tz/5OPj/8vKyP+Qjoz/3t3c/+7s + 6f+8wcn/KUp7/0SHzv9PmeT/TZbh/0+Y5P9QmuX/UJvn/1Gd6f9Rnuv/UqDt/1Kh7/9TovD/VKTy/1Sl + 9P9WqPf/WKz8/1mv//9Yq/z/Vaf3/1Gf7P9FidL/MWKh/y9Mdv9igIn/fpyX/3yZl/99m5n/f52a/4Ke + nP+Dn53/gZ2b/36bmf91lJH/Z4mG/1h9ev9IcG3/QWxn/0Vva/9fg4D/iKSh/6G4tf+rwL7/rMC//6i9 + vP+nvLv/pru6/6W7uv+lu7r/pbu6/6S6uf+kurn/o7m4/6O5uP+iuLb/ori3/6C3tv+gt7X/n7a0/561 + s/+dtLP/nLOx/5uysf+asbD/mbGv/5yzsP+HpKb/GF+O/wdVjP8KWI7/A1eP/yBATuIAAADCAAAAugAA + AK0AAACaAAAAhQAAAHIAAABkAAAAWwAAAFUAAABQAAAASgAAAEIAAAA6AAAAMAAAACYAAAAcAAAAEwAA + AAsAAAAGAAAAAgAAAAEAAAAAAAAAAAAAAACCf328vcHC/+a5q//8q4T//tuy//7ZsP/+2bD//tmx//7U + p//+0J7//tCf//7Qn//+0J///tCf//7Qn//+0J///tCf//7Qn//+0J///9Cf///ToP+ynoj/qKmr/7Cu + rf+vraz/6urp/+fm5f/p6Oj/6+rq/5iWlP+9vLv/8fHw//Ty8P98iqL/I0+K/06Z5P9Rnur/UJzo/1Ge + 6v9Sn+z/U6Hu/1Sj8f9UpPP/Vqj3/1er/P9YrPz/Vqf3/1Gf7f9FidL/PHa6/zRkov8vV4z/Lk98/zlW + ef9Pan3/cpCR/3+dmP99m5j/fpyZ/4Ccm/+Bnpz/gp6c/4Ofnf+EoJ7/haCf/4aioP+Io6H/hqKg/3+d + m/9xkY7/X4OA/0pzb/9BbGf/TnZy/2yNiv+Mp6X/pbu5/63Av/+qv77/p7y7/6a7uv+mu7r/pbu6/6W6 + uf+jurj/pLq4/6O5uP+iuLf/obi3/6C3tv+gtrX/n7a0/560tP+dtLL/nLOy/5qysf+asa//mLCu/5+0 + sP9HgZ7/AFeR/wNdlP8AW5X/LHGP/0hcWOQEBQW8AAAAsgAAAKQAAACOAAAAdQAAAF4AAABMAAAAQQAA + ADkAAAAzAAAALAAAACUAAAAeAAAAFwAAABAAAAAKAAAABgAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAIJ/ + fbq7v8D/6bKg//2uhv/+2rL//tau//7Wrv/+1q7//tau//7Qov/+zZv//s2c//7NnP/+zZz//s2c//7N + nP/+zZz//s2c//7NnP//zZz//8+d/7GciP+pqqz/xcLC/4yJh//a2tr/8/Pz//Dw8P/49/f/z83M/5GO + jP/r6+r/+ff2/+3t7v9bbpD/JleT/0+c6P9Vpvb/VKXz/1ao+f9Wqfn/VKX0/1Kg7/9Kkdv/QX/F/zhs + rv8xXZb/LlGA/zVTd/9BXnb/T2t8/2B+hf9vjo7/eJWT/3+dmP9+m5j/fpyZ/3+cmv+Bnpv/gp+d/4Sg + nv+FoZ//haGg/4aioP+HoqH/h6Oh/4ejof+Ho6H/iKOh/4qlo/+KpKP/gJ2b/2qLif9VfHj/Q25p/0Nt + aP9Ve3f/d5aU/5mxr/+qv77/q7++/6e9u/+lu7r/pbu6/6S7uf+kurj/pLq4/6O4uP+iuLf/obi2/6G3 + tv+ftrX/nra0/561s/+dtLL/nLOx/5qysP+Zsa//nbOv/3qgqP8CYJb/AF+W/wBel/8PZZT/ZomI/1Ns + aeoNERC3AAAAqAAAAJgAAACAAAAAYgAAAEcAAAAzAAAAJwAAAB8AAAAaAAAAFQAAABAAAAALAAAABwAA + AAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAgn99urm9v//or53//q+H//7asv/+1a7//tWu//7V + rv/+1a7//tSu//7Nn//+yZj//sqZ//7Kmf/+ypn//sqZ//7Kmf/+ypn//sqZ///Kmf//zJr/sZuG/6qq + rP/V09T/o6Gg/5mWlP/w8PH//f39//v8/P/9/f3/pKKh/7CtrP/8/f3////+/+7w8/9leJj/JE2G/zl6 + wP9Ei9b/OHi+/zJoqf8yXpf/LlCB/y5Ndv82VXL/QF5x/01teP9fgIH/bIyJ/3OUjv93l5H/eJeT/3qY + lf97mZf/fZuZ/3+bmv+Bnpz/gp+d/4Sgnv+FoaD/hqKg/4ejof+IpKL/iaSi/4mlo/+KpaP/iqWj/4ql + o/+KpaP/iaSi/4qlo/+KpKP/i6Wk/4ejof97mJf/ZYiF/052cv9Aa2f/SHFt/2iKh/+Qqaj/qL28/6vA + v/+nvLv/pbu6/6S6uf+kurj/pLq4/6O4uP+iuLf/obi2/6C2tv+ftrX/n7a0/561s/+ctLL/m7Ox/5qx + sP+asa//l6+u/yFwmv8AW5T/AV6V/wNelP9TgYn/bYyG/1t4de4TGRmyAAAAngAAAI0AAAByAAAAUQAA + ADMAAAAdAAAAEgAAAA0AAAAJAAAABgAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACCf327t7u7/+O0pP/9q4X//ti0//7Vsf/+1bH//tWx//7Vsf/+1bL//tSw//7Ln//+xpb//saW//7H + mP/+x5j//seY//7HmP/+x5j//8eY///Jmf+xmoX/q6yt/9fV1f/Rz8//mZaV/52bmf/r6ur/+/v7//j3 + 9//j4eH/kI6M/8rIx/////////////n4+P+mrr//XnKT/0tljP9rfZv/gYmd/2hseP9Xc3T/VXx5/16D + fv9mioP/aYyG/2yOiv9wkI7/c5OQ/3aVkv94l5X/e5qX/36bmf+AnJn/gp6c/4Sgnv+FoZ//hqKh/4ij + of+JpKH/iqWj/4ulpP+LpqT/jKal/4ynpf+Np6X/jael/42npf+Mp6X/jKal/4umo/+KpaT/iqWi/4ul + o/+LpaP/g6Ce/3GRj/9Yfnr/Q25p/0Nuav9fg3//iKOh/6e8u/+rv77/pry7/6S6uf+kurj/pLq4/6O5 + uP+iuLf/obi2/6C2tv+ftrX/nrW0/520s/+cs7L/mrKw/5mxsP+gtbD/UIih/wBYkv8DXZP/AFqU/zx2 + jv9ujIX/aYqH/2B+e/McJSSwAAAAlgAAAIQAAABnAAAARAAAACUAAAAQAAAABgAAAAMAAAACAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIF+fLWxtbX/4LOk//yqhv/+17b//tW0//7V + tP/+1bT//tW0//7VtP/+1bT//tW0//7OqP/9xpn//cOT//3Dk//9xJT//cSV//3Elf/+xZX//sWV/6yW + hP+ys7T/2NfX/9bV1P/U09L/oqCe/4yJiP+sqqj/wb+9/7+9vP+YlpT/fnt5/7u5uP/s6+r/7u7t//Pw + 7f/p5uX/4eDg/93a2P+ro57/cH55/1d+eP9cgX3/YYWB/2WIhP9pi4j/bo+M/3KSkP91lJL/eJaV/3ua + l/9+nJr/gJyb/4KenP+EoJ7/haGg/4ejof+JpKL/iqWj/4ulpP+Mp6X/jaem/46opv+Op6b/j6in/4+o + p/+PqKf/j6in/4+op/+Op6b/jqim/42npf+MpqT/iqWk/4qlo/+JpKL/iqSj/4eioP94l5T/XoJ//0Zv + a/9Ca2f/W4B9/4mkov+nvbz/qb69/6W7uf+kurj/o7m4/6O4uP+huLb/obe2/6C2tf+ftbT/nrWz/5y0 + sv+bsrH/mrGw/52zsP99oan/Bl2T/wNbkv8AWJH/L3KY/3uYlP9piYb/aYqH/2GAffMdJiWsAAAAkAAA + AH4AAABgAAAAPAAAABwAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAfnx6oaqsrf/btKf/+6iE//7XuP/+1rf//ta2//7Wtv/+1rb//ta2//7Wtv/+1rf//te4//7U + tP/9zaf//cac//3Clf/9wJL//b+Q//7Bkf/9wJH/pZKE/7u8vf/b2tn/19bV/9nY1//b2tn/w8HA/6Si + oP+al5b/m5mX/6mmpf+1s7L/jouK/5mVk/+/urr/zMnI/8vIx/+6tbP/kY2L/2x5d/9Ve3f/WX97/1+D + gP9jh4P/Z4qH/2uNiv9wkY7/dZWS/3iWlP97mZf/fpuZ/4Cdm/+Dn53/haCe/4eioP+Io6H/iaSj/4um + pP+Np6X/jqem/46opv+Pqaf/kKmo/5CpqP+Rqqj/kaqo/5GqqP+Rqqj/kaqo/5CpqP+Qqaj/j6in/46o + pv+Np6X/jKal/4ulo/+Io6L/iKOh/4ijof+GoqD/epiW/2CEgf9GcGz/Qmxo/2GEgf+Qqqn/qb69/6e8 + u/+kurj/o7m4/6K5t/+huLb/obe1/6C2tf+etbT/nbSz/5yzsf+bsrH/m7Kw/5Wvrv8gapX/AliQ/wNZ + kP8UY5P/iaan/3yZlv9niIX/aYqH/2GAffMdJiapAAAAjgAAAHkAAABZAAAANQAAABcAAAAHAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+e3mRpaal/9S3rv/5ooD//tW5//7X + u//+1rr//ta6//7Wuv/+1rr//ta6//7Wuv/+1rr//te6//7XvP/+1rr//tS2//7Qrv/+yaT//8KW//q6 + jf+ejYL/xMXG/97d3P/b2tn/2tnZ/9va2f/e3d3/397d/9rZ2f/b2tn/4N/e/+Lh4f+ioJ//ZHJv/215 + dv9+gn//fYF+/3B7eP9eeXb/Unp2/1d9ef9dgn7/YoWC/2aJhv9qjIn/bo+N/3OTkP94lpT/e5mW/32b + mf9/nZv/gp6d/4Wgn/+HoqD/iaOi/4qlo/+MpqT/jael/46opv+Pqaf/kKmo/5GqqP+Rqqn/kqup/5Kr + qv+Sq6r/kquq/5Krqv+Sq6r/kqup/5Gqqf+Qqqj/kKmo/4+opv+OqKb/jKal/4ulpP+KpKL/h6Kh/4ah + oP+FoZ//hKCe/3eWk/9cgH3/RG5q/0Zwa/9tj4v/nbSz/6m+vf+kurn/o7m4/6K4t/+huLb/oLe2/5+2 + tP+etbP/nLOy/5uzsf+asrD/n7Ww/0R+nP8AVI3/B1mP/whZjv9wlqL/lq2p/3mXlf9niYX/aYqH/2GA + ffIUGhmjAAAAjAAAAHYAAABTAAAALwAAABMAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAH57eXecnZz/ybm0//ebef/+1Lr//tm///7Yvv/+2L7//ti+//7Yvv/+2L7//ti+//7Y + vv/+2L7//ti+//7Yvv/+2L///tnA//7ZwP//2Lz/9sKg/5OJgv/R0dL/4N/f/97d3f/e3d3/3t3d/97d + 3P/e3d3/397d/9/e3f/f3t7/3t3c/5iVlP9QcW3/THZy/1R6df9TeXX/UXl1/1F6dv9Ue3f/WoB8/2CE + gP9liIX/a4yJ/2+Qjf9yko//dpWT/3uZl/9+m5n/gp+d/4aioP+Io6H/iqSj/4ulo/+MpqT/jKel/46o + pv+PqKf/j6mo/5Gqqf+Sq6n/kquq/5Osqv+TrKv/lKyr/5Ssq/+UrKv/lKyr/5Ssq/+TrKv/k6yq/5Kr + qv+Rqqn/kKqo/4+pp/+NqKb/jael/4ulpP+KpKL/iKOg/4ahn/+En57/gp+d/4Cdm/9wkY7/VHp2/0Fr + Z/9Qd3P/hKGe/6e9vP+mvLr/ori3/6K4t/+ht7b/n7a1/561tP+ds7L/m7Oy/5qysf+htrH/ZJCj/wVW + jf8JWI7/AlOM/1OFnP+asKr/j6mn/3mXlP9oiYb/aYqH/1t4dusMDw+cAAAAiQAAAHAAAABMAAAAKAAA + AA4AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgH58VpSTkv+/uLX/8pl5//7N + s//928P//dnB//3Zwf/92cH//dnB//3Zwf/92cH//dnB//3Zwf/92cH//dnB//3Zwf/92cH//dnB///d + xf/pxrH/k4+M/9zc3P/i4uH/4eDg/+Hg4P/h4OD/4eDg/+Hg4P/h4OD/4eDg/+Li4f/e3Nz/i4qI/1Bz + b/9Renb/Unp2/1J6dv9Tenb/VHt3/1d9ev9cgX3/XoJ//12Bfv9bgH3/WoB8/1l+e/9Zfnv/W398/1uA + ff9hhYL/ZYiF/2yNiv90k5D/fJqY/4ahn/+LpqT/kKqo/5WtrP+Vrqz/lKyr/5Ssq/+Urav/lKys/5Wt + rP+Vraz/la6s/5WurP+Vrqz/la2s/5WtrP+Uraz/k6yr/5Osqv+Sq6r/kaqp/4+pqP+OqKb/jael/4ul + pP+KpKL/h6Kh/4Whn/+Dn53/gJ2b/3+cmv96mZb/ZYiE/0lybv9CbGj/Z4qH/5yzsv+ovbz/ori3/6G4 + tv+gt7X/nra0/520s/+ctLL/m7Ox/52zsf+Eo6r/D1uO/wlXjP8EU4r/OXOW/5Ssqf+Qqaf/jqim/3aU + kv9niYb/aYqH/1Ntat8EBQWWAAAAhgAAAGkAAABDAAAAIAAAAAoAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACAfXw0jYqJ/La1s//nm4H//8Gl//7eyv/+2sX//trF//7axf/+2sX//trF//7a + xf/+2sX//trF//7axf/+2sX//trF//7axf/92sX//+DK/9W1pP+bl5X/4+Pi/+Xk5P/k5OP/5OTj/+Tk + 4//k5OP/5OTj/+Tk4//k5OP/5+bm/9fV1P9/gX//UXdz/1N6dv9Tenb/VHt3/1N6dv9ReHT/TnZy/0py + bv9Gb2v/RW9q/0Zva/9GcGz/SHFt/0lybv9JcW7/SHFu/0ZvbP9Fb2v/RW9r/0Vvav9GcGz/SnNv/1J4 + df9eg3//a4yK/3mYlf+KpaP/k6yq/5iwr/+asbD/mLCv/5evrv+Xr63/lq+t/5avrf+Wrq3/lq6t/5au + rf+Vraz/lK2r/5Osq/+Sq6r/kaqp/4+pqP+OqKb/jael/4ulo/+Jo6L/h6Kg/4Sgnv+Bnpz/fpya/3yZ + l/97mZf/cJCO/1Z8eP9Ba2f/Unl2/4ynpf+nvLv/o7m4/6C3tf+ftrX/nbWz/520s/+cs7L/nLOx/5av + r/8mZpH/CFSK/wlUiv8eYI7/jKeo/5Gqp/+OqKb/i6ak/3KSj/9niIX/aYqH/0RaWM4AAACSAAAAgAAA + AF8AAAA3AAAAFwAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIOAfhCFgoDsqq+v/9ie + iv//s5X//uHP//7dyv/+3Mr//tzK//7cyv/+3Mr//tzK//7cyv/+3Mr//tzK//7cyv/+3Mr//tzK//7d + yv//4c3/vqOV/6enp//s7Oz/6Ofn/+jn5v/o5+b/6Ofm/+jn5v/o5+b/6Ofm/+fn5v/t7Oz/ycXE/3J7 + ef9ReXX/U3p2/1N6dv9PdnL/SXFt/0Vvav9IcW3/Unh2/16Cgf9oiYn/b4+Q/3WUlf95l5j/fpqc/36b + nP9+m5z/eZeY/3eWlv9ykpL/bY6O/16CgP9SeXX/T3Zz/0lxbv9Dbmn/RG5q/0hxbf9Ve3j/ZoiF/3mY + lv+MpqT/l6+u/5yzsv+bsrH/mbCv/5ivrv+Xr63/l6+u/5aurf+Vrqz/la2s/5Osq/+Sq6r/kaqp/4+p + qP+OqKb/jKak/4qko/+Io6L/haKg/4Ofnf+AnZv/fZqY/3qYlv94lpT/dJOR/1+EgP9Gb2v/RnBr/3qZ + lv+mu7r/o7m4/6C2tf+etbP/nbSz/5yzsv+bs7H/nrSx/0F3l/8GUIf/DVSJ/xFXiv96nKP/lKyp/4+o + pv+OqKb/iKOh/26Oi/9oiYb/aYmG/y07OrcAAACOAAAAdwAAAFIAAAArAAAADwAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAhIF/AoJ/fsCfoqL/x6aa//uig//+3s7//t/P//7fzv/+387//t/O//7f + zv/+387//t/O//7fzv/+387//t/O//7fzv/+387//9/P///dy/+oj4X/vL6+//Hw8P/r6ur/6+rq/+vq + 6v/r6ur/6+rq/+vq6v/r6ur/6+rq//Hw8P+3s7L/Znd0/1B6dv9QeHT/SnNv/0Ruav9NdXL/YoWE/3WU + lf9/m53/g5+h/4Sgov+Dn6H/g5+h/4Kfof+Dn6H/g5+h/4Sgof+FoKL/haGj/4eipP+IpKb/dZOS/2mJ + hv91lJH/eZeV/2+PjP9lh4T/WoB8/052cv9Fb2r/RG5p/0hxbf9Zfnv/b4+N/4Sgnv+Wrq3/nLOy/5yz + sv+YsK//l6+u/5aurf+Wra3/la2r/5Osq/+Sq6r/kaqp/4+pp/+Op6b/jKWk/4mko/+Ho6H/hKGf/4Ke + nP9/nJr/e5mX/3iWlP90lJH/cZKP/2WIhP9MdHD/Qmxo/26PjP+ht7b/ori2/5+1tP+dtbP/nLSy/5uz + sf+iuLP/W4ie/whPhv8PU4j/DFGH/2WMnv+Yr6r/jqmn/42npf+Np6X/gp+c/2qLiP9oiYb/YoF/9BEW + FqAAAACIAAAAagAAAEIAAAAdAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgH17iJaV + lP+0qqb/8pZ1///Uwv/+5Nb//uHT//7h0//+4dP//uHT//7h0//+4dP//uHT//7h0//+4dP//uHT//7h + 0///5df/9869/5WGf//Z2tr/8fHx/+7u7v/u7u7/7u7u/+7u7v/u7u7/7u7u/+7u7v/v7u7/7+7u/6Cc + m/9eeHT/THZy/0ZwbP9IcW3/YoWE/3uZmv+Dn6H/gp6g/4Gdn/+BnZ//gZ2g/4Gen/+CnqD/gp6h/4Of + of+En6H/hKCh/4Sgov+FoaP/h6Gj/4Whov9tjYv/aYqH/32al/+AnZv/f5yZ/3+bmf99mpf/eJeU/3KR + jv9lh4X/WH56/0tzb/9DbWn/RW5q/1J5dv9rjIr/g6Ce/5evrv+cs7L/mbCv/5evrf+Wraz/lK2s/5Os + q/+Sq6n/kKqo/46op/+NpqX/i6Wk/4ijov+FoqD/g5+d/3+cm/98mpj/eZeV/3WVkv9xkY//bo+M/2aI + hf9Pd3P/QGtm/2+Rjf+lu7r/oLa1/521s/+dtLP/m7Ox/5+2sv91mKT/EVOG/xBShv8JTYT/TXyX/5mw + q/+Pqaf/jqim/4ympP+LpaT/e5iW/2iJhv9piof/T2hm2wAAAJIAAAB9AAAAWgAAADEAAAARAAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAfnxKjImI/6anqP/blX3//7uh//7q3//+5Nj//uTY//7k + 2P/+5Nj//uTY//7k2P/+5Nj//uTY//7k2P/+5Nj//uTY///p3f/bsJ//lpCN/+7u7//z8vL/8fHx//Hx + 8f/x8fH/8fHx//Hx8f/x8fH/8fHx//T09P/k4+P/hoaE/1J2cv9Fb2v/TXVx/3KSkv+EoKL/gp6g/4Gd + n/+BnaD/gZ6f/4KeoP+Cn6D/g5+h/4Ofof+EoKL/hKCi/4Whov+FoaP/hqKj/4eipP+IpKX/hKCg/2mK + h/9rjIn/gp+c/4Ofnf+BnZv/gJya/36cmf9+mpj/fZqY/32amP96mJb/dpSR/2uMiP9dgX7/TXZy/0Nt + af9EbWn/V3x5/3yal/+Sq6r/mrKx/5mwr/+Vrqz/k6yr/5Orqv+Rqqn/j6mn/46opv+MpqT/iaSi/4ai + of+EoJ7/gZ2b/36bmf96mJb/dpWT/3KSkP9uj4z/aoyJ/2SIhP9Pd3P/R3Fs/4aioP+lu7n/nrW0/520 + s/+cs7L/nrSx/4unq/8ZV4f/EFGE/w1Ng/87bpD/k6yp/5GqqP+OqKb/jKak/4qlo/+Io6H/cpGO/2eI + hf9piof/Kzk4tgAAAIsAAABvAAAARgAAACAAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAISB + fw6EgoDnnJ6e/76dkf/7oH///uXZ//7p3//+6N3//ujd//7o3f/+6N3//ujd//7o3f/+6N3//ujd//7o + 3f//6d///+PV/7SLfP+vsLD/+vr6//X19f/19PT/9fT0//X09P/19PT/9fT0//X09P/19PT//Pv8/8rH + xv9ueHX/RW9r/011cv92lZb/hKCj/4Gen/+Bnp//gp6g/4KfoP+Dn6H/g5+h/4Ofof+EoKH/haGi/4Wh + ov+GoaP/hqKk/4ejpP+Io6X/iKSl/4umpv+BnZ3/aImG/3GQjf+Io6D/hqKf/4Wgn/+DoJ3/gp6c/4Gd + m/9/m5r/fpuY/3yal/98mZf/e5mX/3qYlf92lZL/a4yJ/12Cfv9LdHD/Qm1o/052cv9qjIn/iaSi/5iw + r/+YsK//lKyr/5Gqqf+Qqaj/j6in/4ynpf+KpaP/h6Oh/4Whn/+Cnpz/f5ya/3uZl/94lpT/dJOR/3CQ + jf9qjIn/Z4mF/2GFgf9NdnL/S3Nv/4mlov+jurj/nbSz/5yzsv+cs7H/l6+v/yphi/8QToP/EU6D/ylg + if+Pqaj/kaqo/46opv+Mp6X/iqWj/4mkov+Bnpz/aouI/2iJhv9denfsBggHlgAAAH8AAABbAAAAMQAA + ABEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIF+fJqSkI//pKGf/+aRc///yLT//vDp//7r + 4v/+6+L//uvi//7r4v/+6+L//uvi//7r4v/+6+L//uvi///x6f/3wa7/lH51/9nb3P/9/f3/+Pf3//j4 + +P/4+Pj/+Pj4//j4+P/4+Pj/+Pj4//n5+f/6+vr/pqKh/1hxbf9FcGz/cpKS/4Wgo/+CnqD/gp6g/4Of + of+Dn6H/hJ+h/4Sgof+EoKL/haGi/4aho/+GoqP/hqKj/4ijpP+Jo6X/iaSm/4qkpv+Kpqb/jqip/36b + m/9lh4T/dpWS/4ympP+KpaP/iKSh/4eioP+GoZ7/hKCe/4Ofnf+Bnpv/gJ2b/3+bmf99mpj/fJmX/3uY + lv97mJb/epiV/3OSkP9ihYH/TnZy/0JsaP9HcG3/YYSC/4Sgnv+Wrq3/la6s/5Gqqf+PqKf/jaem/4ul + pP+Io6L/haGf/4Ofnf9/nJr/fJqX/3iXlP90lJH/cJCO/2yNiv9niYb/YoaD/1p/e/9Fb2v/TXVx/4+q + qP+iuLb/nLSy/5yzsf+bs7H/P26Q/w9LgP8UToH/HVSE/4aipv+TrKj/j6im/42npf+LpaP/iaSi/4ij + of93lZP/Z4mG/2mKh/82RkW/AAAAiwAAAG4AAABDAAAAHQAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAg4B+PoiFg/6Zm5z/u5aJ//2ffv/+6N7//u7n//7s5P/+7OT//uzk//7s5P/+7OT//uzk//7s + 4//+7+f//+XZ/86Qe/+Yl5b/+vr7//38/P/7+/v/+/v7//v7+//7+/v/+/v7//v7+//7+/v//v7+/+bk + 5P9/gX//R25q/1+Dgv+GoaP/gp6g/4OfoP+En6H/hKCh/4Sgov+FoaL/haGj/4aio/+HoqT/h6Kk/4ij + pf+JpKX/iaSl/4qlp/+Lpaf/jKen/42nqP+Qqav/e5mX/2SGgv99mZf/kaqp/42npv+MpqT/iqWj/4mk + of+Io6H/hqKg/4Whnv+En57/gp6c/4Gemv9/nJr/fpuZ/32al/97mJb/e5iW/3qYlf92lJL/aYqI/1V7 + d/9Dbmn/RW9r/2GEgf+GoZ//la2s/5Grqf+NqKb/i6ak/4ikov+GoqD/g5+d/4Cdm/99mpj/eZeV/3WU + kv9xkY7/bI6L/2iKh/9ihoL/XYJ+/1F4df9DbWn/WH56/5mxr/+ftbT/m7Ox/6G3s/9TfJf/Dkh+/xZN + gP8ZT4H/d5ag/5Wuqv+Pqaf/jael/4ulo/+JpKL/h6Kg/4Ofnf9sjYr/aImG/117eO0GCAeVAAAAfAAA + AFYAAAAsAAAADgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEgX8Dg4B+xZKPjv+bmpr/2o5z//+3 + nf/+7+n//uzl//7r4//+6+P//uvj//7r4//+6+P//u3l///v5//6spn/l3pv/8rNzv///////f39//39 + /f/9/f3//f39//39/f/9/f3//f39//7+/v//////trGw/2Jzb/9Ic2//e5ma/4Who/+EoKH/hKCi/4Wh + ov+FoaP/hqKj/4aipP+IoqT/iKOk/4ijpf+JpKX/i6Wm/4qlpv+Lpqf/jaeo/42nqP+OqKn/j6iq/5Gr + q/95lpX/ZYeE/4OfnP+Urav/kKqo/4+pp/+OqKb/jael/4umpP+KpKP/iKOh/4eiof+Gop//hKCd/4Of + nf+Bnpv/gJ2a/3+bmv99mpj/e5mX/3qYlf97mJb/eJeU/2yNiv9WfHj/Q21p/0dxbf9niYb/iaSj/5Kr + qv+Mp6X/iaSi/4aioP+DoJ7/gJ2b/32amP95mJX/dZWS/3GRj/9tjov/aIqH/2OGg/9dgX7/Vnx4/012 + cv9CbGj/aYuI/6C3tf+ctLL/orez/2aJnP8TSX7/GEx//xZLfv9oipr/l6+r/46pp/+Np6X/i6ak/4ik + ov+HoqD/hqKg/3iWk/9niYb/aYqH/zFAP7kAAACHAAAAZwAAADsAAAAXAAAABAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACDgH5Oh4SC/5OUkv+jlI7/7I9w///Drf//7ub//u/p//7s5f/+6+T//uzl//7v + 6f//7eX//8Kq/8mDa/+UlJT/8vLy//f39//29vb/9vb2//b29v/29vb/9vb2//b29v/29vb//Pz8/+Lf + 3/+Dg4D/SW5p/12CgP+Ho6T/haCi/4Who/+GoaP/hqKj/4eipP+Io6T/iaOk/4mkpf+KpKb/i6am/4um + p/+Mpqf/jaao/46pqv+PqKn/kKqq/5GqrP+Sq6z/k6yt/3WUkv9niIX/iaSi/5ewrv+Urav/k6yq/5Gr + qf+Qqqj/jqmn/42npf+Mp6T/i6Wj/4mkov+Io6D/h6Kg/4Whn/+EoJ7/g5+d/4Gdm/9/nJr/fZuY/3yZ + l/97mZb/e5iW/3qXlf9sjYr/U3l2/0Ntaf9NdXH/dJOR/4ylpP+Mp6b/h6Oh/4Sgnv+BnZv/fZuY/3qY + lv92lZL/cpKP/22Oi/9oiof/ZIeD/12Bfv9WfHj/U3p2/0pzbv9Fb2v/gZ6b/6G3tv+gtrP/dpai/xpM + fv8ZS37/FEZ7/1t/lf+Zsaz/j6mn/42npf+MpqT/iaSi/4aioP+FoZ//gJ2b/2uLif9oiYb/VG5s4AAA + AI4AAABzAAAASAAAAB8AAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCf31/iIWC/4+P + j/+cj4r/zY95//yqjf//ybX//+PZ///o4P//4tf//8iy//qpjP/Ch3L/komF/9TV1f/t7Oz/6unp/+rp + 6f/q6en/6unp/+rp6f/q6en/6ejo/+7t7f/d3Nv/jY6N/2qBf/9Yf3v/dJST/4mkpv+HoqT/h6Kl/4ik + pf+JpKb/i6Wm/4qlpv+Lpqf/jKan/42nqP+Op6n/j6ip/4+pqv+Qqqr/kqus/5OsrP+UrK3/la2u/5av + r/+Wrq//cZGO/2iKh/+Rqqn/nLOx/5ixr/+XsK7/lq+t/5SurP+TrKv/kqyp/5GqqP+Pqaf/jqim/42n + pf+LpqT/iqWj/4mkof+Ho6H/hqGf/4Sgnv+Cn53/gZ2b/4Cdmv9+m5n/fZqY/36amP96mJb/b4+N/1yB + ff9HcGz/Unl1/22Ni/+GoqD/hqGg/4Gdm/99m5j/epiW/3aVkv9yko//bY6L/2iKh/9kh4P/XoJ+/1V8 + eP9Tenb/U3l1/0hxbf9NdXH/i6ak/6G3tf+Lpqr/IU9//xtJfP8VRHn/TnOP/5avq/+Qqaf/jqim/4ym + pP+KpKL/h6Oh/4Wgn/+EoJ7/dZSS/2iJhv9niIX9Iy8uqwAAAHkAAABQAAAAJQAAAAoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDgH6vh4SC/4uLi/+Ki4v/q4l8/9qMcf/0mXn/+KCD//SY + d//ZjXH/o4V5/36AgP/Cw8L/5+bl/+Dg3//h4N//4eDf/+Hg3//h4N//4eDf/+Dg3//k4+L/3Nva/5SS + kv+jlYb/eJKK/2iKiP+AnZ3/iaSm/4mkpf+Kpab/i6am/4ump/+Mp6j/jaeo/46oqf+Pqan/j6mq/5Cq + q/+Rq6z/kqut/5Osrf+Urq3/lq+v/5evr/+YsLD/mrGx/5iwsP9vj4z/aouI/5iwrv+ftrT/nLSy/5uz + sf+asrD/mLGv/5evrv+Wrq3/la2s/5Osqv+Sq6r/kaqo/4+pp/+OqKb/jaek/4umpP+KpaP/iKOh/4ei + oP+FoZ//hKCd/4Kenf+BnZv/gJ2Z/36bmf9/nJn/f5uZ/2+Pjf9Pd3P/QWxn/1l+e/99mpn/hKCe/32b + mP95mJX/dpWS/3KSj/9tjov/aIqH/2SHg/9dgn7/VXx4/1N6dv9Uenb/UXh0/0Ntaf9egoD/nrSy/5av + rv8vWIL/G0d5/xlEeP9DaYn/k6yp/5Cqp/+OqKb/jKak/4qkov+Io6H/haCf/4Ognf99m5j/aYqH/2mK + h/9EWVfLAAAAfQAAAFYAAAAoAAAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAISB + fxGEgX/NhoOB/4qHhv+GiIj/iYiG/5WHgf+eh37/lYiC/4SDgv9/gID/t7Wz/+De3v/b2tn/29rZ/9va + 2f/b2tn/29rZ/9va2f/c29r/4N7d/9TT0/+Sk5T/qpWG///Ppv+uqJT/X4WF/4Cdnf+Mp6f/i6Wn/4ym + p/+Np6j/jqeo/46oqf+Pqqr/kKmq/5Grq/+Sq6z/k6yt/5Strv+Vra7/la6v/5evsP+YsLH/mbGx/5uy + sv+ctLT/mbGx/2uMif9sjIn/nrW0/6G3tv+ftrX/nrW0/520s/+cs7H/mrKx/5mxsP+YsK7/l6+t/5Wu + rP+Urav/k6yq/5Grqf+Qqqj/j6mn/42npf+LpqT/iqWj/4mkov+HoqD/hqGg/4Whnv+Dn53/gp6c/4Cd + mv9/nJr/gJya/3uYlv9dgn7/Q21p/011cf9zk5D/gJ2b/3mYlf91lZL/cZGP/22Oi/9oiof/Y4aD/12B + fv9Ue3f/U3p2/1N6dv9Ue3f/S3Nv/0dwbP+IpKH/nLSy/z5ih/8aRHf/G0R3/z5jhv+Sq6n/kKqn/46o + pv+MpqT/iqSi/4ijof+FoJ//g5+d/4Gem/9tjYv/aIqG/01mZNYAAAB/AAAAWQAAACoAAAANAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAISBfx2DgH+4hIF//4SCgf+Eg4L/hIOC/4KD + gv+CgYD/joyK/768u//c29r/2dfW/9jX1v/Y19b/2NfW/9jX1v/Z19b/2NbV/9PR0f+2tbb/i4uK/7Ga + if/7yqP//9Go/7Wrlv9chIP/fZua/4+pqv+NqKj/jqip/4+oqv+Qqqv/kaqr/5Krq/+TrK3/lKyt/5Wt + rv+Wrq7/l6+v/5iwsP+YsbH/mrKy/5uzs/+dtLT/nrW1/6C3t/+dtLT/a4yJ/2yMif+huLX/pbq5/6K5 + t/+ht7b/oLe1/562tP+etbP/nLSy/5uzsf+asrD/mbGv/5ewrv+Wr63/la2s/5Stq/+SrKn/kaqo/4+p + p/+OqKb/jKak/4ulo/+KpaP/iKOh/4eioP+FoZ//hKCe/4Ofnf+BnZv/gZ2b/4Gdm/9pi4j/SHFt/0hx + bf9qjIn/e5mX/3WUkv9xkY7/bI6L/2iKh/9jhoP/XYF9/1R7d/9Tenb/U3p2/1R6dv9QeHT/Q21p/2mL + h/+gtrT/SmuL/xtCdv8eRHX/Nlh//5Cppv+Rqqj/jqim/4ympP+KpKL/iKOh/4Wgn/+Dn5z/gp6c/3KR + jv9oiYb/VG9t3wAAAIAAAABbAAAALAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAIGAfwR7fX1wiYF+54WBf/+BgH//f35+/4CAf/+Xlpb/o6Ki/5+env+enp7/np6e/56e + nv+enp7/np6d/5+env+dm5r/ko6M/52PhP/UsJT//8yl///Mpf//0Kf/s6uW/1yDg/94lpT/kKqr/5Cp + qv+Rqqv/kaur/5Orrf+Ura3/la2u/5Wurv+Wr6//mLCw/5mwsf+asrL/m7Ky/5yzs/+dtLT/n7a2/6C3 + tv+huLj/pLm5/6C3tv9sjIn/bIyJ/6S6uP+ovbv/pbu5/6S6uf+jubj/ori3/6G3tv+ftrX/nrW0/520 + s/+cs7L/m7Kx/5mxsP+YsK//l6+t/5aurf+Urav/kqyq/5GqqP+Pqqf/jqin/42npf+MpqT/iqWi/4mk + ov+Io6H/hqKg/4Wgn/+Dn53/gp+c/4Sgnf9oiob/SHFt/0Vuav9jhoP/dpWT/3CQjv9rjYr/Z4mG/2KG + gv9cgH3/VHt3/1N6dv9Tenb/U3p2/1N6dv9Icm7/T3Zz/5qyrf9Zd5D/Gjxv/yBAcf80W4f/hqux/5St + qf+OqKb/jKak/4qkov+Ho6H/hKCf/4OfnP+Cnpz/dZSR/2iJhv9ZdHLlAAAAgQAAAFwAAAAsAAAADQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfpn3/R4KGE/9Ge + hP/MnYb/zZ+H/8qehv/JnYX/yZ+H/8mgiP/Joon/yaKK/8qji//KpIz/yaSN/86pkP/nuZn//cii///O + pf//zKX//8yl///RqP+9r5j/YIaE/26OjP+Qqar/k6yt/5Ssrf+Vra3/la6v/5evr/+Xr7D/mLCx/5my + sv+asrL/nLOz/520tP+etbX/n7a2/6G3t/+iuLj/o7q5/6W6uv+nvLz/pLm5/2yMif9sjIn/pry7/6q/ + vv+ovbz/p7y7/6a8uv+lurn/pLq4/6K4t/+iuLf/oLe1/5+2tP+dtbP/nbSy/5uzsf+asrD/mbGv/5iv + rv+Vrq3/lK2r/5Osq/+Sq6n/kaqo/4+pp/+OqKb/jael/4ulpP+KpKL/iKOi/4ejoP+HoqD/fZqX/2qL + iP9lh4X/UXh0/0Ntaf9ghIH/cZGP/2uMif9miYX/YYSB/1uAfP9Tenb/U3p2/1N6dv9Tenb/VHt3/011 + cf9Fb2v/iaWd/2aIn/8fVZD/J2mj/ydsqP8yZ5n/d5Kb/5Grp/+MpqT/iqSi/4ejof+EoJ//g5+d/4Ke + m/93lpP/aIqH/1x5duoAAACBAAAAXAAAACwAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA0oxsM/2pg/n/rof//7GK//+0jP//t4///7mS//+8lP//vpb//8CY///C + mv//xJz//8ad///Hn///yaD//8ui///Lo///y6P//8ul///Mpf//zab//9Go/8u2nP9liIb/Z4mG/4ei + ov+Xr7D/lq6w/5evsP+ZsbD/mbGx/5uysv+bs7P/nLS0/561tf+ftrX/oLe3/6K4t/+iuLj/pbq6/6a8 + u/+nvLz/qL69/6u/v/+nvLz/bIyJ/2yMif+ovrz/rcHA/6vAv/+qvr3/qb68/6i9vP+nvLr/pbu6/6S6 + uf+jubj/ori3/6G3tv+gt7X/n7a0/521s/+ctLL/m7Kw/5mxr/+Yr67/l6+t/5WurP+Urav/k6yq/5Gr + qf+Qqqj/j6im/42opf+MpqX/i6ak/4mkov9wkI3/ZoeE/3iWlf9/nJ3/Unl1/0Ntaf9dgn7/bI2K/2WI + hf9ghID/Wn97/1N6dv9Tenb/U3p2/1N6dv9Tenb/UXh0/0duZ/9Xi5j/O4G4/yZel/8mUIP/JUR0/xs5 + a/9bd43/lK+p/4ympP+JpKL/hqKg/4Whn/+Dnp3/gZ2b/3iWlP9piof/Xnt57QAAAIAAAABaAAAAKwAA + AA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHnnHpy+6uF//yu + iP/8sIv//LON//21j//9t5L//bqU//28lv/9vpj//sCZ//7BnP/+xJ3//sWf//7GoP/+yKL//8qj///L + pP//zKX//82m///Op///0aj/276f/2qKh/9lh4T/dpSS/5mxsf+ZsbH/mrKy/5yzs/+cs7T/nbW1/5+2 + tv+gt7b/obe4/6K5uP+kurn/pbq6/6a8u/+nvbz/qr++/6u/v/+swcD/rsLB/6m+vf9sjIn/bIyJ/6i9 + vP+uwsH/rcHA/63BwP+swL//qr++/6m+vf+ovbz/p7y7/6a8uv+lurr/pLm5/6O5uP+huLf/obe2/5+2 + tf+dtbP/nbSy/5uysf+ZsrD/mbGv/5ewrv+Wrq3/la2s/5Osq/+Sq6n/kaqp/4+pp/+Qqqj/fpuZ/2aI + hP9sjIr/hJ+g/4ijpf9+mpz/UXh1/0Ruav9cgH3/ZYiF/16DgP9YfXr/U3p2/1N6dv9Tenb/U3p2/1N6 + dv9Tenb/THJq/zVxj/8gRn3/JEFw/yNEc/8iRXX/HkN1/2WBk/+Traj/i6ak/4mkov+HoqD/haGf/4Of + nf+BnZv/eJaT/2mKh/9de3jsAAAAfgAAAFcAAAApAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAu+if6v8rYf//K+K//yyjP/8tI7//beR//25k//9u5X//b6X//3A + mf/+wZv//sOd//7Env/+xqD//seh//7Jo///y6T//8yl///Mpv//zqf//86n///Qqf/wyKX/cI2J/2aI + hv9niYb/jKam/5+2tv+dtLT/nra2/6C3tv+huLf/ori4/6S5uf+lu7r/pru7/6e9vP+pvb3/qr++/6zA + v/+twsD/rcHA/63BwP+twcD/p728/2yMif9sjIn/pLq5/6u/vv+rwL//rcHA/63BwP+swcD/rMHA/6u/ + vv+qv77/qb68/6i9vP+nvbv/pru6/6S6uf+kurj/orm3/6G3tv+gtrX/nrWz/520s/+bs7L/m7Kw/5mx + sP+YsK//l6+t/5WurP+Urav/lK2r/4ynpf9sjIn/ZoiF/3yZmf+JpKX/haGj/4eipf98mZr/TnZy/0Zv + a/9bgHz/XoN//1d9eP9Tenb/U3p2/1N6dv9Tenb/U3p2/1N6dv9NdGz/N2uH/x9Jfv8gR3j/H0h5/x5J + ev8aRnn/ZYGT/5Osp/+LpaP/iaSi/4ein/+FoJ7/gp+d/4Gdm/92lJL/aImG/1p3dOcAAAB8AAAAUwAA + ACYAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACJXUkL96iD3Pyu + iP/8sYv//LON//22kP/9uJL//bqV//29l//9v5j//sGa//7DnP/+xJ7//sWf//7Hof/+yaL//8qj///M + pf//zab//82n///Op///z6j//9Cp//3OqP+Hl43/aIuK/2qMif9xkY7/nrW0/6K4uP+iuLj/o7m5/6W6 + uv+mvLv/p728/6i+vf+qvr7/q8C//6zBwP+twcD/rcHA/63BwP+rwL//qr++/6vAvv+lu7r/bIyJ/2qL + iP+etbX/pru7/6a8u/+pvb3/qr++/6zAv/+twcD/rcHA/63BwP+swL//q8C+/6m+vf+ovbz/p7y8/6a8 + uv+lu7n/pLq4/6O5t/+ht7b/oLa1/5+2tP+etbP/nbSy/5uzsf+asrD/mLGv/5ewrv+XsK7/eJaT/2WG + g/9ykY//iqWm/4mkpf+HoqT/haGj/4iipP93lpb/SnJu/0lxbf9Zf3v/Vn15/1N6dv9Tenb/U3p2/1N6 + dv9Tenb/U3p2/051bv84aoL/G0yC/xlMfv8YTYD/Fk+C/xBKgP9jgZL/k6yn/4ulo/+JpKL/hqGg/4Og + nf+Cnpz/gZ2b/3OSkP9oiYb/V3Jw4gAAAHkAAABQAAAAJAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAM+Nbif7rIb3/K+K//yyjP/8tI///beR//25k//9vJb//b6Y//7A + mf/+wpv//sSd//7Fn//+xqD//sih//7Jo///y6T//8ym///Npv//zqf//8+o///PqP//z6j//9Kq/6em + lP9kion/f5ya/2WGg/+Dn53/p728/6a7u/+nvLv/qL29/6m/vv+rwL//rMHA/63BwP+twcD/rcHA/6zB + wP+rwL//qr++/6m+vf+ovr3/qL68/6S6uf9ykY7/aYqH/5evrv+juLn/ori4/6S6uf+mu7v/qL28/6m+ + vf+rv7//rMHA/63BwP+twcD/rMDA/6vAvv+qv77/qb69/6i9vP+nvLr/pru5/6S6uf+iubj/ori3/6G3 + tv+ftrX/nrW0/520s/+cs7L/nrWz/4aioP9miIX/aoqI/4aiov+Np6j/iqSm/4ijpP+HoqP/haGi/4ii + pP9uj47/Rm9r/0tzb/9Ue3f/U3p2/1N6dv9Tenb/U3p2/1N6dv9Tenb/TnVu/ztug/8VUYj/DlSJ/wxX + i/8IUoj/GVGD/3aRmv+Qqqb/iqWj/4ijof+GoqD/hKCe/4KenP+AnJr/b4+M/2iJhv9QamfYAAAAeAAA + AE4AAAAjAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6J98WPyt + iP/8sYv//LOO//21kP/9uJL//buV//29l//9v5n//sGb//7DnP/+xZ7//sag//7Iof/+yaL//8qk///M + pf//zab//86n///OqP//z6j//8+o///PqP//06r/ybac/2KGhP+IpKP/e5mX/2SHg/+TrKv/rsHB/6q/ + v/+swb//rcHA/63CwP+twcD/rMDA/6zAv/+qv77/qb++/6m+vf+ovbz/pry7/6a8uv+lu7r/o7m3/3ST + kf9oiYb/kKqp/6C2tv+ftbb/oLe3/6K4uP+jubn/pbu6/6e8u/+ovb3/qr6+/6zAv/+twcD/rcHA/6zB + wP+swL//q8C//6m+vf+ovbz/p7y7/6a8uv+lurn/pLm4/6K4uP+iuLf/oLa1/6G4tv+Vrqz/bIyJ/2WH + hP9+m5v/kaqr/42nqP+Lpqf/iqSm/4ijpP+GoaP/haGj/4eipP9jhoX/RG5p/051cf9Uenb/U3p2/1N6 + dv9Tenb/U3p2/1N6dv9PdW7/Pm9+/xBXjP8JV43/EEyB/zhhhv97lp3/kKqn/4ympP+KpaP/iKOh/4ah + n/+DoJ3/gp6c/32amP9qi4f/aYqH/0dcXs0AAAB4AAAATwAAACMAAAAJAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADupIGA/K+J//yyjP/8tI///beR//25lP/9u5b//b6Y//7A + mv/+wpz//sSd//7Fnv/+x6D//sii///Jo///y6T//8yl///Op///zqf//8+o///PqP//z6j//8+o///R + qf/xyab/cY2I/3eXlf+cs7P/bY6K/2qLiP+gt7X/sMTD/63BwP+twcD/q8C//6q/vv+qv77/qb69/6i+ + vP+nvbz/pry7/6W7uv+kurn/o7q4/6O4t/+ht7f/eJeU/2aHhP+KpKT/nLOz/5uzs/+dtLT/nrW1/5+2 + tv+ht7f/ori4/6S6uf+mu7v/p7y8/6i+vf+rv77/rMDA/63BwP+twcD/rMHA/6u/vv+qvr3/qb69/6i9 + vP+nvLr/pbu6/6S6uf+lurn/oLa1/3STkf9khoL/dZSS/5KsrP+Rq6v/jqip/42mqP+Lpaf/iaSl/4ej + pf+GoqT/hqGj/4Ofof9Uenf/R3Bs/1N6dv9Tenb/U3p2/1N6dv9Tenb/U3p2/011cP9DbG3/HE59/xxJ + fP8dQXT/aIOU/5qzrP+NqKb/jKak/4qkov+HoqD/haCf/4Kfnf+Cnpz/dZSR/2iJh/9piob/OmI0yAAA + AHkAAABQAAAAJAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfOn + g6L8sIv//LOO//22kP/9uJH//buV//29l//9v5n//sGb//7DnP/+xZ7//sag//7Hof/+yaL//8uk///L + pf//zab//86n///PqP//z6j//8+o///PqP//z6n//9Gp///UsP+eoZX/Y4iH/560tP+Xr67/Z4iF/3CQ + jf+kurn/rcLB/6q+vf+pvr3/qL29/6e9vP+nvLv/pry6/6W7uv+kurn/o7m4/6G4tv+ht7b/oLe1/6G3 + tv98mpf/ZIaD/4Ofnv+ZsbL/l7Cw/5mxsf+asrL/nLOz/520tP+ftrb/oLa2/6K4t/+jubn/pLq6/6a8 + u/+nvbz/qr6+/6zAv/+twcD/rcHA/63BwP+rwL//qr++/6m/vf+ovbz/qL28/6i9vP9/nJr/ZIaD/26O + i/+Rq6v/la6v/5KrrP+Qqav/jqip/4ynp/+Kpab/iaSl/4eipP+GoaL/iKKl/3eVlv9Icm7/Tndy/1R6 + dv9Tenb/U3p2/1N6dv9Tenb/TXVv/zxpcf8YT4H/Gkp9/yJJev98mJ//kqyo/42npf+LpaP/iaSi/4ei + n/+FoJ//g5+d/3+cmf9sjIn/aoiL/2aPdP80dwvNAAAAegAAAFIAAAAlAAAACgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+WEUC9aqFwPyxjP/8tI///beR//24k//9vJb//b6Y//7A + mf/+wpz//sOd//7Fn//+x6D//smi///Ko///y6T//8ym///Op///zqf//8+o///PqP//z6j//8+o///Q + qv//07L/1MB9/3CYR/9hhYP/iKOi/67Cwf+Qqqj/Y4aC/3OSkP+hubf/qr++/6a8uv+murv/pbu5/6S6 + uf+jurj/ori3/6G4tv+gt7X/nra0/561s/+dtLL/n7a0/4Gem/9jhYL/fZqZ/5aur/+Vra7/la6v/5ev + r/+YsLH/mbGy/5uys/+cs7T/nrW1/5+2tv+ht7f/ori4/6O5uf+lu7v/pry8/6m9vf+rwL//rcHA/63B + wP+twcD/rMHA/6vAvv+twcD/iaSj/2WHg/9piof/j6io/5uys/+Vrq//la2t/5KrrP+Qqar/jqip/4ym + qP+Kpab/iKSl/4eio/+GoaP/iKOl/2GFg/9GcGz/U3l1/1N6dv9Tenb/U3p2/1N6dv9NdW3/M2R2/xVM + gv8YR3v/NFqC/46opv+Pqaf/jKel/4qlo/+JpKL/hqKg/4Sgnv+DoJ3/dZOR/2iJhv9qiI7/TKJP/zR7 + CM8AAAB7AAAAUwAAACYAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMSI + agn4rYjX/LON//21kP/9t5L//bqU//28l//9v5n//sGb//7Dnf/+xJ7//sag//7Iof/+yaL//8uk///M + pf//zab//86n///PqP//z6j//8+o///PqP//0Kr//9Oy/7+5bv9NnQP/R6oS/2SRff9yj5D/pru6/6/D + wv+PqKb/Y4WC/3KSj/+ftrX/p7y7/6O5uP+iubf/ori2/6G3tf+gtrT/nraz/521sv+cs7L/m7Kx/5qy + sP+cs7L/haGe/2SHg/92lZP/kaqr/5Grq/+SrKz/k62t/5Wurv+Wr6//l6+w/5mxsf+asrL/m7Oz/520 + s/+etbX/oLe2/6G4t/+iuLj/pbq6/6e8u/+pvb3/qr++/6zAv/+twcD/scTD/5Kqqf9miIX/ZoiF/4ql + pP+htrb/mrKy/5iwsP+Wrq//lKyt/5GrrP+Qqar/jaip/4ymp/+KpKb/iKOl/4ejpP+Io6X/dZWV/0Zw + bP9OdXH/VHp2/1N6dv9Tenb/Unl1/0tzbP8pXnr/FEyD/xVFev9YeZH/lq+q/46opv+MpqT/iqWj/4ij + of+GoqD/haGf/3uZl/9piof/boeJ/1OUgf8auj//N4EL1QAAAHwAAABVAAAAJwAAAAsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3Jp6EPuwiu/8tI7//baR//24kv/9u5X//b2Y//6/ + mv/+wpv//sSd//7Fn//+x6D//smi///Ko///y6T//8ym///Np///zqj//8+o///PqP//z6j//9Cq///T + s/+/u27/S6QG/0u7K/9Z3Hj/Y7mO/2aDhP+Rqqj/scTD/7DEw/+Np6X/ZIWC/3KRjv+asrD/o7q4/6C2 + tf+ftbT/nrSz/520sv+bs7L/mrKx/5mxr/+YsK7/l6+u/5iwrv+JpKL/Z4mF/3CPjf+Np6j/j6ip/4+p + qf+Rq6v/kqus/5Osrf+Ura7/la6u/5avr/+Yr7H/mbGy/5qys/+ctLP/nbS1/5+2tf+gt7f/o7i4/6S6 + uf+lu7r/qL28/63Bwf+Urav/aImG/2SGg/+HoqH/pbq7/6C3t/+ctLT/mrKy/5ewsP+Vrq7/k6yt/5Kq + q/+Pqan/jaeo/4ump/+Kpab/iKOk/4ijpP+DnqD/UHdz/0dxbP9TeXb/U3p2/1R6dv9ReHP/R3Ft/x5X + gP8US4H/IE5+/4Gdov+Sq6j/jael/4ylo/+KpKL/h6Kh/4ain/+AnZr/a4yJ/2qIh/9qiYf/GbNi/w7A + Pv85gw3XAAAAfQAAAFYAAAAoAAAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADmon8j+7GL9vy0j//9t5H//bmT//28lv/9vpj//sGa//7DnP/+xJ7//saf//7Iof/+yaL//8qk///M + pf//zab//86n///PqP//z6j//8+o///Qqv//0rL/vrtu/0unB/9NxEP/Wt+Q/1/lmP9i2pT/ZpCG/3SQ + j/+qv77/rsPC/63BwP+MpqX/ZIaD/22Oiv+Sq6n/oLe1/5yzsv+bsrH/mrGw/5mwr/+Yr67/lq+t/5au + rP+Vraz/lK2r/42npf9qioj/aouI/4mjpP+Mpqj/jaeo/46oqP+Oqan/kKqq/5Gqq/+Tq6z/k62t/5Su + rv+Wr6//l7Cw/5iwsf+asrL/m7Kz/5y0tP+ftbb/oLa3/6K4uP+nvLz/kKmo/2iJhv9khoP/hqGg/6m9 + vf+lu7r/obi3/5+2tv+ds7T/mrGy/5evsP+Wrq7/k6yt/5Gqq/+Pqar/jaeo/4umpv+JpKb/iKOk/4qk + pv9pi4r/RG5q/093c/9Uenb/VHp2/092cP89a3H/FFGE/xBIf/9KcY7/la6q/4+opv+Mp6X/i6Wj/4mk + ov+Io6H/gZ6b/26Oi/9piIb/b4eK/zOmbP8AxVD/Db9F/zqID9sAAAB/AAAAWAAAACkAAAAMAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOymgy/7sYz5/bWP//24kv/9upT//b2X//2/ + mf/+wZv//sOd//7Fn//+x6D//sii///Ko///y6T//8ym///Npv//zqf//8+o///PqP//0Kr//9Cv/7O5 + Y/9Lqgr/TcdM/1ngk/9d4ZT/YeGT/2XomP9ou5H/ZYKD/42npf+vw8L/qr++/6q/vv+Mp6X/Z4iF/2mK + h/+JpKL/m7Kx/5mxr/+XsK3/la6s/5WtrP+TrKr/k6uq/5Kqqf+Rqqj/jqim/26Oi/9piYb/gp6e/4ul + p/+Kpqf/i6Wn/42mp/+Op6n/j6eo/4+pq/+Qqqv/kqur/5Osrf+Ura3/la6u/5avr/+XsLD/mbGx/5uz + s/+dtLT/oLe3/4qko/9oiYb/ZIaD/4eiof+vw8L/q7+//6e8u/+jubn/obe3/5+1tf+btLP/mbGx/5ev + r/+Vra7/kqys/5Cqqv+OqKn/jKao/4ulp/+JpKb/iaSm/3+cnv9LdHD/SnJu/1N6dv9Tenb/TXRt/yxi + ef8MTYX/IVWE/4OfpP+TrKj/jqel/4ympP+LpaP/iqSi/3+bmf9sjIn/aImG/3CGi/9An3L/AMNQ/wDD + Uv8JwEr/O40Q3wAAAH8AAABZAAAAKwAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA8KqFP/yzjfz9tpD//biT//27lf/9vpj//sCa//7Cm//+xJ7//saf//7Hof/+yaL//8qj///M + pf//zab//86n///OqP//z6j//9Cq///QsP+ut17/RqkF/03JUv9Y4JT/W+CS/1/gk/9j4pb/Z+WZ/2vi + m/9omYn/bYmJ/6G4tv+rv77/p7y7/6e8u/+Rq6n/a4yJ/2WHhP9/nJn/la6s/5aurP+TrKr/kqup/5Cq + qP+Qqaf/j6im/46opv+Np6X/dJOR/2aHhP96mJf/iaSm/4ijpP+JpKb/iqWm/4ump/+Mpqf/jaep/46n + qP+PqKr/kKmq/5Gqq/+SrKz/lKyt/5Strf+Wrq//mLGx/5qxsv+Cnpz/ZoeF/2WHg/+GoZ//rsHA/67C + wf+twb//qr+9/6a8vP+juLr/oLi3/561tf+ctLP/mbGx/5avr/+Tra3/k6us/5Cpq/+OqKn/jKen/4ul + p/+JpKX/iaSm/16CgP9Fbmr/Unl1/1J5dP9HcW3/GFiC/wxNhP9lipv/l6+q/4+opv+Np6X/jael/4ik + ov95l5T/aYqH/2qJh/9uiIn/P6Bx/wLBUf8Aw1D/AMJS/wTBTf87kRHiAAAAgAAAAFsAAAArAAAADQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADyrIdM/LSO//23kf/9uZP//byW//2+ + mP/+wZr//sOc//7Fnv/+xqD//sih//7Jo///y6T//8yl///Npv//zqf//8+o///Qqf//0LD/rrdd/0ap + Bf9MyFH/Vd+S/1rfkP9e4JH/YuGV/2bjl/9p5Jr/buqe/2/LmP9mhoX/e5eW/6m+vf+mvLr/pLq4/6S6 + uf+Wrqz/cpGO/2SGg/90k5D/jael/5Krqf+Oqab/jaim/42npf+LpqT/iqWj/4ulo/96l5X/ZYeE/3SS + kf+GoqP/hqKj/4ejpP+HoqT/iKSk/4mlpf+KpKf/jKWn/4ynp/+Np6f/jqiq/4+pqv+Qqqr/kaqr/5St + rv+Sq6z/eZaV/2SHhP9niIX/iaSi/6q/vv+rv77/rMC//63BwP+swcD/qb6+/6a6u/+jubn/oLe2/560 + tP+asrP/mbGx/5aur/+Ura3/k6ur/5Cpqv+Op6n/jKao/4qlpv+Lpaf/cpGR/0Zwa/9OdnL/T3Zv/zNo + dv8FTof/S3qV/5auqv+Rqqj/kKmn/42npf+BnZv/cI+M/2eJhf9niIj/Z4qJ/zOna/8AxE//AMNQ/wDC + Uf8AwlL/A8FO/ziWFuYAAACBAAAAXAAAACwAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPKsiEr8tY///biS//26lP/9vJf//b+Z//7Bm//+w53//sWf//7HoP/+yKL//8qj///L + pP//zKb//86n///Op///z6j//9Cu/6+3Xv9HqQX/S8hQ/1PekP9Y3o//XN+Q/2Dhk/9k4pb/aOOY/2zk + nP9w5p//dOqh/2inff9lgYH/i6ak/6m+vf+jubj/oLe1/6C2tf+YsK//e5iW/2WHhP9sjIn/g5+d/42n + pf+KpaP/iqSi/4ijof+GoqD/h6Kg/36bmP9oiYb/bY2L/4Ofof+FoKL/haGi/4Who/+HoaP/hqKk/4mj + pP+JpKX/iqSm/4ulpv+Lp6f/jaan/46oqf+Qqqv/jKen/3GRjv9khoP/a4uJ/46npv+nvbz/p7y7/6i9 + vP+qv73/rMC//63BwP+swL//qL28/6W7uf+iuLj/n7W2/521tP+bs7L/mLCw/5aur/+TrK3/kaur/4+p + qv+NqKj/i6an/4ulp/+Cnp//S3Nw/0lybf9IcW3/EFeD/ztzlv+UrKv/la6r/46opv+Cnpz/cpGP/2iJ + hv9liIb/Y4eJ/3uPgf9LqT//AMRL/wDDUf8AwlH/AMJR/wDCUv8CwU//NpoZ6AAAAIEAAABcAAAALAAA + AA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8q2ISv21j//9uJL//buV//29 + l//+wJn//sKc//7Enf/+xp///seg//7Jov//yqP//8yl///Npv//zqf//86n///Ss//Uwn//SakH/0nH + Tv9Q3Y7/Vd2N/1nej/9e4JL/YuGU/2bjl/9q5Jr/b+Wd/3PmoP9366X/cduL/2iVgf9phof/la6s/6W7 + uv+ftrX/nLSy/5uzsf+Zsa//g6Cd/2mLiP9piof/f5ya/4mjof+HoqD/haGf/4Sgnv+Dn53/gJ2a/2uL + if9piof/fpuc/4Sfof+Dn6H/hKCh/4Sgov+FoaP/h6Kj/4aio/+Ho6T/iKOl/4mkpf+Lpab/jaeo/4ah + ov9wkI7/ZIaD/3CQjf+TrKv/o7m5/6O5uP+lurn/p7y7/6m+vP+rv77/rMG//63BwP+rwL//qLy8/6W7 + u/+it7j/oLe3/520tP+bsrL/l7Cw/5Surv+UrK3/kqqr/4+pqv+Np6j/i6an/4mkpf9VfHj/R29o/yhl + fP9Be5z/kqup/42no/98mpf/b4+M/2iJhv9oiIj/aYmO/3eOjv+9npX/v6th/0O0Ff8Awk7/AMJS/wDC + Uf8AwlH/AMJS/wDCUf8yoR/tAAAAgAAAAFsAAAAsAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD5so1K/baQ//25kv/9u5X//b6Y//7Amv/+wpz//sSe//7Gn//+yKH//smi///L + pP//zKX//82m///Op///0bD/38SL/2atIv9FyE//Td2M/1Hci/9W3o3/W9+Q/1/hk/9k4pb/aOOZ/2zl + nP9x5p//deei/3jopP9+76v/e9ei/2iMh/9vjIv/mrKx/6G3tv+cs7H/mbGv/5evrf+Wr63/i6aj/3CQ + jP9miIX/dZSR/4GenP+Dn53/gZ6b/4Ccmv9/nJr/cJCN/2aIhP92lZT/hKCi/4Ofof+Dn6H/g5+h/4Og + of+En6L/haCi/4Whov+GoqT/iaOl/4eipP96l5f/aoqH/2aHhP96l5X/l6+t/5+3tf+ftrT/ore2/6S5 + uP+mu7n/qLy7/6m+vP+rv77/rMHA/63BwP+rv7//p728/6S6uv+huLf/nra2/52zs/+asbL/lq+w/5au + rv+TrK3/kaqr/46pqv+Np6n/iaOl/1l+ef81anP/Q3qQ/36al/9zko7/aYqH/2eIhv9qh4n/a4iM/2WJ + fP9hjFT/u6Rr/72oVv9eqxL/Hboz/wDDVP8AwlH/AMJR/wDCUf8AwlL/AMJR/zCiH+0AAAB/AAAAWQAA + ACoAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPSwizv9t5H8/bmT//28 + lf/9vpj//sGa//7DnP/+xZ7//seg//7Iof/+yqP//8uk///Mpf//zab//9Ct/+fGkv9gqBT/Qb4z/0rc + jP9P3In/U92L/1jejv9c4JH/YOGU/2Xjl/9q5Jr/buWd/3LnoP936KP/e+mm/37rqf+F8q7/fMqg/2WF + hP9zkI//m7Kw/520s/+YsK//la+s/5Osqv+Sq6n/iqWj/3GQjv9miIT/a4uJ/3iWk/9+m5j/fZqY/3yZ + l/9xkY7/Z4iF/2yNi/91lJT/eZeX/3+cnf+Dn6H/g5+h/4OfoP+EoKH/haCj/4Whov99mpr/bo6M/2aI + hP9miIX/e5mW/5iwrv+ZsrD/mrKx/560s/+gtrX/ori2/6O5uP+lu7r/qL27/6q+vf+rwL//rcHA/63B + wP+qv73/p727/6S5uf+ht7j/n7W1/5u0s/+ZsbH/l6+v/5Wtrv+SrKz/kKqr/4+pqv97mJb/W4KD/1F/ + if9sjIn/aImH/2mHi/9rh43/bImE/2GSc/9Zn0f/UZwU/0mOAP9QkgH/S6UE/yy3J/8BwlL/AMJS/wDC + Uf8AwlH/AMJR/wDCUv8BwlD/NJ0b6gAAAH0AAABWAAAAKAAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA97KNLP23kfj9uZT//byW//2/mf/+wZv//sOd//7Fn//+x6D//smi///K + o///y6T//8ym///Oqv/4zaT/dK8p/0C4JP9G13z/TNyI/1DciP9V3Yz/Wd+P/17gkv9i4pX/Z+OY/2vk + m/9w5p7/c+eh/3jppP996qf/geuq/4Xtrf+L9LL/fMGf/2SDg/92k5H/mLCu/5mxsP+Vraz/kquq/4+p + p/+Np6X/iKOh/3mXlf9qi4j/Z4iF/2+Oi/91lJH/bo6L/2mKh/9piof/aImG/2eJhf9oiYb/aouI/3KS + kP9+mpz/g5+h/4KeoP97mZn/cJCO/2eJhv9miIT/bo6L/4GenP+Sq6n/la6s/5avrf+YsbD/nLKy/521 + s/+gtrX/obi3/6S6uP+mu7r/qL28/6q+vf+swL//rcHA/63BwP+qv73/pry8/6O4uf+guLj/nrW1/5y0 + s/+YsbH/lq+v/5Wtrv+Tra3/h6Ki/2qKif9piI7/bImO/2mIh/9niH7/Y5Bk/1ydSP85sEn/EcJR/xXC + P/89tBv/T6YJ/0urDP8uuCr/AsJR/wDCUv8AwlH/AMJR/wDCUf8AwlH/AMJS/wPBTv86lxTkAAAAegAA + AFIAAAAlAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9tpEd/LaR9v26 + lP/9vZf//b+Z//7Cm//+xJ3//saf//7Gof/+yaL//8qj///Mpf//zaf//86s/5S6Rv8/uCT/QdV6/0ba + hv9N24b/UtyJ/1bejP9b35D/X+GT/2Tilv9o5Jn/beWb/3Hmn/916KP/euml/37rqP+D7Kz/hu2u/4zw + sv+R9Lb/fLic/2OCgv91k5D/la2s/5aurf+Rqqn/j6mn/4ulo/+Ho6D/hqGf/36bmf9xkY7/aYqH/2mK + h/9oiYb/aouH/22Niv9wkI3/cZCN/2+PjP9ri4n/Z4mF/2uMif92lJT/b4+N/2iJhv9miIT/a4yJ/3eW + k/+Io6H/jqim/5Cpp/+SrKr/la2s/5evrv+Zsa//m7Oy/521tP+gtrX/o7i3/6W6uf+nvLr/qb28/6q/ + vv+swL//rcHA/6zBwP+pvr7/prq7/6O5uP+gt7b/nrS1/5qys/+YsLH/l6+w/5OsrP9wj5D/Z4eD/1+U + Wv9bm0P/Vpgn/1GgEf9KsBP/KsE4/wvJW/8Ix1r/AsVY/wXCT/8avTz/Er9C/wDCUv8AwlL/AMJR/wDC + Uf8AwlH/AMJR/wDCUf8Aw1P/DL9H/zyND90AAAB2AAAATAAAACIAAAAIAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP23kgz8t5Hs/buU//29l//+wJn//sKc//7Env/+xp7//sih//7J + ov//yqT//8yl///Orv+3wGX/QrQb/z3TdP9C2YP/SNmD/07bh/9T3Yr/V96N/1zgkf9g4ZP/ZeKX/2nk + mv9u5Z3/cueg/3fopP976qf/gOuq/4Ttrf+J7rD/je+y/5Hztv+X9br/frmf/2SCgv9ykY7/j6mn/5Os + qv+Np6X/iqWj/4ahoP+Dn53/gZ6b/36bmf9zkpD/aImG/2uLiP9ykY7/eJaU/3yZmP99mpf/epiW/3aU + kv9vjoz/aYqH/2iJhv9oiYb/a4uI/3SSj/+AnJr/h6Kg/4ikov+JpKP/jqem/5Gqqf+TrKv/lq6s/5aw + rv+asbD/nLSy/5+1s/+ht7b/ori3/6S6uf+nvLv/qb28/6q/vv+swL//rcHA/6zAv/+ovbz/pbu5/6O4 + uf+ftbf/nbW0/5uzsv+bs7T/haCg/2iGi/9ZkkD/S6oC/0W3Fv88vCv/NcA7/yDHVv8SymP/EMdd/wzG + WP8HxFX/AcNT/wDDVP8Aw1T/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDDVP8YvD3/OYAM0wAA + AHEAAABFAAAAHQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/biSB/u3 + kdX9u5T//b6X//7Amv/+wpz//sSe//7GoP/+yKH//smj///LpP//zar/6smT/1qyHf86y1z/PtiC/0TY + f/9J2oT/T9uI/1Tdiv9Y3o7/XeCR/2LhlP9m45f/auSb/2/mnv9056H/eOmk/33qp/+B7Kv/hu2u/4ru + sf+O8LP/kvG3/5j1u/+d977/hMCj/2WFhP9tjIv/iKOh/4+op/+JpKL/hqGf/4KfnP+AnJn/fZqY/3SS + kP9qi4j/cpKO/3uZl/+Dn53/iKOh/4mkov+GoqD/gJ2b/3iVlP9tjov/aIqH/2qLiP95l5T/gJyZ/4Ge + nP+EoJ7/haKg/4ijoP+MpqT/j6mm/5GrqP+Urar/lK6s/5iwr/+bsrH/nLOz/561tP+gt7b/o7m3/6W6 + uf+nvLv/qb69/6q/vv+swb//rcHA/6vAv/+ovLz/pLu7/6K4uP+gt7f/oLe3/42np/9tiYz/XpNQ/0uv + D/86xEb/Kc5q/yLObf8czmv/Gctl/xXJYP8Rx1z/DMZZ/wfEVv8DwlP/AMJR/wDCUf8AwlH/AMJR/wDC + Uf8AwlH/AMJR/wDCUf8AwlH/AMNV/yW5Mv83dgnIAAAAawAAAD0AAAAXAAAABAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+reRuv27lf/9vpj//sCa//7CnP/+xZ7//sWg//7I + of/+yqP//8uk///Orf+fu0//Obwv/zrXf/9A137/RNiA/0rahP9Q3Ij/Vd2L/1nfjv9e4JL/Y+KV/2fj + mP9r5Zv/cOaf/3Xoov956aX/fuqo/4Lsq/+H7a7/i++y/5DwtP+U8rj/mPO7/572v/+l+8T/jcur/2iJ + hv9oh4b/gJya/4qkov+FoZ//gp6c/3+cmv99mpf/dJOQ/2uMif94l5T/g5+d/42npf+Urav/lq+t/5Kr + qf+JpKL/f5yZ/3STkP9qi4j/aYqH/3aUkv99mpj/fpua/4GdnP+En57/hqGe/4mkof+Mp6X/j6mn/5Kr + qf+TrKv/lq+t/5mwr/+ZsrD/nLSy/5+2tf+it7b/pLm4/6a7uf+ovLv/qb68/6u/vv+twcD/rcHA/6q/ + v/+nvLz/pru7/6W6uv+Np6b/bYeK/2CUfv9Cwkj/N8xd/yzTdv8oz2//JM5q/x/MZ/8by2T/Fslg/xLI + Xf8Nxlr/CMVX/wPCU/8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUv8Aw1L/M7Ym/yxe + B7MAAABjAAAANAAAABIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD6t5GY/buV//2+mP/+wJr//sOc//7Fnv/+x6D//sih///Ko///y6f/88qa/1+zIv83zGD/O9d//0HX + ff9F2IH/StqF/1Hcif9V3Yz/Wt+P/1/gkv9j4pb/aOOZ/2zlnP9x5p//deii/3rppf9/66n/hOys/4ju + r/+N77L/kfG1/5XyuP+a9Lz/nvW//6P4wv+r/8j/mty3/2+Ujf9kg4L/eJaU/4Ognf99m5j/d5WT/3GQ + jf9sjIn/aImG/3eVk/+KpaP/lK2r/5+2tP+jubf/m7Kx/4+pp/+Dn57/eJaT/2yMif9oiYb/cpGO/3uY + lv99mpj/f5ya/4Kem/+Dn53/hqKg/4mlo/+Np6X/kKmo/5Krqv+Urav/l66t/5ixr/+asrH/nrSz/6C2 + tP+huLb/o7m4/6W7uv+ovbv/qr69/6vAv/+twcD/rcHB/67Cwf+kurn/g5+e/2qFhv9kkIX/R8V//zTZ + fP8x03f/LtFx/ynPbf8lzmr/IMxn/xvLZP8WyWD/Eshd/w3GWv8JxVf/BMNT/wDCUf8AwlH/AMJR/wDC + Uf8AwlH/AMJR/wDCUf8AwlH/AMJS/wHCUP8/shz+Gz0FmgAAAFoAAAAsAAAADgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPu4knb9u5X//b6Y//7Bmv/+w53//sWe//7H + n//+yKL//8qj///Nq//JwnT/Q7gm/zbTd/881nv/Qdd9/0XYgf9L2oX/UdyJ/1bejP9b35D/X+GT/2Ti + lv9p5Jn/beWd/3HnoP926KP/e+qm/4Drqf+E7az/ie6w/43ws/+S8bb/l/K5/5v0vP+f9b//o/fC/6n4 + xv+x/8z/qe3E/3ynmf9lhYP/a4yJ/2qLiP9oiYb/aImG/2uLif9ujoz/bIyJ/4Kem/+Ysa//pbq5/6m+ + vf+etbT/kaup/4Whnv95lpT/bY2K/2iJhv9qi4j/cI+M/3aVkv98mpb/gJ2a/4Ofnf+FoZ//iKSi/4um + pP+OqKb/kKqn/5Ksqf+Urav/l6+t/5mxsP+cs7L/nbS0/5+2tf+iuLf/pLq4/6e7u/+pvbz/rMC//6/D + wv+swcD/lq6t/3SSkf9ng4X/YJ2F/0jNgf882nz/N9R3/zPSdP8u0XH/Ks9u/yXOav8gzGf/HMtk/xfJ + YP8SyF7/DsZa/wnFV/8Ew1P/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8Aw1L/CcBK/0eo + E/YJFQKCAAAAUQAAACUAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA+riST/27lf/9vpj//sGb//7Dnf/+xZ7//seg//7Iov//yqP//82u/6u8V/83vjX/NtZ9/z3W + e/9B137/RtiB/0vbhf9S3In/Vt6N/1vfkP9g4ZP/ZOKW/2nkmf9u5Z3/cueg/3foo/986qb/gOuq/4Xt + rf+K7rD/jvCz/5Lxt/+X87r/nPS9/6D2wP+l98P/qvnG/676yf+1/8//uPzR/428qP9jgoL/ZoeE/2yN + iv93lZb/fJma/3yZmv90k5P/bIyJ/32bmP+Xr63/oLe1/5uzsf+Pqaj/g6Cc/3aUkv9qi4f/a4uJ/2uL + if9oiYb/aImG/2uMif9xkY7/eJaT/4Cdmv+GoZ//iqWj/42npf+Pqaf/kaqp/5Ksq/+Vrq3/mLCu/5qy + sP+ctLL/n7a1/6K4t/+lurn/qL28/6e8u/+gt7X/j6mn/3eVk/9oh4r/ZoiC/1q1hf9I2YP/QtqA/z7W + fP841Hj/M9J0/y/Rcf8qz27/Jc5r/yHMZ/8cy2T/F8lg/xPIXv8Oxlr/CcVX/wTDVP8AwlH/AMJR/wDC + Uf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDDVP8VvUD/QpYO5AEDAHUAAABIAAAAHwAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9u5Uh/byV9v2+mP/+wZv//sOd//7F + n//+x6D//sii///KpP//zav/lrpI/zPDQv831n7/PdZ7/0LXf/9G2IH/TNuG/1Lciv9X3o3/W9+Q/2Dh + k/9l4pf/aeSZ/27lnf9z56D/d+ik/3zqpv+B66r/he2t/4rusP+O8LP/k/G3/5jzuv+c9L3/ofbA/6b3 + xP+q+cf/r/rK/7P8zf+6/9L/v//W/5rHsv9vkYz/Y4OC/2yMiv92lZX/fJmb/32anP94lpj/bo6N/26O + i/94l5T/fZqY/3uZlv9zko//bIyJ/2yNi/9zkpL/dpSU/3OSkv9wj47/bIyK/2iJhv9niYb/aYqH/3CP + jP92lZL/fJmX/4KfnP+Ho6H/jKel/5CqqP+Tq6r/lK2s/5evrv+Xr63/k6yq/42npf+EoJ7/eZeU/2yM + if9jhoT/Z4aL/2WMbf9TqjL/S9x+/0jbhf9E14D/PtZ8/zjUd/8z03X/L9Fx/yrPbv8lzmr/Icxo/xzL + ZP8XyWH/E8hd/w7GW/8JxVf/BMNU/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMNV/yK6 + Nf87gArQAAAAbAAAAD4AAAAZAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP28lgX8u5XS/b6Y//7Bm//+w53//sWf//7HoP/+yaL//8qk///Mqv+Sukf/NMNG/zfW + ff891nv/Qtd//0bYgf9M24b/UtyK/1fejf9b35D/YOGU/2Xilv9p5Jr/buWd/3PnoP936KT/fOqm/4Hr + qv+F7a3/iu6x/4/ws/+T8bf/mPO6/530vf+h9sH/pvfE/6v5x/+v+sr/tPzO/7j90P/A/9X/zP/f/8Dv + 0/+XvK//bo+L/2GCgP9pioj/c5KS/3uYmv99mZv/eJaX/3KRkf9ujY3/Z4mF/2mKh/9wkI7/dJOT/3WU + lP93lZX/eJeX/3qYmP96l5n/eJaX/3STk/9wj47/aouJ/2iJhv9niYX/aImG/2iKhv9qiof/aouI/2qL + iP9ri4j/a4yJ/2uLiP9qi4j/Z4mG/2WHhP9jhoT/YIWF/3qQkf96m2H/T6cN/03HRf9N3In/SdmE/0TY + gP8+1nz/ONR3/zPTdf8v0XH/Ks9u/yXOav8hzGj/HMtk/xfJYf8TyF3/DsZb/wnFV/8Ew1T/AMJR/wDC + Uf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8Aw1T/Lrcq/zBnCLkAAABiAAAANAAAABMAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPu7lZ39vpj//sGb//7D + nf/+xZ///seg//7Jov//yqT//8yq/5O6R/80w0X/N9Z9/z3We/9C13//RtiB/0zbhv9S3Ir/V96N/1vf + kP9g4ZT/ZeKX/2nkmv9u5Z3/c+eg/3fopP986qb/geuq/4Xtrf+K7rH/j/C0/5Pxt/+Y87r/nfS9/6H2 + wf+m98T/q/nH/6/6yv+0/M7/uP3Q/7//1P/H/9r/0P/h/9j/5//K7tn/osK2/3eXkv9ihIH/ZIaD/3CP + j/92lZX/epiZ/3uYmv9ujoz/aYqH/3KSkP91lJT/dpWV/3eWlv95l5f/epiY/3uYmf98mZv/fZqc/36a + nf98mpv/e5ia/3iWlv91lJT/c5KS/3GQkP9xkJD/cZGQ/3GQkP9vj47/bIyK/2iJh/9jh4X/YIaF/3KP + if+zrJ//rrVu/1OrCf9OxUT/Ut6N/03bh/9I2YP/RNeA/z7WfP841Hj/M9J1/y/Rcf8qz27/Jc5r/yHM + aP8cy2T/F8lh/xPIXv8Oxlv/CcVX/wTDVP8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJS/wDC + Uf88sx//HkMGnAAAAFYAAAApAAAADQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA+ruVZP2+mP/+wZv//sOd//7Fn//+x6D//sii///KpP//zKr/lLpH/zTD + RP831n3/PdZ7/0LXfv9G2IH/TNuG/1Lciv9X3oz/W9+Q/2Dhk/9l4pf/aeSZ/27lnf9z56D/d+ik/3zq + pv+B66r/he2t/4rusP+O8LT/k/G3/5jzuv+c9L3/ofbA/6X3xP+q+cf/r/rK/7T8zf+4/dD/vv7V/8b/ + 2v/L/93/0f/h/9v/6P/k/+7/3Pjn/7nTyf+LqaL/aIqF/2qIjf9sjI//cZCR/3CPjv9oiYb/bY2L/3aV + lf93lpb/eZeX/3qYmf97mJn/fJmb/32ZnP99mpz/fpud/3+cnv+AnJ//gJ2g/4Cdn/+AnJ//fpud/3uY + mf92lZX/cJCQ/2iKif9hhoX/aImH/4OXjv+3sZv/8Myu/+/Rmf9drhX/TMVE/1ffkf9S3Yz/TduG/0jZ + g/9E2ID/PtZ8/zjUeP8z0nT/L9Fx/yrPbv8lzmv/Icxn/xzLZP8XyWH/Eshe/w7GWv8JxFf/BMNU/wDC + Uf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8Aw1P/CcBK/0epE/cMGwJ9AAAASAAAAB8AAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9vZcn/b6Y+f7B + m//+w53//sWe//7HoP/+yKL//8qk///Mpv+Ctzv/NMZN/zfWff891Xv/Qdd+/0bYgf9L24X/UtyK/1be + jP9b35D/YOGT/2Tilv9p5Jn/buWd/3LnoP936KP/fOqm/4Drqv+F7a3/ie6w/47ws/+T8bf/l/O6/5z0 + vf+g9sD/pffD/6n5xv+u+sr/s/zN/7f90P+9/9T/xP/Z/8r/3P/P/+D/1f/k/9v/6P/i/+z/7v/2/+v/ + 8v93u1v/UI84/2KHaP9oiIP/aoqN/2qKjv9lh4b/bI2L/3CRj/9zk5L/dpSU/3iWlv94lpf/eZeY/3qX + mP95l5j/d5aX/3WUlP9ykpL/cJCQ/2uNjP9liIf/YIWF/2SHhf9si4f/hZiO/6+tmv/WwaT/+9Ot///Z + sv/y0qH/b7Yr/03ERP9b4ZT/Vt+P/1Hcif9N24b/SNmD/0PYf/8913//NtZ8/zLTdv8u0XH/Ks9t/yXO + av8gzGf/HMtk/xfJYf8SyF3/DsZa/wnEV/8Ew1P/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJR/wDD + Vf8cuzr/QZEM3AAAAGUAAAA4AAAAFgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP29lwL8vZfI/sGZ//7Dnf/+xZ7//seg//7Iov//yqb/9Mma/12z + Iv8zzWP/N9R6/zzVe/9B137/RdiB/0vahf9R3In/Vt6M/1rfkP9f4ZP/ZOKW/2jkmf9t5Z3/cuef/3bo + o/976qb/gOup/4TtrP+J7rD/jfCz/5Lxtf+W8rn/m/S8/6D1v/+k98L/qfnH/676yv+x+8z/tv3P/7v/ + 0//C/9f/yP/b/83/3//T/+L/2P/m/93/6f/h/+z/7f/5/6zjmP9GqgH/QpgA/02PF/9Vijj/ZI5c/4Ka + kP9tjIn/Z4mG/2OHhf9ghYT/X4SE/1+EhP9fhYT/X4SE/2CFhP9jh4X/ZoiF/2mKhv9ujIf/e5OL/5Og + k/+rrZr/ybyi/+jMqv/71bD//9qx///Ysf//1a///9a2/7zDbf9JvC7/XuGV/1rgkv9V3Yv/UdyJ/0za + hf9H2YP/QtmE/zzRa/82yFP/Ms9p/y3SdP8pz23/Jc5q/yDMZ/8by2T/Fslh/xHIXv8Mxlv/B8VY/wLD + VP8AwlH/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMNU/zC2Kf8zbQi0AAAAUwAAACkAAAANAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPu9 + l37+wJn//sOc//7Fnv/+x6D//sih///Lrf+7vmX/Prcl/zHSdP831Hj/PNV7/0DXff9F2IH/StqF/1Hc + if9V3Yz/Wt+P/1/gkv9j4pb/aOOZ/2zlnP9x5p//duii/3rppf9/66j/g+ys/4jur/+N77L/kfG1/5Xy + uP+a87v/oPbB/6f6y/+o+cf/rvzO/7L9z/+0/M3/uf7S/8D/1v/F/9r/y//d/9D/4f/U/+P/2f/m/93/ + 6f/h/+z/5v/x/7vqs/+AzVz/T68R/0KXAP9JjgD/ysuM/+nZvv/QyK3/w8Co/7e4o/+xtKD/srWh/7O0 + oP+ys6D/trah/8O8pP/Owaf/28iq/+3Rr//417L//tqz///ctP//27P//9my///XsP/+1a///tWv//7U + rv//1rb/tsJn/03CPv9e4pf/Wd+P/1Xdi/9Q3Ij/S9qF/0bahf9EyFT/XrUm/3i2NP9PtB3/NMdU/yfQ + cf8kzWn/H8xm/xvKY/8YyF3/FchZ/w7GVP8Cwkv/AcJS/wDDU/8AwlH/AMJR/wDCUf8AwlH/AMJR/wDC + U/8FwU3/Ra8X/RcyBYIAAABCAAAAHAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/b+ZHv7Amev+wpz//sWe//7Gn///yaf/38SG/1i0 + Iv8vylz/MdN2/zbUd/871Xr/P9d9/0TYgP9K2oT/UNyI/1Tdi/9Z34//XeCS/2Lilf9n45j/a+Wa/3Dm + n/906KH/eeml/33qqP+C7Kv/h+2u/4vvsf+P8LT/lPK3/5v2wv+b87v/ddVt/2nGSP9vzFX/o/K1/7T9 + 0P+3/dD/vP/U/8H/1//G/9r/y//d/8//4P/T/+L/1v/l/9n/5f/b/+f/4//y/+H/8P/H88v/ectW/z6Y + AP+1wXL//+rK///mwP//58D//+a////mv///5r7//+S9///kvP//47v//+G5///guP//3rb//9u1///a + tP//2bP//tiy//7Xsf/+17H//taw//7Vr//+1a7//tSu///Vs//by4r/U7go/1rei/9Y35D/VN2L/0/b + iP9J24n/Rs5h/1OrEf/hx4r//tCu/9bFff9PtSH/J81m/yLOa/8dzGj/I8ZU/0axGv9FoAz/XaUe/4u3 + Sv9DtSf/Db5E/wDDU/8AwlH/AMJR/wDCUf8AwlH/AMNV/yK6Nf8/iQzSAAAAXgAAADIAAAARAAAAAgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/L6Ynf7Bm//+xJ7//8ag//7IpP+DtTf/L744/yrSdv8x0nP/NdN2/zrVef8+1nz/Q9d//0na + g/9P24j/U92K/1fejv9c4JH/YeGU/2Xjl/9q5Jr/buad/3PnoP936KP/fOqn/4Drqv+F7a3/ie6w/47w + tf+V9L//heaX/1a+Mv91tzD/zc6K/4a5PP9wz1z/tP7U/7T8zv+5/tH/vf/U/8H/1//F/9n/yf/c/83/ + 3//P/+D/0v/h/9P/4//U/+P/1f/k/9z/8f+38br/Ua0V/9jSl///5MP//OG8//zhvP/84Lv//OC6//3f + uf/93rn//d64//3dt//927b//du1//3atf/92rT//dmz//7Ysv/+2LL//tex//7WsP/+1rD//tWv//7V + rv/+1K7//9Sv//jRpf9jtSf/VNZ1/1ffkf9S3Yr/TtuH/0jciv9Hw0L/V58K//jKoP//0K7//82l/2G0 + I/8nyVv/Ic5r/xzMZ/8byF3/Q7Qf/0ycAP9Xjgn/9LiM/6i1Sf8cuCj/AMNW/wDCUf8AwlH/AMJR/wDC + Uv8BwlD/P7Mc/yFIBpkAAABPAAAAJQAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+wJlE/sGa//7EnP//x6X/2MF+/0az + G/8nzGX/K9Bw/zDRcv8003X/OdR5/z7WfP9C13//R9mD/07bh/9S3Ir/V96N/1vfkP9g4ZP/ZOKX/2nk + mv9t5Zz/cueg/3boo/976ab/f+up/4PsrP+J77H/jfC1/2rSZP9Sshj/p8Nf//vas///38X/0s+K/1y8 + L/+p+MP/svzO/7b9zv+5/tH/vf/U/8H/1//F/9n/yP/b/8r/3P/N/97/zv/f/8//3//P/9//0v/m/63t + r/9suTH/99+3///ivv/84bv//OC7//zgu//93rr//d65//3euP/93bj//dy3//3btv/927X//dq0//3Z + s//+2bP//tiy//7Xsf/+17H//taw//7Wr//+1a///tSu//7Trf//067//9Ov/4e5P/9Ly1X/V+CU/1Hc + if9M24b/R9uH/0fAOv9UnAj/88mc///StP/OxHj/RLUg/yXNaP8hzWj/Hctk/xbKZP8bxlX/RbMZ/0aV + AP/JrGr/t7hZ/xq4KP8Aw1b/AMJR/wDCUf8AwlH/AMNU/xG+Q/9GoRDuBQsBbwAAAEAAAAAaAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP7BmgT9wJnM/8Od///Gpf+Wt0X/Lb00/yPQcP8rz27/L9Fy/zPTdP841Hj/PdZ7/0HX + ff9G2YL/TNuG/1Hcif9V3oz/Wt+P/17gk/9j4pb/Z+OZ/2zlnP9w5p//deih/3nppf996qj/guyr/4bu + sP9hx0v/b7Uq/9XOjf//273//9u3///bt//22a3/Z7cr/5Pqn/+y/dD/s/zO/7f90P+5/tH/vP/T/7// + 1v/C/9f/xf/Z/8f/2v/I/9v/yf/b/8j/2//P/+j/hdh1/4m+R///48L//OC8//zgu//84Lr//d+6//3e + uf/93rn//d24//3dt//93Lb//du1//3atf/92rT//dmz//7Ys//+2LL//tex//7XsP/+1rD//tWv//7V + rv/+1K7//tOt//7TrP//1bb/r8Bf/0a/OP9V4JH/UNyJ/0vbhv9G2ob/RL84/1+gEv/6y6T/7MuZ/2iz + I/8ww0f/I89v/yDMZ/8cy2T/F8lg/w7JY/8qvjn/SqEE/8ytbf+1uFj/Grgo/wDDVv8AwlH/AMJR/wDC + Uf8Aw1X/KLgw/zp8CccAAABdAAAAMQAAABEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPy/mmn/w57/+sSZ/2Oz + I/8kxlT/I89t/yrPbf8u0XH/MtJ0/zfUd/871Xr/QNZ9/0XZgf9L2oX/UNyI/1Tdi/9Z34//XeCS/2Hh + lf9l45j/auSb/2/mnv9y56H/d+ik/3zqpv+C7bD/ctyB/06qDP/fzJL//9u+//7Zs//92rT//tq1///c + uf+IvUX/fdt6/7D90f+w+8v/s/zN/7b9z/+4/dH/uv7S/73/1P+//9X/wP/W/8H/1//C/9f/w//Z/8H+ + 1/9gvzb/wM19///jw//837r//d+6//3fuv/93rn//d65//3duP/93Lf//dy3//3ctv/92rX//dq0//3Z + tP/+2bP//tiy//7Ysf/+17H//taw//7Wr//+1a///tWu//7Urv/+06z//tOs///TsP/kzJH/VLQd/0/X + ef9P3o3/StqF/0Xahv9Avjb/orhR///Rs/+Xukr/M7or/yfQcP8jzmr/H8xn/xrLY/8WyWD/D8hg/xnC + Sf9LqQ3/3bN7/662U/8auCj/AMNW/wDCUf8AwlH/AMJS/wLCUP9Asxz/IkoGmQAAAE0AAAAjAAAACgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA/8KlD/3Dq9y+uWT/PLQa/x7MZf8jzmr/KM9t/y3QcP8x0nP/NtN2/zrV + ev8+1nz/RNiA/0rahP9O24f/U92K/1fejf9c35D/X+GT/2Tilv9p5Jn/beWc/3Hmn/926KL/euml/4Lu + sv9m0F3/QJgA/7C1Y///3L3//tiz//3Zs//+2bT//9u7/5G+TP932HH/rfzQ/6z6yP+v+8v/svvM/7T8 + zv+3/c//uP3Q/7r+0v+7/9P/vP7T/7z+0//F/+H/jOCG/2i1KP/33rb//uC8//3fuf/937n//d65//3e + uP/93bj//dy3//3ct//93Lb//du1//3atP/92bT//dmz//7Ysv/+2LL//tex//7WsP/+1rD//tWv//7V + r//+1K7//tSt//7TrP/+06z//9Ks///TsP+Vu0r/P7sq/0rYfv9H24f/QtmD/z+7LP/Cw2///8+p/2G0 + Jf8rylz/JtBw/yPNaf8ezGb/Gcpi/xXJX/8OyF//HcFG/0qlCv+Eni//ZrEi/xG9Pf8Aw1T/AMJR/wDC + Uf8Aw1T/FL1B/0efDusECgFsAAAAPAAAABgAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAp7JYiWSx + Hv8mwEP/HM1q/yPNaf8nz2z/LNBv/zDRcv8003b/OdR5/z3We/9C13//SNmD/03bhv9R3In/Vt2M/1rf + j/9e4JL/Y+KV/2fjmP9r5Jv/cOae/3TnoP946KT/f+2w/2jSZf9DnAD/XZQU//DSo///27n//diy//7Z + tP//2rf/hrxD/3vbev+p+8z/qfjG/6v5yP+u+sr/sPvL/7P7zf+0/M7/tf3P/7f90P+3/dD/vf/Z/6Hu + q/9RtRz/ys+G///hwv/93rn//d65//3euf/93rj//d24//3ct//93Lb//924///fv///38D//9q1//3Z + s//+2LP//tiy//7Xsf/+17H//taw//7Wr//+1a///tSu//7Urf/+063//tOs//7SrP//0qv//9Ku//PP + ov+HuT7/TbUe/0S+NP9Auy3/Z7Up/+7Mmf/6zaH/VrQf/yrMZP8lzm3/Ic1o/x3LZf8YymL/FMhe/wzI + X/8fwET/TqYL/0qgAP8stib/AcNT/wDCUf8AwlH/AMJR/wDDVP8ruC7/OHgJvwAAAFUAAAArAAAADgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEGvBgRCrQjCKb07/xbKZf8dy2X/Icxo/ybOa/8q0G7/LtFx/zPS + dP831Hj/PNV6/0HXfv9H2IL/S9qF/1DciP9U3Yv/WN6O/13gkf9h4ZT/ZeKX/2nkmv9t5Zz/ceaf/3Xo + ov9766n/deGP/06vE/8/jQD/g6Q6//jWr///3L3//9u5//XXqv9itib/jOid/6P4xv+l98T/qPjF/6r5 + x/+s+cj/rvrK/7D7y/+x+8v/svvM/7b+0v+n9Ln/V7km/6rFZf//4MD//t65//3duP/93bj//d23//3c + t//93Lf//dy3///fvv/42K//ub1x/7C5aP/62LD//9q2//7Ysv/+2LH//tex//7WsP/+1rD//tWv//7V + rv/+1K7//tSt//7Trf/+06z//9Kr///Sq///0ar//9Kt///RrP/dyYn/usFo/7vBaf/uzJn//9Cu//zN + pf90tjH/K8VP/yLPbv8gzGf/G8tk/xfJYf8SyF7/DMdc/xTBTP9Gshj/NrYk/wXBTv8Aw1P/AMJR/wDC + Uf8AwlL/A8FO/0OxGf4gRgaJAAAAQAAAABsAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATrAQBkyv + EdYew1D/FMpl/xzLZP8gzGf/JM5q/yjPbf8t0HD/MdJz/zbTdv861Xn/P9Z9/0TYgf9J2oT/TtuH/1Lc + iv9W3o3/W9+P/1/gkv9j4pX/Z+OY/2vkm/9u5p7/c+eh/3fopP987Kz/YMhM/0eeAP9AiAD/b5wn/8XB + fP/01Kz/usRw/1q9Mv+Y8rn/nvW//6H2wf+k98L/pvfE/6j4xf+q+cf/q/nI/636yf+u+sr/sfzP/2bH + Sf+Ku0T//+DD///duf/93bf//d24//3dt//93Lf//dy3//3ctv//3r3/0MaH/2mcI/8+iwD/OogA/4qo + QP/+2rb//9m2//7Xsf/+1rD//tav///WsP//1rD//9Ww///Wsf//1rT//9a0///Vs///1LH//9Ou///S + q///0ar//9Cq///Rrv//0bL//9Gx///Qq///z6j//8+v/6C7UP8uvDL/IM9v/x7MZv8aymP/Fslg/xHH + Xf8Mxln/B8VX/wfCUP8AwlH/AMJS/wDCUf8AwlH/AMJR/wDDVf8duzj/RJYM2gIEAFEAAAApAAAADgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAT64OgDy3J/8UyWH/Gctk/x7MZv8izWn/J89s/yzQ + b/8v0XL/NNJ1/zjUeP891nz/Q9iA/0jZgv9M2oX/UNyI/1Tdi/9Y3o7/XOCR/2Dhk/9k4pf/aOSZ/2zk + nP9w5p//dOeh/3nqqP935Jn/VLkm/0ibAP9BiwD/RooA/1SRCv9JoQL/cdNo/5r2wv+a9Lz/nfW+/6D1 + wP+i9sH/pPfC/6X3xP+n+MX/qPjG/6v6y/+f8bH/RqsM/42uRP//4L///t24//3ct//93Lb//dy3//3c + tv/927X//9+//83Hhf9ImgH/RKgH/1CyGP9IoAb/P4kA/5mtTv/82LP//9y9///auv//2rv//9i3///V + sP/50qn/7Myb/9LCg//Kv3r/y756/9jDhv/wy53//9Ks///Ts///0Kr//9Cp///PqP//z6j//8+o///P + qP//z63/3MaF/0myGf8iyV3/G8xo/xnKYv8UyF//EMdb/wvGWf8GxFX/AcNT/wDCUv8AwlH/AMJR/wDC + Uf8Aw1P/BcFN/0SyGf8nVweJAAAANwAAABYAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABNsBENUK8N0Cy+Pv8Vy2b/Hctl/yHNaP8mzmv/Kc9u/y7Qcf8y0nT/N9N2/zrVev9C137/RtiB/0ra + hP9O24f/UtyJ/1bejf9a34//XuCS/2LilP9m4pj/auSa/27lnP9x56D/deei/3rrq/914pL/WsE6/0up + DP9GmwD/RaAA/1m9Mv+M7Kv/lPK5/5byuf+Z87v/nPS9/571vv+f9b//ofbB/6L2wv+k98L/p/nI/5nu + q/9LrBD/WJUP//DWqP//3br//du2//3btv/927b//du1///cuv/p1aL/YK8d/1e/M/+D45H/je6u/2bJ + Tv9GmAD/QogA/3GdKP+utmP/ubpt/6myXf+Uqkn/gKE0/2eXHP9SkQf/So4A/0eNAP9IjQD/So0B/1OQ + Cf96oDD/wrty///RrP//0a3//8+o///PqP//z6j//86o///Op///zav/nbpM/zK2IP8ay2T/Fcpj/xPI + Xf8Oxlv/CsVY/wXDVP8BwlH/AMJR/wDCUf8AwlH/AMJS/wDDU/8ttiv/Q5ALygAAAEIAAAAfAAAACgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOrw83SrEV9h/FVf8Yy2b/IMxn/yTN + av8ozmz/LdBw/zHSc/8103X/OdR5/z/Wff9E2ID/SNmC/0zahf9Q3Ij/VN2L/1jejv9c35H/X+CT/2Pi + lv9n45n/a+Sb/2/mnv9y5qD/duii/3vqqv9966j/c92D/2nRYf9v1W//h+up/47wtv+P8LP/kvG2/5Xy + uP+Y87r/mvS8/5v0vv+c9L7/nvW//5/1v/+g9sL/nvS8/1q7LP8/jwD/srlq///fv//927X//du1//3b + tP/+27b/+Nmy/3W3Mf9hylD/lPK6/5Pzvf+Q87v/hOmh/1G0HP9GmgD/QYwA/z+KAP9CjQD/PY4A/z2R + AP9AlQD/RJwA/0mkB/9Kpgr/SqYK/0qkCP9JngD/R5YA/0CMAP9BiQD/hqQ5//DLnv//0Kv//8+o///P + qP//zqf//82m///MqP/3yp//hLY4/zO3I/8WyFz/D8hf/w3GWf8HxFb/A8JT/wDCUf8AwlH/AMJR/wDC + Uf8Aw1X/Grw7/0qjDuwSKARcAAAAKAAAAA4AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABPrQ2APrYn/xjKZP8dy2b/Isxo/ybOa/8r0G7/L9Fx/zPSdP841Hj/PNZ7/0HX + fv9F2IH/SdqE/03ah/9R3In/Vd2L/1nfj/9d4JH/YeGU/2Til/9o45n/bOWc/2/mnv9z56D/duij/3rp + p/9/7K7/hO+0/4fwtf+H7rH/iO6v/4vvsf+O8LP/kvK5/5f1wP+V87n/l/O7/5r1v/+Z87v/mvS8/5v0 + vP+f98X/cNFe/z+ZAP9rmiH/+dix///bt//92rT//dm0///bvP+2xm7/U70w/5Dxtf+Q8bj/jO+y/4ru + sP+I77P/d+CM/1vCPP9OrxT/TawR/06xF/9Styb/Vr42/1nGSf9bzVr/XNNs/1vUcP9Y1G7/VNFn/1DJ + Uf9OvC//TasN/0mYAf84hwD/pa5U///Tsv//z6j//8+o///Op///zab//8uk///Kp//6yKH/j7Y9/zO1 + HP8Rxlf/CcZb/wbEVP8CwlL/AMJR/wDCUf8AwlH/AMNU/wq/Sf9GsBb8KVsIhQAAADIAAAAUAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2wEQhPrw3IL78//xjM + af8gzGf/Jc5q/ynPbf8t0HD/MdJy/zbTdv871Xr/PtZ9/0LXf/9G2IL/S9qF/0/biP9S3Yr/Vt2N/1rf + kP9e4JL/YuKV/2Xil/9p5Jn/bOWc/2/mnv9z56D/duij/3rppf986qj/f+up/4Lsq/+F7a3/h+2v/4zx + tv+H6qb/atJl/1zBPP9fw0D/huaZ/5fzvf+W8rn/l/K5/5n1wP+I5pn/S6wO/0uRAv/gzJb//9u5//3Z + s//+2bT//tm1/3+5O/9t1m//kfS9/4rusP+I7q//he2t/4Lsq/+B7a//fOup/3Pjk/9u34n/b+OV/27k + mv9s5Jv/aeaf/2bln/9i45r/XuKX/1rhlP9W4JP/UuCT/07djP9K0Wn/Rrgj/2mqI//kxY///9Cs///P + qP//zqf//82n///Mpf//y6T//smi///Ipf/6xqD/j7U9/zK1Hf8JxFb/A8NV/wDCUf8AwlH/AMJR/wDC + Uv8BwlH/OLQj/z2CCrUAAAA9AAAAGwAAAAgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAE6vDzZKsRX2IcZW/xvMaP8izWj/Js5r/yvPbv8v0HD/M9J1/zjU + eP881Xr/QNd+/0TYgP9I2YL/TNuG/1Dcif9U3Yv/V96O/1vfkP9f4ZP/YuGV/2bjl/9p5Jr/bOWd/3Dm + nv9z56D/duij/3nppf986af/fuuo/4Hrqv+H8LX/duCK/1O3JP+AuDn/vMd1/5W7SP9fxUX/kfK5/5Hx + tv+S8bb/kvG3/5Tyuv9gxUL/TpwG/+XMmv//27j//tmz///Ztf/z1ab/YLYm/37ll/+L77P/hu2u/4Ts + rP+B7Kr/f+uo/3vppv946aX/dumm/3Popf9w56D/bOWd/2jkm/9l45f/YeGU/17gkf9a35D/V+CT/1Le + jv9M2H//RtFr/0HOYf86wTv/U7MX//DNm///0Kv//86n///Op///zab//8ul///Ko//+yaL//seg///G + ov/7w53/hrQ2/ye2JP8Bw1X/AMJS/wDCUf8AwlH/AMNV/yS5Mv9ImwzdBxACTAAAACMAAAALAAAAAgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE+t + DYA+tyf/Gstl/x/MaP8kzWr/KM9s/yzQb/8x0XP/NtN3/zrVef8+1nz/Qtd//0XYgf9J2oT/TdqH/1Dc + if9U3Yz/WN+O/1zgkP9f4JL/Y+KV/2bjl/9p5Jr/bOWc/2/mnv9y56D/deii/3jopP966ab/f+2u/2/d + gv9euCn/ysl9///Ytv//28L/0MuD/1zAOv+K7rD/jfCz/43wsv+O77P/kvS+/23Vbf98tjb//dez///Y + s//+2LL//9m3/9XMif9ZvDD/g+yq/4Ttrv+C7Kv/gOup/37qqP976ab/d+ik/3Toof9y56D/b+Wd/2zl + nP9o5Jn/ZeOX/2LilP9e4JL/W+CR/1fej/9MzWD/Rb41/1K1If9otiv/gLg7/427Rv+wwWX//M+m///P + qf//zqf//82m///Mpv//y6T//smi//7Hof/+xqD//sSe///Dof/wv5D/arIi/xe6NP8Aw1T/AMJR/wDD + VP8RvkP/S6oR9h5EBm0AAAAsAAAAEQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATbARCE+uDcgwv0D/Gs1r/yHNaf8lzmz/KdBv/y7S + c/8y1Hn/NtV9/zrXf/8/1n3/Q9d//0fZgv9K2oX/TtuH/1Lcif9V3oz/Wd+O/1zgkP9f4ZP/YuGV/2bj + mP9p5Jn/bOWc/2/mnv9x56D/dOeh/3jppf915Zz/Trch/73Fb///2b3//9ax///YuP/HyHr/WsE8/4bu + rv+J7rD/iO6w/4nusP+O87z/XMpR/5m/Uf//2bv//9ey//7Xsf//2bv/q8Jg/1nGR/+D7rH/gOuq/37q + qP986qb/euml/3foo/9z56H/cOaf/27lnf9r5Zv/aOSZ/2Xjl/9h4pT/XuGS/1vfkf9X3o//TcNB/2qz + JP+vv17/48qQ//nPpP//z6j//9Ct///Qr///z6n//86n///Op///zab//8yl///Ko//+yKL//seg//7F + nv/+xJ3//sKb///Aof/UunT/RbEV/wbASf8Aw1X/BcFO/0CzG/82dwmVAAAAMgAAABYAAAAGAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAATq8PNkqxFPgrwkr/H8xm/yLNaP8mzWf/LMxh/zHHUv86xUv/QMdT/z3Tdv9A137/RNeA/0fZ + gv9L2YX/T9uH/1Ldiv9V3o3/Wd+O/1zgkP9f4ZP/YuGV/2Xjl/9o5Jn/a+Sb/23lnf9w5p7/deqo/1zP + YP+AuDj//9az///Wsf//1rD//9m8/52+Uf9byE3/he+z/4PsrP+E7az/iPC2/3Hbf/9Ssxr/1s2M///Y + t//+17D//9ex///Xtf+Ku0P/YNBh/4Husf986qb/euml/3jopP926KL/c+eg/2/mnv9t5Zz/auSb/2fj + mf9k4pf/YeGV/17gkv9b35D/WOGU/1DPY/9UrBD/68uV///Ttf//0a7//8+q///Pqf//z6n//8+o///O + p///zqf//82m///Mpf//y6T//8qj//7Hof/+xqD//sSe//7DnP/+wZr//r+Z//+9nf+Xs0L/I7ci/wDD + VP8vtyr/R5oLvQAAACsAAAAXAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATrAPT02wENlCtiP+QLcn/0y1 + Iv9ctCP/gLg8/3KvKP9MrAn/Pstf/zzXf/9B137/RNh//0jZg/9L2ob/TtyH/1Ldiv9V3oz/Wd+O/1zg + kf9f4ZP/YeGV/2Til/9n45j/auWc/23nov9x66v/UMI//7HCY///17n//tWv///Yuf/OxYD/VbAX/3Dd + hP+A7a//f+up/4Lvs/9u237/TrIX/77Gc///2Lf//9aw//7Wr///1rH//NWt/3i5OP9n2Xj/e+yr/3fo + pP926KL/dOeh/3Lmn/9v5p7/a+Wc/2nkmf9m45j/ZOKW/2HhlP9e4JL/W9+Q/1jejv9V35L/TMND/1af + Cv/4y6H//9Gs///PqP//z6j//8+o///PqP//z6j//86n///Npv//zab//8ul///Ko//+yaL//sef//7F + nv/+xJ3//sKb//7Amv/9vpj//7yZ/+y4hv9ksST/NbQe/0qqENshSwcvAAAAEAAAAAcAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAS7AOD1SsE0HEvm2r5cSL//jKn//wx5b/aqse/0G5K/830nT/OtV6/z7W + fP9B137/RNeA/0jZg/9M2oX/TtuH/1Lciv9V3Yz/WN6O/1vfkP9e4JL/YOGU/2Tkmv9l4pb/W9Vx/1HL + U/9QtR7/18uJ///Vs///1rX/zcOA/1CmCf9ayU7/euur/3rppf997a//a9p7/06yFv++xnL//9i5///V + sP/+1a///tWv///Vsf/506n/bbgx/2ndhP926qb/c+eh/3Hmn/9w5p7/buWd/2vkm/9o45n/ZeKX/2Lh + lf9g4ZT/XeCS/1rfkP9X3o3/VN2M/1Hdjf9MwDz/TZkD/97Civ//0rD//8+o///PqP//z6j//8+o///O + p///zqf//82m///Mpf//y6P//smj//7Iof/+xp///sSd//7CnP/+wZr//b+Z//28l//9upT//7mc/4CC + QJk2hAVzL2wKLAAAAAcAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPrI + ngr/yqm6+smi/4C2Nv85uiv/MNFx/zPTd/8303f/O9V6/z7WfP9C137/RdiA/0jZg/9L2oX/TtuI/1Hc + if9U3Yz/V96O/1rfj/9e4ZX/W9h8/0+6K/9utSv/j7pF/8bHef//1LD//9W0/+HMk/9VqhH/VcVF/3Pn + of916aT/eOur/2bYeP9Oshb/vsZy///XuP//1a///9Ww///Wsv//1bD//9Ww//nTqP9ltin/Z92F/3Ho + ov9v5p7/beWc/2vkm/9p5Jr/ZuOY/2Tilv9h4ZT/X+CT/1zgkf9Z34//Vt6N/1Tdi/9R3In/Td2N/0zF + Rv9DmAD/jqU////Rrf//0Kn//8+o///PqP//zqf//86n///Npv//zKX//8qk///Ko//+yKL//seg//7E + nv/+w5z//sGb//3Amf/9vpj//buV//24k/+8iHKbAAAAKQAAABEAAAAFAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/LtRDVwHy/O7gm/yfPbf8s0XP/MNFy/zTT + df841Hf/O9V6/z7WfP9B137/RNiA/0jZg/9L2oX/TtuH/1Hcif9T3Yv/Vt6P/1jbh/9JtR7/nbpO//vS + q///07L//9Sz///Tr//z0aP/b7Qq/1LGR/9v56L/b+eh/3HopP9g1W//UrMa/77Fc///1rf//9Su///W + sv/806z/5suY//7Urv//2r//28uM/1O2I/9p4pT/bOWd/2rkm/9p5Jn/Z+OY/2Xil/9i4pX/YOCT/13g + kf9b35D/WN6O/1XejP9T3Iv/UNyJ/03bh/9K3Yv/SstX/0ujBP9BigD/vrdr///Ssf//z6j//86n///O + p///zab//8yl///LpP//yqP//smi//7Hof/+xp///sOc//7CnP/+wJr//b6Y//28lv/9upP/vIhsmgAA + ACkAAAARAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAH6zM1YvwUL/ItF0/yrPbv8t0HD/MdJz/zTTdf841Hf/O9V6/z7Wff9B13//RNiA/0fZ + g/9K2oX/TduH/1DciP9T3o//UtNs/0KkAv+nr1b//9W4///SrP//0qv//9Oy/8fGd/9Pwj7/Z+Wd/2nl + nP9r5qD/YNd1/1iyG//NyH///9a3///Urf//1rT/6cua/3SdKf9JjQb/f6I0/6qzYf9rrSH/VcdM/2rm + n/9n45n/ZuOY/2Tilv9j4pX/YeGU/17gkv9c35D/Wd+P/1fejf9U3Yv/UtyK/0/biP9M24b/SdmE/0bZ + hP9F1Hb/TLUd/z+TAP+OpT///9Gv///OqP//zqf//82m///Mpf//y6X//8qk//7Jov/+yKH//sag//7F + nv/+w5z//sGa//2/mf/9vZf//bqU/76LbpgAAAAmAAAAEQAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAR64INEa1IP8oymD/JNBw/yvP + bf8u0HD/MdJ0/zTTdf831Hf/OtZ9/z3YgP9A2IP/Q9iA/0bYgv9J2YT/TNuG/0/ejv9Q0Wj/R6UG/16V + FP/yzJ3//9W1///TsP//1bn/tsRs/1TTbf9j5Jz/ZOOX/2Xjl/9GuCT/n7lR///Xu///06z//9Sy/+rL + mv9qpSD/P5wA/0eYAP9BjAD/PpcA/0u2IP9k343/ZeOZ/2Lilv9h4ZX/YOGT/17gkv9d4JD/W9+Q/1je + jf9V3Yz/U92K/1DciP9O24f/S9qF/0jZg/9G2YL/Qtd//z/Ygv9Cy1v/QqgF/5CoQf//0K3//86o///N + pv//zKb//8yl///KpP/+yaP//seh//7GoP/+xZ///sSd//7Bm//9v5n//b2X//u6lPy7iG2NAAAAIgAA + AA8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABNsBEBT68Nika1IP8pyl//JdBw/yrPbv8u0HD/MdJz/zPUef85zGD/PL0y/0DI + U/8/13//Qtd//0XZg/9H2ob/SNh//03Xev9NsRn/Qo4A/3edKv/UwoX/4saP/+PGk/+evVn/Utd1/17h + lv9g4pb/XtuD/0WrC/96oi7//9Ov///Vsv/60ar/ebIw/0a3IP9az17/Ubwv/02vE/9SvjP/XtqD/2Hj + mP9f4JP/XuCS/13gkv9b35D/Wt+P/1jejv9W3o3/U9yK/1Dcif9P24j/TNqG/0rZhP9H2YP/RdiB/0LX + f/8/1n3/PNZ8/zrUd/8/sRf/kaxB///Prf//zaf//8ym///Mpf//y6T//smj//7Iof/+x6D//sWf//7E + nf/+wpz//sCa//29mP/3uJLzrYBleAAAAB0AAAAMAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATq4Nd0iz + G/8ryFr/JNBx/yrPbv8s0XP/Msxi/1GzHf+fukr/YLQi/zzOZf8+2IH/Qtd9/0XBQP9Psxv/S788/0zA + Pf9MoAL/Q4oA/0qNAP9PjwT/T4wE/06iD/9X2n7/WuCT/1zhk/9a2oH/Ta4S/0ONAP+crE3//dSy/5O7 + Sf9Iuyv/Xt6M/2Hknf9f4JH/Xd6J/17gkv9e4ZX/XN+Q/1vfkP9a34//WN6O/1fejf9V3Yz/VN2L/1Hc + iv9P24j/TNuG/0vahP9I2YP/RtiC/0PYgP9B137/PtZ8/zvVev841Hn/NtN0/z6xGP+Rq0H//86s///M + pv//zKX//8uk//7Jo//+yKH//seg//7Fn//+xJ3//sKc//7Bmv/9vpj/7rGN45FrVV4AAAAaAAAACgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATq4Nc0iyGv8ryFr/JNBx/yjRcv83vDH/ortP///R + uP+PuUP/N8VH/znYhP9BwDv/gLYy/9rHiP9wtS7/Q8pX/0y7Lv9MpQf/SqAD/0mgBP9JnwD/TLUk/1Td + iv9V3o3/Vt6O/1jfjv9Quy7/SJgA/0WJAP+CqDT/U7gl/1fchv9b4ZX/Wt+P/1rgkf9a4JH/Wd+Q/1je + jv9Y3o7/Vt6N/1XdjP9U3Yv/U92K/1Hcif9P3Ij/TduH/0vahf9I2YP/R9mC/0TYgP9C137/P9Z9/z3W + e/861Xn/ONR4/zTTd/8z0XH/PrEY/5GrQP//zav//8yl///KpP/+yaP//sih//7HoP/+xZ///sSe//7D + nP/+wZv//r+Z/+GohspjSjtFAAAAFwAAAAgAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAATq4Nc0iyGv8qyFv/JM5q/0q0HP/ixon//8+x/5O6R/8zxEj/N9Jx/0KsCv+nslX//9W9/4W6 + P/89zFv/RdiA/0nLW/9Kylb/S8tY/0zKVv9N02//UNyK/1Hcif9S3Ir/VN+Q/1LTb/9NsRb/SJYA/0OQ + AP9NtyX/Vt2K/1bejv9W3Yz/Vt6M/1Xdi/9V3Yz/U92L/1Pdiv9S3In/UdyJ/0/ciP9O24f/TNuG/0va + hf9J2oT/R9mB/0TYgP9D13//QNd+/z3WfP881Xr/OdR4/zbTd/8003X/MdJ0/y/Qbv89sRf/kqtA///M + qv//yqT//smj//7Iof/+x6D//sWf//7Env/+w5z//sGb//7Amf/jq4nEIxoVLAAAABMAAAAHAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATq4Nc0e0Hf84uSn/erU18/7L + pf//zaz/lbpH/zDDRf84zGD/SqYJ/1GPB/+hq1D/brIq/z7LWv9A2YT/Q9qF/0Tah/9G24j/SNuK/0rb + iP9L2oX/TduG/07bhv9O24f/T96P/0/Rav9NsRb/SZgB/0uhBf9Pw0P/Ud2M/1Hdif9R3In/UNyJ/1Dc + iP9P24f/TtuH/03bh/9M24b/S9qF/0rahP9I2YP/R9mC/0TYgf9D137/Qdd9/z/WfP881Xv/OdV5/zjU + eP8103b/M9J0/zDRcv8t0XL/K89s/zywF/+Sqj///8up///Jo//+yKH//seg//7Fn//+xJ7//sOc//7B + m//9vpn82KKCoEc2KycAAAAOAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAATq8PTEGsAn6csFUs+Mapc/7LrOyzvV7/N7sv/zHPa/9MrxT/SZIA/0GQ + AP9KrRD/PtBq/zzXfv8+13//P9mE/0DZhP9C2YX/RdmC/0fZgv9I2YP/SdmE/0rahP9L2oX/S92M/0vQ + aP9NsRf/S54A/02tDf9N1nf/TdyJ/0zbhf9M2oX/S9qF/0vahf9K2oT/SdmD/0jZgv9G2YL/RdiB/0TY + gP9C13//QNd+/z7WfP871Xv/OtV5/zjUd/8203b/NNJ0/zHRc/8v0XH/LNBv/ynQb/8ozmn/O7AW/5Cp + Pv//yqj//8ii//7HoP/+xZ///sSe//7CnP/+wZr/8baS1rSIbVoAAAATAAAACAAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/8uoJ+jGj6RWsx//Lctg/znFTf9LsBX/S7AV/z7ESv811Xz/N9V8/zrPZ/85xEX/Qb84/0fE + Sf9B1Xn/QtiA/0PYf/9F2ID/RdiB/0bYgv9H2YL/R9uI/0jScP9Lvjf/Sr86/0jXff9I2oT/SNmD/0fZ + gv9H2YL/RtmB/0XYgf9E2ID/Q9iA/0LXf/9B137/P9Z9/z7WfP881Xv/OtV5/zfUeP8203b/NNN1/zLS + c/8w0XL/LdBw/yvQbv8oz23/Jc5s/yTNZ/88sRf/qLFU///Kqf/+xqD//sWf//7Enf/+wpz/+LyW7dej + gotEMykeAAAACwAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGaxIoBCtR3/LM1n/yzQ + bf8wz2v/LtR7/zLPav86vDL/V7Md/5O6SP+YtkX/TqwK/z7OZf8913//P9Z9/0DXff9A137/Qtd+/0LX + fv9D13//Q9mD/0PZgv9D2IL/Q9iB/0PXf/9D13//Q9d//0LXfv9B137/Qdd9/z/Wff8/1n3/PdZ7/zzV + e/871Xr/OdR5/zfUeP8203b/NNN1/zLSc/8w0XL/LtFx/yzQb/8pz27/J85s/yTOav8hzWn/Hstj/0e0 + H//cwYD//8ek//7Fnv/+w5z//MCa+eWujKaadV44AAAADQAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEquCIxGtSH/Lspe/yrPb/81xEv/R7MZ/5K5RP/myZX/+M2l/4W3 + Of8/uzD/N9R3/znUef861Xr/O9V6/zzVe/891nv/PtZ8/z7WfP8+1nz/PtZ9/z7Wff8/1nz/P9Z8/z7W + fP8+1nv/PdZ8/zzWe/881Xr/O9V6/zrVef851Hj/ONR3/zbTdv8103X/M9N1/zHRc/8v0XL/LtFw/yzQ + b/8qz27/KM9s/yXOav8jzWn/IMxn/xzNav8fxVL/W7Mf//TElv//xKD//MGb9+myj6y2i29DAAAADQAA + AAUAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2u + DnpMsRPlRrIY9VqwGdzJwXT3/82s///OsP+Xukv/NLoo/zHSdf8z03f/NdN1/zbTdv831Hf/N9R3/zjU + eP851Hj/OdR4/zrVef861Xn/OtV5/zrVef861Xn/OtV5/znUeP841Hn/N9V7/zXWff811Xr/NdN3/zTT + dv8z03T/MtJz/zHSc/8v0XH/LdBw/yvPb/8qz23/KM9s/ybOa/8kzWn/Icxo/x7LZv8azGj/Gspi/zS2 + If+juVH/+sGg6uexj523jXE9AAAACwAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE6wEA9HrgohZaMpCvrHozL9yqeL/sqk3IC3 + OP8ywUD/K9J1/y3Sdv8w0nP/MdJ0/zLSdP8z03T/NNJ0/zTTdf8003b/NdN2/zXTdf8103X/NdN1/zXT + df810nX/NNN3/zPTdv80ylv/NMNE/zPIVv8w0XH/LtN4/y7Rc/8t0XH/LNBv/yvQbv8pz23/J85s/yXN + a/8jzWn/Is1n/x/MZv8dzGb/F8xo/x7HWf86tiH/ZaUi1cieen+GZ1QqAAAACgAAAAMAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/zKsLlrlNVkKuCNlDuSn/NMdW/yrRcv8s0HD/L89s/y3S + dP8u0nT/MNFy/zDRcv8w0nL/MdJz/zDSc/8x0nP/MdFy/y/Tdf8xz23/Pbkr/2ezJv+OuUL/bbQq/0C2 + IP8ww0T/Ks5p/yfRc/8nz2//Js9r/yTOav8izWn/Icxo/x7MZ/8czGb/GMxo/xbLZf8nwUj/R7IZ/z6U + BZ0cJw0lAAAADgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAQq4HD06sDGVNrxLTQbov/0O5K/9Lsxz6Pr44/y3NZ/8p0XT/K9Bw/yzQb/8s0G//LNBv/yzQ + b/8r0XL/Lc5q/zq3If+Ntz3/8sqd///Nq//5yqD/xcBw/3u1Mv9GtBz/L786/yjKYP8gzmz/HM5t/xvN + av8cy2b/HMpi/x3IW/8owUj/O7gr/0yrEN9AjwtnAAAAEgAAAAkAAAADAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2wEBBNrAtbVa4TVGCo + ITRMqwigR7Qe/zPFT/8nzmv/JNBx/yXQcP8m0G//JNFy/yjNZ/8/tyT/jrc///vKpP//y6n//8qk///L + pv//y6v//8mk/9LCe/uHtTr0S7EX9zu6L/80vjz/Nrw3/z24K/9DtB/7SbAW8EyqD8NJoAx1LmgJGwAA + AAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNrQ5XTq8OzkS2JP84vj7/MMRP/yzG + Vv80wUb/Q7Ue/1KiE7DPrIJz6Lmabe++mWn0wZ1n9MGdafPAm2DxvppL7b2jObOnax5How0oTKwLaE+r + C4JOqgx/S6YMYEedDTo8iAwWDyMDBQAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABNsBAHTq0OT06tDJFNrxC7S68S0E2rDaxFoQtbAAAACQAAAAUAAAACAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP////////////////////////////////////////////AAAf//gA/////////////A + AAB//gAH////////////gAAAP/AAAB///////////wAAABAAAAAAAD////////4AAAAAAAAAAAAAP/// + ///8AAAAAAAAAAAAAAA//////AAAAAAAAAAAAAAAAP////gAAAAAAAAAAAAAAAAP///4AAAAAAAAAAAA + AAAAAH//8AAAAAAAAAAAAAAAAAAP//AAAAAAAAAAAAAAAAAAAf/wAAAAAAAAAAAAAAAAAAB/4AAAAAAA + AAAAAAAAAAAAH+AAAAAAAAAAAAAAAAAAAA/gAAAAAAAAAAAAAAAAAAAD4AAAAAAAAAAAAAAAAAAAA8AA + AAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAA + AAHAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAA + AAAAAAABwAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAAAAAAHwAAAAAAA + AAAAAAAAAAAAH8AAAAAAAAAAAAAAAAAAAH/AAAAAAAAAAAAAAAAAAAH/wAAAAAAAAAAAAAAAAAAA/8AA + AAAAAAAAAAAAAAAAAP/AAAAAAAAAAAAAAAAAAAB/wAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAA + AD/AAAAAAAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAAAAAAD+AAAAAAAAAAAAAAAAAAAA/gAAAAAAAAAAAA + AAAAAAAH4AAAAAAAAAAAAAAAAAAAB/AAAAAAAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAAAAAAD8AAAAAAA + AAAAAAAAAAAAA/gAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAD/gAAAAAAAAAAAAAAAAAAA/4A + AAAAAAAAAAAAAAAAAAP/AAAAAAAAAAAAAAAAAAAD/4AAAAAAAAAAAAAAAAAAA//AAAAAAAAAAAAAAAAA + AAP/wAAAAAAAAAAAAAAAAAAD/4AAAAAAAAAAAAAAAAAAA/+AAAAAAAAAAAAAAAAAAAP/gAAAAAAAAAAA + AAAAAAAD/4AAAAAAAAAAAAAAAAAAA/+AAAAAAAAAAAAAAAAAAAP/gAAAAAAAAAAAAAAAAAAD/wAAAAAA + AAAAAAAAAAAAA/8AAAAAAAAAAAAAAAAAAAP/AAAAAAAAAAAAAAAAAAAD/wAAAAAAAAAAAAAAAAAAA/8A + AAAAAAAAAAAAAAAAAAP/AAAAAAAAAAAAAAAAAAAD/wAAAAAAAAAAAAAAAAAAA/8AAAAAAAAAAAAAAAAA + AAP/AAAAAAAAAAAAAAAAAAAD/wAAAAAAAAAAAAAAAAAAA/8AAAAAAAAAAAAAAAAAAAP/AAAAAAAAAAAA + AAAAAAAD/wAAAAAAAAAAAAAAAAAAA/8AAAAAAAAAAAAAAAAAAAP/AAAAAAAAAAAAAAAAAAAD/wAAAAAA + AAAAAAAAAAAAA/+AAAAAAAAAAAAAAAAAAAP/gAAAAAAAAAAAAAAAAAAD/4AAAAAAAAAAAAAAAAAAB/+A + AAAAAAAAAAAAAAAAAAf/gAAAAAAAAAAAAAAAAAAH/4AAAAAAAAAAAAAAAAAAB//AAAAAAAAAAAAAAAAA + AAf/wAAAAAAAAAAAAAAAAAAP/8AAAAAAAAAAAAAAAAAAD//AAAAAAAAAAAAAAAAAAA//4AAAAAAAAAAA + AAAAAAAf/+AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAD//8AAAAAAAAAAAAAAAAAA///AAAAAA + AAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAH//+AAAAAAAAAAAAAAAAAB///wAAAAAAAAAAAAAAAAAf//4 + AAAAAAAAAAAAAAAAAP//+AAAAAAAAAAAAAAAAAD///wAAAAAAAAAAAAAAAAB///8AAAAAAAAAAAAAAAA + Af///gAAAAAAAAAAAAAAAAP///8AAAAAAAAAAAAAAAAH////AAAAAAAAAAAAAAAAB////4AAAAAAAAAA + AAAAAA/////AAAAAAAAAAAAAAAAf////wAAAAAAAAAAAAAAAH////+AAAAAAAAAAAAAAAD/////wAAAA + AAAAAAAAAAB/////+AAAAAAAAAAAAAAA//////4AAAAAAAAAAAAAA///////AAAAAAAAAAAAAAf///// + /4AAAAAAAAAAAAAP//////+AAAAAAAAAAAAAH///////gAAAAAAAAAAAAD///////+AAAAAAAAAAAAD/ + ///////wAAAAAAAAAAAB////////+AAAAAAAAAAAA/////////wAAAAAAAAAAAf////////+AAAAAAAA + AAAf/////////+AAAAAAAAAAP//////////4AAAAAAAAAP///////////AAAAAAAAAP///////////4A + AAAAAAAP////////////AAAAAAAAP/////////////gAAAAAAP/////////////+AAAAAAH///////// + /////4AAAAAH///////////////8AAAAP////////////////gA///////////////////////////// + ////////////////////////KAAAAGAAAADAAAAAAQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAB+fn4Bfn5+An5+fgN+fn4Dfn5+A35+fgN+fn4Dfn5+A35+fgN+fn4Dfn5+A35+fgEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfn5+An5+ + fgR+fn4Ffn5+BX5+fgN+fn4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAOjo6AgAAAAoAAAATAAAAGQAAABsAAAAbAAAAGwAAABsAAAAbAAAAGwAA + ABsAAAAbAAAAGQAAABIAAAAKKysrAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAACsrKwMAAAALAAAAFAAAAB4AAAAiAAAAIQAAABsAAAARAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAAAAGQAAADUAAABIAAAAVAAA + AFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAVQAAAEkAAAA0AAAAHQAAAAkAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAJAAAAEwAAACQAAAA3AAAASgAAAFwAAABiAAAAYgAA + AFcAAABCAAAAKQAAABQAAAANAAAACwAAAAgAAAAFAAAAAwAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAkAAAAfEhIRTCkoJ4cqKSiZLCsqoSwrK6IsKyuiLCsroiwrK6IsKyuiLCsroiwrKqMnJiWdERAQjAAA + AHgAAABmAAAASQAAACAAAAAKAAAAAwAAAAUAAAAIAAAACQAAAAcAAAAIAAAADQAAABoAAAArAAAAPQQG + DWIMFieODxwwqBEdM7QOGy6xChQjpQAAAIUAAABzAAAAXAAAAEIAAAA5AAAANAAAAC0AAAAoAAAAIgAA + ABsAAAAWAAAAEQAAAAsAAAAJAAAABgAAAAQAAAADAAAAAgAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABwgIBAYFBSA6ODd0aGVk0IuIh+6LiIfxd3Vz8nd1c/J8eXfye3h38nt4 + d/J7eHbye3h38nt4dvJ4dnTwbGlo5TExMLMBAQGLAAAAcwAAAEYAAAAkAAAAGAAAACEAAAAqAAAAKwAA + ACcAAAApAAAANAAAAEoECA1qESA3oh41W9okQG7xI0Z4+SNKfvolSXz3JEFw8xIiPMoBAgWaAAAAiQAA + AHoAAAB0AAAAcAAAAGoAAABjAAAAXAAAAFEAAABIAAAAPwAAADQAAAArAAAAIgAAABcAAAASAAAADgAA + AAsAAAAKAAAACQAAAAcAAAAGAAAABQAAAAQAAAADAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdXV0CCAgHGGhmY6GopKP55OPi//78 + /P/99vT/6OPh/6Cfnv+Fg4H/iYaE/4mHhf+Jh4X/iYeF/4mHhf+Jh4X/iYaE/4WCgPxUUVHQCwsLlwAA + AHQAAABYAwMDUgcHB2UCAgJuAAAAbgECAm0EBw15ChIgkxsxVM4kQW/1JkZ4/ydKfv8gU4z/G1iW/xta + mf8dW5r/JVyZ/ypQhf0wSWbqSF9f3UFVU9Q3SUfMKDU0wBkhILURGBesDRIRpQYICJsAAQGRAAAAiQAA + AH4AAAByAAAAZgAAAFQAAABGAAAAOwAAAC4AAAAmAAAAIAAAABsAAAAZAAAAFgAAABMAAAARAAAADwAA + AA0AAAALAAAACgAAAAcAAAAFAAAABAAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAADAwMNTk1Lc66tq/rw8fH+/Obh/fnCrv/5v6X9/MKp/+7Bsf2pnpn9h4aF/Y2Lif+Mi4n9jIuJ/Y6L + iP+Mi4n9jIuJ/Y2KiP+Gg4D5SkhHygAAAI4kIyObSUdGuFdVUshHRUPCJisvtRgpPsUeNVrcJEFw9idI + ev4pS33+K0yA/yZWj/0fXZz9H1+f/yFhof0gYqP9IGOl/yljov4tU4j+Tm1//2uMh/5oiof+Z4iF/WKC + f/hbeHbyU21r6kRaWOA1RUTTJTEwxxQcG7YDBASnAAAAnQAAAJAAAACEAAAAdwAAAGUAAABXAAAASwAA + AD0AAAA2AAAALwAAACoAAAAnAAAAJAAAACAAAAAdAAAAGgAAABYAAAAUAAAAEQAAAA0AAAALAAAACAAA + AAUAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmJgEsKylEi4mH2vL08//42M79+KyN/f3ZsP/97ML9/enA//zJ + ov3qo4j9mYeB/Y2NjP+Sj439ko6M/ZKOjv+Sjoz9ko6M/ZKPjf+QjYz+goB++FJQT9J3dXPvioeC+3V4 + gP5NXnf8Lkhw9ydGdvwoSXv+KkyA/ypPg/0tUof9LlaM/yRioP0kZaX9JmWm/yVmqP0laar9J2ms/yZs + sP0sZqX9MVN+/4Kenf2Bnpv9epiV/3STkP5ujYv+aYqH/2aIhf5khYL9YIB9+Vp2dPNIYF7nLz491g4U + FL8AAACwAAAAqAAAAJ0AAACRAAAAhAAAAHEAAABjAAAAWAAAAEwAAABEAAAAPwAAADoAAAA2AAAAMgAA + AC0AAAApAAAAJQAAACAAAAAcAAAAGAAAABMAAAAPAAAADAAAAAgAAAAFAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8ODhp+e3mu1tnZ//fY + zP/5r4r//uzC///70f//+M7///jO///80f//3rX/4Jh6/4eEhP+Vk5L/lpSS/5aUkv+VlJL/l5ST/5eV + k/+WlJL/joyK/4mGhP+Ni4r/UmJ8/yBBdv8jRnn/KEt//ytQhf8tU4n/L1aN/zBakf8yW5P/MGOf/yls + rv8rba//LG+y/yxus/8scbX/LXK3/ytyuf8wdrz/KlqZ/2+Hlv+etbL/m7Ox/5qysP+Ysa//lq6s/4yn + pf+EoJ7/eZeV/3CQjf9rjIn/aIuI/2aHhf1Wc3HyO05N4xceHs0KDg3DAAEBtwAAAKsAAACfAAAAkQAA + AIEAAAB0AAAAaQAAAF4AAABaAAAAVQAAAFAAAABMAAAARwAAAEEAAAA7AAAANgAAAC4AAAAoAAAAIwAA + ABwAAAAXAAAAEgAAAAwAAAAIAAAABQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAD89PEuoqKft7ern/viri//93bP9/fXM/f/zyP/99Mj9//PI//3zyP3+9sv9/dGn/aOD + eP+RkZD9mpiX/ZmYlf+amJb9mpiW/ZSSkP+Mioj9h4SC/ZaTkP9xeYf9Kkl5/SlOgv8sUob9LlOJ/S9Y + j/8vW5P9MV6X/zRhm/01Yp39MWur/y5ytv0ucrb9MHW6/y92uv0xdr39MHm//zB4wf0xfMP9NHS4/05o + h/2ZsK79m7Gx/5uxsf2bs7H9nLOy/520sv2cs7L9m7Kx/5WurP2LpaP9f5yZ/XKSj/9ri4j+aIqH/mB/ + fflNZmPuMkFB3xQbG8wCAgK/AAAAtgAAAKoAAACcAAAAjgAAAH4AAAB0AAAAbQAAAGgAAABkAAAAYAAA + AFwAAABXAAAAUgAAAEsAAABFAAAAPgAAADUAAAAuAAAAJwAAAB4AAAAYAAAAEQAAAAsAAAAHAAAAAwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH17d5rMzc7/88W3//3Blv//88f///DE///x + xf//78X///HF///vxf//8cb///PH/9Kghf+QiYj/npya/5+cm/+em5r/kI2L/4aDgf+EgoD/jImH/5ya + mv9OYYD/KE6C/y9Xjf8wWpD/MF2V/zNfmP8zY53/Nmaf/zZppf84aqj/NXS1/zN5vv81ecD/NHrC/zZ9 + wv82fsT/Nn7H/zZ/x/81gMr/OoPL/0Fhiv+RqKr/nbWz/5uzsf+bs7H/nbWz/5yzsf+cs7H/nbWz/520 + s/+dtLL/nLOx/5evrv+Pqaf/gp6c/2+PjP9niYb/ZIWC/Vp2c/ZCWFbpHScm1QAAAMIAAAC6AAAAsQAA + AKIAAACTAAAAhwAAAHwAAAB1AAAAcQAAAG8AAABsAAAAaAAAAGQAAABfAAAAWQAAAFIAAABLAAAAQwAA + ADcAAAAvAAAAJgAAABsAAAAUAAAADQAAAAYAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaWhnDpeW + levl2NT++KmJ/f/rvf/97cD9/e2+/f/twP/97b79/+3A//3tvv397L79/u7B/e/Sqf+hjIL9nZyb/aSh + oP+TkY/9iIWD/ZKPjf+LiIb9m5mX/ZaYnP85Vn/9LlmR/TNgmf80Yp39NGSg/ThppP85aqj9Om6s/zpx + sP09c7L9Onu//zqAx/05gsn9O4PL/zmEzP05hc79O4bO/zuI0f06h9H9QI3Y/ztjlf2JnqT9oLa1/5+2 + tP2ftrT9n7a0/5+2tP2ftrT9n7a0/5+2tP2dtLT9nrW0/Z61tP+etbP9n7W0/Zyysf+Qqaj9fpqY/m6O + i/9piof+aYqH/lJsafIoNDPcDBAPzQAAAL8AAAC1AAAAqQAAAJoAAACMAAAAhAAAAH4AAAB8AAAAegAA + AHcAAAB0AAAAcQAAAGwAAABmAAAAYQAAAFgAAABQAAAARgAAADoAAAAtAAAAIQAAABQAAAALAAAABQAA + AAEAAAAAAAAAAAAAAAAAAAAAcnBuRrKysf/vyb7++rqS/f/uwP/96Lr9/ei6/f/ovP/96Lr9/+i8//3o + uv3+6Lv+/um7/frjt/+4nYr9nJmZ/aakov+Sj479lpKQ/ZqXlv+QjYv9p6Si/ZKWnv8zVYX9MmKd/Tdo + o/84aKX9OW2q/Ttvrv88c7D9PHS1/z94uf1Aebv9QIHE/z2Hz/0/iNH9PonR/z+K0v0+i9X9QIzX/0CM + 2P0+jdj9RJXh/zllm/2Fm6P9ori2/5+1tP2gt7X9oLe1/6C3tf2gt7X9oLe1/6C3tf2gtbX+nra1/Z+2 + tf+ftrP9nbS0/Z61sv+etbT9nLOy/ZOsqv+FoJ79dZOQ/WiKh/9khIH8UWpo8ScyMdsKDQzKAAAAvgAA + ALMAAACmAAAAmQAAAI4AAACHAAAAggAAAH4AAAB9AAAAewAAAHkAAAB2AAAAcgAAAGwAAABmAAAAXwAA + AFQAAABIAAAAOgAAACcAAAAYAAAADQAAAAQAAAAAAAAAAAAAAAAAAAAAVVNRfcrHxv/zu6b9/c+i/f/n + uf/95rb9/ea2/f/muP/95rb9/+a4//3mtv395rf9/ea3/f/mtv/OspX9mZWT/aeko/+XlJL9oZ+e/aKg + n/+TkY/9sK6r/ZOYov8yVon9Nmqm/TpvrP86cLD9O3Oy/T54uP8+ebv9QX29/0J+wP1BgMT9RIXK/0KN + 1v1Cjdf9RI7a/0SP2/1EkNr9Q5Hc/0OT3f1Dkt/9SJnn/zxnm/2Kn6X9o7m3/6C2tf2gtrb9oLi1/6C2 + tf2gtrX9oLi1/6C2tf2gtrX9obe1/Z+2tv+ft7T9oLW1/Z62s/+ftLP9nrW0/Z61s/+cs7L9mbCu/Yej + oP9zko/+Z4mF/mKBfvtPZ2XwJC8u2QAAAMQAAAC7AAAAsgAAAKcAAACdAAAAkgAAAIgAAACBAAAAfgAA + AH4AAAB9AAAAewAAAHkAAAB1AAAAcQAAAGkAAABfAAAAUgAAADwAAAApAAAAFwAAAAgAAAABAAAAAAAA + AACurawIeXZ0tt3V0f/3s5P//tmq///is///4rP//+Kz///hsv//4rP//+Gy///is///4rP//+Gz///j + s//ix6H/mpON/6Wjov+em5r/rqyr/66rqv+YlpT/t7a0/56jq/83XI7/O3Gx/z53t/8/erv/QXy+/0J/ + wv9DgsX/Q4TJ/0aHzP9Hic//SIrR/0iT3f9JleD/SZbi/0mX4/9JmOT/SZnm/0ma5v9Imej/TJzr/0Bj + kP+Uq63/pLq4/6K4uP+jubb/o7m4/6O5uP+jubj/o7m4/6O5uP+jubj/o7e4/6O5tv+it7f/ori3/6G4 + tv+gt7b/nrW0/5+2tf+etbT/nbSz/561s/+csrH/jqim/3STkP9pi4j/aYuI/0xlY+8VICzbBgoUzwEC + BMQAAAC7AAAAsQAAAJ4AAACPAAAAhAAAAH8AAAB/AAAAfwAAAH4AAAB9AAAAfAAAAHkAAAByAAAAaAAA + AFIAAAA7AAAAIwAAAA0AAAADAAAAAAAAAAC4t7UeiomHz+XRy//4s439/tuq/f/fr//93a39/d2t/f/f + r//93a39/9+v//3drf393a79/d2t/f/gr//w0aX9oZWL/aOhof+lo6L9uLa1/bi2tf+dmpn9ube2/bGz + t/9BYpD9PHa3/UF+wP9Cf8P9QoPF/UWGyv9GiM39RonP/0mN1P1Kj9f9SZDY/0yU4P1Nmub9TZzo/02b + 6f1Nnen9TZ7q/0yd6/1OofD9R5Hf/1Bri/2lurn9p7y7/6W7uf2kurn9o7m4/6O4t/2juLf9pLq5/6S6 + t/2iurf9ori3/aK4uP+jubj9o7e2/aK3t/+guLX9oba2/aC3tP+ftrP9nrW0/Zyzsv+dtLH9nLSy/Zau + rf+HoqD9c5KP/WiJhv9NbXz9Iz5m9hQnROcHEBzTAAABwwAAALUAAACiAAAAjgAAAIEAAAB+AAAAfwAA + AH8AAAB+AAAAfgAAAHwAAAB4AAAAbgAAAFoAAABBAAAAKAAAAA8AAAAEAAAAAAAAAAC6t7Yzl5aW2+nL + wf/7to39/tqp/f/bqv/926j9/duo/f/aqv/926j9/9qq//3bqP3926j9/dqo/f/cqv/616f9qJqK/aKg + of+sqqn9wsDA/cTCwf+joaD9ube2/cfGyP9TbZP9O3e4/USFyf9Ehcr9RYjN/UiM0f9IjdT9So/X/0qT + 3P1Lk939TpXg/0+Y4/1Rnuv9UaHu/1Gg7v1RovH9UKPw/1Ci8f1UqPf9N3Cz/1Buev1/npn9iqaj/5uz + sf2mu7n9qb++/6m9vP2mu7v9pbu6/6W5uf2lubj9o7m5/aS6uf+kurf9ori3/aO5uP+ht7b9ori3/aC4 + tf+ft7b9nrW1/Z22s/+ctbP9m7Ox/Zyzsf+asrD9lq2s/X6bmP9piob9P2N9/htDeP4ZQGz3DSM64QAA + AMMAAAC0AAAAnAAAAIYAAAB/AAAAfwAAAH4AAAB9AAAAfAAAAHgAAABzAAAAaQAAAFUAAAA+AAAAJQAA + AA4AAAAEAAAAAAAAAAC7ubhGoaKj5O3Bsv/8vI7//9im///XpP//2KT//9il///YpP//2KX//9ik///Y + pf//2KX//9il///Ypf//2KT/tKCL/6SjpP+zsbD/zszL/9LR0P+1s7L/rauq/93c2/+Dj6X/OGyp/0mN + 1v9JjtT/SpDY/0yR3f9Nld//TJXh/0+Z5P9Qm+f/T5vq/1Cf6v9Tou7/VKPz/1Wm9v9Vp/f/Vqj5/1Wp + +v9FiM//N1qB/1Z8dv9NdXH/SnJu/0lybv9TeXX/Y4eD/36cmf+Rqqn/n7a1/6a7uv+nvLv/p7y6/6S6 + uf+kurr/pbu6/6W5uf+iurf/o7i4/6O5uP+iuLf/obi1/6C3tv+ftrP/nrWy/520s/+cs7D/m7Kx/5ux + sP+KpaL/cJCN/yBUgf8TTYL/E1KG/wYkO98AAADAAAAArwAAAJMAAACDAAAAeQAAAHYAAAByAAAAbgAA + AGgAAABhAAAAVQAAAEIAAAAvAAAAGgAAAAoAAAACAAAAAAAAAAC8u7pSpqqq6u26p//9wZj9/dqv/f/Y + qv/91KL9/dOg/f/UoP/91KD9/9Sg//3UoP391KD9/dSg/f/UoP//1aH9vKWL/aemqP+3trT91tXU/dzb + 2v/Ny8r9npyb/eXk4v++wsj9PmGP/UmQ2f9MlN79TZTe/U+Y4/9OmOT9UJro/1Ge6f1Qnuv9UaDu/1Oj + 8v1VpvX9Vqr6/1aq+v1Up/j9UJ/t/0B+w/08YIv9Z4SL/3uZlf14lpT9dpWS/3CQjf1miIX9W4F8/1F4 + dP1QdnP9WX98/3GRj/2PqKb9o7m3/aq/vP+nvbv9pbq5/aS7uv+jubj9pLq5/aK6t/+jt7j9ore3/aG4 + tf+gt7T9n7a1/Z61sv+btLL9nLOw/Zmwr/+ZsK/9layo/VB+kv8LU4j9DFWK/gpIc/MHDhLKAAAAuQAA + AKIAAACKAAAAdgAAAGYAAABgAAAAWgAAAFIAAABIAAAAPQAAACsAAAAcAAAADwAAAAUAAAAAAAAAAAAA + AAC+vLtbq66w7u21oP/9wpr9/tqx/f3ZsP/+1ar9/tCf/f3Pn//+0J/9/dCf//7Qn/3+0J/9/tCf/f3P + n///05/9w6mL/aepq/+wraz929va/eXk4//m5eX9paOg/dDPzv/v7e39hJGo/S9oqv9QnOf9T5vn/VCd + 6f9Rnuv9U6Hu/1Oj8/1VqPf9Vqr7/1Sm9v1Nmuf9Q4bQ/zlxs/00Y539N16O/0tqhP1tio79e5mW/3yb + l/1/nJr9gZ6b/4Ofnf2Dnp39gp6c/36bmf11lZL9Z4mG/1N6dv1MdXH9W4F8/YGenP+dtbP9rL+9/ai9 + vP+mu7r9pbm4/aO5uf+iuLf9o7m2/aG3t/+htrb9oLe0/Z+2s/+es7P9m7Ky/Zuxsf+Ysa79mbCu/YOj + qP8bZZP9AVmR/glcj/0xVmHpDREPwgAAAKwAAACWAAAAeQAAAFoAAABJAAAAPwAAADUAAAAsAAAAJAAA + ABcAAAAOAAAABwAAAAIAAAAAAAAAAAAAAAC+vbxcqa2v7u+vmP/9xJv//tav//7Vrf/+1a7//tKn//7M + mv/+y5r//syb//7Mmv/+zJr//sya//3Lmv//zZv/wqaK/7Cxs/+rqKf/ubi3//T09f/29fX/4+Hh/6Kg + nv/t7Ov/+fj2/2l9nv84b6//S5fk/0+f7P9Mmuj/SpTg/0aJ0P8/ebn/OWmh/zZdiP88XHn/SGd5/1x4 + gf9riov/eJWT/3+dmP9+m5n/fpua/4KenP+DoJ7/haGf/4aioP+HoqH/h6Oh/4ejof+Io6H/iaSi/4mj + ov96mJb/ZIeE/0t0cP9Lc2//YISC/4ulo/+ftrX/p726/6a8u/+ju7j/pLq3/6S5uP+ht7f/obi1/6C3 + tv+dtrP/nrWz/520sv+bsa//mbGv/5ewrf9Eg6D/AF6U/wFelv82do//X3x59BYeHb0AAQGhAAAAiAAA + AF4AAAA9AAAAJwAAABkAAAATAAAADQAAAAcAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAC+vLtcp6us7uyv + mP/9w5v9/NWw/f7Vrv/80679/NSv/f7Oo//8x5j9/seW//zImP38yJj9/MiY/f7HmP//yZj9wqSI/bS0 + tv/Ixsb9nZmY/dLR0P/5+fn9/f39/bi2tf+/vbz9+vr6/ejq7v+Il7L9THOj/UZ1rf9Td6X9T2eM/0Bg + dv1EZnX9T3F3/11/f/1pioj9cZOO/3aWkv15l5T9fJmX/32amP2BnJr9g5+d/4Whn/2FoqD9iKKg/4mk + of2KpaP9iaWk/4ulov2LpaL9iaSi/4mlo/2KpKP9iKSi/YGcmv9wkI39Wn98/U51cf9cgX79fJmY/Z21 + s/+ovbz9pbu6/aO5t/+jubb9ore3/aG2tf+etbX9n7S0/Zyzs/+as7D9mbCw/Zuxr/9qlqb9C2CU/QBc + lP8jao/9ZIiG/ll1c+0hLSy7AQIClQAAAHMAAABKAAAAJgAAAA4AAAAGAAAAAwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC/vLtao6em7eiwm//9v5z9/NWz/f7Vs//807P9/NOz/f7Usv/8z6n9/Maa//3C + k/39w5P9/cOU/fzFlP//xZX9v6CG/bi5u//X1dX9ysjH/ZyamP+urKv9ysnH/bu5uP+OjIr9vLm4/fT0 + 8v/s6uv9z9DV/b/DzP+0srX9e4GA/1Z8d/1dgn79ZIeC/2qMiP1vkI39cpKR/3iVk/16mpf9f5qa/4Cc + mv2EoJ79hqKg/4iioP2Io6H9i6ak/4ylpf2Np6T9jqam/46mpv2Opqb9jqem/42lpP2LpqP9i6Si/Yql + o/+Io6H9haCe/XeWk/9eg4D9SnNv/Vd7eP9/nJr9o7m5/ai8u/+kurj9orm2/aK4t/+ft7T9nra1/Z61 + sv+btLL9m7Gx/ZqxsP+JqKv9HGmW/QBZkf8XZJP9Z42R/WiIhf5cenfwIi0stAAAAIYAAABoAAAAPQAA + ABMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC9vLpMm5yd5+Kxn//8vZz//ta4//7W + tv/+1rf//ta3//7Wtv/+1rj//tW2//zOqv/9x5///cOZ//zAk//+wJD/tpqE/8TFx//a2dj/2djX/9fW + 1f+9u7r/qaem/6yqqP+8urn/nJmY/5GQjv+ysK//ube2/5+fm/9yfnz/V3p2/1qAff9hhYL/ZYiF/22N + i/9zk5D/eJWU/3yamP9/m5n/gZ2d/4ahn/+IoaH/iKSj/4ympP+Np6X/jqim/4+pp/+QqKj/kaqo/5Gq + qP+Rqqj/kaqo/5CpqP+Pp6f/jqim/42npf+LpKT/iaSi/4ijof+HoqD/gJ2b/2KFgv9Kcm7/UXh0/4Sh + n/+gt7X/pbq5/6K4uP+guLX/obe0/5+2tf+cs7P/nLOw/5uysf+bsq//Q36b/wBVjv8HWo//aJKh/3yZ + lv9piYb/ZoeE+SEtLLAAAQGHAAAAZwAAADMAAAASAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAC9u7pAlJWU4dmxo//6uJn9/de8/f7XvP/81br9/NW6/f7XvP/81br9/te8//zXvP391rv9/NS3/f7Q + r//8xZ79rZSE/c/P0f/d3Nz929rZ/d3c2//e3dz93Nzc/d7d3P/h4OD9rquq/VZwbP9geHT9Znt3/Vx3 + dP9TeHX9Vnx4/1+DgP1liIX9a42K/3GRjv12lZP9e5mX/4Cdm/2Dn579hqGg/4mjof2KpaP9jKaj/42m + pf2Op6b9j6io/5Gpqf2Sq6j9kauq/5Gqqv2Rqqr9k6qq/5KrqP2Rqqn9kKio/Y+npf+Mp6T9jKak/Yqj + of+GoZ/9haGf/YKenP91lJH9XoJ//Ux0b/9kh4P9j6mn/aa8u/+jubb9oLa2/aC1tf+etbL9m7Ky/Zmx + sf+ds7D9Z5Kj/QBTjP8EVYz9SX6a/Zarp/94lpT9aYuH/lp4de0cJiWsAAAAhAAAAFgAAAAsAAAADQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+vbwtjY2M186wpf/5s5T9/de+/fzXwP/82L/9/Ni//fzX + v//82L/9/Ne///zXv/382L/9/NjA/f3Zwf/20bj9pZiP/dzc3P/g4N/9397f/d/e3v/f3t79397f/d/g + 3v/g39/9op+e/Uxybv9QeXX9UXh0/VF6dv9Ue3f9Wn97/16Cf/1egn/9X4OA/16Cf/1gg4D9YoWC/2qM + if1wkI39d5aT/4Kenf2KpaP9j6mn/5Ssq/2TrKr9k6uq/5Osqv2UrKv9lKuq/5Otqv2Trar9k62q/5Sr + q/2TrKv9kquo/ZGqqf+Pqab9jKam/YympP+KpKL9h6Kf/YSgnv+BnZv9fJqX/WuNif9Rd3P9THRw/YCe + nP+kubj9o7i3/Z+2tP+dtrT9nbOz/ZqysP+cs7D9hqSq/QdXjP8EVIr9Lm2T/ZatqP+MpqT9d5SS/meI + hf1Ub2zkDxQToAAAAHgAAABNAAAAIgAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+vbwShYKBxb+u + p//xqpD//tbB//7bxv/+2cb//tnG//7Zxv/+2cb//tnG//7Zxv/+2cb//tnG//7cx//nyLX/pp2Y/+bm + 5f/l4+T/5eTi/+Xl5P/l5OL/5eTi/+bl5f/f3dz/kJGQ/093c/9Tenb/Unl1/053cv9MdHD/SnJv/0py + bv9NdHH/T3Zz/1J4dv9UeXf/U3l3/1B3dP9OdnP/THVx/0lybv9LdHD/VXp3/2GFgv9xkY7/gZ6b/46n + pv+UrKr/lq6t/5iwrv+Xr63/la2t/5aurf+VrKz/lK2r/5Osq/+Qqan/kKmo/46opv+MpqT/iaKi/4ai + oP+Bn53/f5ya/3yZl/93lZP/YoWC/0Zva/9ihYL/lK2s/6O5uP+gtbT/nLWy/5y0s/+bs7H/nLOv/yBi + j/8GUoj/E1mL/4ynp/+Qqab/jKak/3KSj/9oiYb/VnFv5AUHBpQAAAB0AAAARwAAABZiYmIDAAAAAAAA + AAAAAAAAAAAAAAAAAAC/vbwBf3x6o66mo//mpIz9/dK9/f7ezP/83Mr9/N3K/f7dzP/83cr9/t3M//zd + yv383cr9/NzK/f7ezP/Yuqv9rqmn/e7t7f/o5+f96ejm/enn6P/p6Ob96Ofm/erq6f/Y1dX9foeF/U54 + dP9Pd3P9SXJu/Utyb/9YfXv9ZoaH/3GRkv13lZb9e5ia/36bnP2AnJ79gJ2e/36bnP19mpv9fJqb/2aI + hv1egn79YIOA/1V7d/1Qd3P9TnZy/1V7d/1ihoL9dJKR/4iiof2UrKv9mrCv/5iwr/2Vraz9lK6r/ZWr + rP+Tq6n9kaqp/Y6pqP+Np6T9i6Oi/Yajov+EoZ/9gZ6c/X2Zl/95l5X9dJSR/WOHg/9NdHD9VXx3/ZGq + qf+ht7b9n7Sy/Zu0sf+asrD9oLax/TpylP8IT4b9C1GH/Xubov+Sqqf9jael/YWhn/9vj4z9aYqH/zdJ + SMYCAgKKAAAAZgAAAC0AAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlZKRb56cmv/Wnov9/cex/f7i + 0//839D9/N/Q/f7f0P/839D9/t/Q//zf0P3839D9/N/Q/f7g0f/Hqp39wb+9/fHw8P/s6+v97Ovr/ezt + 7f/s6+v97Ovr/e7t7f/Lycj9b4B9/Ul0cP9Gb2v9VHl3/XKSkv98mZv9gJye/4Gdn/2BnZ/9gp6g/4Ke + oP2DnZ/9hJ+h/4Sgov2FoaP9hqGj/2yMiv1xkY79fZqY/3qYlf12lJH9b5CM/2OFgv1We3j9THVx/0x0 + cf1Zfnv9cZCP/42opv2ZsbD9mLCv/ZaurP+Uq6v9kaqq/ZGqp/+NqKf9jaal/Yiko/+GoqD9g5+c/X2a + mv96mJb9dZWS/W+Qjf9liIT9TnVy/VR7dv+Qq6n9oLa1/Zyzs/+asrD9n7ax/VWCmv8NUIX9CE2E/WWM + nf+UrKj9jKim/Yulo/9/nJr9aoqI/l58evEdJyasAAAAfgAAAEkAAAAcAAAABAAAAAAAAAAAAAAAAAAA + AAAAAAAAnZqZKY6Njf26nJP/9KuP//7p3v/+5Nj//uXZ//7l2f/+5dn//uXZ//7l2f/+5dn//uXZ//TY + y/+zm5L/29vb//Py8v/y8fH/8vHx//Ly8v/y8fH/8vHx//Hw8P+urq3/WXVy/0lxbv9miYj/gZ6f/4Ge + n/+BnZ//gJ6e/4KdoP+Bn5//gp6h/4Sgov+Dn6L/hKGj/4Wiov+Io6T/hKCg/2eIhf94lpP/g6Cd/4Gc + m/9/nJr/fpuZ/32amP97mZf/eZaT/2yNif9cgX3/THVx/0lxbf9egn//fJqX/5Cqqf+Wraz/lK2s/5Gr + qv+QqKj/jqim/4ukov+Go6H/hKCf/4Cbmf98mZf/d5aU/3CQj/9sjYr/ZomF/052cv9dgn7/la6s/561 + tP+bsrH/nrOx/3KWo/8TUoT/DEyC/0x5lP+Sq6j/jqim/4qmpP+JpKL/epiV/2iJhv9Ra2nhDRAQmgAA + AGkAAAA2AAAADwAAAAAAAAAAAAAAAAAAAAAAAAAA0M/PAYSCgdKhmpj+4Zd8/f7d0P/86uH9/One/f7p + 3//86d/9/unf//zp3/386N79/u3j/eW9rv+wopz97u7v/fb29v/29PT99vT0/fb29v/29PT99vb2/ezr + 6/+MkpD9SW5p/WeJiP+BnJ79gJ6f/YKdoP+BnaD9g5+f/4Keof2EoKD9haGi/4Sgof2HoqL9hqOj/4ei + pf2Kpab9gp6e/2eIhf1+m5j9iKOh/4agn/2EoJz9gZ2c/3+bmf19mpj9fZqY/3uZl/15l5T9dJOQ/2iK + h/1WfHn9S3Rv/Vh9ev9ykI/9iqWj/ZWsq/+Rqqn9j6em/Yympf+HoqL9haGf/YGcmv99mpj9eJeT/XOR + kP9tjov9Z4mG/V6Cf/9Lc2/9YIOA/Zy0sv+dtLP9m7Ox/YCfp/8eV4b9D0uA/Tprjf+Qqaf9j6im/Yym + pP+JpKL9haGf/W2Niv9mh4P6Ljw7vAAAAHsAAABPAAAAHjw8PAIAAAAAAAAAAAAAAAAAAAAAAAAAAH98 + en+SkpH/upWI//+4n//+7eX//uzk//7s4//+6+P//uzj//7q4//+7eT//+zi/8aVhP/CwL//+/r7//r6 + +v/6+vr/+vr6//r6+v/6+vr//f39/9TS0v9neXb/Unh2/4KeoP+CnqD/g52f/4Keof+EoKD/g5+i/4Sh + o/+FoKL/hqGk/4ijo/+IpKX/iqOm/4qmpv+Np6n/gJ2c/2iIhf+FoJ7/jaem/4mlov+HoqD/h6Gg/4Wh + nf+Dn53/gJya/36cmP98mZj/fJmX/3qXlf92lJL/bo6L/1p/fP9Lc2//T3Zy/3WUkf+Pqaf/kaqp/4yn + pP+Jo6P/hqKg/4Kdm/9+m5n/eZaV/3KTkf9uj4z/aIqH/2CFgf9Ve3f/RG5q/3OTkP+dtLP/nLOx/4yn + q/8sXoj/EUp+/zBgiP+IpKX/kKqn/4ulo/+KpKL/h6Kg/3qYlv9oiof/Wnd16gAAAIoAAABkAAAAMQoK + CggAAAAAAAAAAAAAAAAAAAAAAAAAAJaUkiiHhILVlJWV/tiUfP/9yLX9/uvk/f7r5P/86+P9/uvj//7s + 5P3+6uD99LSe/Z+RjP/p6+z9+/v7/fv7+//7+/v9+/v7/fv7+//8/Pz9/Pv7/ZOVk/9QcW39cZKS/YSg + ov+DoKD9hZ+i/YSho/+FoqL9h6Gk/4ijo/2JpKX9iqWm/4mkpf2Mpab9jKen/42nqP2Qqar9fpua/2uL + iP2MpqT9kqup/46opv2OqKb9jKel/4qjo/2Ho6D9h6Kg/4OfnP2Bn5v9gZ6b/3+amv17mpj9e5iW/XqY + lf90k5D9YoaB/Ulxbf9QeHT9cpKQ/Yumpf+KpaP9h6Kg/YGfnf9+mpn9epiU/XOUkf9vj4z9aYqH/WGF + gf9Zfnr9UHh0/UhxbP98mpf9nLSy/ZStrf89aYz9FUl9/SdXg/9/nKH9kKqo/Yulo/+IpKL9h6Kg/YKf + nf9vj4z9aYuI/yo3NrMAAAB4AAAASQAAABJ+fn4BAAAAAAAAAAAAAAAAAAAAAPLy8gefnZtyiYeF8KGP + iv/UmYT9+cOu/f7g1f/+6eL9/ujh//7Yyf3wt6L9t4h4/cLDxP/w8PD98O/v/fDv7//u7+/97+/v/fDv + 7//w7+/9xMPD/Wp8ef9af3v9gJ2e/Yaho/+FoKL9hqGk/Ymipf+IpKT9iaOk/4ukp/2Lpab9jKan/42n + qf2QqKr9kKmq/5Oqrf2UrK39epiW/26Oi/2TrKr9lq+t/5Ssqv2RrKr9j6mp/4+ppf2MpqT9iqak/4qj + of2Io6H9haKe/4Sgnv2CnZv9fp2Z/X6al/98mpf9e5iW/XGQjv9egn/9Unl1/V+CgP91lJL9hKCe/YSf + nv99mpj9epiW/XWUkf9vjov9aYmH/WKFgf9YfXn9U3p2/Utzb/9Uenb9i6ak/Zqxsf9NdJH9GEh8/SJQ + f/93lZ79kaqo/Y2npf+Ko6H9hqGf/YSgnv94lpT9aYqH/ktjYdoGCAiIAAAAVgAAABp/f38DAAAAAAAA + AAAAAAAAAAAAAAAAAADy8vEMmJWTm4iHhf+Ti4j/tY5//+qdgv/6rpT/+quP/9mWff+fg3n/qaWk/+Tk + 4//i4eH/4uHg/+Lh4P/i4eD/4eLg/+Xk4//CwsH/nJOL/22Lhf9wkY//hqGj/4ijpf+JpKT/iaWm/4ym + p/+Lp6j/jqin/42nqP+Qqan/kams/5Gsq/+Ura3/lq6u/5avrv+YsLD/eJaU/3KSkP+asrD/nLSy/5iy + sP+Yr63/lq+t/5Otqv+Tqqr/kamp/4+pp/+MpqT/jKWi/4ilo/+Io6H/hqCf/4KgnP+Cnpz/f5uZ/3+b + mP98mZf/eJWT/12Cf/9Kcm7/XIF+/4GdnP+AnZr/epeW/3WUkP9vkI3/aYuI/2KFgP9Yf3v/Unl1/1J5 + df9IcGz/XoJ//5+0s/9fgZf/HUl6/yFLe/9sjJr/kqqn/4ympf+LpaP/iKOh/4Sgnv9/nJn/bI2K/157 + efAcJiWeAAAAXgAAAB9+fn4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7a1BYF+fLaFgoH4hIWF/oeF + hP+Rg3/9kIV//4SFhf2mpqX92NbW/drZ2P/a2dj92tnY/drZ2P/Z2Nf919XV/bW1s/+nl4z988ah/Zue + j/9sj4/9iaSk/Yump/+Lpab9jqan/Y+pqP+QqKr9kamr/5GrrP2UrK39la2u/5Wtr/2YsLD9mLCw/5yz + s/2bs7P9dJSS/3eVkv2htrX9oLe1/560tP2dtLL9m7Ox/5mxsP2YsK79lq+t/5Stqv2SrKr9kaup/4+p + p/2Lp6X9i6Si/Ymkov+HoZ/9hqGf/YKenf+Anpr9gJya/YCbmf9xkI79T3dz/U93c/9ykY79eZiV/XSS + kf9tj4v9aYqH/WGEgf9XfHn9Unl1/VN6dv9Qd3P9RG1p/Ymkof9vjZ39IUl6/SFJef9mhZb9kaqn/Y2n + pf+Jo6H9iKOh/YOenv+Cnpv9cpGP/mKCf/UmMzKrAAAAYQAAACJ/f38FAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAK+urR9+fXyKg4B/5YKAf/9/f3/9fX5+/5mYl/22trb9urq6/bq5uv+4ubn9uLm5/bq5 + uf+0srL9p6Of/bagjv/rv539/9Cm/ZygkP9oi4v9iqWl/Y6oqf+Oqar9kaqr/ZGqrP+TrKv9k6ys/5au + r/2Wrq79ma+v/5mysv2csrL9nrW1/6C2tv2gtrb9dpWT/3eWk/2lurj9pLq4/6K3t/2ft7T9n7az/52z + s/2as7D9mrKv/5ivr/2Vr6z9la6s/5Ksqf2Rqaf9j6mn/Y2mpP+KpqT9iqOh/Yijn/+GoJ/9g6Ce/YGd + m/+BnZv9epiV/VJ4dP9NdHH9aYqI/XSTkf9sjYz9aIqH/WGEgf9XfHj9Unl1/VN6dv9SeXX9Rm9r/WyN + iP95k5/9Jkh3/SJEdf9hgZf9kayp/YympP+Jo6H9iKOh/YOenv+Cnpv9d5WS/mOEgfcqNzaxAAAAYwAA + ACN/f38FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5e3wNonZjqMeYgv+6lYL/uJWD/72b + if+9nIr/vJ2L/7yfjP+8n43/vaCO/72hj//HqJL/4LaY//jJov//zKX//9Cn/6Gjkf9kiIb/iKOj/5Kr + rP+TrKv/k6yu/5aur/+Vrq7/mLGx/5qwsP+as7P/nbS0/520tP+ft7f/obm3/6S6uv+lurn/d5aU/3iX + k/+ovbv/qL28/6a6uf+jurn/o7m4/6C2tf+gtbX/nbW0/5u0sf+bsbH/mLGu/5iurv+Urqz/kqup/5Cr + qf+QqKb/jaim/4unpf+LpaL/iaKi/4ein/+FoZ//gJ2a/2aIhf9Tenf/SHFu/2mKh/9tjoz/Z4mG/16D + gP9WfHj/Unl1/1N6dv9Tenb/THRw/1h9ef97mJ//LVqL/yVhmv82b6D/cJCe/4+ppv+LpaP/h6Oh/4Ke + nf+Cnpz/eZeU/2SGg/ksOjm0AAAAZAAAACN+fn4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADNqJge9aN9zf+uiP//sov9/7WO//+5kv3/vJT9/76X/f/Cmv//xJz9/8ae/f/IoP//yqL9/sqj/f/L + pf/9y6T9/9Gn/bSrl/9jhoP9epeW/ZevsP+WrrD9mbGv/Zqwsv+bs7P9m7S0/520tf2gt7b9ori2/6K4 + uf2mu7v9p7u8/6m+vv2qvr79eJaT/3mWk/2rwL/9rMC//6q+vf2pvbz9p7y7/6S7uv2kurf9o7e4/6G3 + tv2gtrX9nrW0/5y0sv2asrD9mbCt/Zevrf+Vrqz9k6yp/ZCrqf+Qqab9jqim/Yympf+JpKL9cpGO/WuL + if9/m5z9ZoiF/UdxbP9fg3/9ZYiF/V6Cff9Ve3f9UXh0/VN6dv9ReHT9UXh0/Uhzcf9AfKD9KF2V/SVJ + e/8dPG39S2iE/ZKtp/+Jo6H9haGf/YSgnv+BnZv9epeV/maHhPotPDu2AAAAYQAAACJ/f38FAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsRjZG+qmE4/yvif/6sYv9+7SO//u3kf37upX9+72W/f7A + mf/8wZv9/MSd/f7Gof/9yKH9/cuk/f/MpP/9zKX9/8+o/ce1m/9mh4X9aoqI/ZWtrv+bs7P9m7S0/Z61 + tf+etbb9oba2/6O5uf2jubj9pbq7/6i9u/2qv779q8C//6zBwP2rv7/9eZaT/3iVk/2qvbz9rMC//6zA + v/2rwL/9qr++/6m8u/2mvbr9pby7/6W5uP2iubj9ori3/6C3tf2etbL9m7Ky/Zmysf+Zsa79lq6u/Zau + rf+Uq6v9kqqq/ZCqqP+BnZv9Z4iF/XeVlP+GoaP9hJ+i/V6BgP9Kcm79XIB9/VyBff9Uenb9UXh0/VN6 + dv9ReHT9Unl1/UZxcv8oWYT9IEJ0/SBFdf8bQ3b9UXCK/ZKrpv+Io6H9h6Kg/YSgnv+BnZv9eZaU/mWG + g/ksOzmzAAAAXQAAAB9/f38EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACrcldr+62G9Pyx + i//8tI7//beQ//26lf/9vZf//cCZ//7DnP/+xJ7//sWg//3Jov//yaL//8yl///Np///zqf//8+o/9y+ + oP9xjYn/ZomG/4Cdm/+gtrX/oba3/6G5t/+kubj/pry7/6a9vP+pvr3/q8C//6zAv/+swcD/rMC//6u/ + vv+pvrz/eJaT/3WVkf+kubj/p728/6q+vv+rwL//rMHA/6zAv/+rwL//qr+8/6e8vP+lvLv/pLu6/6S6 + t/+it7f/n7e0/5+0tP+ctLH/nLOw/5qysP+Xr63/lq+t/5GqqP9wj43/a4uI/4eio/+HoqT/haGj/4Cb + nf9Yfnz/SnFt/1l/e/9Tenb/U3p2/1N6dv9Tenb/U3p2/0hycv8oWYL/Gkl8/xlMff8SSX7/TXKM/5Kr + pv+Jo6H/h6Kg/4KenP+BnZv/d5WT/2SEgfgqODeuAAAAWgAAABx+fn4EAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPTk3AronHmW+66J/vyyjf/7tJD9/bmT//u8lv39v5f9/MCZ/f7Enf/8xJ/9/Mef/f7I + o//9y6X9/cum/f/Op//9zqf9/s6n/e3Jpf+Gl439eZiX/WuMif+OqKf9pru7/ai9vP+pvr39q8C//6zA + v/2swL/9rMC//6vAv/2ovbz9p7y7/6e9vP2lu7n9fZqY/3GQjv2bsrL9obe3/6K4t/2ku7n9pr28/6q+ + vv2rwL/9rMC//6zAv/2qv779qr69/6i9vP2murn9pbq5/aK5uP+itrb9oLa1/Z21tP+dtLP9nbSy/XiW + k/9oiIb9gp6e/Yymp/+IoqX9h6Ki/YWhov9+m5z9VXp3/Upybv9SeXX9U3h0/VN6dv9ReHT9Unl1/Ulz + cv8mYIX9DFSJ/QxUiP8fWof9aYqY/Y2opP+HoqD9hqKg/YOfnf+AnJr9cpGO/mKBfvQlMjGlAAAAVwAA + ABt/f38DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP3r4xnypYC2+7CK/vy0j//7t5D9/bmT//28 + lv38wJr9/MGc/f7Fnf/8x6D9/sei/f/LpP/9zKT9/c2l/f/OqP/9zab9/s6m/ffNp/+ho5L9d5eW/YKf + nf9wkIz9nbOz/azBwP+swL/9rMG//6u+vf2qv779qb69/6a8u/2lvLv9pbu6/6S6t/2iuLf9gJya/26N + i/2Vra39nbS0/520tf2gtbX9ore4/6O6uP2lurv9qb29/6q/vv2rwL/9rMC//6vAv/2ovr39p728/ae8 + u/+kubj9ori4/aG3tv+ht7b9i6ak/WeIhP95l5b9jqip/Y2nqP+Lpab9h6Kj/YWgov+FoaP9eJaY/Ulx + bf9NdXH9U3l1/VN6dv9ReHT9Unl1/Upzb/8qXnv9EU+E/SJPff9vjJj9jqil/Yukov+Io6H9hJ+f/YKf + nP99mpj9a42K/l+AePIfLSOgAAAAWAAAABx/f38DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF9O + RiX6rIfN/LKM//22kP/9uZH//byW//y/mf/+wJv//sSc//7GoP/+yKD//cqj///Kpf//zab//86n///P + qP//z6j//86n///Sq//Kt6H/b4yL/5uysv94lZP/dJOP/6q/vv+rwL//qr28/6i9vf+nvbz/pry7/6W7 + uv+kurn/orm3/6G2tv+gt7X/g5+d/2qKiP+PqKj/mLGx/5qysv+as7P/nLOz/6C2tv+itrb/orm5/6W7 + u/+nvbz/qr6+/6zAv/+swL//rMC//6q/vv+pvr3/pr26/6e8u/+Yr6//bY2L/3GQjf+Pqan/kqus/46n + qv+Lp6b/iqWm/4ijo/+FoKL/h6Gj/2OGhf9Jc27/Unl1/1N6dv9Tenb/U3p2/0lybv8qW3f/GUp8/zRY + f/+HoaL/jqim/4mlo/+Io5//hZ+f/4KenP93lZL/aoiK/1uHYPIYNwehAAAAWgAAAB1+fn4DAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKVvVjL5r4jk/LOO/v23kf/7upT9/b2W//3Amv38wpz9/MOe/f7H + n//+yaL9/cmi/f/Mpv/9zqf9/c2m/f/PqP/9zqf9/9Cs/eLHkv+JqEj9X4pt/Yymp/+jubf9dZSR/XWU + kv+ftrX9pry6/6O4uP2iuLf9obm3/6G2tP2etbP9nrSy/5u0sf2dtLL9iaSh/2eIhf2HoqL9lKyt/5Os + rv2Vra79l7Cx/5mwsf2cs7L9nLW1/6C1tf2gtrb9ori4/6S6u/2ovb39q7++/azAv/+swL/9rMC//Z20 + s/9wkI39bIyJ/Zaurv+YsLD9la2s/ZKpqv+Pp6j9i6Wo/Yqlpv+Go6P9hqGj/YCdnv9Te3j9TXRw/VN6 + dv9ReHT9Unl1/UVwbv8hVnz9FEV7/VByjf+Qqqb9i6el/Yijof+HoaD9hKCe/X2amP9si4n9ZoiL/jug + OPMZPQKkAAAAXAAAAB5/f38EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmVc0D6sIvy/LOP/v24 + kv/7u5T9/b2Z//zBm/38wp39/MSf/f7Iof/9yqP9/cql/f/Npf/9zqf9/c2m/f/Op///0Kz96sma/XKq + K/9Jtin9Xax1/XaQkv+mu7r9pLq4/XGRjf93lZL9m7Ox/6K4t/2ftbT9n7S0/5y0sf2as7D9mbKv/5iv + rv2ZsK/9i6ak/2aIhP2AnZz9j6mp/4+pqf2SrKz9lK2s/5Sur/2Wrq79ma+x/5uxsf2btLT9nbS0/5+3 + tf2jubf9pru5/ae9vP+rv779pru6/XWSkP9qjIn9j6io/Z+1tf+YsLD9l6+u/ZKrrf+Rqqv9jaio/Yyl + pv+Io6T9hqOk/YWgov9ihYP9SHJt/VN5dv9TeXT9UXh0/T9sb/8aUX/9FEZ7/XeUnf+Qqqf9jKSi/Ymk + ov+GoqD9g5+d/W+PjP9rhof9Q5t4/huxL/QbPgSpAAAAXgAAAB9/f38EAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAOihfVH7soz7/LaQ//24kv/9u5X//sCY//7DnP/+xZ7//seg//3Jov//y6T//8yk///O + p///z6j//8+n///QrP/qyZr/fq4y/0zBQf9Z3YX/YNiS/2mLh/+Tq6r/rsPC/52zsv9xkY//cZGO/5mx + r/+etbP/nLOy/5qwsP+ZsK//l6+u/5auq/+Vraz/jqim/2eIhf95mJf/jKan/42mqP+Nqan/j6qp/5Kr + rP+TrK3/k66u/5evsP+Yr7H/mrKy/5yys/+etbX/n7W3/6S5uf+gtrb/epiW/2iIhv+PqKf/o7m5/5+3 + tf+dtLT/mrCy/5Wtrv+UrK3/kaqr/46oqf+KpqX/iKOk/4ijpP91lJT/SnJv/1F4dP9Tenb/UHdx/zVm + c/8QS4H/MF2F/5OrqP+OpqT/iqWj/4mjof+FoJ7/dZWR/2qGh/9ZkX//Eblb/xezNvYcQQWsAAAAYAAA + ACB+fn4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO+mgWP8s43++7eR/v27lf/9vpj9/L+Z//zC + nf38xp/9/Mah/f/Ko//9yqX9/cum/f/Opv/9z6f9/8+r/dnEiP9tsS39S8VK/Vrhlv9f35P9ZOaX/We0 + jv9zkI/9orm3/aq+vf+etrT9d5WT/2yNiv2JpKL9l6+t/5aurP2Tq6r9kaqq/5Cpp/2QqKb9jqim/2uM + if1zkY/9h6Kk/4ilpv2LpKX9jaWo/46mp/2Np6r9j6qp/5KqrP2Sq6v9la6u/5Wurv2ZsbD9m7Oz/ZKr + q/9ykI79aIiF/ZmwsP+uwsH9qL28/aK4uf+gtbX9m7Sy/Zmxsf+Wra39kayr/ZCoqf+Mpqf9i6Sn/Ymk + pv+GoKP9W4B9/Upybv9SeXX9TnRu/R5Zff8bVIb9dJOe/ZGqpv+LpaT9iqWj/YKenP9xj439aYeH/ViR + fv8Wtlr9AMJQ/hS1PPcdRAavAAAAYQAAACJ/f38FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPKq + g3L8tI7/+7aS/f28lv/8v5f9/sKb//zEnv38xaD9/Mei/f/Lov/9zKX9/c2l/f/NqP//z6v948aT/Wmw + KP9JxUz9VtyM/V3gkv9i4JX9Z+OY/Wzamf9omYn9g56d/aq/vf+lu7n9nrW0/3mXlf1sjIn9fpuZ/5Gq + qP2Rqqj9jamn/46mpP2LpaP9jKak/3GQjv1tjIr9g5+g/4eio/2Io6T9iKSk/4mlpv2MpKb9jaeo/42n + p/2OqKr9kKmq/5Oqq/2Ura79jKam/W2Ni/9sjIn9j6mn/a3AwP+swL/9q8C+/aW8vP+ht7n9n7a2/Zyz + s/+Xr6/9lK6u/ZOqrP+Qqar9jKen/Yukp/+JpKX9cJCP/UZvav9Qd3L9Qm9w/RBUhf9Uf5f9kKmn/Y6o + pv+JpKL9fpuZ/W2Niv9oh4f9V5J+/RS3Wv8Awk/9AMJR/hG3P/gcSAeyAAAAYwAAACJ/f38FAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPOrhXb8tpD//bmS//27l//8wJj//sGc//7Fn//+x5///smi///K + pP//zab//86m///Pqv/kxpL/dq0p/0jFTP9U24r/Wt6Q/2Dhkv9l4pX/aeKa/3Dnnv9swI3/ZoiB/5mx + r/+lu7r/obi2/5qxr/+AnJv/aYqH/3eVk/+KpKL/i6ak/4qkov+Go6H/h6Kg/3aUkf9qioj/fpuc/4Wg + ov+EoaH/h6Cj/4ahpP+Jo6X/iqOm/4umpf+Lp6b/jqip/4+pqv+DoJ//a4uJ/26Ni/+Sq6n/pbu6/6m+ + vf+rv77/rMC//6q+vv+mu7n/obi4/52ztP+bs7H/mLCw/5Wsrv+Qq6r/j6mq/4unpv+Kpab/gp2f/0dw + bP9Lcmz/IV56/0B1l/+OqKn/kamn/4KenP9ykY7/Z4mH/2WHhv9llmr/G7dQ/wDDT/8Awk//AMJR/w+5 + QfkbSwq0AAAAZAAAACN+fn4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPWthnb8tpD/+7qU/f2+ + lv/8v5r9/sOd//zGn/38yKH9/sih/f/Mpf/9zaX9/s6o/erKm/99tDv9RsRJ/VHekP9X3I79Xd+Q/WPg + lf9o45f9buOb/XTnof915pv9bbOJ/W+LjP+Xr639oLa1/5qzsf2Zsa/9jKek/22Oi/1vkI39gZ2b/4Wg + nv2Dn539gp6c/3qYlf1piYf9d5WV/4Ofof2Dn5/9gp6g/4Ofov2EoaH9haKi/4ahpP2Jo6X9iKOk/3mW + lv1piYf9c5KP/Zqysf+iuLf9pLi3/ae8uf+pvrz9q8C+/azAv/+qvr39pru7/aK2uP+etbX9m7Kx/Zau + sP+Uraz9kqmq/Y+nqf+Mpab9iqWm/VB3cv81aXP9RXuV/Yylof99mpf9bo6M/WeGhv9mh4P9fpCF/b2j + ef9ysDD9C79B/QDCUf8AwE/9AMFR/gu7RfoYTw62AAAAYgAAACJ/f38FAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPevinD8t5H/+7mT/f2+mP/8wZn9/sSd//zFnv38x6D9/cqj/f/MpP/+zaf9+Mym/Yqz + Qf9Kwkn9S9mF/VPdi/9Z3Y39XeCR/WXil/9p5Jn9cOad/Xbmo/976qf9f+ip/W6fjv92kpH9mbCv/5uy + sf2Wrqz9lK2r/4qkov1zko/9a4uI/3eVk/1+m5j9fpuZ/3qXlf1qi4f9bY2L/3yam/1/nJ39gp6g/4Of + n/2CnqH9hKCi/4Sgov1+m5v9cZCP/2iIhf17mJb9la2r/Z20s/+etLP9ora1/aW6uf+nu7n9qL67/avA + v/+swL/9qb69/aO5uv+ft7b9nrOz/Ziwsv+Vr679lKut/Y+qq/+OqKn9haCg/VJ7fP9LeoX9bY6O/WyK + i/9phof9Z4mA/WGSYf9Vjjb9epYx/XWoJf8nty39AcFO/QDCUf8AwE/9AMFR/gu7Q/oYTg20AAAAYAAA + ACB/f38EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPewiWH9uJL+/bqU//y/mf/+wpr//sOe//7H + oP/+yaL//8mi///Mpv//zar/q7lZ/0K5LP9H1nv/TdyI/1XcjP9b35D/X+GU/2fjmP9t5Zz/ceWg/3np + o/9+6af/g+2s/4PcqP9tmY3/d5OS/5qysP+Wr63/k6yq/46opv+HoqD/dpWS/2iJhv9ujYr/dpSR/26O + i/9oiYb/aImG/2qLiP9sjIr/c5KR/4Ccnv+CnqD/fpuc/3KRkP9oiob/aYmG/36cmf+Rqqj/lq+t/5iw + sf+dsrH/nraz/6G5t/+lu7n/qLu7/6q/vv+swL//rMC//6i9u/+kuLr/n7e3/5u0tP+ZsLD/la+v/5Os + rf+NqKj/dJKR/2WFjP9ohoz/Z4aE/2SOaP9Tnlb/K7JY/yy2Nf9Ipgz/TaEE/yq2KP8EwE3/AMJR/wDC + Uf8AwlH/AMJR/w+5QfgdSwiwAAAAWwAAAB1+fn4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPy0 + jk37t5H7+7yW/v3AmP/8wZz9/sWd//zGof3+yaH9/suk/fzMp/+3wGn9Sbsy/UHYgf9I2oX9UNqH/Vfe + jf9d4JH9YeCV/WnkmP9v5Jz9c+ei/Xvopv+A66r9hOus/Y3xs/+J36z9bpqN/3WSkP2Rqaf9kqup/42n + pP2Io6H9haGe/3yZl/1ujov9aImG/2iJhv1sjIn9cZCP/3KRjv1ujov9aYqG/2uLif1ujoz9aImG/2qK + h/10k5D9hKCe/42npf2Qqaj9kqur/ZevrP+YsLD9m7Sx/aC1tf+jt7f9pLm4/ai9vP+qv779rMC//avA + v/+ou7z9pLi3/aC2tf+bsrT9mbCw/ZWur/9+mZv9ZYh6/VibPf9SoCz9S6UZ/Ti5J/8Wxk/9B8dZ/QHE + Vf8JwEj9Db9F/QDCUv8AwVH9AMBP/QDCUf8AwE/9AMJS/hqzNvYdQgWnAAAAUwAAABl/f38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPu0jD38t5Hx+7uW/v7Amv/8wZz9/sWd//zIof3+yKP+/sum/dvH + if9fujn9O89s/UTYgf9L2oX9UtyI/Vfdjv9d4JL9ZOKW/Wnjm/9v5p39duij/X3qp/+B7Kv9iOyv/Y3w + sv+U9Lj9keGy/2+Yjv1ykI79iaSi/4ympf2GoZ/9gp6d/3+cmf14lpT9aouI/2+Pi/15l5X9gJ2b/4Ke + nP19mpj9dZOR/2mKh/1niIX9bo6L/3uYlf2Cnpz9hqKg/4ijof2Op6b+kaqn/ZWtq/+Vrq79mrKv/Z60 + s/+gtbX9obe2/aa7uv+nvbz9qr++/azBv/+qv779p7y6/aG3uf+etbX9nbW0/Y2mqP9sjoH9Vpk0/T66 + J/8xw0b9KcZR/RnJX/8QyF79DcZY/QTCU/8AwlL9AMJS/QDCUf8AwE/9AMBP/QDCUf8AwE/9AMJU/iWs + LPIbOwSdAAAASwAAABN/f38BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP3f0C/6tpDh+72V/v6/ + mv/8w5v9/sSf//zIof3+yqL9/82s/ZS8T/85xU79PdZ9/UXYf/9M2YT9U9uK/Vrfj/9g35P9ZOGV/Wzl + nP9y5aD9duei/X7pqP+E66z9iO6w/ZDvs/+U8bn9nPa9/5fgtv10npL9a4qJ/4Wgnv2HoqD9gp+c/36b + mf14lpP9bIyJ/3mXlP2FoZ/9j6mn/5Grqf2KpaP9f5yZ/2+Oi/1oiYb9c5KP/32amP2Am5v9gp6e/4ei + nv2LpaP9jaim/ZKrqP+TrKz9mLCt/Zmxsf+ctbP9obe0/aS4uP+nu7r9p7y8/avAvv+swL/9qr6+/aa7 + u/+lubn9l6+u/W+MjP9WoWP9PsFG/SzPbf8kzm39Hsxo/RjKY/8TyF39DcZa/QXEVP8AwFD9AMBP/QDC + Uf8AwE/9AMBP/QDCUf8AwFH9AMJT/jCkH+4XLwKNAAAAQAAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP7u5CH6t5DI/b2X//7Bmf/+xJ3//saf//7IoP//yqX/8cmY/0q4Lf840nL/P9d9/0bX + gv9N24f/VN2L/1vfkP9h4ZT/Z+OY/23lnf9z55//eemj/4Drqf+G7a3/iu+w/5Lxtv+W87r/nPS+/6T5 + w/+m88P/hbii/2mJhv94lZP/eZiV/3GQjf9sjIn/aYmH/3mVlP+OqKb/nbWz/6K4tv+Vrqz/hqKg/3WS + j/9piYb/bY2K/3mWlP98mpf/gJ2a/4Oenf+Go6H/iqaj/5CpqP+Rqqj/lays/5ixr/+bsbH/nbWy/6G4 + tv+iuLf/p7y5/6q+vf+swL//rcHA/6W7uv+Ko6P/a4uI/1Wpgf860nz/MdR4/yvPcP8nzmr/Icxm/xrK + Y/8UyF3/DsZa/wfEVv8AwVH/AMJR/wDCUf8AwlH/AMJR/wDCUf8AwlH/AMJQ/ziREuMKFgF0AAAANAwM + DAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7t5Bb6t5Cx+72X/v7Bm//8wp39/sae//7H + of3/y6j9zMF2/TfAPf841Xv9PtV7/UXXgv9O24X9U92K/VzfkP9g4ZT9ZuOX/W7lnf9y56H9euml/YHr + qv+F7a79jO+y/ZPxt/+Z87n9nfW9/6X2wv2s+sj9sPnK/5HFrf1skIv9ZYaD/2qKiP1xkI/9dJOS/3CP + jf1/nJn9mrGv/6O5uP2Wrq39h6Kf/3ORkP1piYb9aYmH/2uLiP1wj4z9d5aS/36bmf2EoJ79iaSi/Y6o + pf+Qqqf9kqyq/Zavrf+Zsa/9nLOy/Z+2tf+juLf9pru6/ae8u/+juLf9lK2s/XmVl/9lkYb9VrKD/ULV + fv851Xj9NNFz/S3QcP8nzmz9Icxm/RnKY/8TyF39D8ZZ/QbEVv8AwVH9AMBP/QDCUf8AwE/9AMBP/QDC + Uf8AwlH9CsBJ/jZ7CtAAAQBiAAAAKzw8PAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7t + 5Qn7uJGS+7yW/v7Bm//8wpz9/sae//7Hof3/y6j9tL5h/TDFTP841X39QNV8/UfXgv9N24f9Vd2M/Vzf + j/9i4ZP9ZuOX/W/lnf9z56D9eemk/YHrqv+H7a39i++x/ZTxt/+Y87v9nvW+/6b3xP2r+Mj9svzM/7j8 + 0P2f0bj9cZWO/2SEhP1ykZH9epiZ/3mXmP1ykZD9dJSQ/4Gem/2Cnpz9eZeU/2yMif1tjYv9cpGQ/26O + jf1ri4n9aYqH/2uLiP1xkI39eJaT/YGdm/+Ho6D9jKel/ZKrqf+Urav9l6+u/Zmwrv+Urav9jqim/YCc + mv9xkI79aYiN/WKNZ/9SuV/9SNmD/ULXf/8503j9NNN1/SzPb/8nzmz9Icxo/RnKY/8TyF39D8Zb/QbE + Vf8AwVH9AMBP/QDCUf8AwE/9AMBP/QDCUf8AwlL9Fr0+/i5kBrsAAABWAAAAIjs7OwIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7wp9j+7yW8f7Bm//+xJ7//sWe//3Jof//y6j/rb1d/zDH + Uf861nz/P9V+/0bZgf9P24j/VN2M/1zfkf9i4ZX/aOOZ/2/lnP9156L/eemk/4Lrqv+G7a//je+x/5Tx + uP+a87r/oPXA/6f3xP+t+cf/s/rN/7r90P/G/9r/x/na/53CtP94mZP/aouI/26Ojv93lZb/eJaX/3KR + kf9sjIr/aImG/3GRj/90k5P/dpWV/3iXl/96l5j/eZeY/3WUlP9wj47/bIyK/2mLh/9piYf/aYmH/2mK + iP9qioj/aouJ/2iKhv9lh4T/YYWC/2eIhf98k4r/d5xZ/0y2Iv9M1W//SdmF/0LXf/871Xj/NNN1/yzP + b/8mzmz/Isxo/xnKYv8VyF//D8Zb/wbEVf8AwVH/AMJR/wDCUf8AwlH/AMJR/wDCUP8AwlL/Jrsy/yBE + BJwAAABHAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD73Mk++7yV4P7B + m//8wpz9/sae//7Hof3/yqf9r71d/TDGUP841Xv9QNV8/UfXgv9N24f9Vd2K/Vzfj/9i4ZX9ZuOX/W/l + nf9z56D9eemk/YLrqv+G7a39je+z/ZTxtv+a87v9nvW+/6b3xP2s+cj9sfvL/7j90P3B/db9y//d/9T9 + 5P3L7Nr9r83C/4aknv1vjoz9b42Q/3OSlP1ykZH9aYmH/3CQj/11lJT9d5aW/3mXmP16mJn9fJib/32a + nP19mpz9fZqc/XuZmv95l5j9d5WW/XWTlP9xkZH9a4yM/WSHhv9qiYf9gpaN/buxnf+vt279WbUm/VHW + df9P3Ir9SdiC/ULXf/8503j9NNF1/SzQb/8nzmz9Icxo/RnKYv8TyF/9D8Zb/QbEVf8AwVH9AMBP/QDC + Uf8AwE/9AMBP/QDCUf8AwVD+NLUl/A4gAXwAAAA4AAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD83MkY+7uVy/7Bm//8wp39/sae//7Iof3/yqf9pbtW/THIVf841Xv9QNV8/UfX + gv9O24f9Vd2K/VzfkP9i4ZP9ZuOX/W/lnf9056H9eumk/YHrqv+H7a79i++x/ZTxt/+Y87v9n/W//6b2 + wv2q+cj9svvL/7f90f3A/db9x//a/9H+4f3Z/uf94P7r/+Dz6v2jzKD9WZJO/2WGd/1qiYv9aomO/2aI + h/1vj479cpKS/3eVlf14lpf9eZeY/3qXmf14l5j9d5WX/XSTlf9wkJH9aouM/WSIh/9miYf9dZCJ/aKm + lf/Mu6D97M2r/dzMjf9suzn9U9Nv/VXej/9P2ob9SdmD/UDXf/841n39MtN2/S3QcP8nzmr9Icxm/RrK + Y/8UyF/9DsZZ/QfCVv8AwlH9AMBP/QDCUf8AwE/9AMBP/QDCUf8Jv0r+OaMY6gAAAF0AAAApAAAACAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+7+biP7Amf/+xJ3//sae//7I + o//1yJz/d7Y4/zHPa/851Hr/PtZ8/0bXgv9M24f/VN2L/1vfkP9h4ZT/Z+OY/27lnf9y55//eOml/4Dr + qf+G7az/jO+y/5Hxtv+Y87n/nvW9/6X4xv+r+cr/sPvM/7X9zv++/9P/xv/a/87/3//T/+L/2//m/+L/ + 7//U9dX/dsVH/0yfDv9LkBr/WI08/5Okkv+DmpL/eZSM/3KPif9wjon/cY6J/3GOif91kIr/e5OL/4SY + jf+SnpH/qKuY/8W7ov/kyqn/+9Wv///ZsP//1q///9W2/5u/Wf9Rz2L/WuCU/1Tcif9O24X/SNmD/0LS + cf9CxU//OcZR/yzPbf8lzmv/Icxn/xjKYv8TyF7/C8Za/wLEVP8AwlL/AMJR/wDCUf8AwlH/AMJR/wDC + Uf8bvDv+L3QNvQAAAEIAAAAXKCgoAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA+8yuN/6/mPn8w5v+/saf//vIov29v239SL09/THTdv8403f9PdZ7/UTYgf9N2Yb9UtuJ/Vrf + j/9g35P9ZuGW/WvlnP9y5aD9eOek/X/rp/+D66z9ie2v/ZHxtP+X87r9nfXB/4vllf2J4Ir9o/K3/7T8 + z/25/tH9wP/X/8n93P3P/eD91f/i/9r95/3e/uv91fjc/6jhmf1ywEn9RJcC/8/Nkf3w3b/949W0/9vO + sP3Zza/92syu/9rLrf3ezq795tCv/fHUsP/62LL9/9qy/f/Zsv/+2LH9/taw/f7Urf/80639/9Wz/anD + ZP9SzmH9Wd+Q/VPbif9L2of9RdV4/V64N/+wv2T9nr1U/TfBRP8jzWv9Hsxn/SPFU/8utzX9M7U2/Ty8 + Rv8SvEL9AMFQ/QDCUf8AwE/9AMBP/QPBUP8rrin0GTYFjAAAADAAAAAMAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/vPtAfy9lsb8wZz+/sWf/+jEkP1muDn9K8pg/TLS + dP821Hb9PNR6/UPYgP9M2oX9UtyI/Vfdj/9d4JH9Y+KW/Wvjmf9v5p39deah/X3qqP+B7Kr9h+yu/Y/x + t/+Q77L9bNJj/4C+R/2Zwlr9ec9i/7X+1P22/M/9vf7U/8P+2P3I/dr9zf/f/9H94f3T/eH91//m/9j+ + 6v3C88n9XbUu/9zTnP3+48H9/OK9//zhu/394br9/d+6//3fuP393bf9/dy1/f3atf/92bP9/tey/f7W + sP/81a/9/Naw/f7Vrf/81Kz9/9Sw/c3IgP9WxU39Vt2M/VHciP9K24n9RctY/XupKv/8zaj9/syk/Uy3 + LP8jy2T9HMxo/SXCS/9Hpgz9UpMH/dC3cP9TtjT9BMBL/QDCUf8AwE/9AMFR/Q3ARv8yhxLTCRMAZgAA + ACBfX18FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP69 + lWH+wZr6/8al/6W7Wv8uwEH/KM9u/zDQcf820nX/PNV7/0PWfv9K2oT/T9qJ/1fejP9d4JH/YeCU/2nk + mv9v5pz/c+ag/3vopv9/6qn/hu6w/3zfiv9qvz7/qMNi///cu//x163/eb1A/6f3wv+z/M7/tv3P/73+ + 1P/A/9f/xv/Y/8j/2v/M/93/zP/d/87/4P+79Mb/esNL//3gvf/94bz/+9+6//veuv/93bn//d63//3b + t//92rb//dm1//3atP/82bP//tiy//7Xsf/+1rD//tSu//7Vrv/+0qz//tOt/+XNl/9qv0b/UtqC/0/c + iP9I24f/RMZK/3ulKv/7zqn/ycR1/zS9Nf8hzWn/Hcpl/xTJYf8qvjz/QZ0F/8quaP9ouD7/A8BK/wDC + Uf8AwlD/AMJT/yG1MvkjTQWnAAAARgAAABF+fn4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7XviX8wJnN/8Sh/2S3Mv0jyFn9J89t/S/Rcv8z03T9OdV4/UHX + fv9H2IP9T9uG/VTejP9b3pD9X+GU/Wfjmf9t5Zz9ceeg/Xnppf9/66r9feef/Wi4Mv/KyoL9+9i2//7a + tf3+2rb9lcBR/5Dpnf2x/M/9tPvO/7j9z/26/tH9vf/V/8L91/3C/dj9xf/Y/8f+3P2c5Jr9lMVa///i + wv373rn9+9+6//zeuf373bj9/du2//vctv3727X9+9qz/f3Zsv/917H9/Naw/f7Xr//81q79/NWv/f7T + rv/80639/dKs/fPQpf+JvU39TtJu/U7cif9G2ob9P8RI/Z+yTv/iyJH9Z7c0/SfKYP8gzWn9HMtj/RPJ + YP8WxFL9PaoS/dKxcP9ltjz9A8BK/QDCUf8AwFD9AMJT/jSiHewVLwKBAAAAMxsbGwkAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7w6Af/wKSE3b2A+Ti4 + KP4gzGb9J81s/S7Pcf8z0XP9OdR5/T7Vff9H2YL9TNmF/VTdi/9Z3Y39XeCR/WXhl/9r5Jn9b+Sd/Xfo + ov9+66z9btl3/V2hF//hzJr9/9m2//zYsv3/2rn9qcNj/4LgiP2t+839rvvJ/7P6zf22/M/9uf3P/7v+ + 0v27/tL9vf7U/7v60f16zVz9yNCH//7gvf373bj9/d65//vduP3727b9/dy3//zbtf382rT9+9i0/f3X + s//82LL9/Nex/f7VsP/81K/9/NWt/f7UrP/806v9/NGq/f7SrP++xHL9Tr03/Ujahv9E2oj9OsI//c/E + ef+3wWz9OcBF/STPb/8gy2b9Gslj/RLIX/8TxFP9PKsW/ZWmPv9FtTD9AsFN/QDCUf8AwlL9CcBJ/jiC + C9IDCABaAAAAIzs7OwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACuzYNJYbEn5h3FUv8ezGj/JM5r/yzQbv8w0nP/NtJ4/z7Wev9D2H//S9qF/1Lc + iP9X3o3/W96R/2Pilf9n4pn/buWb/3Tmn/966qn/cNuA/0WaAf+Uq0n/9tau//3Ztf//2bb/m8BV/4fl + k/+n+cn/qPfG/636yf+w+cv/sfrN/7P8zv+2/c7/uf3U/4DVbv+cxFz/9924//3cuP/93bj//d24//3b + tv/93Lf//ty3/+7Wrf/116///dmz//7Ysf/+17H//tWv//7WsP/+1a3//tOu//7UrP/+0qv//tGq///S + q//80Kr/usJr/2m5NP9cvDr/erk9//nNo/+sv2D/NMRO/yLObP8ezGX/GMpi/xDIXv8TxFL/Qa0a/zuo + Dv8PvkH/AMJR/wDCUf8AwlH/Jbsz/yZPBJgAAAA6AAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/qgBoKrs39BTKZf4eymT9Is1o/SrO + bv8u0XD9NNN2/TzVef9C13/9R9mC/VDbiP9T3Yr9Wt+P/WHhk/9k4Zf9aeSZ/W/mn/926KP9eeii/VCx + H/9Okgr9n69W/+vRpf3t06P9eLs+/5Xwsv2h9sL9pffC/6j4xf2p98f9rfrJ/6/5yf2x+879kOWU/4W9 + Rv3s2Kv9/t25//vbtv3727f9/dy3//3ct/302LH9v8B4/3SgMv2Zr1P98tSp/f7Ys//81a/9/NWu/f7W + rv/+1a/9/tSv/f7VsP/+1LD9/tOu/f/SrP/+0an9/9Ct/evMmP/dx4398syd/f/Pq//EwnT9QL09/R/O + bf8cymP9F8lh/Q/HXP8LxFX9ILs6/RO9P/8AwVD9AMJR/QDCUf8GwEz+OK0d8goXAVwAAAAjAAAABwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACQy2ZKOLUk5hPJZP4cy2X9IMtn/SjPbf8s0G/9M9Bz/TjUef9A1n79RdiA/U3Zhv9S3Ij9VtyN/V3g + kf9i4JX9ZuOX/W3lnf9x5Z/9eOmo/WnSbP9Jogn9Ro4D/2mYIP1toiL9ZsJH/5r1wf2c87z9oPXA/6P2 + wP2l98P9p/jF/6n4x/2o98P9XsA8/6m7Y/3/37/9/Nu2//vctf373Lb9/du0//jatf2gtlj9TqIL/0Wi + Cf1GkgX9ma1Q/f/buv//2rr9/9m6/f/Yt///1LD999Cm/d3Gj//ZxIr94caQ/frPpv//07H9/9Cr/f/Q + qv/+z6r9/s+p/f/Pqf/nyZP9YLYv/R3LZf8ZymT9Fcde/Q/FWf8HxVf9AsNT/QDCUf8AwFH9AMBP/QDC + Uv8fvDf/M3wNtgAAADIAAAAPkZGRAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC84aUBV7EVgiu9Pv8XymT/H8xn/ybOa/8rzm//L9Fz/zfS + df881Xr/RNaA/0rahP9P2ob/U92L/1rfj/9f35H/ZOKW/2rkmv9t5Zz/cuWg/3jqpv9s2Hf/V7ox/0yn + FP9XuTD/guWY/5Pxt/+V8bj/mfK7/53zvP+d9b7/n/bB/6P3wv+g9bz/Xr05/3KfKf/y16z//du3//3b + tP/927T//9u5/7HGbP9dvjj/gOGN/4fpo/9atzH/P44A/22bJv+Wq07/kKlG/3egL/9jmBj/TpME/0SR + AP9EkAD/RI4A/1KRCf+Dojn/08CC//3Pqv//zqf//8+o///Opv//zan/ycBz/zi4K/8Yx1v/Eche/wzE + WP8FwlX/AMFQ/wDCUf8AwlD/AMJS/xC+Q/43lRTVCxgBVgAAABUYGBgDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvuGnEEKw + Fs0hw1L+G8tm/STNaP8pzW39LdFx/TXTdf8503r9Qdd+/UfZgv9M2YT9UNyJ/Vfejf9c3o/9X+GU/Wbh + mP9r5Jv9buSd/XXoov956af9eeee/3fgjf2A56H9iu6y/4zusf2R8bb9lvO9/5fzvP2Z8779m/S9/5vz + vP2e9cH9ctFi/02WC/3Gwn/9/tu3//vZs/392rb94tKb/2O/Pv2G6KD9kPG4/4vvs/102n/9VLMo/USZ + BP9EmwX9RJ8M/UinGf9MsCX9ULk1/VK9O/9Ouzj9TbUr/UikEP9CkwD9UpEP/djBhv/+0Kz9/c2m/f/M + pf/+zKT9/sql/ai8W/8+uTH9E8RU/QjFWP8DwVL9AMBQ/QDCUf8AwlH9AcFQ/jSqIO0hRwV+AAEAJhsb + GwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAESqBFA4uCvsG8lh/iHMaP8nzmr9LM5v/TLScv841Hj9PNR8/ULW + gP9J2YP9TtmH/VLdi/9Y3o79Xd6Q/WPilv9n45f9auOa/XHmn/915qH9eumm/37rrP2C7Kz9he2s/4nu + sP2L77L9eN+H/2XLVv1523/9lPC3/5fyuP2Z8779ieea/0WfA/2ar1H9+diz//3Zsv3/2bf9p8Ff/27Y + dP2P8Lj9iO2v/4Xtrf2A66r9duOV/WjVcf9m1HD9Ztl8/WbchP9k3439Yd6Q/Vzejf9X3Iv9UtuG/U3S + b/9Huzb9U6IW/eHDjP/+z6r9/c6m/f/Npv/9y6P9/smj/fnGnv+sulv9Obco/QTEWP8BwlH9AMBQ/QDC + Uf8AwlL9Ibs1/zRwCKgDBwA1AAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOHy2Adftih/MLw79xrM + aP8jzWj/Kc1r/y/PcP810Xb/OtN4/0DXfv9E2H//SdqD/1Dcif9T3Yz/WN2P/1/hkf9j4JX/ZuOX/2zl + nP9w5p3/c+ag/3fno/986KX/f+uq/3znnP9sxlH/kb1L/8XHfP9+v0f/guaZ/5Dwtf+P77T/lPO8/12+ + Ov+gtlb/+9ez//7Ys//41qz/fbxA/4Hpo/+H7a//guyq/37rqf986KX/d+ik/3Topf9w56L/bOWc/2bj + mf9i4ZT/XuCR/1jejv9Q2ID/StFq/0zKWf9LxEn/Xbcp//nOpP//z6j//8yl///Mpf//yqL//sii//7G + oP//xKL/urhf/ye3Kf8BwVD/AMJR/wDCUf8YvD3+PJQQ0gADADcAAAASKCgoAgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACm1YUfRq4QvCDHWf8ezGn9Jc5q/SrQcP8x0nX9NdR6/TzWff9C1X39RdeC/Uza + hv9P2on9VN2M/Vvfjv9f4JL9Y+CU/Wjjmf9q45r9buae/3Pnof136KL9eeqo/2bFS/25xnL9/NWx//XV + sP2Swln9euKS/4rusf2J7bD9j/O9/2vJVf3EyHz9/9e0//7Xs/3gz5f9bsBE/4Ltr/1/66n9fuqo/3vp + pP115qP9ceef/W/knP9r45r9Z+OY/WHik/9e35H9Wd+R/VLLXf9nvUD9kb5R/bXBaf/Dw3T91MeF/f/P + p//9zqf9/c2m/f/Kpf/9yaH9/Mef/f7Fnf/+w539/cCc/YG1Pv8Vujf9AMJR/Qq/Sf82pxzkGjsEawAA + ABkAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAarozQTq2J/8hyF7+H8xp/iXN + af8ry2D9NclX/T3NZP8+1Xr9Q9d//UjZg/9N2Yb9UdyI/Vbejf9b3479Xd+R/WPilv9n45f9a+Ob/23k + nP1z56P9Zdl9/5C8Sf351K79/9ax/+zSpf1+wUz9eeSX/4TsrP2G7rH9fOWa/2u5Nf3k0Jv9/tey///X + s/3IyX/9Z8dS/4DusP166KX9eeek/3bnov1w5p79buWd/Wrkm/9m4Zj9YuCV/V7gkf9a35H9UdZ4/W60 + Lv/eyY799s6m/f/Pqf//z6r9/s+p/f/Np//9zKb9/cyl/f/LpP/+x6L9/Mag/f7EnP/8wpr9/7+a/dq5 + fP9MtC3+AcFM/i21KvQqXQaJAQMAJQAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAGq8NFRGrhG8WLYu5HS4Of+QuUj/fa8u/0W0If860XL/PtZ9/0TYfv9H2YP/S9uF/1Dd + iv9W3ov/Wt+P/17gkf9g4JX/ZeOY/2jjmv9o45j/UcdJ/83Hf///1rX/+NOv/5a5Tv9hylb/e+mn/37r + qv9w3YX/Y7oy/93Nkv//1rP//dau///VsP+3xW//aNFo/3jqqf905qH/c+eg/3Dknv9s5Zz/Z+KY/2Pi + l/9h4ZP/XeCS/1ndjv9V3pD/TMhT/3mmKf/8zqj//8+p///Pp///z6j//82m///Opf//zaX//8uk//3I + of/+x5///sWe//7DnP/+v5r//b6Y//26lf+wr1zzQaka4DqEC4wJFwAVAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACk1YQQ0sWESPfHnujdw4b+arMw/TXI + V/8103b9O9V6/UDVff9D1oD9SdmD/U3Zhf9Q2on9Vd2M/Vndj/9d4JL9X96P/1nKWP1mwUj9gL1G//PQ + pP360q79p7tc/1K8Nf1v4JH9eOqp/2vbgf1svkD9ycqA///WtP3+1bD9/tWv//7Ur/2ww2j9ZdJs/3Lo + o/1u5J39beWb/2nkmf1n4Zj9Y+CU/V7fkv9c3pH9V96N/VPdiv9P3Iz9S8lS/WCcFf/dwoz9/8+p/f/P + qP/9zab9/c6n/f/Npv/9yqP9/cqj/f7Iov/8xp/9/MKb/f7Bm//9v5f9/LyW/vm0kvSQcFSVIT8HRw0k + ABE7OjwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPjGpV2Vu1XoL8VO/izRc/8y0nT9N9J2/TzVe/9A1nz9Q9Z//UnZhP9N2oX9T9qJ/VTd + jP9Y3Y39TcRH/569VP3gy5H978+i//7Sr/3AxHT9W7s1/2rhk/1w56T9aN+J/2O6NP3JyID9/dSv///V + sv330aj9/NOt//vWtv2cv1j9YtZ0/2zlnv1q5Jn9aOOZ/2Xil/1g4ZP9XuCS/VvfkP9W3oz9VNuL/VDc + if9M3Ir9Ss5g/UiZAf+PpUP99Myk/f/Op//9zqf9/c2m/f/Mpf/9yaL9/smi/f7HoP/8w5z9/cKc/f2+ + mP/8vZf+/72W/6d5YJcRCwssAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN3szBBOtiqmJctj/yjPbv8uz2//MdJ0/zfU + dv861Xv/Ptd+/0LYgf9G2YP/S9qE/0/cif9R2H3/Qq4X/7CyYf//07L//9Kt//LQpP+GxVv/Xt6K/2jk + nP9g2oD/Ybgv/+fOmv//1LL//tOw/7C3Y/9Qkwr/YZYa/4SqPP9avDn/ZN+P/2XimP9i4pb/YuGT/1/g + kf9c35D/V96O/1Tdiv9S3Ij/TduG/0nahf9F14P/Qtd9/0axHv9jnRv/5MaT///Op///zab//8yl///J + pP/+yaH//seh//7En//+w5v//MGa//2+mP/3tpLyqXthlAAAABgAAAAHAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANLr + wwRDrAZvOrsz8iTNa/8oz279Ls9w/TPTdf820nT9Octc/T/ScP9B13/9RteC/Urah/9L2H79SrQk/2aX + HP3RwIP98c2h/+PKmP18yWf9XN+Q/2Hhlf1Rx1D9eawy///VuP3/07D9xsJ3/1CtHf1LriH9Rp4I/0iv + Iv1b1HP9YuGW/17fkv1e4JL9XN+P/1jdjf1V3Yv9U9uJ/VDaiP9L2ob9SdiE/UTXgP9C1379PdZ//TzG + Uv9lqSP95caU/f/Np//9zKT9/cuk/f7Jo//8xqH9/MSf/f7Enf/8wZv9/b6Y/vS2kOuZcVqGEQsJJAAA + AAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADV7MgOabs1eji8Nf8lzGn+KM9u/S3Qcf87wkj9d7g6/U+9 + Ov8803b9QNiA/UTDR/9Jvzz9TL46/0mWAP1bkRL9b5oi/22bIv1ZwEz9WN6O/1zfkP1Rwkb9SpYG/8q+ + e/3Zy4z9Zbgy/1jXev1d24T9WdNu/1vZgP1d35L9XN+R/1rfjv1Y3o79VtyN/1Tdi/1R2on9TNuH/Uva + g/9H14P9RNiB/UHXfv891Hr9ONR5/TbKXf9lrCj95cWS/f/Mpv/9y6P9/sij/f7Iof/8xp79/MSc/f7C + m//+v5n++bqU8otmUWwPCggeAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGm7 + M3Y7tyzvJstl/ynKX/92ukD/88ym/3i7Qf81zWT/PMBA/6S5Uf+xwGT/S8VO/0q9N/9Jqxb/R6kV/0is + Gf9OzGD/U92M/1Xejv9T0Gf/SqYP/0yOBf9fqyP/VNRw/1nfk/9Z34//WN+P/1fejv9V3I3/Vd2L/1Lb + i/9S3Ij/UNyH/0zbh/9L2oX/RtmB/0XYf/9A133/PdZ7/zrVeP841Hb/M9N2/zPJWv9lrCf/5cSR///L + pP/+yKP//sih//7Gnv/+xJ7//sKc//3AmvzXoYHKYkg5UQAAAA0XFxcCAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAO335gt1wEV4Orku7ze/QP6qvV38/8ys/nm7Qv8xyVj9QLEd/ZOn + Rf+oul/9SsVP/0LXgP1G0nD9SNJw/0rTc/1M2IH9TtuH/1DbiP1Q2ob9TsZP/0idBP1GnQf9UMdT/1Pd + jf1T24n9UduK/1LciP1P2of9TtuI/07bh/1M2YT9SdqD/0jZg/1E2H/9Q9d9/UDVff871Xv9OtR5/TXT + df8z0nT9LtFz/S7HV/9lqyf95cOQ/f7Jo//8xqH9/Mae/f7Env/9wpz+/sGb/9qkg7pQOzBHAAAADhgY + GAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADs9eYLaLs2YEyr + Eo/Gunh3/8qs3Iu6S/8vxU/+RbUk/UyPAv9UoBH9QsZR/zzXgP0+2IP9QNmH/0PZhv1H2YP9SNmD/0rY + hP1L2ob9TNuH/0vAQf1LogX9TKoO/03Ygf1N24f9TdmG/0zahf1L2oX9StiE/0jZgf1F14L9RdiB/0HX + f/1A1n39PdR7/TrVef820nf9NdF1/THRc/8uz2/9KdBv/SvGVP9iqiX95cGO/f7Iof/8xp79/cSe/v/C + nP/9wJny16ODmSQaFSkAAAAIkZGRAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/+DOEcvLh5RCujLxMsdV/0O3J/8/wD//NNFy/zjN + ZP9Fw0r/VL06/0XCRv8/1Xn/QNd+/0PXfv9D1n//RNiB/0bYg/9HzF//SMRJ/0XXgP9F2YL/RteA/0TY + f/9D2ID/Q9Z+/0DXf/9A1Xz/PdZ7/zzVe/8403n/NdR3/zPRdf8y0nP/L9Fx/yrOb/8oz2v/I85r/ybG + Uv94sjn/7sSW//7Fn//9w53//MCb8NShgKtnTT0+AAAACTk5OgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO72 + 5w15wUuCObw08ivOa/8tzmr+NcJH/3K5Pf21wGj9oLhM/0G4LP0503X9PNV7/zzUev0+1nz9PtZ7/0DV + fP0/13/9P9eA/z/Vfv0/1Xz9QNZ9/z/We/0+1nr9PdR6/zzVef0603n9N9R4/zXSdf000nX9MNBz/S/R + cf8r0G79Ks9s/SXOav8jzWj9Hsxp/SfCSv+cuVP++8Se/vzCm/Prs4+6jGpVaS8iGhU4OToDAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADs9eYOZ7s1fUG1I/JEtiXwkrlM9u7Jmv/WxYf+Xrk1/zLN + av0z03b9NtJ1/zjUd/031Hj9OtR5/zrTef061Xj9O9V6/zvVeP071Xn9OtN5/zfUev021Xz9NdV7/zTT + d/0003X9M9Fz/zHSc/0tz3H9LM5v/SrPbP8nzmz9Jcxq/SHLaP8cy2f9F8xm/kS5L//IvnP59r2axaV+ + ZVsqHxchAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPA + QQt7vE0N4c2kGv/UuHjBv26/Rbox7y7MZ/8t0HH/LtFz/zDRcv8x0nT/MdJz/zPSdf8y0XP/MtNz/zTR + c/8y0XP/MtJ1/zbKXP9CwUX/QMFG/y/LYP8sz27/KtFx/ynObv8oz2v/Js5q/yLNaP8hy2b/Hcxm/xrL + Zf8fxVX/NrQi7maCLJeBYlA+DgoGCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADm4L8VX7YnYEOxGsA6wEL1NsRO/zrB + R/4wy2L+K9By/y3Qb/0uz2/9LtFx/y7Pcf0s0HH9MMZQ/3S3Ov27v2z9ur9p/3W6QP1CvTr9K8ZQ/yXM + af4gzmz9Hc1p/R3LZ/8aymP+Hcdb/iu+Qf1ArhzSKF8EbQYIAhAAAAAEAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAALPbliBEqwdhSa0PgFOnFXhBshzdM8RO/yXOb/4lz3H+JtBv/yTQcf4vxU//Z7gy/+zH + lf//yqf//8ql/+7HmP/IwHX/f7hA+ju4Kvwvv0L/LL9D/zO7Nf86tij6QbIc3UKcDoQeSQEzAAAACign + KAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+4KYdVLEUhUGz + Htk3ujTpMb9A9Dm3LOc8kQyvhHxLYa6Jck/UrZJM98+0TPXNsUL0zbYu07+aF3G5Qyd4vkNWeL1DXnW4 + RD5vq0UaTmc/AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXVhC2m1YRRpdaGZaXThEqPpYEWAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////////////////AA//8D/////////8AAP/wB/////////4A + AD+AAAf///////wAAAAAAAAB//////gAAAAAAAAAA/////AAAAAAAAAAAAP///AAAAAAAAAAAAB//+AA + AAAAAAAAAAAH/+AAAAAAAAAAAAAA/+AAAAAAAAAAAAAAH+AAAAAAAAAAAAAAD8AAAAAAAAAAAAAAA8AA + AAAAAAAAAAAAA8AAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAYAA + AAAAAAAAAAAAAYAAAAAAAAAAAAAAA4AAAAAAAAAAAAAAA4AAAAAAAAAAAAAAD4AAAAAAAAAAAAAAH4AA + AAAAAAAAAAAAf4AAAAAAAAAAAAAAP4AAAAAAAAAAAAAAP4AAAAAAAAAAAAAAH4AAAAAAAAAAAAAAD4AA + AAAAAAAAAAAAD8AAAAAAAAAAAAAAB8AAAAAAAAAAAAAAB8AAAAAAAAAAAAAAA+AAAAAAAAAAAAAAA+AA + AAAAAAAAAAAAAeAAAAAAAAAAAAAAAfAAAAAAAAAAAAAAAfgAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAf4A + AAAAAAAAAAAAAf4AAAAAAAAAAAAAAf4AAAAAAAAAAAAAAf4AAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwA + AAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwA + AAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwA + AAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAfwAAAAAAAAAAAAAA/wAAAAAAAAAAAAAA/wA + AAAAAAAAAAAAA/wAAAAAAAAAAAAAA/4AAAAAAAAAAAAAB/4AAAAAAAAAAAAAB/4AAAAAAAAAAAAAB/8A + AAAAAAAAAAAAB/8AAAAAAAAAAAAAD/8AAAAAAAAAAAAAD/+AAAAAAAAAAAAAD/+AAAAAAAAAAAAAH/+A + AAAAAAAAAAAAH//AAAAAAAAAAAAAP//AAAAAAAAAAAAAP//AAAAAAAAAAAAAP//AAAAAAAAAAAAAf//g + AAAAAAAAAAAA///wAAAAAAAAAAAB///wAAAAAAAAAAAB///4AAAAAAAAAAAD///8AAAAAAAAAAAH///+ + AAAAAAAAAAAP////AAAAAAAAAAAf////wAAAAAAAAAB/////wAAAAAAAAAD/////wAAAAAAAAAH///// + 4AAAAAAAAAP/////+AAAAAAAAAf/////+AAAAAAAAA///////AAAAAAAAB///////8AAAAAAAH////// + /+AAAAAAAf////////AAAAAAB/////////wAAAAAP//////////AAAAAf//////////wAAAA//////// + ////AAAP////////////wf///////////////////////ygAAABIAAAAkAAAAAEAIAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMjIwBFxcXBxoaGgwaGhoPGhoaDxoaGg8aGhoPGhoaDxoa + Gg8aGhoMGBgYB25ubgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABubm4BGBgYCBoa + Gg8aGhoTGhoaERkZGQk8PDwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAACkpKQUAAAAZAAAAMwAAAEUAAABKAAAASgAAAEoAAABKAAAASgAAAEoAAABFAAAANAAA + ABoWFhYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPDw8BBYWFg0AAAAfAAAANgAAAEsAAABUAAAATwAA + ADkAAAAcJycnDDw8PAg7OzsFOzs7Ajs7OwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJycnBAAA + ACMiISFqODc2oDk3N646OTixOjk4sTo5OLE6OTixOjk4sTY1NKwUFBOSAAAAdwAAAFQAAAAhAAAACAAA + AAgAAAANAAAADAAAAAwAAAAVAAAAKAAAAEUIDxt5EyM7rxUnQsETIzy+CA4anwAAAHwAAABdAAAARgAA + AD0AAAA1AAAALAAAACQAAAAcAAAAEwAAAA0AAAAJAAAABQAAAAQAAAADAAAAAgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbW1sBDAsMI2dlY7O0s7P70dHS/7a5 + uf+Eg4L+h4SC/oeEgv6HhIL+h4SC/oeEgv+Bf334R0VFxwECAogAAABYAAAANAAAADoAAABLAAAASgAA + AEkDBQljDhsunR01XNgnRnf9Ik6G/x9Tjv4jVY/+KEt++hkoOccdJyWuFRwcogkMDJUAAACKAAAAgQAA + AHcAAABsAAAAXgAAAE4AAAA9AAAALQAAACEAAAAYAAAAEwAAABAAAAAOAAAACwAAAAkAAAAHAAAABQAA + AAMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCgoSc3JwteHh4v785d//+sq2//zIs/3cvbP/jIqJ/4uK + iP+Nioj/jYqI/Y2KiP+Nioj/ioeF/UxLSswCAgKJLCsqmkdFRLQ0MzGxFBwlqxktSsoiP2zwJ0d5/SpM + f/8kVo/+H12d/x9foP8gYaL/JGOk/i1Uif1Xd4D8ZoeD/GKDgPlaeHTxTWdl5T1QTtcmMjHGFRwbtQQF + BaMAAACTAAAAggAAAHAAAABaAAAASQAAADoAAAAwAAAAKAAAACMAAAAgAAAAHAAAABgAAAATAAAAEAAA + AAwAAAAJAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFhXVwNLSUdx0dHS/fnTxv/6wp7//enA//7uxP3+0qr/zZmF/42Jhv+TkI7/k5CN/ZOQ + j/+TkI3/k5CO/4mHhftkYmDhg4GA+Wdvfv8/VHf8J0d2+ilLff4rT4P/LVSJ/y5Xj/8lZKT9J2ep/ydp + qv8ma67/Jmyw/Sxrrf9CY4j/h6Kg/4Sgnf9+m5j+dpWS/3CQjf5qiof9YIB9+FNta+45S0rcHCUkyAoN + DbcAAAClAAAAlQAAAIIAAABuAAAAXQAAAE8AAABGAAAAQAAAADoAAAA0AAAALgAAACcAAAAhAAAAGwAA + ABUAAAAPAAAACwAAAAYAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1M + SyGdm5ra9uDZ/vu+mP/+9cr///bM//32y/3/+M7/+tGo/6iKff+UlJP/mJaU/ZeWlP+YlpT/lpSS/4yJ + h/+Sjoz+XmuB/yZGev8oTID/K1KH/i1Xjf8xW5L/M12W/zJkof8sb7H9LHGz/y5xt/8tdLn/L3a6/S94 + v/82ZJ3/g5qj/5yysf+asrD9mrGw/5evrf+Sq6n/iKOh/nqYlf9ujov/ZoaE/Fh0cvQ8T03jGSIhzgUG + BrwAAACtAAAAnAAAAIgAAAB2AAAAaQAAAGAAAABbAAAAVQAAAE8AAABHAAAAPwAAADUAAAAtAAAAJAAA + ABwAAAATAAAADAAAAAYAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFNSUGnS0tH/97KW/v7u + wf398cb9/fHE/f7xxf798MT9//PH/dmukf2Rjo39npya/p6bmf2QjYv9hYSC/YiGhP2WlZf+ME98/SxT + iv0uWZD9Ml2U/jJgm/00ZKD9N2ik/TZwsf0yeL3+NHjA/TV6wv01fcP9NH3G/jSAyP01dLf9bYaZ/Z62 + s/2bsrH+m7Sy/Z20sv2dtLL9nbSz/p20sv2ZsK/9jael/n2amP5rjYr+ZoaD/VNta/IuPTzfBQgHxgAA + ALkAAACpAAAAlgAAAIQAAAB4AAAAcAAAAG0AAABpAAAAYwAAAFwAAABUAAAASgAAAD4AAAAyAAAAJgAA + ABoAAAAQAAAACAAAAAIAAAAAAAAAAAAAAAAAAAAAycjIB4OCgrvs0sr//MWa/f/uwf//677//+y+//3s + v/3/677//+2///Xcsv+ejYX/paKj/ZaTkv+Nioj/kI2L/5iVlP+EiZX9LFSJ/zRhmv81ZJ//N2ik/Tls + qf87cK7/PXKy/zx6vf85gcj9O4TL/zqFzf86hdD/PIjR/TyJ0/87gsr/XHqY/6K5tv+etrP9n7a0/5+2 + tP+ftrT/n7az/Z+2tP+etbT/nrWz/5+1tP2cs7L/jKal/3eWlP9rjIj/ZISB+zxPTecRFhXOAAAAvQAA + AK8AAACcAAAAiwAAAIEAAAB8AAAAegAAAHYAAAByAAAAbAAAAGQAAABbAAAATwAAAEAAAAAvAAAAHgAA + AA4AAAAFAAAAAAAAAAAAAAAATEtLKa2sq+P0vKb//uCx/f/ouf//5rr//+a6//3muP3/5rr//+e5//7m + uP+4oY3/pKSl/ZaTkv+dm5r/mJaU/6WjoP98hJb9MV6X/zhrp/86baz/PHOx/T51tv8+erv/QXy+/0KB + xv9BitT9QIzW/0KM1v9Cj9j/QpDb/UKR3f9AitT/W3mY/6W7t/+gtrb9oba2/6G2tv+htrb/obe2/aG2 + tv+ft7b/oLW0/562tf2ftrT/nrW0/5yzsv+TrKr/fpyZ/m2Niv5ffnv5PlJQ5xAWFs4AAAC7AAAArAAA + AJ0AAACRAAAAhgAAAH8AAAB9AAAAewAAAHgAAABzAAAAbAAAAGIAAABTAAAAPgAAACQAAAAPAAAAAwAA + AAAAAAAAamlnTcO9vPj5tZX//uW1/f/itP//47T//+O0//3jtP3/47T//+O0///ktP/TuZn/nZ2d/ZuY + l/+sqqn/oZ6d/66sqv+EjZ39NGWh/z11tP8/d7n/QXy+/UGAw/9Eg8f/RIXK/0eJz/9Gktz9SJTf/0iV + 4f9IleP/SJbk/UiZ5v9Ci9T/aISb/6a7uP+ht7b9o7m2/6O5tv+jubb/obe2/aG5tv+it7f/ori3/6C2 + tv2ht7T/nrW1/5+0s/+etbT/nLOy/ZWtq/+AnZv/bY2K/l58evgwQEHiBwwUzgECBcAAAAC0AAAAoQAA + AI0AAACCAAAAfgAAAH4AAAB9AAAAewAAAHcAAABtAAAAWQAAADsAAAAcAAAABwAAAAAAAAAAjYuJdtLC + vP/6uZH//uGv/f/drv//3q7//96u//3erv3/3q7//92u///frv/pyqL/mZaW/aOhoP+7ubj/rqyr/7Cu + rf+fpK39Nmij/0J/wf9CgsX/RYTI/UeJzv9HjNH/So/X/0qR2f9Nl+L9Tpzo/06d6v9Onur/Tp3r/U+i + 8f9CfsL/gZik/6e9uv+lu7r9pbq5/6S6uf+jurn/o7m4/aS6uf+kurf/ori4/6O5tv2it7f/obi1/5+3 + tv+etbP/nrWy/Z20sv+cs7L/lKyq/3uZl/5qioj/OVh0+xgwVu8IEyHWAAAAvwAAAKgAAACMAAAAgAAA + AH8AAAB+AAAAfgAAAHwAAAB2AAAAZQAAAEUAAAAhAAAACgAAAAAAAAAAlZSTl9u/tv/8wJL9/tmn/v3Y + pv392Kb9/dim/f7Ypv792Kb9/dim/f7ap/3306P9nJaT/qupp/3Jx8f9wsHA/aqop/3Kycz+PWaa/UWH + zf1GidH9SY7V/kuR2v1MlN39TJXh/U+Z5f1Pm+f+U6Lw/VOk8v1TpfT9U6X1/lKi8v02X4n9UXd0/V2C + f/1uj4z+hqKg/Zqzsf2ovLv9qb69/qa7uv2lu7n9o7m4/aS6uf6iuLj9o7m2/aK3t/2huLb9oLW1/p20 + tP2cs7P9nLOx/Zyysf6Np6T9Z4iJ/iVSfv4YS379CiU+4gAAAL0AAACfAAAAhgAAAH0AAAB6AAAAdwAA + AHIAAABqAAAAVwAAADsAAAAcAAAACAAAAAAAAAAAnJubrN+7rf/9yJz//tmr/f/Uo///1aH//9Wh//3V + of3/1aH//9Wh///Vov/60qD/pZ6X/bKwr//X1tX/2NfX/6Siof/n5eP9cISj/0CBx/9Mk93/TJbg/U+X + 5P9Qm+f/UZ7r/1Kg7v9To/H9Vaj3/1aq+/9Vp/j/TJnn/Ttnm/9mhIr/dpSS/3GRjv9niYb9Wn98/1J5 + df9XfXn/b4+M/ZKrqf+nu7n/qb68/6a7uv2lu7j/o7m5/6K6t/+jt7j/oLi1/aC3tP+ftrT/nLOz/5yz + sP2asbD/la2r/1mDk/8LUof/C1SK/QYRGM4AAACzAAAAlgAAAHgAAABoAAAAYAAAAFcAAABLAAAAOAAA + ACEAAAAPAAAAAwAAAAAAAAAAn6CfueC3qP/9yaD//tiv/f3WrP/90J///c6d//7Onv39zp7//c6e//7P + nv/7z53/qqGY/a2sq//b2tn/6unp/8C9vP/Qz8390NPY/0hwo/9KleH/UZ7r/VKh7/9To/H/UqLx/0+d + 6/9Jkdr9QoDB/z9xqP9Ca5X/Tm+K/W6Lj/99mpj/f5ya/4KenP+Dn539g5+e/4Kem/94l5X/Z4qH/Vd9 + ef9egn7/e5mW/5mxr/2nvLv/pru6/6W6uf+iurf/o7m2/aC4t/+gt7T/n7S0/520sf2asbH/mbGv/42q + q/8aZpX/AFqU/i5hdPIZHh7GAAAApAAAAIAAAABXAAAAPwAAADEAAAAmAAAAGQAAAA0AAAAFAAAAAAAA + AAAAAAAAnp+eueCyof/9yaD//NWu/f7Vrv/+0qj//sqa//zJmP3+ypj//sqY//7KmP/7yJn/qqCY/by6 + uv+2tLP/9fX1//b29f+rqaj99PPy/8HJ1P9HcaX/RYnQ/USDyP9Ac67/OmaW/z5khv9KbX/9XHuC/2mI + iP91k5D/fZmX/X+cmv+Anpz/hKCe/4aioP+Go6H9iKSi/4mkov+JpKL/iaSi/YWgnv92lZP/YIOA/1N6 + dv1qi4j/kaup/6S6uf+lu7r/o7m3/aO5tv+guLb/oLW1/521tP2dtLL/mbKw/5qxrv9FgqD/AFqT/SJs + kf9ee3fzICsqvwAAAJEAAABgAAAAMQAAABYAAAAMAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAnJ2cuNuy + o//9xqL//NSy/f7Vsf/+1LL//tGr//zGmv38w5T//MSU//3Elf/6w5T/q6CY/dTU1P+2tLP/rayq/9XU + 0/+0srH9q6mo//Lx7//g4OP/pq69/aepsv9vfHv/WH14/2KGgP9qjIj9cZGP/3aVk/97mpf/gJuZ/YKf + nP+GoqD/h6Ki/4qlov+MpqX9jaek/46npv+Op6b/jael/YympP+LpaP/iaSi/4OenP1pi4j/T3dz/16B + fv+Pqaf/qL29/aS6uP+jubb/oba2/562tf2es7P/mrOw/5qxsP94nqj/AFiR/RFikv9oi4z/ZIOA9yQw + L7cAAAB/AAAATAAAABkAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAl5aWp9Kvov/9w6P9/da4/vzU + tv381Lb9/Na4/f3Vt/79z639/cih/f3CmP34uo39raWf/trZ2P3Z2Nf90M/O/ba0s/26uLf+uLa1/YeJ + h/2lpaP9o6Of/nB/ff1Xe3f9X4N//WaJhv1uj4z+dpWS/XuZl/2AnJv9hKCe/oiiof2JpaP9jael/Y2o + pv2Qqab+j6io/ZGqp/2Rqqf9kaqo/pCpqP2OqKX9jKWl/Yqko/6Io6H9hKCf/W+Qjf1PdnH9XoJ//pWu + rP2lu7r9ori3/aG3tP6ftLT9nbSy/ZuysP2Wrq39FWKS/gVYjv1tlKD9dZOP/miJhvwiLi2yAAAAegAA + AEMAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk5KQjsOrov/7vKD//di//f3Yvf/92L7//di9//3Y + vv392L7//Ne+//7Xvf/yxqj/sK2q/d/f3v/d3N3/3t3d/9/e3f/g39/9ycfG/2B4dP9Td3P/VHd0/VN5 + df9af3z/YYWB/2aJhv9qjIn9cJCO/3aVk/99mpj/hZ+d/Yukov+PqKb/kKqo/5Kqqf+Sq6r9k6yr/5Sr + q/+Uq6v/kqyr/ZGrqv+Rqqn/j6mm/42npP2Jo6P/h6Kf/4Sfnv99mpn/ZYiE/VB3dP91lJL/n7a0/6K4 + t/2gtbX/nLOz/5qzsP+csrD/NnSX/QJTi/9ShJv/kKil/3KRjv5igX71GyMiqQAAAHIAAAA4AAAACgAA + AAAAAAAAAAAAAAAAAAAAAAAAkI6Ma7Sln//2s5j//d3I/fzZxP/82cX//NnF//3Zw/382cX//NnF//3b + xf/hwrD/vbu7/eTj4//k4+H/5OPh/+Pi4f/l5OX9vry7/1l4dP9Renb/UXl1/U52cv9NdnH/T3Zy/1F4 + df9UeXf9VXp4/1R6d/9Tenf/Vnt4/Vp+e/9liIX/c5OQ/4Sgnv+Qqqj9lq2t/5evrf+Wr63/lqyr/ZWt + rP+SrKv/kquq/46pqP2Np6X/iqSh/4ahoP+Cnpz/fZqY/XCQjv9Ve3j/XoF+/5Wtq/2juLb/nbS0/5u0 + sf+csrH/XImf/QVSif81cJP/kKmn/4mkov1tjoz/WHRy6hAWFp0AAABmAAAAJTU1NQQAAAAAAAAAAAAA + AAAAAAAAko+OQqCbmPTrp4///d/O/f7ey//+3sv//t7L//zcy/3+3sv//t7L///fzf/Lr6L/0dLS/erp + 6f/q6ef/6unn/+no5//t7Oz9qaqo/1R3c/9NdXH/SnJu/VuAfv9ujo7/eJaX/3yam/9/nJ79gp2f/4Cd + nv+AnJ3/dJOT/WKEgf9khoP/WX56/1F4df9TenX9Y4aD/3uZl/+Qqaj/mLCv/Zevrv+Wrq3/k6uq/5Kr + qv2Pqab/jKal/4eiov+EoZ//f5ya/XmXlf9yko//XIB9/052cf2OqKb/oLa1/5yzs/+bs7H/ep2m/QpR + h/8iYIz/iqWm/42npf2EoJ3/a4yJ/0pgX9oCAwOJAAAATgAAABMAAAAAAAAAAAAAAAAAAAAA2NfWHY2M + i9vSnYv+/9jG/vzi1f384dX9/OHV/f3h1f784dX9/eLV/fvf0f21oJX96+vs/u/v7/3u7+/97u/v/e/v + 7/3v7+/+ipGP/Ulxbf1Venj9eZeY/oKdn/2BnZ/9gZ2f/YKeoP2Dn6H+hKCg/YWfov2GoaP9dpST/nGQ + jf2AnZv9f5uZ/XyZlv10k5D+ZoiF/VZ7d/1MdHH9Wn98/n2amP2Vraz9mK6t/ZOsq/6Rqan9jqil/Yul + ov2GoqD9gZyc/nuZl/11lJL9bo+M/V+DgP5MdG/9lKyr/Z61tP2cs7L9kaus/hVVhf0XVYb9fJyi/Y6o + pv6LpaP9fJmX/meHhfwtPDu9AAAAdAAAAC8ZGRkGAAAAAAAAAAAAAAAAAAAAAI+OjKatm5X/+rqi/f7q + 4P/+6N7//uje//zo3v3+6N7//ung/+7Nv/+2qaX/+fn5/fT09P/19fX/9PX1//b19f/j4OD9Y3h1/1l/ + fP9/nJ7/gZ6f/YGdoP+Dn5//gp6h/4Wgov+EoKH9h6Gk/4eipf+KpaX/cpGP/XmWlP+HoqD/g6Ce/4Ke + nP9/nJr9fZqY/3qYlv92lJL/aouH/VV7eP9SeHT/bI2K/4umpP2Uraz/kKmo/4ylpf+Io6L/g5+c/X2b + mf93lpL/cJCO/2iKh/1Yfnr/Vnx4/5Stq/+dtLL/m7Kw/Sdeif8TT4L/bY+d/4+ppv2KpqT/h6Kg/3GR + j/9ffnvxCAsKkgAAAFMAAAAVAAAAAAAAAAAAAAAAAAAAAKCdnE+SkI/72JqE/v7h1f/+7OT//uvj//zr + 4/3+6+P//+nf/8yjlP/W1dX//Pz8/fv7+//7+/v/+/v7//7+/v+0s7L9VHVz/3uYmv+Dn6D/gp6h/YOg + ov+EoaH/haKi/4ahpP+HpKX9iaWl/4ympv+Np6j/bY2L/YOenP+Np6b/iaWi/4ijoP+EoZ/9g5+d/4Gd + mf9+m5n/fJmX/XiWlP9ujov/W398/1F3c/1rjIr/iaSi/42opv+JpKL/hKCe/X6amP94l5T/cZGN/2mL + iP1fg4D/THRw/16Cf/+asa//n7Wx/T1qjv8SSX3/XIKX/5KrqP2MpaP/iKOh/3+cmf9piof9NERCwgAA + AG8AAAAsNDQ0BAAAAAAAAAAAAAAAANXU0xGIhoS/oJGM/+yqk//+4tf//uvj//7r4/3/6eD/7rqm/7Kf + l//y8/T/9vb2/fb29v/29vb/9/f3/+7t7f9xfnv9Y4eF/4Sgov+EoaH/haCi/Yaho/+JoqX/iqOm/4qk + pf+Lp6j9jaeo/5Coq/+Qqqr/bIyJ/Yumo/+TrKr/kamn/42np/+MpaP9iKOh/4ahoP+Fn53/gZ2b/X6c + mv98mpf/epiV/3KRj/1Zfnv/VXp3/3STkf+HoqH/haGf/X+cmv95l5X/cpKP/2qLiP1ghID/VXt3/0py + bv9xkY7/obez/VN5lP8UR3v/TXOP/5OtqP2LpaP/h6Kg/4Sgnv9xkY7/Wnh17AQFBYcAAABCGRkZCwAA + AAAAAAAAAAAAAAAAAADZ2Nkog4GA7JaLhv/Ol4P/97Sc//y8pf3cnIT/oIyE/9TU0//l5OP/4+Li/eTj + 4v/l5OP/39/f/6Gclv9mhoH9fJqa/4ijpf+JpKT/iaWm/Yymp/+Mp6j/jaeo/5Cqq/+Sqqz9lK2s/5au + r/+Wra3/aYuI/ZWurP+asrD/mLCu/5Surf+TrKn9kaqo/4+npf+Lp6X/iqWh/YehoP+EoJ7/gp6c/3+c + mv19mpj/dZSS/12Bfv9Qd3T/d5WU/YGdmv95l5X/cpKP/2qLiP1hhID/VHt3/1J4dP9JcW3/iqWi/WuM + nP8ZRnn/QGaI/5KsqP2Np6X/iaSi/4Wgn/98mpf/aYuI/yMvLqgAAABOGhoaEQAAAAAAAAAAAAAAAAAA + AAAAAAAAmpiWQYOAf+iChIT+iIOB/YuCfv6MjYz9ysnI/dva2v3Z2Nj92djY/tnY1/3Ix8j9pZyW/e3C + nv2KmIz+fpuc/Yymp/2Npqj9jaeo/o+qqf2Sq6r9lKut/ZSurf2WrrD+mLCw/Zyzs/2YsLD9aIiF/p60 + sv2gt7X9nrWy/Zyzsv2YsLD+l7Cu/ZWurP2TrKr9j6qo/o6opv2LpqT9iaKg/YWioP6Enpz9gZ6b/X+c + mv1xkY79S3Nv/meJhv14lpT9cZGP/WmLiP5ggoD9U3p2/VN6dv1OdXH9XoJ//nyXov0fRnf9OV2B/ZKr + p/6Np6X9iaKg/YWgn/2AnZr9a42K/jNEQroAAABUGhoaEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIqK + ii6UfnXRmol//5SHgP2qnJX/saOd/6+knP+vpJz/sKSd/bGimv/AppL/7sGf///Ppv+MmI39eJeX/5Cp + qv+Qq6r/k6yt/ZWsrv+Vr67/ma+x/5uxsf+dtLT9nra2/6K4uP+ftbb/aIiF/aO5t/+lu7r/ori4/6K4 + tv+ftrP9nbSz/5uxsf+Zsa//la+t/ZStq/+Qqaf/j6mn/42npf2JpaH/iKOh/4Sfn/+Dn53/cpKN/U10 + cf9dgX7/cI+N/2iKh/1fg3//U3p2/1N6dv9SeXX/SnJu/X+anv8mTX7/MV+O/3+fp/2Np6X/iaSi/4Of + n/+BnZv/bo+M/jhKSMEAAABVGhoaFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGtpA/pm3jR9quI//Kv + i/3yso7/8raR//K5lP/yvJf/8r6Z/fbDnf/+yqP//8yl///Qp/+boJD9b46O/5Krq/+Wra//l6+v/Zmy + sv+ctLT/nbS0/5+3tf+jt7f9pLu7/6i9vP+lurr/aIiF/aa8u/+qv77/qb28/6e8uf+jurn9ore3/5+3 + tP+etrT/nLSy/Zqwrv+Wrqz/la6s/5Osqv2Pqqj/jqam/4umpP+GoqD/aouH/XWUk/9XfHr/WH16/2aJ + hf1dgH7/Unl1/1N6dv9Tenb/SnJs/VGDm/8oXJL/Ik2B/0NjhP2Qq6b/h6Kg/4Ogn/+BnZv/cJCO/jtN + S8QAAABUGhoaEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGFENjj7rIbt/LCL//y1j/39uZP//b2X//3A + mv/+w53//cag/f7Jov//y6P//82m///PqP+yq5b9ZYiF/4mko/+cs7P/nrW1/aC3tf+it7f/o7q6/6e8 + u/+pvr39q8C//6zAv/+nvLv/aIiF/aW6uf+rwL//rMC//6vAv/+pvr39pr26/6a7uv+iuLj/ori2/Z62 + tP+dtLH/mbGx/5evr/2Wra3/lKur/5Gqqf96l5X/bIyK/Yahov9/nJ3/VXp3/1V7d/1agHz/Unl1/1N6 + dv9Tenb/T3Zv/S1eg/8fRHX/HUV3/0Jkhv2QqqX/h6Kg/4Sgnv+AnZv/b4+N/jlMSsEAAABPGhoaEQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2OcWT8roj8/LON/vy2kP77vJb9/b6X/fzDnP38xJ/9/Mig/v7J + pP39y6b9/c6n/f/PqP3Rup7+bY2L/XKRjv2dtbT9pLm5/qa8u/2ovr39q7++/azAv/2swL/+q7++/am+ + vf2jubf9aYmG/puysv2kurn9p7y8/aq/vv2swL/+rMC//aq/vv2ovbz9pby5/qW6t/2ht7f9oLe0/Z61 + sv6csrL9mrKw/YumpP1oiYf9g5+f/oijpf2GoaP9fpub/U11cP5Tenb9U3p2/VF4dP1SeXX9UHdw/i1g + gv0ST4T9DU6D/UJsi/6PqaT9hqOh/YKenP2AnJr9bI2K/jVGRLkAAABKGhoaDwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPGohpf8sYr/+7WQ//u4lP39vpj//sGb//7DnP/+x6D//sij/f/Mpf//zqf//82o///P + qP/uyaX9epSP/3+cmv95mJX/rL+//azAv/+swL//q7+//6q/vf+ovLz9pby7/6W7uf+htrX/a4yJ/ZKr + qv+etbX/oLW1/6G5t/+ku7n9qL29/6u/vv+swL//q8C//am+vf+mu7r/pru6/6K4uP2iuLf/mrKw/3CP + jP96mJf/jqip/Yukp/+Io6P/haGj/3iXl/1IcW3/Unl1/1N6dv9Tenb/UHdx/TBkfP8PTYP/PWWI/4qk + pP2LpaP/h6Kg/4Ofnf98mZf/aouH/ys9M68AAABLGhoaDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOyj + f7z8s43//beQ//u6lv38wJj//sOb//7Gn//+x6D//cmk/f/Npv//zab//8+o///PqP/+0Kj9iZqF/4ul + pv99mpf/haKg/aq/vv+ovbz/p7y7/6a7uv+kurn9ore3/6C3tf+ftLP/bo6L/Ymjo/+XsLD/mLCw/5yy + sv+ftLT9oLa2/6S6uf+mvLv/qb6+/avAv/+swL//qr++/6i+vP2lu7r/eZeV/3SSkP+Tq63/kaqr/Yym + p/+Jpab/hqGj/4eho/1ihYT/TnZx/1N5df9Tenb/T3dx/S5edv8ZR3v/ZIKU/5Cqpv2Jo6H/hqCe/4Ke + nP9xkI//Zo5+/iFKDbAAAABNGhoaEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPSqhdj8tY///bmT//29 + lv3+wZv//sOe//7Hn//9yqP//cyl/f/Op///z6j//8+o//7Qq/+htFL9WqFC/3qYlv+mu7r/dpSR/Yij + of+kurn/o7m3/6G2tv+ftrP9nbSx/5qxsf+asbD/cpGO/X+bm/+Sq6z/kq2s/5atr/+XsLH9mbKx/52z + s/+etbb/obe3/aa7u/+pvr3/q7++/6zBwP2En53/b5CM/5atrv+YsLD/lKus/Y+qq/+Np6f/iKOm/4ei + pP1+nJ3/THRw/1J4dP9TeXX/T3Zv/SJYfP8iUID/gJug/4ynpf2JpKL/haGf/3qYlv9riIj/PKVj/iFS + B7UAAABPGhoaEQAAAAAAAAAAAAAAAAAAAAAAAAAA7828Cvmviez8tpD//bmT//y9mf3+w5v//saf//3H + ov//y6T//c2m/f/NqP//z6j//tCs/6a3V/9KwD39XNuJ/2iaiv+ds7P/qL69/XKRj/+Anpv/nrW0/5yz + sv+asLD9mLCv/5Wvrf+Vraz/eJaU/XaUk/+Npqj/jamo/4+qqf+Rqqv9k62u/5evsP+YsbD/nLOz/Z20 + tP+itrj/pbu6/4ijof1piob/mrGx/6G3t/+cs7L/lq6w/ZSrrf+QqKr/i6Wm/4ikpP2IoqP/WX97/011 + cf9TeXX/SXJv/RVPgP9DbIz/kKmm/4ukov2Io6H/f5yZ/22Kiv9Vkn3/CMJL/iJWCrkAAABRGhoaEgAA + AAAAAAAAAAAAAAAAAAAAAAAA9dLAF/uwi/H7uJL+/byW/f3Amv78xJ79/Meg/f7Iof39zKX9/syl/v7P + qP36zab9lbZM/UrFSv1b4ZX+YuKV/WbGkv12kpH9q7++/qO5uP15lpT9dJOQ/ZStq/2Vrqv+k6qq/ZGq + p/2PqKf9fZuZ/m6Oi/2HoqT9iKOm/Yymp/2Mpqf+jqeo/ZCpq/2Sq6v9lK6t/piwsP2asbH9fpqZ/WmK + hv6juLf9q7++/aO5uv2gtbb9mrOx/peurv2RrKv9j6eo/Yqmpv6JpKb9dZSU/Upybv1SeXT9NWdz/htV + hv2AnqL9jqel/Yqlo/58mZf9bImI/VaSff0KvFX9AcNP/iJbC70AAABUGhoaEwAAAAAAAAAAAAAAAAAA + AAAAAAAA99TBIfuyjPX9uZP//byX//zBm/3+xZ///sih//3Kov//y6b//s6n/fjNpf+Ttkv/TMVN/1jd + j/9f35P9ZuOY/23jnP9ppYr/jKSk/aa8uf+etrT/gJya/26OjP+HoqD9jail/4ympP+JpKL/gp6b/WqK + h/+Cnp//hqKj/4ahpP+JpKX9i6Wm/4ulpv+NqKn/kKmq/Y6oqP90kpH/cJCO/5uzsf2rv77/rMC//6m+ + vf+kuLn/n7S0/Zmysv+Wra//kqus/42oqP2Lpaf/hJ+g/1F5dv9Kc2//HFyA/WyQn/+Rqab/haCe/3OS + j/1oiIf/UJlw/wy8Vf8Awk//AMNR/iBfD8EAAABVGhoaFAAAAAAAAAAAAAAAAAAAAAAAAAAA+NXCIvyz + jfX9upT//b+Y//zBnP3+xp7//cmi///LpP//zaX//s6r/aW6W/9KxEv/UtuL/1vfkP9j4JX9aeSZ/3Lm + oP9y2JT/a5CH/Zeurv+ftrX/mbGv/4eioP9tjov9fpuZ/4ahn/+EoJ7/gZ2b/WmLiP97mJn/g5+h/4Sg + oP+EoKH9haKi/4ijpP+KpKX/hqGi/XCPjf92lJL/mbGw/6S5uP2ou7r/q7++/6zAv/+ovbz/o7e5/Z21 + tf+asLD/lK6t/5Kpqv2MqKn/i6Wn/1yBfv84a3X/W4ia/YWgnf90kpH/aomJ/3OMhf2nnnT/NLU0/wDC + UP8AwlH/AMNS/h1lFMQAAABVGhoaEwAAAAAAAAAAAAAAAAAAAAAAAAAA+dbEHPy2j/P9upX//cCZ//zC + nf3+x6D//cih///Mpf//zan/vb1r/UvCRv9N3Ij/Vt2N/17gkv9m45b9buWd/3Xmof9866j/e8+g/XCP + jf+Xr63/mbGv/5Stq/+Io6H9bo2L/3KRjv99mpf/fJmX/WyMif9vj43/e5mZ/4Cdnv+Cn6D9hJ+h/4Of + oP94l5f/aIqH/XuZlv+XsK7/nbSz/6G3tv2jurn/qL26/6u/vv+swL//p726/aK3uP+cs7P/l7Gx/5Ws + rv2Qqqv/iqSk/1+Ehf9Vf4j/b42M/WiIhf9gj3T/V5VB/2iTIf1crB//Cr5F/wDCUf8AwlH/AMNS/h1l + E8MAAABRGhoaEgAAAAAAAAAAAAAAAAAAAAAAAAAA+9jFD/y1j+77vJb+/b+a/f3Env78xqH9/sqi/f/M + p/3YxoX9Rroz/kfZgv1R3In9Wd2N/WHhlP1p4pj+ceaf/XfnpP2A6qj9iPCv/n3Fn/1wj4z9kqqq/ZOr + qv2Np6X+haGe/XSTkP1ri4j9a4yJ/mmJhv1qi4j9aouH/WmLh/13lZX+dpWU/WqKiP1ri4j9gZ2b/pGq + qP2Vrqz9mbCw/Zyzs/6htrX9pbm5/am9vP2rwL/9q8C//qW6u/2gtrb9nbS0/Zavr/6Ura39d5SV/WWL + d/1hjlv9Wpc9/jazQ/0Nw1H9Grw3/TKyIv4Kv0f9AMFR/QDAT/0AwlH9AsNP/iJeDLsAAABKGhoaDwAA + AAAAAAAAAAAAAAAAAAAAAAAA/NrGAvu2kOL9vZf//sGb//zFnf3+yKH//sqk/+rJlv9euz3/PtZ8/Ura + hP9T24r/W9+Q/2PglP9r5Jv9c+eh/3vopv+D7Kz/i+2x/ZLzt/+Dx6X/b5CM/4mkov+MpqT9haGf/4Cd + mv91lJL/aoqH/XWVkv9/m5n/fpuZ/3SSkP9oiYf9aoqH/3eUkv+Cnpz/h6Oh/Y6npv+Sqqj/lK+t/5qy + r/2etbT/ori3/6a7uv+pvr3/q8C//au/vv+ku7n/n7a3/520tP2LpKb/YY9i/0avI/81wD3/JMVP/RHI + Xf8KxVj/AsNT/wDCUv0AwlH/AMJR/wDCUf8AwlH/DcBH/yJRB64AAAA/GhoaCgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPq6lcf9vpb//sCa//zFn/3+yKD//8un/6O/Xv84zF//Qdd//Urahf9V3Yv/Xd6R/2Xi + lf9t5Zz9deii/33qpv+F663/je+x/ZXyuP+e9L7/j9Gt/2+SjP9/mpn9g5+d/32amP90k4//b4+M/Yah + n/+TrKr/kqup/4Ofnf9ujov9bIyJ/3uYlv+AnJv/hKCc/Yijov+PqaX/k6yq/5evrP2ZsbH/n7Sz/6O3 + tv+murn/qL69/azAv/+qvr7/pbu7/5GoqP1mkYf/Qr5Y/y/NZ/8kzmz/G8tl/RTHX/8Mxln/A8JS/wDA + T/0AwlH/AMJR/wDCUf8AwlH/Gb87/xo8BJgAAAAyFxcXBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPq7 + lqb9vZf//sKc//zGnf3+yKL/9Mmb/2S+Rf841Hj/Q9d//UvZhv9W3Yz/XuCS/2bjl/9u5J39deij/3/r + p/+H7a7/j/C0/ZfxuP+f9b//p/nF/6DjvP9zmZD9bo6M/2yMiv9sjIn/bo2L/YeioP+gt7X/n7a0/4mk + ov9ykI39aYmG/3CPjf95l5T/gJya/YWhn/+LpqT/kKmn/5Osqv2YsK7/nLOy/5+2tf+jubj/qLy7/au+ + vf+kurn/haCf/2WUhv1Hxn7/NdV4/y3Rcf8mzmv/HMtl/RXHX/8Nxlj/BMJU/wDAT/0AwlH/AMJR/wDC + Uf8AwlH/Jrcv+woYAHkAAAAmg4ODAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPu7lnv9vZf//MKc/fzE + n/7+yKL948WN/UvCSv051n39QtZ+/k3bhf1W3I39XeCR/Wfjlv1v5J7+duii/YDrqf2I7K/9kPCz/pjz + uv2f9MD9qfjE/bH7y/2z9Mz+fKSZ/WaGhf10k5T9epeZ/nGRkP1/m5n9iaSi/X6bmP1sjIr+b42N/W2N + i/1qi4j9bIyJ/nSSj/1+m5n9hqKg/Y2npv6TrKr9l6+u/ZqxsP2Zr679kKmn/nyamP1riov9XJhi/UvV + gv4/1379N9J2/S/Pcf0lzmv9Hstl/hTHXv0Nxlr9BMJT/QDAT/4AwE/9AMBP/QDAT/0AwlL+L6Uh7AIF + AGQAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP3PtEX9vZf0/sKc//zGn/3+yaL/38aK/0jD + Tf861n3/QtZ+/U3bh/9X3I3/X+CT/2bjmP9w5J79eOik/4DrqP+I7K//j/C1/Znzu/+h9MH/qvjG/7D7 + zP+7/dH9yf7c/7PbyP+CpJ3/aYmI/XKQkP92lZX/cpCQ/2eJhf9ykZD9dZSU/3iWlv96l5j/eJaX/XOS + kv9vjo3/a42L/2qKif1rjIr/a4yK/2mJh/9jhoT/YYWD/YiYjP9ppT3/TMpS/0rahv1B1X7/NtJ2/y/R + cf8lzmv/Hstl/RTHXv8Nxlr/BMJT/wDAT/0AwlH/AMJR/wDCUf8BwlD/MIcV1gACAE8AAAARAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzl2B77vJbg/sKc//zGn/3+yaL/3sSJ/0jDTf861Xv/QtZ+/U3b + h/9V3Iv/X+CR/2fjmP9w5J79eOik/4Drqf+I7K//kPC1/Znzu/+h9L//qfjG/7H7yv+5/dD9xv/a/9D+ + 4f/Z+ub/yePX/Y+wn/9li3f/bYyM/2uKi/9tjYz9dJSU/3iWlv96l5n/e5ia/XyZm/97mZr/eZeZ/3ST + lf1uj4//bIyL/3iRi/+aopP/1cCl/aC+XP9Sy1f/UtyL/0rYhP1B137/NdR4/y3Rcf8mzmv/Hstl/RTI + Xv8NxFr/BMNT/wDAT/0AwlH/AMJR/wDCUf8LwEj+KFwItAAAADc0NDQIAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP7q3wH7vpiy/sGa//zGn/3/yaX/xcF0/zvGVf851Xr/Q9Z+/UvZhv9W3Yz/XuCS/2Xj + lv9v5J39d+ij/3/rp/+H7K7/j/C0/Zbxuv+g9cD/qPjH/7D7zP+3/c/9w//Y/83/3v/W/+T/4f7s/dT0 + 1f9lsTn/UJIr/1qKTP+Fm5D9eZSN/3OQjP9xj4z/co+M/XSRjP96lI3/gpeO/5Kfk/2urpr/0b+j/+vN + qv/91K//5s6W/VjGT/9Y34//UdyJ/0nZhP1A0m//PMhX/y3Oaf8mzmv/HMtl/RTIYP8Kxln/AcNT/wDC + Uf0AwlH/AMJR/wDCUf8duTf7GDMCgwAAACFVVVUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD8y6xd/sCa+/3Fnv73x57/brtF/y/Pav851Hn/QNd9/Uzahf9U3Yv/W+CR/2Xhl/9t5Zz9deii/33p + pv+F7a3/jO6x/Zbyuv+U7q7/g9p9/5fpoP+1/ND9vv7V/8f/2v/P/+D/1v3k/d3/6f/S9tj/oNyO/0yi + Ef/b05/979u6/+XWtP/i1LL/49Kx/ebTsf/v1bH/+Ney///as/3/2rL//9ex//7Vr//+1K7/6M2Z/VnI + Vf9X3o//UNuI/0XVef15uED/wcJy/1e/Rf8izWr/Hclg/TK1Lv9EsTX/OLs//wHBTf0AwlH/AMJR/wLC + T/8vnR7lAgQATgAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+7+cZ/L6X1P/F + oP6xvGH9LcZT/S7Rc/020nb9QNV9/krYhP1S24r9Wt+O/WHglf1r5Jn+c+ef/Xnopv2B7Kr9jPC1/nXb + e/2EwU791M6Q/X/BSv2x/M/+uP3P/b3+1f3F/dj9y/7d/s793v3R/uH90/3m/X/MXv3z3LP+/OG8/fzf + uv383rn9/N24/vzbtv382rX9/dmz/f3Ysf781rH9/Nau/fzVrf3+0qz9/9Ku/mvASP1T24j9TNuH/UTM + XP6brkb9/s6q/W+7RP0gzGb9GMpj/je0KP1ymiD9s7Va/Qe+P/4AwVD9AMJR/RC+Q/4kVAirAAAAMV5e + XgUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/cWigf/Eov9auDf/JM1p/y7P + cf8203b/PdZ6/UbZgv9Q3If/WN2O/2DhlP9o4pn9cOaf/3jnpP9/66r/atFq/a7Eaf/517H//9q4/6rF + Zv+a7639s/zO/7j9z/+7/tT/wf7V/cX/2f/G/9r/v/nS/4bFVv//4cD9+965//veuf/93bj/+9u3/f3b + tP/92rT//dmz//zWsv3+1a///tSv//7Trv/+0qz//9Ox/Za/V/9N1nn/S9uJ/z/KV/2zt2D/scBp/zPD + TP8fzGj/F8lh/RTEVP9lqin/sLRb/we+P/0AwlH/AMJR/yWuLfIRJQF4AAAAHAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/tzNJs25c+srvjz/I85q/yzQbv800XX/PNV5/UXY + gf9O24f/VtyM/1zgkP9k4Zf9beWb/3XmoP9966r/UbQs/cG+eP//2rb//tm1/77Id/+M6Jr9rPrJ/7H7 + zP+1/M3/t/3P/br+0f+9/tb/k+CM/7zMfP/+37z9/d65//3duP/93Lf//ty4/f7bt//92LL//Niy//zX + sf3+1rD//tWv//7UrP/+06v//tKs/drKjP9bwUj/Q9Jv/z/DRf3myI7/ZL1D/yTNaP8fzGb/Fclg/RHF + Vv9SqBz/Zq4u/wPASv0AwlH/BcFN/y6KF9UBAwBKAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAntV/FUezJt8ZyWD/Isto/yrPbv8w0HL/ONR5/ULXf/9L2oX/U9uK/1vf + jv9j4JX9auSa/3Hmn/946af/XcNJ/WOaHv/izJr//tm3/6XDYP+S7az9pvfF/6r5x/+u+sn/sfvK/bT8 + z/+b6qL/k8Vb//rcuP/83bj9/d22//3ct//727f/1MmO/c3Gh//92bP//taw//zVr/3+1K7//tSu//7U + rv/+063//tKr/f7Rq//YyIj/osBg/7PCa/3/zqr/ab1E/yLMZv8by2X/E8hf/Q7FVv83siH/GLo4/wDC + Uf0AwlH/FL1A/iRWCJ0AAAAoVFRUAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAveGmFDe0INoUymX+H8xn/SfObP0tz3H9NdN1/j/Wff1I2YP9UNuI/Vfcjf1d4JL+ZuGX/Wvj + nP1056H9dOKT/kiiDP1XkhH9jahC/Wu8Pf2b9cD+n/W+/aP1wv2m9sT9qfjG/qv5yP1sv0P93tGb/f7c + t/373LX+/Nq2/fvbt/2jt1r9Rp0H/kaSBf3Cvnn9/9u7/f/ZuP7/17X9/dOt/evLnf3jyJX98s2h/v/S + r/3/0Kz9/9Cs/f/Pq/7/zqv9nr5b/SLGVP0ZymP9EsZd/gjFV/0BwlP9AMFR/QDAT/4Aw1L+L6Uh5wsZ + AFQCAgMPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGy7 + M1ApvkH/G8tm/yTNav8qzm//MtJz/TzVef9F2ID/TNqF/1Pciv9a3Y/9YOGU/2jjmf9v5Jz/deil/XPg + jf9bvz//VbYv/3/ikf+S8bb9l/K6/5z0vf+e9b//ofTA/aH2wf9Zsyz/r7lo//7cuv/72bT9/9q3/7fJ + dP9nylb/j/Cy/WTFT/9FkQD/cJ0r/3yhNf1lmh7/UZYH/0WVAP9DlAD/RY8A/WmZIv/KvXv//s+p//7N + pv3/zaf/8MmZ/2W5O/8Wxlb/DsZb/QbCVv8AwVD/AMJQ/wDCU/4guzb9IUsGhQAAABpJSUkBAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBrQ2kIMZX/R/M + aP8pz2v/MNFy/TjUeP9A1X7/RtmB/0/bh/9W3Yz9Xd6R/2Lilv9q5Jr/cOad/Xboo/986qf/geuq/4bt + rv+L77L9je2w/4Pllf+P66n/mfO7/Zz1wP9tzV//aJ8h//zZtP/92bP959Of/3XJWf+N8LX/iu6x/YDo + o/9iylf/VLcy/1W9Pv1ZxlP/W9Bn/1nTcP9U0Wv/TsdR/UarHP9lnSL/7cmb//7Op/3/zab//8qk/+fE + j/9otzr/DsNP/QPDU/8AwVD/AMJR/wvASP8zfQ24AgUALiIiIgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACn1oYgPLgs3B3KY/8lzWr/LM5u/TTR + dP881Xv/Q9Z+/0rahP9R3In9WN6O/17fkv9j4pX/aeSb/XDmnf926KP/e+mm/4Drqv985pr9e8dW/6PE + Zf93yFb/kfG5/ZLxt/+E5Zj/ZKwn//fVrv//2LT9xst//3XafP+I7rH/geyq/X3qqP946Kb/ceaf/23k + nf1n45r/YeGW/1rfkv9Q2YL/S9Fs/UnGTf+BukP//c6n//7Mpv3/zKX//cih///Hov/qwY3/VbYz/QLB + Tv8AwlH/BMBO/jOmHuYIEQBDCAgJDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY7gvXSy/QfUezGn/Js9t/S/RdP821Hn/PtZ8/0TY + gf9M2ob9U9uK/1nfjf9f35H/ZeKX/Wrkmf9u5p7/dOei/3foo/90wEb969Gh//nWsf+ExFX/h+6w/Yru + sP+B6aL/jcNY///Xtv//17X9ocVk/3bikv9/66n/fOim/XXoo/9x5Z7/bOWc/2fjmP1h4ZP/Wt+R/1XN + Yf99vUn/ucNt/dLGgf/ny5b//s6n//3Npv3/y6T//cih//7Enf//wp7/2bp5/Si4Mf8AwVL/JLUw9R9F + BHQAAAASVFRUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA5/TfBVq4K44xvTj6L8BC/0i+Qf5SuDb9P8hY/T/Wfv1H2ID+TdmG/VPd + i/1Z3439Xd+R/mLilv1p45n9buei/V7XdP3Gx3n+/9a1/dvMkP1qx1T9geyv/n/rqv1ox1L9z8uH/f/W + sv3/1rL+hMNV/XXmnP146KP9dOeh/m/mnv1q5Jn9ZOGW/V/flP5b35D9Uth//W6zM/3/0K39/8+q/v/O + qP3+zqf9/c2m/f7Mpf79yqP9/sWe/fzEnf38wZn9/72b/pi1Tv4ouiz9MngMjwAAABIwMDACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAOb03gORyWUp3sGFreTEi/5jtTT/Ns1l/zrVev9A1X79R9eC/03Zhf9R24r/WN6O/V3g + kv9e3Ij/Xstc/26/Qv/z0KX93suT/2e4OP9w4pH/d+ij/WXFTP/MyoP//9Wy///Vr///1K/9eMRU/2/l + nP9w5p7/beOc/Wjjmf9i4Jb/X+CT/1rfjv1T3Yv/TtR0/12mIP/syJn//s+o/f/Npv//zqf//8yl//3J + ov3+yKH//sWe//7Cmv/9v5j//7yW/7KJaLcmTwdPDxwIDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/+bcEpm8WsYqyVz/LtFy/zTTdv881Xr9QNd+/0fXgv9M2ob/UNyJ/VXci/9buzz/zcaA//LP + o//40aj9ecBM/2PbhP9t5Jv/ZsVP/czJg///1bH/48mU/9PDhv/eypP9Z8ZS/2rkm/9o4pn/ZeKX/WHh + lP9b3pH/WN6O/1Lbi/1O24f/SNZ7/0epGf+WqEn//9Gt/f/Opv//y6T//8uk//7Jov3+xqD//sOb//3A + mv/+vJb+yJF0uxYPDCwGBQcFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFGz + IHkqx1j+KM9u/zDRcf8203b9OtR5/z/WfP9E2IL/S9qF/U7agv9PqRv/yLx5///Sr//izJT9YNNx/2Tk + nP9Xy1r/vMFx/f/Us//Vxof/XaMd/0uUBv9aqSL9X9d7/2Pil/9h4ZT/XuCQ/Vrdj/9U3Yz/UdyJ/03Z + hv1G2YP/QdeA/0DDSf92piz//86t/f/Lpf//y6P//smj//zFn/3+xJ7//cGa//y8l/vKlXe6FA0LKQMD + AwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALbenBNVuS2xKsdX/yjP + cP0v0HD+UL0+/VW+QP0+1Xv9QtFw/kjFS/1KtCj9VZML/YujO/2BpTb+WNV4/Vzgkv1OujX9kadD/urO + nP1ovUD9WdZ0/VfMW/1a1nn+Xd+S/VvfkP1Z3Y39VtyM/lLciv1O24f9StiE/UbYgf5B1X79O9V7/TfN + Zf12rTT9/82r/v3LpP3+yaP9/Mef/f3Dnv79wpv+/r+Y/LmKbaIRCwggQUJCAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADr9eMMXLguoivGVf8sxU3+yMR6/57A + Yf8zzWL/abMv/cPDdf9KxlD/Sbo1/0ewJP9Jti/9UdmC/1Tdjf9SzGH/RZQA/VmkGf9V2Hv/WN6Q/1je + j/9W3Y39Vd2M/1Pbif9R3In/TtuH/Unag/9F14D/Qdd//z7UfP041Hn/NNN2/zHLYP92rTP//8up/f7J + o//+x5///sWe//3CnP7+wJn2fV1LdQIAABJISEgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6PPfEFu6MJtQsibK8cac3KK/YP4xx1L/UJsI/X6o + M/9Dylz/QNiC/0PZg/9G2YT9StqE/0zZhv9N2of/TMRL/UmeA/9Nv0L/UNyJ/07aiP9O24f9TdmG/0va + hf9J2IL/RteA/UPWf/8/1nv/O9V6/zbSd/0z0nT/LdFx/yzJXP92rDH//8mn/f7Hn//+xJ7//sOc/vS4 + lN5xVEJbGBgXDWZnZwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAOjz3wja6skT/OfZJs7JiJc5vz/4Prcw/kCzKf820Gv/PMxh/0zE + Tf9Dyl79Qdd//0TYf/9G2IH/R9iD/UjFUP9Jw0j/SNiC/0fZgv9G14D9Rdh//0PWfv9B137/PtZ8/TvV + ev821Hb/NNF1/zHRcv0s0G//Js9s/ybIWf+FsUD//8el/v7Env/5v5nrv5FzmjsqISwjJSUDAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPf79AV5w02DMcRL/C3MZv5MvkD/pb5f/6u7Wf88wEL9OdR6/zzV + e/8+1nr/P9Z8/T7Xf/8+1n//QNZ9/z/We/8+1nz9PdV7/zvVev8503f/NtJ1/TLRdf8w0XH/LdBw/yrP + bf0lzGn/H8xo/yTET/+3vWb+/8Sg9t2ohq1gSDpDJyMiCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAdcBDWkipC4DUvn+a9cmf5VO5M/8r03n+MdJ0/jPSdf0003X9NtN1/jfS + d/030nX9N9J1/TXTd/0z0XH+MMxi/TDRcv0v0nX9LdFx/izQbv0ozW39JMxp/SHMaP4cy2f+HsdY/1iz + NOm/nHSaYEg5NigpKQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD+/PoB+ObTEXG7PWw9tijZMcdU/zXFUf8uzmn/LNBz/i7Rcf8u0XH/LtFx/y7L + X/9zuT/+q75g/3O6RP83wUb/J8tk/iLObP8ezGr/HMtm/xvKX/8rwUP7OJMRsRQkAzABAAAGAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACx3JYcdcBIWn6/UFlSuTG7McVO+ijLZf8mzWj/LMdW/Wy2OePzx5za/sek2/TF + mtjLvXjOX68twzS4LtwzuC/fObAjzzaXFKwpaANXPks2ElVUVQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADa7csQXLUmX1m7NqhWvTy/U6criElLMy1fUEYf6tvQHfvr4Bv56uIQ1+LDB8jk + siDJ5LQjx+C0EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////8A + AAD8AD/gP/////8AAAD4AB+AAf////+8lv7wAAAAAAD////Fnf/gAAAAAAAB///LpP3gAAAAAAAAB/+7 + Mv3AAAAAAAAAAH/ah/3AAAAAAAAAAB/glf3AAAAAAAAAAAfnov2AAAAAAAAAAAPrrP2AAAAAAAAAAAGa + jf+AAAAAAAAAAAGrqf+AAAAAAAAAAAGhnv+AAAAAAAAAAAGJhv+AAAAAAAAAAAGQj/+AAAAAAAAAAAOK + hv+AAAAAAAAAAAeJhv+AAAAAAAAAAB+gnv+AAAAAAAAAAB+rq/2AAAAAAAAAAA+0sf2AAAAAAAAAAAe5 + uP2AAAAAAAAAAAfAv/2AAAAAAAAAAAO4t/3AAAAAAAAAAAOwsP3AAAAAAAAAAAGIev3AAAAAAAAAAAGl + Gf3gAAAAAAAAAAHHWf3wAAAAAAAAAAG/Rf34AAAAAAAAAAHAT/34AAAAAAAAAAHCUv74AAAAAAAAAAEA + AFP4AAAAAAAAAAEAAAD4AAAAAAAAAAEAAAD4AAAAAAAAAAEAAAD4AAAAAAAAAAG7lv7wAAAAAAAAAAHF + nf/wAAAAAAAAAAHLpv3wAAAAAAAAAAHPbP3wAAAAAAAAAAHciP3wAAAAAAAAAAHilv3wAAAAAAAAAAHo + o/3wAAAAAAAAAAHsr/34AAAAAAAAAAHhsv/4AAAAAAAAAAGkov/4AAAAAAAAAAOenf/4AAAAAAAAAAOL + iP/4AAAAAAAAAAOdm//4AAAAAAAAAAOTkf/8AAAAAAAAAAeOi//8AAAAAAAAAAeioP/+AAAAAAAAAA+q + p/3+AAAAAAAAAA+yr/3+AAAAAAAAAA+3tv3+AAAAAAAAAB+/vv3/AAAAAAAAAB+8uv3/gAAAAAAAAD+1 + tP3/gAAAAAAAAH+ZNP3/wAAAAAAAAH/GUf3/wAAAAAAAAP/GWP3/4AAAAAAAA//CUv3/+AAAAAAAB//A + T/3//AAAAAAAD//CVP7//AAAAAAAH/8AAEv//gAAAAAAP/8AAAD//wAAAAAAf/8AAAD//4AAAAAB//8A + AAD///AAAAAH//+9lf7///wAAAAf///En/////8AAAB////NrP3////gAAD////Wff3////8AA/////b + iv3////////////hlf0oAAAAQAAAAIAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAAAASAAAAFQAAABUAAAAVAAAAFQAA + ABUAAAAUAAAADDo6OgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADo6OgMAAAANAAAAGAAA + ABoAAAATAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODg4AwAAABsAAABDAAAAXQAA + AGIAAABjAAAAYwAAAGMAAABjAAAAYAAAAFEAAAArAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAA + ABYAAAAxAAAAUAAAAGcAAABrAAAAXgAAADcAAAAZAAAAEgAAAA0AAAAIAAAABAAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANzc3AQYG + BiNHRUSgfHl44HBubOdwbWzncm9u53Jubedybm3ncW9t51pYV9UWFRWdAAAAcQAAADYAAAASAAAAHAAA + ACMAAAAeAAAAJwAAAEMJER5+Gi1OxyRCcPEkR3j3Ij1o6QkRHq4AAACEAAAAbgAAAGQAAABcAAAAUAAA + AEMAAAA1AAAAKAAAABwAAAARAAAADAAAAAgAAAAHAAAABQAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAgHBxiCf37R6enp//708v/14t7/p6en/4WDgv+KiIb/ioiG/4qIhv+LiIb/hoSC+yMi + IqsAAAB0BAQEXRAPD3YAAAB4BQcKfQ8dMqogO2XmJ0h5/yZOhP8cWZj/HFyb/yFdnf8qUIb9SGJp6E5m + ZOJAVFLWLjw7xx4oJ7cLDw+lAAAAkwAAAIcAAAB1AAAAXgAAAEkAAAA2AAAAKQAAACAAAAAbAAAAFwAA + ABMAAAAQAAAADQAAAAkAAAAGAAAABAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAADY2NgJubGmo8fLz//i9qP/8yKD//Nat//+7mf+hjIX/jo6M/5GN + i/+RjY3/kY6N/5GOjP+EgH73QT8/xYWCf/d5e4D/QFNu8ihHd/wpSn3/K1CD/y1Tif8kYaD/JWOl/yRn + qP8lZ6v/KGuv/zJVg/99m5b/dZSR/2+Qjf9qjIn/aImG/117ePZHXlzmISwrywUHB7QAAACjAAAAkQAA + AHsAAABjAAAAUQAAAEMAAAA6AAAANAAAAC4AAAAnAAAAIQAAABsAAAAVAAAADwAAAAoAAAAGAAAAAgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKSg+y87O//i8pv/+5rz///nP///3 + zf//+9H/8rOO/4uHhv+XlZT/lpWS/5eVk/+YlZT/kI2L/5GNif9ZZ3//IUN5/ylMgf8rU4j/L1aO/zFb + k/8xYp3/Km2w/ytws/8tcLT/LnO4/yx1u/8vaKr/epKd/5yzsv+bsrD/mbCu/5Gqqf+GoaD/eJaU/2qM + if9lhoP9T2hm7ik2NdcFBwfAAAAArwAAAJ0AAACHAAAAcgAAAGMAAABaAAAAVQAAAE4AAABGAAAAPQAA + ADIAAAApAAAAIAAAABcAAAAOAAAACAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoB+sPPc + 1f/8yp////PI///wxf//8Mb///DG///zx/+zjn3/m5qZ/56bmv+XlZP/h4SC/4eFgv+VlJb/JUl7/y5W + jP8vWpL/M1+Y/zVknv83Z6L/NnCv/zJ4vf80esD/NXzC/zV8xf80f8f/N4HJ/1h0kP+ftrP/m7Ox/5y0 + sv+dtLL/nbSy/521s/+bsbH/jqim/3yZlv9sjYn/ZIWC/EVbWesYHx7SAAAAvQAAAK0AAACYAAAAhAAA + AHcAAABwAAAAawAAAGUAAABeAAAAVQAAAEsAAAA/AAAAMAAAACMAAAAWAAAADAAAAAQAAAAAAAAAAAAA + AAAAAAAAp6akD7Cys/f3tZv//+2////svv//7L7//+y+///rvv//7sD/48Ke/5STlP+ioaD/iYaE/5OQ + jv+XlJL/foST/ypVjv80Ypz/NWWi/zlrpv87bq3/PXKx/z16vf86gsn/PITM/zyEzf88h9H/O4jS/z6N + 2f9IbJT/pLm2/561s/+ftrT/n7a0/5+2tP+ftrP/nrW0/561tP+ftbT/nLOy/4ulpP9zk5H/aYuH/1Rw + bfMgKyrZAAAAwAAAALEAAACbAAAAiQAAAIAAAAB8AAAAeAAAAHQAAABuAAAAZgAAAFsAAABOAAAAPQAA + ACkAAAAWAAAACAAAAAEAAAAAAAAAAC8tLEzVz87/+7uS///puf//57n//+e5///nuf//57n//+e4//7i + tP+Zj4z/oZ6d/5yamP+cmpn/paOg/3N/k/8yZKH/Om6r/zxysf8+d7b/QHu8/0B/wf9Dgsf/QYzW/0OO + 2P9Dj9r/Q5Ha/0KR3f9Fl+X/SWyW/6e8uP+gtrX/obi2/6G4tv+huLb/obi2/6G2tv+ft7b/oLW0/5+2 + tP+etbT/n7az/5WsrP96mJb/aYuI/1ZycPQeJybWAAAAvwAAAK8AAACfAAAAkAAAAIQAAAB+AAAAfQAA + AHsAAAB2AAAAbwAAAGMAAABQAAAANQAAABgAAAAGAAAAAAAAAABxb22H5sjA//7Nnv//4bL//+Cy///g + sv//4LL//+Cy///gsv//5rT/q5uN/56bmv+vraz/qaem/62qqf+DjJ7/Nmys/z95uv9Bfb//Q4HE/0WF + yf9Hic7/SIvS/0mU3/9Kl+P/Spfl/0qa5v9Jm+j/TJzr/1l2lf+nvLr/o7m4/6K4t/+iuLf/o7i4/6O4 + uP+jubj/obe2/6K4t/+htrb/oLW0/562tf+etbP/nbSz/5avrv95mJb/aYuH/0tlZvEMGC3dAQMExgAA + ALcAAACfAAAAiAAAAH8AAAB/AAAAfgAAAH0AAAB5AAAAbAAAAFAAAAAqAAAACwAAAAAAAAAAiIeGsu28 + qv/+16X//9yr///cq///3Kv//9yr///cq///26r//96s/7+qkv+enJz/wL69/7+9vP+qqKf/q662/zJp + qv9EhMj/RobL/0iL0f9Ij9b/SpLb/02V3v9PmOT/UKDt/1Ch7f9QovD/UKLy/0KJ0v9mgYv/lK6s/6G4 + tv+pvbz/qL28/6W7uv+lu7n/o7m4/6S6uf+kuLf/o7m4/6K4t/+htrb/oLW1/520tP+dtLL/nbOy/5Kq + qv90k5D/RGd+/x1BdPsMHzTfAAAAvwAAAJ4AAACDAAAAfwAAAH4AAAB9AAAAeQAAAG4AAABSAAAAKwAA + AAwAAAAAAAAAAJKTk8zytZ3//9mn///WpP//16P//9ej///Xo///16P//9ej///YpP/Ps5T/oKCg/8/O + zf/V1NT/paKh/+De3P86YZb/SpDZ/0mR2P9MlN7/Tpfi/1CZ5v9RnOr/UqDs/1Sk8/9VqPj/Vqv8/1Kj + 8/87Xob/YIR+/1V6d/9OdnL/VHt3/2yNiv+NqKb/pbq5/6m+vP+mu7r/pLu6/6O5uP+iuLf/o7m2/6C4 + tf+gt7T/n7a0/5yzsf+bs7H/mrKw/3+bmP8dVIL/ElOH/wQdMdsAAAC1AAAAkgAAAHoAAAByAAAAawAA + AGMAAABTAAAAOgAAABwAAAAHAAAAAAAAAACZm5vc8rGX//7cs//92K7//dGg//3Qnv/90Z///dGf//3R + n//+0Z//17aT/6eoqf/R0M//5eTk/7OysP/h4N//lJ+y/zyAyP9Pm+b/UJzo/1Kf7f9TpPL/Vaj4/1Sl + 9v9LluP/QoHI/zxwqv9FZoT/eZaU/32bmf+BnZv/g56c/3+cmv9ykY//W398/052cv9sjYn/lK6s/6q/ + vP+ovLv/pbu6/6O5uf+jubj/ori3/5+3tv+ftbT/nbKx/5mxsf+asq//Yo+g/wJWj/8UWoP3ERUSxgAA + AKcAAAB9AAAAWQAAAEYAAAA5AAAAKgAAABkAAAAKAAAAAgAAAAAAAAAAmZub3vSukP/+17D//tSt//7T + q//+y5n//sqZ//7Lmv/+y5n//sua/9ezj/+6urz/o6Gg//j4+P/y8vL/r62r/////f9xhqX/O3/I/0eU + 4f9BhMv/PHGv/zlkkv9AY3//VHJ9/2eEh/94lZL/f5yY/4Cdm/+Dn53/hKGf/4eiof+Io6L/iKSi/4qk + ov+Io6L/c5KQ/1V7eP9ReHX/e5mX/6S6uf+ovbz/pLq5/6K4uP+iuLf/oLW0/521tP+ctLL/mrGw/5au + rf8DX5X/AV6W/2OFg/ocJSS+AAAAjwAAAFoAAAAoAAAAFQAAAAwAAAAFAAAAAAAAAAAAAAAAAAAAAJWY + l93wrpL//taz//7Usf/+1bL//tKt//zHmf/8xJP//MSV//7Flv/VrYv/wsLE/8XDwv+opqX/2tfW/7Cu + rf+9u7r//Pv5/7q+yf+fqLf/g4SJ/1Z6df9ihoD/a42J/3KSkP94l5T/fZuZ/4Kemv+FoZ//iKOh/4ql + o/+MpqX/jaek/46npv+Np6b/jKal/4ulo/+LpqT/gp+d/2SHg/9MdHD/cZCO/6K5t/+mvLn/o7i4/6C4 + tf+gtrX/nrOz/5qxsP+es7D/MnWa/wBYkf9WhI//aYqG/SQwL7gAAAB9AAAAQAAAAAwAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACNjo7O6ayV//7XuP/+1bf//tW3//7WuP/+1rj//NCu//zIof//wZT/zKOG/83O + z//Z2Nf/1tXU/7q5uP++vbv/sa6v/4eKiP+mpqT/h4yK/1d4df9cgn7/ZomG/2+Qjf94lpT/fZuZ/4Ke + nf+HoaD/iKSh/4unpf+OqKX/kKmo/5Gqp/+Rqqn/kaqp/5CpqP+PqKf/jaek/4qko/+Io6H/g6Ce/2aJ + hv9Lc3D/epiW/6e8uv+jubj/oLa1/5+2tP+bsrL/m7Kw/2eTo/8AVI7/RX6a/32alv9oiof9Ii4tsgAA + AHUAAAAyAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAhoaEs92olf/91rz//Ni///zXvv/8177//Ne+//zY + v//82MD//9rB/76llP/b3Nz/397e/9/e3v/f3t7/4eDg/7m3tv9Kcm7/T3dz/1B5df9Yfnr/YIOA/2OH + g/9lh4X/aouJ/3OTkf98mZf/h6Kg/46opv+TrKr/kquq/5Osqv+UrKv/k62q/5Srq/+TrKv/kquq/5Cq + qP+MqKb/i6Si/4eioP+Dn53/fJqY/1p/e/9SeXX/lq6s/6S6uf+ft7T/nLOz/5uzsf+MqKv/BFWL/yFl + kf+Xran/eJaT/2eIhfsVHBulAAAAagAAACUAAAACAAAAAAAAAAAAAAAAAAAAAH98e4vHp5v//8y0//7b + x//+2sb//trG//7axv/+2sb//trG///fyv+xoZn/6Ofn/+bk4//m5eP/5uTj/+jo5/+kpKP/UHdz/1J5 + df9Kc27/SnJu/1J4df9af37/YYSC/2KFhP9cgH//WH17/011cv9PdXL/V356/22Oi/+EoJ7/la6s/5qx + sP+Xr63/lq6t/5Wsq/+TrKv/j6qp/46opv+Ko6P/hqGg/4Cdm/97mZf/bI2K/0lxbv98m5j/pbq4/520 + s/+csrL/nbSw/xldjf8NVIn/jaim/46npf9ykY//YoF98wgJCZQAAABXAAAAFAAAAAAAAAAAAAAAAAAA + AACenJpQqqCd//y5oP/+4NL//t/P//7fz//+38///t/P//7g0P//3Mz/sKej/+/v7//r6+z/6+zs/+vs + 7P/x7+//hI2L/0p1cP9Lc3D/a4yM/36bnf+DnqH/gp6g/4Keof+Dn6H/hKCi/4ejpP9si4n/e5iX/3ST + kP9miIX/VXt3/011cf9bgH3/e5mX/5StrP+ZsbD/lq2s/5Osq/+Qqqj/jaWl/4ijov+DoJ7/fZmZ/3aV + k/9ujov/THRx/22PjP+juLf/m7Ox/5+2sf84bpL/CU2E/3qaov+OqKb/iqSi/22Niv9LZGLcAAAAfwAA + ADkAAAAGAAAAAAAAAAAAAAAAvr28EpCSkvzloYj//une//7l2v/+5tr//uba//7m2v/+5tz/48Cx/8jI + yP/z8/T/8/Hx//Px8f/z8vL/6unp/150cf9SeXf/f52e/4Gdn/+BnqD/gZ2f/4KeoP+Dn6H/hKCi/4ei + pP+GoaL/aYmG/4Sgnv+Cnpz/f5ya/32amP97l5X/b4+M/1p/e/9MdHH/ZYiE/4qlo/+Xr67/kqqp/4+o + p/+KpaL/haGf/4Ccmv93l5X/cZGO/2eKhv9OdXH/f52a/5+2tf+dtLH/WYOb/wtLgf9hiJr/kKmn/4ul + o/+BnZv/aYuI/yEsK68AAABjAAAAGQAAAAAAAAAAAAAAAAAAAACBf363tpaL///Qv//+7eT//uvj//7r + 4//+6+L//+/l/7eThv/09ff/+fn5//n5+f/5+fn/+/v7/8PAv/9KcG3/gJ2f/4KeoP+CnqH/g6Cg/4Sh + of+FoqL/iKOj/4ijpv+Lpqb/haGh/22Mif+Np6X/iKOi/4ainv+CoJz/gZyb/36bmP98mZf/eZaU/2eI + hf9NdXL/WH16/4Whn/+Sq6r/jKal/4Win/+BnZv/epiW/3KSj/9pi4j/XoN//0Vva/+JpaL/nbSy/3SW + ov8NSH3/S3WR/5Krp/+MpqT/iKOh/3OSkP9beHXrAAAAgQAAADc7OzsEAAAAAAAAAAAAAAAAnpyaQo2O + jv/bl37//+bb//7t5//+6+T///Do//K3ov+0sK7//Pz8//n5+f/5+fn/+fn5//r6+v90gH3/Z4uK/4Sg + ov+EoKH/haKi/4iho/+IpKT/iaSl/4ulpv+NqKf/kKmq/4Sgn/90ko//k62r/4+pp/+MqKb/iaSi/4ii + of+EoJ3/gZ+b/4Cbmv98mpf/e5iV/22Oi/9OdnL/XYF+/4ijov+JpKL/gp6c/3uZlv9zk5D/aoyJ/2CC + gP9Tenb/SnNv/5qysP+JpKn/E0h8/zlkif+Vran/i6Wj/4ejof+AnZv/aYuJ/x8pKKoAAABXAAAADwAA + AAAAAAAAAAAAAAAAAACgnJuLi4qJ/76QgP/2tJ3//cGs/96dhv+fj4n/5OTk/+Tj4//k4+P/5eTk/+fm + 5v+koJz/ZIWB/4Gen/+Io6X/iKWm/4ump/+Np6j/jaio/5Coq/+Sq6z/la2s/5evr/+Cnp3/fZqY/5uz + sf+Ysa//la2t/5Osqv+Qqqj/jqim/4umov+Io6H/haGf/4KdnP9/nJr/fpqY/3KRj/9ReHX/YYSB/4Sf + nf97mZb/dJOQ/2qMif9ghID/U3p2/092cv9bgH3/nbSx/x1Ke/8sV4H/lK2o/42npf+HoqD/hKCe/3CQ + jf9OaGbdAAAAZgAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAH97eaqEhIT/hYOB/4mBfv+OkI//1tXU/9nZ + 2P/Z2dj/2dnY/9HQ0P+hnZv/7MCd/4WWi/+GoqL/jKan/46oqf+QqKn/kquq/5Srrf+Wrq3/lrCv/5my + sv+dtLT/gp6c/4Sgnf+huLb/n7S0/5u0sv+asrD/lrCu/5WurP+Sqqr/j6mm/4ynpf+Io6H/h6Kg/4Sg + nv+Bnpv/gJya/2CDgP9Rd3P/eJeV/3OSkP9qjIn/YIOA/1J5df9Tenb/Rm9r/4+ppf8sUX3/KE16/5Os + qP+Np6X/iaOh/4Sfnf94lpT/XXx57QAAAGsAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdGBYia2Q + gf+jjIH/spuQ/7CbkP+wnZH/sZ2S/7Cek//BpI//9sag///Ppv+Ilov/gJyd/5Kqq/+Sq63/lK6t/5au + sP+YsbD/nLOz/521tf+htrb/pLm5/4ahn/+HoqD/p727/6W5uf+jt7f/n7W1/561s/+as7D/mbGu/5at + rf+TrKn/j6qo/46opv+LpqL/iKKh/4Shn/+Dn53/XoJ//0tzb/9uj43/aIqH/16Cf/9SeXX/U3p2/052 + cv9vkIr/PmOL/yVbkP9xlaT/jael/4ijof+Dn53/fJmW/2KCf/QAAABtAAAAGwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAO+eeaf/r4n//7SN//+5k///vpf//8Ga///Fnv//yKH//8qj///Mpf//0Kf/m6CR/2+P + jf+Yr7H/mbGw/5qxs/+ctbP/oLW1/6G3t/+lubn/qL29/6zAv/+Jo6H/iaOh/63BwP+rv77/qL28/6a7 + uv+kuLf/ori3/5+2tf+btLH/mrCw/5ewrv+VrKz/kqqq/46ppv+Np6b/dpSS/3KRj/92lZX/SXJu/2WH + hf9cf33/Unl1/1N6dv9SeXT/Rnd9/yhYkP8jRXX/O1p+/5Gsp/+GoqD/hJ+e/3yZl/9khIH2AAAAagAA + ABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD5qYPj/LGL//u2kP/9uZX//L+X//7BnP/+xJ7//ceh///M + pf//zKX//8+o/7mtl/9jh4X/j6in/5+2tv+iuLj/o7m6/6e8vP+pvr7/rMC//6zBv/+rwL//iKOh/4Wg + nv+ovbz/q7++/6zAv/+rwL//qr69/6a7u/+lu7j/o7m3/6C1tf+cs7P/m7Ox/5mxr/+Wr63/jKak/2eH + hf+HoaL/hqGj/3KRkf9KcW3/WX96/1J5df9Tenb/U3p1/0Jvd/8bSHz/GEp8/zlihv+RqaX/hqGf/4Of + nf96mJb/YYB+8gAAAGUAAAAWAAAAAAAAAAAAAAAAAAAAAAAAAADvy7sc+62G//yyjv/9t5H//L2X//7B + mf/+xZ7//sah//3KpP//zab//86n///PqP/cwKH/cJOS/26Oi/+lurn/qb69/6vAv/+swMD/rMC//6q/ + vv+ovLz/pry7/4qkov98mpf/oba3/6K5t/+mu7v/qb69/6zAv/+swL//qr++/6i9vP+mu7r/orm4/6G2 + tv+ftLT/nbSy/2yNif9/nJz/i6an/4eio/+HoaT/ZoiH/0pybv9Tenb/U3p2/1N6df9GcXb/DFOL/xNT + hf9miJj/jaak/4eioP+Cn5z/dZSR/1t3dukAAABiAAAAFQAAAAAAAAAAAAAAAAAAAAAAAAAAso17Rv2x + i//7tpD//buV//y/mf/+w5z//sWe//3Jof//yqX//86n///PqP//zqf//9Gs/3eQjf+Qqqj/dJOQ/63C + wf+qv77/p769/6e9uv+lu7r/o7i4/6G4tv+Np6b/c5KQ/5mxsv+as7P/nbW0/6G2tv+kurj/p7y8/6q/ + vv+swL//q7++/6m+vf+mu7r/p7y7/3uYlv90kpD/k62t/46mqf+JpaX/hqGj/4aho/9Uenf/Unl1/1N6 + dv9Tenb/Rm9u/xhKfP9HZ4f/lK2o/4mjof+GoJ//gZ6b/2yLjP9Qfk7lAAAAZAAAABYAAAAAAAAAAAAA + AAAAAAAAAAAAAMiIaWf9s47//biR//y9l//+wZv//sOe//3Iof//y6T//82m///Npv//zqf//9Gu/7i5 + Zv9ak1D/layu/4ulo/92lZP/p7y7/6S4uP+iuLf/oLe1/5y1s/+cs7H/kKqn/2yMiv+TrKz/k6ys/5eu + sP+YsLL/m7S0/562tP+it7j/pLm6/6q+vf+swL//rsLB/4qko/9rjIn/mrGx/5aurf+Qqar/jKap/4qj + pv+HoqP/epmZ/0lxbf9Tenb/Unl1/z1qcf8RRn3/bYqY/42npf+JpKL/haGf/3eVk/9liYn/M5ol6QAA + AGYAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAADtpH+G/LWP//26lP/8vZn//sOb//7Gnv/9yaL//8yl///O + p///z6f//9Gu/7G6Yv9Jvjv/XtiO/3KOjv+xxcT/iaOi/3OSj/+etbP/nbOy/5mysP+YsK3/lq6t/5Cq + qP9oiYb/jKan/42nqP+Pqav/k6yr/5Strf+Yr7H/mbGx/5yzs/+gtrb/pry7/46opv9oiYf/n7a1/5+2 + tv+asLL/lKyt/5Gqq/+Np6j/iKOk/4ijpP9PdnL/Unl1/1J4cv8sYHf/HlCB/5Cpp/+MpqT/iKOh/32a + l/9shYj/K6pp/yOmJu0AAABpAAAAGQAAAAAAAAAAAAAAAAAAAAAAAAAA86qEmP22kf/9vJb//MCa//7E + nv/9x6H//8qi///Npv//zab//9Cv/6m4Wf9JxUr/XOGW/2Tllv9mrIz/kqmp/6u/vv+JpKL/bI2K/5Os + qv+Vrqv/kaqo/5GoqP+OqKb/aoqH/4SfoP+JpKb/jKan/4ymp/+OqKr/kquq/5StrP+Vrq7/m7Oz/4Of + nf9oiYb/pru7/6q+vf+iuLj/nrW1/5mxsf+Traz/j6ip/4ulpv+JpKb/bI2N/0xzb/9Pd3D/EVGA/2mM + m/+Qqab/i6Wj/3mYlf9shof/PKBv/wDEUP8hqi7wAAAAawAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAPat + h6b9uJL//L2X//7Cm//+xZ///cii///LpP//zKX//8+s/6i3WP9GxEj/WN+T/2Hhkv9n45n/cOSd/2iL + gv+iuLf/o7m3/5Cpp/9qi4j/g5+d/4ynpf+JpaP/iKOh/3CPjP95mJj/haGi/4Whov+HoqX/iqWm/4ul + pv+OqKn/kaur/3aUkv9ujYv/ori2/6q+vf+swL//qL29/6G3t/+ds7P/l7Cv/5Srrf+Oqar/i6an/4Of + oP9IcGz/M2dz/0V4l/+Wrqn/hJ+d/22Oi/9qhob/OKde/wDETv8AwlH/Ha8z9AAAAG0AAAAbAAAAAAAA + AAAAAAAAAAAAAAAAAAD4r4ql/bmT//y+mP/+w5z//sae//3Jof//zKT//86r/8nAd/9DxEf/U96P/1ze + kP9l4pX/beWc/3Xoov9zzpX/co6O/6C3tv+bsrD/k6yq/3CQjf93lZP/hKCe/4KenP92lZL/b4+N/4Of + of+Dn6H/g6Ci/4Sgof+Io6T/hqGi/2+OjP93lZL/nrW0/6O4t/+nvLn/qr+9/6zAv/+nvLz/oLi4/5yy + sv+VrrD/k6yr/42nqP+Lpqf/R3Jw/0h8kP+BnZn/boyM/2eGhv+AkHj/rqdW/xS8N/8AwlH/AMJR/xi1 + OPcAAABrAAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAA+LGKlv26lP/8v5n//sSd//7HoP/9yqP//8yn/9jD + hP9CuzH/TN2M/1bcjP9f4JP/aOOZ/2/mn/956KX/gu6r/3nAnP94kpH/mrKx/5Osq/+PqKb/dZOR/2uL + iP93lZP/cZCN/2iJhv9ujoz/dpaU/4Gdn/+BnZ//dZST/2eJhP98mZf/mLCu/5uysf+ftrP/orm4/6i7 + u/+rv77/rMC//6a8uv+ft7f/m7Oz/5Wurv+SrKz/fpua/1+CjP9qiIf/ZYtx/0SiZP8/rCn/TZoA/ye1 + Jv8AwlL/AMJR/wDCUf8dsDP0AAAAZgAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAPuzjYL9u5T//MCa//7F + nv/9yKH//8uk//LKnP9NvDb/Q9mE/1Dah/9Z3o7/YuGT/2vkmf9y56H/fOqn/4XsrP+P87X/e7ic/3aQ + kP+TrKr/jKak/4Whn/97mZb/aoqI/2qLh/9zko//dJOQ/2yMiv9ri4n/aIqH/3CPjP+Dn53/jael/5Gq + qv+Xr6z/mrOy/6C1tf+jurf/qL28/6vAv/+rwL//pLm5/6C1tf+asrL/k6yt/2WId/9SpCf/Rqwi/yfB + Pv8IyFr/AcNT/wrASv8AwlL/AMJR/wDCUP8AwlP/J6Um7AAAAF0AAAASAAAAAAAAAAAAAAAAAAAAAAAA + AAD7x6pk/buV//7Bm//+xZ///ceh///Mqf+EukX/OdR3/0XZgf9S3In/W9+O/2Tilv9t5Zv/duij/3/r + qf+I7K//ke+0/5v3vf+FwaT/boqL/4mjof+Dn53/fpuY/26Oi/96mJX/i6Wj/42opv+AnJr/a4yJ/3CQ + jf9/m5n/g5+e/4ein/+Oqab/kqup/5iwr/+asrH/obe2/6W6uf+pvLv/rMC//6q/vv+kurr/nrS0/3GO + jv9HtDv/K85m/x7Na/8WymL/D8Vb/wTCU/8AwlH/AMJR/wDCUf8AwlD/AMNT/zCSGd8AAABNAAAACgAA + AAAAAAAAAAAAAAAAAAAAAAAA+9vIQf27lP/+wJv//sad//7Jov/yyZn/PcFC/z3Wfv9G2YP/U9uK/1ve + kf9m4Zf/beSe/3jnpP+B6qn/iu6x/5Pxt/+b87z/p/vF/5jYtv9rjIj/dZOQ/22Miv9pioj/epiV/520 + sv+iuLf/iqWj/3GQjf9qiof/d5WT/3+cmf+EoJ7/iqWj/5Cpp/+Urav/mLCv/520s/+ht7b/pru6/6q+ + vf+vwsH/mK+v/2yMif9JwH//MdV4/yrQb/8izWf/Gcpi/w7HWv8FxFT/AMFQ/wDCUf8AwlH/AMJR/wDD + UP8sawvFAAAAPTs7OwUAAAAAAAAAAAAAAAAAAAAAAAAAAPzbyBn9upT//sKc//7Gn///yaL/0MN9/zDL + Wv8/1nz/R9iC/1Tdi/9d4JD/ZeOW/3Dmnv956aP/geyr/4zvsP+V8rj/nvW9/6b3xf+x/Mv/sfDK/3CT + jf9piYn/epiZ/3SSk/97mJb/jKak/4Cdmv9tjYr/b4+O/2uLiv9qi4f/cZCN/32Zl/+Gop//jaim/5Ss + q/+YsK//m7Kw/5ivrv+KpaP/co+S/2CNZ/9M04L/P9d+/zXSdf8s0G7/I81p/xjKYf8Qx1z/BcNU/wDB + UP8AwlH/AMJR/wDCUf8Mwkj/IEQEpQAAAC2AgIABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+7qT3f7C + nP/+xp7//8mk/8rCd/8wy1//P9Z9/0nYgv9U3Yv/XOCS/2fjmP9w5p3/eOml/4Psqv+M77L/lPK3/5/1 + v/+o+MT/sPvM/7v+0v/L/t3/qc6+/3SVkP9qion/dpSW/3WSlP9niIX/cpKR/3aVlf95l5f/epeZ/3eV + lv9xkJD/bo6M/2uMif9rjIv/a4yK/2eIhv9ehIL/d46N/3+gWP9NxEP/StqG/0HVfv8003X/LNBu/yPN + af8YymH/EMdc/wXEVP8AwVD/AMJR/wDCUf8AwlH/Gr47/xMnAYIAAAAeAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAPu6k6H+wpz//sae///JpP/IwXT/Mcxg/z/WfP9H2IL/VN2L/13gkP9l45b/cOae/3np + o/+C7Kv/iu+w/5XyuP+e9b3/pvjF/7H7yv+5/NL/x//b/9X/5P/i/+z/yuDX/2GTY/9piIT/a4qN/2uL + i/9zk5L/d5WX/3mWmf96mJr/eZea/3eWmP9xkpL/aYyN/22Mif+QnZH/z76j/9fKhf9PxUb/VN6Q/0ra + g/8/137/M9N4/yzQb/8hzWf/Gcpi/xDHW/8FwlX/AMFQ/wDCUf8AwlD/AMJT/y2xKPYBAQBWAAAADwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7y65Q/sCZ//7Gn///yaj/krpN/zHRcv8+1nz/RtmD/1Pb + iv9c3pH/ZeGX/2/knP9456T/geup/4rusf+S8LX/nfS9/6f5yP+w/M7/tv3P/8P/2P/O/9//2P/m/+X/ + 8f+k3o7/UaUW/02MHv+qs5r/laSX/4abkP+FmpD/hpqQ/5Ohk/+lqpj/wbmf/93JqP/71a///9iw///W + tP99vkr/WuGW/1LbiP9I2YX/RchY/0i+Pf8qzmr/Isto/xjJYf8OyFr/AMNR/wDCUf8AwlH/AMJR/wDD + Uv8ygxHNAAAANDo6OgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/vDmA/y+mOT+xZ7/28GD/zLC + R/8y03X/O9R7/0bXgP9R3In/Wt+Q/2Pilv9r5Zz/dOih/33pqf+I7K7/kvK6/4Hjkf+ExVT/fs9j/7X+ + 0v+7/tT/xf/Y/87/3//T/+H/2v/p/9v/7P9pvkL/5dmm///kv///5L3//+K8///huf//3rf//9y1///Z + s//+17H//taw//7Urf//1LD/ocBb/1Xcif9Q3In/RNJs/6K0Tv//zab/PL08/x3Na/8xuzj/UpgH/6K2 + Uv8Gv0T/AMJR/wDCUf8Yvz7/GDEChQAAABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD8vZSE/8Wi/3W4P/8lzm3/MNJy/zvVev9D2H//T9uI/1jejv9h4ZT/auSa/3Pnn/986Kf/he6w/23O + X/+xxWv//9y//5/DXv+o98L/tv3P/7v+0v/D/9j/yP/b/8r/3P/Q/+X/hM1i///hvv/74Ln/+926//3c + t//827f//Nm0//zYsv/+2LL//tev//7Urv/+067//9Ou/87Hf/9L0mv/TtuI/0PNXf+oslP/zsV8/yvE + TP8dy2X/E8hh/zynEP/JsWX/Cb09/wDCUf8AwlP/MKgi7gAAAE0AAAALAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA/9/QGvS/k/kyvTj/Jc5t/y/Rcv841Hj/QNd9/0zahv9V3Yz/XuCS/2fj + mP9u5p7/eOik/3bhkP+GrTv//9u9//7ZtP/Gy3//keuh/6/7yv+1/M7/uP3Q/73+1P++/tX/tvjJ/5rE + Xf//4L7//d24//3dt//927f//du2//3Ys//817P//tew//7WsP/+1a///tSs//7TrP/80ar/Vr46/0jb + iP86y1f/38aK/1C6OP8izm7/HMtj/xDIYP8vsyf/pa1H/wa+Qv8AwlH/A8NO/y1pCrwAAAAvgICAAgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYsCbTGshe/yPNav8t0HD/NNN2/z/W + e/9J2YT/UtyK/1vfkP9k4pb/bOOa/3Tnof9145X/RJYA/9/Klf//27z/t8Zv/5Ltqv+o+MX/rfjJ/7H7 + zP+y/Mz/tvzR/3TFSv/127P//d24//3dtv/93Lf//926/9rNl///2rb//tix//7Vr//91K7//tSu//7T + rf/+0qv//9Gr/+HKj/+GvUr/kb1R///Np/9BvTz/Ic1r/xnKY/8Nx17/MrUp/yuyIv8AwlP/AMJR/xy/ + O/8WLAF2AAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7Ie2RXK + Zf8hy2f/Ks9u/zHSdP861Xr/RtiB/0/bh/9X3o3/Xt+R/2fjmP9u5J3/eeqp/1vAP/9HjQD/lapL/2+6 + PP+b9cD/oPTA/6X3w/+o+Mb/rPnL/3rVcP/IyoP//ty4//3ct//927b/99mx/2ulI/87lAD/lqxP///b + u///2bj//9e0//zTrf/oy5v/68qb///RrP//0q///9Cu///Prf//z63/eblD/xrMZ/8XyWH/DsZZ/wPD + U/8AwlH/AMJQ/wDDU/82mhfaAAAALjo6OgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAHbAQ0InvkL/HMtm/yXOav8v0XL/NtJ2/0LXf/9L2oP/U9uK/1vfkP9h4JX/auSZ/3Dl + oP956Kb/ZMxb/1S1LP9+4pH/kvG2/5jzuv+c9L7/n/XA/6P2xP900WT/i6lE///dvP/927T//9q4/4G+ + SP9/4pD/g+ec/0GWAP9jlx3/dp4u/2CZGf9MlgL/RJYA/0SUAP9PkAf/oa1U//3Oqf//z6j//82n/+nH + kf85uTD/EMhg/wvFWP8BwVH/AMJQ/wDCU/8lujH9FCoBYgAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ6sGkx3IXv8izWn/LNBv/zTRdf891nz/RNeA/07Z + h/9U3Yv/XeCQ/2Phl/9s5Zr/ceeg/3rpqP+C7rH/he2u/4vvs/+E6KL/ddh3/5Xwtv+Y87r/jemi/0iX + Af/417D//tm0/8zKhP903oP/jO+0/4btr/9z34r/XcZN/13LWv9g027/X9uB/1rbhf9T2Hv/S8ZN/0Wd + Cf/ixZH//86n///Npv//yqX/5sOK/zu3LP8DxFf/AMFQ/wDCUf8PwUX/LWMInAAAABcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbsyAg6sx/gG8xp/yfN + av8uz3H/OdR4/0HXfv9H2YL/UNqJ/1bejv9f35H/ZuOX/2zlnP9x55//d+ej/37rqv9u2Xj/psFf/8zJ + gP9x2Hb/j/C1/5LyvP9fuTT/+9Ww///Ytv+ewlz/g+yq/4Psq/9+6aj/d+ik/3LnpP9s5Z3/ZeOY/17g + kv9T2ob/SMlU/1fCSf9suzr//c6o///Npv//y6X//ceh///Fof/ivoP/JLgu/wDCU/8CwlH/OZMT0QAA + ACg6OjoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAdsBDPiy+P/8ezWr/Js5q/zHNY/880XH/Q9d//0nYg/9S3Ij/V9+O/1/fkf9l4Zf/a+Oa/3Dm + n/9t4ZP/oL9Y///XuP/czZH/bNh3/4btr/+E7Kv/gsBL///Xt///17b/dsJM/4Dtrv976KT/duii/27m + nf9q5Jv/Y+GX/17gkv9U24b/e7k8/+jLlv//z6n//8+u///Op///zab//8qi//3HoP/+xJz//8Cd/661 + WP8DwEX/MLYm8QsXAD8AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0wEJLYbIqvKO8Wv+ZtET/Pr48/zzWff9E1n//S9qF/1Db + iP9Y3o7/XuCR/2PimP9j4ZP/UMlQ/+TOl//40qz/bbUx/3noo/966aX/a749//LSp//+1a///9Sw/2nH + Vf926ab/ceWf/27lnf9o45n/Y+CU/13gkv9X3o3/TM9l/6CvTP//0a7//8+o///Opv//zab//8uj//3J + ov/+xJ3//sKb//2+mP//u5j/U50exCRWBU0AAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6xaGjQLw4/y3R + df830nb/PtZ8/0PYf/9L2oX/UdyJ/1bejf9U0m3/lbxO/9bJiP//1LH/eLk8/2jfjP9v5Zz/ar08//PR + p///1bL/+9Ot//rUrP9dyFT/beWf/2rkmf9k4Zf/YN+S/1vfkP9U3Iv/UNyJ/0rTbv9Slgj/8cuf///O + p///zab//8yl//3Io//+x6D//sOb//y/mf//vpf/oHRdlwAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAArtaLHinDSv8oz2//MdBz/zfUdv881n//QtiB/0nYg/9P3Y3/Rrkx/8G5cv//1bT/4cyU/1bX + eP9n5Z3/Y7w7//jTrP//07D/fKcx/06PBv9kqCH/YdyG/2Til/9h4ZT/XeCQ/1jejv9T3Yn/TtuH/0fY + g/9C2ID/P6wZ/8e6d///zaj//8yk//3KpP/+xqH//sWe//3Bmv//v5j/oHVckQAAAA8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1wUaALMRP/yjPcP8u0HH/V7s4/0THVP9A2IP/RMhV/0vC + RP9NkQT/lKdF/4epOv9W3Yj/Xd+N/06eCf/uzKD/kbxO/1TTav9Vylb/WtZ4/13gk/9b34//WN6O/1Td + jP9O2of/S9qF/0bXgv9B137/OtV8/zfCRP/KvHb//8yn//3KpP/+yKD//sWd//7Cm///v5j7jmhTdwAA + AAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHS/Qngsw0//LcJH/+rI + lP9hvkP/N8VM/8vBd/9bwUb/SMBE/0izKf9Jujb/UtyM/1Xfj/9MtCj/UJAG/1HLWP9Y3pH/V96P/1bd + jf9U3Yr/UtyK/0/biP9M2ob/RtmB/0PWf/8+1nz/ONN3/zPTd/8zv0D/yrp1///Kpf/+yKD//sWf//7C + nP/+v5n0Uz4xUAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAc8FFb1uuI6j/ya3ZZ7xC/z28Of9ekg//Tb09/z7Zhf9A2oj/RduJ/0nYg/9K2oX/TdqG/0qw + If9LqA7/T9yH/07bh/9N2Yb/S9qF/0nZgv9G2IL/Q9eA/z/We/871Xj/NdJ1/zLQc/8r0HH/Lr49/8m5 + cv//yKL//sWf///Enf/wtZDNPS0jNDY3NwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//PsBKjIbogwxEv/O78//zHQbf87w0j/aro//0TC + SP8/13//Qtd//0TXgP9F2IH/Rspc/0TYgP9F2ID/RNh+/0LWff9A1n3/PdR8/zrTev8103f/M9J0/y/R + cf8qz27/I85r/yy+Pf/jwIn//8Wf//3Cm+qZc1tuAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc8FEgTS+ + O/pjuDX25MeQ/5S9U/8zzWT/N9N3/znUd/871Xj/OtV6/zzVe/881Xr/OtV6/znVe/821Xv/NtN3/zPT + dP8y0nL/Ls9x/yvPbv8nzmr/IMto/xnLaP9SujT//8Og5KZ/ZHkdFA0RAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACg1YAJ2dqzC//XwFpbtCrNMMla/yvRdP8v0XP/MNJz/zLSdP8x0XP/M9Jy/zDR + df8+wUT/Vrw8/y7GUP8o0HH/KM9t/yTOa/8gzGj/G8xn/xrKYP84tCPpVFcpXxQMCgoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHa/RFBDsBWtSq0WszHF + Uf8mz3D/J9Bw/ybQcf9LvTb/58eN///LqP/SwXv/cbg8/S+/Qf8kxFD/K79B/zS4Lu8/mw+cBhYAHDc2 + OQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB1v0FJQa8WuTi4K+U9rxbDQkkeSWxTQzP849Ey+d/MJ+rXxhGi0oIhptODPqXQ + gyORp4ECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /////////AD/A//////wAHwAD////+AAAAAAA///4AAAAAAAD//AAAAAAAAA/8AAAAAAAAAfwAAAAAAA + AAeAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAGAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAGAAAAAAAAAB4AA + AAAAAAAfgAAAAAAAAA+AAAAAAAAAB4AAAAAAAAAHgAAAAAAAAAOAAAAAAAAAA8AAAAAAAAABwAAAAAAA + AAHgAAAAAAAAAfAAAAAAAAAB+AAAAAAAAAH4AAAAAAAAAfgAAAAAAAAB8AAAAAAAAAHwAAAAAAAAAfAA + AAAAAAAB8AAAAAAAAAHwAAAAAAAAAfAAAAAAAAAB8AAAAAAAAAHwAAAAAAAAAfAAAAAAAAAB8AAAAAAA + AAHwAAAAAAAAAfAAAAAAAAAB+AAAAAAAAAP4AAAAAAAAA/gAAAAAAAAD+AAAAAAAAAf8AAAAAAAAB/wA + AAAAAAAH/gAAAAAAAA/+AAAAAAAAD/4AAAAAAAAf/wAAAAAAAD//AAAAAAAAP/+AAAAAAAB//8AAAAAA + AP//8AAAAAAD///wAAAAAAf///gAAAAAD////AAAAAAf///+AAAAAD////+AAAAA/////+AAAAP///// + 8AAAD///////AAAf///////gAP//////////////KAAAADAAAABgAAAAAQAgAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAANAAAAFQAAABcAAAAXAAAAFwAAABcAAAAUAAAACwAA + AAIAAAAAAAAAAAAAAAEAAAACAAAABgAAAA8AAAAcAAAAIwAAAB8AAAAUAAAACgAAAAgAAAAIAAAACAAA + AAcAAAAHAAAABgAAAAUAAAAEAAAAAwAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAABwAAAA9AAAAUAAAAFUAAABVAAAAVQAA + AFQAAABOAAAANwAAABkAAAAMAAAAEAAAABYAAAAfAAAAMgAAAEsAAABlAAAAcwAAAGsAAABTAAAAPwAA + ADUAAAAwAAAAKQAAACIAAAAdAAAAGQAAABgAAAAVAAAAEgAAAA8AAAAMAAAACQAAAAYAAAAEAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAGl1dW5J0dnfJZWZm0WBf + XtFjYF/RY2Bf0mFeXc46OTiqAAAAcwAAAFEAAABFAAAATgAAAFcCAwVqER0yoxw0WNghRXX2Hj1o6w4Z + KL8DBASeAAAAjgAAAIQAAAB9AAAAcgAAAGYAAABZAAAATQAAAEIAAAA3AAAAMAAAACoAAAAlAAAAIAAA + ABsAAAAWAAAAEQAAAA0AAAAJAAAABQAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANfX19q+DV + 0v/61sX/4Lyt/5OJhv+KiYj/jYqI/42KiP+LiIb/QkFAvSUkI6FNSka7ISYutRIkQMohPGbuKUx+/yNY + k/8fXp7/IWGi/ylXjf5OaG7yT2di6D9TUd4wQD7RGiIhwAUHB64AAAChAAAAlAAAAIQAAABzAAAAYwAA + AFYAAABKAAAAQwAAADwAAAA1AAAALgAAACYAAAAfAAAAGAAAABEAAAALAAAABQAAAAIAAAABAAAAAAAA + AAFnZ2Zk2MnF///Utf//7sH//+/E/9yskf+PiYj/lZSS/5aUkv+XlZP/iYaD+359f/tMXnv/LUx7/ypO + g/8vVYv/L2Cb/ylrrf8qbbD/KnC0/ydstP9We5z/kaqk/4eioP9/nJn/c5GO/mB8efdFW1noKTY11QoN + Db0AAACtAAAAnwAAAIwAAAB7AAAAbAAAAGEAAABbAAAAVAAAAEwAAABDAAAAOAAAAC0AAAAiAAAAFgAA + AAwAAAAFAAAAARwcGwmcmZnN+8qx///rvf//9sr///bK///pvP+wmYv/mZmZ/5uYl/+Nioj/lI+L/2Bv + iP8iTIX/L1qR/zRhmv83ZqH/NnGx/zN5vv81esD/NX3E/zF/yv9RhLT/nbGu/6C2tP+ftrT/nLOy/5ev + rv+LpqP/fJmW/2SCgPpDWFbpHicn0QAAALkAAACrAAAAmAAAAIgAAAB8AAAAcwAAAGwAAABlAAAAXQAA + AFIAAABEAAAANAAAACIAAAARAAAABmRkYzbKta77/9Sq///vwf//677//+u9///ywv/Vu57/npqa/5ST + kf+Rjoz/nZmX/09qj/8wYZ3/OGun/ztwrv8+dbT/Pn/C/z6Gzv8+iNH/PorU/zuM2v9Ri8D/nLGv/6C3 + tP+gtrX/oLa1/6C2tf+huLb/oLa1/5mxr/+Io6H/c5OQ/09oZvAiLSzWAAAAvAAAAK4AAACgAAAAlAAA + AIcAAAB8AAAAdQAAAG4AAABlAAAAVAAAAD0AAAAiAAAADnh6e2/lvqz//9ys///mtv//5LT//+S0///n + tv/x06n/n5mW/56dnP+npaP/qqil/1Nymv84cbP/QHm6/0J/wf9FhMj/RovR/0eT3f9HlOD/SJbi/0WZ + 6f9blcr/oraz/6W7uP+jubj/orm3/6K4t/+huLf/obi2/6G3tv+huLb/nbSz/42opf92lJL/Umxn8Bso + MNkECRDGAAAAtgAAAKUAAACPAAAAgAAAAHoAAABzAAAAZQAAAEwAAAAtAAAAEouIiJbwwKX//9qm///e + rP//3az//92s///erf/62Kj/pp2U/6+vr/+7urj/t7Sw/2aDqP87fML/R4jN/0mM0/9KkNj/TZXe/1Cc + 6f9Roe//UaPy/02j9/9Vh7L/j6eh/5+2tP+mu7r/qr++/6e9u/+kurn/pLq4/6K5uP+guLb/oLa1/6C2 + tf+ctLL/jKej/2yKjP8rTXH7ECxM5gIFCL4AAAChAAAAhAAAAHIAAABpAAAAWwAAAEQAAAAoAAAAEJWO + jqvzw6T//9mp///WpP//1qP//9ak///XpP/91KH/tKeY/7S0tf/V1NP/wr65/5uouv85esH/TZfh/0+Z + 4/9Rnuv/VKTz/1Wo+f9Tpfj/T6H0/0WEx/9YeYX/ZYmD/2OGg/9tjov/fJuY/5Stq/+mu7r/qr++/6e8 + u/+jurj/obe2/6C3tf+etrT/nrWz/5yzrv9mi5f/DVCF/ws2U+EAAACtAAAAigAAAGcAAABOAAAAPQAA + ACsAAAAYAAAACZ6Vk774wqP//9qy//7TqP/+zZz//s6c///Pnf/7y5r/v7Ci/6+vsP/p6en/0dDP/9rY + 1/9wkr3/PYnZ/0mY6f9Mld//R4jK/0Z/tv9Nfaf/VHiU/2eFjP+Bnpr/haGf/4Sgnf99m5j/cJCN/2WI + hP9oiof/fZqZ/5uzsv+qv77/pru7/6O4t/+gt7X/nbS0/520sv+asq//I3Ca/wpejfwyQ0LNAAAAlwAA + AG0AAAA+AAAAIQAAABIAAAAJAAAAA5qSj731vqH//9ez//7Vsv/+z6f//saY//7FlP/6wI//xrWn/8TF + xv/CwL//0c/P/7u4tv/f3eD/lKbB/3iLqP9PbXv/VXl7/2WDgP9zkIv/f5uV/4OgnP+GoaD/i6Wk/4ym + pf+Np6b/j6mn/42mpf+Bnpv/bI2L/2GEgv91lZL/mrKx/6i9vP+kubj/n7a1/520sv+jtrL/VIuj/wBa + kv9Yg4z/PU9MyQAAAIQAAABSAAAAIQAAAAcAAAABAAAAAI+Jh6TsuqL//9e5//7Xuv/+17r//tS1//7P + rP/4wpr/xbOn/9rc3f/R0M//xcPC/8C/vv+MkpD/naWf/3iKg/9cgHr/aIqF/3GRjv96mJb/g5+d/4ul + o/+Qqaf/kqup/5Krqv+Sq6n/kqup/5CqqP+Qqaj/jqem/4Whn/9tjoz/XoJ//3mYlf+ht7b/pbu6/561 + tP+gtbL/f6Gp/wVYj/9ThZv/e5aQ/zxQTcUAAAB4AAAAQgAAABIAAAABAAAAAISCgo3gsJ7//9nA//3b + xP/92sP//drE///cx//z0Lr/xbu3/+bm5//k4+P/6Ofn/9nY1v9hfHj/SHJt/0p0cP9Tenf/WX57/12C + f/9ghIH/Y4aD/2qMif92lZP/iaSi/5StrP+asbD/mLCv/5WtrP+TrKr/j6mo/4ympP+Io6H/fZqY/2GF + gf9fhID/kqup/6W7uf+ftrP/lq+v/xpgj/87dJb/kKml/3CQjP8yQkG3AAAAbQAAADEAAAAJAAAAAH1/ + f13IopT//9jF//7h0f/938///d/P///i0v/pybj/zcjG/+/w7//r6+r/8fHw/8jJx/9TdXD/Tndz/2aI + h/9zk5P/fJma/36bnP9+m5z/e5ma/2WHhf9niYb/XoJ//2KGg/9wkY7/hqKg/5atrP+asbD/lK2s/4+p + p/+KpKL/hKCe/32amP9niob/VXx4/4aioP+jubf/n7Wy/zxxlP8hX4z/jqin/4ein/9nh4T5GiIimwAA + AFgAAAAcAAAAAn18eiCikIn1+si1///s4v/+59z//ufc///r3//Tua7/5OTk//b29v/19PT//fr6/6Or + qf9QdXL/e5ma/4Wgov+EoaL/haCi/4aio/+IpKX/hqGi/3WUkf+GoqD/f5ya/3aVkv9pi4j/X4OA/2CE + gf9zk5H/jKel/5Wtq/+OqKb/hqGg/36bmf91lJL/ZIiE/1B3c/+EoZ7/qr24/1eBmv8ST4P/hKGk/5Cp + pv97mJb/Umxq3gAAAHYAAAA3AAAACgAAAACFg4K206OR///m2v//8Or///Hr//jXy//Ita3/+vz9//z8 + /P//////8e/v/3GFg/90lJX/hqKk/4Whov+GoqP/iKOl/4qlpv+Np6n/haCh/3qXlP+Pqaf/iaSi/4ah + n/+Dn53/f5ya/3WUkv9lh4T/W4B8/26Oi/+KpKL/iqWk/4Cdmv92lZL/a4yJ/1l+e/9Pd3T/lK2o/3CR + ov8XTH//dJSf/5Gppv+GoZ//b42K/yYzMaIAAABMAAAAEwAAAAB+fHs/k4iD+96rmP//3c///dTF/8ud + jP/V09L/8vLx/+/u7v/y8vL/rrKx/2WDgv+HoqT/iKOl/4qlpv+Mpqf/jqip/5Cqqv+Vra7/hqGh/4Cd + m/+ZsrD/kquq/4+op/+LpqT/h6Oh/4Wgn/+Cn53/e5mW/2aIhP9bgH3/dZWT/4Sfnf93lZP/a4yJ/1yC + fv9MdXH/ZIeC/3+cpv8cS33/Z4iY/5Krp/+Io6H/eZeU/0hfXcsAAABYAAAAGQAAAAAAAAAAfn9+coaB + f/mjh37/nYR8/6ysrP/S1tj/z9HT/8/R0//Curb/xauT/3+ZlP+Lpqj/jqip/5Cpqv+Sq63/la2u/5iw + sP+dtLT/iaSi/4ijof+iubj/m7Kw/5ewrv+Urav/kaqp/42npv+KpaP/h6Kg/4Wgn/94l5T/XYF9/2aJ + hv94lpT/a4yK/1yBfv9Tenb/Tndx/3WTlf8lSnr/ZYSV/5StqP+HoqD/fpyZ/1Nta9kAAABcAAAAGwAA + AAAAAAAAAAAAAJuCdpC8l4P/v52L/9Ctmv/Orpn/zq+b/8yvm//ovJv/+cmi/3qUkP+Pqqv/la2u/5ev + sP+asbL/nbS0/6C3tv+nvLz/jKak/4+op/+qv77/o7m4/6C2tf+dtLL/mrGw/5avrf+TrKr/j6mn/4ym + pP+LpaP/fpuZ/1p+e/9dgX7/aYuH/1uAfP9Tenb/T3Zx/12Ehv8uYJP/RnCW/4ympP+Io6D/gJ2a/1l0 + ceAAAABcAAAAGwAAAAAAAAAAAAAAAeWbeaP/s4v//7qR//++lv//w5r//8ie///Mo///z6b/+cul/3qS + iv+HpKT/oLa2/5+2tv+jubj/pry7/6q/vv+vw8P/j6mo/4ynpf+vw8P/q8C//6i9vP+lurn/ori3/5+1 + tP+cs7H/mLCv/5WurP+Sq6n/dJOQ/36bm/9niYj/VXt4/1h+ev9Tenb/VXpz/0Bygf8gToL/IEp8/4Sf + oP+Io6H/gJya/1p1c98AAABaAAAAGgAAAAAAAAAAjWBLCfOng9n8tI7//bqU//7Amf/+xJ7//sii///M + pf//zqf//9Co/5mglP9xkpP/obe2/6zAv/+swL//rcHA/6vAv/+rwL//kaqo/4Ognv+nvLz/qb69/6zA + v/+swL//qr++/6e8u/+kurj/obe1/6C3tv+En53/dpWU/4ulp/+HoqT/X4OB/011cf9Tenb/VXt0/0Fx + ff8OUIX/NGSK/4qko/+HoqD/fZuY/1RtbNkAAABYAAAAGQAAAAAAAAAAzIxuH/qvifX9t5H//b2X//7D + nP/+x6D//8uj///Npv//z6j//9Sv/7askP94mJj/g5+e/6q+vf+sv7//p727/6W6uf+kurn/kKmn/32a + mf+bsrP/nrW1/6O5uP+nvLz/q7+//6zBwP+rwL//rMC//5aurP90k5D/jqip/46oqf+JpKb/gp6f/1N6 + d/9Qd3P/VXx1/z9sdP8aTH7/dpKc/4+opP+FoZ//eJKX/0lyS9YAAABZAAAAGQAAAAAAAAAA2ph3PPuy + jPz9upT//sCZ//7Fn//+yaL//8yl///PqP//0bH/z8F3/2KwRf99opn/lKur/36bmf+gtrb/ori3/520 + tP+cs7L/kaqo/3aVk/+Qqqv/la6u/5ixsP+cs7T/oLe3/6S6uv+swMD/oLa1/3aVkv+TrKv/mbGy/5Gq + q/+Mpqf/i6an/3OSk/9MdXH/Vnx1/zFidf8rWYX/jKak/4umo/+Dmpv/YI+K/yqKK9oAAABcAAAAGwAA + AAAAAAAA5aJ/Tvy1kP/9vJb//sKc//7HoP//yqT//86n///QsP/Pv3n/V71D/1biiv9os5H/nq+z/5Ks + qv95l5X/k6uq/5iwr/+Urav/jqim/3KRj/+Io6X/jaip/5Cqq/+UrK3/l6+v/5y0tP+Sq6v/dpWS/5ev + rv+ovb3/nLOz/5Wur/+Qqar/i6ao/4ejpP9Zfnv/TXZw/x5XfP9fhJr/lKyn/4Cbnf9rjYz/H69l/xWa + Kt4AAABeAAAAHAAAAAAAAAAA5aOBTvy3kf/9vpj//sSd//7Iof//zKX//9Cv/8/Bef9VwEv/U9+N/2Xm + m/9r3Jn/dZ6Q/6S3uP+SrKn/dpSR/4OfnP+Np6X/iaSi/3OSkP9/nJ3/iKOl/4mlpv+Np6n/kKmq/4Of + nv9zkpD/mbGv/6/Dwv+rv77/o7m4/5qzsv+Vra7/j6mq/46oqv9ujYr/NWhx/0J2lf+MpKb/f5ee/3qO + g/8rrVf/AMZT/xubLeEAAABfAAAAHAAAAAAAAAAA6KeETf25k//+wJn//sWe//7Jov//zqz/0MJ6/1LC + Sf9M3Yn/XuGU/2rjmv927KP/dc6b/36cmf+ftLT/kaqp/3aVkv91lJL/f5ya/3SSj/9zkpL/g5+h/4ah + o/+Cn6D/dZSS/3aUkv+Wr6z/pbq5/6i9u/+swcD/qb69/6G4uP+asrL/lKyt/5OrrP9xkZj/RXOL/3SQ + j/9mk3j/Z49I/2mlMf8IwkP/AMRW/xqeL+QAAABcAAAAGgAAAAAAAAAA76yJSv26lP/+wZr//saf///L + qP/kx4z/VMJL/0Pagv9W3o//YuGU/27lnf956aX/h/Kv/4DKo/9+mpn/lKuq/42npf97mJb/b46M/2yM + if9vjoz/cZGP/3STkv9vj43/fJqX/5Grqf+Zsa//nbSz/6O5uP+ovbz/rMHA/6i9vf+ftrb/nLOz/4+l + qv9nkHH/V5tG/0GtR/8WwFD/Hrgu/w29O/8Aw1T/AMNV/x2YK90AAABWAAAAGAAAAAAAAAAA8rCMLfy6 + lPr+wZz//8eh///Ko/+Bwlz/NNZ2/03cif9Z347/ZeOX/3HmoP996qj/ie6w/5f3u/+Kzqr/d5aT/4Se + nf+Cnp3/cZCN/3iWlP+Oqaf/eJaT/2uLh/99mpj/iKOh/4ympf+Sq6n/mbCv/561tP+kurj/qr69/67C + wf+rv8D/mKuw/2uYiP9BuUz/J89X/xbMX/8Kx1v/AMRW/wDDVP8AwlH/AMNU/yKMIdMAAABPAAAAFAAA + AAAAAAAA7K2JD/u7lOz+wpz//8ik/+fGjf9EyFn/PdmC/0/bh/9b35D/Z+OY/3Pnof+A66n/jO+y/5jz + uv+n/Mb/nd65/3melv9piIf/bYyM/32amP+Zsa//gZ2b/2qLiP9xkY7/epeV/4Sfnf+MpqT/lK2r/5uy + sf+huLb/pbu5/6S5uv+Ppaj/ZaOI/0HLe/8x1nX/Js9u/xrKY/8Oxlr/AsJS/wDCUf8AwlL/AMJR/yl+ + FscAAABFAAAAEAAAAAAAAAAA/buVAve4ksj+wpz//8im/8zEfv86zWT/QdiB/0/biP9c35D/aOOZ/3Tn + of+B66r/je+y/5nzu/+l98P/tf/Q/7f0z/+XwK//eJeV/2+Oj/94lJf/cZCP/3KSkv90k5P/cpGR/3KR + kP91lJL/eZeW/3qYl/93mJf/c5SV/3mQh/9ZnE3/SdV4/z7af/8z0nX/J85r/xvKY/8Oxlr/AsJS/wDC + Uf8AwlL/BMFN/ytuDrIAAAA1AAAACAAAAAAAAAAAAAAAAPS2kpD+wpv//8in/83Eff86zWX/QdiB/0/b + iP9b35D/aOOZ/3Tnof+A66r/jO+y/5nzu/+m+Mb/svzN/7//1v/R/+L/0fLg/6jItv9jjmz/aYmH/2yO + kP9tj5L/b5GU/2+RlP9vkJL/b5CQ/3KQjP+JmpD/vbCc/5W6YP9O0WL/S96K/znWev8s0nH/J85s/xnL + Zf8Kx13/AMJT/wDCUf8Aw1T/E7xB/yBIB4gAAAAkAAAAAgAAAAAAAAAAAAAAAPa5lEr+wZv//8em/5/B + Zf8u0Gr/Qdd//07bh/9a35D/ZuOX/3LnoP9/66j/i++x/5j1wP+V8K//pfW8/7v/1P/H/9r/2P/n/+X/ + 7/+Pznb/c6FF/7+9p/+0tqP/s7Wh/7O0oP+/uaH/z8Cl/+vNq//+1rH//9Sj/3bNZv9R4ZP/R9d7/2/E + Wv9mxFn/Ic5p/yHGVv8jvkT/CsBL/wDDUv8Aw1X/JKgs7QcOAVUAAAAWAAAAAAAAAAAAAAAAAAAAAP2+ + mAv8wJ3e68KK/0fEUP8u1Hb/QNZ9/0zahv9Y3o7/ZOKW/3Dmn/976af/iO+y/4LhjP+iymv/mNN4/6/7 + y/++/9X/yP/b/9P/5f/I/df/m8hj///kvv//5r///+O8///iuv//37j//9y1///Ysv//1rD//tKq/4rK + a/9J3ov/Qstd/8W7bP+/xHL/Gsth/yW/Qv9zox7/ULhF/wDDUf8CwlD/LoAUxAAAADkAAAAKAAAAAAAA + AAAAAAAAAAAAAAAAAAD1uqGBpbtg/x7LXf8w0nT/PdZ7/0nZg/9V3Yv/YOGT/2zknP9566r/bdl8/63B + Zv//3MH/uM59/53ztv+1/dD/vP7T/8P/2v+y9sD/xdSL///gwP/93rn//969///eu//92bT//tey//7W + sP/+1a7//9Sz/7fHdv881W//QMtd/8W/b/9kxFj/Gsxn/xHJXf9jrC3/V7VC/wDEU/8UvUH/JFEHjAAA + ACMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAACdrk5AQr5I/xvNaf8u0HH/OdR5/0XYgf9R3In/XN+R/2fj + mf916qj/Y9Jr/3+lMP/41K//tc16/5Xxsf+r+sn/sPvL/7T+0v+n5p7/8dmq///euv//3bv/3MqQ/9bI + iv//2rn//9m2///Yt///17j//9e5//7Rqf+gxmz/mMVn/+HIif80xVL/Gc1r/xLIXf8xtS7/FLxA/wDE + V/8nqCnrBw4BSAAAABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqQUiKL087hrNa/8qz27/NdN2/0HX + fv9L2oX/V96N/2Lilf9t5Z7/deeg/1W1M/9lnRr/fMtk/5j1vv+h98P/pvjH/5/2vP+ay27//diy///e + vv/KyoT/YLQ0/1KgE/+ztGH/3seN/8a8cv+tslj/qK9S/8+8e///zqr//8+s//7Mo/9ov1D/Dcld/w3G + XP8Dw1L/AMNU/wq/SP8wdw+gAAAAIgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASK4VbiLG + V/8izm3/MdFy/zvVev9G2YH/UNyJ/1vfkP9l4pb/cOeg/3fooP9t2n7/gumk/47yuP+G6qH/lO+x/5n2 + vf+DxWH/99Oo//DVpP+A0Gz/h/Gz/3PbgP9QqyX/WK8u/1S3Ov9Mv0b/Qbo8/z2jFP+msFb//9Gw///O + q//ixIj/Rb1C/wHEVP8AwlT/AcJS/y+eHtkKFgI4AAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAUK4NAj20JrwezGn/JtFx/zLUef8/2IH/StqE/1Tdi/9d4JH/Z+OY/3DmoP9666v/e+uo/3vT + cv+zxm7/jNR3/471v/+K2Yf/+9So/8rNhf9545L/hO+x/37srP9z6Z//auWZ/2Plm/9Z4ZH/VtFs/2LF + Uf/Dw3b//8+t///MpP//yKn/4b+A/zW7Pv8AxFX/IrMy9CFHBlsAAAASAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEyqDic2uzfjMsdX/0bFVf9Bylv/Qth//0zbhv9V3Yz/XuCS/2bi + mP9r6aX/YdVw/9XJhP/6zqD/gtN0/3jwrv+U1oH//9Wy/63Md/9v5Zj/eOml/3LnoP9r5Zz/ZOOY/1Xf + jf9uw1X/5siM//rNof//z6j//82m///Kov/+xp///8Kj/7q4av8iuDL9M34NgAAAABUAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKqAwZt7pnnrK+Zf84xE3/ONV7/0TY + gf9M24b/VN2M/1nfjv9q0W7/oMdr//rPof+Hw1r/ZeGN/3fTc//bzI3//9Oy/5vMdP9n5Jf/beWd/2fj + mP9g4ZT/Wt+Q/03cg/9grS7/8MWU///Qrv//zqf//8uk//7Hof/+w53//76Z/+qqh+JJcRpkAAAADgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8cSPBF+5 + QMgiz2z/MtN3/zfUeP8/13z/St2L/0PUcv+LsD///9Cy/7fGdf9U233/aNBr/+fNk//Nv3r/eqQu/2vL + Yf9k5Zr/YeGU/1zgkf9W3o3/T9yI/0fbh/8/uTj/ubZj///Qr///y6X//sih//7Env/+wJr/7K2L4GtO + PkQAAAALAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFatFy44vDfjJdFy/07GWP9exVf/RNJv/2DHVP9OqBv/e6Ar/2a4P/9V4o//VrQ1/7Cy + V/9vyGD/Ssxd/1ndiv9a35H/Vd2M/1Hcif9M2oX/RdiB/z3Xf/81y17/t71q///NrP/+yaL//sWf//7B + mv/iqIbNcFJBOQAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJqgsuNLgrz6XAZvibxm//QbYy/4KtMv9A0Wv/O8pd/0fS + cP9Q3o7/Tc5n/0agBv9Pylv/VOKY/1Hdiv9O24f/StqE/0bYgf9A137/O9V6/zPTd/8ryVr/tr1q///K + qv/+xZ///cCa/NKefqA1Jx8dAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ60DCKy1Xiq4v3GfMroy/za7 + Pf8+zWP/VcZV/0HRcP9C2IL/RduH/0fNYv9Hy17/RtqF/0TZgv9C14D/PtZ8/zrVef8103b/MdJy/yfQ + cf8lx1b/wb5x///GpP/qso/NuItvWAAAAAsAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAPbEYf0m6PsvDwHPtgb1O/yzQa/801n7/ONV7/zrXfv8713//NNV3/y7Raf8u0nL/L9N3/y7R + cv8qz2//I89u/xjMZ/9Ivkn+3rOEzcycfmkSDgsOAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAG2zJQPww5UearM2dTW8Ods5wkv1M8th/yrTd/8o0nT/UsZY/6TA + Y/9zwVb/NcdX/yTMZv8hymL/JMVU/y+vJtZagCdYEg4LDgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEeuDApIowweRqwXcje7 + O9ozuzrhra5kkeu8oovsuJOEhqhDbzapHoU/pht9Q5kPUx9NAxIAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAGAAAP/wAAwAAAAAD/ + AACAAAAAAA+U/4AAAAAAAZ7/AAAAAAAApP8AAAAAAAA2/wAAAAAAAIf/AAAAAAAAk/8AAAAAAACh/wAA + AAAAAKz/AAAAAAAAnP8AAAAAAAGq/wAAAAAAAZ//AAAAAAABiP8AAAAAAACP/wAAAAAAAIr/gAAAAAAA + h/+AAAAAAACd/8AAAAAAAKr/4AAAAAAAsv/AAAAAAAC3/8AAAAAAAL//wAAAAAAAuf/AAAAAAACy/8AA + AAAAAHf/wAAAAAAAIv/AAAAAAABa/8AAAAAAAEr/wAAAAAAAUf/AAAAAAABT/8AAAAAAAABd4AAAAAAA + AADgAAAAAAEAAOAAAAAAAQAA8AAAAAABlf/wAAAAAAOf//AAAAAAA6n/+AAAAAAHd//4AAAAAAeJ//wA + AAAAD5b//gAAAAAfo///AAAAAD+v//+AAAAAf73//8AAAAH/i///4AAAA/+d///8AAAP/4v///4AAD// + o////8AA//+a/ygAAAAgAAAAQAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AA8AAAAiAAAAKQAAACkAAAAoAAAAHQAAAAYAAAADAAAACAAAAA8AAAAmAAAAOAAAADEAAAAeAAAAFAAA + ABIAAAAOAAAADAAAAAkAAAAHAAAABAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAQEBAKQUFBekNFRqI+Pj2nQkA+qDg1NJwJCQlsAAAAOAAAADQAAABEBwsUbBMmQbMUKkjEBAkOmAAA + AHgAAABmAAAAWwAAAEoAAAA9AAAAMAAAACYAAAAeAAAAGAAAABEAAAAMAAAABwAAAAMAAAAAAAAAAAAA + AAAAAAAAfHx8C29sbJL33cz/9da8/5+Pif+PjIv/kY+N/2xqaOFGRkjFMzxN0Bw3X+QpTYH9JGCg/yJm + qP81Y5L8YHp68lJpZuc8TU3ZHCUkwQ4TEq4AAACRAAAAfAAAAGIAAABSAAAARQAAAD0AAAAvAAAAJAAA + ABYAAAAMAAAAAwAAAAAyMjI50LWq5P/pvv//9cj/2r+g/5qUkf+Wk5L/kY2J/lZog/4sU4f/MVyU/zNm + pP8vdLn/MHa9/zh6u/+CoKv/mK+t/5Grqf6Ampj6Z4B98ztPTeAZISHHAAAApAAAAI4AAAB2AAAAagAA + AF0AAABTAAAAQAAAAC0AAAAVAAAABouDgYLyzav//+u8///ouv/14LX/sqaa/5WUk/+gnJn/Q2iX/zdr + qv8+drb/QIDC/0GK1P9Bjdf/Q47W/4amtf+ht7X/oLe1/6C3tf+huLb/mbKw/4ilov9Xb23vJDAt1AQG + CbYAAACjAAAAjAAAAHsAAABvAAAAXwAAADgAAAAVpZWOr/nSp///4K///9+u//3erf+9rZr/rKur/7Wy + rP9PeKr/QH/D/0eJzv9Jjtf/TZrm/02e7P9MmeH/gKGs/6O5t/+nvbv/pLq5/6O5t/+huLb/n7a0/5ev + rf+CnZn7Pldj7w8jO9wAAACrAAAAiQAAAHEAAABjAAAAPQAAABi0n5XK/NKp//7Tov/90qD//9Og/822 + mv+/v8H/z8zJ/46mwf9EitT/TJrn/0+b5/9PmeH/T5TZ/1WCpP9rjIn/bI2K/3STkP+Ho6D/l7Cu/6S6 + uf+jubj/oLe1/561s/+Trar/M2+U/wozS9kDBASbAAAAXQAAADkAAAAcAAAACregldL90K3//tKp//7J + mv/9xZP/1Lee/8HCw//Qzs7/w8TH/46qzv9eh7L/TXqV/16DkP9tjJL/fZqY/4eioP+Io6L/haGf/3yZ + l/9ykY//eJaU/5evrf+mu7r/n7a1/5+0sf9ikqX/GGGH+DVHR8oAAABqAAAALQAAAAcAAAAAqJSMvPjN + sv/92L3//da7//vPrv/Tuaf/293d/9LQz/+vsrD/f4+K/2KAeP9egnz/bI2K/3aUkf+Cnpz/jKak/5Ss + qv+UrKv/kaqp/4+op/+Bnpz/aYqI/3eWk/+Zsa//oLa0/5Krrf8cY5H/c5aa/zhKR78DBARjAAAAEgAA + AACXiYWc8ci1//3ezP/93Mr/+NnH/9PEvP/q6+v/7uzs/6exrv9Kcm3/X4OB/2yNjf9ykZH/cpGR/2aI + hf9qi4j/dJSS/4ejof+Xrq3/lKyr/4ympP+En53/bI6L/2SHg/+Yr63/oLaz/yllj/9uk5//c5CM9iYy + MagAAAA3AAAAB6CcmVXQqZv2/+zh//7r4f/t1Mn/4dnW//j4+P/8+fn/fJGO/3KRkv+FoKP/haGi/4ij + pP+HoqP/e5mW/4Sgnv93lZL/aouI/2aJhv92lZL/iqSh/4mjov97mZb/ao2I/1p+e/+Vrqn/Q3GS/1qB + lv+MpqL/aYaD8gUHBmwAAAAb1dbVH5WEfszzy73//+LW/9S1qf/o5+f/9fX1/9XX1v9siYj/haCi/4ek + pP+KpKb/j6mp/4ijo/+EoJ7/kaqp/4qlo/+FoZ//fZqY/3KRjv9miIX/dZSS/3+bmP9uj4z/VHx3/2eJ + hP9afpf/TnSP/5CopP98mpf/JzQzmgAAACkAAAAAx8nILpGAeeWliHz/vrWw/83Fwf/LwLj/1LSc/4Cb + mv+PqKr/k6qr/5Wtrv+cs7P/kKmo/5Krqf+gtrX/mbGv/5WtrP+PqKf/iqWj/4Sfnv9ujov/ZIeD/2uM + iv9XfXn/TXZw/1Z5i/9HbI7/kKik/4KfnP83SkiwAAAALgAAAAAAAAAA1pl7vequjP/vuZf/7r2Z//HD + oP/7yqP/epeS/5aur/+ctLT/ori2/6i9vf+Xr67/lq+t/6q/vv+kubj/oLa1/5uxr/+Vra3/kaqo/3+c + mf9sjIv/XIF9/1d9ef9TeXL/PGyE/yZRg/+JoqH/g5+d/zpNTLMAAAAtAAAAAL6bigb4rYfu/LmT//7C + m//+x6H//82m///Rqv+QnJL/iaWk/6zAv/+rv77/qL69/5evrf+LpaT/pLq5/6m+vf+qvr7/p727/6W6 + uf+Sq6r/fJmY/4ulp/90k5P/TnVx/1V6c/8uY3v/NGWK/4ulov+AnJz/NEg/rQAAACwAAAAA4rWgHvuy + jP39vZX//sWf//3Kov//z6r/7cqW/3qnbf+Io6L/k6uq/6O5uP+ftbX/la2r/3+dnP+Wr6//nbS0/6K4 + uP+ovb3/p7y7/4Cdmv+Rqqr/jaip/4qlpv9dgoD/Unly/y1cd/9khpf/i6Si/3OUlv8gViCuAAAALQAA + AADsv6gy/LeR//3Amv/+yKH//82o/9nGjP9rw1v/XNmS/4OvoP+QqKj/hJ+d/5GqqP+OqKb/dpST/4mk + pf+OqKr/k6ys/46pqf+AnJr/o7m4/6G3t/+UrK3/jqip/3yZmf9NdnP/PW6M/4WepP9xlYz/KK5o/w5n + GrQAAAAwAAAAAO7BqjH9uZP//MKc//7KpP/vx5b/Z8Vd/1TciP9r5Zz/csuY/5Cnp/+Op6b/eZeU/4Cd + m/9zkpD/gJye/4aio/9/nJz/fZqY/5mxr/+qv77/qL28/5uzs/+UrK3/h6Gk/013iP9rjI//cpJw/1Km + SP8DxFH/EWgdtgAAAC4AAAAA9MavJ/27lf/+xJ7/7siZ/2zGYP9I24j/X+CS/3LloP+D76z/hMil/4ak + oP+FoJ//c5GP/3KQjv90k5D/cJCO/3qYlv+Rq6n/mrGw/6O5uP+pvr3/p7y8/56ztf91nYv/TaZQ/yW8 + Tv8QvkD/A8BH/wDEVf8UYhmtAAAAKQAAAADyx64N/LyV+P/Fof+8xX//P9Jx/1Lciv9h4JP/duij/4ft + rf+Z8rv/lNKx/3WVkv9si4v/hZ+d/4aioP9rjYj/e5iW/4mjof+Tq6r/nrSz/6W6uf+jt7r/gqWe/0TA + df8pz2b/E8lf/wTDVf8AwlH/AMRS/xpWD58AAAAhAAAAAAAAAAD3uJPP/8aj/5rGc/871Hb/U9yK/2Lg + lv946KT/h+yu/530vv+w/Mz/te7M/5y+tP95mZP/bY2L/26QkP9vkJH/b4+Q/3GSkv91lJH/g5mV/3Kg + av9LyW7/Ntd7/ynPbv8UyWD/BMJV/wDCUf8Fw03/Gz4FfAAAABEAAAAAAAAAAPe4kZX/xaT/hMVp/znU + dv9S3Ir/YeCU/3boo/+H7a7/mPO8/6L1vv/C/9f/0/7k/7bcuf9woFz/oaqf/5qom/+dqJv/qa2c/8m7 + ov/oxqP/bc1s/0jbgv9YyGH/Mcxn/xzFVv8LwEz/AMJS/xS5P/kHDwBKdHR1CAAAAAAAAAAA/cqwQuW+ + h+svylz/ONV6/0/bh/9d4JH/cuah/3zoo/+g04D/q815/676yv/B/tb/yv7e/67bjf//47///+O9///g + uv//3LT//9aw///Trv94z3P/O9Bo/8C8a/9EyGX/OLc7/2GvN/8Aw1D/II0izAAAACCurq4BAAAAAAAA + AADp5c8ZfrdUxx7Naf8203f/StmE/1jdjv9t5Z//aNqB/7W4Zv/Qz4//nfS6/7L7zP+z+Mf/z92h///e + vP/w06j/7tKl///Yt///17b//9e5/8XMif93x2P/qMNx/yLKYv8gwE3/M7Y4/wjAS/sVTw+PMzIzDQAA + AAAAAAAAAAAAANTrxwVGujWJHsxo/y7Qcf9C13//T9yI/2Pilv9x56H/XrxI/3PHX/+V9L3/nPS+/5bm + nv/Zz5b/49aj/37IZP9orzf/p7hg/5i3V/+EsUj/tLhp//rLpf/cyJD/QMJV/wPEV/8Aw1T/G5YqzQcV + ADkAAAAAAAAAAAAAAAAAAAAAAAAAAIXGWBUpv0TkI89w/zfVe/9I2YT/Wd6O/2bjmP9z56D/eumm/4nY + gv+V14P/i+qo/9TSl/+404r/gOqk/3Thkf9j0nP/WNV6/0rOZf9vuEb/6MmX//3KpP/JwHz/EL9I/w6/ + Rv0aQgZgAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGm9Q0RQvEjLXMNX/zzSb/9M2ob/Vt2N/2Ph + lf9t1Hf/48iN/5XSf/+E35L/6NOm/5HTf/9w5p7/bOWc/2Lil/9X0nL/wsJ3///Oqf//zab//sef///C + of+ar1zoJG0QfxMQFAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjJjiNcv1DpLtBx/zzW + fP9J24j/Wc1q/8bGg/+rzH3/YdRz/83Lh/+2tWP/cdN1/2XjmP9d4JL/VN2M/0bNaP+ft1r//86t//3K + o///w53//LuW9GlSOVwAAAAPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG6/ + SEorwUfYbsNc/1DHXP9hukD/Wq00/1bLZP9Rx1z/gLJD/1HPaf9V3Yz/UduK/0rahP9D14D/NNFx/4jA + Y///yqj//sWe/9ulg8diSDhJTE5PAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA7/bpA2K+OjSuuGKJW7lC7Ea9R/9EyVz/Q9R4/0fYgf9FwEf/StZ8/0bZg/9D13//PNV6/zXT + dv8lzWn/isFk///Eo/bfqIeqJRkSKXJwcAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACm25Y1e7dIkpm6VcQty2D3NdBx/jPWff830XH/Tcpl/zTO + av8ozm3/Is1o/y28SeWBiU+hdl5RL0xNTQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADd58MB4enNGj2tFlRAsSeLLsJN6G65 + V8bVu4uuirRaoS6yMao4rCiUHlEJP3+BeQoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAwAAA/4AAAA8AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAgAAAAMAA + AACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAADAAAAAwAAAAMAAAADAAAABwAAAA+AAAAPwAAAH+AAAD/wA + AB/8AAA//4AA///AA/8oAAAAGAAAADAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADo6 + OgYAAAAoAAAAMwAAADIAAAAnAAAABwAAAAcAAAATAAAAMwAAAEYAAAApAAAAGgAAABQAAAAOAAAACwAA + AAgAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGlnZ5awnpfpd3Rz6np3dulAPz63GhkXegoP + F4gWKUW/H0yC9h1DcOsnMjLBGCEgrAMGBpEAAAB1AAAAWwAAAEMAAAAzAAAAJwAAABsAAAAQAAAABwAA + AAAAAAAAPkA/S/vYvv//9sn/xqyX/5aWlf+Sj4v+VGaC/y1Vi/8yY5//LXK2/yt1vv93mKn/lK2r/4Oe + nP1ddXLvKjc21AMEBK0AAACJAAAAbwAAAF8AAABPAAAAOAAAAB0AAAAGoZOOpv/js///57j/89uw/5iV + lf+gnZn/Pmid/zxztP9BgML/Qo3X/z+R3/96obv/pLm2/6G3tv+huLf/mrOy/32Ylvw4SUfgAwgMuwAA + AJwAAACAAAAAcQAAAFEAAAAavqWWzv/apv//2ab//9mm/6yno//Fwr7/WYW4/0qR2v9Pmuf/UqP1/0qa + 7f9mipL/hKCe/5ixr/+nvLv/o7m4/6C2tf+ctLL/Z4eT/wcrS+IAAACWAAAAYwAAAEEAAAAVyKiY3v/X + r//+y5v//caU/7u0rv/U09L/vcHL/2KTzP9LfqX/WYGY/2+Nkf+GoZ//haKg/3qXlf9xkI7/haGg/6S5 + uP+gtrX/obay/xtsmv8yRUXLAAAAXgAAABQAAAACtZuQyv/Zvv/9173/+86w/9DLyP/Y19b/oaim/2eD + e/9afnn/aYqH/3aVkv+Io6H/la6s/5StrP+Rqaj/gJ2b/2mLiP+NqKb/o7i1/0qAnP9pkp3/NkdFvQAA + ADoAAAAAlIeBm//dzf/949b/7tLE/+Tk4//39fX/gJSR/2uNjP9+m5z/gp+g/3WUk/9wkI3/aYuI/3ST + kf+LpqT/kKmn/4Gdm/9ihYL/gJya/3iap/9Oe5X/gp+b/xgfIJEAAAAVvr++Oc+snf//6N7/1ryy//f5 + +v/m5uf/b4uL/4eipP+Jo6X/j6ip/4Ccm/+Qqqj/iKOh/4Cbm/9tjYr/bIyJ/4GenP9wkI3/UXh0/3ya + nf8/aYr/j6ml/1ZvbdwAAAAyAAAAAKOem3ypin3/xbeu/8u+tv/buJ7/gZ6d/5KrrP+Wrq//n7W1/4qk + ov+iuLf/mrGw/5Osq/+Mp6X/haCe/2OGg/9qi4j/Vnx4/1uBfv89ZY7/jaik/2yJhu8AAAA4AAAAAJFf + SF//uJD//8GY///Kof//z6b/fZeT/6S5uf+ovbz/rMHA/4mkov+rwL//qb28/6S6uf+etbP/kquq/3ua + mf9niYj/UXh0/0p2eP8aToH/iqSi/2yIh+8AAAA2AAAAAOafe5P9u5X//saf///Mpf/4zqD/gKJ+/46n + p/+mu7r/oLa2/4OenP+Xr7D/n7a2/6a8vP+pvr3/gZ6b/5Gqq/+JpKX/Vnx5/0Vwcv9PdpD/i6Oi/1OI + Zu0AAAA3AAAAAO+phKf9wJn//smi//jLof9txF//YNeT/5Oqqv+Dnpz/j6im/36amP+HoqT/jqip/5Gq + qv+CnZz/p7y7/5qzs/+Pqar/eJWU/zNme/+Em6X/ZpaB/xCvQvEAAAA6AAAAAPOuiab+w5z//cqi/2jG + X/9V35H/ceif/3zIoP+Rpqj/e5mW/3KRjv9zk5L/eZeX/3yZl/+ds7H/p727/6e9vP+asbL/f5uY/1WQ + aP9ApUz/Hbo9/wyzQvEAAAA2AAAAAPSxioj/xKD/qcV3/z7Zgv9g4ZP/eOek/5Lytv+Qz6//d5SS/3KR + j/+KpKL/bo6L/4Sfnv+Sq6n/n7a0/6m+vf+Pqqr/Rbxu/x3PYP8ExFf/AMJS/xKmN+gAAAArAAAAAPjI + rFX/xKL/gcdv/0bZhP9h4ZT/euml/5Lxtv+t/Mv/ue7P/5e1rf9qioT/bI6Q/2yPkP9vj5D/dpOQ/4+g + hP9LyGn/MtZ4/yDMZ/8ExFf/AMNS/xmPKNAAAAAVAAAAAPzcyRH/wZv5S8li/0XYgv9f4JL/d+ij/4vu + rf+a3o//u//U/9r/6f+VzHf/39Cy/9rMrf/kzqz//dWw/8DPhf9C2X7/nb9j/xzHV/8/tDr/AMVU/xRI + C4+DgYMGAAAAAAAAAACdtWCwIM5p/0HWfv9Y3o7/cOij/33BWf/g0Zr/ofbA/7j90//C4qP//969/+7T + pP//2bj//9a1//LQpf9myWP/kMNn/xDKZP9CsjT/DMBH/QMMAEAAAAAAAAAAAAAAAABlwU1eH8xo/zfU + eP9O24f/Y+KW/2vahP9xx2L/kfO4/5v1vf/EzIf/0NOU/2PGWf+Nskv/gbdO/3avQf/ux5r/1ceK/xDE + UP8AxFX/HHoarTk2OQkAAAAAAAAAAAAAAAAAAAAAL7UrszDMZf9D1Xb/VN2L/2bimf9s55z/xMl+/4Hj + lv/I1pn/ldeH/3vrq/9q5p3/XNuE/6XKef/xy5z//8ml/7e9cv8asTDgAAEAHQAAAAAAAAAAAAAAAAAA + AAAAAAAA0+rEAbK5YZsszmr/P9d+/0vchv+qxHH/pMt7/4jVgP/OvXj/ctiA/2Pilv9W3o//R8VX/+7F + lv/+y6T//8We/9eafcMEDQAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbryAcsty25fMNf/1m+ + R/9Ntj//UtN1/2ayOP9U0Gv/VN2M/03Zhv9D13//L89q/9zEiv//yKH/uYlto09JRw0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3dy2LjC1KNV2w139NdR4/z7Wev891Hb/M9R2/zTT + d/8r0HL/Jspc/+O2h9BiRzdKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADc3rYgO7AgfDTASdJUv1jcw7x9wUK4RLswtDezJ1kOTQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgAAfAIAAAycAAAD/AAAA/wAAAP8AAAD/AAAB/wAAAP8AAAD/gAAA/4AA + AP+AAAD/gAAA/4AAAP+AAAD/gAAA/4AAAP/AAAH/wAAB/+AAA//gAAf/8AAP//wAP///AP//KAAAABAA + AAAgAAAAAQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAFAAAAB0AAAAgAAAAHwAA + ABwAAAAXAAAAFgAAABkAAAAeAAAAIAAAABcAAAAIAAAAAAAAAAAAAAAEAAAAHQAAAEkAAABiAAAAZQAA + AGUAAABeAAAAVQAAAFIAAABYAAAAYgAAAGYAAABNAAAAHwAAAAQAAAAANDQ0FpuLhbfHsZzomYd87Hx7 + eu16d3Pmal1MzWBOUcsxPl3UH0l65yNbl/YgRnTfBAcOgQAAAD0AAAANAAAAAHx3dmz1y6z///fG//DV + r/+dlpL/l5OO/2Z1if8kVJD/MmSg/zd3uf82gMj/NXzL/xguLq8AAABdAAAAIQAAAASkkIiu/9ut///n + t///47P/saSW/6ekoP9ug6D/NHC1/0WEx/9HkNj/SZnp/0OQ6v8leUDdAgYAfAAAAD4AAAANuJqNyf/a + qv//1qL//9ai/8Cvmv/ExMP/mqW0/0KFzv9DlOX/SZjo/16a7/9SjK3/A7dR/xpgFLYAAABWAAAAF7+h + kdT/1bD//tCm//7Hlv/Ot6T/vr/A/767uv+Kor7/f5W1/62jnv+Pom7/ULRP/wDFUf8TkzDaAAAAYQAA + AB2tkYW7/9i///7aw//60rj/1cW6/9/f4f/EycL/uLSH///PqP+e1Hv/ONRs/xPLX/8AxFb/DqQ65wAA + AGQAAAAfjYJ+kPjOvf//7eH/9trN/9nQzP/7/P7/1dTO/+PRof//2rP/s9OO/1bZg/8tz2z/Hb1G/xKq + O+wAAABjAAAAHpWGfEDDopf9/97V/96+tv/p5Ob/8O/y/8fDqP//4bz//925///Ws/+Y0oX/OMpa/yS7 + Qf8SpzjqAAAAXAAAABvksJIKxqKK6JSTfP+dq5v/vMvB/7jLvv+m1Jb/1teZ///hwv//17X/otCF/zPQ + af8Sx13/EJ003QAAAE8AAAAUAAAAALu9gKMrznD/WN6U/3rPff+i3pb/tf/S/9DZnf/r0aH/98+i/7TN + hv9lxmH/FL9H/xmNJ8UAAAA0AAAACgAAAABosj0+Jsxg+Unbh/9k34z/ht2L/5jknP/E0o//etF3/27H + ZP+9wnf/08iQ/yC+T/shZA9uAAAAFAAAAAIAAAAAAAAAAHa0PF8/zGf5TNV6/4PIav+Mym3/i854/1zn + nP9P1Hf/4MeQ//zCpfmBgUR+AAAAFAAAAAMAAAAAAAAAAAAAAAAAAAAAWbpBRma5SMpUyWL8Qs1o/0TS + dP861nr/O8pi/9izg9G2iHNUAAAADAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5v1EDe7lWOzC8 + QId7uF6KTLNNgjOfL08oIBgMAAAAAgAAAAAAAAAAAAAAAAAAAACAA5n/AAGI/wABdP8AAHj/AACB/wAA + ov8AAIfvAAAANgAAAAAAAHuTAACV/4AAn/+AAKX/wAGg/+ADfv/wD6f/ + + + \ No newline at end of file diff --git a/ProjectCarbon/frmSocketInformation.Designer.cs b/ProjectCarbon/frmSocketInformation.Designer.cs new file mode 100644 index 0000000..7891865 --- /dev/null +++ b/ProjectCarbon/frmSocketInformation.Designer.cs @@ -0,0 +1,81 @@ +namespace ProjectCarbon +{ + partial class frmSocketInformation + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.btnClose = new System.Windows.Forms.Button(); + this.lstSocketInformation = new System.Windows.Forms.ListBox(); + this.SuspendLayout(); + // + // btnClose + // + this.btnClose.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.btnClose.DialogResult = System.Windows.Forms.DialogResult.OK; + this.btnClose.Location = new System.Drawing.Point(440, 336); + this.btnClose.Name = "btnClose"; + this.btnClose.Size = new System.Drawing.Size(80, 24); + this.btnClose.TabIndex = 1; + this.btnClose.Text = "OK"; + this.btnClose.UseVisualStyleBackColor = true; + this.btnClose.Click += new System.EventHandler(this.btnClose_Click); + // + // lstSocketInformation + // + this.lstSocketInformation.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.lstSocketInformation.Font = new System.Drawing.Font("Courier New", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.lstSocketInformation.FormattingEnabled = true; + this.lstSocketInformation.IntegralHeight = false; + this.lstSocketInformation.ItemHeight = 15; + this.lstSocketInformation.Location = new System.Drawing.Point(8, 8); + this.lstSocketInformation.Name = "lstSocketInformation"; + this.lstSocketInformation.Size = new System.Drawing.Size(512, 319); + this.lstSocketInformation.TabIndex = 2; + // + // frmSocketInformation + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(532, 373); + this.Controls.Add(this.lstSocketInformation); + this.Controls.Add(this.btnClose); + this.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.Name = "frmSocketInformation"; + this.Text = "Socket Information"; + this.Load += new System.EventHandler(this.frmSocketInformation_Load); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button btnClose; + private System.Windows.Forms.ListBox lstSocketInformation; + } +} \ No newline at end of file diff --git a/ProjectCarbon/frmSocketInformation.cs b/ProjectCarbon/frmSocketInformation.cs new file mode 100644 index 0000000..e9e588f --- /dev/null +++ b/ProjectCarbon/frmSocketInformation.cs @@ -0,0 +1,198 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using System.Net; +using System.Net.Sockets; +using System.Net.NetworkInformation; + +namespace ProjectCarbon +{ + public partial class frmSocketInformation : Form + { + public frmSocketInformation() + { + InitializeComponent(); + } + + private void frmSocketInformation_Load(object sender, EventArgs e) + { + PopulateSocketInformation(); + } + + private void btnClose_Click(object sender, EventArgs e) + { + this.Close(); + } + + private void PopulateSocketInformation() + { + IPGlobalProperties computerProperties = IPGlobalProperties.GetIPGlobalProperties(); + NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces(); + + lstSocketInformation.Items.Clear(); + lstSocketInformation.Items.Add(String.Format("Interface information for {0}.{1}", + computerProperties.HostName, computerProperties.DomainName)); + + if (nics == null || nics.Length < 1) + { + lstSocketInformation.Items.Add(" No network interfaces found."); + return; + } + + lstSocketInformation.Items.Add(String.Format(" Number of interfaces .................... : {0}", nics.Length)); + foreach (NetworkInterface adapter in nics) + { + IPInterfaceProperties properties = adapter.GetIPProperties(); + lstSocketInformation.Items.Add(""); + lstSocketInformation.Items.Add(adapter.Description); + lstSocketInformation.Items.Add(String.Empty.PadLeft(adapter.Description.Length, '=')); + lstSocketInformation.Items.Add(String.Format(" Interface type .......................... : {0}", adapter.NetworkInterfaceType)); + lstSocketInformation.Items.Add(String.Format(" Physical Address ........................ : {0}", + adapter.GetPhysicalAddress().ToString())); + lstSocketInformation.Items.Add(String.Format(" Operational status ...................... : {0}", + adapter.OperationalStatus)); + string versions = ""; + + // Create a display string for the supported IP versions. + if (adapter.Supports(NetworkInterfaceComponent.IPv4)) + { + versions = "IPv4"; + } + if (adapter.Supports(NetworkInterfaceComponent.IPv6)) + { + if (versions.Length > 0) + { + versions += " "; + } + versions += "IPv6"; + } + lstSocketInformation.Items.Add(String.Format(" IP version .............................. : {0}", versions)); + PopulateIPAddresses(properties); + + // The following information is not useful for loopback adapters. + if (adapter.NetworkInterfaceType == NetworkInterfaceType.Loopback) + { + continue; + } + lstSocketInformation.Items.Add(String.Format(" DNS suffix .............................. : {0}", + properties.DnsSuffix)); + + if (adapter.Supports(NetworkInterfaceComponent.IPv4)) + { + IPv4InterfaceProperties ipv4 = properties.GetIPv4Properties(); + lstSocketInformation.Items.Add(String.Format(" MTU...................................... : {0}", ipv4.Mtu)); + if (ipv4.UsesWins) + { + + IPAddressCollection winsServers = properties.WinsServersAddresses; + if (winsServers.Count > 0) + { + //label = " WINS Servers ............................ :"; + foreach (IPAddress wins in winsServers) + { + lstSocketInformation.Items.Add(String.Format(" WINS Servers ............................ : {0}", + wins.ToString() + )); + } + } + } + } + + lstSocketInformation.Items.Add(String.Format(" DNS enabled ............................. : {0}", + properties.IsDnsEnabled)); + lstSocketInformation.Items.Add(String.Format(" Dynamically configured DNS .............. : {0}", + properties.IsDynamicDnsEnabled)); + lstSocketInformation.Items.Add(String.Format(" Receive Only ............................ : {0}", + adapter.IsReceiveOnly)); + lstSocketInformation.Items.Add(String.Format(" Multicast ............................... : {0}", + adapter.SupportsMulticast)); + + //adapter. + //ShowInterfaceStatistics(adapter); + } + } + + public void PopulateIPAddresses(IPInterfaceProperties adapterProperties) + { + IPAddressCollection dnsServers = adapterProperties.DnsAddresses; + if (dnsServers != null) + { + foreach (IPAddress dns in dnsServers) + { + lstSocketInformation.Items.Add(String.Format(" DNS Servers ............................. : {0}", + dns.ToString() + )); + } + } + IPAddressInformationCollection anyCast = adapterProperties.AnycastAddresses; + if (anyCast != null) + { + foreach (IPAddressInformation any in anyCast) + { + lstSocketInformation.Items.Add(String.Format(" Anycast Address .......................... : {0} {1} {2}", + any.Address, + any.IsTransient ? "Transient" : "", + any.IsDnsEligible ? "DNS Eligible" : "" + )); + } + lstSocketInformation.Items.Add(""); + } + + MulticastIPAddressInformationCollection multiCast = adapterProperties.MulticastAddresses; + if (multiCast != null) + { + foreach (IPAddressInformation multi in multiCast) + { + lstSocketInformation.Items.Add(String.Format(" Multicast Address ....................... : {0} {1} {2}", + multi.Address, + multi.IsTransient ? "Transient" : "", + multi.IsDnsEligible ? "DNS Eligible" : "" + )); + } + lstSocketInformation.Items.Add(""); + } + UnicastIPAddressInformationCollection uniCast = adapterProperties.UnicastAddresses; + if (uniCast != null) + { + string lifeTimeFormat = "dddd, MMMM dd, yyyy hh:mm:ss tt"; + foreach (UnicastIPAddressInformation uni in uniCast) + { + DateTime when; + + lstSocketInformation.Items.Add(String.Format(" Unicast Address ......................... : {0}", uni.Address)); + lstSocketInformation.Items.Add(String.Format(" Prefix Origin ........................ : {0}", uni.PrefixOrigin)); + lstSocketInformation.Items.Add(String.Format(" Suffix Origin ........................ : {0}", uni.SuffixOrigin)); + lstSocketInformation.Items.Add(String.Format(" Duplicate Address Detection .......... : {0}", + uni.DuplicateAddressDetectionState)); + + // Format the lifetimes as Sunday, February 16, 2003 11:33:44 PM + // if en-us is the current culture. + + // Calculate the date and time at the end of the lifetimes. + when = DateTime.UtcNow + TimeSpan.FromSeconds(uni.AddressValidLifetime); + when = when.ToLocalTime(); + lstSocketInformation.Items.Add(String.Format(" Valid Life Time ...................... : {0}", + when.ToString(lifeTimeFormat, System.Globalization.CultureInfo.CurrentCulture) + )); + when = DateTime.UtcNow + TimeSpan.FromSeconds(uni.AddressPreferredLifetime); + when = when.ToLocalTime(); + lstSocketInformation.Items.Add(String.Format(" Preferred life time .................. : {0}", + when.ToString(lifeTimeFormat, System.Globalization.CultureInfo.CurrentCulture) + )); + + when = DateTime.UtcNow + TimeSpan.FromSeconds(uni.DhcpLeaseLifetime); + when = when.ToLocalTime(); + lstSocketInformation.Items.Add(String.Format(" DHCP Leased Life Time ................ : {0}", + when.ToString(lifeTimeFormat, System.Globalization.CultureInfo.CurrentCulture) + )); + } + lstSocketInformation.Items.Add(""); + } + } + + } +} \ No newline at end of file diff --git a/ProjectCarbon/frmSocketInformation.resx b/ProjectCarbon/frmSocketInformation.resx new file mode 100644 index 0000000..19dc0dd --- /dev/null +++ b/ProjectCarbon/frmSocketInformation.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectCarbon/search16.ico b/ProjectCarbon/search16.ico new file mode 100644 index 0000000..436b8b4 Binary files /dev/null and b/ProjectCarbon/search16.ico differ