一、管道

管道(pipe)是用于进程间通信的共享内存区域。创建管道的进程称为管道服务器,而连接到这个管道的进程称为管道客户端。一个进程向管道写入信息,而另外一个进程从管道读取信息。

异步管道是基于字符和半双工的(即单向),一般用于程序输入输出的重定向;命名管道则强大地多,它们是面向消息和全双工的,同时还允许网络通信,用于创建客户端/服务器系统

  • 异步管道(匿名管道):

管道(Pipe)是一种具有两个端点的通信通道:有一端句柄的进 程可以和有另一端句柄的进程通信。管道可以是单向-一端是只读的,另一端点是只写的(匿名管道);也可以是双向的一管道的两端点既可读也可写。 匿名管道(Anonymous Pipe)是在父进程和子进程之间,或同一父进程的两个子进程之间传输数据的无名字的单向管道。通常由父进程创建管道, 然后由要通信的子进程继承通道的读端点句柄或写 端点句柄,然后实现通信。父进程还可以建立两个或更多个继承匿名管道读和写句柄的子进程。这些子进程 可以使用管道直接通信,不需要通过父进程。 匿名管道是单机上实现子进程标准I/O重定向的有效方法,它不能在网上使用,也不能用于两个不相关的进程之间。

实验流程图:

aaarticlea/png;base64,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" alt="" />

异步管道实现的流程图说明:
1)父进程是我们需要实现的,其中需要创建管道A,管道B,和子进程,整个实现流程分为4个操作。
2)管道A:输入管道
3)管道B:输出管道
4)操作A:把输入文件sample.in的数据写入输入管道(管道A)
5)操作B:子进程从输入管道中读取数据,作为该进程的加工原料。通常,程序的输入数据由标准的输入设备输入,这里实现输入重定向,即把输入管道作为输入设备。
6)操作C:子进程把加工后的成品(输出数据)输出到输出管道。通常,程序的输出数据会输出到标准的输出设备,一般为屏幕,这里实现输出重定向,即把输出管道作为输出设备。
7)操作D:把输出管道的数据写入输出文件

需要注意的是,管道的本质只是一个共享的内存区域。这个实验中,管道区域处于父进程的地址空间中,父进程的作用是提供环境和资源,并协调子进程进行加工。

GetStdHandle:返回标准的输入、输出或错误的设备的句柄,也就是获得输入、输出/错误的屏幕缓冲区的句柄。

CreatePipe:创建一个匿名管道,并从中得到读、写管道的句柄。

SetStdHandle:为标准的输入、输出或错误的设备设置句柄。和GetStdHandle配合使用其实就是用来使其它的窗口作为标准输入、输出、错误窗口。

子进程sample.exe内容:

#include <iostream>
using namespace std;
int main()
{
int a, b;
while (cin >> a >> b && (a || b))
cout << a + b << endl;
return ;
}

父进程内容:

#include <windows.h>
#include <iostream>
#include <strsafe.h> const int BUFSIZE = ; HANDLE hChildStdinRd, hChildStdinWr, hChildStdinWrDup,
hChildStdoutRd, hChildStdoutWr, hChildStdoutRdDup,
hSaveStdin, hSaveStdout; BOOL CreateChildProcess(LPTSTR);
VOID WriteToPipe(LPTSTR);
VOID ReadFromPipe(LPTSTR);
VOID ErrorExit(LPTSTR);
VOID ErrMsg(LPTSTR, BOOL); void main(int argc, char *argv[])//DataRedirect sample sample.in sample.out
{
// 处理输入参数
if (argc != )
return;
TCHAR lpProgram[0x100] = { };
TCHAR lpInputFile[0x100] = { };
TCHAR lpOutputFile[0x100] = { };
DWORD cchDest = 0x100; StringCchCopy(lpProgram, cchDest, argv[]);
StringCchCopy(lpInputFile, cchDest, argv[]);
StringCchCopy(lpOutputFile, cchDest, argv[]); SECURITY_ATTRIBUTES saAttr;
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL; //重定向标准输出hChildStdoutWr
hSaveStdout = GetStdHandle(STD_OUTPUT_HANDLE);//获得标准输出 //创建管道B,hChildStdoutRd就是管道B的读取方,hChildStdoutWr是向管道B输出,后边用作自己进程的标准输出
if (!CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, ))//创建匿名管道,获得读、写管道的句柄
ErrorExit("Stdout pipe creation failed\n"); if (!SetStdHandle(STD_OUTPUT_HANDLE, hChildStdoutWr))//更改标准输出为hChildStdoutWr,则子线程的cout会输出到hChildStdoutWr
ErrorExit("Redirecting STDOUT failed"); //DuplicateHandle获得一个进程句柄表中的一个记录项,然后在另一个进程的句柄表中创建这个记录项的一个副本。
BOOL fSuccess = DuplicateHandle(//Duplicates an object handle.
GetCurrentProcess(),//A handle to the process with the handle to be duplicated.
hChildStdoutRd,//The handle to be duplicated
GetCurrentProcess(),//A handle to the process that is to receive the duplicated handle.
&hChildStdoutRdDup,//A pointer to a variable that receives the duplicate handle
,
FALSE,
DUPLICATE_SAME_ACCESS);
if (!fSuccess)
ErrorExit("DuplicateHandle failed");
CloseHandle(hChildStdoutRd); //重定向标准输入为 hChildStdinRd
hSaveStdin = GetStdHandle(STD_INPUT_HANDLE); if (!CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, ))//子进程从hChildStdinRd读入
ErrorExit("Stdin pipe creation failed\n"); if (!SetStdHandle(STD_INPUT_HANDLE, hChildStdinRd))
ErrorExit("Redirecting Stdin failed"); fSuccess = DuplicateHandle(
GetCurrentProcess(),
hChildStdinWr,
GetCurrentProcess(),
&hChildStdinWrDup,
,
FALSE,
DUPLICATE_SAME_ACCESS);
if (!fSuccess)
ErrorExit("DuplicateHandle failed");
CloseHandle(hChildStdinWr); //创建子进程(即启动SAMPLE.EXE)
fSuccess = CreateChildProcess(lpProgram);
if (!fSuccess)
ErrorExit("Create process failed"); // 父进程输入输出流的还原设置
if (!SetStdHandle(STD_INPUT_HANDLE, hSaveStdin))
ErrorExit("Re-redirecting Stdin failed\n");
if (!SetStdHandle(STD_OUTPUT_HANDLE, hSaveStdout))
ErrorExit("Re-redirecting Stdout failed\n"); WriteToPipe(lpInputFile);//操作A
ReadFromPipe(lpOutputFile);//操作B
} BOOL CreateChildProcess(LPTSTR lpProgram)
{
PROCESS_INFORMATION piProcInfo;
STARTUPINFO siStartInfo;
BOOL bFuncRetn = FALSE; ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));
ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
siStartInfo.cb = sizeof(STARTUPINFO); bFuncRetn = CreateProcess(NULL, lpProgram, NULL, NULL, TRUE, \
, NULL, NULL, &siStartInfo, &piProcInfo);
if (bFuncRetn == )
{
ErrorExit("CreateProcess failed\n");
return ;
}
else
{
CloseHandle(piProcInfo.hProcess);
CloseHandle(piProcInfo.hThread);
return bFuncRetn;
}
} VOID WriteToPipe(LPTSTR lpInputFile)
{
HANDLE hInputFile = CreateFile(lpInputFile, GENERIC_READ, , NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
if (hInputFile == INVALID_HANDLE_VALUE)
return; BOOL fSuccess;
DWORD dwRead, dwWritten;
CHAR chBuf[BUFSIZE] = { }; for (;;)
{
//操作A //写到管道A
fSuccess = ReadFile(hInputFile, chBuf, BUFSIZE, &dwRead, NULL);
if (!fSuccess || dwRead == )
break;
//父进程往这个管道A里写,子进程就从这个管道A里读
fSuccess = WriteFile(hChildStdinWrDup, chBuf, dwRead, &dwWritten, NULL);
if (!fSuccess)
break;
} if (!CloseHandle(hChildStdinWrDup))
ErrorExit("Close pipe failed\n"); CloseHandle(hInputFile);
} VOID ReadFromPipe(LPTSTR lpOutputFile)
{
HANDLE hOutputFile = CreateFile(lpOutputFile, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hOutputFile == INVALID_HANDLE_VALUE)
return; BOOL fSuccess;
DWORD dwRead, dwWritten;
CHAR chBuf[BUFSIZE] = { }; if (!CloseHandle(hChildStdoutWr))
ErrorExit("Closing handle failed"); for (;;)
{
//从管道B读,读完写到sample.out
//父进程从管道B读,就是子进程往管道B里写
fSuccess = ReadFile(hChildStdoutRdDup, chBuf, BUFSIZE, &dwRead, NULL);
if (!fSuccess || dwRead == )
{
break;
} fSuccess = WriteFile(hOutputFile, chBuf, dwRead, &dwWritten, NULL);
if (!fSuccess)
break;
} CloseHandle(hOutputFile);
} VOID ErrorExit(LPTSTR lpszMessage)
{
MessageBox(, lpszMessage, , );
}

读入的数据:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGwAAABOCAIAAABKYGSnAAADiElEQVR4nO2asY6qQBSG91looL6JjebeYisT14Jyb6GtsXBtoCA3WbOljYaK96DiNazwNawobwHiwM4czsJBjrsn+Stz4sCXMzDzMU+2Y0k65unP7189ZfB7E4iPFIEoEHkEgPi8+tgfjnvvLxlEL7lkWZ5T5AKXNYvOZeUlS7aDY2oH0fWO/1az59UHJcQybnTKzqELQkz84el0hHhrxr4gQv0lECGI2ySfoVAbWtXpDE98FhmmE20/zrLYQ1yfG52QlT8PorNNkC3mhin7ZhyuExtmdBEvaZz7wwd4O+8PSlqg/DTY9YH4pWcie4IARIIMfm8C8ZEiECkgDn4F3yACUSDyiEDsFeLk9b1YJAaLCc1gehXmhqlhm+xGpyxDmYhaJdq59QtxtNitXxzLdqzxMjjsXsekoyoqbBadi61x3Y/5cXaOE4zOMVc2Obd+ISqZrw/HAiglxM8qrGIl8s01xolBlU3O7V4Qx8vg8DYlGg9SYeoNe8kljWYYsWioRDq3+0DsoQ1tR6fC1F/8+EqzCWJjJdq59QVxvAx6IehYNRVWk4aVDyxgQyEq0c6tD4h9EqyoMFC74r8TmDtxsBfLbX1TZDPvPphOhd3WN0WqINpBxDu3XiFKBKJAfLwIRIHIIwJRIPKIEeLLW7lIJFNhButVfCBV14OAy8L6MT+uLhX1J81IpBlOQNCoMK31arA17fyYzoA1rNu7SLM7WxyFRWWrB0K8uSykH9PulxEQ20ozAOJ0k09naiOru+LPd6hxWVg/5obpOfSiUz5P02hWDqGbuQTSbAgpq9FTZi5lMd6PuWF6Y6fpSr3y6CDNMG/n6Ybu3WJwNgCXggLej+WdqPZv/Z/1J83aSzNcJxLNaLP1Ajvxi6+ISoGOl/6kWQdpZoJ4fSASPhP11kvRVtofNTeG8GPKWNdK7UkzGmkmi22CCESByCMCUSDyiEAUiDzSAHG8DIi+l1q2Ax0Aa1/JICDE+fqwW292VBC3SaZuJICNKr6SRWCLEywmowUVxPqpB/OuA1/JI5DZfl+ObIcMYqm/8q1rlJSipX0lkxggztdXEUsM0UsuJSAYIqaSSfQQF7vKQRwaDeHHNUUKTWdkJY80LnHonomqsGswoPhKFrknxJ+5xJEIRIH4SBGIApFHBKJA5BGBKBB5RCAKRB4RiAKRRwSiQOQRgSgQeUQgCkQeEYgE+Q+TGTynxSD/0AAAAABJRU5ErkJggg==" alt="" />

输出结果:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEQAAABNCAIAAACQflUtAAADkUlEQVRoge2ZP0/iYBzHO59Q2j5tbzqHLu1kiCeeVqoJGsUDxJ7GxBtgNR3QpQ7kEoluLBCSS/oaLnFy6mR4C0zwNpgYb+gfHiiILU+hbZp8hxKgeT79Pc/z+377YOxX4E0MSzEsRTMUoAmCxNmv9PX1L0kSPy1F6/57uREl6erl9b2rKZIkSjeN1+57t/ve1f5a337mPsZfFGxpGJICRBJP7GS2y+WSGxj08ggzVRaKSl1eXhwdZUMNQ1KAwPHE9vf01ZW8XhKPMDYJoAmCSBplOTxcc1m8wBgkDEsBmqRAKolviOJeEMriHcacYKnE5uY3l5uYrzAscCWGoRiGoigilUoCQBaLP8/Pz7LZ/SAIMwb3edE0CQCB4wmCwI+Pc+Xyxf7+j4AIA4BwJZLEcTxB0+DkJFcul3Z3d4IjbGPjiyuxLJ1Ob+XzZ6enJ+n0VqCEZaW9yAjjBS4ywg6l7eW1dowYJoZZMUzu7rnZajfV3+hgHt9Go6Ep/WFlMLLa/nNXyN09I4R50Edv6vi6p8krnWZoYQraYNjXCmaJBh15hdMMOQzHC5yqr3SO+VsZA0PVhyGvjNzpT6yZof4Ybhhr0cPX/sPIarvZguQByXlfWevZW/NqysJHsmnGMAGEWfsIYpgYJlzCeIHjD26fzCZTrxygua9pzEbD0VTHtKOB4XHgpLB0U8J4IVNpKEWB4wVOrNZbjVsR6dOStZ7tzeDrWVo2LExOs5LSaptgKGFM47xgrNAvUcCI1XrrPo8I40GHp5PA8XKnP+iols0x0w66skzC+FAWXjBWxZtqwIwZpoe+fFnGMGK17gsJPG6504cWjKpDax2Rs8Z8JoFjc0EbWACTo1d1NIEUg/ZlU7USkmoMR1NrxmRwbMHoAk/0mmZUFMMEVTFMUBU5mOK93WSQRQCopVg9ZJ7bd54XeM0FDqOJJgIUtIH5RnOO7be92cLzAhcG1D/XbMk2mpAgW7ngvMCVATVg8jVjmqFOZnNGM/2w558XuMsFPoezBWXhPj4vcJsLpnazfA3dHiBrPSfJtK384LzAvQF1VAbRTJtN4nT7888LPOQCbLxgEK4ZyOpP7K2zHvbs8wJPuSByTTMyimGCqhgmqIoojFitI3rPtHaYktJqKLVGFGAMS5apRACmeN98qmZ4IQIwJcUKZOGHqTQmXjT7FNFWVZnxh/BXJqowoVcME1TFMEFVDBNU/Qer9HzKPlIZtgAAAABJRU5ErkJggg==" alt="" />

异步管道,就是创建一个管道,管道有两个句柄,有一个句柄专门用来读,另一个句柄专门用来写。

参考:http://bbs.pediy.com/showthread.php?t=26252

  • 命名管道:

命名管道具有以下几个特征:
(1)命名管道是双向的,所以两个进程可以通过同一管道进行交互。
(2)命名管道不但可以面向字节流,还可以面向消息,所以读取进程可以读取写进程发送的不同长度的消息。
(3)多个独立的管道实例可以用一个名称来命名。例如几个客户端可以使用名称相同的管道与同一个服务器进行并发通信。
(4)命名管道可以用于网络间两个进程的通信,而其实现的过程与本地进程通信完全一致。

命名管道是通过网络来完成进程之间的通信的,命名管道依赖于底层网络接口,其中包括有 DNS 服务,TCP/IP 协议等等机制,但是其屏蔽了底层的网络协议细节,对于匿名管道而言,其只能实现在父进程和子进程之间进行通信,而对于命名管道而言,其不仅可以在本地机器上实现两个进程之间的通信,还可以跨越网络实现两个进程之间的通信。命名管道使用了 Windows 安全机制,因而命名管道的服务端可以控制哪些客户有权与其建立连接,而哪些客户端是不能够与这个命名管道建立连接的。利用命名管道机制实现不同机器上的进程之间相互进行通信时,可以将命名管道作为一种网络编程方案时,也就是看做是 Socket 就可以了,它实际上是建立了一个客户机/服务器通信体系,并在其中可靠的传输数据。命名管道的通信是以连接的方式来进行的,服务器创建一个命名管道对象,然后在此对象上等待连接请求,一旦客户连接过来,则两者都可以通过命名管道读或者写数据。          命名管道提供了两种通信模式:字节模式和消息模式。在字节模式下,数据以一个连续的字节流的形式在客户机和服务器之间流动,而在消息模式下,客户机和服务器则通过一系列的不连续的数据单位,进行数据的收发,每次在管道上发出一个消息后,它必须作为一个完整的消息读入。

CreateNamedPipe:Creates an instance of a named pipe and returns a handle for subsequent pipe operations. A named pipe server process uses this function either to create the first instance of a specific named pipe and establish its basic attributes or to create a new instance of an existing named pipe.

HANDLE WINAPI CreateNamedPipe(
_In_ LPCTSTR lpName,//命名管道的名字
_In_ DWORD dwOpenMode,//指示命名管道创建好后,它的传输方向、I/O控制以及安全模式
_In_ DWORD dwPipeMode,//指定了命名管道的读、写以及等待模式。
_In_ DWORD nMaxInstances,//最多可以接受多少个从客户机到服务器的连接
_In_ DWORD nOutBufferSize,
_In_ DWORD nInBufferSize,//nOutBufferSize和nInBufferSize分别指定了为内部输入及输出缓冲区长度保留的字节数。
_In_ DWORD nDefaultTimeOut,//客户机等待同一个命令管道建立连接的最长时间,单位毫秒
_In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes//允许应用程序为命名管道指定一个安全描述符,并决定一个子进程是否能够继承新建的句柄
);

ConnectNamedPipe:Enables a named pipe server process to wait for a client process to connect to an instance of a named pipe. A client process connects by calling either the CreateFile or CallNamedPipe function.

BOOL WINAPI ConnectNamedPipe(
_In_ HANDLE hNamedPipe,
_Inout_opt_ LPOVERLAPPED lpOverlapped//在使用FILE_FLAG_OVERLAPPED标志创建命名管道的情况下,可以使用这个参数让这个连接以异步方式工作,如果这个参数为NULL,则以锁定模式工作
);

一个命名管道客户机成功建立了与服务器的连接之后,ConnectNamedPipe的调用便会结束。随后,服务器可用WriteFile函数,向客户机自由地发送数据;或者使用ReadFile函数,从客户机那里接收数据。服务器完成了与一个客户机的通信之后,便应调用DisconnctNamedPipe函数,以关闭此次通信会话。

先用MSDN上的例子说明:https://msdn.microsoft.com/en-us/library/aa365588%28v=vs.85%29.aspx

The following example is a multithreaded pipe server. It has a main thread with a loop that creates a pipe instance and waits for a pipe client to connect. When a pipe client connects, the pipe server creates a thread to service that client and then continues to execute the loop in the main thread. It is possible for a pipe client to connect successfully to the pipe instance in the interval between calls to the CreateNamedPipe and ConnectNamedPipe functions. If this happens, ConnectNamedPipe returns zero, and GetLastError returns ERROR_PIPE_CONNECTED.

The thread created to service each pipe instance reads requests from the pipe and writes replies to the pipe until the pipe client closes its handle. When this happens, the thread flushes the pipe, disconnects, closes its pipe handle, and terminates. The main thread will run until an error occurs or the process is ended.

Multithreaded pipe server:

#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <strsafe.h> #define BUFSIZE 512 DWORD WINAPI InstanceThread(LPVOID);
VOID GetAnswerToRequest(LPTSTR, LPTSTR, LPDWORD); int _tmain(VOID)
{
BOOL fConnected = FALSE;
DWORD dwThreadId = ;
HANDLE hPipe = INVALID_HANDLE_VALUE, hThread = NULL;
LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe"); // The main loop creates an instance of the named pipe and
// then waits for a client to connect to it. When the client
// connects, a thread is created to handle communications
// with that client, and this loop is free to wait for the
// next client connect request. It is an infinite loop. for (;;)//waits for a pipe client to connect
{
_tprintf(TEXT("\nPipe Server: Main thread awaiting client connection on %s\n"), lpszPipename);
hPipe = CreateNamedPipe(
lpszPipename, // pipe name
PIPE_ACCESS_DUPLEX, // read/write access
PIPE_TYPE_MESSAGE | // message type pipe
PIPE_READMODE_MESSAGE | // message-read mode
PIPE_WAIT, // blocking mode
PIPE_UNLIMITED_INSTANCES, // max. instances
BUFSIZE, // output buffer size
BUFSIZE, // input buffer size
, // client time-out
NULL); // default security attribute if (hPipe == INVALID_HANDLE_VALUE)
{
_tprintf(TEXT("CreateNamedPipe failed, GLE=%d.\n"), GetLastError());
return -;
} // Wait for the client to connect
fConnected = ConnectNamedPipe(hPipe, NULL) ? //enables the namepipe
TRUE : (GetLastError() == ERROR_PIPE_CONNECTED); if (fConnected)
{
printf("Client connected, creating a processing thread.\n"); // Create a thread for this client.
hThread = CreateThread(//创建线程用来处理client的请求
NULL, // no security attribute
, // default stack size
InstanceThread, // thread proc
(LPVOID)hPipe, // thread parameter
, // not suspended
&dwThreadId); // returns thread ID if (hThread == NULL)
{
_tprintf(TEXT("CreateThread failed, GLE=%d.\n"), GetLastError());
return -;
}
else CloseHandle(hThread);
}
else
// The client could not connect, so close the pipe.
CloseHandle(hPipe);
} return ;
} DWORD WINAPI InstanceThread(LPVOID lpvParam)
// This routine is a thread processing function to read from and reply to a client
// via the open pipe connection passed from the main loop. Note this allows
// the main loop to continue executing, potentially creating more threads of
// of this procedure to run concurrently, depending on the number of incoming
// client connections.
{
HANDLE hHeap = GetProcessHeap();
TCHAR* pchRequest = (TCHAR*)HeapAlloc(hHeap, , BUFSIZE*sizeof(TCHAR));
TCHAR* pchReply = (TCHAR*)HeapAlloc(hHeap, , BUFSIZE*sizeof(TCHAR)); DWORD cbBytesRead = , cbReplyBytes = , cbWritten = ;
BOOL fSuccess = FALSE;
HANDLE hPipe = NULL; // Do some extra error checking since the app will keep running even if this
// thread fails. if (lpvParam == NULL)
{
printf("\nERROR - Pipe Server Failure:\n");
printf(" InstanceThread got an unexpected NULL value in lpvParam.\n");
printf(" InstanceThread exitting.\n");
if (pchReply != NULL) HeapFree(hHeap, , pchReply);
if (pchRequest != NULL) HeapFree(hHeap, , pchRequest);
return (DWORD)-;
} if (pchRequest == NULL)
{
printf("\nERROR - Pipe Server Failure:\n");
printf(" InstanceThread got an unexpected NULL heap allocation.\n");
printf(" InstanceThread exitting.\n");
if (pchReply != NULL) HeapFree(hHeap, , pchReply);
return (DWORD)-;
} if (pchReply == NULL)
{
printf("\nERROR - Pipe Server Failure:\n");
printf(" InstanceThread got an unexpected NULL heap allocation.\n");
printf(" InstanceThread exitting.\n");
if (pchRequest != NULL) HeapFree(hHeap, , pchRequest);
return (DWORD)-;
} // Print verbose messages. In production code, this should be for debugging only.
printf("InstanceThread created, receiving and processing messages.\n"); // The thread's parameter is a handle to a pipe object instance. hPipe = (HANDLE)lpvParam; // Loop until done reading
while ()
{
// Read client requests from the pipe. This simplistic code only allows messages
// up to BUFSIZE characters in length.
fSuccess = ReadFile(
hPipe, // handle to pipe
pchRequest, // buffer to receive data
BUFSIZE*sizeof(TCHAR), // size of buffer
&cbBytesRead, // number of bytes read
NULL); // not overlapped I/O if (!fSuccess || cbBytesRead == )
{
if (GetLastError() == ERROR_BROKEN_PIPE)
{
_tprintf(TEXT("InstanceThread: client disconnected.\n"), GetLastError());
}
else
{
_tprintf(TEXT("InstanceThread ReadFile failed, GLE=%d.\n"), GetLastError());
}
break;
} // Process the incoming message.
GetAnswerToRequest(pchRequest, pchReply, &cbReplyBytes); // Write the reply to the pipe.
fSuccess = WriteFile(
hPipe, // handle to pipe
pchReply, // buffer to write from
cbReplyBytes, // number of bytes to write
&cbWritten, // number of bytes written
NULL); // not overlapped I/O if (!fSuccess || cbReplyBytes != cbWritten)
{
_tprintf(TEXT("InstanceThread WriteFile failed, GLE=%d.\n"), GetLastError());
break;
}
} // Flush the pipe to allow the client to read the pipe's contents
// before disconnecting. Then disconnect the pipe, and close the
// handle to this pipe instance. FlushFileBuffers(hPipe);//调用FlushFileBuffers在断开连接之前允许客户端读取管道内容。然后断开客户端连接
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe); HeapFree(hHeap, , pchRequest);
HeapFree(hHeap, , pchReply); printf("InstanceThread exitting.\n");
return ;
} VOID GetAnswerToRequest(LPTSTR pchRequest,
LPTSTR pchReply,
LPDWORD pchBytes)
// This routine is a simple function to print the client request to the console
// and populate the reply buffer with a default data string. This is where you
// would put the actual client request processing code that runs in the context
// of an instance thread. Keep in mind the main thread will continue to wait for
// and receive other client connections while the instance thread is working.
{
_tprintf(TEXT("Client Request String:\"%s\"\n"), pchRequest); // Check the outgoing message to make sure it's not too long for the buffer.
if (FAILED(StringCchCopy(pchReply, BUFSIZE, TEXT("default answer from server"))))
{
*pchBytes = ;
pchReply[] = ;
printf("StringCchCopy failed, no outgoing message.\n");
return;
}
*pchBytes = (lstrlen(pchReply) + )*sizeof(TCHAR);
}

Named pipe client:

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h> #define BUFSIZE 512 int _tmain(int argc, TCHAR *argv[])
{
HANDLE hPipe;
LPTSTR lpvMessage = TEXT("Default message from client.");
TCHAR chBuf[BUFSIZE];
BOOL fSuccess = FALSE;
DWORD cbRead, cbToWrite, cbWritten, dwMode;
LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe"); if (argc > )
lpvMessage = argv[]; // Try to open a named pipe; wait for it, if necessary. while ()
{
hPipe = CreateFile(
lpszPipename, // pipe name
GENERIC_READ | // read and write access
GENERIC_WRITE,
, // no sharing
NULL, // default security attributes
OPEN_EXISTING, // opens existing pipe
, // default attributes
NULL); // no template file // Break if the pipe handle is valid. if (hPipe != INVALID_HANDLE_VALUE)
break; // Exit if an error other than ERROR_PIPE_BUSY occurs. if (GetLastError() != ERROR_PIPE_BUSY)
{
_tprintf(TEXT("Could not open pipe. GLE=%d\n"), GetLastError());
return -;
} // All pipe instances are busy, so wait for 20 seconds. if (!WaitNamedPipe(lpszPipename, ))
{
printf("Could not open pipe: 20 second wait timed out.");
return -;
}
} // The pipe connected; change to message-read mode. dwMode = PIPE_READMODE_MESSAGE;
fSuccess = SetNamedPipeHandleState(
hPipe, // pipe handle
&dwMode, // new pipe mode
NULL, // don't set maximum bytes
NULL); // don't set maximum time
if (!fSuccess)
{
_tprintf(TEXT("SetNamedPipeHandleState failed. GLE=%d\n"), GetLastError());
return -;
} // Send a message to the pipe server. cbToWrite = (lstrlen(lpvMessage) + )*sizeof(TCHAR);
_tprintf(TEXT("Sending %d byte message: \"%s\"\n"), cbToWrite, lpvMessage); fSuccess = WriteFile(
hPipe, // pipe handle
lpvMessage, // message
cbToWrite, // message length
&cbWritten, // bytes written
NULL); // not overlapped if (!fSuccess)
{
_tprintf(TEXT("WriteFile to pipe failed. GLE=%d\n"), GetLastError());
return -;
} printf("\nMessage sent to server, receiving reply as follows:\n"); do
{
// Read from the pipe. fSuccess = ReadFile(
hPipe, // pipe handle
chBuf, // buffer to receive reply
BUFSIZE*sizeof(TCHAR), // size of buffer
&cbRead, // number of bytes read
NULL); // not overlapped if (!fSuccess && GetLastError() != ERROR_MORE_DATA)
break; _tprintf(TEXT("\"%s\"\n"), chBuf);
} while (!fSuccess); // repeat loop if ERROR_MORE_DATA if (!fSuccess)
{
_tprintf(TEXT("ReadFile from pipe failed. GLE=%d\n"), GetLastError());
return -;
} printf("\n<End of message, press ENTER to terminate connection and exit>");
_getch(); CloseHandle(hPipe); return ;
}

举一个简单的例子来说明下:

#include <iostream>
#include <windows.h>
int main(void)
{
HANDLE hPipe;
char buffer[];
DWORD dwRead; hPipe = CreateNamedPipe(TEXT("\\\\.\\pipe\\Wang"),
PIPE_ACCESS_DUPLEX | PIPE_TYPE_BYTE | PIPE_READMODE_BYTE, // FILE_FLAG_FIRST_PIPE_INSTANCE is not needed but forces CreateNamedPipe(..) to fail if the pipe already exists...
PIPE_WAIT,
,
* ,
* ,
NMPWAIT_USE_DEFAULT_WAIT,
NULL); while (hPipe != INVALID_HANDLE_VALUE)
{
if (ConnectNamedPipe(hPipe, NULL) != FALSE) // wait for someone to connect to the pipe//没有等到client就一直返回false
{
while (ReadFile(hPipe, buffer, sizeof(buffer) - , &dwRead, NULL) != FALSE)
{
/* add terminating zero */
buffer[dwRead] = '\0'; /* do something with data in buffer */
printf("%s", buffer);
}
} DisconnectNamedPipe(hPipe);
}
system("pause");
return ;
}

运行起这个服务端,由于管道中黑没有任何数据,所以什么都读不到,是一块黑屏:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAeUAAAEVCAIAAABRwGosAAAgAElEQVR4nOy9aXAc15Woeetf22rZvb2hpHZ0dHS8eRMz8WyRBEEA3EnJEiWRIgmQALEDBEAQ+77Xvu+ZVZVZlbVk1r7vGwo7CJCUKFmOafV7ttuWN3mR1LZst909r+15f+bHzczKAkCKcvu97pkR4gtEVlZm1rknT5578y7ngNdfvzowMNTT09fe3nnzZnNDw/UrV65eunT5uee+9Nxzf/nssyzPfcZnfMZnfMa/IeA//af//eWXX2ltbbt2reHixVdOnTr99J/8+R9/8c+e+sKffv7pP/n8H3/xc3/8hc899YU/eurpP/r8/294iuZzldD7/83Fe7zY/9N/kdHPF/bB0du/uXI+4w/Lv//H4f+LgP/4H/+3v/7rv6mtPXH+/AtPf/HPnnnuS0q17sc/+fBHP/ngpx/+w08/+Ajykw8+fCJ++j+OD7j8+DH85Pfgp5AflfmAgbPzx3t5/8c/qeBHe/khzY9/+H4FP2D+/+D9H/3g/R/94Ic03+fyg/ch36P54fe+/8Pv7ud7P/zu937w3h6++4PvfPf7Zd77/nfe+/633/v+t9/7XgXf+d7ff+e7B/Dt737r29/91rffO5i/fxK+w/LNb3H59uP5BgN3+zM+4/+9fKLNVz4g3/nmt77zzb+n+VYl4G/+5n/90pf+6tlnn/v8U09rdYZ3/s+/c3jCUo1ZokYFcj1fpluSahclmgWxekGsegzzItW8SLUgVkMWJepFiWaJA1+qFUi1fKmGL9NyWZLuR7OHRUkF7K/sB4qxnzmhEjIrVNAIaGb4csg0Xz4NN5bk03z59JIMMrUkm1qUTi5IJxekk/NiyMS8eHxWBBmbFY7NCkdnBKMzgpFp/sgUf2SKPzS5NDS5NDi5ODi5ODCxMDAxPzAx3z821z8+1z82d3t0tm9kpndkundkumdo6tbgZDdkYLLzzkRn/3hH/3h731hb32hr70hr70hLz3DzraHm7qGbXYNNnQONHXcaO/pvtPdfb7t9ve12fWtfQ0tvfXPPteZbV252v97Ufbmp63Jj52s3Ol673vHq9fZXG9pfaWi7eK314rXWl662vHS1+atXml98vfnF15tfuHzzhctNFy41nX+t8fxrjedevXH21RtnX7l+9uL1sxcbzrxcf/rl+tMvXTv90rVTX7128qtXT3716skXr5548crJF6+ceIGm7oUrJy7AjdfrXni99sLrtRderzl3uebcpZpzl46fe+342deOnX312NlXj519haXqzCtVZ16pOn2R5SiHI6de3sPhky99xr85R/bxby7S/8xSP/KAfebKNWaukUOz5z4I8NGoPvta9dnXjrOcu3T83KWa85dqzl+qPX+59vzl2guXwV//9d88++xzTz39J1qdIVNcE6oQodIoUBgEMv2STAud9SLtDR/jryt9tFTLl2kFUq1QphPK9SK5Xqw0iJVGsdIgVhkkKqNETSNW7cfARaSsQKjQPxK57kAEMi1LuZ6Q0rDVCV0ZiNUQugIQqRZEqgWhcp5294o5oWJWyHXxsmm+bGpJOrUknVyUTC5KJhckkwviiXnxxLxofI525WOzwpEZwciMYGRaMDzFH57iQ1c+MLFwZ2Lhzvh8//h8//j87dG5vpGZvpGZ3uHp3qHpW4NTtwYnuwcmu+5MdPZPdPaPt/eNtfeNtfXRHpxx4oM3uwaaOu80drJOvK+hra++pe9aS++15t6rzT1Xmntev9l9mfbjXZdudF660fna9Y7XoCuvb7t4rfXla60vX2t96UrLS1daXrrS/NXXaYf+4uWbL1y+eeFy04VLTRcuNZ2/1Hj+UuP5126cfxVy/fwrN86/euPcq9fPvXr97CvXz75y/ezFhrMXG85crD/zcv3pl66dorkKOflVDtDvc4Ae/0BqL1z+jM/498lj7JZr3tDguY8A+1wwj8m10y/Xn365/gzkYsOZiw1nX2k4+0rDuVeug7/6q7/+8z//i//lmWffeudvBTK9QKbny/RLMh1s5y5K2KbrwZ4aHkB7auim5XqhXCdS6MVKo1SFyNSIXGNS6MwKnVmpNysNFpUBUxsxtRFTGfZj4aLUVwAvciByrelAZBoUIt2HRI3sRWWEwJpDpDSI9tUHfGnZ3Vc2/NWLEjXzqsG05QWKWYEC+vRpvmxqUTq1KJ2ifbpkfF48PicanxONzYlGZ4QjM4KRaf7w1NLwVLlVfmd8vn9svn9s7vboXN/IbN/wTN/wdO/wdM/QVPfgFLcx3nF7rKNvrL1vpK1vpLV3uLVnuOXWcPOtoZvdQze7Bhs7Bxo77zR23LnR0X+jo/96++2Gtr76VpprLb1XW3qvNvdcudlz5eatK03dr0Mauy43dl1q7LzU2HnpRudrNzpeu9Hx6vWOVxs6Xmlop6lvv1jfdrG+7eK1tovX2i5ebbt4tRXy8tWy94d8leX1mywvcnjhctNjuHCp8TM+498njzddrpFzjZ99Il4q0/LSlZaXr7ZC6KcJPlz1beBLX/qrz33u83KFGnN49nRKLEo4Lc3HNavLnlqkMIiVBqkKkWlQhc6s0mNqI65FrTqTzWCxGy12I+ZAcCdqdSF4BUbMuQ9HBRaI3WixGyrRm4kD0ZlotCYbDcqAWLWITYvADasWsWogRhzCrVGUBlhbMBWG1qzQmuVak0xrkmlRmRaVahCpGpGoGXevNIqVRpHCIFToBQqdQKETyHXQyy9JYVtevVDh3Ms9M1NLdGt9akEytSCZmBdPzIvHoE+fLfe3MC30pcGJxYHxhTtj83fG5vtH52+PzvWNzkLP3jsEe1qmbg3Szr17YLKzfxzScXus4/ZYe99oG6R3pLV3pLVnGDbbW7qHmruHbnYP3uwavNk12NQ10Ei332mPf6O9/0Z7//X229fbbze0Qfq4MJVBb31rb0Nrb31LX31LX31rX31LL+TaPq7e7Hk8V5q6K7l1penWlZv7eNT+A2ni1E+fkrIM7C/S2xVyvr5H4AN4RIk43/5+Eu6V8wl18mhFPUaYg8r4r5KcvtqnF+9R/Gt0+IkSXm3ueTzXmnsZeq4191xr7q1v7mUehz5IQ2svBD4+7NN0neY2+Mu//NIfPfX0u//lmwK5rtJZf6K/Vi9K1LD3QyDTCdkGtQZV6ixqI65FbXqz3Yg5UavLbKMsdjfu8FqdXpvLR1B+LjayEtcefDaXz+b0WZ1eq9OLO724gwZzeA7G7uZAwQ0LC0FZCMpCsBuU2UaZbZSpAtJkdZmsLhR3obgLqaxFmHrCzlQMsBqwalHa76uMGA30+HqLXGeS60y0l4dNfhUiVSGsi6d7e+Q6gZz273RnlEQNhwfm6F54xZxQOSNQzMJ+9iW62Q67YibmxRNz4vE50diccHRWODojHJ0RjkwLRqb5w9P8oamlIabxPjixODCxeGd8oR8yNt8/Ot8/Ond7dI52+sMzvcMzvcPTPUPTPUPTPYN0/8ytgcnugcnugYnugYmuOxNddya6+ie6+mGPzUQHbOz3j3f0j3X0j3WWP0503B7nfMvh9tjjae8bbe8bbe8dbdtHe+8o/e0nM1YJvZ9ztRG60noCHidD78Gi0gd/0pF7xa749knFO1jOJ1XUo3l0ufZq44Cvfl+xew+8fRU38Qll+yQ+lQGUhdyjpU+w576xjtvjNJUPAvsEdZahHyv4oHXfmQDPPfeXn3vq6Z9+8NGBg37Ma/5+l61eEDPOGjarVYhMjSh0ZpUB16I2g8WOWl0mgsIdXqvLZ6eCDnfI5Y1Q/qg7EPMEy7gDj4MKRCk/S4T0hUlf2OULu7xhpyf0CIL7KO907CXEEHR4gnY3AxWwUwGCChCk3+ryW11+q9NnLdcZHtzpwewezO6x2CmLnXX3JIq7ENxJgzmhc9db7HoToTcROpONde4aplGvNuLQsyv1mFKPKZieH26XjkSNSFSIWIWIlQaRQg8b70K5nh4TlmnhYMMSPR4LbxAcaFXNCVVwfHWGr5jhK6aXaEdPD6UuySYXZROLsokFCc28eHxOPDYrHmOGUsud79P84WnYY0O37lkGJhYqGF8YGF8YmFiAFcPgxOLgBHPWHiZYFgf2cYfu4qfpH1/oHyt/vDO+cIf+RXg85+CJPV/tZ+HO+MKdsQXY49Q/Ntc/Ond7dPbx9I/O9o/O9Y/N9Y/NV0hC/xBnz9hCPwfukdwSHcDEwsCeUo/R3WL9o3P9nyQhI+ccXSiunHsVwr1lj9LS4iPKNc+wr4BlsTmSj31ayefLku8Vb2lPER6nzANEWugfW7gzdpCETybkAbqtlJBj0rRh77Ftev+BT0H54yL3gKGppeHpJfDss8997qkv/PSDj/gyHV+mZ7qwdZyZG2wvdnkqCNsNAp21RGlkm9U6E4HgTjPhxhxeGxlwesOUP+YJxn3hZCCaDsUy4UQuksxHkvlwMlcmkQ0nsuFEbh/ZcCIbimdD8UwwmoYEoqlAJBkIJ/378IUTBwG/Yo9J+sNJfyTpj6RYfOGUL5zk4g0lvMG4BxKI05UHxB8lfRHSF2FrDocn6HAHGRfvs7l8Vhfj3DmtfrZdbyYoM0G35VEbiVohe7qGHAaLQ2926M12umMHtWkQqwaxaRCryggdPa7Ss44eU+gscp1ZBtGaZRqTVINKNSaJGpWoUdrj073zRpHKKFIahUqjUGEQKYxChVGgYCsA3ZJUtyTVLko1CxLNglhTnmYjUM4KFLPMiOsMZyINWwcw2/LpJdkMXzEjUMwKlLNC1ZxINSdSz4nUc6J920LV7D5mBEoGxQxb3/AV8JozAgV7wKxAOcs9cv+3ey7OHDy9JJ9i31EWJE/I1KJ0akk2vSRnJOHKUBZ1hq+YpqcbKbhHzuwRlTm4Uuzyt5xJSk8q4eSCZHJB+hg5ZyskKe+cFRxwI8q6rajyOewtAn3YFCP51KeRfGpROrUo40hevn1M+6NSqj1q5O9X6SO+3Svkk2uYIyHX0g6UkyPwbKVNMg8CffwccwyXORFENSdSgWeeee7zf/zFn374kVBhECqNQhUiVCJChUGgMAjkeoFMJ5RrhTK1QKoWSNUCiUogUQmkaoFMLZRpRDKNSK4TK3RSlV6mMih1Ji1qQ3CXhfBYXT6HJ0z6Y95wIhDLhBO5aKoQzywnc6VUYTVTXMsUWFYhaYY9H1P51VRuJZkrJbPLicxyPFOIpwuxVB4S5ZLMVZKPJsvfxlKFWLoQSxdimUI8U4xnivHM8n5imeVYphhNFSCRVD5SrlRyIbryyAZjmWAsE4im/ZGUP5L0lZ17jHkVoN8GnN5yw9/hDjrcQQcVtFP0BkEFCSpoZzYIKmAj/TYyYCP9VpfP6vLjTh/u9GEOr8XhtTi8ZsJjJjxmwm0mKBPhRm0UBLGSCE4iOGnESSPuMmBOA+YyWJwGi1MPMTv0ZofO7NCaIHYtSmgqUSOEGrGpEJvKYFUZcIWBqQO0ZqkWlapRiQqRwDa+0kC38SsRyPUCORye1QsVBpHCIFIhEjUq1ZikWrNMa5HrLHKdRa7HKtBZZDqLTGuRas00GrNEY5ZqTBCJmq1yUIkKpbc1JqnGLNWYy2fBE9UmGvr0ygPKR5okalSsQuiRBrmeHWZ4JDItXwY7rPRCpmgSdeVP0AJAUWEFiYi5R5apLBfcKB9TrmVFKqMIPo9ynUD2SUKW5dTvkVPyGG1UYJFqLTIOe8oFSyRSIaJyAVn5UW7jgLYT+kXwk8SmhdcJ5HqBwgAlF6tQidoEpaLl2WMtXDUezKO/VaFiFSKCo01yPfR4T65bUYVu95niwVZn3mO0jJLNMqY47K1n7Z8FPPPMs59/+k8++PAfxPAntWaJxixWm8QqBLa84qncO3/7jXf+9r/u4xtff/cbX3/3G7nV3dzKTm5lJxRLKbSohfDAZrU7mPBH0+FkPpouJnIr6cJadnkjt7KZX9kqrG5XssVhz8et3MpmrrSRXV7PFlczhZVUfiWVKyVzy8lskSWRKeMUngYnJc5M0SU8DU5KXNlSMldK5VZS+ZVUfiVVWE0VVtOFtUxxLVNcL7NMb6QL6+nCGjwslV9N5laSuZVEtgSJZ0vxzHIsU2R9ejiZC8WzoVgmEE0HotB3x32huCcY89C9OlE33SQPw1Z5GX+UQ4z0x0hf1OWPunxRly/q9EWc3rDTG3Z4wg5P2O4O2d0hgoIEbWTQSgYguMuPu+B/P+7yY04/5vRbnD7M6cOcfovDZ7ZDPCaCBrV5UJsbsbpRmxuxuVGbG35ErG7EShlx0oC7DJjLgDl1ZofWpO0+DL7cp4J98eW+Gi0Kmbt1GHzl9iycjaNGZBqTTGuSa81ynUVpwFVGqxq1a0x2rdmpMzt1mEuPkXqMNGAu+Ct6zKWzOHVmp9bs0JodWpNdU4kaJdQooUYIFWJTITY1QqhRQmOy03WP2aGF58LjUeZ4tOIi5YrKZNea7BqUUBmtSgOu0FnguIK0cprQAagRqRqVaUwyrVmhx5RGqwoh1PDiZofO7NSanVCGcs1ntEIqZWZkgEVDCBVi5ZZLw/lKjVhVBlyht8i15qHLAFyaeaSco1cAuDJQKadchykNuAqxqVFGVFpjB+Kk7xEXeGtMjnK56ELhSiNOb0PhOaiMVpUBVxowhc4sh696tNiP0TAiUSNSNSLTQOPBaONBCK3JoTU7dXNNADROWFw6i5N7xxlF2dRcMVBCjRIa1gbQshVxsKmMVqWBbpTItCaZGn2sDSAH6NYIb1ylblljM3P30DedMYDKr8wO1jK5xeG2qMAzzzz71Bf+9IOPfibTY3K9VW6wyvVWmQ6Tas1iNSpSGTe2dn/7u9/9y28/gd/+7nfrWzsyjcHq9Dk8YSoQ90XSoUQ+mg7yTwHu323H7urWPQ7uOzzQ77xXuZPez/wNYWvbhZXNfGkjt7yeLcJW+QoknWcppfMlSnwGnJJR+RVKfAackruLa9nienZ5PVeia4s8XStsF9fuFtd2iuscItrT4Jw4sl1Y3c6tbOVWtnIrm9nSZra0mV3ezCxvZJY3oGdPF9agN09kl+OZYixdiCRyYdhvE0sHIkl/JOkPJ+TtPNCm94bi3lDcE4x5g3Aj7gnGvaGEN5TwhZO+SJqLN5z2hdPecNobTnnDKXcoCaGCCSqYIAOGmzwAQKfYH3f54y5/zOmLiVp5oEXn9MUcvpjDG3V4o3ZvBP630/8jhDtCuMOEO2yjQlYIuRecDOFkECcDmCuAOf2YA/p6L2pDbx8Fzw/odCb75DXuzawfNWAqA7bYdxQ8P7BowFQGTG3A1EZcjVg1iFVrIvQWpwEjEasbJbwmu8/i8GPOAEYGMTKIk/hgNXOlY9MKp9/s8JnsPpPdixIsHpTwoIQboasTCrFSiA1ezWuy+0x2n8nhMzt88Fz6FKYGgkiHj4OqSWnFBT2IlTLgLr3FoTMRGsSqRnBYGz0GlQFTGXCVEdegmp4jAIBjt9V0uUwOn2K0BlRNy+w+E+FFbbSoRpwy4qQRpxCrGyU8ZZntXqaYTKGs8Bh3ueDwIjhpwJw6s12L2sauAnBlUWXAFnqPcO7CkU6RRam3KCfrAagfYeRUG3ENatOZ7HrMacSh0jy0tBylmR2+uUb2Ui1zDr/Z4bdAnH6LM2BxBiwOv2lvuUgDRhow0kCXjmIqe1jxwwOcUL1a1KZGcNVUAxSvrFLRwJcrfAMtvNpo1aA2rcmuqzQes7AVgNZ5h9/i4JqKByU4rQ140wkPVCPUM6ttxhJYG3AbcVJvcepMdtjZqDbgqsfagBLOPDbiasSqNdn1Fn3fUQBANWMJXpPdJxs5DqqmZPB3K2XYR9kY6IMJN1Mcag+ozQ0OHXr2j7/4Zx9+9DMlQqgQuwp1qBC7wmCT6WmXvb1z7++/82M1uaVxb2q9G7rAuiG89s1vfv+Xv/j4R++//6P33//FLz52ZL/myH5tfWtHrkEIMuDyRT3hVDCei6aXk/mI8DQ4JU8tb+yWNu+tbnsHeACcM8Z23txgiGlfAEO+Dc6ejbTxLABnNPn1uw/Wth+sOkd4A+Ty2nZxdauwupkvrUOvnS2uZYurkAyDW3wGnJJ74LfL6/nSRn5lk/bO63eXN3aWN3ZLG7ulrXsrW/dXtx/swTrIO63MlDZ2lzd2lzd2ltfTkrPglDxVWLtbXN8pru0U1u4W1rbzK9u50lZ2eSNdXEvlV6DLjqbykUQ2FHfP1oGaBSoQTfmJpRrQpYgkfaGEL5TwheI+dRcAXfJQ0hdJ+aPpQCwTiGeD8TxNgiGeD8bzAYi+lwd6FLGsL5rxRdEWWI11IJ5w2h1Oe0JpaTsPtBndoZQ7mKJCKSp4AGQwSQaSLn/c6Y87fXEH7dxjDm+M3mZ3+mJ2b8zuiRKeCOGO2KgQ7rLcqQKHhxAEc03XA1Av0JsIHWqbvAbA4SEBMycSTovUojadidCZ7Xqzw4C5ECtlsvssrgBOhWzuCOGJ2n1xhy/u8LvGagBoNTj9CYcvrp2uuyGLEp6ozR2xUmGcgpUHrD+CGBnEXIEyZBCnQlZ3xMYAT7S54Yn7jncpG0DNgCGIuZj9hpkj4PgdjQexUkbMCUcItKhNg8DZnAegkQx+BRy9JSN0JkJv0fUdhdXMjApK4olqp+pA9YLaHbFRYZwRwOKkHR/mCuBkyEoxMlNhGxW2QmnhYU4/XTSm4PQVHD4T4UaspBFzTtYDcI2vQ23820fB84N8I6424kt9RwFoGGPlRHANYtOaCJ3Jrrc4jDiJEh6zw1/WGxVm9BYlPFF+Cw9Uz6vhHmlH1aSd8EQJT5TwxAhvzO6N2X0xuzdGcMvlpD2m2eGzOPwWJ1QyR71Ov8XuMxEe1EYZcZfB4tCb7TpUc+swuDSDaxBGq+LBr4Cj3WJG8ukGAMBXbqt1JkJvYYyH8FgcfowMWqmwTdIBQAffQ9sJq0DmjgcxVxAngzgJWyRsMbmor4PaIYRusuBk0KKbPgKqb6tI1gzYeb0H2ACCaxCrVjr8FVDVK7cbMBdiQ/uraEtQMupVT9SC6lkVFcI5WB9HmN3GySDuCuCuAOby0zjLgEOHnn36T/78w3/4ucbs0lpILUZpzS61yaE02mR6TKI2bd+99+33PrhjzA2Ys8NEapRMTPhi77773i8//hnXX5Olt9a3duRa1O4Okf64L5IJJwvx7EpmOS4+C04rMytb99fuPtjYeXPrnn+IB87qlrfvv7V9/63t+29vZ9Fz4AV19u3t+5CS+gI4q1ve2n24uftwY+eNte0Hq1u7Kxs7JeiyVzbypY18aT2/vJ5fXstxKa55JWfBabl3eS1XWs+XNgorW8W17eX1ndLG7srWvdWt+6vbD9buvrF29831nYfrOw83dh+u7z7c2KU31qlxHhgj7r4B3ffKVk52DpxWZUtbD1a2HqxsPShtPSht3lve2C2u7xRWt7OljUxxLZlbSWSKsVQhmsyHEx7or4OxVDBKztSBmnmXP5z0hxO+cMKv7uaBLkUkFYimg7FsKJEPJQvhVDGSKkZSpUi6FE2XIulSJFOKZFYi6VI4XQobb/PAbVWqGEoWgwlLGw+06sxtPNCqy/tjeV8sJ+/kgU6TL5bzxXK+aM4XzXmjWW8056W3c95ozhPNesJZdzjjDqWpEOO+AwkykCQDSTIISbG4AklXIOkKJJy+GOG2Dh4DR0ZMJhs1ex2AeqHBYjeYCYNs+HlQ1SuDU19o9GbCYLEbMKcRcyFWymz34a6gzR21++JOf8IVTFGhjDucdUdMzTzQrM25ozkqnKXCGTKUdgVTrkASenC7L057Ctp9lLH74g5/whlIugIpVyDlCqbKJ/rjdh99CvTgkKVmHmhW0x+psA2ZOwpqBvR+M+FBrSSCO40Wh8Fs15lsOpQzT5+DDhZW7jBgTsRqvFMFjo6rho+DqimnM5B0BVPG2ZOgRmAIpmj5oeS0DBHCE4MacAaSzkDSGUg4/QknIy0UjPDA+gy6yCjhicL3IdzlN9s9Jhs10wBAvdBgtgv7q8DhISEKpV26DMDlGUZOk01nJgwWKCdpIjyY02+lQjZ3FMrg8CecgQR9f4PkeA04NkMytzvpCiZdwRQZTJOhNBnKUKEMFc5QoYyLLRfHXdooWLQo4YF1PHOz3BErGcJdAczhMxNuqGGD2S7qrwKHh4WskqXDXwFHb0kZyVGbbvYGAFW9CqcRZ5y1028lQ4Q7avfGHfIuALpEgSS814yd0DUKDaNkpjipSpKiNh5oNUD9230xGzp3FNTc0XpMNgrBXUaLA7ZFDjQDncmmMxF6+cjzoKpP6UJtlMluHjwGjo6rhqtB1aQdCqCdrgPHF7VQMF/MThtzHLZU4H13+uMOf9xBt13iTj+9v6K15IkQnjDB2LDNHQaHDj37hT/9i49+9rEOd+utHr3Vo8fdGrNLhdjlekyqMa1tbH/7vQ8EvtVBItFu8TTj9mY79u677/3y45+///7777//w1/84mPf7r3w17bWt3YUOpPDE3YHE/5YNpJeTubXsitJyVlwWp1bu/vGxu7DrXtvbz/4GjnGAxfQ1BuhIR4Y8r6z88aq9gVwzriy88Y7O2+8czdvOg9e1GTf3r7/9ta9tzZ3H67vvLG2fW91c3dlPSU7y749nRUH1wul9XxpPR9SVHS6nFb4Sus+2VlwWhlY2162D/PAsFx9gf72vDF+762te29v3QsOMl0uZ0cmzoEXVdm3N+8FB3hggHq4vvPm2o6f0yfzgjz15vrOQ2KY3TWCre8WVrc9UlamUwukuaN8yokZexpfOAlq+Vgk6Y8kLfMnykJ2oqFELkxKapkddcJwPLcazxFd7BV67E5RucDgli2SsbbzQLuxFDLe5oHTM65iMFlUdfNAFxZIFIPJIrZ0mjm6T5koBhJFZTcPdEmm6V/ulUc9U8xPNqtSVCjtDqUp9S32R5o1WXck6w5n0LmTXKUeHbNY7J65GwBcFxkxp9HiMCpGD4OqXo4H83AAACAASURBVIVDPHAMHBkVWRyG+UYAGvsGjrEXW3QFbO6wwx8XtbGl6lXEi/5EcPoEACekluSyP1H0xQveWMETzbkjnglWIzVLhkDSFTA08UBjWzcAANScOAbAsVmKCmfckaxb0wtAjyyS80RNzezl24yuQNJpWToG6hpb6gAAoFlrl3UC0CHwRO2eqF3WUS5V1ZSccJus4nI3zzWB3mzXm7XlLocjIyJOlwE4Oi63mwaPgaOThNOyVA3ATXXWE81ZFk+DOrEpmnOHsxx91o1aEk5/wjB7EtTwJ9qhlCcnbBkpvQ2OzbjoZxhbYhXH7nTIO7l3AVwXI7hTPHAMHBkRme0Gs11vFrwOwOtzdv1cIwA3pix2o3LsMDh2e+gmq8cRUxTWcIZZ9p6enCCynmhO1skDoEcWyboZPNGcJ5qXdbIK7ZPHC56od6IWVLffqgYAgBPHjgPQqoNexoUtHQMnxvGUK0iO1TAnHZ/XuMNWUtkAQP2NZgAAODoqVo4+D6p6FVBsO3R8vXK4lMFuMNsNFsEVAJ4fNKBWyqSdZO8AXSmqugHoHi+bZbc4lCKZKocMpshQmlL3ANAjjeQ80ZxH28sceaql8xSoE5tieY+2F4AeaSTrjmQodTfHEiblNgrFRVcebwnzjdxTlE7LYDU4OkHYTQvHAGhSJl2BlGHmBGO6UGb4d2LcmiZDaaTCEk6M4ykx82hUz1JkKEUGUyTXEqad0L87FZ3QX/+Hj372scHmNdi8RpvPYPVqMVKF2hUGq1Rrhv66QUe+orZcRtCruL7BoYbt6/ff/yFsXyf/Syn7rdz61o5CZ3Z4w+5QMhDPRTOlVHEjt5qSnQNnNIX1nTc37721df/tu2+8kzZ+FVwwp96MDPPAsO/ru29+fdc/xbtgTr/59Z033tnxTfLAJPnga9v3396+99bm7psbtL/OyM4CcMe1vLpZXNkIyM4CcMeyQjvrU9JovrSeL9l7eQCcVvpWNnyys+CMMrB2t+QY4QEABr3rO29sZJBzAAx6vrZ1f0V9AYALpuSDd7YfvOMa5QHwojr3ztb9r8X1L4LhwMbuW+u7D9d3i4rz4IymuL771vruW44RHhgJru08XL37hnWIBwbcxYjmFDjL968ms6VEphhN5SNJz1wdqFl0h2Jw9qGxjXdimoAzCJN+TTcPdCuiqUA0E3KJasGpeXcpll2NexUnwJlF/4ahjwd67cniRrK4mShsJgobCcsADwzo8uvx3Fo0S3TyQAe6Ek6vqG/xwAmpNbWs7uaBbiyUKoVIaU03FkqVgqng7EkAuvFgqqTq5gEAWg3LgURgug4AAFq0OW8kK23ngRo+Gkq71bcA6JaGM+5wxqPpAaBHFs2ZF04BcHKKyLrDaZeyCwBwdBzDHN65G7TLQDDd7aMAHBkVYw7x4DFwZFRscRihNTeIUCtpItCBYwAcm9F6I6I2HmhD3OGsN5pXdPFAFxZIlgIpKzTUVmMpkCz5E8u+eGCqDlTPe93hDBWiJmrBsVmSDBpv8gCo4RtDaTKURuZOglqhKZrzxvzTdeD4YsAXt7TyQIsu743m3BHTTR5oUqVc0OJbdA4f7NC3jxwHN2RRuzdi90TspvkqUDtkhA1A6TUAri66EMxptAivAHBl3i4eqAJHRkScZbRGxehhcOy2ikRtlNlhHqwGVVMOVzCFzJ8CoFceL1qWzoATUkui6IuZW2qFaDhDhTOSdh6UHJk7CQA4Pu/zxvLyTh4A4Pi81xvNofMnAegWB1MkvlQNToxbU1QoTVkF1eDEOJ6Emr8hC9vIIKafPgIAuC5BcZeEVbjFPlUPoJs2zDcCcGPa4kCUY4cBrFe8mCuw1MwDoFMInXUNHw1n3ZGceeEUqBOZ40VfnLaK4ws+byzvi+d98YK8iwe6MH9iOZAsKbt5oAv308bTIw1nqFCGUt+ixQ6lJe080I5SYfdELaiepahQmgySYzWgaoogKPV1QFeKqNWFYM6ZBvD8gI5epawYod03rWSH0aLrOwoODxpQzcQRUD2g8+FkkEDnj4G6MSxJQt/XjrojWbperxWg8HfnPe5I1h3JebW9APTKE0W/S1oDwPGlYCBZCiStbTwATkixZMmfDE6fAC26gi+Wd0eyJLZ0jLYEL20JC06jxWG0CPZbgtHiMGIOujpUk2a7F3NahqpB1QRh98b00ycA6BLTb1p8YzBFhow3a/nGUJqCWqoVoJEsOn8KAFA973FD8wCges7tDmfQ+VNQvW6boJp27ikS5x8DJ8Yw2hLAoUPPfPHP/sNHP/vYSPiMhB+x+w02rxYj1Sa7wmCVaS3QX7+mM79uMl6z6a67VDd9Uti+ZvtDvvHhN77x4Tfo9rU37Aklg/FcLLNS4a93H27efxv6a2qMB8bCO29+fefNr+/SREZ4YNjH+usX1dm3t++/tXXv4ebum+t3H6xt3VuNac+Ac5LINvTXhRV7Hw/0WmE7WuGDDe0S+3GDaV/fXbYP88CIbfvB+t03NnaLqgvgrK60lTWdAy+qc+9sP3hn+8E72zkz/Lh5/2ubGfQseEGRfri+83B9p+yvN+4FB8ptZwAAAGd1/rWU8DQAANQJA/F0MZrMlftDoik4VVzRwQPtBl844Q8nfEx/iD+axhcrh2IB6LJsJDH4IwOG4mayuJksbiawQR4Y0Oc34vn1WA7669VweiVMyWoBqOEH1d080I2HUqVQqhRKWdtZIVl/3Y0HksVAomhZOg3qRKZozhPJQDctCaUkbXtKdXLS7p2qA8fnvd5I1h1OuwLOkWpwdMxC+2v278ioGHMYLXT7mvHXjTO4C7WRJsJtEbYC0Cbwapr2/EKdxJJcDiRLwdRK0NjPAwCA24rkst8lOb5HI20I9NdNqjQVSlPhjJsQHgegRZf3OSXHwakpZ9Fn6Ntz0rFZyoUvHQN1o+aYwxu1e6N2T0Q7UQuq5zXuMOEO29G5KlAzaPBjDq+Zf3PP6c8PaA2KkecBABxvQvtrNWmyURaHeagaVE05XcG0O2Jq4QHQhWG0v172xYveqG+q/JYgQODTWCsyxfK+eMGn7wOgVx7Pe2N5DyGsBifHrWlk9uQeMZpUKVEbD7Tq7J6IjQxiTt98I8dfl/9uTEF/V+Gvj/WrKbPdi7sCNnTuGKgbw1zjNXt+oVeRKPoTRV+86HOKjwMAwKkpZ8GXwFr33K8TMksiOF0Hjs/7PLAZHkZv8kD1LEWF0WYeaNZk3YSwes/lW7R2t/oGAPVCn9nuRq0kgjmRhSYAGqcf4a8NFuEVAK4uuqTDey/WqEi4lN0AdEvDzKsAbFtEPJO1oHre643mvbG8T9/HA33KZAlbOgNOyLDUSjC1Ekyt4Pwz4IQMT68EUivY0hlQJzHHC55IlsShvw5iDq+Z3/x4S6CjYjD+2kR4LA7L4DFwdNxm90QdPn0TD4BWI8dfp8kQVX5frBWikaxp4RSoFaGRrDuccat7mKZS1kMIj4OTk0TWNHeAJYjbeKDVwPrrX0BnbSQYf023r2l/fQUzNNg1jZSi2S9pj/Dfffe9X3D6r3/323/53W//ZX1rR6E12WF/SDwXSZeShfXcSlJ6FpzR5Nfuvrmx+9bW/be3H4SGeWDI+87dN97ZeeOdnTdpqDEeGA3dfeNrd+8HYQf31u7DzZ031+++sbZ9f3VztxTVnAbnJOGt4upmobReKNn7eKAXpx20l+nC9krhx3Uv9NerW8vEEA8MW7fur919Y32nAP31ZhY9B15QZd/euv/21v2vQfetzLy9ee/tjd1lxXlwRlNYu/vm6t2CnN5+CLtH7pAPV+++ubL9RmnrfnF9N7eylSmuJXOhxZMAANCuz4bi1GwdqJl3BSJJutta3QVAlwzOElHB7YQ3nLQsnAR1IluqGEmXopnVWG4tnl9PFDaYNjUAp5TOwkbcPMADA7rcejS3Fs3a2nmgHVkJpUuhVAnnnwbgdM0JALqwYHJZ2c0D4PSMazmYWqY7SeDOLsyfKPrjBcvCKVArMkUy7lCaUncD0CUOwB49vSuQpN8owxk3bLPMud3hDBVMOX2O4WpwdNRisbu5/SFs27PcBplvBKBxGnOiOInaKLOgBYDWJbe6EYAmZZIMpmE/hiea98YKvnjRn1j2J5b9icD0CQA6Ma9TfBycnCCyVDhDhdJkKE0GU66gsYkHmlQpMkS7bGkHD3SYzAunQafFGy949X0A9MqieU8k64YnBmH7um7UHLV7IoQnYnOHbchcFagZQkI2KmQzzh4FNQM6n9nuNi3dBKBpmikRfDfXl1/YAQA3Js12g2LkMDh2W+VCrZTZbhqsBlWTdmcgRYWzbm0vAOB43WlQJzHHi5aF0wB2K4Wz6NzJCn8dzXtjBa+uD4BeWSzviebcXH9dw0dgGWER4K1p0RLusJUMcF9uKvtDGPb0h6gps92DOf1WZK4K1I1aXGM15a4kTyTnieZ98YIvXvDFCt5Ynu4bqROZ4PuKnr47gWTJnyzB9nX1vNcTybrDWSqcoQVW94BaARrOum2wILT+nf6Ewxu1u9XXob8m3Ci9Fkx4BYArcwf0hzBFaJzGnJLBanB0XE54LE4/TgZt7ojdG3MqugDoFofSsFfdre4B4JY04pmoBdXzXk8074nBurBPkViG1SeWLAWSpUCqhPFp9x1Ilvwu6XFwasqed4czLmypCtQOGQIWh8cMLcHiMMDOmYMsYcriMChGnwfH+lQuk40y0/3XuI0K2z1Rh7wLAHDseB3sD4G9T9B0jbMnQa0ACWfR+VOgVoiEM1QoQ9JtprQ7nIEKnLBl0LmToJaP0uNMqbIlcPw1bF/7jIRPb/VoLaQKsSv0ONt/fd2pavLKWoOiztjirdTsu+++9/HPGX/98cf//M//9I+/+hUcbyTcISqQ8EUy4VQxnlvLlBLis+C0Mre6/WDt7puwOwKMBrcfvL39IDjEA4Pet7cfvL394O3tHHoOTDjvvbW1+zCufQEAcEaTX9t+sLZ1b8UxwrtDFtcS4jMAnFb6Suv55TWv5CwAd0zFtWxAfgqAHgxOFLH18ACcH+KRnAWn5L7SRt42yAND2PpOafPe6naObi/vFBXnARjyr+8+XN99aB/hAfCCIvVw7e6bq3ffWHWN8s7qg1sPSptZ2TlwWpktbT0obT2wDvEAGMU27hfXd/2K8z3W7UxA0S0KxdKFSNILm9X+CDldC47POtlpfO6AY6IG3FREKX+UUnQC0CHxx6hA3GNdOg7A8QVvMFEIJbH2E1JbZkXT06/JrEYyqxHTHR7o12RWw+gdHuhXp1dCqVIoaW3jgVZ9MZAo+OMFf9wHX2ZBp9kX903XgeOLPl8s74ubW3kAdJp98O27w+SJ5twR6D74Rjg6p+gCoFPoi9nlnQCAG7Kowxd3WhaPtepdgaRh5gQc23H644S0HQB6vBEOecGoKSz08JcJjheB5+9oDZjTiIuuAQBuyJlX8g6BN+bwJ/QzJ5pUKTKI3OTdkoSzVDhLhT0TtaB6zkOF3eO1ANTwYd+fqO3EqCXh9BsaeaBRkXAG6DFGUtUNwMnqWnBTDU833eQB0I6SobQrSI7VdAn9cbtloQrUDqH0/EU47L7QxDsyasGcfkw/fQQc71e7UStpxERXAADX+DoToTNpbh2+PoHaBP3X6XEwZkyMHm9UOIyYC7Uhd2Cryhd3BlJkiH6xBbUiNJKTtvNAG0qG0rBrFdTwDcxoJALLq+4BoEcCR1mtwmpwYgxPwg6cYzMuVzDpChiaahZ1vrhd3gmYfhuTduIwoAd7K8cbGWZvAHB9wmSjnUu9CLHSDgVUz2m8Me10HQB1Y1jSFUyR6lvVs24q7JmoPTlugxVkhunZyEo6eAD0SKN5TzRvWjjdrMu7Yf/1rJupRFMujH8MnDgGhyuDTOd1zZIhkHT6E4KWumE0bCVVDQBc43tQK2nEnAazXW8ihP1V4OrS/vFGQX8VAODyLKE32w2KscMAHB4ymgiP2S5vODajpsI2aScAoGra6WRGNUCbkQymxO08Rrdw8KNXFst7HOLjADTrCp5YwROztPAAqBOb4gVPrOCO5qTtvOpZtyuQtJsWjoKaAa3XZKMQnLEE1KZDNT0HWUKPrDzybMRdiBXprwJHRsyYM4CTQRsVXoIDKdULWl9M0MoDLTqHP+GEs6FqlgzBFOyVghbuVHSxI6gkzq8GJ8bxFInzq6ElBBJOv6GpZlHnh2OtdeDQoWdg/zU92Gj16DBKbXIqjYRMZ5FoTGubd//uv35Pm47pshFDPogU/aaS9+23/4711x///Oe/+fU//uIXv4Dz+WxkwOWLesOpUDwfy66ki1HRmYq2/QD55ubuw83dh5u7fjiyBz9u7BaV58Ed8s31u2+s3X2wltSXzzujDqxuFUob+WV7b/lNrR9lZmG7xeyxp2/1nganpBQ9EVvuLq5l8QEeGLCsbhfX7i5vZOB8j5WtBysJQ/m0odEz4II08aC0dX95415x3d3HOyeJ7BTW7vrk5wEAAJwTRXYK62kxO/7X50gX15O5Fd0tRqZavjmc9AbjphnoRGvHLXTYE8NULWhWuTwhp0fdBA9u0ZD+GKXqYi53ctqRD8QLAZeYfW1t1RX8iYI/zryfdpp9MXMLDzRrs55Ixh3JMNUyAG0oRQ+20FerrgWgDaFCaXE7D7QZXYGUK5DUz5ygR649UULaAUDbIhXCyZCq/KrcseSG0zDsw2zfxLHW+ipweAgxYq6pegCu8empbwz820fB4UE+gmtmGgC4fvkqc+KRMYmVMhEes8NSfoO/qaYnFZgXqtib2ap30LM79OyADjO3THsDADjbj/BECW/M7nOOHAfg+JLOn3RALOXxmRuyqM0dgTNABo3MbDm4aEjQAqomZYTbZEP74YS8I6MiM6GTDX+FOf3SNJy8tXiJ2fPlPpXaiGsQ1a3D8JQREWborwJHRi04FbbRky4MTTxY06ScHGGqjsOpAnHddB04vqjzJx2BpFPZDUCXMJB0BqDkdSPmuJ2pOAEAANQNm+DUxtBCuS+p6Uo9ANcEOlPFfL4y0w0ANIwjuEY6/Dyoer2e1W7LgoueAbnUwlzt+KLOn3D4kw6/oZH9BVbCAGfksA1xBdOuADlWA6qmnQ52toM3JmjhAdApYOdmeHVsb9nRcSvuCmAORT0AVxfhpElCh9q0iFUjGfwKnIAoHmTVDgCAsxLL8xHLY7zV/RqvxeHHRG0AtF1nR5aPL2jhpAvLIqvwxrZuALpFwbQrmOYMrp642XYSDiS4gmlnIOlQdIHjCxp3BCfxgSrGEiz2T7QEDYJrEHXZEiz6vqPg8BBqIjxmuLzApWwAABybVVNhGzrP3oOq6lpQvaDxxrRTdeD4gsYbIzwxQtYJQAcfzq6xLFSBuhFzrNISaodNUcITsbkjS808sLi4+IU//YuP/uHnWgupsZAaC6k2OZUIIdfjUo1ZrEJW1rf/+3//v3/z61/+5h9/+Zt//OU//eY3//Sbf/ynX//qX/7b//Xbf/lv//zP//TrX//6V7/65a9+9cv1rR2Z2kivlwnG/VF6Sl+6uJFb2S6u7dBTsLfur20/4HB/bfv+6tb91a37YfUFcFYX2twtbewur+8sr90trm4VVjbzK5v0hOvCKr1AJreSzpVSuWVIEpI9gFRuJZVfTRfWMsvr2dJmDq6uXLtbWLtbWNsp0POp7xaIYR44J4rcza1u51a2sitbpts80OdIL2+ki+scNlLF9WRhLZFbTeRWYpnlSLIQimf9kZQvnPAG4+5AlPRFXN6wyxt2ekP0AnR3wI7MVIHjw0Y/QfoJ0m8j/QQVsLtDdm/Y6Ys5/XEykKACSSqUhPPtWEg49y6YghPvXPQ8sISDOx+IO6XJF7PDOdS+GOGF0HODrO6IlZ3zy7gwk93LLnqEE/jLyyUcfovTb3Z4UcJtZJaWaFF6aYlKbzlgZcFkPVxEA5fMaFE4C9hpwEl6LQO9ZIP5IWfA4mSm7pIhjAyxE2kxVxCDizUqweDxZAgnwzjFAZ7uotd3VKynYFdw4OIrAFxZoBfo60yEFsbbYsIofvJ6GXqhBKHHnEar22T3WZwBzBXCybCVghqO4FQYJ8PMNGqWsqhWqvLgivnmIbog9CoVL0q4EZzcr/zHySke/DI42i2xalFCb3EacIpeb8LOlSahAhnBuHKyQrojFVSWi75ZrlD5ZnGwOANmh89EeFErZWSEpyU3YEq9out58OVexePXJamNVjVi05rsOrPDgLmYNUf0qitL2Qz2qzeyV3jo7Krn1e6I1R3BqTBGqhsAuCb0oQRcMuPQogQdfE3/yZag1GMqA65GrBqUgBLCdWHswihW4WbusiOODVd8dFU8AuUJ+OVZ/PQMfXDo0DNPf/HPP/yHn6sQuxKxKxFCYbTKdNBZo0KF0eUOrG/t7Gfz7r3t3Qeb27vsHtITECt19Hp0X9QdTASimUiyEM+WUvm1zPJGrrSVX90urG0X1+8W1ziUF6a7enlnRaGtXIldg76eKayl8yup3EoqV0pml5OZYiJThFFE4mkmJEhFRJFcNJWLJXOxVC6WysdSTLSQbCmRLSVzq6nCaqqwniqsGft43Za1VGE9VYjwTwNwSk4W1pL51WRuNZ5diXtkdeC2LrMcTRejqWIkVYymitFUMZwshJOFUDwXiGf90YwvnPIE45Q/6vKFnZ6Qwx2wUwGC9LMhn3CnB3d4MLt7oREcGUYtBAWjf5gJt9nuwRxezOnHXQGcDFjJoJUK2dxhdvEhzi47pBcC7L1/0CAgJofPbIfbPrPTb4Zr0uw+E+EzEV6U8CKEB7F5jFa3AacMGKnHXOyaY3qBLL3+2KXDXDrMpcdcesylNTs0KKFml+3q4LJdRKpGpPtzPoxdBeDqIFywu29VMb3eurxy16mzOJnfIvUYacAfDUYyq9jhHsqAuw1Wt8HqNjIYcMqAk3qMhNcsr3HnrPFd7DsKriwqDbiSCY0Cl0p/8mJ0Fb1UWqY1yXUWpdGqRgmt2anDSD1OGnC30eoxWj2sMEbcbcTLsnHwGK0eo40D96xyWegbpDXZ1YhNxa6b13ziunlEunT7P4PD7QITjAegRggN1Dbm0pe1R9E6xCt0WBaSEQ+xQbPxMIK5OadT8O5U3hpSj5E6i5O2HLieXmdhzUaiRiSjV8CX+2aeaM03HdJAhRBqlDEbTkEO0jBEegU0T8Nt9cRhAJ4fMsFSQLFFg8fANSETlgCT68wwHOYnmgE0dakaZYIuYAo9xghpUyMEx7xdXPPej6HC5rlapYxWymilKh8BFzh06Bl2PbpMh0m1mFRrEWtMIhUqVBgFcv2cUDEyzR+ZXBiGTMzDjZGpxdHppfFZ/uS8aHpRPMeXLYiUSr3ZiLksdo/V5Xd4w2Qg5g2ngvFsOFmIpZcTsKlbXMssr5cprmcK65nCWrqwlmaidqTyK8ncSjILYzwVoWuOpvLRZD6azEWS2UgiG6FD+mXDiWw4nglxiaXhXLpgDO7JhuJZNi5gJFVgsJTnSp8QE6lCOJkPJ/OhRD4Uzwbj2UAs449m/NG0L5LyRVJwgbgnlPQEE1QwTgVipD/q9EYcVJB20E4f7vBY7DCmNmmykajVhTLhVWG8PQNnUMtgcRgsTri0xIiTCE4hVpJegsw4KXif9Bipt7i4MM6IxaE1OzRM4AKN2aExOzSoQ4M61KhdjdrpqA4IoUJsSoNVYcAVehxGX2LCzVjoeEycMEzw23JoJKVBWA48pOXvZ+gyAJf7ZFoYFImNN1QZD6gchgmG72F+Eacx4AoDrjBYFVBOFuYARcUBVoXBpjDaFAYbPL58HT0m12Pl2ECVcQo5UX6eLIgSk5SjHERJY5JqLYzAVoXRpjTalGVJGNmgeEYbe4DSaFMiNiVCqBBCSWOrwGijC6KzSLVmNi5VOeTT4+Wc6/k/wPPNc2ywJ5NUa5ExGq5U3V45KyUsy7OvXFbuDZJX3BqrQo/L9RhUe4XwUM9PEK9KwI1XpWQCZkGb0VmY3+Le+oNkmypPZvrPvWrOYVBaxrZViEhpZA37CS2hIi6V0sgxcmjbrGHjj4Fj3vsVe4CqwaFDzzDxnlCRChWpUKESgZ6aL2eT7cKstcp5oXJOoJgVKOaEShhVdUmqFci1IqVeojbKtWalHtOiNgPmNNkozOklyIDDGyb9MU8o4YukArFMKJ4NsX4zmQ+zJPJM3NQs9JXBWCYYSwfo6KmpcqzUUNwXjJcjnQbjTBztKBfKH6GBEbQDUQpGXwrG3YGYJxh3B+JUME4F4lQgxvyPwdBLLl/U5YvAQEt2DxM2jwrYyIDVFYAx8zCHx+LwwNVxqNVlxBzQBcOXVriklc5XoLco9OW8ZXtSlMno/yapxiTjRPCSaEwSjUmsRtn7IqIjoqEiFSJSIkI6FKpRUMYgUBj4cFtuEMgNfLlhSW5YkuuXZCy6RaluQaJbEGvmxZrK6KZ0gNN5Ebuf/pYOE8qXM4E9nzC2Zznm5PSe4JaCcpDMytiqmjmxZh4iqUR8EBLNgkTLofzVnFgzJ4Ko50T7g4JyyvIpomhygpTyFTMCJZT5IEkeg66M9BFIdLAscyL1nFA1w+Ye+hSBSRnl03KqoDYO1O0jxaugrGQW9r7MiStvnLis9nJI2N8nHqxsTzzYWaHq0To/yFQkBxjS3IHifXoJpxgJp5bkFUIKVKycFSZdtslH2/lBhsTuBIcOPQPjqQrkej4Dm2mXDXs/L1LOCxVzTE5xmJ9wQaRaEKuWpBqBXCtS6CUqo0yLKvQWtdEKo2CjNhKzw3wFAYc75PRGSH+Ugk4zGKMJxCg/JErRkeroYKR0LzAbjNRDxyB1UAE7TWWGGldF4Gmr02t1enCnB3d6cTY3DY0P42Sosdjp/2a720S4TTbKZCVRK4ngLgRz6jGHHnPozHYdHVULhgeyqo1WFZNegI7uxuQTYDPF8GVM5gcxwZeA9wAAIABJREFUmwBMxebtZXO0zwoZd8ZXTAsU00xY3skl2eSibHJBNrkgm1iQTtD/acbnJeNz4vE5ydiceGxePDZXZnSWRTQ6KxqZFY3MiEZmhCMzwuFp4fC0YGiaPzTFH5paGpyqDJp+cEqBxQGYeGx84c6e+O4MTxQvf29U/keEb5/iswwxMHv2HsA9bJB72NTeePB7Qu/3V2Yq+LSB6u+MLwyUkzCwMgi4ktB7ph8DvB17GZoWDLGFZWR+8sD/3JD/lXIeoLoKPT9G1EoNV3yc5B9w7ybZHBQc4T91voV5rv3AZAV7db5PNvrXDy7sfpOozAjx++ZV4AhZqfA9Opk82M73Gfxe5Q9O8YemBeDQoWc+99QXfvLBR4tSDQ2do4T11BUt69kKl61YECkXxKoliZov0whkOrHCIKUb2mxKMAeCu0xW0mSjLHYP5vDiTh+d4gu6V6ev7En3J/piU3nB3F0VibtIE9vnYHWhuBPFnQjmgFRmfXQYLQ59eUIlJ68jatOabBrEpkFsaqNVbbSqjLjKWM7zwkTaNDHv0WziLvrljk3ZNSdUzQkV5fj9i9JJmK6lIkEXnaVlaGppCOblmlzkpp+4w8mxy2bnuj061zcy1zsy2zs82zsyQ28Mz/YOzbDJunoGp28NTt8anO4uA9M20nTdmey6MwkTC3WW03cxsDmKuGmKyjs5ebkqcy89Yc6kx+bxGmvvYxMmcQWYqKRSpIpcSvsO699fCliEA7OLfapUVSOcLFB7ZN4vw8ST03nATlrySoE/XUotRs6Dc1B9SlEfldHtUcZTNps/YFawRxjJQcI8krEKe/hD5C2rtGqOYRz8QO0vwpPciHFw6NAzf/TU0z/54EMm6Zea8dGqeZESMifY66xnBfJZgRy2E+dFSiZXuoYv0wrlOrHCIFYZpWoU9pCoDDDrrg0GA9JbCMO+nLnctLmcPLkMTGJcDScxLp1Gi06TaFEy+dTZfFoViXE1CN0FwU2MqzCKFUaRgg69z+d0XTE1lhrWVbMCxSxfMU2/k9KZEsfnxWNzotFZ4ei0YAS2VScXBycWBqDDpf3sTN/wTM/QdA/0noOsx6Sfw46+MW7G25ae4ZZbQy23mHS33YNN3YNNXQNNnQNNnYONnQNNnXTq2xsdd2503NmX9HZv3ltuHnQu11r6rrX0fmKS0Apu9ly9eesqJ8npp873yk1NezA9V29+GpE+heQ9f9BMu38ogXsfDS05R+B/nZx/cK1WqvcAPVQI/6TW8pictp+gc/ouQ8oH7+ORuXr/VRIeYNiP0knP72024NChZ/7o80//5Kcf7vHR0E9x+0D2OGvWZbPdI/MiFeO41UtSrVCmEykMIqVBrDZKNYhUi8o0JrnWRDtTJuY9jYZmT/euFA7XclEZmYxWMMuJnu1/YLsgoM9lUlCyWSj3vCsw6awWZUzWWuiIJXRKcpi3cFowPMUfhs3hicWB8fn+sbnbI7O3R2b7hqd7h6dh9nHaBfePd/SNtfeNtPXRucabbw0x+cUHYHLx6+23WR96raX3aksvbUPw3jd2vd7Ydbmx8/KNztdudLx6veO1ho7XGjpebWh/tb79lfr2V+rbL0KutV281gp5+SqkBfLSFZZmlq9yeb35xcs3X7zcxPLC5aYXOB/3f8XlwqXGPzgvlGmiOeinP+HbR0GfRf/EH1Tmg+T5/YR8pOT/Wpk/WaufTo2cS106iH06/0MbySMKUiFG4+P5H2HDj9T5Xh5Riie4Oxx/TefermCfp65w1qzLY3tIZgWKOXo0UrkgVi3SOXk1tA+lh311Qg4CmRZSMc2AGYddkmhgDlmaPS8BQuW8UMlkDVfMChUzrBfmw0yyEpg4fHJBPDEvnpgXjc9V5JAdnuIPT/Fhv8QA7IsYn6fbxSMzvcPTvUPTtwanugfodnHH7fH2vrG2vlHYFm6+NXSza6Cpa6Cx804jxxfDpuuV5p7Xb3Zfbuq63Nh16Ubna9c7Xrve/kp92yv1bRevtb58rfXlqy0vQe/5evOLl2++cPnmhctNFy41nb/UeP61G+dfvXHu1evnXr1+7pXrZ19pOPtKw5mLDWcuNpx5uf40w6mXrp36f9q7z6ioz/zv49eze6MimjEZjif/DVFAeu+9d1Czxlii0ZjsJsZks4kxxIb0Ih0RsEvvKFiwo4gKYkORaszGKGJLsmn78H7wmxnAkrLlPz/u+/0638PRRIevw5zPuc71u0rgbPfAWVK5BajLf6amXEeXi1/kv1zOvhEURWmrhvP6N4R1/FPDeuS9q5pfqxJcPfTWhHhUdOKI+ZYk1f9dn7hKev424psOv6ymVJd5x6pKekobtUGqjz6L/uiz6I9WRX+0Kvqvq9Z/+On6D1au/WDl2hWfrFnxyZr3P17z/sfSbcpR7/0t6i8fDT8ie/uDlcve/2TZ+5+8tfzjpe99vOTdj6XL5Be989eFb3+48O0PFry1Yv5b789funzekuVzF787d/Ff5rzx5zlv/PnVhe/Mnr9s1vy3Zs5/K/L1pRFz3wyf+2bonEWhf1oU/OobwbMXBs5aEDBzvn/kfL+IeX5SEIfN9Q59zSv0Na+QOV6a5A2c7R4w2y1glpv/LFWe+ka6+EY6+0Y4+0Q4+YQ7+YQ7eoc7eoc7eoU5qMveK9TeK0QqO88R5REsle3osnEP+nfK2i3w/5UKGl1a74fSSgWNxU/C0/NaE5pNR5tbzrQ9Wadaf0c9+ddPn2lraR1Z51pazz3tv5w7NVxnT7aePXlaU2dGVnPLcJ1oaT1xqvW4VCelOn3s5OljzaePNZ8+2txytLnl6ImWIydajhw/deT4qcPHTx4+fvLQsZOHjp5sOtrcdLS56ciJpiMnDh45ceDw8QOHjx84dHz/oWP7m47tazq6r+lo48EjDdIFNwdUF9zs2X9Icy1ZXePBuoaDderNljV7pd09+4d394zY1FNZ21Dx5HLy6r3l1XueXFFe+njVlVbVlVY+pUoeq4p/q1THwD6jSobrv/uNfvFbq+rZf3L093rGm1P8+3v4T9Uv/xN+8e39lX/776yn/lz+hbel7hn1+17h1z4wT3/BZ7wnT7zCf/9j8Ns/or+xHsvrxM/WD9+j3nS0+fM10S8bmPxXS19ThqbqMtM3NBv+rYGp5s/80l//bfWvNPavvsL/WmmlyWe/yaYjfpQjf6CP1eg/8zs7/+0/nREtmekbmukbSWWub2SubzS6GQPT/9Rb97t+HL/3M/yf+oQ/rYcnf3bS2/Lr78yoD8Av1a/3Oep1Rn2KntLVyFf7xXdm9KfR6InSfBL+7Y/Bf+8nNfJ5Y+LICYrP1ie2nGnXNzAVAAA5eGJ9SHLUhuSo6OSo6OSWs+f1Dc203SAAQAghhtdfR21IiYpJ1eyIjYpJPX2u4xUjc203CAAQQojh/Y2fx6atjs9YE5+5JiFrdXzm6vjM1raL04yttN0gAEAIIeX1BN2v79xdk5C1NilnbfKmdSl565I3rU3e1Hr+8nQzW203CAAQQqjyetLtwaF1KXnrUgui07dGp2+LTt8anb71TEenoeXj158CALRDqdQbpzP59uC96I2FGzK3x+YUxeYWx+YUxWQXnbvUZWTjqu0GAQBCCCmvJz5/++79DZk7YnOK4zdXJBRUxedXxm+uaLvSY2zn9esvAQD4X6DJ69icovjN5YlbapO21SdurUvcUtfe2W/i6KvtBgEAQgghlEq98bqKO0P3Y3NL4vOrkrbtSd7RmLy9IXn73varA6ZOftpuEAAghBjO6wdxuSUJBdXJ2/em7NyXvKMxaXtD+9UBUyd/bTcIABBCqPP69t37sbnFmvF10vaGpG17GF8DgIxo5q9jsnfH55UnFNYkbq1P3FKXsKW2rbPPxNG3+Rm03TgA/H9Gndf3NmRuj8kuissrj8+vjM+vjNtc0Xa5x9jOi7wGAFnQrL9el1oYnbEtJnt3TE5RTHbRhqxdZy92Gdm4ktcAIAvS/savB4fWJOWuTclfl7ZlXdrWdWlb1m0slPY3ktcAIAua80M+j8tYnZC9Oil3TdKmNUm5q5NyW9svcX4IAMiF6ny+24NRMalRMWlRselRcRlRcelRMemnz13gfD4AkAvp/OtbtwdXrU9aFZ28KjpFXcktZ89z/jUAyIV0v8yt24Ofrk34dF3CyrUJK6WvaxNOtbZxvwwAyIU6r++sXBu3cs1wfbI67lRrG/c3AoBcDOf1mriVa+LVFbdyTdyp1raXDUy03SAAQAgxIq8/XRv3WJ1qPUdeA4BcPCuvV66JJa8BQEZG5HW8ppgPAQDZeTKvNY8cGV8DgIxIef317Tur1sWvWhsn1adr41auZT4EAOREndeDq9YlSKUeaDMfAgByolTqPTde5+vbg1HRSVHRiZ+tT5Dq03Xxp8606ZPXACATqvND7gx+HpPy+YakzzckRUUnfRad8Nn6hBbyGgDkQ6nUGzdB9/adu2vi0tbEpq2J3fh5TOrnMclR0cktZ9r1DdnfCADyoFTqjdeZdHtwKDopa31S5vrEjPWJ6WvjN66OTW09d34a5z0BgEwolXoTJk6+c/de7Ma82I2bYlNzN6TkRCdlRSdmtLZ1TDe21HaDAAAhhBCRK1ZP0FUMDt1PyixMyixMzChISM+PS8uLSc05e/6ioam1thsEAAghhIhcsUJn0pS79x6kbtqRkrs9JXd7cvbWxKzChIz8to4rMyzstd0gAEAIIUTkihUTJ0+5e+9B2uZd6Zt3peXtSsvblZq7IyVnW/vFTlNrJ203CAAQQqjy+oW79x5mFhRrKj1/d1rero5LXWa2LtpuEAAghBiR1xkFJZkFJZmFJZkFJRkFxWn5RR1XuizsXLXdIABACCFE5IrV0nxIRn5RRkGRenxdlC7ltb2bthsEAAghVM8bFXfvPUjL2ylNXqdtlmpnx5Uuc8bXACATkStWTNB9fnDofmrOtpScbak521Jyt6XmbkvN3d5x6ZqZjbO2GwQACCGEiFyxYvzEyYND9xOzCpOyCqWvUrVf7DS2dNB2gwAAIYR0fojOpMG79xLS8+LT8jRfE9I3t124YmRuq+0GAQBCCPV5T3fuDsWl5sSl5sSO+Hqu45IB+xsBQCak81TvDA7FJGfFJGfGJGduSM6KSc6KSc46d/7itBkW2m4QACCEUN9XcGdwKCYpMyYpc4OqMjYkZpxtv/CKkZm2GwQACCHU94HdGRyKScqIScqISczYkJgRnZgenZB+tu0C518DgFxo8jo2OSsmKTMmOXNDUsaGpIzoxPSz7Re4XwYA5GJEXmfGJmeqRtlJGTFJGeQ1AMiIKq/vDsWnZsWlZsWmZKqCOznzbPtF7kcHALmQ8nrw7lD8xpz41Oz4lOz4lOy4lKzYlKxz58lrAJANTV4nbMxJ2JgTvzE7fmN2fGpOfGp2G3kNAPKhzut7SWmbEtNyE9NyEzbmSsHd1nGJvAYAudDkdXLGpuSMTUnpmxLTchLTchI35pDXACAjqrweupeckZeckZeUvkmqxPTcdvIaAORDyuu7Q/dSs/JTszanZOalZOQlZeQlZeS1X7hMXgOAXKjz+n5aTsHGrPyNWfkpWZulOn/xCnkNAHIxIq8L03IKN2YXbMwu2Jidn5qV30FeA4B8SHk9dO9+5qYtGZu2pOcWpucWStndcYm8BgDZ0OR1Vt62zLytmZu2Zm7akpG7JT2nsONSJ3kNAHKhzusH2fk7sjdvz968PWuzKrgvXiavAUA2pPOv791/kFu4M7dwZ27BzpyCndn527M3b7905SrnPQGAXEj3y9y7/2Dz1t2bt+7O27J7U+GuTYU7cwp2XLpyjbwGALlQKvWemzDx3oOHBTtKC3aU5G8v3rytKG/r7k1bdl3q7CKvAUAupPt27z94uHV3+ZZdZYU7ywp2lOZvL87buvtyZ5e+AffLAIA8REZGjtPRffDw0fbiqm3Fldt2V2zdVV64szR/e/GVq9e5DwwA5EKp1BunM+nBw0c7S2t2llRvL67aVlSxdXf5lp2lndfIawCQDaVSb7zOpAePvtldVrurrGZnWc2OkqptRZVbd5d1XusmrwFALmxt7cbrTHr46Jviyvqiirrd5bW7VJFdcbWrh7wGALmQ5kMePvqmpKpeiuyi8tqdpdU7iivJawCQEWl9yMNH35RU7SmprC+uqCuuqNtVVrOztOra9V7WhwCAXGjyuqx6b2nVnpKqPcWVdcUVtbvLqru6e1l/DQByIe1vfPTNt+U1DeU1e8uq95RV7ymtqiupqL3e00deA4BcSOeHPPrm28q6xorahgpNalft6e7tJ68BQC6USr0/jNd59M23VfX7quobK+saK+saKmobymv29vQNcD4fAMiFdJ7qN998W7N3f82e/dX1+6rqG6vqGitrG3v6yWsAkA1VXn/7XV3Dwdq9B6TIrq7fV13X2Nt/g7wGALnQ5PWexkN7GpvqG5vqGg7WNRyo23ugf+AL5q8BQC6kvP72u+8aDhxu2H947/5De/cf2rOvqb6xqf/GTfIaAORCndf/2Nd0tPHg0caDRxoPHmk4cHjv/sMDX3xJXgOAXEh5/d13/zh4+MSBw8cPHDq+/9CxfU1H9x08euPm39nfCAByIa3n++4f3x8+dvLQ0eZDR5ubjjYfPHLi4JETN7/8ivNDAEAu9PUNpLw+cvzU4eOnDh87eejYSSm1b/6dvAYA2ZDG1//4/vtjzaePNp8+2txy5ETLkeMth4+f+vKrW+Q1AMiFOq9/ONFy5sSpM8dPnTl+svXYydZjzae/uvU1eQ0AciHl9fff/3Dy9Lnm02ebW842t5w5cerMiVOtX926TV4DgFxI5z19/8OPp8+ebznT3nKmveVM26nWtlOt527dvkNeA4BcSOep/vDDj2faOlrPdZw+d/702fOnz7a3nGn/+vagvqGZthsEAAghpLyeoPvDjz+ebb94tv3C2fYLZ9outJ7raD13/vadu68YmWu7QQCAEEJ1f6PuDz/+1HbhclvH5baOS20dl86dv3S2/eLtwbvTjS213SAAQAghhFKpN15n0o8//dRx6WrHpc7zFzvPX+xsv3Cl/cLlwbv3DEyttd0gAEAIIYRSqTdh4vM//vTzpc7rFzu7Ll7punil68LlaxcuX707dN/I3E7bDQIAhBBCKJV6OrqKn376+fK17stXVXWp8/qlzutD9x4YWzpou0EAgBBCCAelns6kKT/9/M+r1/s6r/d2Xu/t7Oq90tV7pavn3v2HZjbO2m4QACCEEGL58tkTJ0/56ed/Xuvuv9bdf/V6n1Sd1/vuP3hkbueq7QYBAEIIIfwWLZ84+YWff/5nV89AV8/ANVX1X+3uv//wkYW9m7YbBAAIIYTwW7Ro4uQp6ry+MTKyyWsAkJHli/x1Jk354cef2i5ebb94tf3i1bYLnW0XOs9d6Lxz9765LfMhACAPDko9HV3F4ND9hIyC+PSC+PT8uPT8uLT8uLT8tgudpjZO2m4QACCEUK2/njzwxd9nL3p/1hvLZy18b+aCdyMXvBu58L2Gg8eMLe213SAAQAih3t/Yf+Nm8JwlQX9aEvTqmwGzF/vPWuw/a1Ft4yEjMxttNwgAEEJI54dM0O0b+MIvcoFvxAKf8PneYfO8w173Cn29qn7/dBPODwEAeZDOU+3tv+EVOtcjeI578Bz3wFfdAma7Br5aWds4bQbn8wGAPEj3FfT0DUgx7eI/y8VvppNvpKNvREXN3leMOP8aAORBqdT7wzidnr4BF7+Zzr6RTj4RTt7hjl7hDl6hZdX13C8DAHIh5XV374CzT4STd5ijV5iDZ5i9R6idR0hZZb2+gYm2GwQACCGG87rf0TvMwTvM3jPUzjPE1iPYxi2otLLuZfIaAGRCk9cO3mEOXuqwdg8irwFAXobzenRYW7sGlpDXACAfmry29wyx91DNhFi7BVq5BpDXACAjI/I61M4zxNYtyNot0No10Mo1oKSilrwGALmQ1l9LeW3rEWLjHmTjGmTtGmDpQl4DgJxI+xu7e/vtvULtPEJs3IKt3QKtXAOtnP2LyWsAkA9NXjt4hdt5htq6B1u7Blm5BFi6+BdX1LL+GgDk4pVXpj03YWJ374CDT4SdZ5iNe7A0eW3hTF4DgJwYG5uMm6Db3Tvg6BNh7xVm6xFi4xZk5Rpg6RJAXgOAjBgbm4zT0e3uG3DynWnvHW7rEWLtHmTlGqieD+H8EACQh+G89ptp7x1h6xli7RZs5RqoGl9z3hMAyISxsck4nUndfQOOqvF1qLV7kJUbeQ0AMqNU6qnzepaDJq9dA1XPG8lrAJCJEXk9094r3NY9xMqNvAYA+dHMhzj4RNp5hkl5beESQF4DgLyonjf2Djh4R9h5hlm7B1u6BFo4B5g7kdcAICeavLb3CrfxCNUMrs2d/IrLa1jPBwByIe2Xud7bb+sRqh5c+5s7+Zk7+RWV17BfBgDkQtqPfr2n39o9ZGRYmzr4kNcAICPSeU/Xe/rU09Z+5o5+pg4+pg4+RWXkNQDIhpTXXd190jNGTVib2pPXACAn0n0FXd190jSImaMveQ0AcqRU6v1hvE5Xd6+5k5+ZZnDNfAgAyM1wXjv6mTr4mjr4Duc1zxsBQD40eW3m6PtYFZfXsF8GAORCndd9Zo5+j1VxOfsbAUA2Rjxv9H+siitq9Q3NtN0gAEAIIYS+voFmPd9jVVxR94oReQ0A8jB16kvqvA58rMhrAJCR4bx2CRxZ5oyvAUBWNHlt6RKkqRHja3NtNwgAEEJo8rqnz9I1SCrNELu4krwGANmYOvWl5yZM7Orpt3ILkcrSNViqksr6aTMstN0gAEAIIcTUqS+Nm6B7vaffxiPM2j10ZJVW7ZlubKntBgEAQggpr3V0r/cO2HlH2npF2KnL1iuirHrvdBMrbTcIABBCCDF16kvjdSZ19w44+s0eVb6zy2saDU1ttN0gAEAIIeX1xMndfTdcguaOqsC5lXX7jcxttd0gAEAIIUSAveEE3ed7+r/wCFvgEbZQXQvcQxdU7TlgbGGv7QYBAEIIIewDInUmKXoHbnpFLvaOXOw9803vyMVekYu9IhZV720ytnTQdoMAACGEEJGRqrz2mbXEZ9YSn1lLpV94z3yzpuGQiZWjthsEAAghhJg69aUn8nopeQ0AsmPu7qGjq+jtHzEfMvNN5kMAQHbczV8a9bwxXPO8cX5V/YEZFnbabhAAIIQYvZ7PNWiua/DrrkGvuwTNdQl8raJun5EZ668BQB5G75d5VV2zHVT7Zay13SAAQAgxvB+9X70TPdLOK3J4PzrnhwCATGjOe3rssCdr95BSzucDAPl48vxrVbkElVTWT+P8awCQCc39MubOAY8V94EBgIzo6xs8N16nq7vXzNHvsSour9U3JK8BQB6USr0/jNe51t1r6uA7unyKymv0DU213SAAQAghhFKppx5f+2pqOK8NTLTdIABACCGEQqGQ5q8tnAOkMnf2N3eS5kMYXwOAbCgUCvX9jSHW7lIFW7kGWboEFlfU6vO8EQBkQqFQPHYfmIPvTDvvCFvPsNKq+mkzWM8HAPKgUCik8548wxd6hC/wCFvgHjrPJeg1J/9Xy2sa2N8IAHKhUCgmTp7Sd+PLgNfeCZjzdsCct/1efct75mKPsAWV9fs57wkA5GLZsmW6z7/Yf/Or8Dc+CHvjg7CFK0LmLw987R3f2Uur9zZxnioAyMWyZcsmKZQDN2/NXPrxzCUfz1zyt/BFH4bMXx7w2js1jYeMLblvFwDkQZXXX96atfQTKbIjFv01ZP7ywNf+XNN4mPtlAEAuXnjhRWl8Hfnm3yIWfxS+6K+hC1cEvf6u/5y3axoPkdcAIBcvvPCiruLF/ptfhS/6MGzhipAF7we9/m7AnLd9Zy+tbmhiPgQA5EKT16ELVwTPey9o7l/857ztO3uJV+Siqj0Hed4IAHIxRTFFldcLVgS//m7AnHd8Zy/1jlzsEbawsv6AkbmtthsEAAghhAgICJDmr8Pe+CB43ntSXntFLnIPnc/6awCQkWXLlk2aohy4eUtaFhLw2ju+s5d4RbzhHjqvsm6fIXkNADJhZ2c3aYrewJe3IhYP57VnxBtuIa9X1O3jfnQAkAs7OztpfB2+6MPgee8FzHnbZ9abnuELXYPnVtQ2GphYabtBAIAQQtqPrnix/+ZXIQuWB879s9+rS70iF7mHzHMO+BPnPQGAjAQEBEyc/ELfjb/7z1nmM0uaCZnnHPAnB9+ZZdV7ps2w0HaDAAAhhBAKhUJnkqJ34KZn+EK3EOkk1dn23pE2HqElldyPDgCyoVAoxk+c3N13w8lfdVOBjWeolVuQhUtAcXmNviH3NwKAPGjuA7N2D7FyC7J0CbRw9jdz9DV18N5dVv3ydGNtNwgAEEKo7ttV3Y9u6uBjau9tYu9lbOc5w8ZjV2nlH6fP0HaDAAAhhBAKheIP4yZcu95jbOsxw9Zjho27kbWbkbWboZXrrpLKP04jrwFAHjR5bWTtZmjtamjlamjlYmjpYmjpQl4DgIyMyGtXQysXA0tnTZHXACAjmryeYeNuaOVqYOlsYCHltcuuksqXmb8GAJmQnjde6+41sfOcYeOuHmKr5kNYHwIAciGt5+vq6TNz9DW28zSydpXCWnreSF4DgFwoFIrxOpOu9/RbugaYOvhIQ2xDK1fyGgDkRbW/sXfA2j3E3Mlvhq2HFNZG5DUAyIpCoZig+3x334CtZ5iFs7+xrYcU1uQ1AMiLOq9v2HmFW7gEGNuR1wAgS08dXzMfAgCyM2L+OtjcyZfnjQAgU5r1IRYuAaYO3kbWbqznAwA5Uq2/7u4zc/SRJkNG7ZdhPzoAyIRmf6Oxnac0uB65H53zQwBALkadz2flYmDpPN3CycDC2cDCeVdJBXkNAHIh5fXVrh4DS1VYS2Vg4byruOKP04y03SAAQAghhEKh+D+yvnKAAAAB6klEQVTPjb/a1T3dYjisyWsAkJ0Ree30eF6XkNcAIBvDeW3uNN18OKx53ggA8jIqrzWDa2n9dSnrrwFANp6cDzGwdDa0cjWydttdVqVvYKLtBgEAQohn5LWRtZuxrUdRWbW+oam2GwQACCGelteGVi4zbNxN7L2Ky2umGZlpu0EAgBDiKXntbGjlamzrYergU1xZO93YQtsNAgCEEE/ktYGU13aeZk6+JZV1040ttd0gAEAI8XheOxtYOhtZu5rYe5k7+ZVU1huYWGm7QQCAEOIX8trZr7SKvAYA2WB8DQBjw+Pz15aq+Wtzaf7ahPlrAJCHpz9vVK0PqWN9CADIxdPW86nXX1fUTJthru0GAQBCiKfvb3RR72+s0TdifyMAyMMzzw+x4fwQAJCTp51/7cz5fAAgO08/T9XC2cDSmfOvAUBGHr+vYDi1nXeVVPwP98sAgEw8Ja/Vkb2zuOJ/XiGvAUAenp7X5k7TzclrAJAT8hoAxgbyGgDGBvIaAMYG8hoAxgbyGgDGBvIaAMYG8hoAxgbyGgDGBvIaAMYG8hoAxgbyGgDGBvIaAMYG8hoAxgbyGgDGBvIaAMYG8hoAxgbyGgDGBvIaAMYG8hoAxgbyGgDGBvIaAMYG8hoAxgbyGgDGBvIaAMaE/wtyfMOecm4LPQAAAABJRU5ErkJggg==" alt="" />

当我们运行客户端:

#include<iostream>
#include<windows.h> int main(void)
{
HANDLE hPipe;
DWORD dwWritten; hPipe = CreateFile(TEXT("\\\\.\\pipe\\Wang"),
GENERIC_READ | GENERIC_WRITE,
,
NULL,
OPEN_EXISTING,
,
NULL);
if (hPipe != INVALID_HANDLE_VALUE)
{
WriteFile(hPipe,
"Hello Pipe\n",
, // = length of string + terminating '\0' !!!
&dwWritten,
NULL); CloseHandle(hPipe);
} return ();
}

服务端从管道中读到了数据:

aaarticlea/png;base64,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" alt="" />

再运行,又读到一次数据:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAkIAAACiCAIAAAAiHjX8AAAgAElEQVR4nOy8V5Mk2XUmeOJ1x8Zsn9aG+xN2l+iqSl26qxuNVqUrta7UWusMrbUWHi7DPbSWGalVVXVXV3eTaJANEARVc4YACDQAAuQOwZ2H3YfrITKrugDO2O6MrTHtszQP9+se514/93z3iBvwB3/wv/5P/+7f6/TGz/74e14mJNPapBqLUGHYlOs3ZLp1qXZNolmTqF+DVbF6Vaxek2gQ1qWadal2owqbMp1QptuUaTflumpsyF6G9hzWpWdQ/paXgcR4GSsiFcKySMlDyGNpU4GwuKlYRAcbisVNxeKGHGFhQ76wLptfk82vyeZXJQhzq5LZZTHCzLJoZlk0vSScXhJOLW5OLWxOLWxOzG9MzG+Mz6+Pz6+Pza2Nza2Oza2OzKyMzK6MzKwMTy8PTS0NTi0OTi0OTCw8Hp/vRxib7x2d6x2Z7RmZ7R6a6Rqa7hyc6hyc6hiYbH880d4/0dY33to71tIz2tIz0tw98qhr+FHX8IPOoQcdg/fbB+61P77b1n+ntf92a9/tlt4Pmns+eNTz/qPu9x92v/ew6937ne/e73znXsc799q/fbf97Tvtb99pf+t221u3W2992PrmBy1vftBy8/3mG+8333jv0Y13H9149+H17zy49p0H1965f+2d+1e/ff/Kt+9d+fa9K2/fu/z23ctv3216607TrTtNt+403rrd+ObtxjdvN7z5YcObH9bf/LD+5of1Nz5AqLvxQd2ND2pvvF974/3aG++VUXP9vZrr79Vce7eMS1W4ePU753Dhyjv/P8DFl/DfXaT/L3v9312S/7c6+JK6VitztZIjta+eCGhqoGlSnjVoEqEJhSZX463baLo1vXUHTcArb9+78u17V7597+q376NJeu07D65/58GNdx/eePfRjfce3Xi/+eb7zWhq3/qw9a3brW/dbkMT/9t329+51/7OvQ5kFt572PX+w+73H3V/8Kjng+ae2y29t1v77rT2323rv9f++H77wIOOwQedQ8jgNHePtPSMtPSMtvaOtfWNt/dPtD+e6BiYRMaqa2i6e2imZ2S2d2S2d3Suf4w3bo/H5wcmFpDRG5paGp5eLtvDsbnV0dnV0dm1sbm10dnVsbm10dm18bn1T//oi//tDy98+YMf7uwf7xwc7+xXsHtwUsHhye7hCfy7f/8/6/TGdGFXpDaLVCah0iiUGzbkOsRh6zxJvIbGzlKXTLcp1wllOpFcL1IYxAqDRGWUqEwSlVGiNkrVJqmGh0T9MozVEKvOQKQ0fCMU+ldCKNeVUaFPGY8yy/IcKdEg8LwoVq+J1Wsi1SrPgsoVkXJZVM188sVN+cKGbGFDNr8unV+Xzq9J59ckc6uSuVXx7ArPcDPLoqkl4dSScGpROLmwObmwiRhubG5tdG5tdHZ1ZHZ1ZHZ1eHplaGppaGppcHJxcGLx8fjC4/H5/rH5vtG53pG53pHZ7qGZ7qGZriGe2ErcNt7WN9baO9rSW+a2oYddQw86hu53DN5vH7zXPnC3feBOW/9tnt76Pmzu/bC594NHPR8ghnvQ9e79zu/c7/zO/c537na8c7fjnbvt377D89zbt9veut1263brrQ9bb33Y+uaHLW9+2PLmB81vvt/85vvNN99/dPO9Rzffe3TjvYc33nt4/d2H1999eP07D3j++86Dq+/cL+EeApp4PN6+e+Xtu5er0PTWnW9C463b/4Z/w/+YeI3eVqs3UvjqKVCeF+WZgiYOmkRoQqHJhSbazfcfoan35gfNaDKiiXkLUVSZpe60v3O3HU1nNLXfvd/53oOu9x92f/Co+4NHPcgI3G7pu93ad7u1/05b/932gXvtA/fbB+93DD7oGHrYNfSoa4hnrN7R1t7Rtr6x9v5xxFiItLqGppBR6h2Z7R2Z6xud6x+bfzw+/3h8YXBicXByERm04ekVZOJGZ1dH59bG5tbG59cn5jeQMZxaFE4ubU4ubk4tbU4tCicXNycXNicXNyYWNj/74y/+929d/PIHP9w5OD6Dl8ns8AT+l//wB5989l2h3CCUGzblhg25HnlF69Kyo/NqAkMNeAJD7KUwiBR6sdIgUZlkarNcY1ZorUq9Tam3qQw2ldGuNjo0JofG5FAbX4a9GirDGaCHvBIKnfWVkGstCLKXINWYz0NtQkCEKlYZxS/R5KaswoJn3UTNulRTckxLnp9QuSxUIqpb3JQvrMsW1mULPNVJZ1clsyvi2RXxzIp4ekk0tSScWtycXNiYXKj4cKOzqyMzqyMzK8PTK0NTy0OTS0OTi4OTiwMTC/3jC9WuW8/wTM/QTPfQVNfQVOfgZOfAZMfjyfbHE239E2194y29Yy29oy09o809I809I4+6hx92DT3o5HG/Y/Bex+C99oG7bQN32x7fbe2/g9DSd7ul78OW3g9bej9s7v2gueeD5p73H/W8/7DnvYfdPB50v/ug690HXe/e73r3fte79zrfvdf5nRLKpIjw7TLutJXxdhXeut36Gtz6sOXf8G/4HxOvV91qJa9W/vKMeKeCjnfudpRnEJpQ/OR60PXug673HnSXZ9/7D3vef9SDJuaHzb1oqt5u6bvT0oem8N3W/rttj++2DdxrH7jXMXi/Y7A86x92DT3qHkYGoaVntKV3tKV3rK1vvA25Vo8nOwcmOwcnu4amuoemeoZmeobPOVgLAxMLg5OLQ5OLQ5NLQ1PLw9MrIzMrIzOryJ1CRgwZtKnFzakl4fSSaGZFjIze7KoEmcGFdSlvGDdk8+vSuTXp/JpsblUyuyqZWRF//t3v/R9vXPr+n/353iFPVzsHxzsHJzsHx7sHJ2UXDV0ChVLj8DLnInvr0iq/5HVOWIXAxEqjRGWUqc1yrUWpt6kNDo3JqbO49Fa30Y6Z7JjJ4TU7cYuLMDvPwOTAX4L3DOwImMmOGc/CYPO8EnorD53VzcNSgtmlM7t1ZnTg0pldWgSTE6GaaFVGRKIlHtXZlDqbQmeV66xynUWus8i0ZpnGLNWUWFBlkqhMYqVRpDQIlXqhUi9U6BH5bciQ56dZO8N5lfDmwgbv2y2sSRfWpHOrkrlVyQyiuuVK0LLkz22Mz62Pza6NzqyOzqyOTK8OT68MTS8jwhucQOHKhcfjPOf1j833IkVEtDc80z003YUwONU5ONU5MInWWR39E+39E239421942194619Yy28t8cTYXP3SHP3yKPu4Ufdww+7EIaqUZotgw86Bx92Dj7oGHrQMYSCnwj3X8K9toHX4y6alhU8vtv6+G7bS/im869EaxVt/ytRkaH8jfzxGTnvnBP4FfiGHlVd/a+T8Lycv+eYfPNAvUaYV/Xxv0ly/mn/evG+Cf8tY/g7JbzXPvB63G8fLGHgfvvA/fbBB+2DpekwhPCwcxChzDQIj3gMP+oaae4ebu4eRhPwLAmNtvaNtfaNt/aNt/aPt/WPI8+p/fFEx+OJzoHJzoGpLj7iN42mf9kaIOPQP86bi4GJhcEJnpyGppeHp1dGpldHq/lpYWNiYWNyYZPnp2XR9LIIrchnVyVzq5L5NenCmpQ3ZRvypU0FMnErIuWqWMXTh1SzLtVsSLUlq6hdl2rXpJpVSckkbir++Is//daF2j/58gdbO/uF7f3C9l5+ey9f3MsV93Jbu/niXm5rN1fkAV/8yfeFCv1ZDvudNFYWQieU60Vl90trUentGpNTZ3EbbJjJgVtchM1N2THa6fW5cJ+bYD0UVw03eRbEObBugnXjrAv3uXCfE/c5vTwcXubVwOgqUOjAXoaHsnsou6d8QNnclM1NWc+AtLoIq4uwOAmLkzCfJdcSfWIlvkTs6NJZeDpUmxw8EBEa7Aq9VaG38uSHHES1WaY2l5mPD5kq9EIFT3t8RFeqQanHFT7Dp1wRqZaEymWUw9vgnTwUz5xblcytSGZXxDMroull0fSSaHpJNLUonFrcnFzcnFjYmCi5euNz62Nz66OzayMIM6sj06sj0yvD0ys8F04uDU4uDU4uDkwsDkwsDozzQc7HSOPH5vrH5vpG5/pG5/pG5vpGUNhzrge5hiOzPSMzPSMzvZWPcz3Ds1VXqzA883p0D013D013D053vYTuwWn+6u/GzFnw56ueNsVz+e+B18kw+GpR+ca/q+V5sc9c/X3Fe7Wcv+9AfTO+uV/nR+MVl/5rxR585es78xJ/T9l+F/5VClAR8two/Q59HprpGZ7lcXYilGdQbwX8tEITrX90rn90vkQ58/1jpcnIZ57KJLQ4MLGIYnqDk0uDk0tDU0tD08sj08sjJYdpbG59fG59fH59fH5jYmFzYmFzclE4tSicWuSNxvSyaGZFNLsinlvhaWm+5Dah0oFloWJZqERhJ2SdVsV8fG5dqtmQIV7QCeU6oUInUhhESoNYaZTwES+zVG3mQ2WlyJlMY5ZpzDKNSaI2ipSGTZluXar94k++f+FS3Xe/92U6t53OFVPZrVR2K5kpJBDS+UQ6H0/n0QH83Y9/+so6i1Ks7GUm06xJShyGnDC1Wa4xK/U2tdGps7iNdsziIqweyun1uQgWowJeOkj4whQXof1RJlAB7X8dKH+E4soIk2yIZEMEGyJ8IZwJfgMCL6Fy0nsewRICXiaA0SVQfozyeyi/h+RcBOciOBfOuipUyjhxxoExDoyxY5QdK7MgaXESZifOw4EjzjPYMYPVY7B69FZ3mfO0JRdQY3IiwlMZHCqDQ1kKn1bHRaUas1RtlqjNEpVRrDQgV0+kMPBlOHIdSmRu8CUw6AWh2hb1ikiNSlqWNpVLm8rFDZ7/+OqVDfn8unxuXT63JuWxKpldkcwsS2ZK1SuVxN7i5uQiCnvyvmAZY3NrZzC7Nja7Nja3hvhyfG59fK501znMlbE+9hJG+fQhj5HZtZGZysfR2bVR/htR+6rGc+cuvYy10dm10Zk1FLYdmVkZmV4Znl5+PaptwRlJ+C+qOjOzNlKF6pbVPXoF5tbGzvV6ho8tj0yvjPwuCUtyrvCdqpbz/IBUv7JvGqX1b+jXagkvdbAidpXkM/9ayVcrkp8Xb+NcF143mK8QaW1kZm105lUS/n5CvmJsz0pYpdK8Yp/Tbf78K2dB5eN6dYOJhY3JRYTNyYUNtCpFk5FH+eoiyjMJURxvmk/P86G8uTXJ3LpsYV2+sCFHpmAJFbuJVMsi5YpYvSLiCamUNiqXO+g35XqhvJxnQeUOKAVjRswkU5tlGrNcw/MToqhSRsmuMjjURofa5NCanVqzU2d26SyukmFEzoBLbXKqjQ6l3q7Q2aQa8/e+/LOLtY2ffv7dUDQZjCT84QQXinHBGBuI+gIRJhBh/BXA3/34p5ty/abcUEqP6atqCMsZskpRYjmWiDhMqjKVnTC91WN24jYP7fD63KQf94UoLsoEYmwo4Y+kgtF0KJ4NJ3LhRC6UyFYQz4TimVA8+xIyoXgmGMsEY+lAJIXgjyT94YQ/lOBeAhuKvwroUrlNggsluHCCCyfLYENJNpSohi8Y9wViDII/xnMqAhch2TDJhsuE6mUCXjpQYj7WTbAuosR5VT5i2Qu0eSibh/f8LG7S4kI4F1/1Gu1eg81rsGF8dNTi1ppdWrNba3apTYj/nGpDmf8cSr1dobfJEXQ2udYq01pkWqtUY5FqLDwR8pk/k1htEqtMIpVJpDSKlSaR0iRUlnlRvyHTb8h06zLtmlS7JtFWCj6FKuTvV+pcSiWdZWosHSsWN+RLm8oloXJZqFoWqVfE6hWxZkWsWRG/dCxSL7+EJaGqBOVSmYY3leiZS0JlucGyULVc3fLlq+ceXmq8uKFYKHu0a9LfEwvrMmQFSpJUy1ARdWlTucgXviqrWy6dE7XU+KzYlatV5bK/r4Tza9L5Ndlr5Fw+I0nl5LLwFS+iMrZnVkJVON8FvtlCSfKFf43kC1V2dmlTuVT1+krLsrNSnRvGzZeH9Buunhfy9x/hKgmrNe2VclYJvHxWJ0sTgW+/UmpTjRUxQlVjsWpFpFwRKleElYrrZSF/BlWirYj4G1fF6jWxZo2vv9NtyPVChUGkNCILIFGbpWqLVGuRai0yrRVBrrPJdbwZUehtSr1diYyM0aE2OjUmlwZZIT5H46n679Jb3Hp+vc4nd4x2rJwbQhkli4uwukmbm7R7KDtW8gc8tNVNWZyE2UEYbJjO6tGYXF/+4M9rGy5/8tkf+cNxLhjzBaKMP0xxIYoNkr4A6Ss5KrQfp/3wdz/5qUhpFKlMIrVZpDKLlEah0ihUGIRyvUihE8k1QplGKNMIpWqhVC2UaYRyjUiuFcu1YoVeotTL1Aa52qjSW3UWt9lJ2D2Mi2C9TIjkor5Q3B9Nh+LZSDIfS28lssVkfidd2E3ny9hBSJVw7mMyt5PMbieyxURmK57eiqXzsVQ+mswhRKqRyJ5FLpKoXI0m89FUPprKR9P5WLoQSxdi6a2XEU1vRdOFSDKPEE7mwhWuzQZ5Ts0EoulANO2PpLhwkgsn2ArnRUuOI+874r6Km+ilA1464KUCGMUfeKiAhwpgpQMP5XeTnJv0u0nORbAugnPirBNnHV6f3euze302D2PzMDYPbfNQVg9tcVMIZhdpdpJmJ2lykiYnYXTgRgdhtONGO25AsHkNNq/e5tVZETCdxaM9C43ZozG71Wa32uhSG51KY4kadTaZziLTWNCaS4IKR5WvKBwVKgxCBaqIMYiURrHSKFabpRqLTGuV6WxynV2htyv0doXBcQZ6u1xvl+vsMp2Nh9Ym1drK80qqKTOxRaq28Mdaq0xrk2ltlbvQjRorD/72sw0qLa1SjUWiNvNZTIWhnML8Rsh1m3IU9TWISl2Tas5+BS8AEhWtG8yS6pYVnO0XOqi0qSw+xGqTGM1HhV4o/11CVuQ0nJNT+prROAO7TGeXV+Fcv1CPxGqzuNLBsvyW6jUTryd82OB3ic0LrxcqDEKlEUkuUVukGiuSipfnnLZUD+Or8c1X1RaJ2ixGmWyFAVm8339sxWfG9iVVfLXW2c4pbWmQbfJSd8qvvqz/FYLRWmU6q0xjkWnMUrUJFX5LVEY0JVF1d7lUjQ/foWCd1qLQWRU6m9JgVxudGrNba/HoLJjO6jXYeBNhdOC83Sj9NzkJk5M3LGYXaXFTFg9l89A2D2PDGDvG2L0+O8bYvYwdY2yl1bm99N+OUXaMdngZp5dx4gxa1rsJ1k1yGOnHKL+XCniZIO4L4b6Qlw56qICb9LsI1o4xVg9lcpA/+OFf1Dddff7p52wwyvgjNBsmfUGcCWC030OyHoL1ED43Au6DH//k7yXoTehsUq1NorFK1Ga0To8ls59998vPvvunL+HLz7/48vMvvszunGa3T7LbJ8FoUqmz2D0McsLoQJyLpEKJXCRViGe3U/ndzNZ+dvsgt32Y3zk6i8MqnPt4mN0+yBb3M1t7mcJOOr+dzG0ns8VEditRjpBmCvF0BbjoGlyR4ukCIboGV6REppjIFpPZ7WRuO5nbTuZ3kvmdVH43XdhNF/Yq2OIPUvm9VH4XNUvmdhLZ7UR2O54pIsQyxVh6K5oulKkulMgGY5lgNO2PpPwRRGkxNhhjAlGGD41GaN6BCyEfrgIuUoUoyUVJNkJwEYKNEGwEZ8P8C2ZCXiaE0UGMDnoohICbDLhIP4KT4JwE+s85Cc6Bcw6cs+OsA2cdOGf3sjYMgbF6eFjcjMVNm120xU2b3bTFTaOPZhdtdlEmJ2l0EkiV9TavzqrrvwB/OKRGeb5KwFNnQVh5fAG+NbyMgt0as1yL4gk2hd6uMjrVJpfGgmmtmM6G62243kEYHKTBQRodBPoWg4PQ23G9DdfZvDqbV2fFtGehsXg0Fo/G7FGb3WqzW2P2aCwerRXjKdnm1aF7UXtLqb3lzEMq/G3FdFZMa/GoTS6V0anU21HOUna2YPUV0JhlGotca5XrbEqDQ2Vyqc0eDXq4zau34TobjmSoLAhMLoSzMpdkQF0ze9RmV3W/tFWXNGaX2uhUGuwKnW3iNsCHS98o5/RdgLtjZ+VU6B0qo1NtdmssJVH5EXslcP4dVQO9Gqu30i++U06VyckfI+GroDa51EanyuhQ6m0KFBjgxX7NCPM2V65FyuPglcfs0Vm9OhuuX2kFaJmzE3o7Xv3GSwPl1lSLYfFoLB5tWQcsFS2qglttcqlKUSy5zirXWF6rA+ZXjK0JvbizY1tWNlv1Gf6llxTg7CWbt6yZ1d2pXmjqLB6t2aMxuabvAtxdUxlsqlLdmUJnVfDOk005/wDg/hQqDjfY1UaH2uTUmJxas1tnxfR23OQkzC7K4qatHp8N89m8rM3L2nEOWQwHf8A6cM6JQHAugrc2bjLgpgIeOuhBFokOesiAm/C7CbTyZp24DzGWi2DdBOshWQ/JoTQNRvu9tB9nggQTJHwhkg1TXIQOxGh/lPbHKH+M5CK4L4wxQTcVcBLcD//ir5qu3khmtxbXpXMropnFjcn5tfHZldGpxeHJhbau8Yctw2XAj3/6M7nBoTC4FEaXwuCS6x0ynU2isYjVpv3D09/+y7/8829/B377L/+yd3gi1xpdOOtlQpQ/xoZTwXgukgpsXoXqv2Hv6c7hkyrQowIYwZ+cPcmfL/1NOHaP8tsHueJ+dmsvU0A+3DZCKldGMZUrUpLrcFVO5bYpyXW4qqALu5nCXmZrL1vkSTTHk+VRYfe4sHtS2KtCWHcNbkrCR/mdo+z2YXb7MLt9kCkeZIoHma2D9NZ+emsfEV4qv4tILp7ZiqUL0VQ+HM+GUPAzmvKHE1w4wYXiim4BdBl8wZgvGGMCUV8AHcSYQMwXjPuCcTaUYMOpavhCKTaU8oVSvlDSF0rSwQQCFYhTgTjpN7YJAKBXwsUILkZwUZyNijsF0KHH2aiXjXp9Ea8vgvnC6D/G/w976LCHDnnokJsKuhDI83CSQScZcJJ+B+F34JzDiyjQZ3Fbhi/BG2N6vRWbv1/9Mh9MGx1qo2N96BK8MbZudKiNDo3RoTE5NWaX1uzSWT0GO250kGYXbfH4rBhr93IO3O8gAw4y4CSd43WlJ9UuKnHO5mWtGGvFfBZPGYzFw1g8tJlnWcrsosxu9DSfFWOtGGv1smgeWjGWv6VEzAiyyXqomZedeSBjdlFGJ2Gwe/VWj9bs0pidiKRfA7XRoTY61San1qIduAgAtcMavl9WL6ucboCaRTnGWj0+i5sX1eSkTE7S5KTMLtriYSoyY75SN0udcqE2dKXj6CFO0ujA9TZMZ3HP3AO4u642OtYGL1a9hYu9YrvKYFfNPwB4MFWSU2Nyai1uvRUzOHCTEw0aw0tbNWg2L7vSUn5Ux4qXs3k5OwLO2XG/HffbvZz1fL9Io4M0Okgj3zuqtAZC6yHUAEfDq7O4NWaneuEhEq8ypOKxPzxjG3jhNSaX1sIb3GrlsYk6ATpXvZzdW60qjMVTtQhDL93DoGFE41we7ZImlHWANjlJgx3XWzEUsdcYnerX6oAKbQ0yOTVml86KGeyGoUsAUFfSBJ8VY+VT9VCzIEffe1aGl1BRBr6xhy51hzqH0lqTMjmIhQcA9zf1Fo9w5FLVAF7qlzq1Zqd26RHAozmLqxLls3kMdq/RgZtdpNVD272sA+ecZNBNhTxMGGMimC+C+SKijrLN7RH6wl4eES8bxRG4KMHFSC5GcjGKJ54owUZwX8jLBDE6gNF+nrEoDpGWlw7gTBD3Id4KkWyI4sIUF6X9fLKJC6e4SIqLpJH1Y4IJyh/H2aiHCf/oL//myvVbPI2tSmaWhBPza2Mzq0OTiwMTiw9bhv/vqj/4yU9/pjJ71GZMbfGqzZjS6JYbeCY7OnnyZ3/+HzXkoZY+0Pn29f49Y2j3+9//q1/+4uu//eqrv/3qq1/84mtv5lNv5tO9wxOF1uwh/QQbYULJQCwbSW0lcmHRNbiqSG7tnxYPnuwc+cYEADdN0ZOP90uI6t6CCXa/6sx+ynQD4Lo2t3f8bPfo2Q4+JRgjt3aPCjuH+Z2DXHEPkVmmsJsp7CCkS6Al1+GqgkFXt/Zyxf3c9gFPWnvHW/snW/unxf3T4uGT7cOnO0fPzsE1LrimShf3T7f2T7f2T7b2UtIbcFWRzO8eF/ZOCrsn+d3j/O5RbvsoWzzMbO2nCrvJ3DZiskgyF45ngjF6uQka1ih/JMl5NhqgTxlOsME4G4yzwRir6QPoUwQTbDjJRVL+aNofywRiOR7xEmK5QCznRzAMCmBAGc2wkTQbsfCa1mNmQik6lGKCKVm3ALpMdDBJB5JUMEkFXgEykCD9CYKL4VwMZ2NenvOiXl+UPy6fZKOYL4oxEQ8T9tBhNxV0EvbRGrgwYTY7iMUHAA+EBqtHb3HP3we4MCEsbVpA+xZ0/LTBDDav0UGYXZQVY+2E30kF3XTYw0QwNuZlY16OmGkA6DTiXNzLxnSLTc3yiIeJuOmwiwo5KcSpiFYDDjLgIPwVkAEnFXTRYXcJ6EY3jW58qT2heggNY8aAgyidNy5dhPpRLWN2USYHjrKPOotba0bbLV4BrXT8W3Dpsdyjt3oMdv0Qsh61S2okCRPRLTRB3ZqGDrupkLMkgB3n+cBB+J1k0EWVZKZCbirkQtKiZjjHd63Ucf4JXtbqoc0u0uTA53nj5d4cvgRvjG+anBqTc2PoEsDDmbKcZrTo9uitmMHuNTlJi4exebnKuFGh0rhFPExks0MAdasadEbWUzOPeZiIh4l4mKjHF8V8UYyNYr6op7pfOE8kNi9r93J2HA1y1fDinB1jrR7G4qZMTsJo9xpsmN6ifXwBPlxyas2lUZWMfwsu9UtKki8+BIBvDWv0VmRzCbOLsnoYu5dzkAEXFXJLewB6NhleT8oDWHrjAQcRcJIBJ4kWauVuVkPzCBonzPxKzkkG7PrFi1A3rCbLalDeePMKHTA7tWaXTjb5LagZVGBGB2F2W0ZqeE1QlYZXM9cIdctqKuisgut1CJWPnWTASfidhBssvD8AACAASURBVN9BcDzwM7B7WZuHWW4GeCA22b2SsRq4OCmyevRWt2ikBqB53upBdRPl1JTRjpkcuMlBWNykDWMcOOciAx46jDERnI0R/gQZSFKBpLRbAA2bZmRA1P11SwQVSJSQpINJKpikg0k6mGSCKSaUZIJJJpRigknaH6O4KMGGS5V3AS8dwOmAlwkQTJDwBQlfEMWiKA5V+UWYQIwJxthQwh9NB2KZYMnu+WM5LpplIxkmlCL9ib/467+9evOtdH5nVaxG+5FmV6TTS6Lx+Y3RmbWHLcO/rPqDn/z9z7U2QmcndQ5KZyM0Vq/K5JYbHFKN9ej4yQ9/9ONRU3bMlpn0JKfJ+Bwb/eKLH/3y659V0xhZ/GTv8EShs2B0kORibDgdSuRjme30VkxyA66p0tuHT3ePn+2ffHz4hJsQwA391tHTT46efnL09MVRxnIT3tJkXhw9RShqbsEN/dbh6fOD0+f7Jx/tHj3bOTzd3j8pIibb3s8V93PFvdzWXm5rN1uNwq5PegOuKXxbu9niXq64n98+LOwebe2dFPdPtw+f7Bw+3Tl6tnv80e7xx3snz/dOnu+fPt87fb5/yh/sUbMCmPEcf4RYbfswK78J19SZ4uGz7cNn24fPiofPigdPtvZPC3sn+Z2jTHE/XdhNZLfj6UI0mY8kcqE4g2gsEE0GIuRSEzSsElwowYXibCjOafoF0KcMJ/2RVCCaCcZzwUQ+lCyEk4VwshhOFSOpYjhVDKeL4fR2OFUMpYoh07AAhtXJQjBRCMTtXQLo1Nu6BNCpz3HRHBvNKnoF0Gtlo1k2mmUjWTaS9UUyvkjWxx9nfZEsE8kwoQwdStPBFBUssZo/TvoTpD9BBhCSZRD+BOFPEGhZRLvGa+HilNXqppYfATwQGe2Y0eYxyiffgJpBebnWyIPyukY7ZnTgJgdhdlE2jHUSATcdwdgYzsWJQJIKpulQhg5b2wXQrsvSkSwVylChNBlMEYEk4U8gYsPYGG9AeataAcbGvFwc9ycIf5LwJ4lAsnIjF8NY/hZEbAgb7QJo1/AfqZDbvHIJGsYMnM3DWFyk2Ymb7F6jDdNb3XpL1f7CKuhRZxVoSWsarYFLs+rJeqhZwHF/gggkTctXoEFoDCR5+ZHkvAxhDxNFI4D7E7g/gfvjOBfHS9IiwTwMonnEHBEPE0Hes5PgbBhjdVNLDwEeiIw2TDRSAxcmRBYk7cZtgNtLJTmtbr3NY6wsvRkHzrmooJuOIBm8XBz3x/n3GyBnG6B2iSy97gQRSBCBJBlIkcEUGUxTwTQVSlPBNFHuVxWLuCnUtYiHQUuf0suiwy4y6CT8Di9r89BohI02TDxSAxcmReVBlk1+Cy49lpUkt7j1y80ANYNKPupl9TB2nHORQQ8dwXwxr6IPoE/sT6B3XdITnmh5lAa51J3kWSTEXQLoNKLxx9io27JyCRpGdYzVTZmdhMnuRUu0V6oBX7mgmHoDaoZUhMVNWTHbeC1cmlVP1kHNPIYE0C02Qf26DgnGRjFemWNoAYfeO87FvFzMyy/pYjjHnz+ziGTCHibkKelwSXsDToJbbQF4JLW4COl4LVyclqD5aBPeBbi7ym+oNfFbdXGzE7c4CYuLtHpoB84iDvP6ojgXJwNJOphmQhkmwiw0Qf2qj40i65HxRdJMOO2LpH2RDBvJoP/V4CIZLpJhwykmmKD9MT5v4gsRKGbIRw6DBBsi2RDJlTksimJRbCjBRZKBWDaUyIdTW+FUIZzcCiW3QsliILHFxfJMJPOXf/Mfr996J1c8FCpMGzLDqkS/LNYsbijn1hWzK/KHLcP/qeoPfvqzr/VO2uBiDC7G4KS1NkJtxhQGh0xr3d0/+uGPfixkd8Y98W470+7E2jHHF1/86Jdf//yrr7766qu/+cUvvmZPn4Q+Pdw7PFHqrV4mRAfiXDQTTm0lcruZ7YT0BlzTZHePP9o/fX745MXRs0/JGQHcsiQ/Ck4IYML32clHO7q34KZp++Sjz04++uw4Z30T3tZmXhw9fXH45JOD0+d7Jx/tHj3ZOTjd3kvKb5Q96BuSQGkrXFB5JnJ5TckW91j5Dbim8u8ebWGTAphUaG7xV980xZ58cvjkxeGTwHjJh74xNXcT3lZnXhw8CYwJYIx6vnfy8e4JVxXYfEuR/Hjv5LlnsnxqyrF3mt85YmRlma6ukbaeyi2Xl7CUc+0KNG46wgkunLCvXq4I2WsJxrMhUtpYOtEkCsWyO7Gsp6/8hAEMF1c6DI/d4bSrWwDdpmLQNCyAa0tEIZAoqPsF0OfwxwuBRMGxca3UekgVL/jjBVW/APqki/w3DyoizELpK9vVSSqYooMpSvO4/CXt2gwdztChtGXlSvWgXpqx2zFmpRngkdjkwE12r0k5fQFqBpVeyVgtXJwW273G1RaAlqGx2vLD1gm/mw55uZi4q9yrQWWswMUDi5cBLsvsiS0uXmBjeV80z0SydJiZK49Iw4bRnyD8xlYBtHT1AwA0XK4FqF2mqFCaDmdo7SDAgDycZSLW9vLju0yEP4HbN2qhqaWjCQCgXYfJewF6hEwEYyKYvKfSq5oFhYe2uiSVWOl9ocGGGWy6Stzu4pS4Ku4Gl2YVmHW8Fi7Ne3D7Rh1AmybDRLL29WvQJLFGsnQoUzWeTdP2OM7FjctXoGFzrhtJeWXOnZbxx1C7RPCmzbFRHrjySa+it/otwCOJ2YlLxmrh4pTYhhltmMEmvANwZwUzrLQANC/YMZNq5gLUDk+0lcdxyhpBxG9cLr/TK3OeDBPJynsFAAPycIYugYlkmUhO3lse0CFFLM9EfHONUNf9uA4A4HJtPUCnHhlfwrFRC5dnnUkiQM40lG6qX9XSIRepegjwoLkdAODStEQ1/QbUDCqR2Bjig0EF2oKJGW2Y0S68C/DGuNHioqy6+fIb4NcK6n6A/tmKWvZLgkmyxMRkIEkGU5RmAGBAFs4ykSyjGyy1vNrRexWaJNZojtENAgzIwhk6nKY0/VWaMK9wUxan+O7rNWG1pfoWFW4fr4NLcx7MulYL0KpKEP6kcelySXWRzOjv8qwrRQZT5jOacHnWmZSUpkbdMkUGk2QgSVZrwiKOaA9XntWEZrnNTckn6+DSjNSBmx1es0N0F+DuGm5aawVoWXLiZvXMBagdmWgt3VM3buTcVBBjIobFsi26sujNcbG8sk9QMhp5fyzPxXIIyoo9GlTFcv4Yu9QEDb0DDQAAV+obAbpNTCBO+6OUfbUOGmdtIcLnmqkva8KKmQtTnLZdAO1dPQAADeu2UIILJwPRdCiRj6S3opntaGYnmtmJZHYimd1wejuY2ubiW3/11X+68dZ3ivtP5Aa3ROsQqewbCuu63LIiMS6LDd2PZ87kxn76s6+Nbp/R7TO5WaPLp3OQagumNLpkOhuisYd68j2N/bbZcs9peOjVIG/sq6/+BnljiT8pZn6Q3Ts8UeptXl+IDib8sWwkXUwW9rM7SflNuK7N7518fPDkk8OnL44/+ixl+jbcsiU/Dk8KYJL9/PTjz0+5BcEtW+rjz08++uyEnRfAPPns06OnL46efHJw+vE+T2Np+Q2AUWJr56Cwve+X3wAYtW/zHHZVFskV93JFbFAAcE3Fbu+z8htwXeXfPS56pwQAMO7bO/loP22+CTDOfHr4dFtzC+CWNfHss6NnnxHTAoC3NdnPDp9+GjO8DZP+/dNP9k6f750WlG/CdW1h7/STvdNPvFMCmArsnjzfOf7INSGAMboQ1l6FG5vcTiJTjKcLkWQunGBWmqBhnQ5G0fYAU5fg8qIHlfgnOG2/APqVkaQ/kg4S4ka4ukoXo5mdmE95Ga6vc/vGIQEMYonCfqJwEM8fxPP7cfuYAMb0ub1YdjeS8fQKoMeyHUptax4L4LLMldzS9Aug3xFMFoOkrKHfEUwWA8nA8hWAfmcgWVT3CwCg07jlj/sXmwAAOnRZXzgj6xZAw6YlmKI1jwH6ZaE0HUoz2gGAAXkka1u7CnBlwZOhQylC1QcAl2YdDq9vpZm3pGaHfvgSwMVpicMr4ZeEXhOa5A/FFhdp9VjGagFql3S+sLhLAF1mOpTxRXLKPgH0OfyJoj/pQvO301T0J4pcfIuN+ReaoG7VR4fSVJCaa4TaZZIMmNoEAA2bpmCKDKbMK1egUWSNZH1RbrEJ6tf9bMzeKYAOfc4XydJha5sAWtVJAhmCDr2XRclCbKoemuURzBfGmDBmXa2BxgkTchdk9wHurRNmB26yi9B6VjJWAxenxFU/FmNSTl+A2mE1aXFTNq9tvA5qFrxEIGlevQowqIgV7BvX4bLMHi+wUVtHo8gSSlOhNArUmJDYAPWrrC+aU/QKAKB+1eeLZC2rVwD6JYEk6dyog8uzriQVTFEuYR1cnnUm0Mg3y0NuMuAwLF4EgEdSi7O8Bvea7NjCA0DsZVxtAWhetHvNqpkLgOjW5yD8G+0CgF4R4rCGTUsoQ4eztrWr0CS2xQpsjNeK+jXWF82xsRwbyyv6BNDn4OJb/kRR1S+APifHK8+ALJSmgmlK85gXO5iSdgug20KF6LlGqFumqGCKDJAzDVCz4PFQmkfArxUsLsLswJcewhtjev63eJRTPKvxg+w12fVDl+DCuNGinbsIdWN61kkGPJbVWmiacSRIRAndFjqc4Zc7jUIL+t5Vhg5n6HDWpxsEGFTECxwhawCo3wj4E0V/wtUlALgscySKXCKweBk69Hk2mqPDGdKxUctrgo/XhDXcZPea7MKXNcFk95ocXn6VoCFtmM+B2yfqoGbOg/mihsXLAH0S3i/fNAWSZNDU1rhpCqYoNEqNQks4Y1m9CgB1qwyN1AOgboWmQ2nL6lU0vLRbWMdzXpJ0btbC5RkHrwmtqjjORTHrSg0AtCjsGK2YrINLszInP7Y8e61X0xjApRm5m7J5qNUWAOjcoIK6hUaoXzcFknQobVu9Ck1ieyzvj/uXLwMANGz4/YjM4nkVmq3xvD9eUPUJoNeGaAxgQBXNctEMpx0A6JMFYhQXkXQKoEND+Nwz9VC74CJ8QZJ1z9ZD3aKH4rRtAoCGVWsgyrti4WQglgkl87HMdjy3G8vtxXN7sdxeLL8fze6F0jv+ZPGv//bv3nn/zs7BU4ODVVtIpYmQ6b0SHSbSuDdVrk2VY0PpWJPbVuW2FakVfvqzr00e1uThzBhndPt0DlJjxZRGl1xnRzT2gd52x2q679Y/ItRtrAx5Y+Wg4pc/+fLLn3zJe2O+EBNMBGLZaHr7DI2dPj94+gLRGDUjgJnQycefn3z8+SmP8JQAJtkyjb2tybw4evrJ4ZPnB6cf7x0/2z18shPVXYeb0vARorH8NjYkgEEX8rqULHLLiuWP+yVv7HgLmxTAlPvo2d7xR/unBfUtuKEvHmasN+FtTfazo2efHT377ChrQx8Pnn56kLbcgLeUqed7J8/3Tio0tv8kMFbxtAAA4Iae202KrgEANIn8sVQhkshWgoqRJNripuwRQLeRDcW5UJwtBRW5SMq5frb6BaDPvp9woC8ZMxYOEoWDROEg7hgXwJghtx/L7UWziMZ2QqntECVvBGjYDGj6BdDvDCaLwWQxmHR1l4Us01i/058o+OMF+8Y1aBJbI1kmnEbsJQ0mpV3nenVlHvOhCIMvnKFDKcKPT9XBpRk7T2Plv4vTEofXZOe9sRKNtSw5CYubtHpou6gToEvo07ae+4YmqT2x5U8UA8ntgGlEAAAwrExscYS0/mxD6DIjGmtVp6hgigqlaY+oHqBDn2NxaT1cXcALrHHo3E21yxTh3KiFpmlb1OuLYL4IxoR1c41Qt6qlQx46hFlWaqBh3Mg5vD7bZtu5298Y0xmVU28AQJWR5WlMQ1rdlN1rm6iDmgWcCKTosLVDANDncPA0tsXGCr4Iu1DxKYVmZKQaxdZojo3lWcMQwKAilvNFc4xHVAdXZl0p8/KVc2K0qpPiLgF06jEm7CYDDpzlQ0mIxip/zQuIBs7QWO2IhrJhPifhd1tWaqFpxkHMNpz7hkFlvMDFC2yswOKSegCAqwt4no07Os+9r8tyezyw2AT1qyyDnLaQpU0AdcsUFbK0C6Bdm6E9orpzj+/QYbSmGeCBiLVhtMVFmh24ea0VoGXxG2jMaBfdBbi3Tsgmzz+sRRknVP0A/bJQyXFES64wM98Idas+XyTni+ZYw5AAhlSJomPjOlyWO5LbgeR2ILnt3LwOl+XO1LY/ue3YuA5NUlssz4QzpBPRWMDh9dk221+vCfxP4pVozOph7F77eC1cmnVjTMTLGloFAJ2mKhpLkUGqEl1oFFnCGevaVWgUW8IZOpSmNQOlFWSG8Yjq4cq8J2NdeYUmSLoE0Gkk/AmCi3l94Y02QYXGqgZpyYGbHedorHZYTVjdpNVN2nRzl6B+wuR8aXQHFNEcFy/4E1sBUtYAAHB1Cc9zMdt529AkdsR8i01Qv8qgogw2ZOoQQN2Sl2S1rQCt8iBuXa499/gODclq2wTQpgyjxBhPY9FMKFmIZbYRgcXz+7H8fjx/EM3uh9O7geT2X//t391r7tg5eIr5kmZ3yODy6x1+rY1VW30qM6000XIjKdXjUgMp1nrhpz/7BeIwk6dEY7w3xtPYXYfxIaZtoZTtnLQ7vPnFFz/6RVVu7F9++8//8tt/3js8UeqsGAoqxrLhVDGR38tuJ2Q34Lo2t3v88f7pJ4dPXxw9C04KYML32fFHn5189NnJxzyoGQFMB48/+vT4aQAlzw5Pnx+cfLx3/NHu0dOdg9NiRHsNbkpDh4Wdg3xxL1/EhgQw6OR5y1dKj/lk6OOeD9HYzuGWZ0IAk67Dp7vHH+2d5BGNHWQsN+EtdebF4dMXh08/RaymSr84ePJi/3RL+SZc1+Z3jz/eOc4r+OPnKMY4Sj7fOf54++ij4uHTwt5pdvswXdhNZIPrVwAAug2ZYIxaboKGVcIfTvApMU0fQJ8c1Suq0XHcF0rY165Ak9idLIRTxUh6J5rdRe+y5IEBXFXh+f2YbUwAY/rsXiS7G8m4uwXQbd4OporBZNG5eQ3gWsNlgD5HILGl6hcAXFsitgLJLT7SiE72Obh4gYvl7WtXoVFsDafpYIrS9AP0SfwoW2BAmV4SUQVa4a7QdChNBZI4652sg0vTdjtGVwcVy55KZcW62gLQsujALU7S4qZswg6Azg1a0wLQqkqQgRQKBjKRnC+aZ2MFLr7Fxbe4uH/xMkCvw4dL6uHKnCdDhdJUMEUGU2QgSQRMrQJoVSfJIM9ksh4B9Fhta9eg1+6L5X2GIYBBeSTHhDM0ujGAvLGmaVsEY8IeJuymQ27zSg00TJiDbiroNi1fgoYxPWvDaOtGG0DrYqlHKMBlqES9AKB53oYZlVPIIlhclA2zjtdBzTyG+5NUKEPrBgGgvukaNEltsYJ97Rqg2GwoY1m5cobGIjlfNO/TDwEMyqM5JpKlq2msYdOM+oi6gF5Nh85Dh1ykv9oVPhtULOFcUFFD8fl880oNNE3biZmGSjyWCWeZSI6N5dlYno3mfdEcH2BsEluRd2vg344/UeQSReSN1a36mHCGDmWoUJoXWDMAjUJLKEO7UUf48ce5uNcXwWjNI0RjHtrCb+0X3QW4u/KKoGKpCy2LDlw6XgeXZhUexo5zTjLgpsOYL4or+wD6JcEUytjRmgGAx7IwM9cIdas+JpJjomiJMKSMb6FVhSNR9CeK/mTRscmzmj9R5AhZPVxdwHJ0KE04NmqgccLot3sZG9IEu9eIIpyv0oQFu9eonH4DaofUhNVN2fjcmNNNhTAm4lX0AUBtfRMKKqIQLlJd0/IVaBSaQxnL6lVoFJlDaSqYJvmlZIoOpdEAzrnTlpUr0Lhp4XPYyYomdBoJfwLnYhgTOkNjl2YkKMiP4PCa1tAwek2q6QtQM6wu5ca0cxehbtyAPEg3zsYILkEFU3QozYQzbCTHxfJcPM/F8opeATSJbRFrJ8rBx3JcLIfy7myEWWyE+hWKCSWZYIIOxM1LTVC/apB3Q92Sng54zUs10DBt9qNCD/Q7SoRP0wrQqgiRXJj2R5kAyo2lg4l8JL0dze7Ecnux7F40uxfN7oczu8HUDpfY+u6Xf760IVlY2dg5ekEG8w4qYcWjZixi8oQN7pDOGdQ6/Bo7p7ayKquv7I2xJg9rcDE6O6k2Y0qDs5wbe4SrW33yzoC4N7r+OLn8xRc/+vrnJRr7+ut/+qd//Idf/QqVeHjoIOWPs+F0KFmIZXfTxbjkBlxTZXeOnu0ef4xiejAdOHr24uhZYEIA474XR89eHD17cZS13IQ5/Mknh6fPY7q3AOC6Nrd79Gz38Mm2d0owShZ245LrANdUbHEvt7Xrk94AGLUWdjN+xVWAAQcqWXQPCABVKjLSG3BVwRb3c+5xAUw49k6KB092jrK8d3VSUL4JMMHtnT7fO32OTQkA3lImn+8ef7xz/NEOMS24YQgcPiseZOQ34ZoqUzx8Vjx85poQAEw79p8W9k455ZsDrqO0X9kvDkZT+XDCh5wwLkwuNkL9Ml6us6f93rkGaFNGKC5CKXsBeqRclPLHGNdGPUD9mi8QzwcTju7LMnd6Wzswok3vhNM7YeuoAEa06Z2QZVQAI5rUdjBZDCZcXQLoNBT88TwXy3MxFkWEoNfGxtjFJqhfZ9lojo3ZOgUAvTYWhbB6rEwkS4eRVd00oYIIZR9Ar4iNYopeAGiWR7xsDLev13YaCH/CuHQZpdNxLuaRdQPwJR6oygD9kmQZfMWBFaXo4Y1RndGBm5zi+wDQrCjFtXqEvqiXixuWLreqk2TA3CZ4LA1lqFCGCjFzjVC3wlAherYRoGET5RXEXZen7XGcM7YIoEUZx/18WQep7ge4UtcIbRp0u7VNANBtIYMpIkDONPSJuBhmX6uBxgkLv8EAFYCttQouTtsdOOcwLF6E+hENbXGRJof4LgDc39RbPXqr9vGFR3MWt3DkEV96UCpD4Es8lF6Tg7C4zaNoDc7GcH+SDPLRIWgUW8JZWbcAuixkMIXSNtCwaSwVgJhRfzUDAANSVNjiEtXB5RlnAkVBa5cIIpAg/MbWhnU9G8MUvVAKflp1cxeAr685W+JRwnIzwKM5q5u3uQ/EZhdvZ6FuReuL6habAJpmHAkikCQ1j+uWaSrEzDVemXWjdUO6FB7MSHsEAAOySI6J5Kxr19r1ORrlxpbp0toiSTg2a+FyLaoQCZQSYw0bRn8C5+LCjqZJS8hFqh8C3N9kLC7S5MCNNsxg9YhGauDexsslHsKRGgC4vewx2DCjcuYCwIUJk9XD2DDFw9olDRVyy3oBoGYRx0sZU+gykYGkpFtQGluUWB2UR3OMV1IP0K7PM9E8E7V3CACaJNZYnonm6UhW1i2oW6YJfwKzrl2ChjGdz+qmzM6SJljceot24FWaMCCvFPuYnITZZR6pgYtTNgfud5IBNxXaQEnaujUdGxV2CqBD7+XiOKrLbdgwBpIotIs0HFf2lYtWSOdmHVyedSZJ52Yd0gR/HOeMrQ3reg6VtzRN22IYE3Gbly8BQLPM6qZkE7VwcVpswwxWj7Fco7jcDNA8b/MYFJNvAMADodGBmVAW4NKs3MOopusBGibMQQ8TwRV9tUsEGSDnGi/PuTNomSLrFkC3mQ6iDO6APJxhQmnLypV2dZIOknMNULeEk/4YgartrSs10FBTC5dm7G6CdRP2yVqA2gUNwbpJdrOtYcrsxyhVC0CLLIAzQZINmxeboGHdGkqoegXQ5wingqtXoHEzGEq7ewTQZd7m4ltMJJfZOf7ok89vvfP+xMzCzsHJJ3/8/acvvvfkky9On39x8vy7xx//8dGzPzp69kdHTz8/fPo5/PRnX/P1HS5G76A0Vlxl8sj1dqnWuntw/L0//UtdKqrPhI25gLnAWYu+Fy++V6axr3/+89/8+h9+8YtfoIJ7N+kn2IgvlAzGctHMdqoQEV8/41+OkR8fnD4/OH1+cMqhYgr0cf+0oHoTRsmP944/2j1+tpswVO67rvHvHOaL+7ktbLDi5I5YSrvHaEm57bXHg9fgqoziN5Ap6MJuxjkmgDH7zlFh93hrP40qD7cPn23HjZXbJqavwy1Z/Fnx8OnW/pPCHj0kuCkNn+R3j1nFmwAAcFMcPsnvpSTlkoshb6qwl8hu6x+XZGrctIUSvkDMuoS4pXHWzv8UpHGhEdrVBBPEGQ2fb+3QklyUUveVHndl0Zvzx/J+QlKO/XTq0eKoFOTptbFRW4cA2nUZJpymw+nSIg6gy0Lx+W3+aXWNAF1mKpiSdAugy0T4k4Q/YVi6zNdQMRGPrAega50KOsmguhJv6tmgUUEgNlkO8NV2PqiBCxPm8oYVvja9hM3hS3BhfNPs1C49BHh0+17pxoszUhdl9TA2r70SBmvT8OVttrWa8svsNHj5OkNDOYdeKv7WNQOgcnwPE/H4ohiLT9UD1G/ouYQXwV5JiTfLI246jGoRx02lcna0B1zYATXzcg9tdVv4/TYXp8U2j14++a3S7R8uourq9Q9LZ/5wSK0xObVm9eML6JYpscM4UgMXp+1OKuTmy/+MrQJEwEm8SpiaelS0FtMvNkH9up5LeP0JXNUP0CfyJ3A/krxpyhbDSusJAABomrSivQfBtUpAtvXuA4D7Qr31TMF9BYsPAR7Omp1a2eQbUHPnQXl0O9YIfovCRnljUP26not7uYSXM7aUv6Esob+qWKPLTARShJ+caYCaRdxbrrvzRYUdAoBeYblK0Kcvh5wvzbqchN/hVT4AuLeOdjV49Ba3zuzSSse/hXYISMbLww4AaNtAZcNApaymbkTrs3s5h7gLoOtRuZinfk2Hyv/s6+UBb+nqB+gXB1JEIFVVz3K5resKSlISgRTuT3iVfVC/pqXDTtI5VlPSBDv2OzVBa3ZqzZqKJtgNQ5fgwoTF6mFsaFskoXoIALXLGirktqyW/cr+tQAAIABJREFU30FNXSPUrWl9Ud1CE9SvaX1RDxP1yHsBejZRnad9rQaapmzRs5rQOGmNeJiwmw5vVKqYOh80AzySmBw4CoSIrO7KjhezS4f2jZldOunEt+DSnftlKZoX7LjZSVrcdNXormiZMOaL8kHRkiYY/HGCixHVmtBpILgYwXqn66Fm3oMxYYz/6Q1uoxUA2te86JelaAcme1jWhGmrC/e5CUUzwCMJ66E4Lx0wzDdC/arZH5N3C6DX4o+zy5ehYZ3zxx0oz02HMrg/ibGxYLLwyedfzK2K37vb3HD1Zv2Vm/WXb9Q23ahtul7TeK2m8dqlhquX6q9erL8CP/37n+vspNZOau2kxoqrzB6FwSnT2iRq8/be0X/5L//Xb379y9/8wy9/8w+//Mff/OYff/MP//jrX/3zf/4/f/vP//mf/ukff/3rX//qV7/81a9+uXd4IteY+O3PgRgX4WvuU4X97PZRYfeE3zp2+HT36FkVnu4ePd05fLpz+DSkuQU39MGD0+L+6dbeydbucWHnML99kNs+4DeK5Xf4/c7Z7VS2mMxuISQQMq9AMrudzO2k8rvprb1M8SCLfkNk9zi/e5zfPcnz+8CO855JAdwUh4+zO0fZ7cPM9qF1WABD3tTWfqqwV4X9ZGEvkd+NZ3fi2e1oeiucyAdjGS6cZENxXyBG+yMkGyZ8IcIXwn1B/tenaD9mXqqB+kkT5yE5D8m5Sc5D+TE6iPlCOBvFuRjpj1P+BBVMoIL4MkhUHB9Iosp4gi/UjnurC3ara47ZKIb2frFRjw+BL9510WFXea9SybJbMV/5pz3QfszK7lcvZ8c5m9dn8dCm0k5hnYXfKaw22F+xUXT+AdoTjXZA6yxo99L/0959vrVxZgsA5/4l6+zG3o3tdNe4UG0DpncwvfcOEqDee28ICWQ6CASiFxfcS9ziFNsYJ9mNaXaysdPu1/vhnRlJNGEne7Gy5/ech0cIIR2NRnOYQXNOk1Rrxk5Nxc7AxR+oqV3dhJ9yZO7UmDuJE4A0pg4NOvfWNTTo9uZOrblL2+wU6NdN2Om6LqfHEifkahnoo1yoO5dYaRCh1sz4IAL3pz9j570aJJomma5F2diqbmrXmDq15i5dM1rC3drmLq25Cz/9iwhHqrpm1xu7nCfXiT0R7KTj0wpDi1xrXr3wN8qTUfiu10cZTJ1IYZCom6TaZuz0YeIcLzNagHhiznkSSbZ0u4Tr88JeLFOn48VyCnVTu8rYqjScVuiaZXjyWOZSDU/CTX/f691s7sanmQtkOgHqOqEySjUm/BRy7CR6tWM1WL14u1cmj2rAXrKgpVvX0q1t7tKYBdFeXpG0VoUBnQFtFCkMWJ9uifs1gSfR8KVagVwnVBhQhug0f+I8d2KBq5zPIndah12+Nbm8BRwnDjrOPsTOLFQ3takaTyv0LbK1Vok1JjgyCt/1+jCDrsH+0HG8JY1SrVmua1Y4qi86rxGdzugU6HQRdN5IM948wdyubWrTNrVqjK3qxtNq1BtPZ1boTPhXk1KH/0MOb0ylaWzRGFtQs3iDub2xuQM1LGzp7Ld0DVi6Bixdgy1dA+YOW1N7f+PpXq25U9XULje0dvaP3Lj92VePnnz5cO6LB4+/ePD4/lezn301+9mXj+598ejeFw/vffHw7hcPvRaXn/PljTx5I09u4Mp0bDGqYQoaV2ZqaZ8+d2F1nJ25dP7ilbPnLxLXmC3tDJ4Ya0bV2tPS0dfeM9jdP2K1j9uGpwbHzgyNnxuePD8ydX50emZ0yikcXalM2f/jTe88NzRONKCaHhyZGhiesA1N2IbG++1j/YOjfYOjqLOidQBvk+jSZXGoxzbU2z/UaxvqtQ332vAOivbxPvt4/9CkbWTSNjJtG5mS5fxPhnrKNjJtG+mmHPHyOswxj0z1D0/2D01a7RNWC/ugV654cKxnYLTHNtptG+2xjfbYRrv6R7r6RzqtQ+1We1vPYGuXzdJhbW7rMbV2NVk6jS3tjc3tBnMb0R1Y22TRGi2axpa6OK8PixVqrClZs8rQomq0aIynNU1tWlO71tyuM3fomjv1LV1Eiw0t0VwDO69z5WqN3icolMZWVSO63KpqalOhzguNrUpDq9JwWmE4LTdY5HqLTNci1TZLNWaJxkQ0HMK642DNh0xijUmsMUk0JonGJFIZhQqDgOjZI0Y9e9BUhVWjR8sivLwiClG3nlUthbBmS462PU1idRP+WGaJxizVrh8aM97CCl3TLNW2SHUtUl2LDA+ptlmqNUs0ZnSfjgZXTg1+6nM+8gqv50m1PLxdJOqT5L4TFR/rk8QWKTliNU+mEygMIlWTWGOWaM1SbYtMZ5HpLEQyMm2LTOvIzSksMp1FpncK599yPBfsBRIpGwVyPZ9omiV02zRLzmrI3e31QQpViZqBCeQGIVraGpPEsfSasWWodVmGjiTx9OR6tNpY8MRanH69Gb06ri+NWaIxi9VN2JqDmmmJ1cRqwxTImaXhXu/m1Gyq4RPWz4wvNwgU+Grj9ETWWsIoWOFeidXosqDiAy+v94uU6FmgtOmFe7wiaXhPMg1HrEIDJdyuBmhVZwkUeMc1DVeiwZPUC+QGp9Xb5Lx6rw6pyzrvvFSbZbpmma7Z9S2AtW0jVgmeZI33I8s50JrQgE0PxvrDSTQ87K8EVIObJBoTUYPRVkKut8gNFrmhheh6o0QX9I5+dTLUfVHdhJ3e7nTyqOMUUhX+CSmNETuDTWdS6swqQ7O60aJtatWZ2xtbOo2WbvQ5LENLl9bcqTG1q4ytMn2LBPuUhp4l1tCFagpXUc+Wk5nSWoa4mi6upArL63nlDfzyel5ZPQ9rRsUWa1giDUukZgiVdL6CxpVRORISjVtSTSmprCtGUUFGF0qq6kurG8prKZVkenU9g0Rh19F5PIlKpjGpGy06U5vxdJe5vfd0l63Dau/qH+kdGOtDO0ajU4Nj044YnR4cmR4cmRoYmRrAOxnahif6hyb67agd8CiqWD224Z7+4Z7+oe5+e3efvRtrim/v6rN3WQc7naN3AH3YvaMXXWPvtNqJzvrdthE81I5zvD5hGGwjXf3DXf3DnX3DnVZ7h9Xe3jvY1jPY1jPQ2m1r7bah7lCWzn5LR19zh7W5vRd1ADM2d2B1q6lVa7SoG9EMM7NSb1boTAp8bgvqWC91+hyBVG2UqpvQmcIyrVmubZbrzFj/IXzbja++Zona5Bz4NpoIo0hlFOLN3IQqo1BlFCqMQoVRoGgUKBqxTndyA1+u50l1XKmWK9GiRr14Z1I11rrXqWMv+qmjiy5PSnP0qEVtUl2jKNTLKzSHLUL9c4nWtK6tYx0de1GnV/wRtVhItVyplivVcVGeROA34LrcQMeV6rkyPVeqR7d33I9Ew5FoHG1kXTv9OzWE3Vy/XXw2rKPfrlDJEqnxhHVcmZ4n0/McmeC5ofRkeuIGPJmeJ9fz5Aa+3MDDQu8SMj32RMRqlkhFtDB2dAfeOE9S1k6v9xNJRF9gJUukZuNL2HXRrczTNUNHPquel875BeK4vDQ6rkTLkWjQYndJHi3nTbQ2pjq3NubhvZXROiNW44/l/NKvlVuV42O1u7MFTjdD2eLrNl9O58mIFXuTa4JLC2OezGklR+s2sWJrNwin1Xv1gl1vUWvYIhXq0406L6/5fkRjC6mkrJ1e7yWSxFSOhMbBG3bzZAy8YTf6Q4Er0XAlWp5Mz3fqSMnH+1JiGxAF/q1cL5DpBaipplTLk2h4EjWXGCwsUWFfJWq+FAU6NqMVyLUihU6k0EuUBrT1k2ubFPpm1GhYabCgvUypxiRSGflyA0eqZYnUNL6CwpHVMcU1dEFlA7eygVdexykls4trmIXVjIIqekEVraCSWlBFQ62BFXS+gs5X0HhyVMAoHDGa3IiGs5DpPDKNR8KGePLQuJYGlojKEdF5EqZAxhGpeBKNSKGXapqU+mZN02mDud14usvc1mvp7GvttrX3DnZa7Z1EOekf7iKibxgfyGJHJaSjd7Cjd6AdG8ticwxh6bS2dlgdI1Q6rPjcsh7naMZOGu/GJpa19zSjRr0dVnQaeUu7tbkDtQXrxb/2oi69ptYeU2s36snbaMEbzze3683tOlM76jqvMVrURgvqAaHQmWQaI6pMaDcf9bPBxmZK1NhLi/+5h43NFCpY+AU2Ph+B6IHNFCqZQiVDoCBeFzrWU1xB58vpPDkNm7EiozpCSuVKKegyR0rlSCkcaQNH2sCRNLCJENezxHVMcR1DSGYIXcemYJNTyHTieuyn2PwRCgefGLLJoSFOY41WTM2gOqZvuA5tEZIYQjIKpmsw1gqmsI4pcgrHj0gMIYmOQkCir5424vRcXmE8h9P0Ewq3hspDOa+VyQYhdgRrnWCK0XMh0QUkGr+GmAz+ChNP8IWP5clHS2PNZbtuei7hWMhEEK8LieH6wjEci90xa+Z1Bs2wVwyaqaXx11/ma60qzDVWJNKa6b16hlV4hlVocBeRJJVP5OmySjvWyfXX87VWJKcr0Z1gb0lsNNL670c0gQgPYogSlioxO4nMENYxhfVMsdOGwhEUjoSCzSiQNLDFFDZ2gRjnhCYdYsHC5pOhEWVUbCKEmMaV0LkSOg+bnMkWKthCJVes4ko0qBzypVqOWMMWqVhCJZ0np3IkDSwxiSGopvIqGzhlZGZxLa2ompZX2ZBf3pBbXp9dSs4qJWUVkzKLajOLa7OKSV7zi0tUDpYuhSNpwEcPE9MXyXQemeYYb4OGftbR+XUMfgNLSOWI6FwJky9jixRciVog06GpYwq9WdOIxma2G1s6m053m9t6mlEt6ejFor23uQ1FTzPW6x2bcoL9h4mYcmLBhpsYmx3dJ13mR5tcBn3pmk7rmizaJou26bSWmByNRavGaX60uhH7qmpsURpalHp0nNcs15rkmiaJxijRGMWqRjHWlxp1ktUJZDo+PuUS64+Oj7Uk5jhT2PgAUnxgG5nORwOB0ChLLGj4Vp7CraZyq/ExSJUN7Mp6dmUdu7KOXVHHqsC+YlFOZpaTGOUkZhmJUUZmlJEcUVpLBL20ll5SSy+poZfU0EpqaMXVtOJqalE1paiKUlTVUFjlOrtv7cmW9QUV9QXY1ETXMYN4bGps48rhkOtMEayiEFGEB37Nyhs436zQ+WZVK8cSrpgAmec6MPNV5yXml9cVOGaBEjlQnTPBrqneINDLsTKKqqlFxJPFc978/EnnyZOuea6x6FyW8wapui5hl28rKWu8dpXEKFSn5F957CfZef1BMzNXLvNVuWGPvvaTXb1KuA4m3ezkzFqn1dtlDXes0pWOPFcm5pRb0RqxzvLHLzivFS5zXzcKcn4ZGcuwHBuUipJE91xcTS2upqFNRAnaYtTS0dajrJZRVssoI6E5uvQy7Epspu6qoJfX0spI9HISvQJN6cQLKiq6NQ1stMUj0bBp0fiYeyGZIUBD16opnKp6djmJUVpDK6qiFFTU55aSc0pIWcU1mYXVaQWVafmVqXmVKbnlKbnlKbkVqbnlKXkVXk8XlupZQiywCcJEAXPZD6t1qWTcOjqvjsFvYAoobCGVLWZwpSxst0wtkGlFCr1EZZRrTUqdWalvVjdaNMbT2qZWVG+wqtPU6igwRiw0TqMmNY0tamzgZLNaT8xZbkb/P8QO3OlMCm2TQos6shjl+JQ2x7kUaqPEcSIIduhWhAYxK/VCuV4o1wtkOrSnzJc5pjDjIzyU+MEoGZ2HT15miyls9AII6hho6h3XMUaynlWJhimTGOUkehmJVlpLK8VnKBdVNRRVoiHi9c7DYfMr6vLLHaN+c/HIKSFll9RmF9dml9RgF4prs4tq0MDyrMLqrMLqzMLqzMLqDEdUZRRWZRRgkZ5fmZ5fiaahE8PRU4kgBqs7z1Z3XFmWmlu25sD4TQ56X3vUfY5jPj0+5d05gQrXcE3JZQD8qputCMdTKFtr5v1mR9c7PymUuWvOq3Oo+H2BZe6a8CbzLHXNc83ltt4yXD+fdRfvmiuPY7V5rUW9eoUpczyXlWmvlcy6UeayPrziyrDmiu28Pq+/JuMZvv7qgf86ehZOb0ki1niv4ZG6xhutIhXfGqQXVGKbC7TpwLckaMNCbGHQZSyKHBeyi6uzi2qyi2qyi6tzimtySmpynP8iKScXlJMLK+oKK+oLK+uLqhqKqykl1bTSWloZiV5KopXWUEtqaKhIF1TU55fX5ZaQsopqMgur0vMrU3PLU3LKkrNLkzKLE7OKEzOLEjOLEzMLEzKLEjOKkjKLk7JLvJ4uLNYx0IhnAV66+GQ6DwWJurKG1VI5tVQO2qsg03nEuGsKW0TjiBlcKYMvYwkU6DAjOjaKGp9LVAaJ2iB16vFDBOrHTNQYsdIgIkLu+DgpFjKtAB21QyFV86TYh4hQ+UEzeNAYHrZIyRbKseN4AjlTgP23lsGVMbgyOhebAElxOiyOF3IBKuG1VG4thVtN4VQ1sKrqmZV1zAoyo5zMKCPRS2tppdXUErRnU1lfWFFXgOoQVn5qcoprsoqqs7A1gygk2OYpNacsOac0OQd7/yRlFSdlFiVlFiVmFCVkFCZkFMZnFManF8SnFcSnFcalFcSnFcSl5cel5cem5sem5sem5MWk5Mak5EYnE5GzIqJOrRVJOZFJ2RGJWa8QCVkRCZkRCZnheITFZ2wmwuMzwuMzXSJhvciKSHiVlF4l+ZWPFZ8Zvrn813pGf1TC2evHqrR/Z57/iaXqWDHWWg4uyW92bVl75dnMSpKAHnHFC521KlatdfGZ4fEZGy/e8BWr8Tprr2tuG76yxLdJK28QmbRuEPfwym9e18DvMCcqaeWWgdiSoA1LTEpuTEpedHJedHJeTEpeTEpubEpebGp+bEp+XGp+bGp+XGp+XFp+fFpBfFpBfHpBfEYh2nAlZhShTVlSVjFW+3NKk3NKUR1NyytPz6/IKKjMKKjMLKzKxP7arkwvqEjLL0/Lq0jJLUvOLkXbw8SMIrQNjEvNj03NjU3Ni03Ni01FmeTFpeXFpeUnpBd6PZ1fXFG60Obb+UDiihpGVDLiGCOZzsfrmaCBJaKxxXSulM6TMgQyllDOEinYQiVHpMRqDD56EQshFiv+dcRCHxxyDr6MwZehvSI6T0rnSoiDeMRxPFSKsKN5TGE9U4B2mFz3LDk1FE4NhVNdj44vE/WJWUFmlJHoZbW0ErTzVEUpRjtPWIki5ZbU5pbU5hRXZxdXZxZWZRRWYZUprzw1pywlpyQ5p+RUVnFSVnFiZlFCemF8ekEc9hrkxaTkEqUlMik7Iikbe2uhd0tcelhcemhcWmhs2snY1OCY1JPRqSejU4OjU4KjUoKiUoKiUgJRRCYHRp5CcSICRRKK4+FEJBJxzDUCQhMCQuOJ8A+N93f6dvWPnMMvJO4PD39HxGOx+qFD1oq1Mlz/d+P8/+Cc10rjVXNzk/bvzdnNUn21ZFyf3QavyH9qgcet+0ScHtFtvOLjbrzoEpwjAEXYfzhCEwLQw73OryeiOBbuvK1wCXyTcorYyARGJgdGJgdGJQdGJQdGJgdFpgRFpQZGpQZFpwZFpwZHpwbHpJ5EEZsaEpcWGpceGpceFpcRHp+BlXlUQbFimROdnBuTkocXwoK4VKxQxaXkx6bmxybnxSTnRSfnRGN/cGe71uCsqFPZUUnZ0ck5Mck5sSm5cal5Xk/nF8k0Htq7co5VBcylhhGVgDjMWEvlkrAPgPDqGPx6hgD90w8rLdgHkMQ0p6CyRShcPvCGfyII/duwnogVu4w0HpnGIzll7ihOFHZVA7uynllZj/7byaggMyrI9HISdki3pIZaUoNKFAUd3CtAB/TKydheVElNdnF1dlF1ZmFVRgG2F4Xt2+aUoj2nxMyihPSC+PSCuLT8OKcShf5WCk/MCkvICI1PD41LD4lNOxmTejImJSgqOSgqOTDy1InIUyciko6HJx5Da1Vogn9ogl9ovF9IvG9InO/JWN/gWJ/gGJ/gGJ+gGO+gaO+g6KOB0UcDo4+eiDqCx+HjkYePRx4+HoHi0DE8AsKJ+MQ1DvqHvXYc8AuFgPjviYN+oQf9iPU//BMUq95TWx6ON/6rB74NWSOI7czRQCKijwZGo82Rd1C0T1CMT3CsT3Cs70kUcb4hcb4hcX4h8X6h8VhRD0s8Fob+mE46EZF0IvJUUFRyUFRKcHQKKnshsWkhsWlY5YtND41PD4lLC41ND41LD4lLD4lND41ND0ERl46qY3h8RnhCRkRiJqpq6LCT19P5RbwS8IiopaJYu4ARBYOI6gY2cRkrbPiOGlHbyHSe00FLvuOx0EcenAqn426JaECViYUF+jQOmYEuVJAZFWRGOYleTqKX19LLammlNdTSGmpJFaWkilJcie9OVZALKsh55Y5PJWSXVGcVVWUVVWUWVmYUVKbnV6bllafllafklJ3KLj2VXZKUWZyYWZSYUZiQXhiXmh+XmheTnBuTnBt1KicyMSsiMTM8MTMsPiM0Li0kLi04JiU4OiUwKjkw8tTxiKRj4YkBYYn+oQn+qD6djPMJjvUOjvUOivEmCtLxyMPHIg8dizgUEIGVGb+wg35hB/xCD/iG7vcN2e8bss8nZJ9PyD7vk3vx2OMdvMc7CMXHR53iSCCKj1zjw8MnXjECneODQyc+OHQcAuK/Jz48dPzDQ9jb4aPD6H0URITLm+7NiD3ewb8n9jptXpwD2/j4hOzzCUGbo/2+Ift9nYt92EH/cKcyH3HoWMThY5GHj0UePh555HjU0RNRRwOjvQNjvINivINifYJjfU7G+YXE+4XE+4cm+IclHgtHpS7peETS8YjEExGnTqCjTWjPLyo10FH20lDZw+pZQkZ4QmZkUnbUqWx0UNFRYEh09Ald/uTZmUtXb166evPS1RvOcfHKK8SK37109cblqzcuXXGO6yvi4hpx7eKVaxcuE3EV/4rFjNOFmUtXz1+8cv7ilXMoLlw5d+HK2QuXz85cPjNz+czMpTPnL02fvzR97uL0uYtT5y5MnbswefbC5JkLE2dmJs7MTEyfn5g+Pz59fmzq3NjUudHJc6OTZ0cnzo5MnHFM7HRMoJ4cHMV7iwxP2IbHbUPjNrylSJ8dnaw96jhZGztHe7jHhs6BG+ruH+ruG3KcBme1d1kHV58J17EybC7f9tg6egY6etAFLNqxFvubjp7VMbD6Ttq6bdjQmd8d7avij7rntk3f7R/7oBB/mljx1nB6i7nGGu9NTw7r4HrRuTLs+Cm5LoFO6u0mNm62oW7bUA++0eu1DaOGFdYBvDHF4GiffdQ6ONo3ONqHui8NjfXbx2z2sf6hMdvQuG1o3DY8jjawKAZHJu0jqInuJOoIPzw2jf9vjCFwPuVi8uzFOipj2/Zd27bv2rZ957a3Ubzzlz8itjnFq97eEdt3onhr+863dux6a8euv+7Y9dcdu95aFdhTQPEqj+uawM5tb+903I/jDndu5g6dMt+5YWwqPex+XDJZ8TRdXq+1F+CKrJzvZ4drbN/luib8Ya/+BvGfvv8//HH/8FRf9els8iH+f/Lf5I3/P5f2az0vp/fFWtsWiP+H2LbONtx5/UGfVBTiZ19K6ljSOrb08o3bb/3dtXUnAAAA8AZ6urBUx5LUc2QNPEUDT9XAVzXwVVdu3v3bzo+2OjUAAADAnacLSw08BYWvoYr0NHEjXdxIEzdevXV/+3sr58UCAAAAb5z5xWWqUEuXGBnyZqbSwlSeZqpar9/96u8fHt7q1AAAAAB35hef0aVNTKWFpeng6Lo5+h6OwXrj/uw7+/xmZmZmZmbQzZwvb2DGyWaufyUzq6x5g9e+fwAAAJ5nfuk5U2lhazq5jX38pkG+2S4wD336xZNdB0+8Rhnb+Ma/v8xsnBKUMQAA+K+zsPw9S9PONVgF5iFhy5jQMi46PXHrq293Hz7pcWUMAADAf52F5e85um5e04CwZVTUOilqmxK3Td968M/3joZuUDM2Pki4+etf9WDjeimteT/Et+v9CAohAAB4vIXlHziGXr5pUGgZF7VNidvPiDvO3nr4r/e8w2dWQb/idpdok2XM7f2sdw/rVaD1yuSKy6/xuAAAAN5QC89+4BqsfJNdeHpc3DYt7jgj7jh364GjjKGbrb78SuVkzetfu4xt/qcblLEN8gcAAOAxFp79wFlZxlz2xtDNXqnkeEQZc/tYAAAAPMDC8g8cfS/PNCi0jInapkRt0+KOs5vZG1t9meBBZQxKGgAAeLaF5e/Zum6e0SZoHhGenhC1Top+x0c8ZlbZ/PVuU93gxpt83M3cFQAAAE8yv/ycpW7n6K08k13QPCqwjAkt459++c3uwye3OrU/ABQqAAD4k5tfek6Xt7DUHRyDlWcc4JkGeSb7zS+e7Dp4YqtT+71glwsAAP785hefUSVGuryFqW5nabvY2m62rvfGZ4/e2ee31akBAAAA7jxdXG7ga6iiRqrURJe30BUtdIXl2p0voTUwAAAAD/B0YamOI6/nqhoEWopQTxHqKULDFRjUAgAAwCM8nV8kMURkpoTMltVxFGSOgsxRXL5xB8ZmAgAA8ADfzS/WUvm1dEEtXVjLENYyRLUM0aVrt976+3tbnRoAAADgznfzC9UUbjWFW03lVlN5NVReNYV78cqNbTt2rT4By+29rffhwD/kQ4PrnRy24gavff8AAAA8z3fzCzUUDhZUTjWFg5Wx7Ttfo4xtfOPfX2Y2TgnKGAAA/Nf5bn6hhsKuobBrKBz8AvvilRt/efsdjytjAAAA/us4lTEsqhtYF69c37iMbXyQcPPXv+rBxvVSWvN+iG/X+xEUQgAA8HguBxUpnOoGdnWDy97Y6i2+212iTZYxt/ez3j2sV4HWK5MrLr/G4wIAAHhDOZcxVMOqG9gb742tV94I/+kytvmfblDGNsgfAACAx3g6v1BL5bgcVKS4OajodtMcZHORAAAMK0lEQVTvEWXM7WMBAADwAE/nFx17YxQ2io0/4uG2/HhQGYOSBgAAng3tjdVSOTVUNhab+KTijBPne5tZZfPXu011gxtv8nE3c1cAAAA8CXZQ0amGEWVsq1P7A0ChAgCAP7mn84tob6yWyqmlYPHnKGOwywUAAH9+T+cXSTRuLRUL9E+yP0cZAwAA8Of3dH6RROdhQeOSqFwSlXPxKpQxAAAAnuDp/CKZzifT+SQan0TjkWg8EpV7CcoYAAAAj/B0YbGeKahj8OsYfDKdT6bzSDTepas3tkEZAwAA8OabX1hqYIkaWKJ6prCeIaxjCMg0/qWrN6GMAQAA8ADzi0s0jpTCllDYEgpbXM8U1TOFl69BGQMAAOAJ5heXaTwZjSejcqUUjoTCFjcwRVeuf7rt7Z1bnRoAAADgzsLiMlOgpPMVdJ6CzpNTudIGtvjy9U+3bYcyBgAA4I23sLTMEqlYQiVToGTwFTSejMqRXLlxC8oYAAAAD7Cw9Iwt1rBFKpZIxRSo6Hw5jSe9CmUMAACAR1hcesaRaNhiNVukYgqVDL6CxoUyBgAAwEMsOMqYmiVUMgQKOk8GZQwAAIBnWFx6xhap0UFFllDJ4MsZqIzBJxUBAAC8+RaWltkiFUuoRLtiTL6cjv43BueNAQAAePMtLC6jGsYSKlgCBYMvgzIGAADAYywsLrMECiYKvozOk9G50mtQxgAAAHiEhcVltlDBEihYAgWTL2fw5XSe9NqN29DhHgAAgAdYWFxmCRUsoYIlkLMEciZfxuTLrt+EMgYAAMATLCwtc0RKjkjBxisZSyC/dvMOlDEAAAAeYHFpmStWcUQqjlCJgi1UXP/0DvxvDAAAgAdYXFrmSlRciYorVnHFKo5YxRGpbty6C2UMAACAB1hcesaXavgSDU+i5knUXLGaK4YyBgAAwEMsLj0TyLQo+FINX6rhSdQ3b92FLh4AAAA8wOLyM6FCJ1TohDKtUKYVyDR8qfbm7XvQUxEAAIAHWFp+JlYZxEqDWGEQKfRCuVYo134KZQwAAIBHWFp+LlE3SlSNElWjWGkQKw0ihf7Wnc+gjAEAAPAAS8+eS9VGqdooUTeieiZWGm7dvQ9lDAAAgAdYfvZcoTXJtU0yjVGmMUrVRqm6EcoYAAAAz7D87HuVoVmpMyt1JoXOJNeYZBrjbShjAAAAPMKz59+rGy3qRou6sUVlaFbqmxU68517n2/bvmurUwMAAADcefb8B52pTWdq0zW1aptOa4wWtaHl7v0v39qxe6tTAwAAANx5/v0PhpZOQ0unoblDb27Xm9t0ptZ7n3/1t3+8t9WpAQAAAO48/+HfptZeU2tP0+meptM9RkuX0dJ1/4sHb+/8YKtTAwAAANz5/ocfLV22lo7+lo7+5o4+c7vV1Nb7+VePduz+eKtTAwAAANz54d8v2nqH2nrsrT2Drd2Dlq4BS9fAlw8e/+O9vVudGgAAAODODz++6Owf6ewf6egbabcOt/cOt/UOf/Xoya4PD2x1agAAAIA7//7xZffAOIou21iXbayzf+zB4693f/zJVqcGAAAAuPPvFy+tQ5NW+2SvfbLHPtljn+wenHg49827ew5tdWoAAACAO/9+8bJveMo6hEWvfbLXPvlo7lsoYwAAADzAjy9e9g1P9Q25VLJHc9/u/ggOKgIAAHjj/fjiZd/wZN/wZN/QpHVoss8+aR2amJ37dueH+7c6NQAAAMCdH1+87Bua6Bua6LNjX6328Udz3/zjvT1bnRoAAADgzo8vXvZjNWy8zz5utY9b7WOP5r7ZsevDrU4NAAAAcOfHFy9tQ+P9Q+N99vE++1iffcw6OPZo7uu/vQM9FQEAALzxnMrYWJ99rG9w1Do4Ovv467/+HTrcAwAAeOP9+OKlbXjcNjTebx/rG8TL2NzXb+2AeWMAAADeeD++eDk4Mjk4MjkwPDEwPG4bGrcNjT2e+wamPwMAAPAAL168HBqbGhqdtI9O2kcmB4cnBoYnHj/5Ztvb72x1agAAAIA7L17+NDJxZnh8enhsemhsemhsyj46Off1t3+BMgYAAODN9/LlT2NT50Ynz45Onh2dODsyMT08Pv3km39CGQMAAOABXv708+SZmQkU0+fHp86NTZ375tt/QRkDAADgAV7+9PPUuQtTZy9MnnUUs2/+CWUMAACAJ/jpp5/Pzlw6c/7SmfOXps9dRCXt2399B2UMAACAB/jp51/OX7p6/uLVcxeunLtw5ezM5TMzl//5r6dQxgAAAHiAn3/+5cLl6zOXrs1cukbUs399Nw9lDAAAgAf4+ZdfL1/79NLVm5eu3rh45caFK9cvXL7+3dMFOG8MAACAB/jll1+v3rh15fqnl6/dvHT1Bipm381DGQMAAOAJfvn112s3b1+9cevqdayYXb528+n8IpQxAAAAHuCXX3+7cevu9U/vXLt5m6hn8wtL296GnooAAADeeL/++tuntz+7efseKmbXb965dvP2/OIStAYGAADgAX797bdbdz+/def+p3ewYnbj1t2FpWUoYwAAADzAr7/9dvve57fu3keV7NPb927evrcIZQwAAIBH+PW3/717/8s7977Aitndz27d+Wxp6RmUMQAAAB7gN1TGPvvi9r3Pb9+9f+vu/Vt37y8tQxkDAADgCX777X/vff7V3ftf3v3sizv3PkfFbGn5OZQxAAAAHgCVsXuojGGV7P7S8nP4wD0AAAAPgJpRXb5289LVmxevXEf9FaEZFQAAAM8wv7BUzxSS6HwSjVdDYVc3sKvqWRevXIcyBgAAwAPMzn0dEJbkH5rgExzjHRhz5ETUkeORvf1DUMYAAAB4gEePn3gHxR45EX34WOTBgPADfqH7fUK6+gahjAEAAPAAjx4/OXIi6vDxyIMB4Qf9w/b7he7zCemyQhkDAADgCR7Ozh0+HnkwIAKrYb4h+3xOdkIZAwAA4BEezs4dCog46B++3y9sv2/IPp+Te7yDoYwBAADwDA9n5z4JCD/oH3bAL3S/b8g+n5C93sGd1gE4/RkAAIAHeDg7d9A//IBf2H7f0H0+oXu9T+45erKzdxDKGAAAAA+Al7Hw/b6h+3xD93qH7Dl6stM6uG37rq1ODQAAAHDn4ezcQf+IA/7h+/3C9vmE7vUJ2esd0mkdfGsHlDEAAABvvIezcwf8I/b7he/zCdvrE7rXO/TjoyGdvVDGAAAAeIIHs3P70a6Yb9hen9A9PiEfHz0Je2MAAAA8w4NHc/v9wvf7Yntje7xD92B7Y7u3OjUAAADAHVTG9vmF7fUN3eMTusc75GNvtDcGZQwAAMAb78Hs3H7/iP1+EXt9w/b6hO3xCd3jHdpptf/17+9udWoAAACAOw9m5w4GRB7wj9zvH7HPL3yvb/he37DOvqG//eO9rU4NAAAAcOfh7JNPjsccPB598FjUgYCoAwGR+/wju/qG//bO+1udGgAAAODOw8dfHwmOPxwUfzgo7lBg3KETsZ8cj+2xjWzf+eFWpwYAAAC48+jx196hp7xDTh0NSTp6MunIycTDQYm9A2M7dn+01akBAAAA7jya+8Y/Is0vItUvPM03PNUnLMU7NMVqH//Hu3u2OjUAAADAndkn3wZEZwZEZQZEZ/pHZvhFZvhFpPUNTf7jvb1bnRoAAADgzuyTb4/HZh+LyT4Wkx0QnRUQnekXmdE3PPnO+/u2OjUAAADAndkn3x6LyT4WkxUQDWUMAACAp5md+8Y/KsM/MsM/KtM/KsM3It03PK1vaAIOKgIAAPAAj+a+8QlL8QlL9QlP8Q5N8Q5NPhqSZB0c+/u7H291agAAAIA7Dx9/fTg48UhwAvqo/aGg+EOBcT0Dozt2wXljAAAA3ngPZ58cPB5z8HjsgWMxB47FHDgWvT8guqt/ePvOD7Y6NQAAAMCdB4/m9vlF7PUN3+sbsdc3Yq9v+Mc+YZ1WO/RUBAAA4AG+evT4o6MhRHx45OSHR4I7egehwz0AAAAP8NXDxx8cDkLx/qHA9w8Fvv9JYHvPwF9h3hgAAIA335cPZ9/75ASKdw8eR9HWY3trx66tTg0AAABw58sHs+8eOPbugWO79wcQ0dbdv207lDEAAABvvC8fzO7eH7Brn79T+LV19W3bvnOrUwMAAADc+fLB7O79/kQ4ytjb72x1agAAAIAb/wcaQ4jMYmZBcAAAAABJRU5ErkJggg==" alt="" />

然后,服务端就一直处在循环等待的状态。

参考:

http://www.cplusplus.com/forum/general/139656/

http://stackoverflow.com/questions/26561604/create-named-pipe-c-windows

Windows进程间通信(上)的更多相关文章

  1. Windows进程间通信的各种方法

    原文:Windows进程间通信的各种方法 进程是装入内存并准备执行的程序,每个进程都有私有的虚拟地址空间,由代码.数据以及它可利用的系统资源(如文件.管道等)组成.多进程/多线程是Windows操作系 ...

  2. windows XP上实现python2.7.5和python3.4.3共存

    windows XP上实现python2.7.5和python3.4.3共存过程记录: 1. 首先安装python2.7.5和python3.4.3,两个版本安装顺序不分前后; 2. 检查系统环境变量 ...

  3. JMeter--二、在Windows环境上搭建wordpress

    为了学习使用JMeter,在Windows环境上搭建了wordpress. 使用JMeter录制或是编写登录worepress.编辑文章.删除文章的脚本. 首先了解一下wordpress是什么? Wo ...

  4. 在本地windows机器上安装SecureCRT客户端

    一.SecureCRT客户端介绍. SecureCRT是一款支持SSH(SSH1和SSH2)的终端仿真程序,简单地说是Windows下登录UNIX或Linux服务器主机的软件. SecureCRT支持 ...

  5. windows forms 上一个类似于wpf snoop 的工具: Hawkeye

    windows forms 上一个类似于wpf snoop 的工具: Hawkeye 周银辉 WPF上有snoop这样的run time object editor让人用着很爽, 今天搜到了一个for ...

  6. Windows OS上安装运行Apache Kafka教程

    Windows OS上安装运行Apache Kafka教程 下面是分步指南,教你如何在Windows OS上安装运行Apache Zookeeper和Apache Kafka. 简介 本文讲述了如何在 ...

  7. 怎么把Windows主机上的目录共享到Ubuntu上

    使用Oracle VM VirtualBox在Windows主机上创建了一台Ubuntu虚拟机,怎么把宿主机上的目录共享到Ubuntu上,可使用以下方法: eg.把Windows主机上D盘里的test ...

  8. 在Windows平台上安装Node.js及NPM模块管理

    1. 下载Node.js官方Windows版程序:http://nodejs.org/#download    从0.6.1开始,Node.js在Windows平台上提供了两种安装方式,一是.MSI安 ...

  9. 【使用Unity开发Windows Phone上的2D游戏】(1)千里之行始于足下

    写在前面的 其实这个名字起得不太欠当,Unity本身是很强大的工具,可以部署到很多个平台,而不仅仅是可以开发Windows Phone上的游戏. 只不过本人是Windows Phone 应用开发出身, ...

  10. windows系统上安装与使用Android NDK r5 (转)

    windows系统上安装与使用Android NDK r5  很早就听说了android的NDK应用,只是一直没有时间去研究,今天花了点时间在windows平台搭建了NDK环境,并成功运行了第一个简单 ...

随机推荐

  1. ORACLE ORDER BY用法总结

    order by后面的形式却比较新颖(对于我来说哦),以前从来没看过这种用法,就想记下来,正好总结一下ORDER BY的知识. 1.ORDER BY 中关于NULL的处理 缺省处理,Oracle在Or ...

  2. python基础-更新篇

    对于windows来说就很简单了: 下载最新版本的python,然后卸载老版本,重新安装即可 对于linux系统的主机来说就有点复杂了: 现在linux主机自带的python版本都使2.x版的,而且L ...

  3. suricata抓包方式之一AF_PACKET

    suricata抓包方式之一AF_PACKET 噜拯渡 睦坚削 曜纡宄 式犒藿氆 咬焚桤φ 要蒯钮 喃俚夼 币噎嶂颐 话千叶舞就后悔了怎么想都容易让人引 虻谮м 及葚雏钏 看着表面平静实际 ...

  4. Codeforces Round #346 (Div. 2) D Bicycle Race

    D. Bicycle Race 题目链接http://codeforces.com/contest/659/problem/D Description Maria participates in a ...

  5. SPA 单页面应用

    SPA一般只一个web页面,通过ajax,router等技术实现局部刷新,不会随着用户操作而出现重新加载页面或者页面跳转的功能,所有的用户操作都在一个页面实现. 组件化:UI组件和非UI组件 传统的u ...

  6. Error js内置错误 js处理错误流程 Throw语句

    Exceptional Exception Handling in JavaScript       MDN资料 Anything that can go wrong, will go wrong. ...

  7. python获取

    def anc():pass print anc.__name__ def timeit(func): def run(*argv): print "this function name i ...

  8. PHP使用正则表达式验证电话号码(手机和固定电话)

    这个还不错,很有用. tel='验证的电话号码'; $isMob="/^1[3-8]{1}[0-9]{9}$/";  $isTel="/^([0-9]{3,4}-)?[0 ...

  9. 面向GC的Java编程(转)

    转自:http://blog.hesey.net/2014/05/gc-oriented-java-programming.html Java程序员在编码过程中通常不需要考虑内存问题,JVM经过高度优 ...

  10. Java反序列化漏洞分析

    相关学习资料 http://www.freebuf.com/vuls/90840.html https://security.tencent.com/index.php/blog/msg/97 htt ...